@dbx-tools/shared-model 0.6.73 → 0.6.75

package/lib/src/openai-responses.d.ts

@@ -32,6 +32,9 @@
  *   - {@link sanitizeOpenResponsesInput} rewrites `output_*` content part types
  *     in `input` to `input_*`, and drops Claude thinking / reasoning blocks
  *     that Open Responses rejects on replay (`redacted_thinking`, …).
+ *   - {@link repairTrailingAssistantInput} drops a trailing assistant turn that
+ *     Anthropic reads as a prefill request, the Responses-side counterpart to
+ *     `@dbx-tools/appkit-mastra`'s `repairAssistantPrefill`.
  *
  * Only the surface real clients exercise is translated; unknown fields are
  * ignored rather than rejected, so a newer client degrades instead of breaking.
@@ -167,9 +170,41 @@ export declare const REASONING_TYPES: ReadonlySet<string>;
  * Returns a shallow copy when anything changes; otherwise the input body.
  */
 export declare function sanitizeOpenResponsesInput(body: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Drop trailing assistant turns so the transcript ends on something Anthropic
+ * will continue from.
+ *
+ * Databricks Open Responses rejects a body whose last item is an assistant
+ * message with `"This model does not support assistant message prefill. The
+ * conversation must end with a user message."` (the upstream Bedrock route
+ * disallows prefill). Two ways a real client hits it:
+ *
+ * 1. The client replays its own last answer. The Codex CLI does this when a turn
+ *    ends without a tool call and the next request carries the full transcript.
+ * 2. {@link sanitizeOpenResponsesInput} CREATES the shape: a turn that ended in a
+ *    `reasoning` item is stripped for replay compatibility, promoting the
+ *    assistant message before it to last. Running this repair after that strip
+ *    is what keeps one fix from causing the other failure.
+ *
+ * Dropping is correct rather than lossy: a trailing assistant turn carries text
+ * the model itself just produced, so it is context the provider does not need
+ * repeated in order to continue. Appending a synthetic `"Continue."` user turn
+ * also satisfies the provider, but it puts words in the user's mouth that show
+ * up in the model's context, so this takes the honest option.
+ *
+ * A trailing `function_call` is left ALONE. It is also an assistant-side item,
+ * but Anthropic rejects an unanswered `tool_use` on a different rule
+ * (`tool_use` ids without `tool_result`), and dropping it would silently discard
+ * a tool call the client is about to answer. That is the client's bug to fix,
+ * not something to paper over here.
+ *
+ * Returns a shallow copy when anything changes; otherwise the input body.
+ */
+export declare function repairTrailingAssistantInput(body: Record<string, unknown>): Record<string, unknown>;
 /**
  * Full Open Responses request sanitizer: strip non-`function` tools, rewrite
- * `output_*` content parts, and drop thinking / reasoning blocks. Safe no-op
+ * `output_*` content parts, drop thinking / reasoning blocks, and drop a
+ * trailing assistant turn the provider would read as a prefill. Safe no-op
  * when nothing needs changing.
  */
 export declare function sanitizeOpenResponsesRequest(body: Record<string, unknown>): Record<string, unknown>;

package/lib/src/openai-responses.js

@@ -32,6 +32,9 @@
  *   - {@link sanitizeOpenResponsesInput} rewrites `output_*` content part types
  *     in `input` to `input_*`, and drops Claude thinking / reasoning blocks
  *     that Open Responses rejects on replay (`redacted_thinking`, …).
+ *   - {@link repairTrailingAssistantInput} drops a trailing assistant turn that
+ *     Anthropic reads as a prefill request, the Responses-side counterpart to
+ *     `@dbx-tools/appkit-mastra`'s `repairAssistantPrefill`.
  *
  * Only the surface real clients exercise is translated; unknown fields are
  * ignored rather than rejected, so a newer client degrades instead of breaking.
@@ -675,12 +678,73 @@ export function sanitizeOpenResponsesInput(body) {
     }
     return changed ? { ...body, input } : body;
 }
+/**
+ * Drop trailing assistant turns so the transcript ends on something Anthropic
+ * will continue from.
+ *
+ * Databricks Open Responses rejects a body whose last item is an assistant
+ * message with `"This model does not support assistant message prefill. The
+ * conversation must end with a user message."` (the upstream Bedrock route
+ * disallows prefill). Two ways a real client hits it:
+ *
+ * 1. The client replays its own last answer. The Codex CLI does this when a turn
+ *    ends without a tool call and the next request carries the full transcript.
+ * 2. {@link sanitizeOpenResponsesInput} CREATES the shape: a turn that ended in a
+ *    `reasoning` item is stripped for replay compatibility, promoting the
+ *    assistant message before it to last. Running this repair after that strip
+ *    is what keeps one fix from causing the other failure.
+ *
+ * Dropping is correct rather than lossy: a trailing assistant turn carries text
+ * the model itself just produced, so it is context the provider does not need
+ * repeated in order to continue. Appending a synthetic `"Continue."` user turn
+ * also satisfies the provider, but it puts words in the user's mouth that show
+ * up in the model's context, so this takes the honest option.
+ *
+ * A trailing `function_call` is left ALONE. It is also an assistant-side item,
+ * but Anthropic rejects an unanswered `tool_use` on a different rule
+ * (`tool_use` ids without `tool_result`), and dropping it would silently discard
+ * a tool call the client is about to answer. That is the client's bug to fix,
+ * not something to paper over here.
+ *
+ * Returns a shallow copy when anything changes; otherwise the input body.
+ */
+export function repairTrailingAssistantInput(body) {
+    if (!Array.isArray(body.input) || body.input.length === 0)
+        return body;
+    const input = [...body.input];
+    let changed = false;
+    // A loop, not one check: stripping reasoning can leave several assistant
+    // turns in a row at the end.
+    while (input.length > 0 && isAssistantMessageItem(input[input.length - 1])) {
+        input.pop();
+        changed = true;
+    }
+    // Never send an empty `input`: an all-assistant transcript is not something
+    // this repair can rescue, so leave the body for the provider to reject with
+    // its own message rather than inventing a request.
+    if (!changed || input.length === 0)
+        return body;
+    return { ...body, input };
+}
+/**
+ * Whether an `input` item is an assistant MESSAGE (the prefill trigger), as
+ * opposed to a `function_call` or any other assistant-side item type.
+ */
+function isAssistantMessageItem(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const item = value;
+    if (item.role !== "assistant")
+        return false;
+    return item.type === undefined || item.type === "message";
+}
 /**
  * Full Open Responses request sanitizer: strip non-`function` tools, rewrite
- * `output_*` content parts, and drop thinking / reasoning blocks. Safe no-op
+ * `output_*` content parts, drop thinking / reasoning blocks, and drop a
+ * trailing assistant turn the provider would read as a prefill. Safe no-op
  * when nothing needs changing.
  */
 export function sanitizeOpenResponsesRequest(body) {
-    return sanitizeOpenResponsesInput(sanitizeResponsesTools(body));
+    return repairTrailingAssistantInput(sanitizeOpenResponsesInput(sanitizeResponsesTools(body)));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"openai-responses.js","sourceRoot":"","sources":["../../src/openai-responses.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * OpenAI Responses API <-> Chat Completions translation.\n *\n * Some clients speak only the Responses API (`POST /v1/responses`) - the Codex\n * CLI is the motivating one. Databricks now also exposes native Responses\n * surfaces (`/serving-endpoints/responses` and `/serving-endpoints/open-responses`),\n * while most endpoints still speak Chat Completions at `/invocations`. This\n * module bridges the two, in both directions:\n *\n *   - {@link responsesToChat} lowers a Responses request body to a chat\n *     completions body (instructions -> system message, typed `input` items ->\n *     `messages`, `tools`/`tool_choice` carried through, function-call outputs\n *     folded back into the transcript).\n *   - {@link chatToResponsesRequest} raises a chat-completions request into a\n *     Responses request (the inverse of {@link responsesToChat}), for routing a\n *     chat client at a Responses-only model like Codex.\n *   - {@link chatToResponse} lifts a non-streaming chat completion back into a\n *     Responses `response` object.\n *   - {@link responseToChatCompletion} lifts a native Responses `response`\n *     back into a chat-completions body (the inverse of {@link chatToResponse}).\n *   - {@link createResponsesStreamTranslator} lifts a streaming chat completion\n *     (an OpenAI SSE `chat.completion.chunk` stream) into the Responses SSE\n *     event stream those clients consume (`response.created`,\n *     `response.output_text.delta`, function-call argument deltas,\n *     `response.completed`).\n *   - {@link readResponsesOutput} reads the other direction: pull the answer\n *     text and citations out of a `response` object returned by an endpoint\n *     that speaks Responses natively (the Databricks native web-search tool).\n *   - {@link sanitizeResponsesTools} keeps only `function` tools on a Responses\n *     request body (for `/open-responses` / Anthropic, which reject Codex\n *     built-ins like `web_search`).\n *   - {@link sanitizeOpenResponsesInput} rewrites `output_*` content part types\n *     in `input` to `input_*`, and drops Claude thinking / reasoning blocks\n *     that Open Responses rejects on replay (`redacted_thinking`, …).\n *\n * Only the surface real clients exercise is translated; unknown fields are\n * ignored rather than rejected, so a newer client degrades instead of breaking.\n *\n * Browser-safe: pure functions over plain JSON, no transport and no Node\n * built-ins, so the same translation runs in a proxy, a server route, or a test.\n *\n * @module\n */\n\nimport { string } from \"@dbx-tools/shared-core\";\n\nimport { type ChatMessage, type ChatToolCall, chatContentToText } from \"./openai-chat.ts\";\n\n/**\n * Lower a Responses request body to a chat-completions body. Returns the chat\n * body plus whether the caller asked for streaming (the server needs it to pick\n * the upstream `accept` header and the translation path).\n */\nexport function responsesToChat(body: Record<string, unknown>): {\n  chat: Record<string, unknown>;\n  stream: boolean;\n} {\n  const messages: ChatMessage[] = [];\n\n  // `instructions` becomes the leading system message.\n  if (typeof body.instructions === \"string\" && body.instructions.length > 0) {\n    messages.push({ role: \"system\", content: body.instructions });\n  }\n\n  // `input` is an array of typed items: messages, function_call, and\n  // function_call_output. Fold each into the chat transcript.\n  const input = Array.isArray(body.input) ? body.input : [];\n  for (const raw of input) {\n    if (!raw || typeof raw !== \"object\") continue;\n    const item = raw as Record<string, unknown>;\n    const type = item.type;\n\n    if (type === \"function_call\") {\n      // A prior tool call the model made; re-attach it to an assistant turn.\n      messages.push({\n        role: \"assistant\",\n        content: null,\n        tool_calls: [toChatToolCall(item)],\n      });\n      continue;\n    }\n\n    if (type === \"function_call_output\") {\n      // The tool's result, keyed back to the call it answers.\n      messages.push({\n        role: \"tool\",\n        tool_call_id: String(item.call_id ?? item.id ?? \"\"),\n        content: typeof item.output === \"string\" ? item.output : chatContentToText(item.output),\n      });\n      continue;\n    }\n\n    // Default: a message item with a role and typed content.\n    const role = typeof item.role === \"string\" ? item.role : \"user\";\n    // Chat has no \"developer\" role; treat it as system (its intent here).\n    const chatRole = role === \"developer\" ? \"system\" : role;\n    messages.push({ role: chatRole, content: chatContentToText(item.content) });\n  }\n\n  const chat: Record<string, unknown> = {\n    model: body.model,\n    messages,\n    stream: body.stream === true,\n  };\n\n  // Carry through function-calling config when present. Responses function\n  // tools are FLAT (`{type:\"function\", name, description, parameters}`); chat\n  // wants them NESTED (`{type:\"function\", function:{name, …}}`). Clients also\n  // send built-in tool types (local_shell, web_search, …) that Databricks chat\n  // rejects (\"Missing 'function' in the tool specification\"), so we translate\n  // only function tools and drop the rest.\n  if (Array.isArray(body.tools) && body.tools.length > 0) {\n    const chatTools = body.tools\n      .map(toChatTool)\n      .filter((t): t is Record<string, unknown> => t !== undefined);\n    if (chatTools.length > 0) {\n      chat.tools = chatTools;\n      if (body.tool_choice !== undefined) chat.tool_choice = body.tool_choice;\n      // NOTE: do NOT forward `parallel_tool_calls`. Clients send it, but\n      // Databricks Model Serving's chat API rejects unknown fields\n      // (\"parallel_tool_calls: Extra inputs are not permitted\"), which would\n      // fail the whole turn. Drop it.\n    }\n  }\n\n  return { chat, stream: body.stream === true };\n}\n\n/**\n * Raise a chat-completions request into a Responses request body. Inverse of\n * {@link responsesToChat}: used when a chat client hits a Responses-only\n * Databricks model (e.g. Codex) so the proxy can POST to\n * `/serving-endpoints/responses` without the client knowing.\n */\nexport function chatToResponsesRequest(body: Record<string, unknown>): {\n  responses: Record<string, unknown>;\n  stream: boolean;\n} {\n  const messages = Array.isArray(body.messages) ? body.messages : [];\n  const input: unknown[] = [];\n  let instructions: string | undefined;\n\n  for (const raw of messages) {\n    if (!raw || typeof raw !== \"object\") continue;\n    const message = raw as Record<string, unknown>;\n    const role = typeof message.role === \"string\" ? message.role : \"user\";\n\n    // Leading system / developer messages become top-level `instructions`.\n    if (\n      (role === \"system\" || role === \"developer\") &&\n      instructions === undefined &&\n      input.length === 0\n    ) {\n      const text = chatContentToText(message.content);\n      if (text) instructions = text;\n      continue;\n    }\n\n    if (role === \"tool\") {\n      input.push({\n        type: \"function_call_output\",\n        call_id: String(message.tool_call_id ?? \"\"),\n        output: chatContentToText(message.content),\n      });\n      continue;\n    }\n\n    if (\n      role === \"assistant\" &&\n      Array.isArray(message.tool_calls) &&\n      message.tool_calls.length > 0\n    ) {\n      for (const rawCall of message.tool_calls) {\n        if (!rawCall || typeof rawCall !== \"object\") continue;\n        input.push(toFunctionCallItem(rawCall as Record<string, unknown>));\n      }\n      const text = chatContentToText(message.content);\n      if (text) {\n        input.push({ type: \"message\", role: \"assistant\", content: text });\n      }\n      continue;\n    }\n\n    input.push({\n      type: \"message\",\n      role,\n      content: chatContentToText(message.content),\n    });\n  }\n\n  const responses: Record<string, unknown> = {\n    model: body.model,\n    input,\n    stream: body.stream === true,\n  };\n  if (instructions) responses.instructions = instructions;\n\n  // Chat tools are nested (`function: { name, … }`); Responses wants them flat.\n  if (Array.isArray(body.tools) && body.tools.length > 0) {\n    const tools = body.tools\n      .map(toResponsesTool)\n      .filter((t): t is Record<string, unknown> => t !== undefined);\n    if (tools.length > 0) {\n      responses.tools = tools;\n      if (body.tool_choice !== undefined) responses.tool_choice = body.tool_choice;\n    }\n  }\n\n  // Prefer Responses' max_output_tokens naming; fall back from chat max_tokens.\n  if (typeof body.max_output_tokens === \"number\") {\n    responses.max_output_tokens = body.max_output_tokens;\n  } else if (typeof body.max_tokens === \"number\") {\n    responses.max_output_tokens = body.max_tokens;\n  }\n\n  return { responses, stream: body.stream === true };\n}\n\n/** Lift a non-streaming chat completion JSON into a Responses `response` object. */\nexport function chatToResponse(chat: Record<string, unknown>, model: string): unknown {\n  const choices = Array.isArray(chat.choices) ? chat.choices : [];\n  const first = (choices[0] ?? {}) as Record<string, unknown>;\n  const message = (first.message ?? {}) as Record<string, unknown>;\n  const output: unknown[] = [];\n\n  const text = typeof message.content === \"string\" ? message.content : \"\";\n  if (text) {\n    output.push({\n      type: \"message\",\n      role: \"assistant\",\n      content: [{ type: \"output_text\", text }],\n    });\n  }\n\n  // Surface any tool calls as Responses `function_call` output items.\n  const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];\n  for (const raw of toolCalls) {\n    output.push(toFunctionCallItem(raw as Record<string, unknown>));\n  }\n\n  const usage = (chat.usage ?? {}) as Record<string, unknown>;\n  return {\n    id: String(chat.id ?? \"resp\"),\n    object: \"response\",\n    created_at: typeof chat.created === \"number\" ? chat.created : 0,\n    model,\n    status: \"completed\",\n    output,\n    usage: {\n      input_tokens: Number(usage.prompt_tokens ?? 0),\n      output_tokens: Number(usage.completion_tokens ?? 0),\n      total_tokens: Number(usage.total_tokens ?? 0),\n    },\n  };\n}\n\n/**\n * Lift a native Responses `response` object into a chat-completions body.\n * Inverse of {@link chatToResponse}: used after a Responses-only upstream call\n * when the client spoke Chat Completions.\n */\nexport function responseToChatCompletion(\n  response: Record<string, unknown>,\n  model: string,\n): Record<string, unknown> {\n  const { text } = readResponsesOutput(response);\n  const toolCalls: unknown[] = [];\n  const output = Array.isArray(response.output) ? response.output : [];\n  for (const raw of output) {\n    if (!raw || typeof raw !== \"object\") continue;\n    const item = raw as Record<string, unknown>;\n    if (item.type !== \"function_call\") continue;\n    toolCalls.push(toChatToolCall(item));\n  }\n\n  const message: Record<string, unknown> = {\n    role: \"assistant\",\n    content: text || null,\n  };\n  if (toolCalls.length > 0) message.tool_calls = toolCalls;\n\n  const usage = (response.usage ?? {}) as Record<string, unknown>;\n  return {\n    id: String(response.id ?? \"chatcmpl\"),\n    object: \"chat.completion\",\n    created: typeof response.created_at === \"number\" ? response.created_at : 0,\n    model,\n    choices: [\n      {\n        index: 0,\n        message,\n        finish_reason: toolCalls.length > 0 ? \"tool_calls\" : \"stop\",\n      },\n    ],\n    usage: {\n      prompt_tokens: Number(usage.input_tokens ?? 0),\n      completion_tokens: Number(usage.output_tokens ?? 0),\n      total_tokens: Number(usage.total_tokens ?? 0),\n    },\n  };\n}\n\n/**\n * A tool call's `arguments` JSON. Both wires carry it as an unparsed string;\n * anything else (absent, an already-parsed object) becomes an empty literal so\n * the receiving side always has valid JSON to parse.\n */\nfunction callArguments(value: unknown): string {\n  return typeof value === \"string\" ? value : \"{}\";\n}\n\n/**\n * The Responses `function_call` item for a tool call in either spelling: a chat\n * `tool_calls[]` entry (`{id, function:{name, arguments}}`) or an item that is\n * already flat.\n */\nfunction toFunctionCallItem(call: Record<string, unknown>): Record<string, unknown> {\n  const fn = (call.function ?? call) as Record<string, unknown>;\n  return {\n    type: \"function_call\",\n    call_id: String(call.call_id ?? call.id ?? \"\"),\n    name: String(fn.name ?? \"\"),\n    arguments: callArguments(fn.arguments),\n  };\n}\n\n/** The chat `tool_calls[]` entry for a Responses `function_call` item. */\nfunction toChatToolCall(item: Record<string, unknown>): ChatToolCall {\n  return {\n    id: String(item.call_id ?? item.id ?? \"\"),\n    type: \"function\",\n    function: {\n      name: String(item.name ?? \"\"),\n      arguments: callArguments(item.arguments),\n    },\n  };\n}\n\n/**\n * The chat-nested spelling (`{type:\"function\", function:{name, …}}`) of a tool\n * spec, or `undefined` for a built-in Responses tool (`web_search`,\n * `local_shell`, …) that chat cannot express and Databricks rejects.\n */\nfunction toChatTool(value: unknown): Record<string, unknown> | undefined {\n  if (!value || typeof value !== \"object\") return undefined;\n  const tool = value as Record<string, unknown>;\n  if (tool.type !== \"function\") return undefined;\n  if (tool.function && typeof tool.function === \"object\") return tool; // already nested\n  if (typeof tool.name !== \"string\") return undefined;\n  return {\n    type: \"function\",\n    function: {\n      name: tool.name,\n      ...(tool.description ? { description: tool.description } : {}),\n      ...(tool.parameters ? { parameters: tool.parameters } : {}),\n    },\n  };\n}\n\n/**\n * The flat Responses spelling (`{type:\"function\", name, …}`) of a tool spec.\n * Inverse of {@link toChatTool}; non-function tools are dropped the same way.\n */\nfunction toResponsesTool(value: unknown): Record<string, unknown> | undefined {\n  if (!value || typeof value !== \"object\") return undefined;\n  const tool = value as Record<string, unknown>;\n  if (tool.type !== \"function\") return undefined;\n  if (tool.function && typeof tool.function === \"object\") {\n    const fn = tool.function as Record<string, unknown>;\n    return {\n      type: \"function\",\n      name: fn.name,\n      ...(fn.description ? { description: fn.description } : {}),\n      ...(fn.parameters ? { parameters: fn.parameters } : {}),\n    };\n  }\n  return typeof tool.name === \"string\" ? tool : undefined; // already flat\n}\n\n/** One Server-Sent Event, ready to write to the client. */\nfunction sse(event: string, data: unknown): string {\n  return `event: ${event}\\ndata: ${JSON.stringify(data)}\\n\\n`;\n}\n\n/**\n * Incremental chat-chunk -> Responses-SSE translator. `feed` and `finish` both\n * return the SSE bytes to forward, or `\"\"` when a chunk produced no event.\n */\nexport interface ResponsesStreamTranslator {\n  /** Translate one upstream `chat.completion.chunk` object. */\n  feed(chunk: Record<string, unknown>): string;\n  /** Close any open items and emit `response.completed`. Call once, at end of stream. */\n  finish(): string;\n}\n\n/**\n * Translate an upstream chat-completions SSE stream into the Responses SSE\n * event stream a Responses client consumes.\n *\n * Upstream chunks are `chat.completion.chunk` objects whose `choices[0].delta`\n * carries incremental `content` (assistant text) and/or `tool_calls` (function\n * calls, streamed by `index` with partial `arguments`). We emit the Responses\n * lifecycle around them:\n *\n *   response.created\n *   -> per text run:  output_item.added → output_text.delta* → output_item.done\n *   -> per tool call: output_item.added → function_call_arguments.delta*\n *                       → function_call_arguments.done → output_item.done\n *   response.completed   (with the assembled final `response` object)\n *\n * The translator is intentionally tolerant: malformed/keepalive lines yield\n * nothing.\n */\nexport function createResponsesStreamTranslator(\n  model: string,\n  responseId: string,\n): ResponsesStreamTranslator {\n  let started = false;\n  let outputIndex = 0;\n\n  // Text run state: whether a message item is currently open, and its buffer.\n  let textOpen = false;\n  let textBuffer = \"\";\n  let textItemId = \"\";\n\n  // Tool-call state, keyed by the upstream `tool_calls[].index`.\n  interface ToolState {\n    outputIndex: number;\n    callId: string;\n    name: string;\n    args: string;\n  }\n  const tools = new Map<number, ToolState>();\n\n  const created = () =>\n    sse(\"response.created\", {\n      type: \"response.created\",\n      response: { id: responseId, object: \"response\", status: \"in_progress\", model, output: [] },\n    });\n\n  function openText(): string {\n    textOpen = true;\n    textItemId = `${responseId}-msg-${outputIndex}`;\n    const ev = sse(\"response.output_item.added\", {\n      type: \"response.output_item.added\",\n      output_index: outputIndex,\n      item: { id: textItemId, type: \"message\", role: \"assistant\", content: [] },\n    });\n    return ev;\n  }\n\n  function closeText(): string {\n    if (!textOpen) return \"\";\n    const item = {\n      id: textItemId,\n      type: \"message\",\n      role: \"assistant\",\n      content: [{ type: \"output_text\", text: textBuffer }],\n    };\n    const ev =\n      sse(\"response.output_text.done\", {\n        type: \"response.output_text.done\",\n        item_id: textItemId,\n        output_index: outputIndex,\n        content_index: 0,\n        text: textBuffer,\n      }) +\n      sse(\"response.output_item.done\", {\n        type: \"response.output_item.done\",\n        output_index: outputIndex,\n        item,\n      });\n    textOpen = false;\n    textBuffer = \"\";\n    outputIndex += 1;\n    return ev;\n  }\n\n  function feed(chunk: Record<string, unknown>): string {\n    let out = \"\";\n    if (!started) {\n      started = true;\n      out += created();\n    }\n    const choices = Array.isArray(chunk.choices) ? chunk.choices : [];\n    const choice = (choices[0] ?? {}) as Record<string, unknown>;\n    const delta = (choice.delta ?? {}) as Record<string, unknown>;\n\n    // Assistant text deltas.\n    if (typeof delta.content === \"string\" && delta.content.length > 0) {\n      if (!textOpen) out += openText();\n      textBuffer += delta.content;\n      out += sse(\"response.output_text.delta\", {\n        type: \"response.output_text.delta\",\n        item_id: textItemId,\n        output_index: outputIndex,\n        content_index: 0,\n        delta: delta.content,\n      });\n    }\n\n    // Tool-call deltas: each is keyed by `index`; `arguments` arrives in pieces.\n    const toolDeltas = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];\n    for (const rawTc of toolDeltas) {\n      const tc = rawTc as Record<string, unknown>;\n      const idx = Number(tc.index ?? 0);\n      const fn = (tc.function ?? {}) as Record<string, unknown>;\n      let state = tools.get(idx);\n      if (!state) {\n        // First fragment for this call: a text run (if open) must close first so\n        // output ordering stays monotonic, then we open a function_call item.\n        out += closeText();\n        state = {\n          outputIndex,\n          callId: String(tc.id ?? `${responseId}-call-${idx}`),\n          name: String(fn.name ?? \"\"),\n          args: \"\",\n        };\n        tools.set(idx, state);\n        out += sse(\"response.output_item.added\", {\n          type: \"response.output_item.added\",\n          output_index: state.outputIndex,\n          item: {\n            id: state.callId,\n            type: \"function_call\",\n            call_id: state.callId,\n            name: state.name,\n            arguments: \"\",\n          },\n        });\n        outputIndex += 1;\n      }\n      if (typeof fn.name === \"string\" && fn.name && !state.name) state.name = fn.name;\n      if (typeof fn.arguments === \"string\" && fn.arguments.length > 0) {\n        state.args += fn.arguments;\n        out += sse(\"response.function_call_arguments.delta\", {\n          type: \"response.function_call_arguments.delta\",\n          item_id: state.callId,\n          output_index: state.outputIndex,\n          delta: fn.arguments,\n        });\n      }\n    }\n    return out;\n  }\n\n  function finish(): string {\n    let out = closeText();\n    // Close any open tool calls, emitting their assembled arguments.\n    for (const state of tools.values()) {\n      out += sse(\"response.function_call_arguments.done\", {\n        type: \"response.function_call_arguments.done\",\n        item_id: state.callId,\n        output_index: state.outputIndex,\n        arguments: state.args,\n      });\n      out += sse(\"response.output_item.done\", {\n        type: \"response.output_item.done\",\n        output_index: state.outputIndex,\n        item: {\n          id: state.callId,\n          type: \"function_call\",\n          call_id: state.callId,\n          name: state.name,\n          arguments: state.args,\n        },\n      });\n    }\n    out += sse(\"response.completed\", {\n      type: \"response.completed\",\n      response: { id: responseId, object: \"response\", status: \"completed\", model },\n    });\n    return out;\n  }\n\n  return { feed, finish };\n}\n\n/** A source the model cited, as carried by a Responses content-part annotation. */\nexport interface ResponsesCitation {\n  url: string;\n  title?: string;\n}\n\n/** What {@link readResponsesOutput} pulls out of a `response` object. */\nexport interface ResponsesOutput {\n  /** The assistant's answer, with the output items concatenated. */\n  text: string;\n  /** Cited sources in first-seen order, deduplicated by URL. */\n  citations: ResponsesCitation[];\n}\n\n/**\n * Read the answer text and cited sources out of a Responses `response` payload.\n *\n * This is the inverse of {@link chatToResponse}: it consumes what an endpoint\n * speaking Responses natively returns, rather than producing it. The Databricks\n * native web-search tool answers this way, with each source attached as a\n * `url_citation` annotation on the content part that used it.\n *\n * Prefers the flattened `output_text` when the payload carries it, and falls\n * back to walking `output[].content[].text`. Every field is optional upstream,\n * so a payload missing any of it yields empty results rather than throwing.\n */\nexport function readResponsesOutput(payload: Record<string, unknown>): ResponsesOutput {\n  const output = Array.isArray(payload.output) ? (payload.output as unknown[]) : [];\n  const texts: string[] = [];\n  const citations: ResponsesCitation[] = [];\n  const seen = new Set<string>();\n\n  for (const rawItem of output) {\n    if (!rawItem || typeof rawItem !== \"object\") continue;\n    const content = (rawItem as Record<string, unknown>).content;\n    if (!Array.isArray(content)) continue;\n    for (const rawPart of content) {\n      if (!rawPart || typeof rawPart !== \"object\") continue;\n      const part = rawPart as Record<string, unknown>;\n      const text = string.trimToEmpty(part.text);\n      if (text) texts.push(text);\n      const annotations = Array.isArray(part.annotations) ? part.annotations : [];\n      for (const rawAnn of annotations) {\n        if (!rawAnn || typeof rawAnn !== \"object\") continue;\n        const ann = rawAnn as Record<string, unknown>;\n        const url = string.trimToEmpty(ann.url);\n        if (!url || seen.has(url)) continue;\n        seen.add(url);\n        const title = string.trimToEmpty(ann.title);\n        citations.push({ url, ...(title ? { title } : {}) });\n      }\n    }\n  }\n\n  return { text: string.trimToEmpty(payload.output_text) || texts.join(\"\\n\").trim(), citations };\n}\n\n/**\n * Strip tool types the upstream model doesn't support from a Responses request\n * body, returning a shallow copy safe to forward (the input is not mutated).\n *\n * Clients like the Codex CLI include built-in Responses tools (`web_search`,\n * `local_shell`, `custom`, ...) alongside their `function` tools. Databricks'\n * Open Responses surface for Anthropic/Claude (and other non-OpenAI providers)\n * only accepts `function` tools and hard-errors otherwise:\n *   \"Anthropic does not support tool type 'web_search'. Only 'function' is supported.\"\n * Call this before forwarding to `/serving-endpoints/open-responses`. The OpenAI\n * `/serving-endpoints/responses` path should keep built-ins (GPT supports them).\n * If filtering empties the list, `tools` / `tool_choice` / `parallel_tool_calls`\n * are dropped so we never send an empty `tools: []`.\n */\nexport function sanitizeResponsesTools(body: Record<string, unknown>): Record<string, unknown> {\n  if (!Array.isArray(body.tools) || body.tools.length === 0) return body;\n  const fnTools = body.tools.filter(\n    (t) => t && typeof t === \"object\" && (t as Record<string, unknown>).type === \"function\",\n  );\n  if (fnTools.length === body.tools.length) return body; // nothing to strip\n  const next: Record<string, unknown> = { ...body };\n  if (fnTools.length > 0) {\n    next.tools = fnTools;\n  } else {\n    delete next.tools;\n    delete next.tool_choice;\n    delete next.parallel_tool_calls;\n  }\n  return next;\n}\n\n/**\n * Content-part / input-item types Claude extended thinking uses on the wire.\n *\n * Shared so both wire surfaces strip the same set: the Responses path here\n * ({@link sanitizeOpenResponsesInput}) and the Chat Completions path in\n * `@dbx-tools/appkit-mastra`'s serving sanitize. Anthropic signs these blocks,\n * so a replay that mutates one is rejected outright - both paths must agree on\n * what counts as a reasoning block.\n */\nexport const REASONING_TYPES: ReadonlySet<string> = new Set([\n  \"reasoning\",\n  \"thinking\",\n  \"redacted_thinking\",\n]);\n\n/**\n * Rewrite Responses `input` so Open Responses will accept it.\n *\n * Two OpenAI / Codex shapes that Databricks Open Responses (Claude, Gemini, …)\n * reject:\n *\n * 1. Prior assistant turns with `output_text` / `output_*` content parts —\n *    Open Responses only allows `input_text`, `input_image`, `input_file`,\n *    `input_audio`. Map every `output_<kind>` part to `input_<kind>`.\n * 2. Replayed extended-thinking blocks (`thinking`, `redacted_thinking`,\n *    `reasoning` content parts, and top-level `reasoning` input items). Claude\n *    signs those; any client round-trip that mutates them (or a cross-provider\n *    replay) fails with e.g.\n *      \"messages.N.content.M: Invalid `data` in `redacted_thinking` block\"\n *    Strip them — the UI/client already showed the thinking; replay does not\n *    need the signed blob. Same policy as appkit-mastra's serving sanitize.\n *\n * Returns a shallow copy when anything changes; otherwise the input body.\n */\nexport function sanitizeOpenResponsesInput(body: Record<string, unknown>): Record<string, unknown> {\n  if (!Array.isArray(body.input) || body.input.length === 0) return body;\n\n  let changed = false;\n  const input: unknown[] = [];\n\n  for (const raw of body.input) {\n    if (!raw || typeof raw !== \"object\") {\n      input.push(raw);\n      continue;\n    }\n    const item = raw as Record<string, unknown>;\n\n    // Top-level Responses reasoning items (not message content parts).\n    if (typeof item.type === \"string\" && REASONING_TYPES.has(item.type)) {\n      changed = true;\n      continue;\n    }\n\n    if (!Array.isArray(item.content)) {\n      input.push(raw);\n      continue;\n    }\n\n    let partChanged = false;\n    const content: unknown[] = [];\n    for (const part of item.content) {\n      if (!part || typeof part !== \"object\") {\n        content.push(part);\n        continue;\n      }\n      const p = part as Record<string, unknown>;\n      if (typeof p.type === \"string\" && REASONING_TYPES.has(p.type)) {\n        partChanged = true;\n        continue;\n      }\n      if (typeof p.type === \"string\" && p.type.startsWith(\"output_\")) {\n        partChanged = true;\n        content.push({ ...p, type: `input_${p.type.slice(\"output_\".length)}` });\n        continue;\n      }\n      content.push(part);\n    }\n\n    if (!partChanged) {\n      input.push(raw);\n      continue;\n    }\n    changed = true;\n    // Drop assistant turns that only carried thinking (nothing left to replay).\n    if (content.length === 0 && item.role === \"assistant\") continue;\n    input.push({ ...item, content });\n  }\n\n  return changed ? { ...body, input } : body;\n}\n\n/**\n * Full Open Responses request sanitizer: strip non-`function` tools, rewrite\n * `output_*` content parts, and drop thinking / reasoning blocks. Safe no-op\n * when nothing needs changing.\n */\nexport function sanitizeOpenResponsesRequest(\n  body: Record<string, unknown>,\n): Record<string, unknown> {\n  return sanitizeOpenResponsesInput(sanitizeResponsesTools(body));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"openai-responses.js","sourceRoot":"","sources":["../../src/openai-responses.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * OpenAI Responses API <-> Chat Completions translation.\n *\n * Some clients speak only the Responses API (`POST /v1/responses`) - the Codex\n * CLI is the motivating one. Databricks now also exposes native Responses\n * surfaces (`/serving-endpoints/responses` and `/serving-endpoints/open-responses`),\n * while most endpoints still speak Chat Completions at `/invocations`. This\n * module bridges the two, in both directions:\n *\n *   - {@link responsesToChat} lowers a Responses request body to a chat\n *     completions body (instructions -> system message, typed `input` items ->\n *     `messages`, `tools`/`tool_choice` carried through, function-call outputs\n *     folded back into the transcript).\n *   - {@link chatToResponsesRequest} raises a chat-completions request into a\n *     Responses request (the inverse of {@link responsesToChat}), for routing a\n *     chat client at a Responses-only model like Codex.\n *   - {@link chatToResponse} lifts a non-streaming chat completion back into a\n *     Responses `response` object.\n *   - {@link responseToChatCompletion} lifts a native Responses `response`\n *     back into a chat-completions body (the inverse of {@link chatToResponse}).\n *   - {@link createResponsesStreamTranslator} lifts a streaming chat completion\n *     (an OpenAI SSE `chat.completion.chunk` stream) into the Responses SSE\n *     event stream those clients consume (`response.created`,\n *     `response.output_text.delta`, function-call argument deltas,\n *     `response.completed`).\n *   - {@link readResponsesOutput} reads the other direction: pull the answer\n *     text and citations out of a `response` object returned by an endpoint\n *     that speaks Responses natively (the Databricks native web-search tool).\n *   - {@link sanitizeResponsesTools} keeps only `function` tools on a Responses\n *     request body (for `/open-responses` / Anthropic, which reject Codex\n *     built-ins like `web_search`).\n *   - {@link sanitizeOpenResponsesInput} rewrites `output_*` content part types\n *     in `input` to `input_*`, and drops Claude thinking / reasoning blocks\n *     that Open Responses rejects on replay (`redacted_thinking`, …).\n *   - {@link repairTrailingAssistantInput} drops a trailing assistant turn that\n *     Anthropic reads as a prefill request, the Responses-side counterpart to\n *     `@dbx-tools/appkit-mastra`'s `repairAssistantPrefill`.\n *\n * Only the surface real clients exercise is translated; unknown fields are\n * ignored rather than rejected, so a newer client degrades instead of breaking.\n *\n * Browser-safe: pure functions over plain JSON, no transport and no Node\n * built-ins, so the same translation runs in a proxy, a server route, or a test.\n *\n * @module\n */\n\nimport { string } from \"@dbx-tools/shared-core\";\n\nimport { type ChatMessage, type ChatToolCall, chatContentToText } from \"./openai-chat.ts\";\n\n/**\n * Lower a Responses request body to a chat-completions body. Returns the chat\n * body plus whether the caller asked for streaming (the server needs it to pick\n * the upstream `accept` header and the translation path).\n */\nexport function responsesToChat(body: Record<string, unknown>): {\n  chat: Record<string, unknown>;\n  stream: boolean;\n} {\n  const messages: ChatMessage[] = [];\n\n  // `instructions` becomes the leading system message.\n  if (typeof body.instructions === \"string\" && body.instructions.length > 0) {\n    messages.push({ role: \"system\", content: body.instructions });\n  }\n\n  // `input` is an array of typed items: messages, function_call, and\n  // function_call_output. Fold each into the chat transcript.\n  const input = Array.isArray(body.input) ? body.input : [];\n  for (const raw of input) {\n    if (!raw || typeof raw !== \"object\") continue;\n    const item = raw as Record<string, unknown>;\n    const type = item.type;\n\n    if (type === \"function_call\") {\n      // A prior tool call the model made; re-attach it to an assistant turn.\n      messages.push({\n        role: \"assistant\",\n        content: null,\n        tool_calls: [toChatToolCall(item)],\n      });\n      continue;\n    }\n\n    if (type === \"function_call_output\") {\n      // The tool's result, keyed back to the call it answers.\n      messages.push({\n        role: \"tool\",\n        tool_call_id: String(item.call_id ?? item.id ?? \"\"),\n        content: typeof item.output === \"string\" ? item.output : chatContentToText(item.output),\n      });\n      continue;\n    }\n\n    // Default: a message item with a role and typed content.\n    const role = typeof item.role === \"string\" ? item.role : \"user\";\n    // Chat has no \"developer\" role; treat it as system (its intent here).\n    const chatRole = role === \"developer\" ? \"system\" : role;\n    messages.push({ role: chatRole, content: chatContentToText(item.content) });\n  }\n\n  const chat: Record<string, unknown> = {\n    model: body.model,\n    messages,\n    stream: body.stream === true,\n  };\n\n  // Carry through function-calling config when present. Responses function\n  // tools are FLAT (`{type:\"function\", name, description, parameters}`); chat\n  // wants them NESTED (`{type:\"function\", function:{name, …}}`). Clients also\n  // send built-in tool types (local_shell, web_search, …) that Databricks chat\n  // rejects (\"Missing 'function' in the tool specification\"), so we translate\n  // only function tools and drop the rest.\n  if (Array.isArray(body.tools) && body.tools.length > 0) {\n    const chatTools = body.tools\n      .map(toChatTool)\n      .filter((t): t is Record<string, unknown> => t !== undefined);\n    if (chatTools.length > 0) {\n      chat.tools = chatTools;\n      if (body.tool_choice !== undefined) chat.tool_choice = body.tool_choice;\n      // NOTE: do NOT forward `parallel_tool_calls`. Clients send it, but\n      // Databricks Model Serving's chat API rejects unknown fields\n      // (\"parallel_tool_calls: Extra inputs are not permitted\"), which would\n      // fail the whole turn. Drop it.\n    }\n  }\n\n  return { chat, stream: body.stream === true };\n}\n\n/**\n * Raise a chat-completions request into a Responses request body. Inverse of\n * {@link responsesToChat}: used when a chat client hits a Responses-only\n * Databricks model (e.g. Codex) so the proxy can POST to\n * `/serving-endpoints/responses` without the client knowing.\n */\nexport function chatToResponsesRequest(body: Record<string, unknown>): {\n  responses: Record<string, unknown>;\n  stream: boolean;\n} {\n  const messages = Array.isArray(body.messages) ? body.messages : [];\n  const input: unknown[] = [];\n  let instructions: string | undefined;\n\n  for (const raw of messages) {\n    if (!raw || typeof raw !== \"object\") continue;\n    const message = raw as Record<string, unknown>;\n    const role = typeof message.role === \"string\" ? message.role : \"user\";\n\n    // Leading system / developer messages become top-level `instructions`.\n    if (\n      (role === \"system\" || role === \"developer\") &&\n      instructions === undefined &&\n      input.length === 0\n    ) {\n      const text = chatContentToText(message.content);\n      if (text) instructions = text;\n      continue;\n    }\n\n    if (role === \"tool\") {\n      input.push({\n        type: \"function_call_output\",\n        call_id: String(message.tool_call_id ?? \"\"),\n        output: chatContentToText(message.content),\n      });\n      continue;\n    }\n\n    if (\n      role === \"assistant\" &&\n      Array.isArray(message.tool_calls) &&\n      message.tool_calls.length > 0\n    ) {\n      for (const rawCall of message.tool_calls) {\n        if (!rawCall || typeof rawCall !== \"object\") continue;\n        input.push(toFunctionCallItem(rawCall as Record<string, unknown>));\n      }\n      const text = chatContentToText(message.content);\n      if (text) {\n        input.push({ type: \"message\", role: \"assistant\", content: text });\n      }\n      continue;\n    }\n\n    input.push({\n      type: \"message\",\n      role,\n      content: chatContentToText(message.content),\n    });\n  }\n\n  const responses: Record<string, unknown> = {\n    model: body.model,\n    input,\n    stream: body.stream === true,\n  };\n  if (instructions) responses.instructions = instructions;\n\n  // Chat tools are nested (`function: { name, … }`); Responses wants them flat.\n  if (Array.isArray(body.tools) && body.tools.length > 0) {\n    const tools = body.tools\n      .map(toResponsesTool)\n      .filter((t): t is Record<string, unknown> => t !== undefined);\n    if (tools.length > 0) {\n      responses.tools = tools;\n      if (body.tool_choice !== undefined) responses.tool_choice = body.tool_choice;\n    }\n  }\n\n  // Prefer Responses' max_output_tokens naming; fall back from chat max_tokens.\n  if (typeof body.max_output_tokens === \"number\") {\n    responses.max_output_tokens = body.max_output_tokens;\n  } else if (typeof body.max_tokens === \"number\") {\n    responses.max_output_tokens = body.max_tokens;\n  }\n\n  return { responses, stream: body.stream === true };\n}\n\n/** Lift a non-streaming chat completion JSON into a Responses `response` object. */\nexport function chatToResponse(chat: Record<string, unknown>, model: string): unknown {\n  const choices = Array.isArray(chat.choices) ? chat.choices : [];\n  const first = (choices[0] ?? {}) as Record<string, unknown>;\n  const message = (first.message ?? {}) as Record<string, unknown>;\n  const output: unknown[] = [];\n\n  const text = typeof message.content === \"string\" ? message.content : \"\";\n  if (text) {\n    output.push({\n      type: \"message\",\n      role: \"assistant\",\n      content: [{ type: \"output_text\", text }],\n    });\n  }\n\n  // Surface any tool calls as Responses `function_call` output items.\n  const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];\n  for (const raw of toolCalls) {\n    output.push(toFunctionCallItem(raw as Record<string, unknown>));\n  }\n\n  const usage = (chat.usage ?? {}) as Record<string, unknown>;\n  return {\n    id: String(chat.id ?? \"resp\"),\n    object: \"response\",\n    created_at: typeof chat.created === \"number\" ? chat.created : 0,\n    model,\n    status: \"completed\",\n    output,\n    usage: {\n      input_tokens: Number(usage.prompt_tokens ?? 0),\n      output_tokens: Number(usage.completion_tokens ?? 0),\n      total_tokens: Number(usage.total_tokens ?? 0),\n    },\n  };\n}\n\n/**\n * Lift a native Responses `response` object into a chat-completions body.\n * Inverse of {@link chatToResponse}: used after a Responses-only upstream call\n * when the client spoke Chat Completions.\n */\nexport function responseToChatCompletion(\n  response: Record<string, unknown>,\n  model: string,\n): Record<string, unknown> {\n  const { text } = readResponsesOutput(response);\n  const toolCalls: unknown[] = [];\n  const output = Array.isArray(response.output) ? response.output : [];\n  for (const raw of output) {\n    if (!raw || typeof raw !== \"object\") continue;\n    const item = raw as Record<string, unknown>;\n    if (item.type !== \"function_call\") continue;\n    toolCalls.push(toChatToolCall(item));\n  }\n\n  const message: Record<string, unknown> = {\n    role: \"assistant\",\n    content: text || null,\n  };\n  if (toolCalls.length > 0) message.tool_calls = toolCalls;\n\n  const usage = (response.usage ?? {}) as Record<string, unknown>;\n  return {\n    id: String(response.id ?? \"chatcmpl\"),\n    object: \"chat.completion\",\n    created: typeof response.created_at === \"number\" ? response.created_at : 0,\n    model,\n    choices: [\n      {\n        index: 0,\n        message,\n        finish_reason: toolCalls.length > 0 ? \"tool_calls\" : \"stop\",\n      },\n    ],\n    usage: {\n      prompt_tokens: Number(usage.input_tokens ?? 0),\n      completion_tokens: Number(usage.output_tokens ?? 0),\n      total_tokens: Number(usage.total_tokens ?? 0),\n    },\n  };\n}\n\n/**\n * A tool call's `arguments` JSON. Both wires carry it as an unparsed string;\n * anything else (absent, an already-parsed object) becomes an empty literal so\n * the receiving side always has valid JSON to parse.\n */\nfunction callArguments(value: unknown): string {\n  return typeof value === \"string\" ? value : \"{}\";\n}\n\n/**\n * The Responses `function_call` item for a tool call in either spelling: a chat\n * `tool_calls[]` entry (`{id, function:{name, arguments}}`) or an item that is\n * already flat.\n */\nfunction toFunctionCallItem(call: Record<string, unknown>): Record<string, unknown> {\n  const fn = (call.function ?? call) as Record<string, unknown>;\n  return {\n    type: \"function_call\",\n    call_id: String(call.call_id ?? call.id ?? \"\"),\n    name: String(fn.name ?? \"\"),\n    arguments: callArguments(fn.arguments),\n  };\n}\n\n/** The chat `tool_calls[]` entry for a Responses `function_call` item. */\nfunction toChatToolCall(item: Record<string, unknown>): ChatToolCall {\n  return {\n    id: String(item.call_id ?? item.id ?? \"\"),\n    type: \"function\",\n    function: {\n      name: String(item.name ?? \"\"),\n      arguments: callArguments(item.arguments),\n    },\n  };\n}\n\n/**\n * The chat-nested spelling (`{type:\"function\", function:{name, …}}`) of a tool\n * spec, or `undefined` for a built-in Responses tool (`web_search`,\n * `local_shell`, …) that chat cannot express and Databricks rejects.\n */\nfunction toChatTool(value: unknown): Record<string, unknown> | undefined {\n  if (!value || typeof value !== \"object\") return undefined;\n  const tool = value as Record<string, unknown>;\n  if (tool.type !== \"function\") return undefined;\n  if (tool.function && typeof tool.function === \"object\") return tool; // already nested\n  if (typeof tool.name !== \"string\") return undefined;\n  return {\n    type: \"function\",\n    function: {\n      name: tool.name,\n      ...(tool.description ? { description: tool.description } : {}),\n      ...(tool.parameters ? { parameters: tool.parameters } : {}),\n    },\n  };\n}\n\n/**\n * The flat Responses spelling (`{type:\"function\", name, …}`) of a tool spec.\n * Inverse of {@link toChatTool}; non-function tools are dropped the same way.\n */\nfunction toResponsesTool(value: unknown): Record<string, unknown> | undefined {\n  if (!value || typeof value !== \"object\") return undefined;\n  const tool = value as Record<string, unknown>;\n  if (tool.type !== \"function\") return undefined;\n  if (tool.function && typeof tool.function === \"object\") {\n    const fn = tool.function as Record<string, unknown>;\n    return {\n      type: \"function\",\n      name: fn.name,\n      ...(fn.description ? { description: fn.description } : {}),\n      ...(fn.parameters ? { parameters: fn.parameters } : {}),\n    };\n  }\n  return typeof tool.name === \"string\" ? tool : undefined; // already flat\n}\n\n/** One Server-Sent Event, ready to write to the client. */\nfunction sse(event: string, data: unknown): string {\n  return `event: ${event}\\ndata: ${JSON.stringify(data)}\\n\\n`;\n}\n\n/**\n * Incremental chat-chunk -> Responses-SSE translator. `feed` and `finish` both\n * return the SSE bytes to forward, or `\"\"` when a chunk produced no event.\n */\nexport interface ResponsesStreamTranslator {\n  /** Translate one upstream `chat.completion.chunk` object. */\n  feed(chunk: Record<string, unknown>): string;\n  /** Close any open items and emit `response.completed`. Call once, at end of stream. */\n  finish(): string;\n}\n\n/**\n * Translate an upstream chat-completions SSE stream into the Responses SSE\n * event stream a Responses client consumes.\n *\n * Upstream chunks are `chat.completion.chunk` objects whose `choices[0].delta`\n * carries incremental `content` (assistant text) and/or `tool_calls` (function\n * calls, streamed by `index` with partial `arguments`). We emit the Responses\n * lifecycle around them:\n *\n *   response.created\n *   -> per text run:  output_item.added → output_text.delta* → output_item.done\n *   -> per tool call: output_item.added → function_call_arguments.delta*\n *                       → function_call_arguments.done → output_item.done\n *   response.completed   (with the assembled final `response` object)\n *\n * The translator is intentionally tolerant: malformed/keepalive lines yield\n * nothing.\n */\nexport function createResponsesStreamTranslator(\n  model: string,\n  responseId: string,\n): ResponsesStreamTranslator {\n  let started = false;\n  let outputIndex = 0;\n\n  // Text run state: whether a message item is currently open, and its buffer.\n  let textOpen = false;\n  let textBuffer = \"\";\n  let textItemId = \"\";\n\n  // Tool-call state, keyed by the upstream `tool_calls[].index`.\n  interface ToolState {\n    outputIndex: number;\n    callId: string;\n    name: string;\n    args: string;\n  }\n  const tools = new Map<number, ToolState>();\n\n  const created = () =>\n    sse(\"response.created\", {\n      type: \"response.created\",\n      response: { id: responseId, object: \"response\", status: \"in_progress\", model, output: [] },\n    });\n\n  function openText(): string {\n    textOpen = true;\n    textItemId = `${responseId}-msg-${outputIndex}`;\n    const ev = sse(\"response.output_item.added\", {\n      type: \"response.output_item.added\",\n      output_index: outputIndex,\n      item: { id: textItemId, type: \"message\", role: \"assistant\", content: [] },\n    });\n    return ev;\n  }\n\n  function closeText(): string {\n    if (!textOpen) return \"\";\n    const item = {\n      id: textItemId,\n      type: \"message\",\n      role: \"assistant\",\n      content: [{ type: \"output_text\", text: textBuffer }],\n    };\n    const ev =\n      sse(\"response.output_text.done\", {\n        type: \"response.output_text.done\",\n        item_id: textItemId,\n        output_index: outputIndex,\n        content_index: 0,\n        text: textBuffer,\n      }) +\n      sse(\"response.output_item.done\", {\n        type: \"response.output_item.done\",\n        output_index: outputIndex,\n        item,\n      });\n    textOpen = false;\n    textBuffer = \"\";\n    outputIndex += 1;\n    return ev;\n  }\n\n  function feed(chunk: Record<string, unknown>): string {\n    let out = \"\";\n    if (!started) {\n      started = true;\n      out += created();\n    }\n    const choices = Array.isArray(chunk.choices) ? chunk.choices : [];\n    const choice = (choices[0] ?? {}) as Record<string, unknown>;\n    const delta = (choice.delta ?? {}) as Record<string, unknown>;\n\n    // Assistant text deltas.\n    if (typeof delta.content === \"string\" && delta.content.length > 0) {\n      if (!textOpen) out += openText();\n      textBuffer += delta.content;\n      out += sse(\"response.output_text.delta\", {\n        type: \"response.output_text.delta\",\n        item_id: textItemId,\n        output_index: outputIndex,\n        content_index: 0,\n        delta: delta.content,\n      });\n    }\n\n    // Tool-call deltas: each is keyed by `index`; `arguments` arrives in pieces.\n    const toolDeltas = Array.isArray(delta.tool_calls) ? delta.tool_calls : [];\n    for (const rawTc of toolDeltas) {\n      const tc = rawTc as Record<string, unknown>;\n      const idx = Number(tc.index ?? 0);\n      const fn = (tc.function ?? {}) as Record<string, unknown>;\n      let state = tools.get(idx);\n      if (!state) {\n        // First fragment for this call: a text run (if open) must close first so\n        // output ordering stays monotonic, then we open a function_call item.\n        out += closeText();\n        state = {\n          outputIndex,\n          callId: String(tc.id ?? `${responseId}-call-${idx}`),\n          name: String(fn.name ?? \"\"),\n          args: \"\",\n        };\n        tools.set(idx, state);\n        out += sse(\"response.output_item.added\", {\n          type: \"response.output_item.added\",\n          output_index: state.outputIndex,\n          item: {\n            id: state.callId,\n            type: \"function_call\",\n            call_id: state.callId,\n            name: state.name,\n            arguments: \"\",\n          },\n        });\n        outputIndex += 1;\n      }\n      if (typeof fn.name === \"string\" && fn.name && !state.name) state.name = fn.name;\n      if (typeof fn.arguments === \"string\" && fn.arguments.length > 0) {\n        state.args += fn.arguments;\n        out += sse(\"response.function_call_arguments.delta\", {\n          type: \"response.function_call_arguments.delta\",\n          item_id: state.callId,\n          output_index: state.outputIndex,\n          delta: fn.arguments,\n        });\n      }\n    }\n    return out;\n  }\n\n  function finish(): string {\n    let out = closeText();\n    // Close any open tool calls, emitting their assembled arguments.\n    for (const state of tools.values()) {\n      out += sse(\"response.function_call_arguments.done\", {\n        type: \"response.function_call_arguments.done\",\n        item_id: state.callId,\n        output_index: state.outputIndex,\n        arguments: state.args,\n      });\n      out += sse(\"response.output_item.done\", {\n        type: \"response.output_item.done\",\n        output_index: state.outputIndex,\n        item: {\n          id: state.callId,\n          type: \"function_call\",\n          call_id: state.callId,\n          name: state.name,\n          arguments: state.args,\n        },\n      });\n    }\n    out += sse(\"response.completed\", {\n      type: \"response.completed\",\n      response: { id: responseId, object: \"response\", status: \"completed\", model },\n    });\n    return out;\n  }\n\n  return { feed, finish };\n}\n\n/** A source the model cited, as carried by a Responses content-part annotation. */\nexport interface ResponsesCitation {\n  url: string;\n  title?: string;\n}\n\n/** What {@link readResponsesOutput} pulls out of a `response` object. */\nexport interface ResponsesOutput {\n  /** The assistant's answer, with the output items concatenated. */\n  text: string;\n  /** Cited sources in first-seen order, deduplicated by URL. */\n  citations: ResponsesCitation[];\n}\n\n/**\n * Read the answer text and cited sources out of a Responses `response` payload.\n *\n * This is the inverse of {@link chatToResponse}: it consumes what an endpoint\n * speaking Responses natively returns, rather than producing it. The Databricks\n * native web-search tool answers this way, with each source attached as a\n * `url_citation` annotation on the content part that used it.\n *\n * Prefers the flattened `output_text` when the payload carries it, and falls\n * back to walking `output[].content[].text`. Every field is optional upstream,\n * so a payload missing any of it yields empty results rather than throwing.\n */\nexport function readResponsesOutput(payload: Record<string, unknown>): ResponsesOutput {\n  const output = Array.isArray(payload.output) ? (payload.output as unknown[]) : [];\n  const texts: string[] = [];\n  const citations: ResponsesCitation[] = [];\n  const seen = new Set<string>();\n\n  for (const rawItem of output) {\n    if (!rawItem || typeof rawItem !== \"object\") continue;\n    const content = (rawItem as Record<string, unknown>).content;\n    if (!Array.isArray(content)) continue;\n    for (const rawPart of content) {\n      if (!rawPart || typeof rawPart !== \"object\") continue;\n      const part = rawPart as Record<string, unknown>;\n      const text = string.trimToEmpty(part.text);\n      if (text) texts.push(text);\n      const annotations = Array.isArray(part.annotations) ? part.annotations : [];\n      for (const rawAnn of annotations) {\n        if (!rawAnn || typeof rawAnn !== \"object\") continue;\n        const ann = rawAnn as Record<string, unknown>;\n        const url = string.trimToEmpty(ann.url);\n        if (!url || seen.has(url)) continue;\n        seen.add(url);\n        const title = string.trimToEmpty(ann.title);\n        citations.push({ url, ...(title ? { title } : {}) });\n      }\n    }\n  }\n\n  return { text: string.trimToEmpty(payload.output_text) || texts.join(\"\\n\").trim(), citations };\n}\n\n/**\n * Strip tool types the upstream model doesn't support from a Responses request\n * body, returning a shallow copy safe to forward (the input is not mutated).\n *\n * Clients like the Codex CLI include built-in Responses tools (`web_search`,\n * `local_shell`, `custom`, ...) alongside their `function` tools. Databricks'\n * Open Responses surface for Anthropic/Claude (and other non-OpenAI providers)\n * only accepts `function` tools and hard-errors otherwise:\n *   \"Anthropic does not support tool type 'web_search'. Only 'function' is supported.\"\n * Call this before forwarding to `/serving-endpoints/open-responses`. The OpenAI\n * `/serving-endpoints/responses` path should keep built-ins (GPT supports them).\n * If filtering empties the list, `tools` / `tool_choice` / `parallel_tool_calls`\n * are dropped so we never send an empty `tools: []`.\n */\nexport function sanitizeResponsesTools(body: Record<string, unknown>): Record<string, unknown> {\n  if (!Array.isArray(body.tools) || body.tools.length === 0) return body;\n  const fnTools = body.tools.filter(\n    (t) => t && typeof t === \"object\" && (t as Record<string, unknown>).type === \"function\",\n  );\n  if (fnTools.length === body.tools.length) return body; // nothing to strip\n  const next: Record<string, unknown> = { ...body };\n  if (fnTools.length > 0) {\n    next.tools = fnTools;\n  } else {\n    delete next.tools;\n    delete next.tool_choice;\n    delete next.parallel_tool_calls;\n  }\n  return next;\n}\n\n/**\n * Content-part / input-item types Claude extended thinking uses on the wire.\n *\n * Shared so both wire surfaces strip the same set: the Responses path here\n * ({@link sanitizeOpenResponsesInput}) and the Chat Completions path in\n * `@dbx-tools/appkit-mastra`'s serving sanitize. Anthropic signs these blocks,\n * so a replay that mutates one is rejected outright - both paths must agree on\n * what counts as a reasoning block.\n */\nexport const REASONING_TYPES: ReadonlySet<string> = new Set([\n  \"reasoning\",\n  \"thinking\",\n  \"redacted_thinking\",\n]);\n\n/**\n * Rewrite Responses `input` so Open Responses will accept it.\n *\n * Two OpenAI / Codex shapes that Databricks Open Responses (Claude, Gemini, …)\n * reject:\n *\n * 1. Prior assistant turns with `output_text` / `output_*` content parts —\n *    Open Responses only allows `input_text`, `input_image`, `input_file`,\n *    `input_audio`. Map every `output_<kind>` part to `input_<kind>`.\n * 2. Replayed extended-thinking blocks (`thinking`, `redacted_thinking`,\n *    `reasoning` content parts, and top-level `reasoning` input items). Claude\n *    signs those; any client round-trip that mutates them (or a cross-provider\n *    replay) fails with e.g.\n *      \"messages.N.content.M: Invalid `data` in `redacted_thinking` block\"\n *    Strip them — the UI/client already showed the thinking; replay does not\n *    need the signed blob. Same policy as appkit-mastra's serving sanitize.\n *\n * Returns a shallow copy when anything changes; otherwise the input body.\n */\nexport function sanitizeOpenResponsesInput(body: Record<string, unknown>): Record<string, unknown> {\n  if (!Array.isArray(body.input) || body.input.length === 0) return body;\n\n  let changed = false;\n  const input: unknown[] = [];\n\n  for (const raw of body.input) {\n    if (!raw || typeof raw !== \"object\") {\n      input.push(raw);\n      continue;\n    }\n    const item = raw as Record<string, unknown>;\n\n    // Top-level Responses reasoning items (not message content parts).\n    if (typeof item.type === \"string\" && REASONING_TYPES.has(item.type)) {\n      changed = true;\n      continue;\n    }\n\n    if (!Array.isArray(item.content)) {\n      input.push(raw);\n      continue;\n    }\n\n    let partChanged = false;\n    const content: unknown[] = [];\n    for (const part of item.content) {\n      if (!part || typeof part !== \"object\") {\n        content.push(part);\n        continue;\n      }\n      const p = part as Record<string, unknown>;\n      if (typeof p.type === \"string\" && REASONING_TYPES.has(p.type)) {\n        partChanged = true;\n        continue;\n      }\n      if (typeof p.type === \"string\" && p.type.startsWith(\"output_\")) {\n        partChanged = true;\n        content.push({ ...p, type: `input_${p.type.slice(\"output_\".length)}` });\n        continue;\n      }\n      content.push(part);\n    }\n\n    if (!partChanged) {\n      input.push(raw);\n      continue;\n    }\n    changed = true;\n    // Drop assistant turns that only carried thinking (nothing left to replay).\n    if (content.length === 0 && item.role === \"assistant\") continue;\n    input.push({ ...item, content });\n  }\n\n  return changed ? { ...body, input } : body;\n}\n\n/**\n * Drop trailing assistant turns so the transcript ends on something Anthropic\n * will continue from.\n *\n * Databricks Open Responses rejects a body whose last item is an assistant\n * message with `\"This model does not support assistant message prefill. The\n * conversation must end with a user message.\"` (the upstream Bedrock route\n * disallows prefill). Two ways a real client hits it:\n *\n * 1. The client replays its own last answer. The Codex CLI does this when a turn\n *    ends without a tool call and the next request carries the full transcript.\n * 2. {@link sanitizeOpenResponsesInput} CREATES the shape: a turn that ended in a\n *    `reasoning` item is stripped for replay compatibility, promoting the\n *    assistant message before it to last. Running this repair after that strip\n *    is what keeps one fix from causing the other failure.\n *\n * Dropping is correct rather than lossy: a trailing assistant turn carries text\n * the model itself just produced, so it is context the provider does not need\n * repeated in order to continue. Appending a synthetic `\"Continue.\"` user turn\n * also satisfies the provider, but it puts words in the user's mouth that show\n * up in the model's context, so this takes the honest option.\n *\n * A trailing `function_call` is left ALONE. It is also an assistant-side item,\n * but Anthropic rejects an unanswered `tool_use` on a different rule\n * (`tool_use` ids without `tool_result`), and dropping it would silently discard\n * a tool call the client is about to answer. That is the client's bug to fix,\n * not something to paper over here.\n *\n * Returns a shallow copy when anything changes; otherwise the input body.\n */\nexport function repairTrailingAssistantInput(\n  body: Record<string, unknown>,\n): Record<string, unknown> {\n  if (!Array.isArray(body.input) || body.input.length === 0) return body;\n\n  const input = [...body.input];\n  let changed = false;\n  // A loop, not one check: stripping reasoning can leave several assistant\n  // turns in a row at the end.\n  while (input.length > 0 && isAssistantMessageItem(input[input.length - 1])) {\n    input.pop();\n    changed = true;\n  }\n  // Never send an empty `input`: an all-assistant transcript is not something\n  // this repair can rescue, so leave the body for the provider to reject with\n  // its own message rather than inventing a request.\n  if (!changed || input.length === 0) return body;\n  return { ...body, input };\n}\n\n/**\n * Whether an `input` item is an assistant MESSAGE (the prefill trigger), as\n * opposed to a `function_call` or any other assistant-side item type.\n */\nfunction isAssistantMessageItem(value: unknown): boolean {\n  if (!value || typeof value !== \"object\") return false;\n  const item = value as Record<string, unknown>;\n  if (item.role !== \"assistant\") return false;\n  return item.type === undefined || item.type === \"message\";\n}\n\n/**\n * Full Open Responses request sanitizer: strip non-`function` tools, rewrite\n * `output_*` content parts, drop thinking / reasoning blocks, and drop a\n * trailing assistant turn the provider would read as a prefill. Safe no-op\n * when nothing needs changing.\n */\nexport function sanitizeOpenResponsesRequest(\n  body: Record<string, unknown>,\n): Record<string, unknown> {\n  return repairTrailingAssistantInput(sanitizeOpenResponsesInput(sanitizeResponsesTools(body)));\n}\n"]}

package/package.json

@@ -3,7 +3,7 @@
   "repository": {
     "type": "git",
     "url": "git+https://github.com/reggie-db/dbx-tools.git",
-    "directory": "packages/shared/model"
+    "directory": "packages/js/shared/model"
   },
   "scripts": {
     "build": "projen build",
@@ -23,7 +23,7 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@dbx-tools/shared-core": "0.6.73",
+    "@dbx-tools/shared-core": "0.6.75",
     "zod": "4.3.6"
   },
   "main": "./lib/index.js",
@@ -40,7 +40,7 @@
       "./package.json": "./package.json"
     }
   },
-  "version": "0.6.73",
+  "version": "0.6.75",
   "types": "./lib/index.d.ts",
   "type": "module",
   "exports": {

package/src/openai-responses.ts

@@ -32,6 +32,9 @@
  *   - {@link sanitizeOpenResponsesInput} rewrites `output_*` content part types
  *     in `input` to `input_*`, and drops Claude thinking / reasoning blocks
  *     that Open Responses rejects on replay (`redacted_thinking`, …).
+ *   - {@link repairTrailingAssistantInput} drops a trailing assistant turn that
+ *     Anthropic reads as a prefill request, the Responses-side counterpart to
+ *     `@dbx-tools/appkit-mastra`'s `repairAssistantPrefill`.
  *
  * Only the surface real clients exercise is translated; unknown fields are
  * ignored rather than rejected, so a newer client degrades instead of breaking.
@@ -755,13 +758,75 @@ export function sanitizeOpenResponsesInput(body: Record<string, unknown>): Recor
   return changed ? { ...body, input } : body;
 }
 
+/**
+ * Drop trailing assistant turns so the transcript ends on something Anthropic
+ * will continue from.
+ *
+ * Databricks Open Responses rejects a body whose last item is an assistant
+ * message with `"This model does not support assistant message prefill. The
+ * conversation must end with a user message."` (the upstream Bedrock route
+ * disallows prefill). Two ways a real client hits it:
+ *
+ * 1. The client replays its own last answer. The Codex CLI does this when a turn
+ *    ends without a tool call and the next request carries the full transcript.
+ * 2. {@link sanitizeOpenResponsesInput} CREATES the shape: a turn that ended in a
+ *    `reasoning` item is stripped for replay compatibility, promoting the
+ *    assistant message before it to last. Running this repair after that strip
+ *    is what keeps one fix from causing the other failure.
+ *
+ * Dropping is correct rather than lossy: a trailing assistant turn carries text
+ * the model itself just produced, so it is context the provider does not need
+ * repeated in order to continue. Appending a synthetic `"Continue."` user turn
+ * also satisfies the provider, but it puts words in the user's mouth that show
+ * up in the model's context, so this takes the honest option.
+ *
+ * A trailing `function_call` is left ALONE. It is also an assistant-side item,
+ * but Anthropic rejects an unanswered `tool_use` on a different rule
+ * (`tool_use` ids without `tool_result`), and dropping it would silently discard
+ * a tool call the client is about to answer. That is the client's bug to fix,
+ * not something to paper over here.
+ *
+ * Returns a shallow copy when anything changes; otherwise the input body.
+ */
+export function repairTrailingAssistantInput(
+  body: Record<string, unknown>,
+): Record<string, unknown> {
+  if (!Array.isArray(body.input) || body.input.length === 0) return body;
+
+  const input = [...body.input];
+  let changed = false;
+  // A loop, not one check: stripping reasoning can leave several assistant
+  // turns in a row at the end.
+  while (input.length > 0 && isAssistantMessageItem(input[input.length - 1])) {
+    input.pop();
+    changed = true;
+  }
+  // Never send an empty `input`: an all-assistant transcript is not something
+  // this repair can rescue, so leave the body for the provider to reject with
+  // its own message rather than inventing a request.
+  if (!changed || input.length === 0) return body;
+  return { ...body, input };
+}
+
+/**
+ * Whether an `input` item is an assistant MESSAGE (the prefill trigger), as
+ * opposed to a `function_call` or any other assistant-side item type.
+ */
+function isAssistantMessageItem(value: unknown): boolean {
+  if (!value || typeof value !== "object") return false;
+  const item = value as Record<string, unknown>;
+  if (item.role !== "assistant") return false;
+  return item.type === undefined || item.type === "message";
+}
+
 /**
  * Full Open Responses request sanitizer: strip non-`function` tools, rewrite
- * `output_*` content parts, and drop thinking / reasoning blocks. Safe no-op
+ * `output_*` content parts, drop thinking / reasoning blocks, and drop a
+ * trailing assistant turn the provider would read as a prefill. Safe no-op
  * when nothing needs changing.
  */
 export function sanitizeOpenResponsesRequest(
   body: Record<string, unknown>,
 ): Record<string, unknown> {
-  return sanitizeOpenResponsesInput(sanitizeResponsesTools(body));
+  return repairTrailingAssistantInput(sanitizeOpenResponsesInput(sanitizeResponsesTools(body)));
 }