@dbx-tools/cli-model-proxy 0.3.24 → 0.3.26

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.24",
-    "@dbx-tools/shared-model": "0.3.24",
-    "@dbx-tools/shared-core": "0.3.24"
+    "@dbx-tools/model": "0.3.26",
+    "@dbx-tools/shared-core": "0.3.26",
+    "@dbx-tools/shared-model": "0.3.26"
   },
   "main": "index.ts",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.24",
+  "version": "0.3.26",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/cli.ts

@@ -20,7 +20,7 @@
 
 import { spawn } from "node:child_process";
 import type { Server } from "node:http";
-import { classify } from "@dbx-tools/shared-model";
+import { classify, type ServingEndpointSummary } from "@dbx-tools/shared-model";
 import { Command, CommanderError } from "commander";
 
 import { DatabricksBackend, type BackendOptions } from "./backend";
@@ -157,15 +157,7 @@ export function buildProgram(): Command {
     const opts = globalOpts<CommonOpts & { chat?: boolean }>(command);
     const backend = await DatabricksBackend.create(backendOptions(opts));
     const endpoints = await backend.models();
-    // Enrich each endpoint with a derived `capabilities` object so consumers
-    // filter on capability rather than re-deriving it from raw `task`/`class`
-    // strings. `chat` = OpenAI chat/completions + Responses (what an agent
-    // like Codex needs); `embedding` = vector endpoints; `tools` = whether the
-    // endpoint supports function/tool calls (all chat endpoints here do).
-    const enriched = endpoints.map((endpoint) => ({
-      ...endpoint,
-      capabilities: classify.endpointCapabilities(endpoint),
-    }));
+    const enriched = endpoints.map(enrichEndpoint);
     const out = opts.chat ? enriched.filter((e) => e.capabilities.chat) : enriched;
     process.stdout.write(`${JSON.stringify(out, null, 2)}\n`);
   });
@@ -178,13 +170,33 @@ export function buildProgram(): Command {
   ).action(async (query: string[], _local: CommonOpts, command: Command) => {
     const opts = globalOpts<CommonOpts>(command);
     const backend = await DatabricksBackend.create(backendOptions(opts));
-    const resolved = await backend.resolve(query.join(" "));
-    process.stdout.write(`${JSON.stringify(resolved, null, 2)}\n`);
+    const search = query.join(" ");
+    const resolved = await backend.resolve(search);
+    // Same shape as one `models` entry when matched; null when nothing in the
+    // catalogue scores within the threshold (caller can fall back to the query).
+    if (!resolved.matched) {
+      process.stdout.write("null\n");
+      return;
+    }
+    const endpoint = (await backend.models()).find((e) => e.name === resolved.modelId);
+    process.stdout.write(
+      `${JSON.stringify(endpoint ? enrichEndpoint(endpoint) : null, null, 2)}\n`,
+    );
   });
 
   return program;
 }
 
+/** One `models` / `resolve` list entry: endpoint summary + derived capabilities. */
+function enrichEndpoint(endpoint: ServingEndpointSummary) {
+  return {
+    ...endpoint,
+    // `chat` = OpenAI chat/completions + Responses; `embedding` = vectors;
+    // `tools` = function/tool calls (every chat endpoint here).
+    capabilities: classify.endpointCapabilities(endpoint),
+  };
+}
+
 /** Parse `argv` and run the matching command. Throws {@link CommanderError} on flag errors. */
 export async function runCli(argv: string[]): Promise<void> {
   await buildProgram().parseAsync(argv);

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, sanitizeResponsesTools } =
+  openaiResponses;
 
 const logger = log.logger("model-proxy/server");
 
@@ -329,6 +330,10 @@ 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, so Codex's
+ * built-in `web_search` / `local_shell` / … are stripped there. The OpenAI
+ * `/responses` path keeps them - GPT models support those tool types.
  */
 async function handleResponses(
   backend: DatabricksBackend,
@@ -345,24 +350,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 tool types; OpenAI
+  // `/responses` keeps Codex built-ins (web_search, local_shell, custom, …).
+  const forward = upstreamUrl.includes("/open-responses")
+    ? sanitizeResponsesTools(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, {