cx-viewer 1.0.3 → 1.0.4

package/lib/sdk-manager.js

@@ -1,472 +1,453 @@
 /**
- * sdk-manager.js — Agent SDK session lifecycle manager.
+ * sdk-manager.js - Codex SDK session lifecycle manager.
  *
- * Wraps @openai/codex query() to provide:
- * - Structured message processing → JSONL entries for the frontend
- * - canUseTool callback for AskUserQuestion + permission approval
- * - Streaming status tracking
- * - Multi-turn conversation via session resume
- * - Completed-entry fallback when a turn only exposes final assistant text via stream events
+ * Uses the official @openai/codex-sdk event stream:
+ *   Codex -> Thread -> runStreamed() -> thread/item/turn events.
  */
 
-import { sdkToJSONLEntry, buildStreamingStatus } from './sdk-adapter.js';
-
-let _query;
+import {
+  DEFAULT_CODEX_TOOLS,
+  buildStreamingStatus,
+  isSdkToolItem,
+  sdkItemToAssistantBlock,
+  sdkItemToToolUseBlock,
+  sdkToJSONLEntry,
+  sdkToolName,
+  sdkToolOutput,
+} from './sdk-adapter.js';
+import { startProxy, stopProxy } from '../proxy.js';
+
+let _Codex = null;
+let _sdkImportError = null;
 try {
-  const sdk = await import('@openai/codex');
-  _query = sdk.query;
+  const sdk = await import('@openai/codex-sdk');
+  _Codex = sdk.Codex;
 } catch (err) {
+  _sdkImportError = err;
   console.warn('[SDK] Codex SDK not available:', err.message);
 }
 
-// Interactive tool names — filtered from entries, handled via canUseTool → WS
-const INTERACTIVE_TOOLS = new Set(['AskUserQuestion', 'ExitPlanMode']);
-
-// Session state
+let _codex = null;
+let _thread = null;
 let _sessionId = null;
 let _model = null;
 let _cwd = null;
 let _projectName = null;
-let _permissionMode = 'default';
-let _accumulatedMessages = [];
-let _activeQuery = null;
-let _queryBusy = false; // concurrency guard
-let _sdkTools = null;    // real tools list from SDKSystemMessage
+let _codexPath = null;
+let _codexOptions = {};
+let _threadOptions = {};
+let _initialPrompt = null;
 
-// Stable timestamp per conversation turn — used as dedup key by frontend
+let _accumulatedMessages = [];
+let _queryBusy = false;
+let _messageQueue = [];
+let _abortController = null;
 let _turnTimestamp = null;
-
-// Streaming accumulation state
-let _streamingContent = [];
-let _currentBlockData = null;
+let _turnStartTime = null;
 let _streamingRequestId = null;
+let _streamingChunkCount = 0;
 let _streamThrottleTimer = null;
-let _pendingFinalContent = null;
-let _pendingFinalRequestMessages = null;
+let _pendingAssistantContent = [];
+let _currentItems = new Map();
+let _itemOrder = [];
+let _completedToolIds = new Set();
 let _finalEntryEmittedThisTurn = false;
 
-// Callbacks registered by server.js
 let _onEntry = null;
 let _onStreamingStatus = null;
+let _onStreamProgress = null;
 let _broadcastWs = null;
+let _sdkProxyPort = null;
+let _sdkProxyPromise = null;
 
-// Pending canUseTool promises: id → { resolve }
 const _pendingApprovals = new Map();
 
-// Message queue for messages sent while a query is running
-let _messageQueue = [];
-
 export function isSdkAvailable() {
-  return typeof _query === 'function';
+  return typeof _Codex === 'function';
 }
 
-/**
- * Initialize SDK session.
- * Does NOT start a query — waits for the first user message via sendUserMessage().
- */
-export function initSdkSession(cwd, projectName, { onEntry, onStreamingStatus, broadcastWs, permissionMode }) {
+export function getSdkUnavailableReason() {
+  return _sdkImportError?.message || null;
+}
+
+export function getInitialPrompt() {
+  return _initialPrompt;
+}
+
+export function initSdkSession(cwd, projectName, {
+  onEntry,
+  onStreamingStatus,
+  onStreamProgress,
+  broadcastWs,
+  permissionMode,
+  codexPath,
+  codexArgs = [],
+} = {}) {
   _cwd = cwd;
   _projectName = projectName;
   _onEntry = onEntry;
   _onStreamingStatus = onStreamingStatus;
+  _onStreamProgress = onStreamProgress;
   _broadcastWs = broadcastWs;
-  _permissionMode = permissionMode || 'default';
-  _resetFullState();
+  _codexPath = codexPath || null;
+
+  const parsed = parseSdkCodexArgs(codexArgs);
+  _codexOptions = parsed.codexOptions;
+  _threadOptions = {
+    workingDirectory: cwd,
+    skipGitRepoCheck: true,
+    ...parsed.threadOptions,
+  };
+  if (permissionMode === 'bypassPermissions') {
+    _threadOptions.approvalPolicy = 'never';
+    _threadOptions.sandboxMode = 'danger-full-access';
+  }
+  _model = _threadOptions.model || null;
+  _initialPrompt = parsed.initialPrompt || null;
+
+  _resetFullState({ keepConfig: true });
+  _sessionId = parsed.resumeThreadId || null;
+
+  // 启动本地代理以拦截 SDK 模式下的真实 API 调用
+  if (_sdkProxyPort === null && !_sdkProxyPromise) {
+    const proxyPromise = startProxy().then(port => {
+      if (_sdkProxyPromise !== proxyPromise) {
+        stopProxy();
+        return null;
+      }
+      _sdkProxyPort = port;
+      return port;
+    }).catch(err => {
+      console.warn('[SDK] Failed to start proxy:', err.message);
+    }).finally(() => {
+      if (_sdkProxyPromise === proxyPromise) _sdkProxyPromise = null;
+    });
+    _sdkProxyPromise = proxyPromise;
+  }
 }
 
-/**
- * Send a user message. Starts a new query (or resumes existing session).
- * Queues the message if a query is already running.
- */
 export async function sendUserMessage(text) {
-  if (!_query) throw new Error('Agent SDK not available');
+  if (!_Codex) throw new Error(`Codex SDK not available${_sdkImportError ? `: ${_sdkImportError.message}` : ''}`);
+  if (!text || !String(text).trim()) return;
 
-  // If a query is already running, queue this message and return
   if (_queryBusy) {
-    _messageQueue.push(text);
+    _messageQueue.push(String(text));
     return;
   }
 
   _queryBusy = true;
-
   try {
-    await _executeQuery(text);
-
-    // Process any queued messages
+    await _executeTurn(String(text));
     while (_messageQueue.length > 0) {
       const next = _messageQueue.shift();
-      await _executeQuery(next);
+      await _executeTurn(next);
     }
   } finally {
     _queryBusy = false;
   }
 }
 
-/**
- * Execute a single query for one user message.
- */
-async function _executeQuery(text) {
-  // Generate stable timestamp for this turn — all entries share it for dedup
+async function _executeTurn(text) {
+  _resetTurnState();
   _turnTimestamp = new Date().toISOString();
-  _streamingRequestId = `sdk_${Date.now()}`;
-  _pendingFinalContent = null;
-  _pendingFinalRequestMessages = null;
-  _finalEntryEmittedThisTurn = false;
+  _turnStartTime = Date.now();
+  _streamingRequestId = `sdk_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
 
-  // Accumulate user message BEFORE creating entries (this is the request)
   _accumulatedMessages.push({ role: 'user', content: text });
 
-  const options = {
-    cwd: _cwd,
-    includePartialMessages: true,
-    permissionMode: _permissionMode,
-    canUseTool: _permissionMode === 'bypassPermissions' ? undefined : _handleCanUseTool,
-    ..._permissionMode === 'bypassPermissions' && { allowDangerouslySkipPermissions: true },
-  };
-
-  if (_sessionId) {
-    options.resume = _sessionId;
+  if (!_codex) {
+    _codex = new _Codex({
+      ..._codexOptions,
+      ...(_codexPath ? { codexPathOverride: _codexPath } : {}),
+      env: {
+        ...process.env,
+        CXV_SDK_MODE: '1',
+        CXV_PROJECT_DIR: _cwd,
+        ...(_sdkProxyPort ? { OPENAI_BASE_URL: `http://127.0.0.1:${_sdkProxyPort}` } : {}),
+      },
+    });
+  }
+  if (!_thread) {
+    _thread = _sessionId
+      ? _codex.resumeThread(_sessionId, _threadOptions)
+      : _codex.startThread(_threadOptions);
   }
 
-  if (_onStreamingStatus) _onStreamingStatus(buildStreamingStatus(true, { model: _model }));
+  _abortController = new AbortController();
+  _sendStreamingStatus(true);
 
   try {
-    _activeQuery = _query({ prompt: text, options });
-
-    for await (const msg of _activeQuery) {
-      _processMessage(msg);
+    const streamed = await _thread.runStreamed(text, { signal: _abortController.signal });
+    for await (const event of streamed.events) {
+      _processEvent(event);
     }
   } catch (err) {
-    if (err.name !== 'AbortError') {
-      console.error('[SDK] Query error:', err.message);
+    if (err?.name === 'AbortError') {
+      _emitErrorEntry('Turn interrupted');
+    } else {
+      console.error('[SDK] runStreamed error:', err.message);
+      _emitErrorEntry(err.message || String(err));
     }
   } finally {
-    _resetStreamingState();
-    _activeQuery = null;
-    if (_onStreamingStatus) _onStreamingStatus(buildStreamingStatus(false));
+    _flushStreamProgress();
+    _clearStreamThrottle();
+    _abortController = null;
+    _sendStreamingStatus(false);
   }
 }
 
-/**
- * Process a single SDK message.
- */
-function _processMessage(msg) {
-  switch (msg.type) {
-    case 'system':
-      if (msg.session_id) _sessionId = msg.session_id;
-      if (msg.model) _model = msg.model;
-      // Capture real tools from init message (tools is string[], convert to {name} format)
-      if (msg.subtype === 'init') {
-        if (Array.isArray(msg.tools)) _sdkTools = msg.tools.map(name => ({ name }));
-      }
-      // Handle compact boundary: reset accumulated messages since SDK compacted internally
-      if (msg.subtype === 'compact_boundary') {
-        _accumulatedMessages = [];
-      }
+function _processEvent(event) {
+  if (!event || typeof event !== 'object') return;
+
+  switch (event.type) {
+    case 'thread.started':
+      _sessionId = event.thread_id || _sessionId;
       break;
 
-    case 'assistant':
-      // Main agent message (not sub-agent)
-      if (!msg.parent_tool_use_id && msg.message) {
-        _resetStreamingState();
-        _pendingFinalContent = null;
-        _pendingFinalRequestMessages = null;
-
-        // Snapshot messages BEFORE adding assistant (body.messages = request history, unfiltered)
-        const requestMessages = [..._accumulatedMessages];
-
-        // Accumulate the assistant response for future turns
-        // Merge with previous if both are assistant (same API turn, multiple content blocks)
-        const lastMsg = _accumulatedMessages[_accumulatedMessages.length - 1];
-        if (lastMsg && lastMsg.role === 'assistant' && Array.isArray(lastMsg.content) && Array.isArray(msg.message.content)) {
-          lastMsg.content = [...lastMsg.content, ...msg.message.content];
-        } else {
-          _accumulatedMessages.push({ role: 'assistant', content: msg.message.content });
-        }
-
-        // Only filter interactive tools from the RESPONSE content (Last Response rendering),
-        // NOT from body.messages (history) — filtering history creates orphaned tool_results
-        const filteredContent = _filterInteractiveContent(msg.message.content);
-        const displayMsg = { ...msg, message: { ...msg.message, content: filteredContent } };
-
-        // Convert to JSONL entry with stable turn timestamp and real SDK metadata
-        const entry = sdkToJSONLEntry(displayMsg, requestMessages, _model, _projectName, {
-          timestamp: _turnTimestamp,
-          tools: _sdkTools,
-        });
-        if (_onEntry) _onEntry(entry);
-        _finalEntryEmittedThisTurn = true;
-      }
-      if (msg.session_id) _sessionId = msg.session_id;
+    case 'turn.started':
+      _sendStreamingStatus(true);
       break;
 
-    case 'user':
-      // Tool results from tool execution — accumulate (skip replays)
-      if (msg.message && !msg.isReplay) {
-        // Merge with previous if both are user (consecutive tool_results for same turn)
-        const lastUserMsg = _accumulatedMessages[_accumulatedMessages.length - 1];
-        if (lastUserMsg && lastUserMsg.role === 'user' && Array.isArray(lastUserMsg.content) && Array.isArray(msg.message.content)) {
-          lastUserMsg.content = [...lastUserMsg.content, ...msg.message.content];
-        } else {
-          _accumulatedMessages.push({ role: 'user', content: msg.message.content });
-        }
-      }
+    case 'item.started':
+    case 'item.updated':
+      _upsertItem(event.item);
+      _scheduleStreamProgress();
       break;
 
-    case 'stream_event':
-      if (_onStreamingStatus) {
-        _onStreamingStatus(buildStreamingStatus(true, { model: _model }));
-      }
-      if (!msg.parent_tool_use_id) {
-        _processStreamEvent(msg.event);
-      }
+    case 'item.completed':
+      _upsertItem(event.item);
+      _handleCompletedItem(event.item);
+      _scheduleStreamProgress();
       break;
 
-    case 'result':
-      if (!_finalEntryEmittedThisTurn && _pendingFinalContent?.length > 0) {
-        _emitCompletedEntryFromStream();
-      }
-      if (msg.session_id) _sessionId = msg.session_id;
-      if (_onStreamingStatus) _onStreamingStatus(buildStreamingStatus(false));
+    case 'turn.completed':
+      _emitCompletedEntry(event.usage);
       break;
 
-    default:
+    case 'turn.failed':
+      _emitErrorEntry(event.error?.message || 'Codex turn failed');
+      break;
+
+    case 'error':
+      _emitErrorEntry(event.message || 'Codex SDK error');
       break;
   }
 }
 
-/**
- * Filter interactive tool_use blocks from an array of content blocks.
- */
-function _filterInteractiveContent(content) {
-  return Array.isArray(content)
-    ? content.filter(b => b.type !== 'tool_use' || !INTERACTIVE_TOOLS.has(b.name))
-    : content;
+function _upsertItem(item) {
+  if (!item || typeof item !== 'object') return;
+  const id = item.id || `${item.type || 'item'}_${_itemOrder.length}`;
+  if (!_currentItems.has(id)) _itemOrder.push(id);
+  _currentItems.set(id, { ...item, id });
 }
 
-/**
- * Process a single streaming event.
- * Accumulates content blocks and pushes throttled in-progress entries.
- */
-function _processStreamEvent(event) {
-  if (!event) return;
-  const type = event.type;
-
-  if (type === 'message_start') {
-    _streamingContent = [];
-    _currentBlockData = null;
-  } else if (type === 'content_block_start') {
-    const block = event.content_block;
-    if (!block) return;
-    if (block.type === 'text') {
-      _currentBlockData = { type: 'text', text: block.text || '' };
-    } else if (block.type === 'thinking') {
-      _currentBlockData = { type: 'thinking', thinking: block.thinking || '' };
-    } else if (block.type === 'tool_use') {
-      if (INTERACTIVE_TOOLS.has(block.name)) {
-        _currentBlockData = null;
-      } else {
-        _currentBlockData = { type: 'tool_use', id: block.id, name: block.name, input: {} };
-      }
-    } else {
-      _currentBlockData = null;
-    }
-  } else if (type === 'content_block_delta') {
-    const delta = event.delta;
-    if (!delta || !_currentBlockData) return;
-    if (delta.type === 'text_delta' && _currentBlockData.type === 'text') {
-      _currentBlockData.text += delta.text || '';
-      _pushStreamingEntry();
-    } else if (delta.type === 'thinking_delta' && _currentBlockData.type === 'thinking') {
-      _currentBlockData.thinking += delta.thinking || '';
-    } else if (delta.type === 'input_json_delta' && _currentBlockData.type === 'tool_use') {
-      if (!_currentBlockData._rawInput) _currentBlockData._rawInput = '';
-      _currentBlockData._rawInput += delta.partial_json || '';
-    }
-  } else if (type === 'content_block_stop') {
-    if (_currentBlockData) {
-      if (_currentBlockData.type === 'tool_use' && _currentBlockData._rawInput) {
-        try { _currentBlockData.input = JSON.parse(_currentBlockData._rawInput); } catch {}
-        delete _currentBlockData._rawInput;
-      }
-      _streamingContent.push(_currentBlockData);
-      _currentBlockData = null;
-      _pushStreamingEntry();
-    }
-  } else if (type === 'message_stop') {
-    if (_streamingContent.length > 0) {
-      _pendingFinalContent = [..._streamingContent];
-      _pendingFinalRequestMessages = [..._accumulatedMessages];
-    }
-    _resetStreamingState();
+function _handleCompletedItem(item) {
+  if (!item || typeof item !== 'object') return;
+  if (isSdkToolItem(item)) {
+    _completeToolItem(item);
+    return;
   }
+
+  const block = sdkItemToAssistantBlock(item);
+  if (!block) return;
+
+  // Replace older block for the same item if an item.completed arrives after
+  // repeated item.updated events. Only completed items enter durable history.
+  const id = item.id || '';
+  _pendingAssistantContent = _pendingAssistantContent.filter(b => b._sdkItemId !== id);
+  _pendingAssistantContent.push({ ...block, _sdkItemId: id });
 }
 
-/**
- * Push a throttled in-progress entry with accumulated streaming content.
- */
-function _pushStreamingEntry() {
-  if (_streamThrottleTimer) return;
-  _streamThrottleTimer = setTimeout(() => {
-    _streamThrottleTimer = null;
-    _flushStreamingEntry();
-  }, 100);
+function _completeToolItem(item) {
+  const id = item.id || `${item.type || 'tool'}_${Date.now()}`;
+  if (_completedToolIds.has(id)) return;
+  _completedToolIds.add(id);
+
+  const toolUse = sdkItemToToolUseBlock({ ...item, id });
+  if (!toolUse) return;
+
+  _pendingAssistantContent.push(toolUse);
+  _flushPendingAssistantContent();
+
+  const output = sdkToolOutput(item);
+  _accumulatedMessages.push({
+    role: 'user',
+    content: [{
+      type: 'tool_result',
+      tool_use_id: toolUse.id,
+      content: typeof output === 'string' ? output : JSON.stringify(output, null, 2),
+      is_error: item.status === 'failed' || !!item.error,
+    }],
+  });
+
+  _emitToolEntry(item, toolUse, output);
 }
 
-function _flushStreamingEntry() {
-  if (!_onEntry) return;
-  const content = [..._streamingContent];
-  if (_currentBlockData) {
-    const clone = { ..._currentBlockData };
-    if (clone._rawInput) delete clone._rawInput;
-    content.push(clone);
+function _flushPendingAssistantContent() {
+  const content = _stripInternalFields(_pendingAssistantContent);
+  if (content.length > 0) {
+    _accumulatedMessages.push({ role: 'assistant', content });
   }
-  if (content.length === 0) return;
+  _pendingAssistantContent = [];
+}
+
+function _emitCompletedEntry(usage) {
+  if (_finalEntryEmittedThisTurn) return;
+  const finalContent = _stripInternalFields(_pendingAssistantContent);
+  const messagesSnapshot = cloneJson(_accumulatedMessages);
 
-  const syntheticMsg = {
+  const assistantMsg = {
     message: {
       id: _streamingRequestId,
       type: 'message',
       role: 'assistant',
       model: _model,
-      content,
-      stop_reason: null,
-      usage: { input_tokens: 0, output_tokens: 0 },
+      content: finalContent,
+      usage,
     },
   };
-  // Use the SAME stable turn timestamp so in-progress entries dedup with the final entry
-  const entry = sdkToJSONLEntry(syntheticMsg, [..._accumulatedMessages], _model, _projectName, {
-    inProgress: true,
-    tools: _sdkTools,
-    requestId: _streamingRequestId,
+
+  const entry = sdkToJSONLEntry(assistantMsg, messagesSnapshot, _model, _projectName, {
     timestamp: _turnTimestamp,
+    requestId: _streamingRequestId,
+    threadId: _sessionId || _thread?.id || null,
+    cwd: _cwd,
+    tools: DEFAULT_CODEX_TOOLS,
+    duration: _turnStartTime ? Date.now() - _turnStartTime : 0,
+    metadata: { source: 'codex-sdk' },
   });
-  _onEntry(entry);
-}
 
-function _resetStreamingState() {
-  _streamingContent = [];
-  _currentBlockData = null;
-  if (_streamThrottleTimer) {
-    clearTimeout(_streamThrottleTimer);
-    _streamThrottleTimer = null;
+  if (_onEntry) _onEntry(entry);
+  if (finalContent.length > 0) {
+    _accumulatedMessages.push({ role: 'assistant', content: finalContent });
   }
+  _pendingAssistantContent = [];
+  _finalEntryEmittedThisTurn = true;
 }
 
-function _emitCompletedEntryFromStream() {
-  if (!_onEntry || !_pendingFinalContent?.length) return;
-
-  const requestMessages = _pendingFinalRequestMessages || [..._accumulatedMessages];
-  const content = _filterInteractiveContent(_pendingFinalContent);
-  const syntheticMsg = {
+function _emitErrorEntry(message) {
+  if (_finalEntryEmittedThisTurn || !_onEntry) return;
+  const content = message ? [{ type: 'text', text: `Error: ${message}` }] : [];
+  const assistantMsg = {
     message: {
-      id: _streamingRequestId,
+      id: _streamingRequestId || `sdk_${Date.now()}`,
       type: 'message',
       role: 'assistant',
       model: _model,
       content,
-      stop_reason: 'end_turn',
-      usage: { input_tokens: 0, output_tokens: 0 },
+      error: { message },
+      usage: null,
     },
   };
-
-  const entry = sdkToJSONLEntry(syntheticMsg, requestMessages, _model, _projectName, {
-    timestamp: _turnTimestamp,
-    tools: _sdkTools,
+  const entry = sdkToJSONLEntry(assistantMsg, cloneJson(_accumulatedMessages), _model, _projectName, {
+    timestamp: _turnTimestamp || new Date().toISOString(),
+    threadId: _sessionId || _thread?.id || null,
+    cwd: _cwd,
+    status: 500,
+    statusText: 'Error',
+    stopReason: 'error',
+    duration: _turnStartTime ? Date.now() - _turnStartTime : 0,
+    metadata: { source: 'codex-sdk' },
   });
   _onEntry(entry);
   _finalEntryEmittedThisTurn = true;
-
-  const lastMsg = _accumulatedMessages[_accumulatedMessages.length - 1];
-  if (lastMsg && lastMsg.role === 'assistant' && Array.isArray(lastMsg.content)) {
-    lastMsg.content = [...lastMsg.content, ...content];
-  } else {
-    _accumulatedMessages.push({ role: 'assistant', content });
-  }
-
-  _pendingFinalContent = null;
-  _pendingFinalRequestMessages = null;
 }
 
-/**
- * canUseTool callback — handles AskUserQuestion + permission approval.
- */
-async function _handleCanUseTool(toolName, input, options) {
-  const id = options?.toolUseID || `sdk_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+function _emitToolEntry(item, toolUse, output) {
+  if (!_onEntry) return;
+  const name = sdkToolName(item);
+  _onEntry({
+    timestamp: new Date().toISOString(),
+    project: _projectName || 'sdk',
+    url: `codex://sdk/tool/${encodeURIComponent(name)}`,
+    method: 'TOOL',
+    headers: {},
+    body: {
+      tool_name: name,
+      tool_input: toolUse.input || {},
+      _callId: toolUse.id,
+      _threadId: _sessionId || _thread?.id || null,
+      _itemType: item.type,
+      status: item.status,
+      raw_item: cloneJson(item),
+    },
+    response: {
+      status: item.status === 'failed' || item.error ? 500 : 200,
+      statusText: item.status === 'failed' || item.error ? 'Error' : 'OK',
+      headers: {},
+      body: {
+        output,
+        status: item.status,
+      },
+    },
+    duration: 0,
+    isStream: false,
+    mainAgent: false,
+    subAgent: false,
+    _sdkSource: true,
+  });
+}
 
-  if (toolName === 'ExitPlanMode') {
-    if (_broadcastWs) {
-      _broadcastWs({ type: 'sdk-plan-pending', id, input });
-    }
-    const result = await _waitForApproval(id, 5 * 60 * 1000);
-    if (result === null) {
-      return { behavior: 'deny', message: 'Timeout waiting for plan approval' };
-    }
-    if (typeof result === 'object' && result.approve === false) {
-      return { behavior: 'deny', message: result.feedback || 'User rejected the plan' };
-    }
-    return { behavior: 'allow', updatedInput: input };
-  }
+function _scheduleStreamProgress() {
+  if (_streamThrottleTimer) return;
+  _streamThrottleTimer = setTimeout(() => {
+    _streamThrottleTimer = null;
+    _flushStreamProgress();
+  }, 80);
+}
 
-  if (toolName === 'AskUserQuestion') {
-    if (_broadcastWs) {
-      _broadcastWs({ type: 'sdk-ask-pending', id, questions: input.questions });
-    }
-    const answers = await _waitForApproval(id, 5 * 60 * 1000);
-    if (answers === null) {
-      return { behavior: 'deny', message: 'Timeout waiting for user answer' };
-    }
-    return { behavior: 'allow', updatedInput: { questions: input.questions, answers } };
-  }
+function _flushStreamProgress() {
+  if (!_onStreamProgress || !_turnTimestamp) return;
+  const content = _streamContentFromItems();
+  if (!content.length) return;
+  _streamingChunkCount += 1;
+  _onStreamProgress({
+    timestamp: _turnTimestamp,
+    url: `codex://sdk/${encodeURIComponent(_sessionId || _thread?.id || _model || 'thread')}`,
+    content,
+    model: _model,
+  });
+}
 
-  // Tools that need explicit user approval via Web UI (mutating or external access)
-  const APPROVAL_TOOLS = new Set(['Bash', 'Edit', 'Write', 'NotebookEdit', 'WebFetch', 'WebSearch']);
-  if (!APPROVAL_TOOLS.has(toolName)) {
-    return { behavior: 'allow', updatedInput: input };
+function _streamContentFromItems() {
+  const blocks = [];
+  for (const id of _itemOrder) {
+    const item = _currentItems.get(id);
+    const block = sdkItemToAssistantBlock(item);
+    if (!block) continue;
+    if (block.type === 'text' && !block.text?.trim()) continue;
+    if (block.type === 'thinking' && !block.thinking?.trim()) continue;
+    blocks.push(block);
   }
+  return _stripInternalFields(blocks);
+}
 
-  // Permission approval for mutating tools
-  const suggestions = options?.suggestions;
-  if (_broadcastWs) {
-    _broadcastWs({ type: 'perm-hook-pending', id, toolName, input });
+function _sendStreamingStatus(active) {
+  if (_onStreamingStatus) {
+    _onStreamingStatus(buildStreamingStatus(active, {
+      model: _model,
+      startTime: _turnStartTime,
+      chunksReceived: _streamingChunkCount,
+    }));
   }
+}
 
-  const result = await _waitForApproval(id, 5 * 60 * 1000);
-  if (result === null) {
-    return { behavior: 'deny', message: 'Timeout waiting for user approval' };
-  }
-  const decision = typeof result === 'object' ? result.decision : result;
-  const allowSession = typeof result === 'object' && result.allowSession;
-  if (decision === 'deny') {
-    return { behavior: 'deny', message: 'User denied via cx-viewer' };
-  }
-  const response = { behavior: 'allow', updatedInput: input };
-  if (allowSession && Array.isArray(suggestions) && suggestions.length > 0) {
-    response.updatedPermissions = suggestions;
+function _clearStreamThrottle() {
+  if (_streamThrottleTimer) {
+    clearTimeout(_streamThrottleTimer);
+    _streamThrottleTimer = null;
   }
-  return response;
 }
 
-function _waitForApproval(id, timeoutMs) {
-  return new Promise((resolve) => {
-    const timer = setTimeout(() => {
-      _pendingApprovals.delete(id);
-      resolve(null);
-    }, timeoutMs);
-    _pendingApprovals.set(id, {
-      resolve: (value) => {
-        clearTimeout(timer);
-        _pendingApprovals.delete(id);
-        resolve(value);
-      },
-    });
-  });
+export function interruptTurn() {
+  _messageQueue = [];
+  if (_abortController) {
+    try { _abortController.abort(); } catch {}
+    return true;
+  }
+  return false;
 }
 
-/**
- * Resolve a pending canUseTool approval.
- * Called by server.js when a WS message arrives.
- */
 export function resolveApproval(id, value) {
   const pending = _pendingApprovals.get(id);
   if (pending) {
@@ -476,44 +457,216 @@ export function resolveApproval(id, value) {
   return false;
 }
 
-/**
- * Stop the active SDK session.
- */
 export function stopSession() {
-  // Use close() instead of interrupt() — works in all modes
-  if (_activeQuery && typeof _activeQuery.close === 'function') {
-    _activeQuery.close();
+  interruptTurn();
+  if (_sdkProxyPort !== null || _sdkProxyPromise) {
+    const pendingProxy = _sdkProxyPromise;
+    _sdkProxyPromise = null;
+    stopProxy();
+    _sdkProxyPort = null;
+    if (pendingProxy) {
+      pendingProxy.then(() => stopProxy()).catch(() => {});
+    }
   }
-  _resetFullState();
+  _resetFullState({ keepConfig: false });
 }
 
-/**
- * Reset all session state.
- */
-function _resetFullState() {
-  _activeQuery = null;
+export function getSessionId() {
+  return _sessionId;
+}
+
+function _resetTurnState() {
+  _turnTimestamp = null;
+  _turnStartTime = null;
+  _streamingRequestId = null;
+  _streamingChunkCount = 0;
+  _pendingAssistantContent = [];
+  _currentItems = new Map();
+  _itemOrder = [];
+  _completedToolIds = new Set();
+  _finalEntryEmittedThisTurn = false;
+  _clearStreamThrottle();
+}
+
+function _resetFullState({ keepConfig } = {}) {
+  interruptTurn();
+  _codex = null;
+  _thread = null;
   _sessionId = null;
-  _model = null;
-  _sdkTools = null;
+  _model = keepConfig ? (_threadOptions.model || null) : null;
   _queryBusy = false;
-  _accumulatedMessages = [];
-  _turnTimestamp = null;
   _messageQueue = [];
-  _pendingFinalContent = null;
-  _pendingFinalRequestMessages = null;
-  _finalEntryEmittedThisTurn = false;
-  _resetStreamingState();
-  _streamingRequestId = null;
-  // Reject all pending approvals
+  _accumulatedMessages = [];
+  _resetTurnState();
   for (const [, pending] of _pendingApprovals) {
     pending.resolve(null);
   }
   _pendingApprovals.clear();
 }
 
-/**
- * Get current session ID (for resume).
- */
-export function getSessionId() {
-  return _sessionId;
+function cloneJson(value) {
+  if (value == null) return value;
+  try {
+    return JSON.parse(JSON.stringify(value));
+  } catch {
+    return value;
+  }
+}
+
+function _stripInternalFields(blocks) {
+  return (blocks || []).map(block => {
+    if (!block || typeof block !== 'object') return block;
+    const { _sdkItemId, ...rest } = block;
+    return rest;
+  });
+}
+
+function parseSdkCodexArgs(args = []) {
+  const threadOptions = {};
+  const codexOptions = {};
+  const config = {};
+  const additionalDirectories = [];
+  const promptParts = [];
+  let resumeThreadId = null;
+
+  const setConfig = (path, value) => {
+    const keys = String(path || '').split('.').filter(Boolean);
+    if (keys.length === 0) return;
+    const parsedValue = parseConfigValue(value);
+    if (keys.length === 1 && keys[0] === 'model' && typeof parsedValue === 'string') {
+      threadOptions.model = parsedValue;
+    }
+    let target = config;
+    for (let i = 0; i < keys.length - 1; i++) {
+      const key = keys[i];
+      if (!target[key] || typeof target[key] !== 'object' || Array.isArray(target[key])) {
+        target[key] = {};
+      }
+      target = target[key];
+    }
+    target[keys[keys.length - 1]] = parsedValue;
+  };
+
+  const takeValue = (argv, index, inline) => {
+    if (inline !== undefined) return { value: inline, nextIndex: index };
+    return { value: argv[index + 1], nextIndex: index + 1 };
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg) continue;
+
+    if (arg === 'exec' || arg === 'review') {
+      promptParts.push(...args.slice(i + 1));
+      break;
+    }
+
+    if (arg === 'resume') {
+      const maybeId = args[i + 1];
+      if (maybeId && maybeId !== '--last' && !maybeId.startsWith('-')) {
+        resumeThreadId = maybeId;
+        i += 1;
+      }
+      continue;
+    }
+
+    if (arg === '--last') {
+      continue;
+    }
+
+    const [flag, inline] = arg.includes('=') ? arg.split(/=(.*)/s, 2) : [arg, undefined];
+
+    if (flag === '-m' || flag === '--model') {
+      const taken = takeValue(args, i, inline);
+      if (taken.value) threadOptions.model = taken.value;
+      i = taken.nextIndex;
+      continue;
+    }
+    if (flag === '-C' || flag === '--cd') {
+      const taken = takeValue(args, i, inline);
+      if (taken.value) threadOptions.workingDirectory = taken.value;
+      i = taken.nextIndex;
+      continue;
+    }
+    if (flag === '-s' || flag === '--sandbox') {
+      const taken = takeValue(args, i, inline);
+      if (taken.value) threadOptions.sandboxMode = taken.value;
+      i = taken.nextIndex;
+      continue;
+    }
+    if (flag === '-a' || flag === '--ask-for-approval') {
+      const taken = takeValue(args, i, inline);
+      if (taken.value) threadOptions.approvalPolicy = normalizeApprovalPolicy(taken.value);
+      i = taken.nextIndex;
+      continue;
+    }
+    if (flag === '--add-dir') {
+      const taken = takeValue(args, i, inline);
+      if (taken.value) additionalDirectories.push(taken.value);
+      i = taken.nextIndex;
+      continue;
+    }
+    if (flag === '-c' || flag === '--config') {
+      const taken = takeValue(args, i, inline);
+      if (taken.value && String(taken.value).includes('=')) {
+        const [key, value] = String(taken.value).split(/=(.*)/s, 2);
+        setConfig(key, value);
+      }
+      i = taken.nextIndex;
+      continue;
+    }
+    if (arg === '--search') {
+      threadOptions.webSearchMode = 'live';
+      continue;
+    }
+    if (arg === '--skip-git-repo-check') {
+      threadOptions.skipGitRepoCheck = true;
+      continue;
+    }
+    if (arg === '--dangerously-bypass-approvals-and-sandbox') {
+      threadOptions.approvalPolicy = 'never';
+      threadOptions.sandboxMode = 'danger-full-access';
+      continue;
+    }
+    if (arg === '--full-auto') {
+      threadOptions.approvalPolicy = 'on-failure';
+      threadOptions.sandboxMode = 'workspace-write';
+      continue;
+    }
+    if (arg.startsWith('-')) {
+      continue;
+    }
+    promptParts.push(arg);
+  }
+
+  if (additionalDirectories.length > 0) {
+    threadOptions.additionalDirectories = additionalDirectories;
+  }
+  if (Object.keys(config).length > 0) {
+    codexOptions.config = config;
+  }
+
+  return {
+    threadOptions,
+    codexOptions,
+    resumeThreadId,
+    initialPrompt: promptParts.join(' ').trim(),
+  };
+}
+
+function normalizeApprovalPolicy(value) {
+  if (value === 'on_request') return 'on-request';
+  if (value === 'on_failure') return 'on-failure';
+  return value;
+}
+
+function parseConfigValue(raw) {
+  const value = String(raw ?? '').trim();
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  if (/^-?\d+(\.\d+)?$/.test(value)) return Number(value);
+  if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+    return value.slice(1, -1);
+  }
+  return value;
 }