agents-bridge 0.1.1 → 0.1.3

package/dist/agents/cli-output.test.js

@@ -0,0 +1,56 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createCliOutputProbe, parseCliJsonl, } from './cli-output.js';
+const CODEX_BACKEND = {
+    command: 'codex',
+    output: 'jsonl',
+    sessionIdFields: ['thread_id'],
+};
+test('parseCliJsonl extracts codex thread id and final agent text', () => {
+    const raw = [
+        '{"type":"thread.started","thread_id":"thread-123"}',
+        '{"type":"item.completed","item":{"id":"item_1","type":"agent_message","text":"OK"}}',
+        '{"type":"turn.completed","usage":{"input_tokens":10,"output_tokens":2}}',
+    ].join('\n');
+    const parsed = parseCliJsonl(raw, CODEX_BACKEND);
+    assert.ok(parsed);
+    assert.equal(parsed.cliSessionId, 'thread-123');
+    assert.equal(parsed.text, 'OK');
+    assert.deepEqual(parsed.usage, {
+        input: 10,
+        output: 2,
+        cacheRead: undefined,
+        cacheWrite: undefined,
+        total: undefined,
+    });
+});
+test('parseCliJsonl keeps codex thread id even when no final text is present', () => {
+    const raw = [
+        '{"type":"thread.started","thread_id":"thread-456"}',
+        '{"type":"turn.completed","usage":{"input_tokens":10,"output_tokens":0}}',
+    ].join('\n');
+    const parsed = parseCliJsonl(raw, CODEX_BACKEND);
+    assert.ok(parsed);
+    assert.equal(parsed.cliSessionId, 'thread-456');
+    assert.equal(parsed.text, '');
+});
+test('createCliOutputProbe tracks reconnects, fallback, and first message timing', () => {
+    const probe = createCliOutputProbe({
+        backend: CODEX_BACKEND,
+        mode: 'jsonl',
+    });
+    probe.onStdout('{"type":"thread.started","thread_id":"thread-789"}\n', 20);
+    probe.onStdout('{"type":"error","message":"Reconnecting... 2/5 (timeout waiting for child process to exit)"}\n', 40);
+    probe.onStdout('{"type":"item.completed","item":{"id":"item_0","type":"error","message":"Falling back from WebSockets to HTTPS transport. timeout waiting for child process to exit"}}\n', 60);
+    probe.onStdout('{"type":"item.completed","item":{"id":"item_1","type":"agent_message","text":"READY"}}\n', 80);
+    probe.onStdout('{"type":"turn.completed","usage":{"input_tokens":1,"output_tokens":1}}\n', 100);
+    const snapshot = probe.snapshot();
+    assert.equal(snapshot.cliSessionId, 'thread-789');
+    assert.equal(snapshot.threadStartedMs, 20);
+    assert.equal(snapshot.firstAgentMessageMs, 80);
+    assert.equal(snapshot.turnCompletedMs, 100);
+    assert.equal(snapshot.reconnectCount, 1);
+    assert.equal(snapshot.fellBackToHttps, true);
+    assert.equal(snapshot.lastText, 'READY');
+});
+//# sourceMappingURL=cli-output.test.js.map

package/dist/agents/cli-output.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-output.test.js","sourceRoot":"","sources":["../../src/agents/cli-output.test.ts"],"names":[],"mappings":"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"}

package/dist/agents/cli-runner.d.ts

@@ -0,0 +1,23 @@
+import type { AppConfig } from '../config/zod-schema.js';
+import type { CliBackendConfig, CliRunParams, CliRunResult, CliTurnExecutor, Logger } from '../types/index.js';
+import { type CodexTurnRuntime } from './codex-app-server-runtime.js';
+import { CliSessionStore } from './cli-session-store.js';
+export declare class LocalCliTurnExecutor implements CliTurnExecutor {
+    private readonly options;
+    private codexRuntime;
+    constructor(options: {
+        config: Pick<AppConfig, 'agents'>;
+        logger: Logger;
+        sessionStore?: CliSessionStore;
+        defaultTimeoutMs?: number;
+        createCodexRuntime?: (backend: CliBackendConfig) => CodexTurnRuntime;
+    });
+    run(params: CliRunParams): Promise<CliRunResult>;
+    private emitProcessing;
+    private executeTurn;
+    teardown(): Promise<void>;
+    private getCodexRuntime;
+    private executeCodexAppServerTurn;
+    private executeCliExecTurn;
+}
+//# sourceMappingURL=cli-runner.d.ts.map

package/dist/agents/cli-runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli-runner.d.ts","sourceRoot":"","sources":["../../src/agents/cli-runner.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,KAAK,EAGV,YAAY,EACZ,YAAY,EAEZ,eAAe,EACf,MAAM,EAEP,MAAM,mBAAmB,CAAA;AAQ1B,OAAO,EAAE,eAAe,EAAwB,MAAM,wBAAwB,CAAA;AA+B9E,qBAAa,oBAAqB,YAAW,eAAe;IAExD,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE;QACxB,MAAM,EAAE,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAA;QACjC,MAAM,EAAE,MAAM,CAAA;QACd,YAAY,CAAC,EAAE,eAAe,CAAA;QAC9B,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAC1B;IAGG,GAAG,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;YA8FxC,cAAc;YAId,WAAW;CA8F1B"}
+{"version":3,"file":"cli-runner.d.ts","sourceRoot":"","sources":["../../src/agents/cli-runner.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,KAAK,EACV,gBAAgB,EAGhB,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,MAAM,EAEP,MAAM,mBAAmB,CAAA;AAc1B,OAAO,EAEL,KAAK,gBAAgB,EACtB,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAAE,eAAe,EAAwB,MAAM,wBAAwB,CAAA;AAkB9E,qBAAa,oBAAqB,YAAW,eAAe;IAIxD,OAAO,CAAC,QAAQ,CAAC,OAAO;IAH1B,OAAO,CAAC,YAAY,CAAgC;gBAGjC,OAAO,EAAE;QACxB,MAAM,EAAE,IAAI,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAA;QACjC,MAAM,EAAE,MAAM,CAAA;QACd,YAAY,CAAC,EAAE,eAAe,CAAA;QAC9B,gBAAgB,CAAC,EAAE,MAAM,CAAA;QACzB,kBAAkB,CAAC,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,gBAAgB,CAAA;KACrE;IAGG,GAAG,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;YAyHxC,cAAc;YAId,WAAW;IAqBnB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAI/B,OAAO,CAAC,eAAe;YAUT,yBAAyB;YA+DzB,kBAAkB;CAwIjC"}

package/dist/agents/cli-runner.js

@@ -1,16 +1,11 @@
 import { randomUUID } from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { CLI_FRESH_WATCHDOG_DEFAULTS, CLI_RESUME_WATCHDOG_DEFAULTS, CLI_WATCHDOG_MIN_TIMEOUT_MS, normalizeProviderId, resolveCliBackendConfig, } from './cli-backends.js';
+import { createCliOutputProbe, isSessionExpiredError, parseCliOutput, } from './cli-output.js';
+import { CodexAppServerRuntime, } from './codex-app-server-runtime.js';
 import { CliSessionStore, parseAgentSessionKey } from './cli-session-store.js';
 const CLI_RUN_QUEUES = new Map();
 const DEFAULT_TIMEOUT_MS = 15 * 60 * 1_000;
-const SESSION_EXPIRED_PATTERNS = [
-    /session expired/i,
-    /invalid session/i,
-    /conversation not found/i,
-    /thread not found/i,
-    /resume session not found/i,
-];
 class CliExecutionError extends Error {
     reason;
     stdout;
@@ -27,6 +22,7 @@ class CliExecutionError extends Error {
 }
 export class LocalCliTurnExecutor {
     options;
+    codexRuntime = null;
     constructor(options) {
         this.options = options;
     }
@@ -39,21 +35,28 @@ export class LocalCliTurnExecutor {
         }
         const sessionStore = this.options.sessionStore ?? new CliSessionStore();
         const envelope = params.envelope;
-        // Legacy fallback: if this is an agent-prefixed key, check for data under the old (unprefixed) key
-        const parsed = parseAgentSessionKey(envelope.sessionId);
-        if (parsed) {
-            await sessionStore.getWithLegacyFallback(envelope.sessionId, parsed.originalKey);
+        let existingSessionEntry = await sessionStore.get(envelope.sessionId);
+        const parsedAgentSession = parseAgentSessionKey(envelope.sessionId);
+        if (!existingSessionEntry && parsedAgentSession) {
+            existingSessionEntry = await sessionStore.getWithLegacyFallback(envelope.sessionId, parsedAgentSession.originalKey);
         }
         const sessionEntry = await sessionStore.ensureSession(envelope.sessionId, {
             provider: providerId,
             model: params.model,
         });
         const existingCliSessionId = await sessionStore.getCliSessionId(envelope.sessionId, providerId);
+        if (providerId === 'codex-cli' && !existingCliSessionId && existingSessionEntry?.provider === providerId) {
+            this.options.logger.warn({
+                provider: providerId,
+                sessionId: envelope.sessionId,
+                runtimeSessionId: sessionEntry.runtimeSessionId,
+            }, 'No persisted Codex thread id found for existing botlink session; next turn will start fresh');
+        }
         await this.emitProcessing(callbacks);
         const queueKey = backendResolved.config.serialize === false
             ? `${backendResolved.id}:${randomUUID()}`
             : `${backendResolved.id}:${envelope.sessionId}`;
-        return enqueueCliRun(queueKey, async () => {
+        return enqueueCliRun(queueKey, async ({ queueWaitMs }) => {
             try {
                 const result = await this.executeTurn({
                     envelope,
@@ -64,6 +67,7 @@ export class LocalCliTurnExecutor {
                     systemPrompt: params.systemPrompt,
                     backend: backendResolved.config,
                     cliSessionId: existingCliSessionId,
+                    queueWaitMs,
                     runtimeSessionId: sessionEntry.runtimeSessionId,
                     agentEnv: params.agentEnv,
                     agentClearEnv: params.agentClearEnv,
@@ -73,6 +77,15 @@ export class LocalCliTurnExecutor {
                         model: params.model,
                     });
                 }
+                else if (providerId === 'codex-cli') {
+                    this.options.logger.warn({
+                        provider: providerId,
+                        sessionId: envelope.sessionId,
+                        runtimeSessionId: sessionEntry.runtimeSessionId,
+                        isResume: result.isResume,
+                        diagnostics: result.diagnostics,
+                    }, 'Codex turn completed without a persisted thread id; future turns will remain fresh');
+                }
                 else {
                     await sessionStore.ensureSession(envelope.sessionId, {
                         provider: providerId,
@@ -84,8 +97,8 @@ export class LocalCliTurnExecutor {
             catch (error) {
                 if (existingCliSessionId &&
                     isSessionExpiredError(error) &&
-                    backendResolved.config.resumeArgs &&
-                    backendResolved.config.resumeArgs.length > 0) {
+                    (providerId === 'codex-cli' ||
+                        Boolean(backendResolved.config.resumeArgs && backendResolved.config.resumeArgs.length > 0))) {
                     this.options.logger.warn({ provider: providerId, sessionId: envelope.sessionId }, 'CLI session expired, clearing provider mapping and retrying fresh turn');
                     await sessionStore.clearCliSessionId(envelope.sessionId, providerId, { model: params.model });
                     const retried = await this.executeTurn({
@@ -97,6 +110,7 @@ export class LocalCliTurnExecutor {
                         systemPrompt: params.systemPrompt,
                         backend: backendResolved.config,
                         cliSessionId: undefined,
+                        queueWaitMs,
                         runtimeSessionId: sessionEntry.runtimeSessionId,
                         agentEnv: params.agentEnv,
                         agentClearEnv: params.agentClearEnv,
@@ -116,6 +130,65 @@ export class LocalCliTurnExecutor {
         await callbacks.onProcessing?.();
     }
     async executeTurn(params) {
+        if (params.providerId === 'codex-cli' && params.backend.runtimeMode === 'app-server') {
+            return this.executeCodexAppServerTurn(params);
+        }
+        return this.executeCliExecTurn(params);
+    }
+    async teardown() {
+        await this.codexRuntime?.teardown();
+    }
+    getCodexRuntime(backend) {
+        if (!this.codexRuntime) {
+            this.codexRuntime = this.options.createCodexRuntime?.(backend) ?? new CodexAppServerRuntime({
+                backend,
+                logger: this.options.logger,
+            });
+        }
+        return this.codexRuntime;
+    }
+    async executeCodexAppServerTurn(params) {
+        const normalizedModel = normalizeCliModel(params.model, params.backend);
+        const existingCliSessionId = params.cliSessionId?.trim() || undefined;
+        const isResume = Boolean(existingCliSessionId);
+        const promptPayload = buildPromptPayload(params.envelope, params.backend, true);
+        this.options.logger.info({
+            provider: params.providerId,
+            model: normalizedModel,
+            sessionId: params.envelope.sessionId,
+            cliSessionId: existingCliSessionId,
+            runtimeSessionId: params.runtimeSessionId,
+            isResume,
+            runtimeMode: 'app-server',
+        }, 'Starting Codex app-server turn');
+        const runtime = this.getCodexRuntime(params.backend);
+        const result = await runtime.run({
+            sessionId: params.envelope.sessionId,
+            runtimeSessionId: params.runtimeSessionId,
+            existingThreadId: existingCliSessionId,
+            model: normalizedModel,
+            workspaceDir: params.workspaceDir,
+            timeoutMs: params.timeoutMs,
+            noProgressTimeoutMs: resolveCliNoOutputTimeoutMs(params.backend, params.timeoutMs, isResume),
+            systemPrompt: resolveAppServerSystemPrompt(params.backend, params.systemPrompt, !existingCliSessionId),
+            prompt: promptPayload.prompt,
+            imagePaths: promptPayload.imagePaths,
+        });
+        return {
+            text: result.text,
+            provider: params.providerId,
+            model: params.model,
+            cliSessionId: result.cliSessionId,
+            isResume: result.isResume,
+            usage: result.usage,
+            diagnostics: {
+                ...result.diagnostics,
+                queueWaitMs: params.queueWaitMs,
+                totalElapsedMs: result.diagnostics.totalElapsedMs + params.queueWaitMs,
+            },
+        };
+    }
+    async executeCliExecTurn(params) {
         const normalizedModel = normalizeCliModel(params.model, params.backend);
         const existingCliSessionId = params.cliSessionId?.trim() || undefined;
         const useResume = Boolean(existingCliSessionId &&
@@ -125,7 +198,7 @@ export class LocalCliTurnExecutor {
             backend: params.backend,
             cliSessionId: existingCliSessionId,
         });
-        const promptPayload = buildPromptPayload(params.envelope, params.backend);
+        const promptPayload = buildPromptPayload(params.envelope, params.backend, Boolean(params.backend.imageArg));
         const promptInput = resolvePromptInput({
             backend: params.backend,
             prompt: promptPayload.prompt,
@@ -165,6 +238,10 @@ export class LocalCliTurnExecutor {
         for (const key of params.agentClearEnv ?? []) {
             delete env[key];
         }
+        const probe = createCliOutputProbe({
+            backend: params.backend,
+            mode: outputMode,
+        });
         const output = await executeCliCommand({
             command: params.backend.command,
             args,
@@ -173,22 +250,56 @@ export class LocalCliTurnExecutor {
             stdin: promptInput.stdin,
             timeoutMs: params.timeoutMs,
             noOutputTimeoutMs: resolveCliNoOutputTimeoutMs(params.backend, params.timeoutMs, useResume),
+            onStdoutChunk(chunk, atMs) {
+                probe.onStdout(chunk, atMs);
+            },
+            onStderrChunk(chunk, atMs) {
+                probe.onStderr(chunk, atMs);
+            },
         });
+        const probeSnapshot = probe.snapshot();
         const parsed = parseCliOutput(output.stdout.trim(), outputMode, params.backend) ?? {
-            text: output.stdout.trim(),
+            text: probeSnapshot.lastText ?? output.stdout.trim(),
+            cliSessionId: probeSnapshot.cliSessionId,
+            usage: probeSnapshot.usage,
         };
-        const cliSessionId = parsed.cliSessionId ?? existingCliSessionId ?? sessionIdToSend.sessionId;
+        const cliSessionId = parsed.cliSessionId ?? probeSnapshot.cliSessionId ?? existingCliSessionId ?? sessionIdToSend.sessionId;
+        const diagnostics = buildRunDiagnostics({
+            queueWaitMs: params.queueWaitMs,
+            commandElapsedMs: output.elapsedMs,
+            outputMode,
+            stdout: output.stdout,
+            stderr: output.stderr,
+            cliSessionId,
+            existingCliSessionId,
+            runtimeSessionId: sessionIdToSend.sessionId,
+            probe: probeSnapshot,
+        });
+        if (params.providerId === 'codex-cli' && !cliSessionId) {
+            this.options.logger.warn({
+                provider: params.providerId,
+                sessionId: params.envelope.sessionId,
+                runtimeSessionId: params.runtimeSessionId,
+                isResume: useResume,
+                diagnostics,
+                stdoutPreview: trimOutputPreview(output.stdout),
+                stderrPreview: trimOutputPreview(output.stderr),
+            }, 'Unable to extract Codex thread id from CLI output');
+        }
+        const text = parsed.text.trim() || probeSnapshot.lastText?.trim() || output.stdout.trim();
         return {
-            text: parsed.text.trim(),
+            text,
             provider: params.providerId,
             model: params.model,
             cliSessionId,
             isResume: useResume,
             usage: parsed.usage,
+            diagnostics,
         };
     }
 }
 async function enqueueCliRun(key, task) {
+    const queuedAt = Date.now();
     const previous = CLI_RUN_QUEUES.get(key) ?? Promise.resolve();
     let release;
     const current = new Promise((resolve) => {
@@ -198,7 +309,9 @@ async function enqueueCliRun(key, task) {
     CLI_RUN_QUEUES.set(key, tail);
     await previous.catch(() => undefined);
     try {
-        return await task();
+        return await task({
+            queueWaitMs: Date.now() - queuedAt,
+        });
     }
     finally {
         release();
@@ -229,6 +342,20 @@ function resolveSystemPrompt(backend, systemPrompt, isNewSession, useResume) {
     }
     return trimmed;
 }
+function resolveAppServerSystemPrompt(backend, systemPrompt, isNewThread) {
+    const trimmed = systemPrompt?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const when = backend.systemPromptWhen ?? 'first';
+    if (when === 'never') {
+        return undefined;
+    }
+    if (when === 'first' && !isNewThread) {
+        return undefined;
+    }
+    return trimmed;
+}
 function resolveSessionIdToSend(params) {
     const mode = params.backend.sessionMode ?? 'always';
     const existing = params.cliSessionId?.trim();
@@ -253,7 +380,7 @@ function resolvePromptInput(params) {
     }
     return { promptArg: params.prompt };
 }
-function buildPromptPayload(envelope, backend) {
+function buildPromptPayload(envelope, backend, useSeparateImageInputs = Boolean(backend.imageArg)) {
     const imagePaths = envelope.content.attachments
         .filter((attachment) => attachment.type === 'photo' && attachment.localPath)
         .map((attachment) => attachment.localPath);
@@ -262,14 +389,14 @@ function buildPromptPayload(envelope, backend) {
         return `Attachment: ${attachment.localPath}${name}`;
     });
     const promptParts = [envelope.content.text.trim()];
-    if (!backend.imageArg && imagePaths.length > 0) {
+    if (!useSeparateImageInputs && imagePaths.length > 0) {
         promptParts.push(...imagePaths.map((imagePath) => `Image: ${imagePath}`));
     }
     const nonImageFiles = fileLines.filter((line) => !imagePaths.some((imagePath) => line.includes(imagePath)));
     promptParts.push(...nonImageFiles);
     return {
         prompt: promptParts.filter(Boolean).join('\n\n').trim(),
-        imagePaths: backend.imageArg && imagePaths.length > 0 ? imagePaths : undefined,
+        imagePaths: useSeparateImageInputs && imagePaths.length > 0 ? imagePaths : undefined,
     };
 }
 function buildCliArgs(params) {
@@ -326,6 +453,7 @@ async function executeCliCommand(params) {
         const stderrChunks = [];
         let settled = false;
         let timedOutReason = null;
+        const startedAt = Date.now();
         const child = spawn(params.command, params.args, {
             cwd: params.cwd,
             env: params.env,
@@ -346,6 +474,7 @@ async function executeCliCommand(params) {
             resolve(result ?? {
                 stdout: decodeCliOutput(Buffer.concat(stdoutChunks)),
                 stderr: decodeCliOutput(Buffer.concat(stderrChunks)),
+                elapsedMs: Date.now() - startedAt,
             });
         };
         const armNoOutputTimer = () => {
@@ -365,11 +494,15 @@ async function executeCliCommand(params) {
             finish(new CliExecutionError(error.message, 'spawn-error', decodeCliOutput(Buffer.concat(stdoutChunks)), decodeCliOutput(Buffer.concat(stderrChunks))));
         });
         child.stdout?.on('data', (chunk) => {
-            stdoutChunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+            const buffer = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+            stdoutChunks.push(buffer);
+            params.onStdoutChunk?.(decodeCliOutput(buffer), Date.now() - startedAt);
             armNoOutputTimer();
         });
         child.stderr?.on('data', (chunk) => {
-            stderrChunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+            const buffer = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+            stderrChunks.push(buffer);
+            params.onStderrChunk?.(decodeCliOutput(buffer), Date.now() - startedAt);
             armNoOutputTimer();
         });
         child.on('close', (code) => {
@@ -377,6 +510,7 @@ async function executeCliCommand(params) {
             const stderr = decodeCliOutput(Buffer.concat(stderrChunks));
             const trimmedStdout = stdout.trim();
             const trimmedStderr = stderr.trim();
+            const elapsedMs = Date.now() - startedAt;
             if (timedOutReason) {
                 const timeoutMessage = timedOutReason === 'overall-timeout'
                     ? `CLI exceeded timeout (${Math.round(params.timeoutMs / 1000)}s) and was terminated.`
@@ -388,7 +522,7 @@ async function executeCliCommand(params) {
                 finish(new CliExecutionError(trimmedStderr || trimmedStdout || `CLI failed with exit code ${code ?? 'unknown'}.`, 'exit', trimmedStdout, trimmedStderr, code));
                 return;
             }
-            finish(undefined, { stdout: trimmedStdout, stderr: trimmedStderr });
+            finish(undefined, { stdout: trimmedStdout, stderr: trimmedStderr, elapsedMs });
         });
         if (params.stdin !== undefined && child.stdin) {
             child.stdin.write(params.stdin);
@@ -432,145 +566,50 @@ function tryDecodeWithEncoding(buffer, encoding) {
         return null;
     }
 }
-function parseCliOutput(raw, mode, backend) {
-    if (!raw.trim()) {
-        return null;
-    }
-    if (mode === 'text') {
-        return { text: raw.trim() };
-    }
-    if (mode === 'jsonl') {
-        return parseCliJsonl(raw, backend);
-    }
-    return parseCliJson(raw, backend);
-}
-function parseCliJson(raw, backend) {
-    try {
-        const parsed = JSON.parse(raw);
-        if (!isRecord(parsed)) {
-            return null;
+function buildRunDiagnostics(params) {
+    let cliSessionIdSource;
+    if (params.cliSessionId) {
+        if (params.probe.cliSessionId && params.cliSessionId === params.probe.cliSessionId) {
+            cliSessionIdSource = 'stream';
         }
-        return {
-            text: (collectText(parsed.message) ||
-                collectText(parsed.content) ||
-                collectText(parsed.result) ||
-                collectText(parsed)).trim(),
-            cliSessionId: pickCliSessionId(parsed, backend),
-            usage: isRecord(parsed.usage) ? toUsage(parsed.usage) : undefined,
-        };
-    }
-    catch {
-        return null;
-    }
-}
-function parseCliJsonl(raw, backend) {
-    const lines = raw
-        .split(/\r?\n/g)
-        .map((line) => line.trim())
-        .filter(Boolean);
-    if (lines.length === 0) {
-        return null;
-    }
-    let cliSessionId;
-    let usage;
-    let lastText = '';
-    for (const line of lines) {
-        try {
-            const parsed = JSON.parse(line);
-            if (!isRecord(parsed)) {
-                continue;
-            }
-            cliSessionId = cliSessionId ?? pickCliSessionId(parsed, backend) ?? getString(parsed.thread_id);
-            if (isRecord(parsed.usage)) {
-                usage = toUsage(parsed.usage) ?? usage;
-            }
-            const candidate = (collectText(parsed.item) ||
-                collectText(parsed.message) ||
-                collectText(parsed.delta) ||
-                collectText(parsed.result)).trim();
-            if (candidate) {
-                lastText = candidate;
-            }
+        else if (params.existingCliSessionId && params.cliSessionId === params.existingCliSessionId) {
+            cliSessionIdSource = 'existing';
         }
-        catch {
-            continue;
+        else if (params.runtimeSessionId && params.cliSessionId === params.runtimeSessionId) {
+            cliSessionIdSource = 'runtime';
         }
-    }
-    if (!lastText) {
-        return null;
-    }
-    return { text: lastText, cliSessionId, usage };
-}
-function pickCliSessionId(parsed, backend) {
-    const fields = backend.sessionIdFields ?? ['session_id', 'sessionId', 'conversation_id', 'conversationId'];
-    for (const field of fields) {
-        const value = getString(parsed[field]);
-        if (value) {
-            return value;
+        else {
+            cliSessionIdSource = 'parsed';
         }
     }
-    return undefined;
-}
-function collectText(value) {
-    if (!value) {
-        return '';
-    }
-    if (typeof value === 'string') {
-        return value;
-    }
-    if (Array.isArray(value)) {
-        return value.map((entry) => collectText(entry)).filter(Boolean).join('\n');
-    }
-    if (!isRecord(value)) {
-        return '';
-    }
-    if (typeof value.text === 'string') {
-        return value.text;
-    }
-    if (typeof value.content === 'string') {
-        return value.content;
-    }
-    if (Array.isArray(value.content)) {
-        return value.content.map((entry) => collectText(entry)).filter(Boolean).join('\n');
-    }
-    if (isRecord(value.message)) {
-        return collectText(value.message);
-    }
-    if (isRecord(value.item)) {
-        return collectText(value.item);
-    }
-    return '';
-}
-function toUsage(raw) {
-    const pick = (...keys) => {
-        for (const key of keys) {
-            const value = raw[key];
-            if (typeof value === 'number' && value >= 0) {
-                return value;
-            }
-        }
-        return undefined;
-    };
-    const usage = {
-        input: pick('input_tokens', 'inputTokens'),
-        output: pick('output_tokens', 'outputTokens'),
-        cacheRead: pick('cache_read_input_tokens', 'cached_input_tokens', 'cacheRead'),
-        cacheWrite: pick('cache_write_input_tokens', 'cacheWrite'),
-        total: pick('total_tokens', 'total'),
+    return {
+        queueWaitMs: params.queueWaitMs,
+        commandElapsedMs: params.commandElapsedMs,
+        totalElapsedMs: params.queueWaitMs + params.commandElapsedMs,
+        outputMode: params.outputMode,
+        runtimeMode: 'exec',
+        hadStdout: Boolean(params.stdout),
+        hadStderr: Boolean(params.stderr),
+        firstStdoutMs: params.probe.firstStdoutMs,
+        firstStderrMs: params.probe.firstStderrMs,
+        threadStartedMs: params.probe.threadStartedMs,
+        firstAgentMessageMs: params.probe.firstAgentMessageMs,
+        turnCompletedMs: params.probe.turnCompletedMs,
+        reconnectCount: params.probe.reconnectCount,
+        fellBackToHttps: params.probe.fellBackToHttps,
+        threadOperation: params.existingCliSessionId ? 'resume' : 'start',
+        threadOperationElapsedMs: params.probe.threadStartedMs,
+        cliSessionIdSource,
     };
-    if (Object.values(usage).every((value) => value === undefined)) {
+}
+function trimOutputPreview(raw, limit = 1200) {
+    const normalized = raw.trim();
+    if (!normalized) {
         return undefined;
     }
-    return usage;
-}
-function isSessionExpiredError(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return SESSION_EXPIRED_PATTERNS.some((pattern) => pattern.test(message));
-}
-function isRecord(value) {
-    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
-}
-function getString(value) {
-    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+    if (normalized.length <= limit) {
+        return normalized;
+    }
+    return `${normalized.slice(0, limit)}...`;
 }
 //# sourceMappingURL=cli-runner.js.map