@renseiai/agentfactory 0.8.21 → 0.8.23

package/dist/src/providers/codex-app-server-provider.js

@@ -23,14 +23,56 @@
  */
 import { spawn } from 'child_process';
 import { createInterface } from 'readline';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
 import { classifyTool } from '../tools/tool-category.js';
 import { evaluateCommandApproval, evaluateFileChangeApproval, } from './codex-approval-bridge.js';
+function isServerRequest(msg) {
+    return 'id' in msg && 'method' in msg;
+}
 function isResponse(msg) {
-    return 'id' in msg && typeof msg.id === 'number';
+    return 'id' in msg && !('method' in msg);
 }
 function isNotification(msg) {
     return 'method' in msg && !('id' in msg);
 }
+// ---------------------------------------------------------------------------
+// Codex model mapping (SUP-1749)
+// ---------------------------------------------------------------------------
+export const CODEX_MODEL_MAP = {
+    'opus': 'gpt-5-codex',
+    'sonnet': 'gpt-5.2-codex',
+    'haiku': 'gpt-5.3-codex',
+};
+export const CODEX_DEFAULT_MODEL = 'gpt-5-codex';
+export function resolveCodexModel(config) {
+    if (config.model)
+        return config.model;
+    const tier = config.env.CODEX_MODEL_TIER;
+    if (tier && CODEX_MODEL_MAP[tier])
+        return CODEX_MODEL_MAP[tier];
+    if (config.env.CODEX_MODEL)
+        return config.env.CODEX_MODEL;
+    return CODEX_DEFAULT_MODEL;
+}
+// ---------------------------------------------------------------------------
+// Codex pricing and cost calculation (SUP-1750)
+// ---------------------------------------------------------------------------
+/** Codex pricing per 1M tokens (USD). Update when pricing changes. */
+export const CODEX_PRICING = {
+    'gpt-5-codex': { input: 2.00, cachedInput: 0.50, output: 8.00 },
+    'gpt-5.2-codex': { input: 1.00, cachedInput: 0.25, output: 4.00 },
+    'gpt-5.3-codex': { input: 0.50, cachedInput: 0.125, output: 2.00 },
+};
+export const CODEX_DEFAULT_PRICING = CODEX_PRICING['gpt-5-codex'];
+export function calculateCostUsd(inputTokens, cachedInputTokens, outputTokens, model) {
+    const pricing = (model && CODEX_PRICING[model]) || CODEX_DEFAULT_PRICING;
+    const freshInputTokens = Math.max(0, inputTokens - cachedInputTokens);
+    return ((freshInputTokens / 1_000_000) * pricing.input +
+        (cachedInputTokens / 1_000_000) * pricing.cachedInput +
+        (outputTokens / 1_000_000) * pricing.output);
+}
 /**
  * Manages a single long-lived `codex app-server` process.
  *
@@ -60,19 +102,109 @@ export class AppServerProcessManager {
         this.cwd = options.cwd;
         this.env = options.env || {};
     }
+    /**
+     * Get the PID file path for tracking the app-server process.
+     * Used for orphan detection on startup.
+     */
+    static getPidFilePath() {
+        const dir = join(homedir(), '.agentfactory');
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        return join(dir, 'codex-app-server.pid');
+    }
+    /**
+     * Kill any orphaned app-server process from a prior fleet run.
+     * Called before starting a new process to prevent resource leaks.
+     */
+    static killOrphanedProcess() {
+        const pidFile = AppServerProcessManager.getPidFilePath();
+        if (!existsSync(pidFile))
+            return;
+        try {
+            const pid = parseInt(readFileSync(pidFile, 'utf-8').trim(), 10);
+            if (isNaN(pid)) {
+                unlinkSync(pidFile);
+                return;
+            }
+            // Check if the process is alive
+            try {
+                process.kill(pid, 0); // signal 0 = check existence
+            }
+            catch {
+                // Process is dead, just clean up the PID file
+                unlinkSync(pidFile);
+                return;
+            }
+            // Process is alive — kill it
+            console.error(`[CodexAppServer] Killing orphaned app-server process (PID ${pid})`);
+            try {
+                process.kill(pid, 'SIGTERM');
+                // Give it a moment, then force kill
+                setTimeout(() => {
+                    try {
+                        process.kill(pid, 0); // still alive?
+                        process.kill(pid, 'SIGKILL');
+                    }
+                    catch {
+                        // Already dead
+                    }
+                }, 2000);
+            }
+            catch {
+                // Kill failed, process may have already exited
+            }
+            unlinkSync(pidFile);
+        }
+        catch {
+            // PID file read/delete failed — ignore
+        }
+    }
+    /**
+     * Write the current app-server PID to the PID file.
+     */
+    writePidFile() {
+        if (!this.process?.pid)
+            return;
+        try {
+            writeFileSync(AppServerProcessManager.getPidFilePath(), String(this.process.pid));
+        }
+        catch {
+            // Best effort
+        }
+    }
+    /**
+     * Remove the PID file on shutdown.
+     */
+    static removePidFile() {
+        try {
+            const pidFile = AppServerProcessManager.getPidFilePath();
+            if (existsSync(pidFile)) {
+                unlinkSync(pidFile);
+            }
+        }
+        catch {
+            // Best effort
+        }
+    }
     /**
      * Start the app-server process and complete the initialization handshake.
      * Idempotent — returns immediately if already initialized.
+     * Kills any orphaned app-server from a prior fleet run before starting.
      */
     async start() {
         if (this.initialized && this.process && !this.process.killed) {
             return;
         }
+        // Kill orphaned app-server from prior fleet run
+        AppServerProcessManager.killOrphanedProcess();
         this.process = spawn(this.codexBin, ['app-server'], {
             cwd: this.cwd,
             env: { ...process.env, ...this.env },
             stdio: ['pipe', 'pipe', 'pipe'],
         });
+        // Track PID for orphan detection on next startup
+        this.writePidFile();
         this.readline = createInterface({ input: this.process.stdout });
         // Parse incoming JSONL messages
         this.readline.on('line', (line) => {
@@ -87,7 +219,12 @@ export class AppServerProcessManager {
                 // Non-JSON output — ignore
                 return;
             }
-            if (isResponse(msg)) {
+            if (isServerRequest(msg)) {
+                // Server requests have both `id` and `method` — Codex expects a response.
+                // Approval requests (commandExecution/requestApproval, etc.) come as server requests.
+                this.handleServerRequest(msg);
+            }
+            else if (isResponse(msg)) {
                 this.handleResponse(msg);
             }
             else if (isNotification(msg)) {
@@ -106,6 +243,16 @@ export class AppServerProcessManager {
         });
         // Perform initialization handshake
         await this.initialize();
+        // Discover available models (best effort — older servers may not support model/list)
+        try {
+            const models = await this.listModels();
+            if (models.length > 0) {
+                console.error(`[CodexAppServer] Available models: ${models.map(m => m.id).join(', ')}`);
+            }
+        }
+        catch {
+            console.error('[CodexAppServer] model/list not supported by this server version');
+        }
     }
     /**
      * JSON-RPC 2.0 initialization handshake:
@@ -174,6 +321,44 @@ export class AppServerProcessManager {
             pending.resolve(response.result);
         }
     }
+    /**
+     * Handle an incoming JSON-RPC server request (has both `id` and `method`).
+     * Codex sends approval requests as server requests that expect a response.
+     * Route to the thread listener (as a notification-like object) and store
+     * the request ID so the handle can respond.
+     */
+    handleServerRequest(request) {
+        const threadId = request.params?.threadId;
+        console.error(`[CodexAppServer] Server request: ${request.method} (id=${request.id}, thread=${threadId ?? 'none'})`);
+        // Wrap as a notification-compatible object for the thread listener,
+        // but include the id so the handle can respond.
+        const notificationLike = {
+            method: request.method,
+            params: { ...request.params, _serverRequestId: request.id },
+        };
+        if (threadId) {
+            const listener = this.threadListeners.get(threadId);
+            if (listener) {
+                listener(notificationLike);
+                return;
+            }
+        }
+        // No thread listener — auto-accept to avoid hanging
+        console.error(`[CodexAppServer] No thread listener for ${request.method} — auto-accepting`);
+        this.respondToServerRequest(request.id, { decision: 'acceptForSession' });
+    }
+    /**
+     * Send a JSON-RPC response to a server request.
+     */
+    respondToServerRequest(requestId, result) {
+        if (!this.process?.stdin?.writable) {
+            console.error('[CodexAppServer] Cannot respond to server request: stdin not writable');
+            return;
+        }
+        console.error(`[CodexAppServer] Responding to server request ${requestId}: ${JSON.stringify(result)}`);
+        const response = JSON.stringify({ jsonrpc: '2.0', id: requestId, result });
+        this.process.stdin.write(response + '\n');
+    }
     /**
      * Handle an incoming JSON-RPC notification.
      * Routes to the appropriate thread listener based on threadId in params.
@@ -236,8 +421,8 @@ export class AppServerProcessManager {
         }
         try {
             await this.request('config/batchWrite', {
-                entries: [
-                    { key: 'mcpServers', value: mcpServers },
+                edits: [
+                    { keyPath: 'mcpServers', mergeStrategy: 'replace', value: mcpServers },
                 ],
             });
             this.mcpConfigured = true;
@@ -264,6 +449,13 @@ export class AppServerProcessManager {
             return [];
         }
     }
+    /**
+     * Discover available models from the app-server via model/list.
+     */
+    async listModels() {
+        const result = await this.request('model/list', {});
+        return result?.models ?? [];
+    }
     /**
      * Get the PID of the app-server process.
      */
@@ -281,6 +473,8 @@ export class AppServerProcessManager {
     }
     async performShutdown() {
         this.initialized = false;
+        // Remove PID file before killing process
+        AppServerProcessManager.removePidFile();
         // Clear all pending requests
         this.rejectAllPending(new Error('App server shutting down'));
         // Kill the process
@@ -359,6 +553,7 @@ export function mapAppServerNotification(notification, state) {
             if (turn?.usage) {
                 state.totalInputTokens += turn.usage.input_tokens ?? 0;
                 state.totalOutputTokens += turn.usage.output_tokens ?? 0;
+                state.totalCachedInputTokens += turn.usage.cached_input_tokens ?? 0;
             }
             if (turnStatus === 'completed') {
                 return [{
@@ -367,6 +562,8 @@ export function mapAppServerNotification(notification, state) {
                         cost: {
                             inputTokens: state.totalInputTokens || undefined,
                             outputTokens: state.totalOutputTokens || undefined,
+                            cachedInputTokens: state.totalCachedInputTokens || undefined,
+                            totalCostUsd: calculateCostUsd(state.totalInputTokens, state.totalCachedInputTokens, state.totalOutputTokens, state.model ?? undefined),
                             numTurns: state.turnCount || undefined,
                         },
                         raw: notification,
@@ -381,6 +578,8 @@ export function mapAppServerNotification(notification, state) {
                         cost: {
                             inputTokens: state.totalInputTokens || undefined,
                             outputTokens: state.totalOutputTokens || undefined,
+                            cachedInputTokens: state.totalCachedInputTokens || undefined,
+                            totalCostUsd: calculateCostUsd(state.totalInputTokens, state.totalCachedInputTokens, state.totalOutputTokens, state.model ?? undefined),
                             numTurns: state.turnCount || undefined,
                         },
                         raw: notification,
@@ -408,7 +607,7 @@ export function mapAppServerNotification(notification, state) {
             return mapAppServerItemEvent(method, params);
         // --- Item deltas (streaming) ---
         case 'item/agentMessage/delta': {
-            const text = params.text;
+            const text = (params.delta ?? params.text);
             if (text) {
                 return [{
                         type: 'assistant_text',
@@ -435,7 +634,7 @@ export function mapAppServerNotification(notification, state) {
             return [{
                     type: 'system',
                     subtype: 'command_progress',
-                    message: (params.delta ?? params.output) ?? '',
+                    message: stripAnsi((params.delta ?? params.output) ?? ''),
                     raw: notification,
                 }];
         // --- Turn diff/plan ---
@@ -462,6 +661,16 @@ export function mapAppServerNotification(notification, state) {
                 }];
     }
 }
+/**
+ * Strip ANSI escape codes from text.
+ * Codex shell commands produce raw terminal output with color codes,
+ * cursor movement, etc. that pollute logs and activity tracking.
+ */
+// eslint-disable-next-line no-control-regex
+const ANSI_PATTERN = /\x1b\[[0-9;]*[a-zA-Z]|\x1b\].*?\x07|\x1b[()][AB012]|\x1b\[[\d;]*m/g;
+function stripAnsi(text) {
+    return text.replace(ANSI_PATTERN, '');
+}
 /**
  * Map item/started and item/completed notifications to AgentEvents.
  * Exported for unit testing.
@@ -507,7 +716,7 @@ export function mapAppServerItemEvent(method, params) {
                         type: 'tool_result',
                         toolName: 'shell',
                         toolUseId: item.id,
-                        content: item.text ?? '',
+                        content: stripAnsi(item.text ?? ''),
                         isError: item.status === 'failed' || (item.exitCode !== undefined && item.exitCode !== 0),
                         raw: { method, params },
                     }];
@@ -607,20 +816,75 @@ export function normalizeMcpToolName(server, tool) {
 // Resolve approval policy from AgentSpawnConfig
 // ---------------------------------------------------------------------------
 function resolveApprovalPolicy(config) {
-    // SUP-1747: Use 'onRequest' for autonomous agents so all tool executions
+    // SUP-1747: Use 'on-request' for autonomous agents so all tool executions
     // flow through the approval bridge for safety evaluation. The bridge
     // auto-approves safe commands and declines destructive patterns.
+    // Codex v0.117+ uses kebab-case: 'on-request' | 'untrusted' | 'on-failure' | 'never'
     if (config.autonomous)
-        return 'onRequest';
-    return 'unlessTrusted';
+        return 'on-request';
+    return 'untrusted';
 }
-function resolveSandboxPolicy(config) {
+/**
+ * Map AgentSpawnConfig sandbox settings to Codex App Server sandbox policy.
+ *
+ * Codex sandbox levels vs Claude sandbox:
+ * | Feature               | Claude                  | Codex                          |
+ * |-----------------------|-------------------------|--------------------------------|
+ * | File write control    | Per-file glob patterns  | Workspace root only            |
+ * | Network access        | Per-domain allow-lists  | All-or-nothing per level       |
+ * | Tool-level permissions| Per-tool allow/deny     | Not supported (approval policy)|
+ * | Custom writable paths | Multiple glob patterns  | Single writableRoots array     |
+ * | Process isolation     | macOS sandbox-exec      | Docker/firewall container      |
+ *
+ * Key limitation: Codex cannot restrict writes to specific subdirectories within
+ * the workspace or allow network access to specific domains. The mapping is intent-based:
+ *   "safe browsing/analysis" → readOnly
+ *   "normal development"     → workspaceWrite
+ *   "install/deploy/admin"   → dangerFullAccess
+ */
+/**
+ * Resolve sandbox policy as an object for turn/start (supports writableRoots).
+ * Codex v0.117+ turn/start accepts: { type: 'workspaceWrite', writableRoots: [...] }
+ *
+ * Network access is enabled by default for agents because they need to run
+ * commands like `gh`, `curl`, `pnpm install`, etc. The sandbox still restricts
+ * file writes to the workspace root.
+ */
+export function resolveSandboxPolicy(config) {
+    if (config.sandboxLevel) {
+        switch (config.sandboxLevel) {
+            case 'read-only':
+                return { type: 'readOnly', networkAccess: true };
+            case 'workspace-write':
+                return { type: 'workspaceWrite', writableRoots: [config.cwd], networkAccess: true };
+            case 'full-access':
+                return { type: 'dangerFullAccess' };
+        }
+    }
+    // Fallback: boolean sandboxEnabled → workspaceWrite with network
     if (!config.sandboxEnabled)
         return undefined;
-    return {
-        type: 'workspaceWrite',
-        writableRoots: [config.cwd],
-    };
+    return { type: 'workspaceWrite', writableRoots: [config.cwd], networkAccess: true };
+}
+/**
+ * Resolve sandbox mode as a simple string for thread/start.
+ * Codex v0.117+ thread/start accepts: 'read-only' | 'workspace-write' | 'danger-full-access'
+ */
+export function resolveSandboxMode(config) {
+    if (config.sandboxLevel) {
+        switch (config.sandboxLevel) {
+            case 'read-only':
+                return 'read-only';
+            case 'workspace-write':
+                return 'workspace-write';
+            case 'full-access':
+                return 'danger-full-access';
+        }
+    }
+    // Fallback: boolean sandboxEnabled → workspace-write
+    if (!config.sandboxEnabled)
+        return undefined;
+    return 'workspace-write';
 }
 // ---------------------------------------------------------------------------
 // Base Instructions Builder (SUP-1746)
@@ -663,8 +927,10 @@ class AppServerAgentHandle {
     resumeThreadId;
     mapperState = {
         sessionId: null,
+        model: null,
         totalInputTokens: 0,
         totalOutputTokens: 0,
+        totalCachedInputTokens: 0,
         turnCount: 0,
     };
     activeTurnId = null;
@@ -673,6 +939,8 @@ class AppServerAgentHandle {
     streamEnded = false;
     /** True while we're waiting for a possible injected turn between turns */
     awaitingInjection = false;
+    /** Accumulated assistant text for the result message (completion comment) */
+    accumulatedText = '';
     constructor(processManager, config, resumeThreadId) {
         this.processManager = processManager;
         this.config = config;
@@ -725,7 +993,7 @@ class AppServerAgentHandle {
         }
         await this.processManager.request('turn/steer', {
             threadId: this.sessionId,
-            turnId: this.activeTurnId,
+            expectedTurnId: this.activeTurnId,
             input: [{ type: 'text', text }],
         });
     }
@@ -738,9 +1006,10 @@ class AppServerAgentHandle {
      *
      * Returns a system event if the request was declined, for observability.
      */
-    async handleApprovalRequest(notification) {
+    handleApprovalRequest(notification) {
         const params = notification.params ?? {};
-        const requestId = params.requestId;
+        // Server requests pass _serverRequestId; fall back to requestId for backwards compat
+        const serverRequestId = params._serverRequestId;
         const command = params.command;
         const filePath = params.filePath;
         let decision;
@@ -756,13 +1025,14 @@ class AppServerAgentHandle {
             // Unknown approval request — accept by default
             decision = { action: 'acceptForSession' };
         }
-        // Respond to the App Server with the approval decision
-        await this.processManager.request('approval/respond', {
-            threadId: this.sessionId,
-            requestId,
-            decision: decision.action,
-            reason: decision.reason,
-        });
+        // Respond to the server request with the approval decision.
+        // Codex sends approval requests as JSON-RPC server requests (with `id`),
+        // expecting a JSON-RPC response matching that id.
+        if (serverRequestId != null) {
+            this.processManager.respondToServerRequest(serverRequestId, {
+                decision: decision.action,
+            });
+        }
         // Emit system event for declined approvals (observability)
         if (decision.action === 'decline') {
             const target = command ?? filePath ?? 'unknown';
@@ -789,9 +1059,7 @@ class AppServerAgentHandle {
             cwd: this.config.cwd,
             approvalPolicy: resolveApprovalPolicy(this.config),
         };
-        if (this.config.maxTurns) {
-            turnParams.maxTurns = this.config.maxTurns;
-        }
+        turnParams.model = resolveCodexModel(this.config);
         const sandboxPolicy = resolveSandboxPolicy(this.config);
         if (sandboxPolicy) {
             turnParams.sandboxPolicy = sandboxPolicy;
@@ -818,7 +1086,7 @@ class AppServerAgentHandle {
                 // Resume existing thread
                 const result = await this.processManager.request('thread/resume', {
                     threadId: this.resumeThreadId,
-                    personality: 'concise',
+                    personality: 'pragmatic',
                 });
                 threadId = result?.thread?.id ?? this.resumeThreadId;
             }
@@ -829,15 +1097,17 @@ class AppServerAgentHandle {
                     approvalPolicy: resolveApprovalPolicy(this.config),
                     serviceName: 'agentfactory',
                 };
-                // SUP-1746: Pass persistent system instructions via `instructions` on thread/start.
+                // SUP-1746: Pass persistent system instructions via `baseInstructions` on thread/start.
                 // Separates safety rules and project context from per-turn task input.
                 const instructions = buildBaseInstructions(this.config);
                 if (instructions) {
-                    threadParams.instructions = instructions;
+                    threadParams.baseInstructions = instructions;
                 }
-                const sandboxPolicy = resolveSandboxPolicy(this.config);
-                if (sandboxPolicy) {
-                    threadParams.sandboxPolicy = sandboxPolicy;
+                threadParams.model = resolveCodexModel(this.config);
+                // thread/start uses simple string sandbox mode (not object like turn/start)
+                const sandboxMode = resolveSandboxMode(this.config);
+                if (sandboxMode) {
+                    threadParams.sandbox = sandboxMode;
                 }
                 const result = await this.processManager.request('thread/start', threadParams);
                 threadId = result?.thread?.id ?? '';
@@ -852,6 +1122,7 @@ class AppServerAgentHandle {
             }
             this.sessionId = threadId;
             this.mapperState.sessionId = threadId;
+            this.mapperState.model = resolveCodexModel(this.config);
             // Subscribe to thread notifications
             this.processManager.subscribeThread(threadId, (notification) => {
                 this.notificationQueue.push(notification);
@@ -873,9 +1144,7 @@ class AppServerAgentHandle {
                 cwd: this.config.cwd,
                 approvalPolicy: resolveApprovalPolicy(this.config),
             };
-            if (this.config.maxTurns) {
-                turnParams.maxTurns = this.config.maxTurns;
-            }
+            turnParams.model = resolveCodexModel(this.config);
             const sandboxPolicy = resolveSandboxPolicy(this.config);
             if (sandboxPolicy) {
                 turnParams.sandboxPolicy = sandboxPolicy;
@@ -905,9 +1174,11 @@ class AppServerAgentHandle {
                 while (this.notificationQueue.length > 0) {
                     const notification = this.notificationQueue.shift();
                     // SUP-1747: Intercept approval requests before other processing.
-                    // The App Server emits these when approvalPolicy is 'onRequest'.
-                    if (notification.method.endsWith('/requestApproval')) {
-                        const deniedEvent = await this.handleApprovalRequest(notification);
+                    // Codex sends approvals as server requests with methods like:
+                    //   item/commandExecution/requestApproval, item/fileChange/requestApproval,
+                    //   item/permissions/requestApproval, applyPatchApproval, execCommandApproval
+                    if (notification.method.includes('pproval') || notification.method.includes('requestApproval')) {
+                        const deniedEvent = this.handleApprovalRequest(notification);
                         if (deniedEvent) {
                             yield deniedEvent;
                         }
@@ -928,18 +1199,31 @@ class AppServerAgentHandle {
                     }
                     const events = mapAppServerNotification(notification, this.mapperState);
                     for (const event of events) {
-                        // Intercept turn/completed result events — convert to system events
-                        // so the orchestrator doesn't think the agent is done. Track the last
-                        // turn's outcome so we can emit a proper result when the stream ends.
+                        // Intercept turn/completed result events.
+                        // In autonomous mode (fleet), emit the result directly to end the session.
+                        // In interactive mode, convert to system event to keep the stream alive
+                        // for potential message injection.
+                        // Accumulate assistant text for the result message / completion comment
+                        if (event.type === 'assistant_text' && event.text) {
+                            this.accumulatedText += event.text;
+                        }
                         if (event.type === 'result') {
-                            lastTurnSuccess = event.success;
-                            lastTurnErrors = event.errors;
-                            yield {
-                                type: 'system',
-                                subtype: 'turn_result',
-                                message: `Turn ${event.success ? 'succeeded' : 'failed'}${event.errors?.length ? ': ' + event.errors[0] : ''}`,
-                                raw: event.raw,
-                            };
+                            if (this.config.autonomous) {
+                                // Autonomous: emit result with accumulated text and end stream
+                                yield { ...event, message: this.accumulatedText.trim() || undefined };
+                                this.streamEnded = true;
+                            }
+                            else {
+                                // Interactive: keep stream alive for injection
+                                lastTurnSuccess = event.success;
+                                lastTurnErrors = event.errors;
+                                yield {
+                                    type: 'system',
+                                    subtype: 'turn_result',
+                                    message: `Turn ${event.success ? 'succeeded' : 'failed'}${event.errors?.length ? ': ' + event.errors[0] : ''}`,
+                                    raw: event.raw,
+                                };
+                            }
                         }
                         else {
                             yield event;
@@ -955,14 +1239,17 @@ class AppServerAgentHandle {
             catch {
                 // Best effort
             }
-            // Emit the final result event when the stream ends
+            // Emit the final result event when the stream ends (interactive mode / stop)
             yield {
                 type: 'result',
                 success: lastTurnSuccess,
+                message: this.accumulatedText.trim() || undefined,
                 errors: lastTurnErrors,
                 cost: {
                     inputTokens: this.mapperState.totalInputTokens || undefined,
                     outputTokens: this.mapperState.totalOutputTokens || undefined,
+                    cachedInputTokens: this.mapperState.totalCachedInputTokens || undefined,
+                    totalCostUsd: calculateCostUsd(this.mapperState.totalInputTokens, this.mapperState.totalCachedInputTokens, this.mapperState.totalOutputTokens, this.mapperState.model ?? undefined),
                     numTurns: this.mapperState.turnCount || undefined,
                 },
                 raw: null,