fix: normalize codex tool function fields

Author: 0x4007

src/openai.ts

@@ -209,14 +209,18 @@ type PassthroughToolSchemaKey = "tools" | "tool_choice" | "parallel_tool_calls"
 const normalizeCodexToolChoice = (value: unknown): unknown => {
   if (!isRecord(value)) return value;
   if (getString(value.type) !== "function") return value;
-  if (typeof value["name"] === "string" && value["name"].trim()) return value;
+
+  const normalized: Record<string, unknown> = { ...value };
+  const topLevelName = getString(normalized.name);
   const fn = isRecord(value.function) ? value.function : null;
-  if (!fn) return value;
+  if (!fn && !topLevelName) return value;
 
-  const name = getString(fn.name);
-  if (!name) return value;
+  if (!topLevelName) {
+    const functionName = getString(fn?.name);
+    if (!functionName) return value;
+    normalized.name = functionName;
+  }
 
-  const normalized: Record<string, unknown> = { ...value, name };
   delete normalized.function;
   return normalized;
 };
@@ -229,17 +233,17 @@ const normalizeCodexTools = (value: unknown): unknown => {
     const nestedFunction = isRecord(tool.function) ? tool.function : null;
     if (!nestedFunction) return tool;
 
-    const name = getString(nestedFunction.name);
-    if (!name) return tool;
-    if (typeof tool.name === "string" && tool.name.trim()) return tool;
+    const normalized: Record<string, unknown> = { ...tool };
+    const topLevelName = getString(normalized.name);
+    const nestedName = getString(nestedFunction.name);
+    if (!topLevelName && !nestedName) return tool;
 
-    const normalized: Record<string, unknown> = { ...tool, name };
-    if (!("description" in normalized) && nestedFunction.description !== undefined) {
-      normalized.description = nestedFunction.description;
+    if (!topLevelName) {
+      normalized.name = nestedName;
     }
-    if (!("parameters" in normalized)) {
-      const nestedParameters = nestedFunction.parameters;
-      if (nestedParameters !== undefined) normalized.parameters = nestedParameters;
+    for (const [key, nestedValue] of Object.entries(nestedFunction)) {
+      if (key in normalized) continue;
+      normalized[key] = nestedValue;
     }
     delete normalized.function;
     return normalized;

tests/openai-compat.test.ts

@@ -249,9 +249,14 @@ Deno.test("openai: normalize function-style tools for codex compatibility", asyn
                   name: "legacy_tool",
                   description: "Already top-level tool name.",
                   parameters: { type: "object", properties: {} },
+                  function: { strict: true },
                 },
               ],
-              tool_choice: { type: "function", function: { name: "fetch_weather" } },
+              tool_choice: {
+                type: "function",
+                name: "forced_choice",
+                function: { name: "fetch_weather", strict: true },
+              },
             }),
           }),
         ),
@@ -265,11 +270,19 @@ Deno.test("openai: normalize function-style tools for codex compatibility", asyn
     assert.equal(recordedTools.length, 2);
     assert.equal(recordedTools[0]?.name, "fetch_weather");
     assert.equal(recordedTools[1]?.name, "legacy_tool");
+    assert.equal(recordedTools[0]?.description, "Fetch weather for a city.");
+    assert.deepEqual(recordedTools[0]?.parameters, {
+      type: "object",
+      properties: { city: { type: "string" } },
+    });
+    assert.equal(recordedTools[1]?.strict, true);
     assert.equal(Object.prototype.hasOwnProperty.call(recordedTools[0], "function"), false);
+    assert.equal(Object.prototype.hasOwnProperty.call(recordedTools[1], "function"), false);
     const recordedToolChoice = recorded["tool_choice"] as Record<string, unknown> | undefined;
     assert.ok(recordedToolChoice);
     assert.equal(recordedToolChoice.type, "function");
-    assert.equal(recordedToolChoice["name"], "fetch_weather");
+    assert.equal(recordedToolChoice["name"], "forced_choice");
+    assert.equal(Object.prototype.hasOwnProperty.call(recordedToolChoice, "strict"), false);
     assert.equal(Object.prototype.hasOwnProperty.call(recordedToolChoice, "function"), false);
   });
 
@@ -310,6 +323,8 @@ Deno.test("openai: normalize function-style tools for codex compatibility", asyn
     assert.ok(Array.isArray(recordedTools));
     assert.equal(recordedTools.length, 1);
     assert.equal(recordedTools[0]?.name, "fetch_weather");
+    assert.equal(recordedTools[0]?.description, "Fetch weather for a city.");
+    assert.deepEqual(recordedTools[0]?.parameters, { type: "object", properties: { city: { type: "string" } } });
     assert.equal(Object.prototype.hasOwnProperty.call(recordedTools[0], "function"), false);
   });
 });