@dbx-tools/cli-model-proxy 0.3.25 → 0.3.27

package/README.md

@@ -134,8 +134,10 @@ Use this when tests or local developer tools need a managed proxy lifecycle.
      Responses-only models (Codex) which are translated and posted to
      `/serving-endpoints/responses`.
    - Responses → `/serving-endpoints/responses` (OpenAI-family) or
-     `/serving-endpoints/open-responses` (Claude/Gemini/…), body forwarded
-     as-is.
+     `/serving-endpoints/open-responses` (Claude/Gemini/…). For Open
+     Responses the proxy strips non-`function` tools and rewrites prior-turn
+     `output_*` content parts to `input_*` (Claude/Gemini reject
+     `output_text` in `input`).
 5. JSON or SSE response bodies are piped back (with a chat↔Responses
    translation only when a chat client hit a Responses-only model).
 

package/package.json

@@ -18,16 +18,16 @@
     "@databricks/sdk-experimental": "^0.17.0",
     "commander": "^15.0.0",
     "tsx": "^4.23.0",
-    "@dbx-tools/model": "0.3.25",
-    "@dbx-tools/shared-model": "0.3.25",
-    "@dbx-tools/shared-core": "0.3.25"
+    "@dbx-tools/model": "0.3.27",
+    "@dbx-tools/shared-core": "0.3.27",
+    "@dbx-tools/shared-model": "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/server.ts

@@ -38,7 +38,8 @@ import { classify, openaiChat, openaiResponses } from "@dbx-tools/shared-model";
 import type { DatabricksBackend } from "./backend";
 import { DEFAULT_BIND_HOST, DEFAULT_PORT } from "./defaults";
 
-const { chatToResponsesRequest, responseToChatCompletion } = openaiResponses;
+const { chatToResponsesRequest, responseToChatCompletion, sanitizeOpenResponsesRequest } =
+  openaiResponses;
 
 const logger = log.logger("model-proxy/server");
 
@@ -300,18 +301,23 @@ async function proxyChatViaResponses(
   headers["content-type"] = "application/json";
   headers.accept = "application/json";
 
+  const upstreamUrl = backend.responsesUrl(modelId);
+  const forward = upstreamUrl.includes("/open-responses")
+    ? sanitizeOpenResponsesRequest(responses)
+    : responses;
+
   logger.info("proxy", {
     requested,
     resolved: modelId,
     matched,
-    upstream: "responses",
+    upstream: upstreamUrl,
     stream: false,
   });
 
-  const upstream = await fetch(backend.responsesUrl(modelId), {
+  const upstream = await fetch(upstreamUrl, {
     method: "POST",
     headers,
-    body: JSON.stringify(responses),
+    body: JSON.stringify(forward),
   });
 
   if (!upstream.ok) {
@@ -329,6 +335,12 @@ async function proxyChatViaResponses(
  * `POST /v1/responses`: forward the Responses body to Databricks' native
  * Responses / Open Responses surface (model stays in the body; URL is
  * workspace-level). Streaming and non-streaming both pass through as-is.
+ *
+ * Open Responses (Claude/Gemini/…) only accepts `function` tools and
+ * `input_*` content part types, so Codex's built-in `web_search` /
+ * `local_shell` / … and prior-turn `output_text` parts are rewritten/
+ * stripped there. The OpenAI `/responses` path keeps them - GPT supports
+ * those shapes.
  */
 async function handleResponses(
   backend: DatabricksBackend,
@@ -345,24 +357,35 @@ async function handleResponses(
   const resolved = await backend.resolve(requested);
   body.model = resolved.modelId;
 
-  const wantsStream = body.stream === true;
+  const upstreamUrl = backend.responsesUrl(resolved.modelId);
+  // Cross-provider Open Responses rejects non-function tools and `output_*`
+  // content parts in `input`; OpenAI `/responses` keeps Codex's native shapes.
+  const forward = upstreamUrl.includes("/open-responses")
+    ? sanitizeOpenResponsesRequest(body)
+    : body;
+
+  const wantsStream = forward.stream === true;
   const headers = await backend.authHeaders();
   headers["content-type"] = "application/json";
   headers.accept = wantsStream ? "text/event-stream" : "application/json";
 
-  const upstreamUrl = backend.responsesUrl(resolved.modelId);
+  const stripped =
+    Array.isArray(body.tools) &&
+    (!Array.isArray(forward.tools) || forward.tools.length !== body.tools.length);
+
   logger.info("responses", {
     requested,
     resolved: resolved.modelId,
     matched: resolved.matched,
     upstream: upstreamUrl,
     stream: wantsStream,
+    ...(stripped ? { strippedNonFunctionTools: true } : {}),
   });
 
   const upstream = await fetch(upstreamUrl, {
     method: "POST",
     headers,
-    body: JSON.stringify(body),
+    body: JSON.stringify(forward),
   });
 
   res.writeHead(upstream.status, {