Files
devplacepy/devplacepy/services/openai_gateway/responses.py
T
retoorandClaude Sonnet 5.5 f55c7ee5f4
DevPlace CI / test (push) Failing after 31m42s
Add community node protocol spec, Agent Skills, and make the failing tests hermetic
Community nodes (Phase 1 of plan.md): the protocol specification in
services/nodes/spec.py as the single source of truth, GET /nodes/spec.json,
a generated protocol docs page, the Community nodes API docs group, and the
implementation plan plus the residential proxy research. The no-open-proxy rule
is enforced in the spec (open_proxy cannot be set).

Agent Skills: register the Skills API docs group, cascade skills on account
deletion, add the nested CLAUDE.md, README and routes docs, and cover the
parser, the fetcher (end to end against a mock origin), the data layer and the
routes with 73 unit and 16 api tests.

Tests made hermetic with the repo's existing patterns instead of ambient
environment: embeddings tests set OPENROUTER_API_KEY via monkeypatch, the
workspace tests install FakeBackend via runtime.set_backend, and the skills
install tests use run_async. DockerCliBackend now returns 127 (command not
found) when the CLI is missing instead of raising FileNotFoundError, so a host
without docker answers with a clean error rather than a 500. The Providers tab
empty state no longer names the Model routes tab.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-14 07:13:25 +02:00

1043 lines
36 KiB
Python

# retoor <retoor@molodetz.nl>
"""Chat Completions <-> Responses protocol transpiler.
Lets the gateway keep its normal OpenAI surface (`POST /v1/chat/completions`
in, ChatCompletion JSON or Chat chunks out) while forwarding to a
Responses-protocol upstream such as Meta's `.../v1/responses`. The provider
row selects the protocol; `handle_chat` calls into this module at the send
boundary and on the way back.
Every lossy mapping is reported in a warnings list, never dropped silently.
Core conversions (text, images, function tools/calls, structured outputs,
scalars, common stream events) are exact both ways. Known drops: Chat `n`,
`stop`, seeds/penalties, audio/file parts, custom tools; Responses
`namespace`/built-in tools, reasoning items, `previous_response_id` /
conversation state, `truncation`, `include`, extra choices.
Grounded in the official OpenAI migration guide and both API references
(retrieved 2026-10-11) plus the Meta wire capture; Meta response bytes were
never observed, so the Response-object/SSE shapes are the OpenAI standard
ones the Meta client demonstrably shares on the request side.
"""
from __future__ import annotations
from typing import Any, Optional
def _text_of_content(content: Any) -> str:
if isinstance(content, str):
return content
if isinstance(content, list):
return "".join(
str(part.get("text") or part.get("refusal") or "")
for part in content
if isinstance(part, dict)
)
return ""
def _chat_parts_to_input_parts(parts: Any, warn: list, where: str) -> list:
out = []
for part in parts or []:
if not isinstance(part, dict):
continue
kind = part.get("type")
if kind == "text":
out.append({"type": "input_text", "text": part.get("text") or ""})
elif kind == "image_url":
image = part.get("image_url") or {}
item = {"type": "input_image", "image_url": image.get("url") or ""}
if image.get("detail"):
item["detail"] = image["detail"]
out.append(item)
elif kind == "refusal":
warn.append(
"%s: refusal part has no Responses input shape; kept as text"
% (where,)
)
out.append({"type": "input_text", "text": part.get("refusal") or ""})
else:
warn.append(
"%s: dropped content part type %r (no verified Responses mapping)"
% (where, kind)
)
return out
def _chat_messages_to_input(messages: Any) -> tuple[str, list, list]:
"""Split Chat messages into Responses `instructions` + `input` items."""
warn: list = []
instructions: list = []
items: list = []
leading = True
for message in messages or []:
if not isinstance(message, dict):
continue
role = message.get("role") or "user"
if role in ("system", "developer") and leading:
text = _text_of_content(message.get("content")).strip()
if text:
instructions.append(text)
continue
leading = False
if role == "tool":
items.append(
{
"type": "function_call_output",
"call_id": message.get("tool_call_id") or "",
"output": _text_of_content(message.get("content")),
}
)
continue
content = message.get("content")
if isinstance(content, list):
content = _chat_parts_to_input_parts(
content, warn, "message[%s]" % (role,)
)
calls = (
list(message.get("tool_calls") or []) if role == "assistant" else []
)
legacy = (
(message.get("function_call") or {}) if role == "assistant" else {}
)
empty = content is None or content == "" or content == []
if not (role == "assistant" and empty and (calls or legacy.get("name"))):
items.append(
{
"type": "message",
"role": role,
"content": content if content is not None else "",
}
)
if role == "assistant":
for call in calls:
func = (
(call.get("function") or {})
if isinstance(call, dict)
else {}
)
items.append(
{
"type": "function_call",
"call_id": (
(call.get("id") if isinstance(call, dict) else "")
or ""
),
"name": func.get("name") or "",
"arguments": func.get("arguments") or "",
}
)
if legacy.get("name"):
warn.append(
"deprecated assistant.function_call converted without a "
"stable id"
)
items.append(
{
"type": "function_call",
"call_id": "call_legacy",
"name": legacy.get("name") or "",
"arguments": legacy.get("arguments") or "",
}
)
for dropped in ("name", "audio"):
if message.get(dropped) is not None:
warn.append(
"message[%s]: dropped %r (no Responses input field)"
% (role, dropped)
)
return "\n\n".join(instructions), items, warn
def _chat_tool_to_responses(tool: Any, warn: list) -> Optional[dict]:
if not isinstance(tool, dict):
return None
if tool.get("type") == "function":
func = tool.get("function") or {}
out = {
"type": "function",
"name": func.get("name") or "",
"parameters": func.get("parameters")
or {"type": "object", "properties": {}},
}
if func.get("description") is not None:
out["description"] = func["description"]
# Chat is non-strict by default; Responses attempts strict mode when
# the key is omitted, so pin the Chat default explicitly.
out["strict"] = bool(func.get("strict", False))
return out
warn.append(
"dropped tool type %r (only function tools transpile)"
% (tool.get("type"),)
)
return None
def _chat_tool_choice_to_responses(choice: Any, warn: list) -> Any:
if choice in (None, "none", "auto", "required"):
return choice
if isinstance(choice, dict):
if choice.get("type") == "function":
return {
"type": "function",
"name": (choice.get("function") or {}).get("name") or "",
}
if choice.get("type") == "allowed_tools":
tools = []
for entry in choice.get("tools") or []:
if isinstance(entry, dict) and entry.get("type") == "function":
tools.append(
{
"type": "function",
"name": (entry.get("function") or {}).get("name")
or "",
}
)
else:
warn.append("dropped allowed_tools entry %r" % (entry,))
return {
"type": "allowed_tools",
"mode": choice.get("mode") or "auto",
"tools": tools,
}
warn.append("dropped tool_choice %r (no Responses equivalent)" % (choice,))
return None
def _chat_response_format_to_text(fmt: Any, warn: list) -> Optional[dict]:
if not isinstance(fmt, dict):
return None
kind = fmt.get("type") or "text"
if kind == "text":
return {"format": {"type": "text"}}
if kind == "json_object":
return {"format": {"type": "json_object"}}
if kind == "json_schema":
schema = fmt.get("json_schema") or {}
out = {
"format": {
"type": "json_schema",
"name": schema.get("name") or "result",
"schema": schema.get("schema") or {},
}
}
if schema.get("description") is not None:
out["format"]["description"] = schema["description"]
if schema.get("strict") is not None:
out["format"]["strict"] = schema["strict"]
return out
warn.append("dropped response_format type %r" % (kind,))
return None
# Chat scalar fields with a direct Responses counterpart.
_CHAT_SCALARS = (
("model", "model"),
("temperature", "temperature"),
("top_p", "top_p"),
("stream", "stream"),
("store", "store"),
("metadata", "metadata"),
("user", "user"),
("service_tier", "service_tier"),
("parallel_tool_calls", "parallel_tool_calls"),
("prompt_cache_key", "prompt_cache_key"),
("max_tokens", "max_output_tokens"),
("max_completion_tokens", "max_output_tokens"),
)
# Chat fields with no Responses equivalent (verified against the reference).
_CHAT_DROPPED = (
"n",
"stop",
"seed",
"logprobs",
"frequency_penalty",
"presence_penalty",
"logit_bias",
"prediction",
"modalities",
"audio",
"web_search_options",
"prompt_cache_options",
"prompt_cache_retention",
"safety_identifier",
"stream_options",
"verbosity",
)
# Top-level Chat fields the transpiler understands (mapped, converted, or
# explicitly dropped above). Anything else is warned about, never silently
# ignored, so a gateway dialect field can never vanish here unnoticed.
_CHAT_KNOWN = (
frozenset(src for src, _ in _CHAT_SCALARS)
| frozenset(_CHAT_DROPPED)
| frozenset(
{
"messages",
"tools",
"tool_choice",
"response_format",
"reasoning_effort",
"reasoning",
"thinking",
"think",
"enable_thinking",
"top_logprobs",
}
)
)
_THINKING_FALSE = {False, 0, "0", "false", "no", "off", "none", "disabled"}
_THINKING_TRUE = {True, 1, "1", "true", "yes", "on", "enabled"}
def _thinking_flag(value: Any) -> Optional[bool]:
if isinstance(value, str):
value = value.strip().lower()
if value in _THINKING_FALSE:
return False
if value in _THINKING_TRUE:
return True
return None
def _chat_thinking_to_reasoning(chat: dict, out: dict, warn: list) -> None:
# Explicit effort wins; a Responses-shaped reasoning dict passes its
# effort through; chat-dialect thinking flags collapse to effort
# "minimal" when disabled and to "upstream default" (unset) when
# enabled. "minimal" (not "none") because the Responses reasoning-effort
# enum has no "none" value - only minimal/low/medium/high(/xhigh/max on
# some providers).
if chat.get("reasoning_effort") is not None:
out["reasoning"] = {"effort": chat["reasoning_effort"]}
return
reasoning = chat.get("reasoning")
if isinstance(reasoning, dict):
if reasoning.get("effort") is not None:
out["reasoning"] = {"effort": reasoning["effort"]}
extra = sorted(k for k in reasoning if k != "effort")
if extra:
warn.append(
"dropped reasoning keys %r (only effort transpiles)"
% (extra,)
)
return
enabled = _thinking_flag(reasoning.get("enabled"))
if enabled is False:
out["reasoning"] = {"effort": "minimal"}
return
if enabled is True:
return
thinking = chat.get("thinking")
if isinstance(thinking, dict):
enabled = _thinking_flag(thinking.get("type"))
if enabled is False:
out["reasoning"] = {"effort": "minimal"}
return
if enabled is True:
return
for key in ("think", "enable_thinking"):
enabled = _thinking_flag(chat.get(key))
if enabled is False:
out["reasoning"] = {"effort": "minimal"}
return
if enabled is True:
return
def chat_to_responses(chat: dict) -> tuple[dict, list]:
"""Convert a `POST /v1/chat/completions` body to `POST /responses`."""
warn: list = []
out: dict = {}
for src, dst in _CHAT_SCALARS:
if chat.get(src) is not None and dst not in out:
out[dst] = chat[src]
if chat.get("top_logprobs") is not None:
out["top_logprobs"] = chat["top_logprobs"]
_chat_thinking_to_reasoning(chat, out, warn)
instructions, items, converted_warnings = _chat_messages_to_input(
chat.get("messages")
)
warn += converted_warnings
if instructions:
out["instructions"] = instructions
out["input"] = items
tools = []
for tool in chat.get("tools") or []:
converted = _chat_tool_to_responses(tool, warn)
if converted is not None:
tools.append(converted)
if tools:
out["tools"] = tools
if chat.get("tool_choice") is not None:
choice = _chat_tool_choice_to_responses(chat["tool_choice"], warn)
if choice is not None:
out["tool_choice"] = choice
if chat.get("response_format") is not None:
text = _chat_response_format_to_text(chat["response_format"], warn)
if text is not None:
out["text"] = text
for key in _CHAT_DROPPED:
if chat.get(key) is not None:
warn.append("dropped chat field %r (no Responses equivalent)" % (key,))
for key in sorted(chat):
if key not in _CHAT_KNOWN:
warn.append("ignored unknown chat field %r" % (key,))
return out, warn
def _input_parts_to_chat_parts(parts: Any, warn: list, where: str) -> list:
out = []
for part in parts or []:
if not isinstance(part, dict):
continue
kind = part.get("type")
if kind in ("input_text", "output_text", "text"):
out.append({"type": "text", "text": part.get("text") or ""})
elif kind == "input_image":
image = {"url": part.get("image_url") or ""}
if part.get("detail"):
image["detail"] = part["detail"]
out.append({"type": "image_url", "image_url": image})
elif kind == "refusal":
out.append({"type": "refusal", "refusal": part.get("refusal") or ""})
else:
warn.append(
"%s: dropped input part type %r (no Chat mapping)"
% (where, kind)
)
return out
def _call_output_to_text(output: Any, warn: list) -> str:
if isinstance(output, str):
return output
if isinstance(output, list):
texts = []
for part in output:
if not isinstance(part, dict):
continue
if part.get("type") == "input_text":
texts.append(part.get("text") or "")
else:
warn.append(
"dropped function_call_output part type %r "
"(tool messages carry text only)" % (part.get("type"),)
)
return "".join(texts)
return ""
def _responses_input_to_chat_messages(
input_items: Any, warn: list
) -> list:
messages: list = []
pending_calls: list = []
for item in input_items or []:
if isinstance(item, str):
messages.append({"role": "user", "content": item})
continue
if not isinstance(item, dict):
continue
kind = item.get("type") or "message"
if kind == "message":
content = item.get("content")
if isinstance(content, list):
content = _input_parts_to_chat_parts(
content, warn, "input.message"
)
messages.append(
{"role": item.get("role") or "user", "content": content}
)
continue
if kind == "function_call":
pending_calls.append(
{
"id": item.get("call_id") or item.get("id") or "",
"type": "function",
"function": {
"name": item.get("name") or "",
"arguments": item.get("arguments") or "",
},
}
)
continue
if kind == "function_call_output":
if pending_calls:
messages.append(
{
"role": "assistant",
"content": None,
"tool_calls": pending_calls,
}
)
pending_calls = []
messages.append(
{
"role": "tool",
"tool_call_id": item.get("call_id") or "",
"content": _call_output_to_text(item.get("output"), warn),
}
)
continue
warn.append(
"dropped input item type %r "
"(reasoning/native-tool items do not replay in Chat)" % (kind,)
)
if pending_calls:
messages.append(
{"role": "assistant", "content": None, "tool_calls": pending_calls}
)
return messages
def _responses_tool_to_chat(tool: Any, warn: list) -> Optional[dict]:
if not isinstance(tool, dict):
return None
if tool.get("type") == "function":
func: dict = {"name": tool.get("name") or ""}
if tool.get("description") is not None:
func["description"] = tool["description"]
if tool.get("parameters") is not None:
func["parameters"] = tool["parameters"]
if tool.get("strict") is not None:
func["strict"] = tool["strict"]
return {"type": "function", "function": func}
warn.append(
"dropped tool type %r (namespaces and builtins have no Chat shape)"
% (tool.get("type"),)
)
return None
def _responses_tool_choice_to_chat(choice: Any, warn: list) -> Any:
if choice in (None, "none", "auto", "required"):
return choice
if isinstance(choice, dict):
if choice.get("type") == "function":
return {
"type": "function",
"function": {"name": choice.get("name") or ""},
}
if choice.get("type") == "allowed_tools":
tools = []
for entry in choice.get("tools") or []:
if isinstance(entry, dict) and entry.get("type") == "function":
tools.append(
{
"type": "function",
"function": {"name": entry.get("name") or ""},
}
)
else:
warn.append("dropped allowed_tools entry %r" % (entry,))
return {
"type": "allowed_tools",
"mode": choice.get("mode") or "auto",
"tools": tools,
}
warn.append("dropped tool_choice %r (no Chat equivalent)" % (choice,))
return None
def _responses_text_to_response_format(text: Any, warn: list) -> Optional[dict]:
fmt = (text or {}).get("format") if isinstance(text, dict) else None
if not isinstance(fmt, dict):
return None
kind = fmt.get("type") or "text"
if kind == "text":
return None
if kind == "json_object":
return {"type": "json_object"}
if kind == "json_schema":
schema: dict = {
"name": fmt.get("name") or "result",
"schema": fmt.get("schema") or {},
}
if fmt.get("description") is not None:
schema["description"] = fmt["description"]
if fmt.get("strict") is not None:
schema["strict"] = fmt["strict"]
return {"type": "json_schema", "json_schema": schema}
warn.append("dropped text.format type %r" % (kind,))
return None
_RESPONSES_SCALARS = (
("model", "model"),
("temperature", "temperature"),
("top_p", "top_p"),
("stream", "stream"),
("store", "store"),
("metadata", "metadata"),
("user", "user"),
("service_tier", "service_tier"),
("parallel_tool_calls", "parallel_tool_calls"),
("prompt_cache_key", "prompt_cache_key"),
("top_logprobs", "top_logprobs"),
("max_output_tokens", "max_tokens"),
)
_RESPONSES_DROPPED = (
"previous_response_id",
"conversation",
"truncation",
"include",
"background",
"max_tool_calls",
"prompt",
"prompt_cache_options",
"prompt_cache_retention",
"safety_identifier",
"stream_options",
"context_management",
"moderation",
"access_programs",
)
_RESPONSES_KNOWN = (
frozenset(src for src, _ in _RESPONSES_SCALARS)
| frozenset(_RESPONSES_DROPPED)
| frozenset(
{
"input",
"instructions",
"tools",
"tool_choice",
"text",
"reasoning",
}
)
)
def responses_to_chat(resp: dict) -> tuple[dict, list]:
"""Convert a `POST /responses` body to `POST /v1/chat/completions`."""
warn: list = []
out: dict = {}
for src, dst in _RESPONSES_SCALARS:
if resp.get(src) is not None:
out[dst] = resp[src]
reasoning = resp.get("reasoning") or {}
if isinstance(reasoning, dict) and reasoning.get("effort") is not None:
out["reasoning_effort"] = reasoning["effort"]
raw_input = resp.get("input")
items = (
[{"type": "message", "role": "user", "content": raw_input}]
if isinstance(raw_input, str)
else raw_input
)
messages = _responses_input_to_chat_messages(items, warn)
instructions = resp.get("instructions")
if isinstance(instructions, str) and instructions.strip():
messages.insert(0, {"role": "system", "content": instructions})
elif isinstance(instructions, list):
messages[0:0] = _responses_input_to_chat_messages(instructions, warn)
out["messages"] = messages
tools = []
for tool in resp.get("tools") or []:
converted = _responses_tool_to_chat(tool, warn)
if converted is not None:
tools.append(converted)
if tools:
out["tools"] = tools
if resp.get("tool_choice") is not None:
choice = _responses_tool_choice_to_chat(resp["tool_choice"], warn)
if choice is not None:
out["tool_choice"] = choice
if resp.get("text") is not None:
fmt = _responses_text_to_response_format(resp["text"], warn)
if fmt is not None:
out["response_format"] = fmt
for key in _RESPONSES_DROPPED:
if resp.get(key) is not None:
warn.append(
"dropped responses field %r (no Chat equivalent)" % (key,)
)
for key in sorted(resp):
if key not in _RESPONSES_KNOWN:
warn.append("ignored unknown responses field %r" % (key,))
return out, warn
def responses_object_to_chat_completion(resp: dict) -> tuple[dict, list]:
"""Convert a Responses object to a ChatCompletion object (one choice)."""
warn: list = []
text: list = []
refusal: list = []
calls: list = []
for item in resp.get("output") or []:
if not isinstance(item, dict):
continue
if item.get("type") == "message":
for part in item.get("content") or []:
if not isinstance(part, dict):
continue
if part.get("type") == "output_text":
text.append(part.get("text") or "")
elif part.get("type") == "refusal":
refusal.append(part.get("refusal") or "")
else:
warn.append(
"dropped output part type %r" % (part.get("type"),)
)
elif item.get("type") == "function_call":
calls.append(
{
"id": item.get("call_id") or item.get("id") or "",
"type": "function",
"function": {
"name": item.get("name") or "",
"arguments": item.get("arguments") or "",
},
}
)
else:
warn.append("dropped output item type %r" % (item.get("type"),))
message: dict = {"role": "assistant", "content": "".join(text) or None}
if refusal:
message["refusal"] = "".join(refusal)
if calls:
message["tool_calls"] = calls
incomplete = (resp.get("incomplete_details") or {}).get("reason")
if calls:
finish = "tool_calls"
elif incomplete == "max_output_tokens":
finish = "length"
elif incomplete == "content_filter":
finish = "content_filter"
else:
finish = "stop"
usage = resp.get("usage") or {}
return {
"id": resp.get("id") or "",
"object": "chat.completion",
"created": resp.get("created_at") or 0,
"model": resp.get("model") or "",
"choices": [{"index": 0, "message": message, "finish_reason": finish}],
"usage": {
"prompt_tokens": usage.get("input_tokens") or 0,
"completion_tokens": usage.get("output_tokens") or 0,
"total_tokens": usage.get("total_tokens") or 0,
},
}, warn
def chat_completion_to_responses_object(comp: dict) -> tuple[dict, list]:
"""Convert a ChatCompletion object to a Responses object (choice 0)."""
warn: list = []
choices = comp.get("choices") or []
if len(choices) > 1:
warn.append(
"kept choice 0 of %d (Responses returns one generation)"
% (len(choices),)
)
message = (choices[0] or {}).get("message") if choices else {}
output: list = []
if (message.get("content") or None) is not None or not message.get(
"tool_calls"
):
output.append(
{
"id": "msg_transpiled_0",
"type": "message",
"status": "completed",
"role": "assistant",
"content": [
{
"type": "output_text",
"text": message.get("content") or "",
"annotations": [],
}
],
}
)
if message.get("refusal"):
output.append(
{
"id": "msg_transpiled_refusal",
"type": "message",
"status": "completed",
"role": "assistant",
"content": [
{"type": "refusal", "refusal": message["refusal"]}
],
}
)
for call in message.get("tool_calls") or []:
func = (
(call.get("function") or {}) if isinstance(call, dict) else {}
)
output.append(
{
"type": "function_call",
"call_id": (
(call.get("id") if isinstance(call, dict) else "") or ""
),
"name": func.get("name") or "",
"arguments": func.get("arguments") or "",
}
)
usage = comp.get("usage") or {}
return {
"id": comp.get("id") or "",
"object": "response",
"created_at": comp.get("created") or 0,
"status": "completed",
"model": comp.get("model") or "",
"output": output,
"usage": {
"input_tokens": usage.get("prompt_tokens") or 0,
"output_tokens": usage.get("completion_tokens") or 0,
"total_tokens": usage.get("total_tokens") or 0,
},
}, warn
def responses_failure_message(data: Any) -> Optional[str]:
"""Extract a failure message from a 200 Responses body, if any."""
if not isinstance(data, dict):
return None
error = data.get("error")
if isinstance(error, dict):
message = error.get("message") or error.get("code") or "upstream error"
return str(message)[:300]
if data.get("object") == "response" and data.get("status") in (
"failed",
"incomplete",
"cancelled",
):
details = data.get("incomplete_details") or {}
reason = details.get("reason") or data.get("status")
return "response %s: %s" % (data.get("status"), reason)
return None
def responses_error_object(data: Any) -> Optional[dict]:
"""Normalize a Responses error body to a Chat-style error object."""
if not isinstance(data, dict):
return None
error = data.get("error")
if isinstance(error, dict):
out = {"message": str(error.get("message") or "upstream error")}
if error.get("type") is not None:
out["type"] = error["type"]
if error.get("code") is not None:
out["code"] = error["code"]
return {"error": out}
message = responses_failure_message(data)
if message:
return {"error": {"message": message, "type": "upstream_error"}}
return None
class ResponsesToChatStream:
"""Translate Responses SSE events into ChatCompletion chunks.
Text deltas and function-call argument deltas map exactly; lifecycle
events are consumed; `response.completed` yields the terminal chunk with
the real finish reason and usage. Error events yield `{"error": ...}`
payloads (the Chat stream error shape) and are also stashed on `failed`.
"""
def __init__(self, model: str = ""):
self.model = model
self.calls: dict = {}
self.order: list = []
self.failed: Any = None
self.role_sent = False
self.text_sent = False
def feed(self, event: Any) -> list:
if not isinstance(event, dict):
return []
kind = event.get("type") or ""
if kind == "response.output_text.delta":
delta: dict = {"content": event.get("delta") or ""}
if not self.role_sent:
delta = {"role": "assistant", **delta}
self.role_sent = True
self.text_sent = True
return [self._chunk(delta)]
if kind == "response.output_item.added":
item = event.get("item") or {}
if item.get("type") == "function_call" and item.get("call_id"):
index = self._index(item["call_id"])
return [
self._chunk(
{
"tool_calls": [
{
"index": index,
"id": item["call_id"],
"type": "function",
"function": {
"name": item.get("name") or "",
"arguments": "",
},
}
]
}
)
]
return []
if kind == "response.function_call_arguments.delta":
call_id = event.get("item_id") or ""
return [
self._chunk(
{
"tool_calls": [
{
"index": self._index(call_id),
"function": {
"arguments": event.get("delta") or ""
},
}
]
}
)
]
if kind == "response.completed":
response = event.get("response") or {}
converted, _ = responses_object_to_chat_completion(response)
chunks = []
message = (converted["choices"][0] or {}).get("message") or {}
if message.get("refusal") and not self.text_sent:
chunks.append(self._chunk({"refusal": message["refusal"]}))
chunk = self._chunk({})
chunk["choices"][0]["finish_reason"] = (
converted["choices"][0] or {}
).get("finish_reason")
chunk["usage"] = converted["usage"]
chunks.append(chunk)
return chunks
if kind in ("response.failed", "response.incomplete", "error"):
self.failed = event
payload = responses_error_object(
event.get("response") or event.get("error") or event
) or {"error": {"message": kind, "type": "upstream_error"}}
return [payload]
return []
def _index(self, call_id: str) -> int:
if call_id not in self.calls:
self.calls[call_id] = len(self.order)
self.order.append(call_id)
return self.calls[call_id]
def _chunk(self, delta: dict) -> dict:
return {
"id": "chatcmpl_transpiled",
"object": "chat.completion.chunk",
"created": 0,
"model": self.model,
"choices": [{"index": 0, "delta": delta, "finish_reason": None}],
}
class ChatToResponsesStream:
"""Translate ChatCompletion chunks into Responses SSE events.
Best effort: text and tool-call deltas map exactly, but Chat chunks
carry no lifecycle events, so the synthesized stream skips
`response.created` / `output_item.added` for text and emits
`response.completed` with an assembled object. Streaming call ids are
tracked by tool-call index, per the Chat streaming contract (the id
arrives on the first chunk for each index).
"""
def __init__(self):
self.text: list = []
self.calls: dict = {}
self.order: list = []
self.warnings: list = []
def feed(self, chunk: Any) -> list:
events = []
choices = (chunk or {}).get("choices") or []
delta = (choices[0] or {}).get("delta") if choices else {}
for call in (delta or {}).get("tool_calls") or []:
if not isinstance(call, dict):
continue
index = call.get("index")
func = call.get("function") or {}
call_id = call.get("id")
if call_id and call_id not in self.calls:
self.calls[call_id] = True
self.order.append(call_id)
events.append(
{
"type": "response.output_item.added",
"output_index": len(self.order) - 1,
"item": {
"type": "function_call",
"call_id": call_id,
"name": func.get("name") or "",
"arguments": "",
},
}
)
if not call_id and isinstance(index, int) and index < len(
self.order
):
call_id = self.order[index]
if func.get("arguments"):
if not call_id:
self.warnings.append(
"tool-call arguments arrived before any call id"
)
events.append(
{
"type": "response.function_call_arguments.delta",
"item_id": call_id or "",
"output_index": 0,
"delta": func["arguments"],
}
)
piece = (delta or {}).get("content")
if piece:
self.text.append(piece)
events.append(
{
"type": "response.output_text.delta",
"item_id": "msg_transpiled_0",
"output_index": 0,
"content_index": 0,
"delta": piece,
}
)
finish = (choices[0] or {}).get("finish_reason") if choices else None
if finish:
output = [
{
"id": "msg_transpiled_0",
"type": "message",
"status": "completed",
"role": "assistant",
"content": [
{
"type": "output_text",
"text": "".join(self.text),
"annotations": [],
}
],
}
]
events.append(
{
"type": "response.completed",
"response": {
"id": "resp_transpiled",
"object": "response",
"status": "completed",
"model": (chunk or {}).get("model") or "",
"output": output,
},
}
)
return events