@jeffusion/bungee-core 5.19.0 → 5.21.0

package/dist/plugins/openai-messages-to-chat/index.js

@@ -5337,6 +5337,601 @@ var PROVIDER_ADAPTERS = {
   anthropic: createAnthropicAdapter(),
   gemini: createGeminiAdapter()
 };
+// packages/llms/src/responses-codec/common.ts
+var DEFAULT_RESPONSES_CODEC_LIMITS = Object.freeze({
+  maxRequestBytes: 8 * 1024 * 1024,
+  maxOutputBytes: 8 * 1024 * 1024,
+  maxArgumentBytes: 1024 * 1024,
+  maxItems: 1024
+});
+
+class ResponsesCodecError extends Error {
+  code;
+  param;
+  constructor(code, message, param) {
+    super(message);
+    this.code = code;
+    this.param = param;
+    this.name = "ResponsesCodecError";
+  }
+}
+function fail(code, message, param) {
+  throw new ResponsesCodecError(code, message, param);
+}
+function record(value, where) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    fail("invalid_payload", `${where} must be an object`);
+  return value;
+}
+function string(value, where, nonempty = false) {
+  if (typeof value !== "string" || nonempty && !value)
+    fail("invalid_payload", `${where} must be a${nonempty ? " non-empty" : ""} string`);
+  return value;
+}
+function list(value, where) {
+  if (!Array.isArray(value))
+    fail("invalid_payload", `${where} must be an array`);
+  return value;
+}
+function limits(overrides) {
+  const result = { ...DEFAULT_RESPONSES_CODEC_LIMITS, ...overrides };
+  for (const [key, value] of Object.entries(result)) {
+    if (!Number.isSafeInteger(value) || value <= 0)
+      fail("invalid_limit", `${key} must be a positive integer`);
+  }
+  return result;
+}
+function bytes(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+function bounded(value, max, where) {
+  if (bytes(value) > max)
+    fail("resource_limit", `${where} exceeds ${max} bytes`);
+  return value;
+}
+function serialized(value, max, where) {
+  let result;
+  try {
+    result = JSON.stringify(value);
+  } catch {
+    fail("invalid_payload", `${where} must be serializable JSON`);
+  }
+  if (result === undefined)
+    fail("invalid_payload", `${where} must be serializable JSON`);
+  return bounded(result, max, where);
+}
+function argumentObject(text) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    fail("invalid_tool_arguments", "Tool arguments must be complete JSON");
+  }
+  return record(value, "tool arguments");
+}
+function restoreTool(name, names) {
+  const result = names.get(name);
+  if (result)
+    return result;
+  if (names.size)
+    fail("unknown_tool", `Provider returned undeclared tool ${name}`);
+  return { name, custom: false };
+}
+function customInput(text) {
+  const value = argumentObject(text);
+  if (Object.keys(value).length !== 1 || typeof value.input !== "string") {
+    fail("invalid_tool_arguments", "Custom tools require exactly one string input property");
+  }
+  return value.input;
+}
+function customInputPrefix(text) {
+  const prefix = /^\s*\{\s*"input"\s*:\s*"/.exec(text);
+  if (!prefix)
+    return "";
+  let result = "";
+  for (let i = prefix[0].length;i < text.length; ) {
+    const char = text[i];
+    if (char === '"')
+      break;
+    if (char !== "\\") {
+      if (char.charCodeAt(0) < 32)
+        fail("invalid_tool_arguments", "Invalid JSON string character");
+      result += char;
+      i++;
+      continue;
+    }
+    const escape = text[i + 1];
+    if (escape === undefined)
+      break;
+    const size = escape === "u" ? 6 : 2;
+    if (i + size > text.length)
+      break;
+    try {
+      result += JSON.parse(`"${text.slice(i, i + size)}"`);
+    } catch {
+      fail("invalid_tool_arguments", "Invalid JSON string escape");
+    }
+    i += size;
+  }
+  return result;
+}
+function terminal(reason, protocol) {
+  if (typeof reason !== "string" || !reason)
+    fail("missing_terminal", "Upstream has no explicit completion reason");
+  const completed = protocol === "chat_completions" ? ["stop", "tool_calls", "function_call"] : ["end_turn", "tool_use", "stop_sequence"];
+  if (completed.includes(reason))
+    return { status: "completed", reason };
+  if (reason === "length" || reason === "max_tokens" || reason === "model_context_window_exceeded")
+    return { status: "incomplete", reason: "max_output_tokens" };
+  if (reason === "content_filter" || reason === "refusal")
+    return { status: "incomplete", reason: "content_filter" };
+  if (reason === "error")
+    return { status: "failed", reason: "upstream_error" };
+  fail("unknown_terminal", `Unsupported upstream completion reason: ${reason}`);
+}
+function tokens(value, where) {
+  if (value === undefined)
+    return 0;
+  if (!Number.isSafeInteger(value) || value < 0)
+    fail("invalid_usage", `${where} must be a non-negative integer`);
+  return value;
+}
+function normalizeUsage(raw, protocol, prior = {}) {
+  if (raw === undefined || raw === null)
+    return prior;
+  const usage = record(raw, "usage");
+  const chat = protocol === "chat_completions";
+  const input = tokens(usage[chat ? "prompt_tokens" : "input_tokens"] ?? prior.input_tokens, "input_tokens");
+  const output = tokens(usage[chat ? "completion_tokens" : "output_tokens"] ?? prior.output_tokens, "output_tokens");
+  const details = chat ? usage.prompt_tokens_details : undefined;
+  const cached = chat ? details ? record(details, "prompt_tokens_details").cached_tokens : undefined : usage.cache_read_input_tokens;
+  const cacheRead = tokens(cached ?? prior.input_tokens_details?.cached_tokens, "cached_tokens");
+  const cacheWrite = chat ? 0 : tokens(usage.cache_creation_input_tokens, "cache_creation_input_tokens");
+  const totalInput = chat ? input : usage.input_tokens === undefined ? input : input + cacheRead + cacheWrite;
+  const reasoning = chat && usage.completion_tokens_details ? record(usage.completion_tokens_details, "completion_tokens_details").reasoning_tokens : undefined;
+  return {
+    input_tokens: totalInput,
+    output_tokens: output,
+    total_tokens: totalInput + output,
+    input_tokens_details: { cached_tokens: cacheRead },
+    output_tokens_details: { reasoning_tokens: tokens(reasoning ?? prior.output_tokens_details?.reasoning_tokens, "reasoning_tokens") }
+  };
+}
+function toolItem(id, name, args, names, status = "completed") {
+  const original = restoreTool(name, names);
+  const item = { id: `fc_${id}`, type: original.custom ? "custom_tool_call" : "function_call", call_id: id, name: original.name, status };
+  if (original.namespace)
+    item.namespace = original.namespace;
+  if (original.custom)
+    item.input = customInput(args);
+  else {
+    argumentObject(args);
+    item.arguments = args;
+  }
+  return item;
+}
+function responsePayload(id, model, output, end, usage, error, createdAt = Math.floor(Date.now() / 1000)) {
+  const result = { id, object: "response", created_at: createdAt, model, status: end.status, output, usage: Object.keys(usage).length ? usage : null };
+  if (end.status === "incomplete")
+    result.incomplete_details = { reason: end.reason };
+  if (end.status === "failed")
+    result.error = error ?? { code: end.reason, message: end.reason };
+  return result;
+}
+
+// packages/llms/src/responses-codec/request.ts
+var contentNormalizer = new OpenAIProtocolConversion({ trimWhitespace: false });
+// packages/llms/src/responses-codec/events.ts
+class ResponsesEventEncoder {
+  protocol;
+  model;
+  toolNames;
+  budget;
+  id = `resp_${crypto.randomUUID().replaceAll("-", "")}`;
+  createdAt = Math.floor(Date.now() / 1000);
+  output = [];
+  states = new Map;
+  anthropicBlocks = new Map;
+  usage = {};
+  end;
+  error;
+  started = false;
+  anthropicStarted = false;
+  anthropicStopped = false;
+  finalized = false;
+  poisoned = false;
+  sequence = 0;
+  retained = 0;
+  constructor(protocol, model, toolNames = new Map, configuredLimits) {
+    this.protocol = protocol;
+    this.model = model;
+    this.toolNames = toolNames;
+    this.budget = limits(configuredLimits);
+  }
+  event(type, fields = {}) {
+    return { type, sequence_number: this.sequence++, ...fields };
+  }
+  start(events) {
+    if (this.started)
+      return;
+    this.started = true;
+    const payload = { id: this.id, object: "response", created_at: this.createdAt, model: this.model, status: "in_progress", output: [], usage: null };
+    events.push(this.event("response.created", { response: payload }), this.event("response.in_progress", { response: { ...payload } }));
+  }
+  retain(text) {
+    this.retained += bytes(text);
+    if (this.retained > this.budget.maxOutputBytes)
+      fail("resource_limit", "Accumulated response output exceeds maxOutputBytes");
+  }
+  state(key, kind) {
+    const existing = this.states.get(key);
+    if (existing) {
+      if (existing.kind !== kind)
+        fail("invalid_stream", "Output item changed kind");
+      return existing;
+    }
+    if (this.output.length >= this.budget.maxItems)
+      fail("resource_limit", "Too many output items");
+    const state = { key, index: this.output.length, kind, id: `${this.id}_item_${this.output.length}`, text: "", name: "", callId: "", args: "", emittedInput: "", added: false, closed: false };
+    this.states.set(key, state);
+    this.output.push(state);
+    return state;
+  }
+  fields(state) {
+    return { response_id: this.id, item_id: state.id, output_index: state.index };
+  }
+  item(state, status, strict = false) {
+    if (state.kind === "tool") {
+      if (strict)
+        return { ...toolItem(state.callId, state.name, state.args || "{}", this.toolNames, status), id: state.id };
+      const original = state.original ?? restoreTool(state.name, this.toolNames);
+      return {
+        id: state.id,
+        type: original.custom ? "custom_tool_call" : "function_call",
+        call_id: state.callId,
+        name: original.name,
+        ...original.namespace ? { namespace: original.namespace } : {},
+        status,
+        ...original.custom ? { input: state.emittedInput } : { arguments: state.args }
+      };
+    }
+    if (state.kind === "reasoning")
+      return { id: state.id, type: "reasoning", summary: status === "in_progress" ? [] : [{ type: "summary_text", text: state.text }] };
+    return {
+      id: state.id,
+      type: "message",
+      role: "assistant",
+      status,
+      content: status === "in_progress" ? [] : [this.part(state)]
+    };
+  }
+  part(state) {
+    return state.kind === "refusal" ? { type: "refusal", refusal: state.text } : state.kind === "reasoning" ? { type: "summary_text", text: state.text } : { type: "output_text", text: state.text, annotations: [] };
+  }
+  add(state, events, final = false) {
+    if (state.added)
+      return;
+    if (state.kind === "tool") {
+      if (!state.callId || !state.name || this.toolNames.size && !this.toolNames.has(state.name))
+        return;
+      if (!final && !state.args && [...this.toolNames.keys()].some((name) => name !== state.name && name.startsWith(state.name)))
+        return;
+      state.original = restoreTool(state.name, this.toolNames);
+    }
+    state.added = true;
+    const initial = this.item(state, "in_progress");
+    if (state.kind === "tool") {
+      if (state.original?.custom)
+        initial.input = "";
+      else
+        initial.arguments = "";
+    }
+    events.push(this.event("response.output_item.added", { response_id: this.id, output_index: state.index, item: initial }));
+    if (state.kind !== "tool") {
+      const part = state.kind === "reasoning" ? { type: "summary_text", text: "" } : state.kind === "refusal" ? { type: "refusal", refusal: "" } : { type: "output_text", text: "", annotations: [] };
+      events.push(this.event(state.kind === "reasoning" ? "response.reasoning_summary_part.added" : "response.content_part.added", { ...this.fields(state), [state.kind === "reasoning" ? "summary_index" : "content_index"]: 0, part }));
+    }
+  }
+  appendText(state, delta, events) {
+    if (state.closed)
+      fail("invalid_stream", "Delta arrived after content block stop");
+    this.retain(delta);
+    state.text += delta;
+    this.add(state, events);
+    const type = state.kind === "reasoning" ? "response.reasoning_summary_text.delta" : state.kind === "refusal" ? "response.refusal.delta" : "response.output_text.delta";
+    if (delta)
+      events.push(this.event(type, { ...this.fields(state), [state.kind === "reasoning" ? "summary_index" : "content_index"]: 0, delta }));
+  }
+  emitArgs(state, events, fragment = "", first = false) {
+    if (!state.added)
+      return;
+    if (state.original?.custom) {
+      const prefix = customInputPrefix(state.args);
+      if (!prefix.startsWith(state.emittedInput))
+        fail("invalid_tool_arguments", "Custom input prefix changed");
+      const delta = prefix.slice(state.emittedInput.length);
+      state.emittedInput = prefix;
+      if (delta)
+        events.push(this.event("response.custom_tool_call_input.delta", { ...this.fields(state), delta }));
+    } else {
+      const delta = first ? state.args : fragment;
+      if (delta)
+        events.push(this.event("response.function_call_arguments.delta", { ...this.fields(state), delta }));
+    }
+  }
+  toolDelta(state, raw, events) {
+    if (state.closed)
+      fail("invalid_stream", "Tool delta arrived after content block stop");
+    if (raw.id !== undefined) {
+      const id = string(raw.id, "tool call id", true);
+      if (state.callId && state.callId !== id)
+        fail("invalid_stream", "Tool call id changed");
+      if (!state.callId)
+        this.retain(id);
+      state.callId = id;
+    }
+    const fn = raw.function === undefined ? {} : record(raw.function, "tool function");
+    if (fn.name !== undefined) {
+      const name = string(fn.name, "tool name");
+      if (state.added && name)
+        fail("invalid_stream", "Tool name changed after output_item.added");
+      this.retain(name);
+      state.name += name;
+    }
+    const args = fn.arguments === undefined ? "" : string(fn.arguments, "tool arguments delta");
+    this.retain(args);
+    state.args = bounded(state.args + args, this.budget.maxArgumentBytes, "tool arguments");
+    const wasAdded = state.added;
+    this.add(state, events);
+    this.emitArgs(state, events, args, !wasAdded);
+  }
+  push(raw) {
+    if (this.poisoned)
+      fail("invalid_stream", "Encoder cannot continue after a codec error");
+    if (this.finalized)
+      fail("invalid_stream", "Event arrived after response terminal");
+    try {
+      const chunk = record(raw, "stream event");
+      serialized(chunk, this.budget.maxOutputBytes, "stream event");
+      const events = [];
+      this.start(events);
+      if (chunk.error !== undefined || chunk.type === "error") {
+        this.error = record(chunk.error, "upstream error");
+        this.end = { status: "failed", reason: "upstream_error" };
+        this.anthropicStopped = true;
+        return [...events, ...this.complete()];
+      }
+      if (this.protocol === "chat_completions")
+        this.chat(chunk, events);
+      else
+        this.anthropic(chunk, events);
+      return events;
+    } catch (error) {
+      this.poisoned = true;
+      throw error;
+    }
+  }
+  chat(chunk, events) {
+    const choices = list(chunk.choices, "choices");
+    if (choices.length > 1)
+      fail("unsupported_response", "Multiple response candidates are not supported");
+    if (choices.length) {
+      const choice = record(choices[0], "choice");
+      if (choice.index !== undefined && choice.index !== 0)
+        fail("unsupported_response", "Only choice index 0 is supported");
+      const delta = record(choice.delta ?? {}, "choice delta");
+      for (const key of Object.keys(delta))
+        if (!["role", "content", "refusal", "reasoning_content", "reasoning", "tool_calls", "function_call", "annotations"].includes(key))
+          fail("unsupported_content", `Unsupported Chat output field ${key}`);
+      if (delta.annotations !== undefined && list(delta.annotations, "annotations").length)
+        fail("unsupported_content", "Chat output annotations cannot be faithfully converted");
+      if (delta.role !== undefined && delta.role !== "assistant")
+        fail("unsupported_response", "Response role must be assistant");
+      if (this.end && Object.values(delta).some((v) => v !== undefined && v !== null && v !== "" && (!Array.isArray(v) || v.length)))
+        fail("invalid_stream", "Output arrived after finish_reason");
+      const reasoning = delta.reasoning_content ?? delta.reasoning;
+      if (reasoning !== undefined && reasoning !== null)
+        this.appendText(this.state("reasoning", "reasoning"), string(reasoning, "reasoning delta"), events);
+      if (delta.content !== undefined && delta.content !== null)
+        this.appendText(this.state("text", "text"), string(delta.content, "text delta"), events);
+      if (delta.refusal !== undefined && delta.refusal !== null)
+        this.appendText(this.state("refusal", "refusal"), string(delta.refusal, "refusal delta"), events);
+      if (delta.tool_calls !== undefined) {
+        for (const rawTool of list(delta.tool_calls, "tool_calls")) {
+          const tool = record(rawTool, "tool call");
+          if (!Number.isSafeInteger(tool.index) || tool.index < 0)
+            fail("invalid_stream", "Streamed tool requires a non-negative integer index");
+          if (tool.type !== undefined && tool.type !== "function")
+            fail("unsupported_tool", "Unknown upstream tool call type");
+          this.toolDelta(this.state(`tool:${tool.index}`, "tool"), tool, events);
+        }
+      }
+      if (delta.function_call !== undefined)
+        fail("unsupported_response", "Legacy function_call lacks a stable call_id");
+      if (choice.finish_reason !== undefined && choice.finish_reason !== null) {
+        const next = terminal(choice.finish_reason, this.protocol);
+        if (this.end && (this.end.status !== next.status || this.end.reason !== next.reason))
+          fail("invalid_stream", "Conflicting finish reasons");
+        this.end = next;
+      }
+    }
+    this.usage = normalizeUsage(chunk.usage, this.protocol, this.usage);
+  }
+  anthropic(chunk, events) {
+    if (chunk.type === "ping")
+      return;
+    if (this.anthropicStopped)
+      fail("invalid_stream", "Event arrived after message_stop");
+    if (chunk.type === "message_start") {
+      if (this.anthropicStarted)
+        fail("invalid_stream", "Duplicate message_start");
+      const message = record(chunk.message, "message");
+      this.anthropicStarted = true;
+      this.usage = normalizeUsage(message.usage, this.protocol, this.usage);
+      return;
+    }
+    if (!this.anthropicStarted)
+      fail("invalid_stream", "Anthropic event arrived before message_start");
+    if (chunk.type === "message_delta") {
+      const delta = record(chunk.delta, "message delta");
+      if (delta.stop_reason != null) {
+        const next = terminal(delta.stop_reason, this.protocol);
+        if (this.end && (this.end.status !== next.status || this.end.reason !== next.reason))
+          fail("invalid_stream", "Conflicting stop reasons");
+        this.end = next;
+      }
+      this.usage = normalizeUsage(chunk.usage, this.protocol, this.usage);
+      return;
+    }
+    if (chunk.type === "message_stop") {
+      if (!this.end)
+        fail("missing_terminal", "message_stop has no preceding stop_reason");
+      if ([...this.anthropicBlocks.values()].some((s) => !s.closed))
+        fail("invalid_stream", "message_stop arrived before content_block_stop");
+      this.anthropicStopped = true;
+      return;
+    }
+    if (!Number.isSafeInteger(chunk.index) || chunk.index < 0)
+      fail("invalid_stream", "Anthropic content requires a non-negative integer index");
+    const index = chunk.index;
+    if (this.end)
+      fail("invalid_stream", "Content arrived after stop_reason");
+    if (chunk.type === "content_block_start") {
+      if (this.anthropicBlocks.has(index))
+        fail("invalid_stream", "Duplicate content_block_start");
+      const block = record(chunk.content_block, "content block");
+      const kind = block.type === "tool_use" ? "tool" : block.type === "text" ? "text" : block.type === "thinking" ? "reasoning" : undefined;
+      if (!kind)
+        fail("unsupported_content", `Unsupported Anthropic block ${String(block.type)}`);
+      const state = this.state(`block:${index}`, kind);
+      this.anthropicBlocks.set(index, state);
+      if (kind === "tool") {
+        const input = record(block.input ?? {}, "tool input");
+        this.toolDelta(state, { id: block.id, function: { name: block.name, ...Object.keys(input).length ? { arguments: serialized(input, this.budget.maxArgumentBytes, "tool input") } : {} } }, events);
+      } else
+        this.appendText(state, string(block[kind === "text" ? "text" : "thinking"] ?? "", "block text"), events);
+      return;
+    }
+    const state = this.anthropicBlocks.get(index);
+    if (!state || state.closed)
+      fail("invalid_stream", "Content event has no open block");
+    if (chunk.type === "content_block_stop") {
+      state.closed = true;
+      return;
+    }
+    if (chunk.type !== "content_block_delta")
+      fail("unsupported_response", `Unknown Anthropic event ${String(chunk.type)}`);
+    const delta = record(chunk.delta, "content delta");
+    if (delta.type === "input_json_delta" && state.kind === "tool")
+      this.toolDelta(state, { function: { arguments: delta.partial_json } }, events);
+    else if (delta.type === "text_delta" && state.kind === "text")
+      this.appendText(state, string(delta.text, "text delta"), events);
+    else if (delta.type === "thinking_delta" && state.kind === "reasoning")
+      this.appendText(state, string(delta.thinking, "thinking delta"), events);
+    else if (delta.type === "signature_delta" && state.kind === "reasoning") {
+      bounded(string(delta.signature, "signature"), this.budget.maxArgumentBytes, "signature");
+    } else
+      fail("unsupported_content", `Unsupported content delta ${String(delta.type)}`);
+  }
+  complete() {
+    if (!this.end)
+      fail("missing_terminal", "Stream ended without an explicit upstream terminal");
+    const events = [];
+    const items = [];
+    const callIds = new Set;
+    for (const state of this.output) {
+      const strict = this.end.status === "completed";
+      if (state.kind === "tool") {
+        if (!state.callId || !state.name)
+          fail("invalid_tool_arguments", "Tool call is missing id or name");
+        if (callIds.has(state.callId))
+          fail("invalid_tool_arguments", "Duplicate provider call_id");
+        callIds.add(state.callId);
+        state.original ??= restoreTool(state.name, this.toolNames);
+        this.add(state, events, true);
+        if (!state.added)
+          fail("unknown_tool", `Unknown tool ${state.name}`);
+        if (strict) {
+          argumentObject(state.args || "{}");
+          if (state.original.custom) {
+            const text = customInput(state.args);
+            if (!text.startsWith(state.emittedInput))
+              fail("invalid_tool_arguments", "Custom tool input changed");
+            if (text.length > state.emittedInput.length)
+              events.push(this.event("response.custom_tool_call_input.delta", { ...this.fields(state), delta: text.slice(state.emittedInput.length) }));
+            state.emittedInput = text;
+          }
+        }
+      }
+      const item = this.item(state, this.end.status === "completed" ? "completed" : "incomplete", strict);
+      const fields = this.fields(state);
+      if (state.kind === "tool") {
+        const custom = state.original.custom;
+        events.push(this.event(custom ? "response.custom_tool_call_input.done" : "response.function_call_arguments.done", { ...fields, [custom ? "input" : "arguments"]: custom ? item.input : item.arguments }));
+      } else {
+        const reasoning = state.kind === "reasoning";
+        const textField = state.kind === "refusal" ? "refusal" : "text";
+        events.push(this.event(reasoning ? "response.reasoning_summary_text.done" : state.kind === "refusal" ? "response.refusal.done" : "response.output_text.done", { ...fields, [reasoning ? "summary_index" : "content_index"]: 0, [textField]: state.text }));
+        events.push(this.event(reasoning ? "response.reasoning_summary_part.done" : "response.content_part.done", { ...fields, [reasoning ? "summary_index" : "content_index"]: 0, part: this.part(state) }));
+      }
+      events.push(this.event("response.output_item.done", { response_id: this.id, output_index: state.index, item }));
+      items.push(item);
+    }
+    const response = responsePayload(this.id, this.model, items, this.end, this.usage, this.error, this.createdAt);
+    serialized(response, this.budget.maxOutputBytes, "final response");
+    events.push(this.event(`response.${this.end.status}`, { response }));
+    this.finalized = true;
+    return events;
+  }
+  finish() {
+    if (this.poisoned)
+      fail("invalid_stream", "Encoder cannot finish after a codec error");
+    if (this.finalized)
+      return [];
+    try {
+      if (this.protocol === "anthropic_messages" && !this.anthropicStopped)
+        fail("missing_terminal", "Anthropic stream ended before message_stop");
+      return this.complete();
+    } catch (error) {
+      this.poisoned = true;
+      throw error;
+    }
+  }
+}
+
+// packages/llms/src/responses-codec/result.ts
+function encodeResponsesResult(raw, protocol, model, toolNames = new Map, configuredLimits) {
+  const body = record(raw, "upstream response");
+  const budget = limits(configuredLimits);
+  serialized(body, budget.maxOutputBytes, "upstream response");
+  if (body.error !== undefined || body.type === "error")
+    return responsePayload(`resp_${crypto.randomUUID().replaceAll("-", "")}`, model, [], { status: "failed", reason: "upstream_error" }, {}, record(body.error, "upstream error"));
+  const encoder = new ResponsesEventEncoder(protocol, model, toolNames, configuredLimits);
+  if (protocol === "chat_completions") {
+    const choices = list(body.choices, "choices");
+    if (choices.length !== 1)
+      fail("unsupported_response", "Exactly one response choice is required");
+    const choice = record(choices[0], "choice");
+    const message = record(choice.message, "message");
+    const delta = { ...message };
+    if (message.tool_calls !== undefined)
+      delta.tool_calls = list(message.tool_calls, "tool_calls").map((tool, index) => ({ ...record(tool, "tool call"), index }));
+    encoder.push({ choices: [{ index: choice.index ?? 0, delta, finish_reason: choice.finish_reason }], usage: body.usage });
+  } else {
+    encoder.push({ type: "message_start", message: { usage: body.usage } });
+    for (const [index, rawBlock] of list(body.content, "content").entries()) {
+      const block = record(rawBlock, "content block");
+      encoder.push({ type: "content_block_start", index, content_block: block });
+      encoder.push({ type: "content_block_stop", index });
+    }
+    encoder.push({ type: "message_delta", delta: { stop_reason: body.stop_reason } });
+    encoder.push({ type: "message_stop" });
+  }
+  const end = encoder.finish().at(-1);
+  if (!end)
+    fail("missing_terminal", "JSON response has no terminal result");
+  return record(end.response, "Responses result");
+}
 // plugins/openai-messages-to-chat/server/index.ts
 var RESPONSE_STATE_REFERENCE_FIELDS = [
   "previous_response_id",
@@ -5354,7 +5949,7 @@ var OpenAIMessagesToChatPlugin = definePlugin(class {
   adaptedRequestIds = new Set;
   responsesAdaptedRequestIds = new Set;
   streamConversionRequestIds = new Set;
-  responsesStreamConversionRequestIds = new Set;
+  responsesRequestModels = new Map;
   responsesRequestMessages = new Map;
   responsesRequestConversationIds = new Map;
   responsesHistoryByResponseId = new Map;
@@ -5384,7 +5979,7 @@ var OpenAIMessagesToChatPlugin = definePlugin(class {
       this.adaptedRequestIds.delete(ctx.requestId);
       this.responsesAdaptedRequestIds.delete(ctx.requestId);
       this.streamConversionRequestIds.delete(ctx.requestId);
-      this.responsesStreamConversionRequestIds.delete(ctx.requestId);
+      this.responsesRequestModels.delete(ctx.requestId);
       this.responsesRequestMessages.delete(ctx.requestId);
       this.responsesRequestConversationIds.delete(ctx.requestId);
       this.validationErrors.delete(ctx.requestId);
@@ -5414,6 +6009,7 @@ var OpenAIMessagesToChatPlugin = definePlugin(class {
         ctx.url.pathname = "/v1/chat/completions";
         ctx.body = this.normalizeAssistantToolCallReasoningContent(validation.body);
         this.responsesAdaptedRequestIds.add(ctx.requestId);
+        this.responsesRequestModels.set(ctx.requestId, String(validation.body.model));
         this.responsesRequestMessages.set(ctx.requestId, this.extractMessagesFromDowngradedBody(validation.body));
         if (stateReference.conversationId) {
           this.responsesRequestConversationIds.set(ctx.requestId, stateReference.conversationId);
@@ -5443,20 +6039,21 @@ var OpenAIMessagesToChatPlugin = definePlugin(class {
         if (!isRecord4(parsedBody)) {
           return response;
         }
-        const converted = this.convertChatCompletionToResponsesPayload(parsedBody);
-        if (!converted) {
-          return response;
+        const converted = this.convertChatCompletionToResponsesPayload(parsedBody, this.responsesRequestModels.get(ctx.requestId) ?? "");
+        if (converted.status !== "failed") {
+          const conversationId = this.responsesRequestConversationIds.get(ctx.requestId);
+          const baseMessages = this.responsesRequestMessages.get(ctx.requestId) ?? [];
+          const assistantMessage = this.extractAssistantMessageFromChatCompletionPayload(parsedBody);
+          const history = assistantMessage ? [...baseMessages, assistantMessage] : baseMessages;
+          this.storeResponsesState(String(converted.id), history, conversationId);
         }
-        const responseId = typeof converted.id === "string" ? converted.id : this.toResponsesId(parsedBody.id);
-        const conversationId = this.responsesRequestConversationIds.get(ctx.requestId);
-        const baseMessages = this.responsesRequestMessages.get(ctx.requestId) ?? [];
-        const assistantMessage = this.extractAssistantMessageFromChatCompletionPayload(parsedBody);
-        const history = assistantMessage ? [...baseMessages, assistantMessage] : baseMessages;
-        this.storeResponsesState(responseId, history, conversationId);
+        const headers = new Headers(response.headers);
+        headers.delete("content-length");
+        headers.delete("content-encoding");
         return new Response(JSON.stringify(converted), {
           status: response.status,
           statusText: response.statusText,
-          headers: response.headers
+          headers
         });
       }
       if (!this.adaptedRequestIds.has(ctx.requestId)) {
@@ -5476,20 +6073,21 @@ var OpenAIMessagesToChatPlugin = definePlugin(class {
     });
     hooks.onStreamChunk.tapPromise({ name: "openai-messages-to-chat", stage: 10 }, async (envelope, ctx) => {
       const chunk = structuredClone(envelope.json);
-      if (chunk === undefined)
-        return null;
       const converterContext = { ...ctx, sseEvent: envelope };
       if (this.responsesAdaptedRequestIds.has(ctx.requestId)) {
-        if (!this.messagesCompatibilityNormalizer.isOpenAIStreamChunk(chunk)) {
-          return null;
+        if (envelope.data === "[DONE]")
+          return [];
+        const encoder = this.getResponsesEncoder(ctx, isRecord4(chunk) ? chunk.model : undefined);
+        let normalized = chunk;
+        if (!ctx.streamState.has("responses_legacy_message") && isRecord4(chunk) && Array.isArray(chunk.choices) && chunk.choices.length === 1 && isRecord4(chunk.choices[0])) {
+          const choice = chunk.choices[0];
+          const delta = isRecord4(choice.delta) ? choice.delta : {};
+          normalized = { ...chunk, choices: [{ ...choice, delta: { ...delta, content: delta.content ?? "" } }] };
+          ctx.streamState.set("responses_legacy_message", true);
         }
-        const converted = this.convertChatCompletionChunkToResponsesEvents(chunk, ctx);
-        if (converted.length > 0) {
-          this.responsesStreamConversionRequestIds.add(ctx.requestId);
-        }
-        return protocolSSEOutput(converted, "responses", envelope);
+        return protocolSSEOutput(encoder.push(normalized), "responses", envelope);
       }
-      if (!this.adaptedRequestIds.has(ctx.requestId)) {
+      if (chunk === undefined || !this.adaptedRequestIds.has(ctx.requestId)) {
         return null;
       }
       if (!this.messagesCompatibilityNormalizer.isOpenAIStreamChunk(chunk)) {
@@ -5503,10 +6101,13 @@ var OpenAIMessagesToChatPlugin = definePlugin(class {
       return protocolSSEOutput(this.protocolConversion.ensureMessagesStreamCompatibility(converted, ctx), "anthropic", envelope);
     });
     hooks.onFlushStream.tapPromise({ name: "openai-messages-to-chat", stage: 10 }, async (chunks, ctx) => {
-      if (this.responsesStreamConversionRequestIds.has(ctx.requestId)) {
-        this.responsesStreamConversionRequestIds.delete(ctx.requestId);
-        const completionEvents = this.buildResponsesStreamCompletionEvents(ctx);
-        this.persistResponsesStateFromStream(ctx);
+      if (this.responsesAdaptedRequestIds.has(ctx.requestId)) {
+        const completionEvents = this.getResponsesEncoder(ctx).finish();
+        for (const event of completionEvents) {
+          if (isRecord4(event.response) && event.response.status !== "failed") {
+            this.persistResponsesStateFromResult(ctx.requestId, event.response);
+          }
+        }
         return [...chunks, ...protocolSSEOutput(completionEvents, "responses")];
       }
       if (!this.streamConversionRequestIds.has(ctx.requestId)) {
@@ -5521,7 +6122,7 @@ var OpenAIMessagesToChatPlugin = definePlugin(class {
       this.adaptedRequestIds.delete(ctx.requestId);
       this.responsesAdaptedRequestIds.delete(ctx.requestId);
       this.streamConversionRequestIds.delete(ctx.requestId);
-      this.responsesStreamConversionRequestIds.delete(ctx.requestId);
+      this.responsesRequestModels.delete(ctx.requestId);
       this.responsesRequestMessages.delete(ctx.requestId);
       this.responsesRequestConversationIds.delete(ctx.requestId);
       this.validationErrors.delete(ctx.requestId);
@@ -5531,7 +6132,7 @@ var OpenAIMessagesToChatPlugin = definePlugin(class {
     this.adaptedRequestIds.clear();
     this.responsesAdaptedRequestIds.clear();
     this.streamConversionRequestIds.clear();
-    this.responsesStreamConversionRequestIds.clear();
+    this.responsesRequestModels.clear();
     this.responsesRequestMessages.clear();
     this.responsesRequestConversationIds.clear();
     this.responsesHistoryByResponseId.clear();
@@ -5734,32 +6335,40 @@ var OpenAIMessagesToChatPlugin = definePlugin(class {
     }
     return null;
   }
-  persistResponsesStateFromStream(ctx) {
-    const streamState = ctx.streamState.get("responses_stream_state");
-    if (!streamState) {
+  persistResponsesStateFromResult(requestId, response) {
+    if (response.status === "failed" || !Array.isArray(response.output))
       return;
-    }
-    const baseMessages = this.responsesRequestMessages.get(ctx.requestId) ?? [];
-    const conversationId = this.responsesRequestConversationIds.get(ctx.requestId);
-    let history = baseMessages;
-    if (streamState.messageText.length > 0 || streamState.toolCalls.length > 0) {
-      const assistantMessage = {
-        role: "assistant",
-        content: streamState.messageText.length > 0 ? streamState.messageText : null
-      };
-      if (streamState.toolCalls.length > 0) {
-        assistantMessage.tool_calls = streamState.toolCalls.map((toolCall) => ({
-          id: toolCall.id,
-          type: "function",
-          function: {
-            name: toolCall.name,
-            arguments: toolCall.arguments
-          }
-        }));
-      }
-      history = [...baseMessages, assistantMessage];
-    }
-    this.storeResponsesState(streamState.responseId, history, conversationId);
+    const assistant = { role: "assistant", content: null };
+    const text = [];
+    const reasoning = [];
+    const tools = [];
+    for (const item of response.output) {
+      if (!isRecord4(item))
+        continue;
+      if (item.type === "message" && Array.isArray(item.content)) {
+        for (const part of item.content) {
+          if (isRecord4(part) && part.type === "output_text" && typeof part.text === "string")
+            text.push(part.text);
+          if (isRecord4(part) && part.type === "refusal" && typeof part.refusal === "string")
+            assistant.refusal = part.refusal;
+        }
+      } else if (item.type === "function_call") {
+        tools.push({ id: item.call_id, type: "function", function: { name: item.name, arguments: item.arguments } });
+      } else if (item.type === "reasoning" && Array.isArray(item.summary)) {
+        for (const part of item.summary)
+          if (isRecord4(part) && typeof part.text === "string")
+            reasoning.push(part.text);
+      }
+    }
+    if (text.length)
+      assistant.content = text.join("");
+    if (tools.length)
+      assistant.tool_calls = tools;
+    if (reasoning.length)
+      assistant.reasoning_content = reasoning.join("");
+    const base = this.responsesRequestMessages.get(requestId) ?? [];
+    const history = text.length || tools.length || reasoning.length || assistant.refusal ? [...base, assistant] : base;
+    this.storeResponsesState(String(response.id), history, this.responsesRequestConversationIds.get(requestId));
   }
   storeResponsesState(responseId, history, conversationId) {
     const normalizedResponseId = this.normalizeNonEmptyString(responseId);
@@ -5887,500 +6496,41 @@ var OpenAIMessagesToChatPlugin = definePlugin(class {
     }
     return { message: rawMessage, changed: false };
   }
-  convertChatCompletionToResponsesPayload(payload) {
-    if (payload.object === "response") {
+  convertChatCompletionToResponsesPayload(payload, requestModel) {
+    if (payload.object === "response")
       return payload;
-    }
-    if (!Array.isArray(payload.choices)) {
-      return null;
-    }
-    const choices = payload.choices.filter((choice) => isRecord4(choice) && isRecord4(choice.message));
-    if (choices.length === 0) {
-      return null;
-    }
-    const responseId = this.toResponsesId(payload.id);
-    const createdAt = typeof payload.created === "number" ? payload.created : Math.floor(Date.now() / 1000);
-    const model = typeof payload.model === "string" ? payload.model : "";
-    const output = [];
-    const finishReasons = [];
-    for (let choiceIndex = 0;choiceIndex < choices.length; choiceIndex += 1) {
-      const choice = choices[choiceIndex];
-      const message = choice.message;
-      const content = this.normalizeChatMessageContentToResponseOutputText(message.content);
-      const messageId = choices.length === 1 ? `${responseId}_msg` : `${responseId}_msg_${choiceIndex}`;
-      const messageContent = content ? [
-        {
-          type: "output_text",
-          text: content,
-          annotations: []
-        }
-      ] : [];
-      output.push({
-        id: messageId,
-        type: "message",
-        role: "assistant",
-        status: "completed",
-        content: messageContent
-      });
-      const toolCalls = this.normalizeToolCalls(message.tool_calls) ?? [];
-      for (let toolCallIndex = 0;toolCallIndex < toolCalls.length; toolCallIndex += 1) {
-        const toolCall = toolCalls[toolCallIndex];
-        const toolFunction = isRecord4(toolCall.function) ? toolCall.function : undefined;
-        const toolCallId = typeof toolCall.id === "string" && toolCall.id.trim().length > 0 ? toolCall.id.trim() : `${responseId}_choice_${choiceIndex}_call_${toolCallIndex}`;
-        const argumentsPayload = typeof toolFunction?.arguments === "string" ? toolFunction.arguments : JSON.stringify(toolFunction?.arguments ?? {});
-        output.push({
-          id: toolCallId,
-          type: "function_call",
-          call_id: toolCallId,
-          name: typeof toolFunction?.name === "string" ? toolFunction.name : "",
-          arguments: argumentsPayload,
-          status: "completed"
-        });
-      }
-      if (typeof choice.finish_reason === "string" && choice.finish_reason.length > 0) {
-        finishReasons.push(choice.finish_reason);
-      }
-    }
-    const usage = isRecord4(payload.usage) ? payload.usage : {};
-    const terminal = this.aggregateTerminalFromFinishReasons(finishReasons);
-    const converted = {
-      id: responseId,
-      object: "response",
-      created_at: createdAt,
-      model,
-      status: this.terminalStatusFromType(terminal.type),
-      output,
-      usage: {
-        input_tokens: typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0,
-        output_tokens: typeof usage.completion_tokens === "number" ? usage.completion_tokens : 0,
-        total_tokens: typeof usage.total_tokens === "number" ? usage.total_tokens : (typeof usage.prompt_tokens === "number" ? usage.prompt_tokens : 0) + (typeof usage.completion_tokens === "number" ? usage.completion_tokens : 0)
-      }
-    };
-    if (terminal.type === "response.incomplete") {
-      converted.incomplete_details = {
-        reason: terminal.reason
-      };
-    }
-    if (terminal.type === "response.failed") {
-      converted.error = {
-        code: "completion_terminated",
-        message: terminal.reason
-      };
-    }
-    if (finishReasons.length > 0) {
-      converted.metadata = {
-        finish_reason: finishReasons[0],
-        finish_reasons: finishReasons
-      };
-    }
-    return converted;
-  }
-  convertChatCompletionChunkToResponsesEvents(chunk, ctx) {
-    if (!isRecord4(chunk) || !Array.isArray(chunk.choices)) {
-      return [];
-    }
-    const state = this.getOrCreateResponsesStreamState(chunk, ctx.streamState);
-    const events = [];
-    if (ctx.streamState.get("responses_stream_started") !== true) {
-      events.push({
-        type: "response.created",
-        response: {
-          id: state.responseId,
-          object: "response",
-          created_at: state.createdAt,
-          model: state.model,
-          status: "in_progress",
-          output: []
-        }
-      });
-      events.push({
-        type: "response.in_progress",
-        response: {
-          id: state.responseId,
-          object: "response",
-          created_at: state.createdAt,
-          model: state.model,
-          status: "in_progress",
-          output: []
-        }
-      });
-      events.push({
-        type: "response.output_item.added",
-        response_id: state.responseId,
-        output_index: 0,
-        item: {
-          id: state.messageId,
-          type: "message",
-          role: "assistant",
-          status: "in_progress",
-          content: []
-        }
-      });
-      ctx.streamState.set("responses_stream_started", true);
-    }
-    for (const choice of chunk.choices) {
-      if (!isRecord4(choice)) {
-        continue;
-      }
-      const delta = isRecord4(choice.delta) ? choice.delta : undefined;
-      if (delta) {
-        if (typeof delta.content === "string" && delta.content.length > 0) {
-          if (!state.hasTextContentPart) {
-            events.push({
-              type: "response.content_part.added",
-              response_id: state.responseId,
-              item_id: state.messageId,
-              output_index: 0,
-              content_index: 0,
-              part: {
-                type: "output_text",
-                text: "",
-                annotations: []
-              }
-            });
-            state.hasTextContentPart = true;
-          }
-          state.messageText += delta.content;
-          events.push({
-            type: "response.output_text.delta",
-            response_id: state.responseId,
-            item_id: state.messageId,
-            output_index: 0,
-            content_index: 0,
-            delta: delta.content
-          });
-        }
-        if (Array.isArray(delta.tool_calls)) {
-          for (const rawToolCall of delta.tool_calls) {
-            if (!isRecord4(rawToolCall)) {
-              continue;
-            }
-            const toolCallIndex = typeof rawToolCall.index === "number" ? rawToolCall.index : state.toolCalls.length;
-            const functionData = isRecord4(rawToolCall.function) ? rawToolCall.function : {};
-            const idFromDelta = typeof rawToolCall.id === "string" && rawToolCall.id.trim().length > 0 ? rawToolCall.id.trim() : undefined;
-            const existingId = state.toolCallIndexToId.get(toolCallIndex);
-            const toolCallId = existingId ?? idFromDelta ?? `${state.responseId}_call_${toolCallIndex}`;
-            let toolCall = state.toolCalls.find((item) => item.id === toolCallId);
-            const firstSeen = !toolCall;
-            if (!toolCall) {
-              toolCall = {
-                id: toolCallId,
-                name: "",
-                arguments: ""
-              };
-              state.toolCalls.push(toolCall);
-              state.toolCallIndexToId.set(toolCallIndex, toolCallId);
-            }
-            if (typeof functionData.name === "string" && functionData.name.length > 0) {
-              toolCall.name = functionData.name;
-            }
-            if (firstSeen) {
-              events.push({
-                type: "response.output_item.added",
-                response_id: state.responseId,
-                output_index: state.toolCalls.length,
-                item: {
-                  id: toolCall.id,
-                  type: "function_call",
-                  call_id: toolCall.id,
-                  name: toolCall.name,
-                  arguments: "",
-                  status: "in_progress"
-                }
-              });
-            }
-            if (typeof functionData.arguments === "string" && functionData.arguments.length > 0) {
-              toolCall.arguments += functionData.arguments;
-              const toolOutputIndex = state.toolCalls.indexOf(toolCall) + 1;
-              events.push({
-                type: "response.function_call_arguments.delta",
-                response_id: state.responseId,
-                item_id: toolCall.id,
-                output_index: toolOutputIndex,
-                delta: functionData.arguments
-              });
-            }
-          }
-        }
-      }
-      if (typeof choice.finish_reason === "string" && choice.finish_reason.length > 0) {
-        state.finishReason = choice.finish_reason;
-        const terminal = this.mapFinishReasonToTerminalEvent(choice.finish_reason);
-        if (terminal) {
-          state.terminalEventType = terminal.type;
-          state.terminalReason = terminal.reason;
-        }
-      }
-    }
-    if (isRecord4(chunk.usage)) {
-      state.usage = {
-        input_tokens: typeof chunk.usage.prompt_tokens === "number" ? chunk.usage.prompt_tokens : state.usage.input_tokens,
-        output_tokens: typeof chunk.usage.completion_tokens === "number" ? chunk.usage.completion_tokens : state.usage.output_tokens,
-        total_tokens: typeof chunk.usage.total_tokens === "number" ? chunk.usage.total_tokens : state.usage.total_tokens
-      };
-    }
-    return events;
-  }
-  buildResponsesStreamCompletionEvents(ctx) {
-    const state = ctx.streamState.get("responses_stream_state");
-    if (!state) {
-      return [];
-    }
-    const events = [];
-    const output = [];
-    const messageContentPart = {
-      type: "output_text",
-      text: state.messageText,
-      annotations: []
-    };
-    const messageContent = state.hasTextContentPart ? [messageContentPart] : [];
-    const messageItem = {
-      id: state.messageId,
-      type: "message",
-      role: "assistant",
-      status: "completed",
-      content: messageContent
-    };
-    output.push(messageItem);
-    if (state.hasTextContentPart) {
-      events.push({
-        type: "response.output_text.done",
-        response_id: state.responseId,
-        item_id: state.messageId,
-        output_index: 0,
-        content_index: 0,
-        text: state.messageText
-      });
-      events.push({
-        type: "response.content_part.done",
-        response_id: state.responseId,
-        item_id: state.messageId,
-        output_index: 0,
-        content_index: 0,
-        part: messageContentPart
-      });
-    }
-    events.push({
-      type: "response.output_item.done",
-      response_id: state.responseId,
-      output_index: 0,
-      item: messageItem
+    const model = typeof payload.model === "string" ? payload.model : requestModel;
+    if (!Array.isArray(payload.choices) || payload.choices.length === 0) {
+      return encodeResponsesResult(payload, "chat_completions", model);
+    }
+    const candidates = payload.choices.map((rawChoice) => {
+      if (!isRecord4(rawChoice) || !isRecord4(rawChoice.message)) {
+        return encodeResponsesResult({ ...payload, choices: [rawChoice] }, "chat_completions", model);
+      }
+      const message = { ...rawChoice.message, content: rawChoice.message.content ?? "" };
+      const toolCalls = this.normalizeToolCalls(message.tool_calls);
+      if (toolCalls !== undefined)
+        message.tool_calls = toolCalls;
+      return encodeResponsesResult({ ...payload, choices: [{ ...rawChoice, index: 0, message }] }, "chat_completions", model);
     });
-    for (const toolCall of state.toolCalls) {
-      const toolOutputIndex = output.length;
-      const toolItem = {
-        id: toolCall.id,
-        type: "function_call",
-        call_id: toolCall.id,
-        name: toolCall.name,
-        arguments: toolCall.arguments,
-        status: "completed"
-      };
-      events.push({
-        type: "response.function_call_arguments.done",
-        response_id: state.responseId,
-        item_id: toolCall.id,
-        output_index: toolOutputIndex,
-        arguments: toolCall.arguments
-      });
-      events.push({
-        type: "response.output_item.done",
-        response_id: state.responseId,
-        output_index: toolOutputIndex,
-        item: toolItem
-      });
-      output.push(toolItem);
-    }
-    const normalizedUsage = {
-      input_tokens: state.usage.input_tokens,
-      output_tokens: state.usage.output_tokens,
-      total_tokens: state.usage.total_tokens > 0 ? state.usage.total_tokens : state.usage.input_tokens + state.usage.output_tokens
-    };
-    const terminal = this.resolveTerminalEvent(state);
-    const responsePayload = {
-      id: state.responseId,
-      object: "response",
-      created_at: state.createdAt,
-      model: state.model,
-      status: terminal.status,
-      output,
-      usage: normalizedUsage,
-      metadata: {
-        finish_reason: state.finishReason || terminal.reason
-      }
-    };
-    if (terminal.type === "response.incomplete") {
-      responsePayload.incomplete_details = {
-        reason: terminal.reason
-      };
+    const priority = (status) => status === "failed" ? 3 : status === "incomplete" ? 2 : 1;
+    const terminal = candidates.reduce((selected, candidate) => priority(candidate.status) > priority(selected.status) ? candidate : selected);
+    const converted = { ...terminal, id: candidates[0].id, output: candidates.flatMap((candidate) => candidate.output) };
+    const finishReasons = payload.choices.filter(isRecord4).map((choice) => choice.finish_reason);
+    converted.metadata = { finish_reason: finishReasons[0], finish_reasons: finishReasons };
+    if (converted.status === "failed" && isRecord4(converted.error)) {
+      converted.error = { ...converted.error, code: "completion_terminated" };
     }
-    if (terminal.type === "response.failed") {
-      responsePayload.error = {
-        code: "stream_terminated",
-        message: terminal.reason
-      };
-    }
-    events.push({
-      type: terminal.type,
-      response: responsePayload
-    });
-    return events;
+    return converted;
   }
-  getOrCreateResponsesStreamState(chunk, streamState) {
-    const existing = streamState.get("responses_stream_state");
-    if (existing) {
+  getResponsesEncoder(ctx, upstreamModel) {
+    const existing = ctx.streamState.get("responses_shared_encoder");
+    if (existing)
       return existing;
-    }
-    const responseId = this.toResponsesId(chunk.id);
-    const createdAt = typeof chunk.created === "number" ? chunk.created : Math.floor(Date.now() / 1000);
-    const model = typeof chunk.model === "string" ? chunk.model : "";
-    const created = {
-      responseId,
-      messageId: `${responseId}_msg`,
-      createdAt,
-      model,
-      messageText: "",
-      finishReason: "",
-      usage: {
-        input_tokens: 0,
-        output_tokens: 0,
-        total_tokens: 0
-      },
-      hasTextContentPart: false,
-      toolCalls: [],
-      toolCallIndexToId: new Map,
-      terminalEventType: null,
-      terminalReason: ""
-    };
-    streamState.set("responses_stream_state", created);
-    return created;
-  }
-  resolveTerminalEvent(state) {
-    if (state.terminalEventType) {
-      return {
-        type: state.terminalEventType,
-        status: this.terminalStatusFromType(state.terminalEventType),
-        reason: state.terminalReason || state.finishReason || (state.terminalEventType === "response.incomplete" ? "unknown" : "stop")
-      };
-    }
-    const mappedByFinishReason = this.mapFinishReasonToTerminalEvent(state.finishReason);
-    if (mappedByFinishReason) {
-      return {
-        type: mappedByFinishReason.type,
-        status: this.terminalStatusFromType(mappedByFinishReason.type),
-        reason: mappedByFinishReason.reason
-      };
-    }
-    if (state.messageText.length === 0 && state.toolCalls.length === 0) {
-      return {
-        type: "response.failed",
-        status: "failed",
-        reason: "empty_stream_output"
-      };
-    }
-    return {
-      type: "response.incomplete",
-      status: "incomplete",
-      reason: "unknown"
-    };
-  }
-  mapFinishReasonToTerminalEvent(finishReason) {
-    const normalizedFinishReason = finishReason.trim();
-    if (!normalizedFinishReason) {
-      return;
-    }
-    if (normalizedFinishReason === "stop" || normalizedFinishReason === "tool_calls") {
-      return {
-        type: "response.completed",
-        reason: normalizedFinishReason
-      };
-    }
-    if (normalizedFinishReason === "length") {
-      return {
-        type: "response.incomplete",
-        reason: "max_output_tokens"
-      };
-    }
-    if (normalizedFinishReason === "content_filter") {
-      return {
-        type: "response.incomplete",
-        reason: "content_filter"
-      };
-    }
-    if (normalizedFinishReason === "error") {
-      return {
-        type: "response.failed",
-        reason: "upstream_error"
-      };
-    }
-    return {
-      type: "response.completed",
-      reason: normalizedFinishReason
-    };
-  }
-  aggregateTerminalFromFinishReasons(finishReasons) {
-    let selectedTerminal;
-    let selectedPriority = -1;
-    for (const finishReason of finishReasons) {
-      const mapped = this.mapFinishReasonToTerminalEvent(finishReason);
-      if (!mapped) {
-        continue;
-      }
-      const priority = this.terminalPriority(mapped.type);
-      if (priority > selectedPriority) {
-        selectedTerminal = mapped;
-        selectedPriority = priority;
-      }
-    }
-    return selectedTerminal ?? {
-      type: "response.completed",
-      reason: "stop"
-    };
-  }
-  terminalPriority(type) {
-    if (type === "response.failed") {
-      return 3;
-    }
-    if (type === "response.incomplete") {
-      return 2;
-    }
-    return 1;
-  }
-  terminalStatusFromType(type) {
-    if (type === "response.completed") {
-      return "completed";
-    }
-    if (type === "response.incomplete") {
-      return "incomplete";
-    }
-    return "failed";
-  }
-  normalizeChatMessageContentToResponseOutputText(content) {
-    if (typeof content === "string") {
-      return content;
-    }
-    if (!Array.isArray(content)) {
-      return "";
-    }
-    const textSegments = [];
-    for (const item of content) {
-      if (!isRecord4(item)) {
-        continue;
-      }
-      if (typeof item.text === "string") {
-        textSegments.push(item.text);
-      }
-    }
-    return textSegments.join("");
-  }
-  toResponsesId(rawId) {
-    if (typeof rawId !== "string" || rawId.trim().length === 0) {
-      return `resp_${Date.now()}`;
-    }
-    if (rawId.startsWith("resp_")) {
-      return rawId;
-    }
-    return `resp_${rawId}`;
+    const model = typeof upstreamModel === "string" ? upstreamModel : this.responsesRequestModels.get(ctx.requestId) ?? "";
+    const encoder = new ResponsesEventEncoder("chat_completions", model);
+    ctx.streamState.set("responses_shared_encoder", encoder);
+    return encoder;
   }
   normalizeAssistantToolCallReasoningContent(body) {
     const rawMessages = body.messages;
@@ -6494,4 +6644,4 @@ export {
   server_default as default
 };
 
-//# debugId=362FF24FE66CC08264756E2164756E21
+//# debugId=50667B5F9ABB6B8964756E2164756E21