codex-grok-bridge 1.7.1 → 1.7.2

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 1.7.2 — 2026-09-30
+
+- Readable compaction summaries are passed through as user messages. A compaction item that only carries encrypted or internal fields is still dropped.
+- A Grok thread can generate a video without an API key. The bridge declares `grok_bridge_generate_video` on the upstream request and, when the model calls it, posts to `https://api.x.ai/v1/videos/generations` with the grok login bearer, polls `GET /videos/{request_id}`, and returns the video URL to the model as the tool result. A refusal from that API stays a tool error and does not fail the turn.
+- Codex input items Grok does not accept (`local_shell_call`, `web_search_call`, `tool_search_call`, `tool_search_output`, `additional_tools`, `image_generation_call`, and unmapped custom tool items) keep their readable text as user `input_text` messages, the same shape as a compaction summary. That text includes shell commands, search queries, tool-search text, an image `revised_prompt`, and custom tool text. `encrypted_content`, `encrypted_function_args`, `internal_*` fields, and image-byte `result` values stay dropped.
+- `POST /v1/images/generations` and `POST /v1/images/edits` are forwarded to the Imagine API with the grok login bearer. Codex's `gpt-image-2` body is rewritten to `grok-imagine-image-quality` and `b64_json`. OpenAI `file_id` edits are refused. No `XAI_API_KEY`.
+- Codex `web_search` is kept as one server-side `{type:"web_search"}` tool. `web_search_call` results are passed through to Codex.
+- Voice WebRTC (`POST /v1/realtime/calls`) and Codex cloud tasks are not in this package.
+
 ## 1.7.1 — 2026-09-30
 
 - The bridge holds the upstream reply and sends it to Codex only after `response.completed`. A reset before that (`ECONNRESET`, `EPIPE`, `UND_ERR_SOCKET`, or a close before the reply finishes) is retried up to two more times, and only if Codex has not been sent a byte. This provider's Codex `request_max_retries` and `stream_max_retries` are 0. A retry sends the prompt again, so that attempt's input tokens can be billed again.

package/README.md

@@ -30,13 +30,45 @@ The bridge does **not** execute Grok-native tools. It translates Codex tools int
 function calling, streams the upstream Responses events, and rewrites names back
 so Codex still recognizes them.
 
-Fourteen files under `src/`. Zero runtime dependencies. Node.js ≥ 22.
+Eighteen files under `src/`. Zero runtime dependencies. Node.js ≥ 22.
 
 This is not a second-opinion review product and not a Grok-native search
 product. The picker shows `grok-4.7` (Grok 4.7 / xAI) and keeps `grok-4.6`.
 Any other `grok-*` id uses the same route. `GROK_BRIDGE_MODELS` adds further
-`grok-*` ids. If Codex exposes a web-search tool, Grok can call
-that tool the same way it calls any other Codex tool.
+`grok-*` ids. Codex `web_search` is xAI's server-side tool, not a function
+the bridge runs. See Release history.
+
+## Release history
+
+What each recent version added. Older cuts are in `CHANGELOG.md`.
+
+### 1.7.2 — 2026-09-30
+
+- Readable compaction summaries are passed through as user messages. A compaction item that only carries encrypted or internal fields is still dropped.
+- `grok_bridge_generate_video`. The bridge declares this tool and, when the model calls it, posts to `https://api.x.ai/v1/videos/generations` with the grok login bearer, polls `GET /videos/{request_id}`, and returns the video URL as the tool result. A refusal from that API stays a tool error and does not fail the turn.
+- Readable text from Codex input items that used to be dropped is forwarded as user `input_text`: shell, search, tool-search, a revised image prompt, and custom tool text. Encrypted blobs and image-byte results stay dropped.
+- `POST /v1/images/generations` and `POST /v1/images/edits` are forwarded to the Imagine API with the grok login bearer. Codex's `gpt-image-2` body is rewritten to `grok-imagine-image-quality` and `b64_json`. OpenAI `file_id` edits are refused. No `XAI_API_KEY`.
+- Codex `web_search` is kept as one server-side `{type:"web_search"}` tool. `web_search_call` results are passed through to Codex.
+- Voice WebRTC (`POST /v1/realtime/calls`) and Codex cloud tasks are not in this package.
+
+### 1.7.1 — 2026-09-30
+
+- The bridge holds the upstream reply and sends it to Codex only after `response.completed`. A reset before that (`ECONNRESET`, `EPIPE`, `UND_ERR_SOCKET`, or a close before the reply finishes) is retried up to two more times, and only if Codex has not been sent a byte. This provider's Codex `request_max_retries` and `stream_max_retries` are 0. A retry sends the prompt again, so that attempt's input tokens can be billed again.
+- When `grok --version` fails or does not report a version, the client version is `unknown` instead of the stale `1.0.24`.
+
+### 1.7.0 — 2026-09-29
+
+- One `x-grok-conv-id` per Codex thread, and the forwarded transcript prefix stays byte-stable so the prompt cache can hit. The full transcript is still sent.
+- Upstream `cached_prompt_tokens` and `cache_read_input_tokens` are copied onto `response.completed` usage and the diagnostics log when the proxy sends them, including `0`. Missing counters are not invented.
+
+### 1.6.1 — 2026-09-28
+
+- Darwin bundled CLI resolves `Codex.app/Contents/Resources/codex-cli/bin/codex` when that file exists (Codex 26.924). The legacy `Contents/Resources/codex` path remains the fallback. `CODEX_BINARY` still wins. Linux and Windows layouts are unchanged.
+
+### 1.6.0 — 2026-09-27
+
+- Default catalog model is `grok-4.7` (`Grok 4.7 / xAI`). `grok-4.6` stays listed so existing threads still resolve.
+- `grok-*` still routes to `grok_build_cli`. No other model ids were added. `GROK_BRIDGE_MODELS` still appends extra `grok-*` ids.
 
 ## Requirements
 
@@ -72,7 +104,7 @@ starts, and tears the provider down with that process.
 ```sh
 git clone https://github.com/deximple/codex-grok-bridge.git
 cd codex-grok-bridge
-npm test                        # 174 tests, no network, no inference
+npm test                        # 191 tests, no network, no inference
 node scripts/codex-grok.mjs
 ```
 
@@ -107,8 +139,8 @@ launches from its usual icon.
 2. The wrapper adds Grok to the model catalog and sets the provider of a new
    Grok thread to `grok_build_cli`.
 3. Codex `/v1/responses` requests go to the localhost bridge.
-4. The bridge flattens Codex tools (plain functions, namespaced functions,
-   freeform custom tools, `web_search`) into function tools, then pipes the
+4. The bridge flattens Codex function and custom tools into function tools,
+   forwards `web_search` as xAI's server-side tool, then pipes the
    `cli-chat-proxy.grok.com` Responses stream through.
 5. Tool results return as the next Codex request `input`.
 
@@ -139,8 +171,8 @@ before any of it is sent.
 Codex keeps the conversation and sends the whole turn each time. Grok can
 treat the unchanged beginning as a cache. If the connection drops before
 Codex has been sent any bytes, the bridge tries again. Codex does not send
-that same request again. Voice, cloud tasks, and video are not in this
-release.
+that same request again. Voice WebRTC (`POST /v1/realtime/calls`) and
+Codex cloud tasks are not in this package.
 
 If the Responses path misbehaves, `GROK_BRIDGE_INFERENCE=cli` falls back to the
 older CLI envelope. That path pastes the whole JSON into a prompt each turn, so
@@ -258,7 +290,7 @@ starting a new thread, before the first turn is saved.
 
 ### Not in this release
 
-Voice, cloud tasks, and video generation are not in this release.
+Voice WebRTC (`POST /v1/realtime/calls`) and Codex cloud tasks are not in this package.
 
 Upstream sometimes resets the connection mid-response (three measured cases:
 25 s / 27 s / 253 s, 726 KB–22 MB). The bridge holds the reply and, if that
@@ -308,7 +340,7 @@ Start here when something breaks. Do not open `~/.grok/auth.json` or
 ## Verify
 
 ```sh
-npm test                    # 174 tests, no remote inference
+npm test                    # 191 tests, no remote inference
 npm run test:coverage       # 80% line / branch / function gate
 npm run verify:app-server   # real app-server routing; also runs against an installed bundle
 npm audit --omit=dev
@@ -377,14 +409,46 @@ Grok 4.7을 Codex 모델 목록에 넣고, Codex의 `/v1/responses`를
 calling으로 옮기고, 상류 Responses 스트림을 전달한 뒤, Codex가 알아보는
 이름으로 되돌립니다.
 
-`src/` 아래 파일 14개. 런타임 의존성 없음. Node.js 22 이상. 1.5.0부터 npm
+`src/` 아래 파일 18개. 런타임 의존성 없음. Node.js 22 이상. 1.5.0부터 npm
 `"os"`는 `darwin` / `linux` / `win32`입니다.
 
 코드 리뷰 전용 제품이 아니고 Grok 네이티브 검색 제품도 아닙니다. 피커에는
 `grok-4.7`(Grok 4.7 / xAI)이 기본으로 보이고 `grok-4.6`도 남습니다. 그 외
 `grok-*` id도 같은 경로로 붙고, `GROK_BRIDGE_MODELS`로 카탈로그에 더합니다.
-Codex가 웹 검색 도구를 노출하면 Grok은 다른 Codex 도구와 같이 그 도구를
-호출할 수 있습니다.
+Codex `web_search`는 브리지가 실행하는 함수가 아니라 xAI 서버 도구입니다.
+릴리스 기록을 보세요.
+
+## 릴리스 기록
+
+최근 버전이 더한 것입니다. 그 이전은 `CHANGELOG.md`에 있습니다.
+
+### 1.7.2 — 2026-09-30
+
+- 읽을 수 있는 compaction 요약을 사용자 메시지로 넘깁니다. 암호화된 내용이나 내부 필드만 있는 compaction 항목은 그대로 버립니다.
+- `grok_bridge_generate_video`. 브리지가 이 도구를 선언하고, 모델이 호출하면 grok 로그인 bearer로 `https://api.x.ai/v1/videos/generations`에 보낸 뒤 `GET /videos/{request_id}`를 폴링하고, 영상 URL을 도구 결과로 돌려줍니다. 그 API의 거절은 도구 오류로 남고 턴을 실패시키지 않습니다.
+- 예전에는 버리던 Codex 입력 항목의 읽을 수 있는 글을 사용자 `input_text`로 넘깁니다. 셸, 검색, tool-search, 수정된 이미지 프롬프트, 커스텀 도구 텍스트입니다. 암호화된 blob과 이미지 바이트 결과는 그대로 버립니다.
+- `POST /v1/images/generations`와 `POST /v1/images/edits`를 grok 로그인 bearer로 Imagine API에 넘깁니다. Codex의 `gpt-image-2` 본문은 `grok-imagine-image-quality`와 `b64_json`으로 바꿉니다. OpenAI `file_id` 편집은 거절합니다. `XAI_API_KEY`는 쓰지 않습니다.
+- Codex `web_search`는 서버 측 `{type:"web_search"}` 도구 하나로 유지합니다. `web_search_call` 결과는 Codex로 통과합니다.
+- 음성 WebRTC(`POST /v1/realtime/calls`)와 Codex 클라우드 작업은 이 패키지에 없습니다.
+
+### 1.7.1 — 2026-09-30
+
+- 브리지는 상류 응답을 `response.completed` 이후에만 Codex로 보냅니다. 그 전의 리셋(`ECONNRESET`, `EPIPE`, `UND_ERR_SOCKET`, 또는 응답이 끝나기 전의 닫힘)은 최대 두 번 더 재시도하며, Codex에 바이트를 아직 보내지 않았을 때만 합니다. 이 provider의 Codex `request_max_retries`와 `stream_max_retries`는 0입니다. 재시도는 프롬프트를 다시 보내므로 그 시도의 입력 토큰이 다시 과금될 수 있습니다.
+- `grok --version`이 실패하거나 버전을 보고하지 않으면 클라이언트 버전은 오래된 `1.0.24` 대신 `unknown`입니다.
+
+### 1.7.0 — 2026-09-29
+
+- Codex 스레드마다 `x-grok-conv-id`는 하나이고, 전달하는 트랜스크립트 접두는 바이트 그대로라 프롬프트 캐시가 맞을 수 있습니다. 전체 트랜스크립트는 그대로 보냅니다.
+- 상류가 보내면 `cached_prompt_tokens`와 `cache_read_input_tokens`를 `response.completed` usage와 진단 로그에 복사합니다. `0`도 포함합니다. 없는 카운터는 만들지 않습니다.
+
+### 1.6.1 — 2026-09-28
+
+- Darwin 번들 CLI는 파일이 있으면 `Codex.app/Contents/Resources/codex-cli/bin/codex`를 씁니다(Codex 26.924). 예전 `Contents/Resources/codex`는 폴백으로 남습니다. `CODEX_BINARY`가 우선합니다. Linux와 Windows 배치는 그대로입니다.
+
+### 1.6.0 — 2026-09-27
+
+- 기본 카탈로그 모델은 `grok-4.7`(Grok 4.7 / xAI)입니다. `grok-4.6`은 기존 스레드가 계속 맞게 목록에 남습니다.
+- `grok-*`는 여전히 `grok_build_cli`로 갑니다. 다른 모델 id는 추가하지 않았습니다. `GROK_BRIDGE_MODELS`는 그 외 `grok-*` id를 카탈로그에 더합니다.
 
 ## 필요한 것
 
@@ -419,7 +483,7 @@ codex-grok exec --skip-git-repo-check --sandbox workspace-write '작업 내용'
 ```sh
 git clone https://github.com/deximple/codex-grok-bridge.git
 cd codex-grok-bridge
-npm test                        # 174건, 네트워크·추론 없음
+npm test                        # 191건, 네트워크·추론 없음
 node scripts/codex-grok.mjs
 ```
 
@@ -453,8 +517,8 @@ Codex 창에도 보일 수 있습니다.
 2. 래퍼가 모델 목록에 Grok를 추가하고, 새 Grok 작업의 제공자를
    `grok_build_cli`로 설정합니다.
 3. Codex의 `/v1/responses` 요청은 localhost 브리지로 갑니다.
-4. 브리지는 Codex 도구(일반 함수, namespace 함수, freeform 커스텀, `web_search`)를
-   function tool로 펼친 뒤 `cli-chat-proxy.grok.com` Responses 스트림을 이어줍니다.
+4. 브리지는 Codex 함수·커스텀 도구를 function tool로 펼치고, `web_search`는
+   xAI 서버 도구로 넘긴 뒤 `cli-chat-proxy.grok.com` Responses 스트림을 이어줍니다.
 5. 도구 결과는 다음 Codex 요청의 `input`으로 돌아갑니다.
 
 인증은 `grok login` 세션입니다. `XAI_API_KEY`는 쓰지 않습니다.
@@ -481,8 +545,8 @@ Codex 창에도 보일 수 있습니다.
 
 Codex가 대화를 갖고 있고, 턴마다 그 턴 전체를 보냅니다. 앞부분이 그대로면
 Grok는 그 부분을 캐시로 볼 수 있습니다. Codex에 바이트를 보내기 전에 연결이
-끊기면 브리지가 다시 시도합니다. Codex는 그 요청을 또 보내지 않습니다. 음성,
-클라우드 작업, 영상은 이번 릴리스에 없습니다.
+끊기면 브리지가 다시 시도합니다. Codex는 그 요청을 또 보내지 않습니다. 음성
+WebRTC(`POST /v1/realtime/calls`)와 Codex 클라우드 작업은 이 패키지에 없습니다.
 
 Responses 경로가 이상하면 `GROK_BRIDGE_INFERENCE=cli`로 이전 CLI 봉투 경로를
 씁니다. 매 턴 전체 JSON을 프롬프트로 넣으므로 더 느리고 비싸며, 토큰 단위
@@ -592,7 +656,7 @@ OpenAI 경로가 맞습니다.
 
 ### 이번 릴리스에 없는 것
 
-음성, 클라우드 작업, 영상 생성은 이번 릴리스에 없습니다.
+음성 WebRTC(`POST /v1/realtime/calls`)와 Codex 클라우드 작업은 이 패키지에 없습니다.
 
 상류가 응답 중간에 연결을 리셋하는 경우가 있습니다(실측 3건: 25초 / 27초 /
 253초, 726 KB–22 MB). 브리지는 응답을 들고 있다가, Codex에 그 응답을 보내기
@@ -640,7 +704,7 @@ OpenAI 경로가 맞습니다.
 ## 검증
 
 ```sh
-npm test                    # 174건, 외부 추론 없음
+npm test                    # 191건, 외부 추론 없음
 npm run test:coverage       # line/branch/function 80% 게이트
 npm run verify:app-server   # 실제 app-server 라우팅. 설치된 앱 번들에서도 실행
 npm audit --omit=dev

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-grok-bridge",
-  "version": "1.7.1",
+  "version": "1.7.2",
   "description": "Run Grok 4.7 as the model inside Codex, with Codex still owning tools, permissions, history and MCP. Uses the grok login session, not an API key.",
   "type": "module",
   "license": "MIT",

package/src/bridge.mjs

@@ -8,7 +8,9 @@ import {
   parseGrokResult,
   runGrok,
 } from "./cli-inference.mjs";
-import { relayProxySse } from "./proxy.mjs";
+import { emitProxySse, readRelayProxySse } from "./proxy.mjs";
+import { videoCallsFromParts, videoToolOutput } from "./videogen.mjs";
+import { forwardImagine } from "./imagine.mjs";
 import {
   applyCacheUsage,
   createPrefixMemory,
@@ -23,6 +25,89 @@ import { catalogModelInfos, isGrokModel, MODEL_INFO } from "./models.mjs";
 
 export { MODEL_INFO };
 
+const VIDEO_FOLLOW_UPS = 2;
+
+async function relayWithVideo(options, output, map, usageBox, onClientByte) {
+  let body = options.body;
+  for (let step = 0; step <= VIDEO_FOLLOW_UPS; step += 1) {
+    const parts = await readRelayProxySse({ ...options, body }, output);
+    const calls =
+      process.env.GROK_BRIDGE_VIDEO_GEN === "off" ? [] : videoCallsFromParts(parts);
+    if (!calls.length || step === VIDEO_FOLLOW_UPS) {
+      await emitProxySse(parts, output, map, usageBox, onClientByte);
+      return;
+    }
+    // The videos API poll can sit for minutes. Keepalive is safe here: this
+    // upstream reply is finished, and nothing has been written to Codex yet.
+    onClientByte();
+    const additions = [];
+    for (const call of calls) {
+      const toolOutput = await videoToolOutput(call, options.video);
+      additions.push(
+        {
+          type: "function_call",
+          name: call.name,
+          call_id: call.call_id,
+          arguments: call.arguments,
+        },
+        {
+          type: "function_call_output",
+          name: call.name,
+          call_id: call.call_id,
+          output: toolOutput,
+        },
+      );
+    }
+    body = { ...body, input: [...body.input, ...additions] };
+  }
+}
+
+async function relayImagine(req, res, json, kind, options) {
+  const controller = new AbortController();
+  res.on("close", () => controller.abort());
+  let body;
+  try {
+    const chunks = [];
+    let size = 0;
+    const limit = options.maxBodyBytes ?? 40 * 1024 * 1024;
+    for await (const chunk of req) {
+      size += chunk.length;
+      if (size > limit) return json(413, { error: "Request too large" });
+      chunks.push(chunk);
+    }
+    body = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    return json(400, { error: "Invalid request" });
+  }
+  try {
+    const session = options.grokSession ?? readGrokBearerToken(options.grokHome);
+    const response = await forwardImagine({
+      kind,
+      body,
+      token: session.token,
+      fetchImpl: options.imagineFetch,
+      baseUrl: options.imagineBaseUrl,
+      signal: controller.signal,
+    });
+    if (!res.writableEnded && !res.destroyed) json(200, response);
+  } catch (error) {
+    if (res.writableEnded || res.destroyed) return;
+    if (error instanceof GrokAuthError) return json(401, { error: error.message });
+    const status = Number(error?.status);
+    const message = String(error?.message ?? "");
+    if (
+      status >= 400 &&
+      status < 600 &&
+      (message.startsWith("Image generation") ||
+        message.startsWith("Image edit") ||
+        message.startsWith("OpenAI file") ||
+        message.startsWith("Grok login"))
+    )
+      return json(status, { error: message });
+    return json(502, { error: "Image generation failed." });
+  }
+}
+
 export function publicBridgeError(error, context = {}) {
   if (error instanceof GrokAuthError) return error.message;
   const message = String(error?.message ?? "");
@@ -51,13 +136,20 @@ export function createBridgeServer(options = {}) {
     const route = new URL(req.url, "http://127.0.0.1").pathname;
     if (req.method === "GET" && route === "/v1/models")
       return json(200, { models: catalogModelInfos() });
-    if (req.method !== "POST" || route !== "/v1/responses")
+    const imagineKind =
+      route === "/v1/images/generations"
+        ? "generations"
+        : route === "/v1/images/edits"
+          ? "edits"
+          : null;
+    if (req.method !== "POST" || (!imagineKind && route !== "/v1/responses"))
       return json(404, { error: "Not found" });
     const auth = Buffer.from(req.headers.authorization ?? "");
     if (auth.length !== token.length || !timingSafeEqual(auth, token))
       return json(401, { error: "Unauthorized" });
     if (req.headers.origin)
       return json(403, { error: "Browser requests are not accepted" });
+    if (imagineKind) return relayImagine(req, res, json, imagineKind, options);
     let body;
     let requestBytes = 0;
     try {
@@ -165,7 +257,7 @@ export function createBridgeServer(options = {}) {
           },
         });
       } else {
-        const session = readGrokBearerToken(options.grokHome);
+        const session = options.grokSession ?? readGrokBearerToken(options.grokHome);
         // Grok takes input_image blocks natively; only unusable attachments
         // are swapped for an explanation, so one bad image cannot make the
         // upstream reject the whole conversation.
@@ -179,7 +271,7 @@ export function createBridgeServer(options = {}) {
         request.input = prefixes.reuse(convId, projected);
         const usageBox = {};
         try {
-          await relayProxySse(
+          await relayWithVideo(
             {
               token: session.token,
               userId: session.userId,
@@ -189,9 +281,6 @@ export function createBridgeServer(options = {}) {
               baseUrl: options.proxyBaseUrl,
               convId,
               sessionId: Array.isArray(threadId) ? threadId[0] : threadId,
-              onClientByte: () => {
-                responseStarted = true;
-              },
               onRetry: ({ attempt, kind }) =>
                 diagnostics.record({
                   event: "turn_retried",
@@ -199,10 +288,20 @@ export function createBridgeServer(options = {}) {
                   attempt,
                   elapsedMs: Date.now() - startedAt,
                 }),
+              video: {
+                token: session.token,
+                fetchImpl: options.videoFetch,
+                baseUrl: options.videoBaseUrl,
+                pause: options.videoPause,
+                signal: controller.signal,
+              },
             },
             res,
             map,
             usageBox,
+            () => {
+              responseStarted = true;
+            },
           );
         } finally {
           cacheUsage = usageBox.cacheUsage ?? null;

package/src/imagine.mjs

@@ -0,0 +1,150 @@
+// Codex posts OpenAI Images requests on the provider base
+// (`POST /v1/images/generations`, `POST /v1/images/edits`). grok-build sends
+// the same two paths to the Imagine API with the login bearer, not an
+// XAI_API_KEY. The bodies are not the same: Codex hardcodes `gpt-image-2`
+// plus `size` / `quality` / `background`, and edits use `{image_url}` or
+// `{file_id}`. Imagine wants `grok-imagine-image-quality`, `response_format:
+// b64_json`, and `{url}` references.
+
+export const DEFAULT_IMAGINE_API_BASE = "https://api.x.ai/v1";
+export const IMAGINE_MODEL = "grok-imagine-image-quality";
+
+const IMAGINE_TIMEOUT_MS = 300_000;
+
+function promptOf(input) {
+  const prompt = typeof input?.prompt === "string" ? input.prompt.trim() : "";
+  if (!prompt) {
+    const error = new Error("Image generation requires a prompt.");
+    error.status = 400;
+    throw error;
+  }
+  return prompt;
+}
+
+function basePayload(prompt) {
+  return {
+    model: IMAGINE_MODEL,
+    prompt,
+    n: 1,
+    resolution: "1k",
+    response_format: "b64_json",
+  };
+}
+
+export function imagineGenerationBody(input) {
+  return basePayload(promptOf(input));
+}
+
+export function imagineEditBody(input) {
+  const prompt = promptOf(input);
+  const images = Array.isArray(input?.images) ? input.images : [];
+  const urls = [];
+  for (const image of images) {
+    if (!image || typeof image !== "object") continue;
+    if (typeof image.image_url === "string" && image.image_url.trim()) {
+      urls.push(image.image_url.trim());
+      continue;
+    }
+    if (typeof image.file_id === "string" && image.file_id.trim()) {
+      const error = new Error("OpenAI file ids cannot be edited with Grok.");
+      error.status = 400;
+      throw error;
+    }
+  }
+  if (!urls.length) {
+    const error = new Error("Image edit requires a reference image.");
+    error.status = 400;
+    throw error;
+  }
+  const payload = basePayload(prompt);
+  if (urls.length === 1) payload.image = { url: urls[0] };
+  else {
+    payload.images = urls.map((url) => ({ url }));
+    payload.aspect_ratio = "auto";
+  }
+  return payload;
+}
+
+export function codexImageResponse(payload) {
+  const data = [];
+  if (Array.isArray(payload?.data)) {
+    for (const item of payload.data) {
+      if (item && typeof item.b64_json === "string" && item.b64_json.length)
+        data.push({ b64_json: item.b64_json });
+    }
+  }
+  if (!data.length) {
+    const error = new Error("Image generation returned no image.");
+    error.status = 502;
+    throw error;
+  }
+  const created = Number.isInteger(payload?.created)
+    ? payload.created
+    : Math.floor(Date.now() / 1000);
+  return { created, data };
+}
+
+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;
+}
+
+async function imagineHttp(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("Image generation failed (redirect).");
+    error.status = 502;
+    throw error;
+  }
+  let body = null;
+  if (text) {
+    try {
+      body = JSON.parse(text);
+    } catch {
+      body = null;
+    }
+  }
+  return { status: response.status, body };
+}
+
+export async function forwardImagine(options) {
+  const token = options.token;
+  const kind = options.kind === "edits" ? "edits" : "generations";
+  const payload =
+    kind === "edits" ? imagineEditBody(options.body) : imagineGenerationBody(options.body);
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const base = (options.baseUrl ?? DEFAULT_IMAGINE_API_BASE).replace(/\/$/, "");
+  const timeout = AbortSignal.timeout(IMAGINE_TIMEOUT_MS);
+  const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
+  let result;
+  try {
+    result = await imagineHttp(fetchImpl, `${base}/images/${kind}`, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${token}`,
+        "content-type": "application/json",
+      },
+      body: JSON.stringify(payload),
+      signal,
+    });
+  } catch (error) {
+    if (error?.status) throw error;
+    const wrapped = new Error(scrub(error?.message || "Image generation failed.", token));
+    wrapped.status = 502;
+    throw wrapped;
+  }
+  if (result.status === 401 || result.status === 403) {
+    const error = new Error("Grok login expired. Run grok login.");
+    error.status = 401;
+    throw error;
+  }
+  if (result.status < 200 || result.status >= 300) {
+    const error = new Error(`Image generation failed (${result.status}).`);
+    error.status = result.status >= 400 && result.status < 500 ? result.status : 502;
+    throw error;
+  }
+  return codexImageResponse(result.body);
+}

package/src/proxy.mjs

@@ -261,13 +261,13 @@ export async function pipeProxySse(stream, output, map, usageBox, onClientByte)
 
 // Open and read one attempt. If the socket dies before Codex has a byte, send
 // the same request again. Once a byte has been written, never resubmit.
-export async function relayProxySse(options, output, map, usageBox, attempts = PROXY_ATTEMPTS) {
+async function relayAttempts(options, consume, attempts = PROXY_ATTEMPTS) {
   const rounds = Math.max(1, attempts);
   let lastError;
   for (let attempt = 1; attempt <= rounds; attempt += 1) {
     try {
       const response = await openProxyStream(options);
-      await pipeProxySse(response.body, output, map, usageBox, options.onClientByte);
+      await consume(response);
       return response;
     } catch (error) {
       lastError = error;
@@ -284,3 +284,88 @@ export async function relayProxySse(options, output, map, usageBox, attempts = P
   }
   throw lastError;
 }
+
+export async function relayProxySse(options, output, map, usageBox, attempts = PROXY_ATTEMPTS) {
+  return relayAttempts(
+    options,
+    (response) =>
+      pipeProxySse(response.body, output, map, usageBox, options.onClientByte),
+    attempts,
+  );
+}
+
+// Read until response.completed (or the other terminal events). Do not write
+// those bytes yet: a video tool call has to be answered before Codex sees the
+// turn, and a reset before that write is still safe to retry.
+export async function readUntilTerminal(stream, output) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const collected = [];
+  let released = false;
+  const finish = async (error) => {
+    if (released) return;
+    released = true;
+    await reader.cancel(error).catch(() => {});
+  };
+  try {
+    while (true) {
+      if (output?.destroyed || output?.writableEnded) throw clientClosed();
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const split = completeBlocks(buffer);
+      buffer = split.rest;
+      collected.push(...split.parts);
+      if (collected.some((part) => isTerminalSseBlock(part))) {
+        await finish();
+        return collected;
+      }
+    }
+    buffer += decoder.decode();
+    if (buffer.trim()) collected.push(buffer);
+    if (!collected.some((part) => isTerminalSseBlock(part)))
+      throw prematureUpstreamClose();
+    await finish();
+    return collected;
+  } catch (error) {
+    await finish(error);
+    if (error && typeof error === "object" && error.clientBytes == null)
+      error.clientBytes = 0;
+    throw error;
+  }
+}
+
+export async function readRelayProxySse(options, output, attempts = PROXY_ATTEMPTS) {
+  let parts;
+  await relayAttempts(
+    options,
+    async (response) => {
+      parts = await readUntilTerminal(response.body, output);
+    },
+    attempts,
+  );
+  return parts;
+}
+
+export async function emitProxySse(parts, output, map, usageBox, onClientByte) {
+  const rewrite = createSseRewriter(map);
+  let clientBytes = 0;
+  try {
+    for (const part of parts) {
+      const rewritten = rewrite(part);
+      if (rewritten === null) continue;
+      const block = `${rewritten}\n\n`;
+      if (output.destroyed || output.writableEnded) throw clientClosed();
+      const accepted = output.write(block);
+      clientBytes += Buffer.byteLength(block);
+      onClientByte?.();
+      if (!accepted) await drained(output);
+    }
+  } catch (error) {
+    if (error && typeof error === "object") error.clientBytes = clientBytes;
+    throw error;
+  } finally {
+    if (usageBox) usageBox.cacheUsage = rewrite.cacheUsage ?? null;
+  }
+}

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;
+}