@cartanova/qgrid-cli 2.3.4 → 2.3.6

package/bundle/src/utils/providers/anthropic/anthropic-quota.ts

@@ -0,0 +1,27 @@
+import { fetchUsageWithMeta } from "../../../application/qgrid/oauth";
+
+export type AnthropicQuotaUsageResult =
+  | { kind: "ok"; utilizationPct: number; cacheAgeMs: number }
+  | { kind: "lookup_failed"; reason: string };
+
+export async function readAnthropicQuotaUsage(
+  accessToken: string,
+): Promise<AnthropicQuotaUsageResult> {
+  try {
+    const { data, cachedAt } = await fetchUsageWithMeta(accessToken);
+    if (data.error) return { kind: "lookup_failed", reason: data.error };
+
+    const utilization = data.five_hour?.utilization;
+    if (typeof utilization !== "number" || !Number.isFinite(utilization)) {
+      return { kind: "lookup_failed", reason: "five_hour utilization unavailable" };
+    }
+
+    return {
+      kind: "ok",
+      utilizationPct: utilization,
+      cacheAgeMs: Math.max(Date.now() - cachedAt, 0),
+    };
+  } catch (e) {
+    return { kind: "lookup_failed", reason: (e as Error).message };
+  }
+}

package/bundle/src/utils/providers/anthropic/claude-session.test.ts

@@ -12,6 +12,7 @@ import {
   oneMillionEnv,
   runClaudeSession,
   structuredOutputRetriesEnv,
+  SYSTEM_PROMPT_ARGV_MAX_BYTES,
   withSessionLock,
 } from "./claude-session";
 import { buildStreamJsonInput } from "./stream-json-adapter";
@@ -238,6 +239,45 @@ describe("buildClaudeArgs (멀티턴/격리/structured)", () => {
     expect(args).toContain("--system-prompt");
     expect(args[args.indexOf("--system-prompt") + 1]).toBe("you are X");
   });
+
+  // E2BIG 회피: 대형 시스템 프롬프트는 파일 경로로 넘겨 Linux argv 한계(128KB)를 피한다.
+  it("systemPromptFile 이 오면 --system-prompt-file 을 쓰고 inline --system-prompt 는 안 쓴다", () => {
+    const args = buildClaudeArgs({
+      model: "m",
+      systemPromptFile: "/cfg/7/system-prompt-u.txt",
+      sessionId: "u",
+    });
+    expect(args).toContain("--system-prompt-file");
+    expect(args[args.indexOf("--system-prompt-file") + 1]).toBe("/cfg/7/system-prompt-u.txt");
+    expect(args).not.toContain("--system-prompt");
+  });
+
+  it("systemPromptFile 이 inline system 보다 우선한다 (둘 다 와도 file 경로만)", () => {
+    const args = buildClaudeArgs({
+      model: "m",
+      system: "ignored inline",
+      systemPromptFile: "/cfg/7/sp.txt",
+      sessionId: "u",
+    });
+    expect(args).toContain("--system-prompt-file");
+    expect(args).not.toContain("--system-prompt");
+    expect(args).not.toContain("ignored inline");
+  });
+
+  it("임계값(64KB)을 넘는 시스템 프롬프트가 argv 에 통째로 들어가지 않는다 (E2BIG 회귀 방지)", () => {
+    const huge = "x".repeat(SYSTEM_PROMPT_ARGV_MAX_BYTES + 1);
+    // 실제 호출부(runClaudeSession)는 huge 를 파일로 빼고 systemPromptFile 만 넘긴다.
+    const args = buildClaudeArgs({
+      model: "m",
+      systemPromptFile: "/cfg/7/sp.txt",
+      sessionId: "u",
+    });
+    // 어떤 단일 인자도 임계값을 넘지 않아야 한다(=거대 프롬프트가 argv 에 없음).
+    for (const a of args) {
+      expect(Buffer.byteLength(a, "utf8")).toBeLessThanOrEqual(SYSTEM_PROMPT_ARGV_MAX_BYTES);
+    }
+    expect(args).not.toContain(huge);
+  });
 });
 
 describe("decorateAndSerialize (envelope, U2 P1-#3 위임분)", () => {

package/bundle/src/utils/providers/anthropic/claude-session.ts

@@ -16,11 +16,12 @@
 
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { mkdirSync, writeFileSync } from "node:fs";
+import { mkdirSync, unlinkSync, writeFileSync } from "node:fs";
 
 import { type JsonValue } from "../../../codex-protocol/serde_json/JsonValue";
 import { type TokenUsageBreakdown } from "../../../codex-protocol/v2/TokenUsageBreakdown";
 import { type UserInput } from "../../../codex-protocol/v2/UserInput";
+import { createTtftTracker } from "../common/ttft";
 import {
   ANTHROPIC_CLAUDE_CWD,
   anthropicConfigDir,
@@ -111,6 +112,7 @@ export interface ClaudeSessionRequest {
 export interface ClaudeSessionResult extends ClaudeStreamResult {
   sessionId: string;
   workerId: number;
+  ttftMs: number | null;
 }
 
 // per-token CLAUDE_CONFIG_DIR 보장(격리). 경로 규칙은 anthropicConfigDir(순수 함수)이 소유 —
@@ -156,9 +158,21 @@ export function structuredOutputRetriesEnv(raw = process.env.MAX_STRUCTURED_OUTP
   return { MAX_STRUCTURED_OUTPUT_RETRIES: String(Math.max(parsed, 1)) };
 }
 
+// Linux 단일 argv 인자 한계(MAX_ARG_STRLEN = PAGE_SIZE×32 = 128KB, 커널 하드코딩 상수)
+// 시스템 프롬프트가 이를 넘으면 execve 가 E2BIG 로 거부된다. deti 등 대형 프롬프트는 실측
+// 평균 343KB·최대 485KB(opus-4-8)라 일상적으로 초과한다. 한계의 절반(64KB)을 임계값으로 잡아
+// UTF-8 멀티바이트·예측 못 한 여유분까지 안전 마진을 둔다.
+export const SYSTEM_PROMPT_ARGV_MAX_BYTES = 64 * 1024;
+
 export function buildClaudeArgs(opts: {
   model: string;
+  // 시스템 프롬프트 전달은 크기로 분기한다(호출부가 결정):
+  //  - 작으면 system(inline) → --system-prompt <text> (파일 I/O 없음, 기존 경로)
+  //  - 크면 systemPromptFile(경로) → --system-prompt-file <path> (argv 한계 회피)
+  // --system-prompt-file 은 --system-prompt 와 동일하게 default 를 replace 한다(append 아님 —
+  // R7 격리 보존, 실측 확인). 둘 다 없으면 빈 --system-prompt(default 23k 주입 방지).
   system?: string;
+  systemPromptFile?: string;
   effort?: string;
   jsonSchema?: string;
   sessionId: string;
@@ -171,6 +185,12 @@ export function buildClaudeArgs(opts: {
     ? ["--tools", "", "--allowed-tools", "StructuredOutput"]
     : ["--tools", ""];
 
+  // 시스템 프롬프트: 파일 경로가 오면 --system-prompt-file, 아니면 inline --system-prompt.
+  // (호출부가 크기로 분기해 둘 중 하나만 채운다. 둘 다 없으면 빈 --system-prompt.)
+  const systemArgs = opts.systemPromptFile
+    ? ["--system-prompt-file", opts.systemPromptFile]
+    : ["--system-prompt", opts.system ?? ""];
+
   const args: Array<string> = [
     "-p",
     ...toolArgs,
@@ -189,8 +209,8 @@ export function buildClaudeArgs(opts: {
     "--model",
     applyOneMillionSuffix(opts.model, opts.needsOneMillionSuffix ?? false),
     // inline [System] 금지 — 정식 채널만(R7). 생략 시 CC default(23k) 주입되므로 반드시 명시.
-    "--system-prompt",
-    opts.system ?? "",
+    // 크기에 따라 --system-prompt(작음) / --system-prompt-file(큼)로 분기(systemArgs).
+    ...systemArgs,
     "--thinking",
     "disabled",
     "--effort",
@@ -225,9 +245,19 @@ export function runClaudeSession(
     ensureCwd();
     const configDir = ensureConfigDir(req.tokenId);
 
+    // 시스템 프롬프트를 크기로 분기: 128KB(argv 한계)의 절반을 넘으면 파일로 넘겨 E2BIG 회피.
+    // 작은 프롬프트는 파일 I/O 없이 기존 inline 경로를 그대로 쓴다(대부분의 호출).
+    // 실제 파일 쓰기는 abort 체크 이후(Promise 안)로 미뤄, 이미 취소된 요청엔 쓰지 않는다.
+    const system = req.system ?? "";
+    const useSystemPromptFile = Buffer.byteLength(system, "utf8") > SYSTEM_PROMPT_ARGV_MAX_BYTES;
+    const systemPromptFile = useSystemPromptFile
+      ? `${configDir}/system-prompt-${sessionId}.txt`
+      : undefined;
+
     const args = buildClaudeArgs({
       model,
-      system: req.system,
+      system: useSystemPromptFile ? undefined : req.system,
+      systemPromptFile,
       effort: req.effort,
       jsonSchema: req.jsonSchema,
       sessionId,
@@ -247,6 +277,9 @@ export function runClaudeSession(
         return;
       }
 
+      // 대형 시스템 프롬프트는 spawn 직전에 파일로 기록(argv E2BIG 회피). 종료 시 정리한다.
+      if (systemPromptFile) writeFileSync(systemPromptFile, system);
+
       const child = spawn("claude", args, {
         // stderr 도 캡처: invalid OAuth / 잘못된 플래그 / CLI 검증 실패가
         // "closed without result" 로 뭉개지지 않게 close/error 에 stderr 를 실어 보낸다.
@@ -274,6 +307,8 @@ export function runClaudeSession(
       let settled = false;
       let buffer = "";
       const streamState: ClaudeStreamJsonState = {};
+      const ttftTracker = createTtftTracker();
+      const onTrackedDelta = ttftTracker.wrapDelta(onDelta);
       // bounded stderr 버퍼(최근 ~4KB만 유지 — 무한 누적 방지).
       let stderrBuf = "";
       const STDERR_CAP = 4096;
@@ -281,11 +316,23 @@ export function runClaudeSession(
         stderrBuf = (stderrBuf + d.toString()).slice(-STDERR_CAP);
       });
       const stderrSuffix = () => (stderrBuf.trim() ? ` — stderr: ${stderrBuf.trim()}` : "");
+      // spawn 시 쓴 임시 시스템 프롬프트 파일 정리(한 번만). 모든 종료 경로에서 호출한다.
+      // 누락돼도 다음 ensureConfigDir 가 디렉토리를 재사용할 뿐이지만, sessionId 별 파일이라
+      // 쌓이면 디스크가 차므로 settle 시 즉시 지운다.
+      const cleanupSpawnFiles = () => {
+        if (!systemPromptFile) return;
+        try {
+          unlinkSync(systemPromptFile);
+        } catch {
+          // 이미 없거나 권한 문제면 무시 — 정리는 best-effort.
+        }
+      };
       let cleanupAbort: (() => void) | undefined;
       const timer = setTimeout(() => {
         if (settled) return;
         settled = true;
         cleanupAbort?.();
+        cleanupSpawnFiles();
         child.kill();
         reject(new Error(`Claude session timeout after ${req.timeoutMs / 1000}s`));
       }, req.timeoutMs);
@@ -295,7 +342,8 @@ export function runClaudeSession(
         settled = true;
         clearTimeout(timer);
         cleanupAbort?.();
-        resolve({ ...result, sessionId, workerId });
+        cleanupSpawnFiles();
+        resolve({ ...result, sessionId, workerId, ttftMs: ttftTracker.value() });
       };
 
       const onAbort = () => {
@@ -303,6 +351,7 @@ export function runClaudeSession(
         settled = true;
         clearTimeout(timer);
         cleanupAbort?.();
+        cleanupSpawnFiles();
         child.kill();
         reject(new Error("aborted"));
       };
@@ -315,7 +364,7 @@ export function runClaudeSession(
         const lines = buffer.split("\n");
         buffer = lines.pop() ?? "";
         for (const line of lines) {
-          const result = handleStreamJsonLine(line, onDelta, {
+          const result = handleStreamJsonLine(line, onTrackedDelta, {
             structuredOutput: useStructured,
             state: streamState,
           });
@@ -331,6 +380,7 @@ export function runClaudeSession(
         settled = true;
         clearTimeout(timer);
         cleanupAbort?.();
+        cleanupSpawnFiles();
         reject(new Error(`Claude session closed without result${stderrSuffix()}`));
       });
       child.on("error", (err) => {
@@ -338,10 +388,12 @@ export function runClaudeSession(
         settled = true;
         clearTimeout(timer);
         cleanupAbort?.();
+        cleanupSpawnFiles();
         reject(new Error(`Claude session spawn error: ${err.message}`));
       });
 
       // stdin 으로 입력 JSONL 흘리고 닫는다.
+      ttftTracker.markStart();
       child.stdin?.write(stdinPayload);
       child.stdin?.end();
     });

package/bundle/src/utils/providers/common/provider-dispatcher.ts

@@ -49,6 +49,7 @@ export interface GenerateResult {
   tokenName: string;
   usage: ProviderTokenUsageBreakdown;
   durationMs: number;
+  ttftMs?: number | null;
   // Provider 가 직접 산출한 비용. Anthropic Claude Code 는 total_cost_usd 를 주므로 이 값을
   // 우선 사용하고, 없으면 상위가 모델별 가격표로 계산한다.
   costUsd?: number;

package/bundle/src/utils/providers/common/ttft.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+
+import { createTtftTracker } from "./ttft";
+
+describe("createTtftTracker", () => {
+  it("records the first delta once relative to the marked start", () => {
+    let now = 100;
+    const tracker = createTtftTracker(() => now);
+    const deltas: string[] = [];
+    const onDelta = tracker.wrapDelta((text) => deltas.push(text));
+
+    tracker.markStart();
+    now = 135;
+    onDelta("a");
+    now = 200;
+    onDelta("b");
+
+    expect(tracker.value()).toBe(35);
+    expect(deltas).toEqual(["a", "b"]);
+  });
+
+  it("keeps null when no delta is recorded", () => {
+    const tracker = createTtftTracker(() => 100);
+
+    tracker.markStart();
+
+    expect(tracker.value()).toBeNull();
+  });
+
+  it("does not treat a delta before start as zero", () => {
+    const tracker = createTtftTracker(() => 100);
+
+    tracker.recordFirstDelta();
+
+    expect(tracker.value()).toBeNull();
+  });
+});

package/bundle/src/utils/providers/common/ttft.ts

@@ -0,0 +1,26 @@
+export function createTtftTracker(now: () => number = Date.now): {
+  markStart: () => void;
+  recordFirstDelta: () => void;
+  value: () => number | null;
+  wrapDelta: (onDelta: (text: string) => void) => (text: string) => void;
+} {
+  let startedAt: number | null = null;
+  let ttftMs: number | null = null;
+
+  const recordFirstDelta = () => {
+    if (startedAt === null || ttftMs !== null) return;
+    ttftMs = Math.max(0, now() - startedAt);
+  };
+
+  return {
+    markStart: () => {
+      startedAt = now();
+    },
+    recordFirstDelta,
+    value: () => ttftMs,
+    wrapDelta: (onDelta) => (text) => {
+      recordFirstDelta();
+      onDelta(text);
+    },
+  };
+}

package/bundle/src/utils/providers/openai/codex-worker.test.ts

@@ -53,6 +53,41 @@ function createWorkerWithRequestSpy() {
   return { worker, request };
 }
 
+function createWorkerWithNotificationRpc(
+  onRequest: (
+    method: string,
+    params: unknown,
+    handlers: Map<string, (params: never) => void>,
+  ) => Promise<unknown>,
+) {
+  const worker = new CodexAppServerWorker({
+    tokenId: 1,
+    tokenName: "token",
+    accessToken: "access",
+    accountId: "account",
+  });
+  const handlers = new Map<string, (params: never) => void>();
+  const request = vi.fn((method: string, params?: unknown) => onRequest(method, params, handlers));
+  const rpc = {
+    request,
+    onNotification(method: string, handler: (params: never) => void) {
+      handlers.set(method, handler);
+    },
+  };
+  (
+    worker as unknown as {
+      rpc: typeof rpc;
+      ready: boolean;
+    }
+  ).rpc = rpc;
+  (
+    worker as unknown as {
+      ready: boolean;
+    }
+  ).ready = true;
+  return { worker, request, handlers };
+}
+
 describe("CodexAppServerWorker active turn cleanup", () => {
   it("rejects a non-streaming turn when the worker process exits", async () => {
     const { worker } = createWorkerWithFakeRpc();
@@ -101,6 +136,119 @@ describe("CodexAppServerWorker active turn cleanup", () => {
   });
 });
 
+describe("CodexAppServerWorker TTFT", () => {
+  it("captures fast non-stream deltas registered before turn/start completes", async () => {
+    let now = 1_000;
+    const nowSpy = vi.spyOn(Date, "now").mockImplementation(() => now);
+    const { worker } = createWorkerWithNotificationRpc(async (method, _params, handlers) => {
+      if (method === "thread/start") {
+        return { thread: { id: "thread-1" }, model: "gpt-test" };
+      }
+      if (method === "turn/start") {
+        now = 1_025;
+        handlers.get("item/agentMessage/delta")?.({
+          threadId: "thread-1",
+          delta: "h",
+        } as never);
+        now = 1_050;
+        handlers.get("item/agentMessage/delta")?.({
+          threadId: "thread-1",
+          delta: "i",
+        } as never);
+        handlers.get("turn/completed")?.({
+          threadId: "thread-1",
+          turn: { status: "completed", durationMs: 90 },
+        } as never);
+        return { turn: { id: "turn-1" } };
+      }
+      throw new Error(`unexpected request: ${method}`);
+    });
+
+    try {
+      const result = await worker.executeTurn({
+        input: [{ type: "text", text: "hi", text_elements: [] }],
+      });
+
+      expect(result.text).toBe("hi");
+      expect(result.ttftMs).toBe(25);
+    } finally {
+      nowSpy.mockRestore();
+    }
+  });
+
+  it("keeps non-stream ttft null when no delta arrives", async () => {
+    const { worker } = createWorkerWithNotificationRpc(async (method, _params, handlers) => {
+      if (method === "thread/start") {
+        return { thread: { id: "thread-1" }, model: "gpt-test" };
+      }
+      if (method === "turn/start") {
+        handlers.get("turn/completed")?.({
+          threadId: "thread-1",
+          turn: { status: "completed", durationMs: 90 },
+        } as never);
+        return { turn: { id: "turn-1" } };
+      }
+      throw new Error(`unexpected request: ${method}`);
+    });
+
+    const result = await worker.executeTurn({
+      input: [{ type: "text", text: "hi", text_elements: [] }],
+    });
+
+    expect(result.ttftMs).toBeNull();
+  });
+
+  it("captures stream ttft from the first delta only", async () => {
+    let now = 2_000;
+    const nowSpy = vi.spyOn(Date, "now").mockImplementation(() => now);
+    const { worker } = createWorkerWithNotificationRpc(async (method, _params, handlers) => {
+      if (method === "thread/start") {
+        return { thread: { id: "thread-1" }, model: "gpt-test" };
+      }
+      if (method === "turn/start") {
+        now = 2_030;
+        handlers.get("item/agentMessage/delta")?.({
+          threadId: "thread-1",
+          delta: "a",
+        } as never);
+        now = 2_080;
+        handlers.get("item/agentMessage/delta")?.({
+          threadId: "thread-1",
+          delta: "b",
+        } as never);
+        handlers.get("turn/completed")?.({
+          threadId: "thread-1",
+          turn: { status: "completed", durationMs: 120 },
+        } as never);
+        return { turn: { id: "turn-1" } };
+      }
+      throw new Error(`unexpected request: ${method}`);
+    });
+    const callbacks: StreamCallbacks = {
+      onDelta: vi.fn(),
+      onComplete: vi.fn(),
+      onError: vi.fn(),
+    };
+
+    try {
+      await worker.executeTurnStream(
+        {
+          input: [{ type: "text", text: "hi", text_elements: [] }],
+        },
+        callbacks,
+      );
+
+      expect(callbacks.onDelta).toHaveBeenCalledWith("a");
+      expect(callbacks.onDelta).toHaveBeenCalledWith("b");
+      expect(callbacks.onComplete).toHaveBeenCalledWith(
+        expect.objectContaining({ text: "ab", ttftMs: 30 }),
+      );
+    } finally {
+      nowSpy.mockRestore();
+    }
+  });
+});
+
 describe("CodexAppServerWorker prompt prefix", () => {
   it("uses the same base instructions with and without an output schema", async () => {
     type WorkerInternals = {

package/bundle/src/utils/providers/openai/codex-worker.ts

@@ -10,6 +10,7 @@ import { type TokenUsageBreakdown } from "../../../codex-protocol/v2/TokenUsageB
 import { type TurnStartParams } from "../../../codex-protocol/v2/TurnStartParams";
 import { type TurnStartResponse } from "../../../codex-protocol/v2/TurnStartResponse";
 import { type StreamCallbacks as CommonStreamCallbacks } from "../common/provider-dispatcher";
+import { createTtftTracker } from "../common/ttft";
 import { CodexRpcClient } from "./codex-rpc";
 
 const logger = getLogger(["qgrid", "codex-worker"]);
@@ -44,6 +45,7 @@ export interface TurnResult {
   text: string;
   usage: TokenUsageBreakdown;
   durationMs: number;
+  ttftMs: number | null;
   model: string;
 }
 
@@ -387,8 +389,17 @@ export class CodexAppServerWorker {
     } else {
       ({ threadId, model } = await this.createThread(req));
     }
-    await this.startTurnOnThread(threadId, req);
-    const result = await this.consumeTurnNotifications(threadId, model);
+    const ttftTracker = createTtftTracker();
+    const resultPromise = this.consumeTurnNotifications(threadId, model, ttftTracker);
+    try {
+      ttftTracker.markStart();
+      await this.startTurnOnThread(threadId, req);
+    } catch (e) {
+      this.failActiveTurn(e as Error);
+      await resultPromise.catch(() => {});
+      throw e;
+    }
+    const result = await resultPromise;
     return { ...result, threadId };
   }
 
@@ -405,10 +416,20 @@ export class CodexAppServerWorker {
     } else {
       ({ threadId, model } = await this.createThread(req));
     }
-    const { turnId } = await this.startTurnOnThread(threadId, req);
     cb.onThreadId?.(threadId);
+    const ttftTracker = createTtftTracker();
+    const resultPromise = this.consumeStreamNotifications(threadId, model, cb, ttftTracker);
+    let turnId: string;
+    try {
+      ttftTracker.markStart();
+      ({ turnId } = await this.startTurnOnThread(threadId, req));
+    } catch (e) {
+      this.failActiveTurn(e as Error);
+      await resultPromise.catch(() => {});
+      throw e;
+    }
     cb.onTurnId?.(turnId);
-    await this.consumeStreamNotifications(threadId, model, cb);
+    await resultPromise;
     return { threadId };
   }
 
@@ -456,7 +477,11 @@ export class CodexAppServerWorker {
     abort?.(error);
   }
 
-  private consumeTurnNotifications(threadId: string, model: string): Promise<TurnResult> {
+  private consumeTurnNotifications(
+    threadId: string,
+    model: string,
+    ttftTracker = createTtftTracker(),
+  ): Promise<TurnResult> {
     return new Promise<TurnResult>((resolve, reject) => {
       let settled = false;
       let abort: ActiveTurnAbort;
@@ -510,6 +535,12 @@ export class CodexAppServerWorker {
         if (p.item.type === "agentMessage") text = p.item.text;
       });
 
+      this.rpc!.onNotification("item/agentMessage/delta", (p) => {
+        if (p.threadId !== threadId) return;
+        ttftTracker.recordFirstDelta();
+        text += p.delta;
+      });
+
       this.rpc!.onNotification("thread/tokenUsage/updated", (p) => {
         if (p.threadId !== threadId) return;
         // thread 재사용 시 .total 은 대화 전체 누적이라, cold 였던 이전 turn 까지 섞여
@@ -521,8 +552,11 @@ export class CodexAppServerWorker {
       this.rpc!.onNotification("turn/completed", (p) => {
         if (p.threadId !== threadId) return;
         durationMs = p.turn.durationMs ?? 0;
-        if (p.turn.status === "completed") finishWithResult({ text, usage, durationMs, model });
-        else finishWithError(new Error(`turn failed: ${JSON.stringify(p.turn.error)}`));
+        if (p.turn.status === "completed") {
+          finishWithResult({ text, usage, durationMs, ttftMs: ttftTracker.value(), model });
+        } else {
+          finishWithError(new Error(`turn failed: ${JSON.stringify(p.turn.error)}`));
+        }
       });
 
       this.rpc!.onNotification("error", (p) => {
@@ -538,6 +572,7 @@ export class CodexAppServerWorker {
     threadId: string,
     model: string,
     cb: StreamCallbacks,
+    ttftTracker = createTtftTracker(),
   ): Promise<void> {
     return new Promise<void>((resolve, reject) => {
       let settled = false;
@@ -590,6 +625,7 @@ export class CodexAppServerWorker {
 
       this.rpc!.onNotification("item/agentMessage/delta", (p) => {
         if (p.threadId !== threadId) return;
+        ttftTracker.recordFirstDelta();
         text += p.delta;
         cb.onDelta(p.delta);
       });
@@ -610,7 +646,13 @@ export class CodexAppServerWorker {
       this.rpc!.onNotification("turn/completed", (p) => {
         if (p.threadId !== threadId) return;
         if (p.turn.status === "completed") {
-          finishWithComplete({ text, usage, durationMs: p.turn.durationMs ?? 0, model });
+          finishWithComplete({
+            text,
+            usage,
+            durationMs: p.turn.durationMs ?? 0,
+            ttftMs: ttftTracker.value(),
+            model,
+          });
         } else {
           finishWithError(new Error(`turn ${p.turn.status}: ${JSON.stringify(p.turn.error)}`));
         }