codex-grok-bridge 1.7.0 → 1.7.2

package/src/tools.mjs

@@ -4,6 +4,7 @@ import {
   isImageGenerationItem,
   saveGeneratedImage,
 } from "./imagegen.mjs";
+import { GROK_VIDEO_TOOL, GROK_VIDEO_TOOL_NAME } from "./videogen.mjs";
 import { DEFAULT_GROK_MODEL, resolveGrokModel } from "./models.mjs";
 import {
   applyCacheUsage,
@@ -27,14 +28,6 @@ const CUSTOM_INPUT_SCHEMA = {
   additionalProperties: false,
 };
 
-const WEB_SEARCH_SCHEMA = {
-  type: "object",
-  properties: {
-    query: { type: "string", description: "Search query" },
-  },
-  required: ["query"],
-};
-
 const EFFORT = {
   ultra: "xhigh",
   max: "xhigh",
@@ -50,12 +43,14 @@ const DROP = Symbol("drop");
 // Items whose payload only the originating provider can read. "reasoning" is
 // deliberately absent: Codex reasoning items carry a plain-text summary that is
 // useful to Grok across a multi-call turn, and only their encrypted_content is
-// opaque - that field is stripped by the key filter below.
-const PROVIDER_OPAQUE_TYPES = new Set([
+// opaque - that field is stripped by the key filter below. Compaction items are
+// likewise absent: a stored summary is rewritten into a user message, and an
+// item with no readable text is dropped.
+const PROVIDER_OPAQUE_TYPES = new Set(["encrypted_content"]);
+const COMPACTION_ITEM_TYPES = new Set([
   "compaction",
   "compaction_summary",
   "context_compaction",
-  "encrypted_content",
 ]);
 const GROK_INPUT_ITEM_TYPES = new Set([
   "message",
@@ -233,6 +228,21 @@ function decodeCustomInput(argumentsValue) {
   return argumentsValue;
 }
 
+function plainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// xAI runs `{type:"web_search"}` on the server. A hashed function is never
+// called, so Codex's hosted tool stays one server tool. Keep filters and
+// allowed_domains; every other field on that tool is dropped.
+function keptWebSearchFields(tool) {
+  const next = {};
+  if (plainObject(tool.filters)) next.filters = tool.filters;
+  if (Array.isArray(tool.allowed_domains))
+    next.allowed_domains = tool.allowed_domains;
+  return next;
+}
+
 function addFunction(flattened, map, spec) {
   // Index names change when Codex reorders tools, which rewrites every
   // earlier function_call and breaks the prompt-cache prefix.
@@ -264,8 +274,25 @@ function addFunction(flattened, map, spec) {
 export function flattenCodexTools(tools = []) {
   const flattened = [];
   const map = new Map();
+  let webSearch = null;
   for (const tool of tools) {
     if (!tool || typeof tool !== "object") continue;
+    if (tool.type === "web_search") {
+      const kept = keptWebSearchFields(tool);
+      if (!webSearch) {
+        webSearch = { type: "web_search", ...kept };
+        flattened.push(webSearch);
+      } else {
+        if (webSearch.filters === undefined && kept.filters !== undefined)
+          webSearch.filters = kept.filters;
+        if (
+          webSearch.allowed_domains === undefined &&
+          kept.allowed_domains !== undefined
+        )
+          webSearch.allowed_domains = kept.allowed_domains;
+      }
+      continue;
+    }
     if (tool.type === "function" || tool.type === "custom") {
       addFunction(flattened, map, {
         kind: tool.type === "custom" ? "custom" : "function",
@@ -276,16 +303,6 @@ export function flattenCodexTools(tools = []) {
       });
       continue;
     }
-    if (tool.type === "web_search") {
-      addFunction(flattened, map, {
-        kind: "web_search",
-        namespace: null,
-        name: "web_search",
-        description: tool.description || "Search the web",
-        parameters: tool.parameters || WEB_SEARCH_SCHEMA,
-      });
-      continue;
-    }
     if (tool.type === "namespace" && Array.isArray(tool.tools)) {
       for (const nested of tool.tools) {
         if (!nested || typeof nested !== "object") continue;
@@ -301,6 +318,10 @@ export function flattenCodexTools(tools = []) {
     }
     flattened.push(stableJsonValue(structuredClone(tool)));
   }
+  if (webSearch) {
+    const index = flattened.indexOf(webSearch);
+    flattened[index] = stableJsonValue(structuredClone(webSearch));
+  }
   return { tools: flattened, map };
 }
 
@@ -316,7 +337,178 @@ export function proxyToolChoice(choice, map) {
   return "auto";
 }
 
-function toProxyInputNode(node, map, state) {
+function readableString(value) {
+  return typeof value === "string" && value.trim() ? value : null;
+}
+
+function textsFromValue(value) {
+  const direct = readableString(value);
+  if (direct) return [direct];
+  if (!Array.isArray(value)) return [];
+  const texts = [];
+  for (const part of value) {
+    if (!part || typeof part !== "object" || part.type === "encrypted_content")
+      continue;
+    const text = readableString(part.text);
+    if (text) texts.push(text);
+  }
+  return texts;
+}
+
+// Codex replaces older history with a compaction item. The encrypted blob is
+// provider-private, but the item may already carry the summary as plain text.
+// That text is what Grok can read; everything else on the item is dropped.
+function compactionInputTexts(node) {
+  for (const key of ["summary", "content", "text", "message"]) {
+    const texts = textsFromValue(node[key]);
+    if (texts.length) return texts;
+  }
+  return [];
+}
+
+function rememberText(texts, seen, value) {
+  const text = readableString(value);
+  if (!text || seen.has(text)) return;
+  seen.add(text);
+  texts.push(text);
+}
+
+// Content parts, stdout/stderr rows, and bare string lists. Encrypted parts
+// are skipped. This does not walk arbitrary keys, so ids, status, env, and
+// image bytes are not treated as text.
+function rememberTextValue(texts, seen, value) {
+  if (typeof value === "string") {
+    rememberText(texts, seen, value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const part of value) {
+      if (typeof part === "string") {
+        rememberText(texts, seen, part);
+        continue;
+      }
+      if (!part || typeof part !== "object" || part.type === "encrypted_content")
+        continue;
+      rememberText(texts, seen, part.text);
+      rememberText(texts, seen, part.stdout);
+      rememberText(texts, seen, part.stderr);
+    }
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+  rememberText(texts, seen, value.text);
+  rememberText(texts, seen, value.stdout);
+  rememberText(texts, seen, value.stderr);
+  if (typeof value.content === "string" || Array.isArray(value.content))
+    rememberTextValue(texts, seen, value.content);
+}
+
+function commandLines(action) {
+  const lines = [];
+  for (const list of [action.command, action.commands]) {
+    if (Array.isArray(list)) {
+      const line = list.filter((part) => typeof part === "string").join(" ").trim();
+      if (line) lines.push(line);
+    } else if (typeof list === "string" && list.trim()) {
+      lines.push(list.trim());
+    }
+  }
+  return lines;
+}
+
+function rememberArguments(texts, seen, value) {
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+        value = parsed;
+      else {
+        rememberText(texts, seen, value);
+        return;
+      }
+    } catch {
+      rememberText(texts, seen, value);
+      return;
+    }
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return;
+  rememberText(texts, seen, value.query);
+  rememberTextValue(texts, seen, value.queries);
+}
+
+function stripOpaqueFields(value) {
+  if (Array.isArray(value)) return value.map(stripOpaqueFields);
+  if (!value || typeof value !== "object") return value;
+  const next = {};
+  for (const [key, child] of Object.entries(value)) {
+    if (
+      key === "encrypted_content" ||
+      key === "encrypted_function_args" ||
+      key.startsWith("internal_")
+    )
+      continue;
+    next[key] = stripOpaqueFields(child);
+  }
+  return next;
+}
+
+function containsReadableText(value) {
+  if (typeof value === "string") return Boolean(value.trim());
+  if (Array.isArray(value)) return value.some(containsReadableText);
+  if (value && typeof value === "object")
+    return Object.values(value).some(containsReadableText);
+  return false;
+}
+
+function rememberTools(texts, seen, tools) {
+  if (!Array.isArray(tools) || !tools.length) return;
+  const stripped = stripOpaqueFields(tools);
+  if (!containsReadableText(stripped)) return;
+  rememberText(texts, seen, JSON.stringify(stripped));
+}
+
+// Text Grok can read off an item type it will not accept. The caller turns
+// these strings into a user message. Fields that 422 when forwarded
+// (encrypted blobs, internal metadata, image bytes) are not read.
+function droppedItemInputTexts(node) {
+  const texts = [];
+  const seen = new Set();
+  for (const key of [
+    "summary",
+    "content",
+    "text",
+    "message",
+    "input",
+    "output",
+    "query",
+    "revised_prompt",
+  ]) {
+    rememberTextValue(texts, seen, node[key]);
+  }
+  const action = node.action;
+  if (action && typeof action === "object" && !Array.isArray(action)) {
+    const lines = commandLines(action);
+    for (const line of lines) rememberText(texts, seen, line);
+    if (lines.length) rememberText(texts, seen, action.working_directory);
+    rememberText(texts, seen, action.query);
+    rememberTextValue(texts, seen, action.queries);
+    rememberText(texts, seen, action.url);
+    rememberText(texts, seen, action.pattern);
+  }
+  rememberArguments(texts, seen, node.arguments);
+  rememberTools(texts, seen, node.tools);
+  return texts;
+}
+
+function userInputTextMessage(texts) {
+  return whitelistInputNode({
+    type: "message",
+    role: "user",
+    content: texts.map((text) => ({ type: "input_text", text })),
+  });
+}
+
+function toProxyInputNode(node, map, state, salvage = false) {
   if (!node || typeof node !== "object") return node;
   if (Array.isArray(node)) {
     const items = [];
@@ -342,6 +534,16 @@ function toProxyInputNode(node, map, state) {
     if (converted !== DROP) next[key] = converted;
   }
 
+  if (COMPACTION_ITEM_TYPES.has(next.type)) {
+    const texts = compactionInputTexts(next);
+    if (!texts.length) return DROP;
+    return whitelistInputNode({
+      type: "message",
+      role: "user",
+      content: texts.map((text) => ({ type: "input_text", text })),
+    });
+  }
+
   if (next.type === "reasoning") {
     // Forward the summary and nothing else. Codex's own item id and null
     // content fields mean nothing to the upstream and only widen the surface
@@ -404,7 +606,14 @@ function toProxyInputNode(node, map, state) {
     }
   }
 
-  return whitelistInputNode(next);
+  const whitelisted = whitelistInputNode(next);
+  if (!salvage || isForwardedItem(whitelisted)) return whitelisted;
+  // Grok rejects these Codex item types. Keep the readable text as a user
+  // message, the same shape as a compaction summary. An item with nothing
+  // left but an encrypted blob, image bytes, or ids is dropped.
+  const texts = droppedItemInputTexts(next);
+  if (!texts.length) return DROP;
+  return userInputTextMessage(texts);
 }
 
 function isForwardedItem(item) {
@@ -419,14 +628,14 @@ function isForwardedItem(item) {
 
 function projectInput(input, map) {
   if (!Array.isArray(input)) {
-    const items = toProxyInputNode(input, map, { callIds: new Map() });
+    const items = toProxyInputNode(input, map, { callIds: new Map() }, true);
     return { items, pairs: [] };
   }
   const state = { callIds: new Map() };
   const pairs = [];
   for (const item of input) {
     const fingerprint = logicalFingerprint(item);
-    const next = toProxyInputNode(item, map, state);
+    const next = toProxyInputNode(item, map, state, true);
     if (!isForwardedItem(next)) continue;
     pairs.push({ fingerprint, item: next });
   }
@@ -463,6 +672,14 @@ export const IMAGE_GENERATION_PROVENANCE =
   "and do not use OpenAI, image_gen, or a Python image CLI — those send the " +
   "picture to another vendor.";
 
+// Codex does not offer a video tool to this provider, and cli-chat-proxy has
+// no video_generation tool type. The function below is the bridge's own.
+export const VIDEO_GENERATION_PROVENANCE =
+  "Videos: clips on this transport are generated by the grok_bridge_generate_video " +
+  "function, which is already on the request. The bridge calls Grok's videos API " +
+  "with the grok login and returns the video URL. Do not ask for an API key and " +
+  "do not send the clip to another vendor.";
+
 export function toProxyRequest(body) {
   const { tools, map } = flattenCodexTools(body.tools ?? []);
   const effort = EFFORT[body.reasoning?.effort] ?? "high";
@@ -484,13 +701,25 @@ export function toProxyRequest(body) {
   const imageGenOn = process.env.GROK_BRIDGE_IMAGE_GEN !== "off";
   if (imageGenOn && !declaresImageTool)
     request.tools = [...request.tools, GROK_IMAGE_TOOL];
+  // Codex tool names are rewritten to codex_<hash>_…, so this literal name
+  // cannot collide with one. A second copy is not added if it is already there.
+  const videoGenOn = process.env.GROK_BRIDGE_VIDEO_GEN !== "off";
+  const declaresVideoTool = request.tools.some(
+    (tool) => tool?.name === GROK_VIDEO_TOOL_NAME,
+  );
+  if (videoGenOn && !declaresVideoTool)
+    request.tools = [...request.tools, GROK_VIDEO_TOOL];
   if (tools.length) {
     request.tool_choice = proxyToolChoice(body.tool_choice, map);
     request.parallel_tool_calls = body.parallel_tool_calls !== false;
   }
   const provenanceLine = transportProvenance(request.model);
-  const provenance = imageGenOn
-    ? `${provenanceLine}\n\n${IMAGE_GENERATION_PROVENANCE}`
+  const notes = [
+    imageGenOn ? IMAGE_GENERATION_PROVENANCE : "",
+    videoGenOn ? VIDEO_GENERATION_PROVENANCE : "",
+  ].filter(Boolean);
+  const provenance = notes.length
+    ? `${provenanceLine}\n\n${notes.join("\n\n")}`
     : provenanceLine;
   request.instructions =
     typeof body.instructions === "string" && body.instructions

package/src/videogen.mjs

@@ -0,0 +1,196 @@
+// cli-chat-proxy has no Responses `video_generation` tool. grok-build generates
+// video by calling the videos API itself when the model invokes a function
+// (`image_to_video` / `reference_to_video`): POST {xai_api_base}/videos/generations,
+// then GET /videos/{request_id}. The bridge does the same with the grok login
+// bearer it already sends to cli-chat-proxy — the `key` from that session, not
+// an XAI_API_KEY.
+
+export const GROK_VIDEO_TOOL_NAME = "grok_bridge_generate_video";
+
+export const DEFAULT_VIDEO_API_BASE = "https://api.x.ai/v1";
+
+const VIDEO_MODEL = "grok-imagine-video-1.5";
+const POLL_LIMIT = 60;
+
+export const GROK_VIDEO_TOOL = Object.freeze({
+  type: "function",
+  name: GROK_VIDEO_TOOL_NAME,
+  description:
+    "Generate a short video with Grok. The bridge runs this tool itself; Codex does not. " +
+    "Provide a prompt. Provide image_url only when the clip should start from that still image.",
+  parameters: {
+    type: "object",
+    properties: {
+      prompt: { type: "string", description: "What the video should show." },
+      image_url: {
+        type: "string",
+        description: "Optional http(s) or data URL of a still image to animate.",
+      },
+      duration: {
+        type: "integer",
+        description: "Length in seconds, from 1 to 15.",
+      },
+      aspect_ratio: {
+        type: "string",
+        description: "One of 1:1, 16:9, 9:16, 4:3, 3:4, 3:2, 2:3.",
+      },
+    },
+    required: ["prompt"],
+    additionalProperties: false,
+  },
+});
+
+function scrub(text, token) {
+  let out = String(text ?? "");
+  out = out.replace(/Bearer\s+\S+/gi, "Bearer [redacted]");
+  if (token) out = out.split(token).join("[redacted]");
+  return out;
+}
+
+function parseArgs(value) {
+  if (value && typeof value === "object") return value;
+  if (typeof value !== "string" || !value.trim()) return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function videoPayload(args) {
+  const payload = { model: VIDEO_MODEL, prompt: args.prompt };
+  if (typeof args.image_url === "string" && args.image_url.trim())
+    payload.image = { url: args.image_url.trim() };
+  if (Number.isInteger(args.duration)) payload.duration = args.duration;
+  else if (typeof args.duration === "string" && /^\d+$/.test(args.duration))
+    payload.duration = Number(args.duration);
+  if (typeof args.aspect_ratio === "string" && args.aspect_ratio.trim())
+    payload.aspect_ratio = args.aspect_ratio.trim();
+  return payload;
+}
+
+async function videoHttp(fetchImpl, url, init) {
+  const response = await fetchImpl(url, { ...init, redirect: "manual" });
+  const text = await response.text().catch(() => "");
+  if (response.status >= 300 && response.status < 400) {
+    const error = new Error("Video generation failed (redirect).");
+    error.status = response.status;
+    throw error;
+  }
+  let body = null;
+  if (text) {
+    try {
+      body = JSON.parse(text);
+    } catch {
+      body = null;
+    }
+  }
+  return { status: response.status, body };
+}
+
+function httpFailure(status) {
+  const error = new Error(`Video generation failed (${status}).`);
+  error.status = status;
+  return error;
+}
+
+export async function generateVideo(options) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const base = (options.baseUrl ?? DEFAULT_VIDEO_API_BASE).replace(/\/$/, "");
+  const headers = {
+    authorization: `Bearer ${options.token}`,
+    "content-type": "application/json",
+  };
+  const started = await videoHttp(fetchImpl, `${base}/videos/generations`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(videoPayload(options)),
+    signal: options.signal,
+  });
+  if (started.status < 200 || started.status >= 300)
+    throw httpFailure(started.status);
+  const requestId = started.body?.request_id;
+  if (typeof requestId !== "string" || !requestId)
+    throw httpFailure(started.status);
+  const pause = options.pause ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  for (let attempt = 0; attempt < POLL_LIMIT; attempt += 1) {
+    if (attempt > 0) await pause(5000);
+    const poll = await videoHttp(
+      fetchImpl,
+      `${base}/videos/${encodeURIComponent(requestId)}`,
+      { method: "GET", headers, signal: options.signal },
+    );
+    if (poll.status === 202) continue;
+    if (poll.status < 200 || poll.status >= 300) throw httpFailure(poll.status);
+    const status = poll.body?.status;
+    if (status === "done") {
+      const url = poll.body?.video?.url;
+      if (typeof url !== "string" || !url)
+        throw new Error("Video generation finished without a URL.");
+      return url;
+    }
+    if (status === "failed" || status === "expired")
+      throw new Error(`Video generation ${status}.`);
+  }
+  throw new Error("Video generation timed out.");
+}
+
+export async function videoToolOutput(call, options) {
+  const token = options?.token;
+  try {
+    const args = parseArgs(call?.arguments);
+    const prompt = typeof args.prompt === "string" ? args.prompt.trim() : "";
+    if (!prompt) return "Video generation failed: a prompt is required.";
+    const url = await generateVideo({
+      token: options.token,
+      fetchImpl: options.fetchImpl,
+      baseUrl: options.baseUrl,
+      pause: options.pause,
+      signal: options.signal,
+      prompt,
+      image_url: args.image_url,
+      duration: args.duration,
+      aspect_ratio: args.aspect_ratio,
+    });
+    return scrub(`Video ready at ${url}`, token);
+  } catch (error) {
+    const status = Number(error?.status) || 0;
+    if (status === 401 || status === 403)
+      return `Video generation failed (${status}).`;
+    return "Video generation failed.";
+  }
+}
+
+export function videoCallsFromParts(parts) {
+  const calls = [];
+  const seen = new Set();
+  for (const part of parts ?? []) {
+    for (const line of String(part).split("\n")) {
+      if (!line.startsWith("data:")) continue;
+      const payload = line.slice(5).trim();
+      if (!payload || payload === "[DONE]") continue;
+      let value;
+      try {
+        value = JSON.parse(payload);
+      } catch {
+        continue;
+      }
+      const item = value?.item;
+      if (value?.type !== "response.output_item.done") continue;
+      if (item?.type !== "function_call" || item.name !== GROK_VIDEO_TOOL_NAME)
+        continue;
+      if (typeof item.call_id !== "string" || seen.has(item.call_id)) continue;
+      seen.add(item.call_id);
+      calls.push({
+        name: item.name,
+        call_id: item.call_id,
+        arguments:
+          typeof item.arguments === "string"
+            ? item.arguments
+            : JSON.stringify(item.arguments ?? {}),
+      });
+    }
+  }
+  return calls;
+}