codex-grok-bridge 1.7.0 → 1.7.2

package/CHANGELOG.md

@@ -1,6 +1,18 @@
 # Changelog
 
-## Unreleased
+## 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.
+- 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
 

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                        # 160 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`.
 
@@ -120,10 +152,27 @@ address when one exists, so a 5–20 s tool gap does not force a fresh name
 lookup every time. `GROK_BRIDGE_TRANSPORT=fetch` restores the older `fetch`
 path.
 
-A request that dies **before** the first SSE block is written to Codex is
-retried once. After the first block, the bridge never retries — Codex already
-saw bytes, so a replay would duplicate them. Deterministic refusals (422) and
-user aborts are not retried either.
+The bridge holds Grok’s reply until it finishes (`response.completed`). No
+byte of that reply is sent to Codex before then. If the connection drops
+first — a reset (`ECONNRESET`, `EPIPE`, `UND_ERR_SOCKET`) or a close before
+the reply finishes — the bridge sends the same request again, up to two more
+times. DNS and connection failures use that same budget. This provider sets
+Codex `request_max_retries` and `stream_max_retries` to 0, so Codex does not
+send the prompt again as well. If any byte of the reply was already sent to
+Codex, the bridge does not resubmit. A retry sends the prompt to Grok again,
+so that attempt’s input tokens can be billed again. This replaces Codex
+resending the prompt up to two extra times. User aborts and deterministic 422
+responses are not retried. Codex still gives the stream five minutes of
+silence (`stream_idle_timeout_ms`); a reply that takes longer can be cut off
+before any of it is sent.
+
+### In short
+
+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 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
@@ -239,15 +288,15 @@ ephemeral threads and child agents refuse a switch. Other subscribers can block
 the reload; if they do, no inference is sent. Pick the model you want when
 starting a new thread, before the first turn is saved.
 
-### Not guaranteed
+### Not in this release
 
-Voice, cloud tasks, and video generation are not promised.
+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 cannot retry after the first
-SSE byte. The provider sets Codex `request_max_retries` / `stream_max_retries`
-to 2 so **Codex** can resend the same request. Only the side that owns the
-conversation can retry safely.
+25 s / 27 s / 253 s, 726 KB–22 MB). The bridge holds the reply and, if that
+drop happens before Codex has been sent any of it, tries the same request up
+to two more times. Codex does not also resend it. A retry can bill the input
+tokens for that attempt again.
 
 ## Diagnostics
 
@@ -291,7 +340,7 @@ Start here when something breaks. Do not open `~/.grok/auth.json` or
 ## Verify
 
 ```sh
-npm test                    # 160 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
@@ -360,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를 카탈로그에 더합니다.
 
 ## 필요한 것
 
@@ -402,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                        # 160건, 네트워크·추론 없음
+npm test                        # 191건, 네트워크·추론 없음
 node scripts/codex-grok.mjs
 ```
 
@@ -436,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`는 쓰지 않습니다.
@@ -447,10 +528,25 @@ Codex 창에도 보일 수 있습니다.
 실행으로 5–20초가 비어도 매번 이름을 다시 찾지 않기 위해서입니다.
 `GROK_BRIDGE_TRANSPORT=fetch`로 이전 `fetch` 경로로 되돌릴 수 있습니다.
 
-Codex에 첫 SSE 블록을 쓰기 **전**에 죽은 요청은 한 번 다시 보냅니다. 아직
-아무것도 전달하지 않았으므로 재전송이 대화를 오염시키지 않습니다. 첫 블록을
-쓴 뒤에는 절대 재시도하지 않습니다. 422 같은 결정적 거절과 사용자 중단도
-재시도하지 않습니다.
+브리지는 Grok의 응답이 끝날 때까지(`response.completed`) 들고 있습니다.
+그 전에 Codex로 응답 바이트를 보내지 않습니다. 그 전에 연결이 끊기면 —
+리셋(`ECONNRESET`, `EPIPE`, `UND_ERR_SOCKET`)이거나, 응답이 끝나기 전에
+닫힌 경우 — 브리지가 같은 요청을 최대 두 번 더 보냅니다. DNS·연결 실패도
+같은 횟수를 씁니다. 이 provider는 Codex `request_max_retries`와
+`stream_max_retries`를 0으로 두어, Codex가 그 프롬프트를 또 보내지 않게
+합니다. 응답 바이트를 Codex에 이미 보냈다면 브리지는 다시 보내지 않습니다.
+재시도는 프롬프트를 Grok에 다시 보내므로, 그 시도의 입력 토큰이 다시 과금될
+수 있습니다. Codex가 프롬프트를 최대 두 번 더 보내던 것을 이것으로 대신합니다.
+사용자 중단과 422 같은 결정적 거절은 재시도하지 않습니다. Codex는 응답
+바이트 없이 5분(`stream_idle_timeout_ms`)을 기다립니다. 그보다 오래 걸리면
+보내기 전에 끊길 수 있습니다.
+
+### 쉽게 말하면
+
+Codex가 대화를 갖고 있고, 턴마다 그 턴 전체를 보냅니다. 앞부분이 그대로면
+Grok는 그 부분을 캐시로 볼 수 있습니다. Codex에 바이트를 보내기 전에 연결이
+끊기면 브리지가 다시 시도합니다. Codex는 그 요청을 또 보내지 않습니다. 음성
+WebRTC(`POST /v1/realtime/calls`)와 Codex 클라우드 작업은 이 패키지에 없습니다.
 
 Responses 경로가 이상하면 `GROK_BRIDGE_INFERENCE=cli`로 이전 CLI 봉투 경로를
 씁니다. 매 턴 전체 JSON을 프롬프트로 넣으므로 더 느리고 비싸며, 토큰 단위
@@ -558,15 +654,14 @@ OpenAI 경로가 맞습니다.
 구독자가 재로드를 막으면 추론을 보내지 않습니다. 첫 턴이 저장되기 전에 새
 작업을 시작할 때 원하는 모델을 고르세요.
 
-### 아직 보장하지 않는 것
+### 이번 릴리스에 없는 것
 
-음성, 클라우드 작업, 영상 생성은 약속하지 않습니다.
+음성 WebRTC(`POST /v1/realtime/calls`)와 Codex 클라우드 작업은 이 패키지에 없습니다.
 
 상류가 응답 중간에 연결을 리셋하는 경우가 있습니다(실측 3건: 25초 / 27초 /
-253초, 726 KB–22 MB). 첫 SSE 바이트 이후에는 브리지가 재시도할 수 없습니다.
-provider에 Codex `request_max_retries` / `stream_max_retries`를 2로 두어
-**Codex**가 같은 요청을 다시 보내게 했습니다. 대화를 소유한 쪽만 안전하게
-재시도할 수 있습니다.
+253초, 726 KB–22 MB). 브리지는 응답을 들고 있다가, Codex에 그 응답을 보내기
+전에 끊기면 같은 요청을 최대 두 번 더 시도합니다. Codex가 또 보내지는
+않습니다. 재시도하면 그 시도의 입력 토큰이 다시 과금될 수 있습니다.
 
 ## 진단 로그
 
@@ -609,7 +704,7 @@ provider에 Codex `request_max_retries` / `stream_max_retries`를 2로 두어
 ## 검증
 
 ```sh
-npm test                    # 160건, 외부 추론 없음
+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.0",
+  "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 { openProxyStreamWithRetry, pipeProxySse } 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 {
@@ -101,8 +193,14 @@ export function createBridgeServer(options = {}) {
       );
     const id = "resp_" + randomUUID();
     const startedAt = Date.now();
+    // A keepalive comment is an SSE byte. Writing one before the reply finishes
+    // would make a later upstream reset unsafe to retry, so the proxy path
+    // stays quiet until the first real event is handed to Codex. The CLI path
+    // writes its own events and may keep the socket warm while it runs.
+    let responseStarted = false;
     const keepalive = setInterval(() => {
-      if (!res.destroyed && !res.writableEnded) res.write(": keepalive\n\n");
+      if (!responseStarted || res.destroyed || res.writableEnded) return;
+      res.write(": keepalive\n\n");
     }, 10000);
     const useCli =
       Boolean(options.runGrok) ||
@@ -125,6 +223,7 @@ export function createBridgeServer(options = {}) {
       acquired = true;
       queuedMs = Date.now() - queuedAt;
       if (useCli) {
+        responseStarted = true;
         event("response.created", { response: { id } });
         const invocation = buildGrokInvocation(body, options);
         invocation.threadId = req.headers["thread-id"];
@@ -158,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.
@@ -171,25 +270,39 @@ export function createBridgeServer(options = {}) {
         if (convId) request.prompt_cache_key = convId;
         request.input = prefixes.reuse(convId, projected);
         const usageBox = {};
-        const proxy = await openProxyStreamWithRetry({
-          token: session.token,
-          userId: session.userId,
-          body: request,
-          signal: controller.signal,
-          fetchImpl: options.proxyFetch,
-          baseUrl: options.proxyBaseUrl,
-          convId,
-          sessionId: Array.isArray(threadId) ? threadId[0] : threadId,
-          onRetry: ({ attempt, kind }) =>
-            diagnostics.record({
-              event: "turn_retried",
-              kind,
-              attempt,
-              elapsedMs: Date.now() - startedAt,
-            }),
-        });
         try {
-          await pipeProxySse(proxy.body, res, map, usageBox);
+          await relayWithVideo(
+            {
+              token: session.token,
+              userId: session.userId,
+              body: request,
+              signal: controller.signal,
+              fetchImpl: options.proxyFetch,
+              baseUrl: options.proxyBaseUrl,
+              convId,
+              sessionId: Array.isArray(threadId) ? threadId[0] : threadId,
+              onRetry: ({ attempt, kind }) =>
+                diagnostics.record({
+                  event: "turn_retried",
+                  kind,
+                  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/errors.mjs

@@ -40,7 +40,14 @@ const CONNECT_CODES = new Set([
   "DEPTH_ZERO_SELF_SIGNED_CERT", "ERR_TLS_CERT_ALTNAME_INVALID",
 ]);
 const TIMEOUT_CODES = new Set(["UND_ERR_HEADERS_TIMEOUT", "UND_ERR_BODY_TIMEOUT", "ETIMEDOUT"]);
-const CLOSED_CODES = new Set(["UND_ERR_SOCKET", "ECONNRESET", "EPIPE"]);
+const CLOSED_CODES = new Set([
+  "UND_ERR_SOCKET",
+  "ECONNRESET",
+  "EPIPE",
+  // The body ended without response.completed. Same class as a socket reset:
+  // the reply never finished, and Codex has not been given a partial one.
+  "ERR_UPSTREAM_PREMATURE_CLOSE",
+]);
 const ABORT_CODES = new Set([
   "ABORT_ERR", "ERR_STREAM_DESTROYED", "ERR_STREAM_WRITE_AFTER_END", "ERR_STREAM_PREMATURE_CLOSE",
 ]);