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

package/README.md

@@ -135,9 +135,10 @@ Use this when tests or local developer tools need a managed proxy lifecycle.
      `/serving-endpoints/responses`.
    - Responses → `/serving-endpoints/responses` (OpenAI-family) or
      `/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`).
+     Responses the proxy strips non-`function` tools, rewrites prior-turn
+     `output_*` content parts to `input_*`, and drops Claude
+     `thinking` / `redacted_thinking` / `reasoning` blocks (replay of those
+     signed blobs fails with "Invalid `data` in `redacted_thinking`").
 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.27",
-    "@dbx-tools/shared-core": "0.3.27",
-    "@dbx-tools/shared-model": "0.3.27"
+    "@dbx-tools/shared-core": "0.3.29",
+    "@dbx-tools/shared-model": "0.3.29",
+    "@dbx-tools/model": "0.3.29"
   },
   "main": "index.ts",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.27",
+  "version": "0.3.29",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/server.ts

@@ -32,7 +32,7 @@
  */
 
 import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
-import { error, log } from "@dbx-tools/shared-core";
+import { error, json, log } from "@dbx-tools/shared-core";
 import { classify, openaiChat, openaiResponses } from "@dbx-tools/shared-model";
 
 import type { DatabricksBackend } from "./backend";
@@ -222,7 +222,7 @@ async function handleProxy(
   req: IncomingMessage,
   res: ServerResponse,
 ): Promise<void> {
-  const body = (await readJsonBody(req)) as Record<string, unknown>;
+  const body = await readJsonBody(req);
   const requested = typeof body.model === "string" ? body.model : undefined;
   if (!requested) {
     sendJson(res, 400, errorBody("missing 'model' in request body", "invalid_request_error"));
@@ -337,8 +337,9 @@ async function proxyChatViaResponses(
  * 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/
+ * `input_*` content part types, and rejects replayed Claude thinking
+ * blocks — so Codex's built-in tools, prior-turn `output_text`, and
+ * `redacted_thinking` / `thinking` / `reasoning` parts are rewritten or
  * stripped there. The OpenAI `/responses` path keeps them - GPT supports
  * those shapes.
  */
@@ -347,7 +348,7 @@ async function handleResponses(
   req: IncomingMessage,
   res: ServerResponse,
 ): Promise<void> {
-  const body = (await readJsonBody(req)) as Record<string, unknown>;
+  const body = await readJsonBody(req);
   const requested = typeof body.model === "string" ? body.model : undefined;
   if (!requested) {
     sendJson(res, 400, errorBody("missing 'model' in request body", "invalid_request_error"));
@@ -423,14 +424,16 @@ function isAuthorized(req: IncomingMessage, apiKey: string): boolean {
   return header.replace(/^Bearer\s+/i, "").trim() === apiKey;
 }
 
-/** Drain a request body and parse it as JSON (empty body parses to `{}`). */
-async function readJsonBody(req: IncomingMessage): Promise<unknown> {
+/**
+ * Drain a request body and parse it as a JSON object. An empty, malformed, or
+ * non-object body yields `{}`, which the callers reject as a missing `model`.
+ */
+async function readJsonBody(req: IncomingMessage): Promise<Record<string, unknown>> {
   const chunks: Buffer[] = [];
   for await (const chunk of req) {
     chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk as Uint8Array));
   }
-  const raw = Buffer.concat(chunks).toString("utf8");
-  return raw ? JSON.parse(raw) : {};
+  return json.parseRecord(Buffer.concat(chunks).toString("utf8")) ?? {};
 }
 
 /** Serialize and send a JSON response. */