codex-grok-bridge 1.0.4 → 1.5.0

package/src/tools.mjs

@@ -4,6 +4,7 @@ import {
   isImageGenerationItem,
   saveGeneratedImage,
 } from "./imagegen.mjs";
+import { resolveGrokModel } from "./models.mjs";
 
 const OBJECT_SCHEMA = { type: "object", properties: {} };
 
@@ -56,16 +57,145 @@ const GROK_INPUT_ITEM_TYPES = new Set([
   "function_call_output",
   "shell_call",
 ]);
+// Codex item ids, status, and new client metadata have 422'd the upstream.
+// Keep only the fields Grok's Responses input is known to accept.
+const INPUT_ITEM_FIELDS = {
+  message: ["type", "role", "content"],
+  reasoning: ["type", "summary"],
+  function_call: ["type", "name", "call_id", "arguments"],
+  function_call_output: ["type", "name", "call_id", "output"],
+  shell_call: ["type", "name", "call_id", "action"],
+};
+const CONTENT_PART_FIELDS = {
+  input_text: ["type", "text"],
+  output_text: ["type", "text"],
+  summary_text: ["type", "text"],
+  input_image: ["type", "image_url", "detail"],
+};
+
+function pickKeys(node, keys) {
+  const next = {};
+  for (const key of keys) {
+    if (node[key] !== undefined) next[key] = node[key];
+  }
+  return next;
+}
+
+function whitelistContentPart(part) {
+  if (!part || typeof part !== "object" || Array.isArray(part)) return part;
+  const keys = CONTENT_PART_FIELDS[part.type];
+  if (!keys) return part;
+  const next = pickKeys(part, keys);
+  if (next.image_url && typeof next.image_url === "object")
+    next.image_url = pickKeys(next.image_url, ["url", "detail"]);
+  return next;
+}
+
+function whitelistInputNode(node) {
+  if (!node || typeof node !== "object" || Array.isArray(node)) return node;
+  const itemKeys = INPUT_ITEM_FIELDS[node.type];
+  if (itemKeys) {
+    const next = pickKeys(node, itemKeys);
+    if (Array.isArray(next.content))
+      next.content = next.content.map(whitelistContentPart);
+    return next;
+  }
+  if (node.type == null && node.role != null && node.content !== undefined) {
+    const next = pickKeys(node, ["role", "content"]);
+    if (Array.isArray(next.content))
+      next.content = next.content.map(whitelistContentPart);
+    return next;
+  }
+  return whitelistContentPart(node);
+}
+
+function isObjectFragment(schema) {
+  return (
+    schema &&
+    typeof schema === "object" &&
+    !Array.isArray(schema) &&
+    (schema.type === "object" || schema.type == null)
+  );
+}
+
+function mergeObjectFragments(fragments) {
+  const properties = {};
+  let required;
+  for (const fragment of fragments) {
+    if (fragment.properties && typeof fragment.properties === "object")
+      Object.assign(properties, fragment.properties);
+    if (Array.isArray(fragment.required)) {
+      required =
+        required === undefined
+          ? fragment.required.slice()
+          : required.filter((key) => fragment.required.includes(key));
+    }
+  }
+  return { properties, required };
+}
+
+function emitObjectParameters(source, overrides = {}) {
+  const properties =
+    overrides.properties ??
+    (source.properties && typeof source.properties === "object"
+      ? source.properties
+      : {});
+  const required =
+    overrides.required !== undefined
+      ? overrides.required
+      : Array.isArray(source.required)
+        ? source.required
+        : undefined;
+  const next = { type: "object", properties: { ...properties } };
+  if (required?.length) next.required = required.slice();
+  if (source.additionalProperties !== undefined)
+    next.additionalProperties = source.additionalProperties;
+  if (source.description !== undefined) next.description = source.description;
+  return next;
+}
 
 function usableParameters(parameters) {
-  if (!parameters || typeof parameters !== "object") return OBJECT_SCHEMA;
-  if (
-    parameters.type === "object" ||
-    Array.isArray(parameters.oneOf) ||
-    Array.isArray(parameters.anyOf)
-  )
-    return parameters;
-  return OBJECT_SCHEMA;
+  if (!parameters || typeof parameters !== "object" || Array.isArray(parameters))
+    return OBJECT_SCHEMA;
+  const variants = Array.isArray(parameters.oneOf)
+    ? parameters.oneOf
+    : Array.isArray(parameters.anyOf)
+      ? parameters.anyOf
+      : null;
+  if (!variants) {
+    return parameters.type === "object"
+      ? emitObjectParameters(parameters)
+      : OBJECT_SCHEMA;
+  }
+  const fragments = variants.filter(isObjectFragment);
+  if (fragments.length === 0) {
+    return parameters.type === "object"
+      ? emitObjectParameters(parameters)
+      : OBJECT_SCHEMA;
+  }
+  const merged = mergeObjectFragments(fragments);
+  const properties = {
+    ...(parameters.properties && typeof parameters.properties === "object"
+      ? parameters.properties
+      : {}),
+    ...merged.properties,
+  };
+  let required = merged.required;
+  if (Array.isArray(parameters.required)) {
+    required =
+      required === undefined
+        ? parameters.required.slice()
+        : required.filter((key) => parameters.required.includes(key));
+  }
+  const first = fragments[0];
+  return emitObjectParameters(
+    {
+      additionalProperties:
+        parameters.additionalProperties ?? first.additionalProperties,
+      description: parameters.description ?? first.description,
+    },
+    { properties, required },
+  );
 }
 
 function sanitize(name) {
@@ -189,7 +319,7 @@ function toProxyInputNode(node, map, state) {
     if (
       key === "encrypted_content" ||
       key === "encrypted_function_args" ||
-      key === "internal_chat_message_metadata_passthrough"
+      key.startsWith("internal_")
     )
       continue;
     const converted = toProxyInputNode(value, map, state);
@@ -204,7 +334,7 @@ function toProxyInputNode(node, map, state) {
       (part) => part && typeof part.text === "string" && part.text.trim(),
     );
     if (!summary.length) return DROP;
-    return { type: "reasoning", summary };
+    return whitelistInputNode({ type: "reasoning", summary });
   }
 
   if (next.type === "agent_message") {
@@ -214,7 +344,7 @@ function toProxyInputNode(node, map, state) {
         ? [{ type: "input_text", text: next.text }]
         : [];
     if (!content.length) return DROP;
-    return { type: "message", role: "assistant", content };
+    return whitelistInputNode({ type: "message", role: "assistant", content });
   }
 
   if (
@@ -227,10 +357,7 @@ function toProxyInputNode(node, map, state) {
       delete next.namespace;
       if (typeof next.call_id === "string") state.callIds.set(next.call_id, proxyName);
     }
-    return next;
-  }
-
-  if (
+  } else if (
     next.type === "custom_tool_call" &&
     typeof next.name === "string"
   ) {
@@ -244,10 +371,7 @@ function toProxyInputNode(node, map, state) {
       delete next.input;
       if (typeof next.call_id === "string") state.callIds.set(next.call_id, proxyName);
     }
-    return next;
-  }
-
-  if (
+  } else if (
     next.type === "function_call_output" ||
     next.type === "custom_tool_call_output"
   ) {
@@ -262,10 +386,9 @@ function toProxyInputNode(node, map, state) {
       next.name = proxyName;
       delete next.namespace;
     }
-    return next;
   }
 
-  return next;
+  return whitelistInputNode(next);
 }
 
 function toProxyInput(input, map) {
@@ -304,7 +427,7 @@ export function toProxyRequest(body) {
   const { tools, map } = flattenCodexTools(body.tools ?? []);
   const effort = EFFORT[body.reasoning?.effort] ?? "high";
   const request = {
-    model: "grok-4.6",
+    model: resolveGrokModel(body.model),
     input: toProxyInput(body.input, map),
     tools,
     reasoning: { effort },