@dbx-tools/shared-model 0.3.25 → 0.3.27

package/package.json

@@ -12,14 +12,14 @@
   },
   "dependencies": {
     "zod": "^4.3.6",
-    "@dbx-tools/shared-core": "0.3.25"
+    "@dbx-tools/shared-core": "0.3.27"
   },
   "main": "index.ts",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.25",
+  "version": "0.3.27",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/openai-responses.ts

@@ -26,6 +26,11 @@
  *   - {@link readResponsesOutput} reads the other direction: pull the answer
  *     text and citations out of a `response` object returned by an endpoint
  *     that speaks Responses natively (the Databricks native web-search tool).
+ *   - {@link sanitizeResponsesTools} keeps only `function` tools on a Responses
+ *     request body (for `/open-responses` / Anthropic, which reject Codex
+ *     built-ins like `web_search`).
+ *   - {@link sanitizeOpenResponsesInput} rewrites `output_*` content part types
+ *     in `input` to `input_*` (Open Responses rejects `output_text` in history).
  *
  * Only the surface real clients exercise is translated; unknown fields are
  * ignored rather than rejected, so a newer client degrades instead of breaking.
@@ -607,3 +612,85 @@ export function readResponsesOutput(payload: Record<string, unknown>): Responses
 function str(value: unknown): string {
   return typeof value === "string" ? value.trim() : "";
 }
+
+/**
+ * Strip tool types the upstream model doesn't support from a Responses request
+ * body, returning a shallow copy safe to forward (the input is not mutated).
+ *
+ * Clients like the Codex CLI include built-in Responses tools (`web_search`,
+ * `local_shell`, `custom`, ...) alongside their `function` tools. Databricks'
+ * Open Responses surface for Anthropic/Claude (and other non-OpenAI providers)
+ * only accepts `function` tools and hard-errors otherwise:
+ *   "Anthropic does not support tool type 'web_search'. Only 'function' is supported."
+ * Call this before forwarding to `/serving-endpoints/open-responses`. The OpenAI
+ * `/serving-endpoints/responses` path should keep built-ins (GPT supports them).
+ * If filtering empties the list, `tools` / `tool_choice` / `parallel_tool_calls`
+ * are dropped so we never send an empty `tools: []`.
+ */
+export function sanitizeResponsesTools(
+  body: Record<string, unknown>,
+): Record<string, unknown> {
+  if (!Array.isArray(body.tools) || body.tools.length === 0) return body;
+  const fnTools = body.tools.filter(
+    (t) => t && typeof t === "object" && (t as Record<string, unknown>).type === "function",
+  );
+  if (fnTools.length === body.tools.length) return body; // nothing to strip
+  const next: Record<string, unknown> = { ...body };
+  if (fnTools.length > 0) {
+    next.tools = fnTools;
+  } else {
+    delete next.tools;
+    delete next.tool_choice;
+    delete next.parallel_tool_calls;
+  }
+  return next;
+}
+
+/**
+ * Rewrite Responses `input` content parts so Open Responses will accept them.
+ *
+ * OpenAI `/responses` (and Codex) replay prior assistant turns with
+ * `output_text` / `output_*` content part types. Databricks Open Responses
+ * (Claude, Gemini, …) only allows input-side types:
+ *   "Open Responses input content part type 'output_text' is not supported.
+ *    Supported: input_text, input_image, input_file, input_audio."
+ * Map every `output_<kind>` part to `input_<kind>` (shallow copy; no mutation).
+ * Call together with {@link sanitizeResponsesTools} before forwarding to
+ * `/serving-endpoints/open-responses`.
+ */
+export function sanitizeOpenResponsesInput(
+  body: Record<string, unknown>,
+): Record<string, unknown> {
+  if (!Array.isArray(body.input) || body.input.length === 0) return body;
+
+  let changed = false;
+  const input = body.input.map((raw) => {
+    if (!raw || typeof raw !== "object") return raw;
+    const item = raw as Record<string, unknown>;
+    if (!Array.isArray(item.content)) return raw;
+
+    let partChanged = false;
+    const content = item.content.map((part) => {
+      if (!part || typeof part !== "object") return part;
+      const p = part as Record<string, unknown>;
+      if (typeof p.type !== "string" || !p.type.startsWith("output_")) return part;
+      partChanged = true;
+      return { ...p, type: `input_${p.type.slice("output_".length)}` };
+    });
+    if (!partChanged) return raw;
+    changed = true;
+    return { ...item, content };
+  });
+
+  return changed ? { ...body, input } : body;
+}
+
+/**
+ * Full Open Responses request sanitizer: strip non-`function` tools and rewrite
+ * `output_*` input content parts. Safe no-op when nothing needs changing.
+ */
+export function sanitizeOpenResponsesRequest(
+  body: Record<string, unknown>,
+): Record<string, unknown> {
+  return sanitizeOpenResponsesInput(sanitizeResponsesTools(body));
+}