@renseiai/agentfactory 0.8.21 → 0.8.22

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

@@ -25,12 +25,51 @@ import { spawn } from 'child_process';
 import { createInterface } from 'readline';
 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.
  *
@@ -87,7 +126,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 +150,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 +228,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 +328,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 +356,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.
      */
@@ -359,6 +458,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 +467,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 +483,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 +512,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 +539,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 +566,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 +621,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 +721,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 +832,10 @@ class AppServerAgentHandle {
     resumeThreadId;
     mapperState = {
         sessionId: null,
+        model: null,
         totalInputTokens: 0,
         totalOutputTokens: 0,
+        totalCachedInputTokens: 0,
         turnCount: 0,
     };
     activeTurnId = null;
@@ -673,6 +844,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 +898,7 @@ class AppServerAgentHandle {
         }
         await this.processManager.request('turn/steer', {
             threadId: this.sessionId,
-            turnId: this.activeTurnId,
+            expectedTurnId: this.activeTurnId,
             input: [{ type: 'text', text }],
         });
     }
@@ -738,9 +911,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 +930,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 +964,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 +991,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 +1002,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 +1027,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 +1049,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 +1079,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 +1104,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 +1144,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,