fix(responses): give every function tool schema an object root

Providers that validate strictly, DeepSeek among them, reject a function
schema whose root has no type. The parser forwarded (t.parameters ?? {})
untouched, so a tool declared without parameters — or with properties
but no root type — went out as an invalid schema.

Both routes are covered. The parser normalizes at build time, and the
raw Responses passthrough normalizes top-level tools and
input[].additional_tools.tools before serializing, because that path
copies _rawBody and never reaches the parser. Fixing only the parser
would have left every passthrough request still broken.

Valid schemas are returned unchanged rather than rebuilt, so existing
property sets cannot be reordered or dropped on the way through.

PR #745 by @white-source proposed the right normalizers but carried no
tests, which is why it could not land as-is. Ablating both normalizers
fails three tests: the parser root-type case and the two serialized
passthrough cases.

Co-authored-by: Mr.Hat <white-source@users.noreply.github.com>

Author: lidge-jun

src/adapters/openai-responses.ts

@@ -354,6 +354,47 @@ function isPlainObject(v: unknown): v is Record<string, unknown> {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
 
+function normalizeFunctionToolSchema(tool: unknown): unknown {
+  if (!isPlainObject(tool) || tool.type !== "function") return tool;
+  if (isPlainObject(tool.parameters) && tool.parameters.type === "object") return tool;
+  return {
+    ...tool,
+    parameters: { ...(isPlainObject(tool.parameters) ? tool.parameters : {}), type: "object" },
+  };
+}
+
+function normalizeToolSchemas(body: unknown): unknown {
+  if (!isPlainObject(body)) return body;
+
+  const normalizeTools = (tools: unknown[]): unknown[] => {
+    let changed = false;
+    const normalized = tools.map((tool) => {
+      const fixed = normalizeFunctionToolSchema(tool);
+      if (fixed !== tool) changed = true;
+      return fixed;
+    });
+    return changed ? normalized : tools;
+  };
+
+  let normalizedBody = body;
+  if (Array.isArray(body.tools)) {
+    const tools = normalizeTools(body.tools);
+    if (tools !== body.tools) normalizedBody = { ...normalizedBody, tools };
+  }
+  if (Array.isArray(normalizedBody.input)) {
+    let inputChanged = false;
+    const input = normalizedBody.input.map((item) => {
+      if (!isPlainObject(item) || item.type !== "additional_tools" || !Array.isArray(item.tools)) return item;
+      const tools = normalizeTools(item.tools);
+      if (tools === item.tools) return item;
+      inputChanged = true;
+      return { ...item, tools };
+    });
+    if (inputChanged) normalizedBody = { ...normalizedBody, input };
+  }
+  return normalizedBody;
+}
+
 const MAX_RESPONSES_CALL_ID_LENGTH = 64;
 const REPAIRED_CALL_ID_PREFIX = "call_ocx_";
 const REPAIRED_CALL_ID_DIGEST_LENGTH = MAX_RESPONSES_CALL_ID_LENGTH - REPAIRED_CALL_ID_PREFIX.length;
@@ -938,7 +979,7 @@ export function createResponsesPassthroughAdapter(provider: OcxProviderConfig):
       if (parsed._compactionRequest === true && !isCanonicalOpenAiForwardProvider(provider)) {
         outBody = buildRoutedCompactionBody(outBody);
       }
-      const sanitizedBody = stripSparkCompatibility(stripUnsupportedReasoningParams(stripItemIdsWhenUnstored(stripInvalidItemIds(stripUnsupportedHostedTools(sanitizeReasoningInputContent(scrubOcxCompactionItems(outBody)))))));
+      const sanitizedBody = normalizeToolSchemas(stripSparkCompatibility(stripUnsupportedReasoningParams(stripItemIdsWhenUnstored(stripInvalidItemIds(stripUnsupportedHostedTools(sanitizeReasoningInputContent(scrubOcxCompactionItems(outBody))))))));
       return {
         url,
         method: "POST",

src/responses/parser.ts

@@ -137,11 +137,15 @@ function allowedToolName(tool: unknown): string | undefined {
 function buildTools(tools: unknown[] | undefined): OcxTool[] | undefined {
   if (!tools) return undefined;
   const out: OcxTool[] = [];
+  const normalizeParameters = (raw: unknown): Record<string, unknown> => {
+    if (isObj(raw) && raw.type === "object") return raw;
+    return { ...(isObj(raw) ? raw : {}), type: "object" };
+  };
   const pushFn = (t: Record<string, unknown>, namespace?: string) => {
     const tool: OcxTool = {
       name: t.name as string,
       description: (t.description as string) ?? "",
-      parameters: (t.parameters ?? {}) as Record<string, unknown>,
+      parameters: normalizeParameters(t.parameters),
     };
     if (t.strict !== undefined) tool.strict = t.strict as boolean;
     if (namespace) tool.namespace = namespace;

tests/openai-responses-passthrough.test.ts

@@ -50,6 +50,80 @@ describe("OpenAI Responses key-auth URL construction", () => {
 });
 
 describe("OpenAI Responses passthrough sanitization", () => {
+  test("normalizes top-level function schemas in the serialized raw body (#745)", () => {
+    const validParameters = {
+      type: "object",
+      properties: { path: { type: "string" } },
+      required: ["path"],
+      additionalProperties: false,
+    };
+    const request = createResponsesPassthroughAdapter(provider).buildRequest({
+      modelId: "gpt-5.5",
+      context: { messages: [] },
+      stream: true,
+      options: {},
+      _rawBody: {
+        model: "gpt-5.5",
+        input: [],
+        tools: [
+          { type: "function", name: "missing_parameters" },
+          { type: "function", name: "missing_root_type", parameters: { properties: { query: { type: "string" } } } },
+          { type: "function", name: "valid_schema", parameters: validParameters },
+        ],
+      },
+    }, { headers: new Headers() });
+    const body = JSON.parse(request.body) as { tools: { name: string; parameters: Record<string, unknown> }[] };
+
+    expect(body.tools).toEqual([
+      { type: "function", name: "missing_parameters", parameters: { type: "object" } },
+      {
+        type: "function",
+        name: "missing_root_type",
+        parameters: { type: "object", properties: { query: { type: "string" } } },
+      },
+      { type: "function", name: "valid_schema", parameters: validParameters },
+    ]);
+  });
+
+  test("normalizes additional_tools function schemas in the serialized raw body (#745)", () => {
+    const validParameters = {
+      type: "object",
+      properties: { path: { type: "string" } },
+      required: ["path"],
+      additionalProperties: false,
+    };
+    const request = createResponsesPassthroughAdapter(provider).buildRequest({
+      modelId: "gpt-5.5",
+      context: { messages: [] },
+      stream: true,
+      options: {},
+      _rawBody: {
+        model: "gpt-5.5",
+        input: [{
+          type: "additional_tools",
+          tools: [
+            { type: "function", name: "missing_parameters" },
+            { type: "function", name: "missing_root_type", parameters: { properties: { query: { type: "string" } } } },
+            { type: "function", name: "valid_schema", parameters: validParameters },
+          ],
+        }],
+      },
+    }, { headers: new Headers() });
+    const body = JSON.parse(request.body) as {
+      input: { type: string; tools: { name: string; parameters: Record<string, unknown> }[] }[];
+    };
+
+    expect(body.input[0].tools).toEqual([
+      { type: "function", name: "missing_parameters", parameters: { type: "object" } },
+      {
+        type: "function",
+        name: "missing_root_type",
+        parameters: { type: "object", properties: { query: { type: "string" } } },
+      },
+      { type: "function", name: "valid_schema", parameters: validParameters },
+    ]);
+  });
+
   test("model reasoning-summary opt-out strips unsupported delivery fields (#323)", () => {
     const adapter = createResponsesPassthroughAdapter({
       adapter: "openai-responses",
@@ -1008,7 +1082,7 @@ describe("OpenAI Responses hosted-tool name conflicts", () => {
     const body = JSON.parse(request.body) as { tools: Array<Record<string, unknown>> };
 
     expect(body.tools).toEqual([
-      { type: "function", name: "image_gen", parameters: {} },
+      { type: "function", name: "image_gen", parameters: { type: "object" } },
       { type: "image_generation" },
     ]);
   });

tests/responses-parser.test.ts

@@ -2,6 +2,34 @@ import { describe, expect, test } from "bun:test";
 import { parseRequest } from "../src/responses/parser";
 
 describe("Responses parser", () => {
+  test("normalizes function tool schemas to an object root without corrupting valid schemas (#745)", () => {
+    const validParameters = {
+      type: "object",
+      properties: { path: { type: "string" } },
+      required: ["path"],
+      additionalProperties: false,
+    };
+    const parsed = parseRequest({
+      model: "test-model",
+      input: "test",
+      tools: [
+        { type: "function", name: "missing_parameters" },
+        { type: "function", name: "missing_root_type", parameters: { properties: { query: { type: "string" } } } },
+        { type: "function", name: "valid_schema", parameters: validParameters },
+      ],
+    });
+
+    expect(parsed.context.tools).toEqual([
+      { name: "missing_parameters", description: "", parameters: { type: "object" } },
+      {
+        name: "missing_root_type",
+        description: "",
+        parameters: { type: "object", properties: { query: { type: "string" } } },
+      },
+      { name: "valid_schema", description: "", parameters: validParameters },
+    ]);
+  });
+
   test("describes the exact apply_patch freeform envelope", () => {
     const parsed = parseRequest({
       model: "xai/grok-4.5",