cx-viewer 1.0.2 → 1.0.4

package/lib/interceptor-core.js

@@ -1,72 +1,515 @@
 import { appendFileSync, existsSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import * as zlib from 'node:zlib';
+import {
+  getInputItemText,
+  getInstructionsText,
+  getResponseConversationItems,
+  getResponseTools,
+  getResponseInputItems,
+  hasResponseInputArray,
+  textFromContent,
+} from './openai-body.js';
 
-const SUBAGENT_SYSTEM_RE = /(?:command execution|file search|planning) specialist|general-purpose agent/i;
+export { getInstructionsText } from './openai-body.js';
 
-export function getSystemText(body) {
-  const system = body?.system;
-  if (typeof system === 'string') return system;
-  if (Array.isArray(system)) {
-    return system.map(s => (s && s.text) || '').join('');
+const SUBAGENT_INSTRUCTIONS_RE = /(?:command execution|file search|planning) specialist|general-purpose agent|subagent|sub-agent/i;
+const CODEX_TOOL_NAMES = new Set([
+  'apply_patch',
+  'local_shell',
+  'shell',
+  'shell_command',
+  'view_image',
+  'update_plan',
+  'request_user_input',
+  'tool_search',
+  'web_search',
+  'spawn_agent',
+  'send_input',
+  'resume_agent',
+  'wait_agent',
+  'close_agent',
+]);
+
+function safeJsonParse(value) {
+  if (typeof value !== 'string') return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+function getHeader(headers, name) {
+  if (!headers) return '';
+  const target = name.toLowerCase();
+  if (typeof headers.get === 'function') return headers.get(name) || headers.get(target) || '';
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === target) return Array.isArray(value) ? value.join(', ') : String(value);
   }
   return '';
 }
 
-export function isMainAgentRequest(body) {
-  if (!body?.system || !Array.isArray(body?.tools)) return false;
-
-  const sysText = getSystemText(body);
-  if (!sysText.includes('You are Codex')) return false;
-  if (SUBAGENT_SYSTEM_RE.test(sysText)) return false;
-
-  const isSystemArray = Array.isArray(body.system);
-  const hasToolSearch = body.tools.some(t => t.name === 'ToolSearch');
-
-  if (isSystemArray && hasToolSearch) {
-    const messages = body.messages || [];
-    const firstMsgContent = messages.length > 0 ?
-      (typeof messages[0].content === 'string' ? messages[0].content :
-        Array.isArray(messages[0].content) ? messages[0].content.map(c => c.text || '').join('') : '') : '';
-    if (firstMsgContent.includes('<available-deferred-tools>')) {
-      return true;
+function bodyToBuffer(body) {
+  if (body == null) return null;
+  if (Buffer.isBuffer(body)) return body;
+  if (body instanceof Uint8Array) return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+  if (body instanceof ArrayBuffer) return Buffer.from(body);
+  return null;
+}
+
+function decodeCompressedRequestBody(buffer, encoding) {
+  const enc = String(encoding || '').toLowerCase().split(',').map(s => s.trim()).filter(Boolean);
+  let out = buffer;
+  for (let i = enc.length - 1; i >= 0; i--) {
+    const e = enc[i];
+    if (e === 'identity') continue;
+    if (e === 'gzip' || e === 'x-gzip') {
+      out = zlib.gunzipSync(out);
+    } else if (e === 'br') {
+      out = zlib.brotliDecompressSync(out);
+    } else if (e === 'deflate') {
+      try {
+        out = zlib.inflateSync(out);
+      } catch {
+        out = zlib.inflateRawSync(out);
+      }
+    } else if (e === 'zstd') {
+      if (typeof zlib.zstdDecompressSync !== 'function') {
+        throw new Error('zstd decompression is not supported by this Node.js runtime');
+      }
+      out = zlib.zstdDecompressSync(out);
+    } else {
+      throw new Error(`unsupported content-encoding: ${e}`);
     }
   }
+  return out;
+}
+
+export function parseRequestBodyForLog(rawBody, headers = {}) {
+  if (rawBody == null) return null;
 
-  // v2.1.81+: 轻量 MainAgent 初始请求工具数可能 < 10，降低阈值兼容
-  if (body.tools.length > 5) {
-    const hasEdit = body.tools.some(t => t.name === 'Edit');
-    const hasBash = body.tools.some(t => t.name === 'Bash');
-    const hasTaskOrAgent = body.tools.some(t => t.name === 'Task' || t.name === 'Agent');
-    if (hasEdit && hasBash && hasTaskOrAgent) {
-      return true;
+  const contentEncoding = getHeader(headers, 'content-encoding');
+  const buffer = bodyToBuffer(rawBody);
+  try {
+    let text;
+    if (buffer) {
+      const decoded = contentEncoding
+        ? decodeCompressedRequestBody(buffer, contentEncoding)
+        : buffer;
+      text = decoded.toString('utf8');
+    } else {
+      text = typeof rawBody === 'string' ? rawBody : String(rawBody);
+    }
+    return JSON.parse(text);
+  } catch {
+    if (buffer) {
+      const encoded = contentEncoding ? `${contentEncoding} ` : '';
+      return `[${encoded}binary request body: ${buffer.length} bytes]`;
     }
+    return String(rawBody).slice(0, 500);
   }
+}
+
+function getToolName(tool) {
+  if (!tool || typeof tool !== 'object') return '';
+  return tool.name || tool.tool || tool.type || tool.function?.name || '';
+}
+
+function hasCodexTool(body) {
+  return getResponseTools(body).some(tool => CODEX_TOOL_NAMES.has(getToolName(tool)));
+}
+
+function hasCodexInput(body) {
+  const input = getResponseConversationItems(body);
+  return input.some(item => {
+    if (!item || typeof item !== 'object') return false;
+    const type = item.type || '';
+    if (type === 'local_shell_call' || type === 'function_call' || type === 'custom_tool_call') return true;
+    const text = getInputItemText(item);
+    return /Codex|AGENTS\.md|sandbox|approval|workspace/i.test(text);
+  });
+}
+
+export function isCodexResponsesRequest(body) {
+  if (!body || typeof body !== 'object') return false;
+  if (!hasResponseInputArray(body)) return false;
+  if (!body.model || body.stream !== true) return false;
+  const instructionsText = getInstructionsText(body);
+  return /Codex/i.test(instructionsText) || hasCodexTool(body) || hasCodexInput(body);
+}
+
+export function isSubAgentRequest(body) {
+  if (!body || typeof body !== 'object') return false;
+  const instructionsText = getInstructionsText(body);
+  if (SUBAGENT_INSTRUCTIONS_RE.test(instructionsText)) return true;
+  const metadata = body.client_metadata || body.metadata || {};
+  const metadataText = Object.entries(metadata).map(([k, v]) => `${k}:${v}`).join('\n');
+  return /parent_thread_id|subagent|sub_agent|thread_spawn|guardian|compact|review/i.test(metadataText);
+}
 
+export function isMainAgentRequest(body) {
+  if (isCodexResponsesRequest(body)) {
+    return !isSubAgentRequest(body);
+  }
   return false;
 }
 
+export function isChatGptCodexResponsesUrl(urlStr) {
+  try {
+    const url = new URL(urlStr);
+    return url.hostname === 'chatgpt.com'
+      && /^\/backend-api\/codex\/responses(?:\/|$)/.test(url.pathname);
+  } catch {
+    return typeof urlStr === 'string'
+      && urlStr.includes('chatgpt.com/backend-api/codex/responses');
+  }
+}
+
+export function isResponsesEndpointUrl(urlStr) {
+  try {
+    const pathname = new URL(urlStr).pathname;
+    return /^\/backend-api\/codex\/responses(?:\/|$)/.test(pathname)
+      || /^\/v1\/responses(?:\/|$)/.test(pathname);
+  } catch {
+    return typeof urlStr === 'string' && /\/(?:backend-api\/codex\/responses|v1\/responses)(?:\/|$)/.test(urlStr);
+  }
+}
+
+function inferResponsesSubAgentName(urlStr, body = {}) {
+  const metadata = body?.client_metadata || body?.metadata || {};
+  const explicit = metadata.subAgentName || metadata.subagent_name || metadata.subagent
+    || metadata.sub_agent || metadata.thread_spawn || metadata.threadSpawn;
+  if (explicit) return String(explicit);
+
+  const instructionsText = getInstructionsText(body);
+  if (/Extract any file paths/i.test(instructionsText)) return 'Shell';
+  if (/process shell commands/i.test(instructionsText)) return 'Shell';
+  if (/command execution specialist/i.test(instructionsText)) return 'Shell';
+  if (/file search specialist/i.test(instructionsText)) return 'Search';
+  if (/planning specialist/i.test(instructionsText)) return 'Plan';
+  if (/general-purpose agent/i.test(instructionsText)) return 'General';
+  if (/security monitor/i.test(instructionsText)) return 'Advisor';
+  if (/performing a web search/i.test(instructionsText)) return 'web_search';
+
+  try {
+    const host = new URL(urlStr).hostname;
+    if (host === 'api.openai.com') return 'OpenAI Responses';
+    return host ? `Responses ${host}` : 'Responses';
+  } catch {
+    return 'Responses';
+  }
+}
+
+export function classifyAgentRequest(urlStr, body) {
+  if (isChatGptCodexResponsesUrl(urlStr)) {
+    const subAgent = isSubAgentRequest(body);
+    return {
+      mainAgent: !subAgent,
+      subAgent,
+      subAgentName: subAgent ? inferResponsesSubAgentName(urlStr, body) : null,
+    };
+  }
+
+  const codexLike = isCodexResponsesRequest(body) || isSubAgentRequest(body);
+  if (codexLike && isResponsesEndpointUrl(urlStr)) {
+    const subAgent = isSubAgentRequest(body);
+    return {
+      mainAgent: isMainAgentRequest(body),
+      subAgent,
+      subAgentName: subAgent ? inferResponsesSubAgentName(urlStr, body) : null,
+    };
+  }
+
+  const subAgent = isSubAgentRequest(body);
+  return {
+    mainAgent: isMainAgentRequest(body),
+    subAgent,
+    subAgentName: subAgent ? inferResponsesSubAgentName(urlStr, body) : null,
+  };
+}
+
 export function isPreflightEntry(entry) {
   if (entry.mainAgent || entry.isHeartbeat || entry.isCountTokens) return false;
   const body = entry.body || {};
-  if (Array.isArray(body.tools) && body.tools.length > 0) return false;
-  const msgs = body.messages || [];
-  if (msgs.length !== 1 || msgs[0].role !== 'user') return false;
-  const sysText = typeof body.system === 'string' ? body.system :
-    Array.isArray(body.system) ? body.system.map(s => s?.text || '').join('') : '';
-  return sysText.includes('Codex');
+  if (getResponseTools(body).length > 0) return false;
+  const input = getResponseConversationItems(body);
+  if (input.length !== 1 || input[0].role !== 'user') return false;
+  return getInstructionsText(body).includes('Codex');
 }
 
 export function isOpenAiApiPath(urlStr) {
   try {
     const pathname = new URL(urlStr).pathname;
-    return /^\/v1\/messages(\/count_tokens)?$/.test(pathname)
+    return /^\/v1\/responses(\/.*)?$/.test(pathname)
       || /^\/v1\/chat\/completions$/.test(pathname)
       || /^\/v1\/completions$/.test(pathname)
       || /^\/v1\/embeddings$/.test(pathname)
       || /^\/v1\/batches(\/.*)?$/.test(pathname);
   } catch {
-    return /\/v1\/messages/.test(urlStr) || /\/v1\/chat\/completions/.test(urlStr);
+    return /\/v1\/responses/.test(urlStr) || /\/v1\/chat\/completions/.test(urlStr);
+  }
+}
+
+function normalizeResponseItem(item, fallbackText = '') {
+  if (!item || typeof item !== 'object') return null;
+  const type = item.type;
+
+  if (type === 'message' || type === 'agent_message') {
+    const text = item.text || textFromContent(item.content) || fallbackText;
+    return text ? {
+      type: 'text',
+      text,
+      ...(item.phase ? { phase: item.phase } : {}),
+      ...(item.id ? { _codexItemId: item.id } : {}),
+    } : null;
+  }
+
+  if (type === 'reasoning') {
+    const summary = Array.isArray(item.summary) ? item.summary.map(s => typeof s === 'string' ? s : s?.text || '').join('\n\n') : '';
+    const content = Array.isArray(item.content) ? item.content.map(c => c?.text || '').join('\n\n') : '';
+    const thinking = summary || content || fallbackText;
+    return thinking ? { type: 'thinking', thinking, summary: item.summary } : null;
   }
+
+  if (type === 'function_call' || type === 'custom_tool_call' || type === 'local_shell_call' || type === 'tool_search_call' || type === 'web_search_call') {
+    const rawInput = item.arguments ?? item.input ?? item.action ?? {};
+    const name = item.name || item.tool || item.type || 'tool';
+    return {
+      type: 'tool_use',
+      id: item.call_id || item.id || name,
+      name,
+      input: safeJsonParse(rawInput),
+    };
+  }
+
+  return null;
+}
+
+function responseItemKey(item, fallback) {
+  return item?.id || item?.call_id || item?.callId || fallback;
+}
+
+function dedupeResponseItems(items) {
+  const ordered = [];
+  const indexByKey = new Map();
+  for (let i = 0; i < (items || []).length; i++) {
+    const item = items[i];
+    if (!item || typeof item !== 'object') continue;
+    const key = responseItemKey(item, null);
+    if (!key) {
+      ordered.push(item);
+      continue;
+    }
+    const existingIndex = indexByKey.get(key);
+    if (existingIndex === undefined) {
+      indexByKey.set(key, ordered.length);
+      ordered.push(item);
+    } else {
+      // The terminal copy is authoritative. Responses streams commonly emit the
+      // same item first in output_item.added and later in output_item.done.
+      ordered[existingIndex] = item;
+    }
+  }
+  return ordered;
+}
+
+function normalizeOpenAiUsage(usage) {
+  if (!usage || typeof usage !== 'object') return usage || null;
+  const rawInput = usage.input_tokens ?? usage.inputTokens ?? 0;
+  const output = usage.output_tokens ?? usage.outputTokens ?? 0;
+  const rawInputDetails = usage.input_tokens_details ?? usage.inputTokensDetails;
+  const inputDetails = rawInputDetails && typeof rawInputDetails === 'object'
+    ? {
+        ...rawInputDetails,
+        cached_tokens: rawInputDetails.cached_tokens ?? rawInputDetails.cachedTokens ?? 0,
+        cache_write_tokens: rawInputDetails.cache_write_tokens ?? rawInputDetails.cacheWriteTokens ?? 0,
+      }
+    : null;
+  const reasoning = usage.reasoning_output_tokens
+    ?? usage.reasoningOutputTokens
+    ?? usage.output_tokens_details?.reasoning_tokens
+    ?? 0;
+  const total = usage.total_tokens ?? usage.totalTokens ?? (rawInput + output);
+  return {
+    input_tokens: rawInput,
+    output_tokens: output,
+    reasoning_output_tokens: reasoning,
+    total_tokens: total,
+    ...(inputDetails ? { input_tokens_details: inputDetails } : {}),
+  };
+}
+
+function mergeContentBlock(content, block) {
+  if (!block) return;
+  const prev = content[content.length - 1];
+  if (prev && prev.type === block.type && block.type === 'text') {
+    prev.text += block.text || '';
+    return;
+  }
+  if (prev && prev.type === block.type && block.type === 'thinking') {
+    prev.thinking += block.thinking || '';
+    return;
+  }
+  content.push(block);
+}
+
+export function assembleOpenAiResponseMessage(events) {
+  const items = new Map();
+  const itemOrder = [];
+  let response = null;
+  let anonymousIndex = 0;
+
+  const ensureItem = (key, seed, outputIndex) => {
+    const stableKey = key || `anonymous:${anonymousIndex++}`;
+    let record = items.get(stableKey);
+    if (!record) {
+      record = {
+        key: stableKey,
+        item: seed ? { ...seed } : {},
+        outputIndex: Number.isInteger(outputIndex) ? outputIndex : null,
+        insertionIndex: itemOrder.length,
+        messageText: '',
+        reasoningText: '',
+      };
+      items.set(stableKey, record);
+      itemOrder.push(stableKey);
+    } else if (seed) {
+      record.item = { ...record.item, ...seed };
+    }
+    if (record.outputIndex == null && Number.isInteger(outputIndex)) record.outputIndex = outputIndex;
+    return record;
+  };
+
+  const eventRecord = (event, kind) => {
+    const key = event.item_id || event.itemId || event.call_id || event.callId || null;
+    const synthetic = key || `${kind}:${event.output_index ?? event.outputIndex ?? anonymousIndex}`;
+    return ensureItem(synthetic, {
+      id: event.item_id || event.itemId || undefined,
+      call_id: event.call_id || event.callId || undefined,
+      type: kind,
+    }, event.output_index ?? event.outputIndex);
+  };
+
+  for (const event of events) {
+    if (!event || typeof event !== 'object') continue;
+    const type = event.type || event.event;
+
+    if (type === 'response.created' && event.response) {
+      response = { ...response, ...event.response };
+      continue;
+    }
+
+    if ((type === 'response.output_item.added' || type === 'response.output_item.done') && event.item) {
+      const key = event.item.id || event.item.call_id || `${event.item.type}:${items.size}`;
+      ensureItem(key, event.item, event.output_index ?? event.outputIndex);
+      continue;
+    }
+
+    if (type === 'response.content_part.added' && event.part) {
+      if (event.part.type === 'output_text' || event.part.type === 'text') {
+        const record = eventRecord(event, 'message');
+        record.messageText += event.part.text || '';
+      }
+      continue;
+    }
+
+    if (type === 'response.output_text.delta') {
+      const record = eventRecord(event, 'message');
+      record.messageText += event.delta || '';
+      continue;
+    }
+
+    if (type === 'response.output_text.done' || type === 'response.content_part.done') {
+      const partType = event.part?.type;
+      if (!partType || partType === 'output_text' || partType === 'text') {
+        const record = eventRecord(event, 'message');
+        record.messageText = event.text || event.part?.text || record.messageText;
+      }
+      continue;
+    }
+
+    if (type === 'response.reasoning_summary_text.delta' || type === 'response.reasoning_text.delta') {
+      const record = eventRecord(event, 'reasoning');
+      record.reasoningText += event.delta || '';
+      continue;
+    }
+
+    if (type === 'response.reasoning_summary_text.done' || type === 'response.reasoning_text.done') {
+      const record = eventRecord(event, 'reasoning');
+      record.reasoningText = event.text || record.reasoningText;
+      continue;
+    }
+
+    if (type === 'response.function_call_arguments.delta' || type === 'response.custom_tool_call_input.delta') {
+      const key = event.item_id || event.call_id || `tool:${items.size}`;
+      const record = ensureItem(key, {
+        type: type.includes('custom_tool_call') ? 'custom_tool_call' : 'function_call',
+        id: event.item_id || key,
+        call_id: event.call_id || key,
+        ...(event.name ? { name: event.name } : {}),
+      }, event.output_index ?? event.outputIndex);
+      const existing = record.item;
+      const inputKey = existing.type === 'custom_tool_call' ? 'input' : 'arguments';
+      existing[inputKey] = (existing[inputKey] || existing.arguments || existing.input || '') + (event.delta || '');
+      continue;
+    }
+
+    if (type === 'response.function_call_arguments.done' || type === 'response.custom_tool_call_input.done') {
+      const key = event.item_id || event.call_id || `tool:${items.size}`;
+      const custom = type.includes('custom_tool_call');
+      const record = ensureItem(key, {
+        type: custom ? 'custom_tool_call' : 'function_call',
+        id: event.item_id || key,
+        call_id: event.call_id || key,
+        ...(event.name ? { name: event.name } : {}),
+      }, event.output_index ?? event.outputIndex);
+      const existing = record.item;
+      const inputKey = custom ? 'input' : 'arguments';
+      existing[inputKey] = event.arguments || event.input || existing[inputKey] || '';
+      continue;
+    }
+
+    if (type === 'response.completed' && event.response) {
+      response = { ...response, ...event.response };
+    }
+  }
+
+  const content = [];
+  const finalOutput = Array.isArray(response?.output) && response.output.length > 0
+    ? dedupeResponseItems(response.output)
+    : null;
+
+  if (finalOutput) {
+    for (const item of finalOutput) mergeContentBlock(content, normalizeResponseItem(item));
+  } else {
+    const orderedRecords = itemOrder
+      .map(key => items.get(key))
+      .filter(Boolean)
+      .sort((a, b) => {
+        if (a.outputIndex == null || b.outputIndex == null || a.outputIndex === b.outputIndex) {
+          return a.insertionIndex - b.insertionIndex;
+        }
+        return a.outputIndex - b.outputIndex;
+      });
+    for (const record of orderedRecords) {
+      const fallback = record.item.type === 'reasoning' ? record.reasoningText : record.messageText;
+      mergeContentBlock(content, normalizeResponseItem(record.item, fallback));
+    }
+  }
+
+  if (content.length === 0 && !response) return null;
+
+  return {
+    id: response?.id,
+    type: 'message',
+    role: 'assistant',
+    model: response?.model,
+    content,
+    stop_reason: response?.status || response?.incomplete_details?.reason || null,
+    usage: normalizeOpenAiUsage(response?.usage),
+    raw_response: response || undefined,
+  };
 }
 
 
@@ -206,9 +649,9 @@ export function migrateConversationContext(oldFile, newFile) {
       try {
         const entry = JSON.parse(parts[i]);
         if (entry.mainAgent) {
-          const msgs = entry.body?.messages;
-          // Delta storage: 使用 _totalMessageCount（delta 条目）或 msgs.length（旧格式）
-          const msgCount = entry._totalMessageCount || (Array.isArray(msgs) ? msgs.length : 0);
+          const input = entry.body?.input;
+          // Delta storage: 使用 _totalMessageCount（delta 条目）或 input.length（全量条目）
+          const msgCount = entry._totalMessageCount || (Array.isArray(input) ? input.length : 0);
           if (msgCount === 1) {
             originIndex = i;
             break;
@@ -255,11 +698,15 @@ export function migrateConversationContext(oldFile, newFile) {
  * @param {number} maxSize - max file size in bytes
  * @returns {{ rotated: boolean, oldFile?: string, newFile?: string }}
  */
-export function rotateLogFile(currentFile, newFile, maxSize) {
+export function rotateLogFile(currentFile, newFile, maxSize, nextWriteBytes = 0) {
   try {
     if (!existsSync(currentFile)) return { rotated: false };
     const size = statSync(currentFile).size;
-    if (size < maxSize) return { rotated: false };
+    // Rotate before the next record is appended. Keep an empty file writable
+    // even when a single oversized record exceeds maxSize; it cannot be split
+    // without corrupting the JSONL record boundary.
+    if (size === 0 || size + Math.max(0, nextWriteBytes) < maxSize) return { rotated: false };
+    if (!newFile || newFile === currentFile) return { rotated: false };
     // 不迁移旧内容，创建空新文件（立即创建，避免 watcher 时序窗口）
     try { writeFileSync(newFile, ''); } catch { }
     // 触发旧文件 watcher 回调，使其检测到文件变更并切换到新文件

package/lib/log-watcher.js

@@ -1,6 +1,6 @@
 import { readFileSync, existsSync, watchFile, unwatchFile, openSync, readSync, closeSync, statSync } from 'node:fs';
-import { isMainAgentEntry, extractCachedContent } from './kv-cache-analyzer.js';
-import { buildContextWindowEvent, getContextSizeForModel } from './context-watcher.js';
+import { isMainAgentEntry } from './main-agent-entry.js';
+import { buildContextWindowEvent } from './context-watcher.js';
 import { reconstructEntries, createIncrementalReconstructor } from './delta-reconstructor.js';
 import { countLogEntries, streamReconstructedEntries } from './log-stream.js';
 
@@ -175,14 +175,9 @@ export function watchLogFile(opts) {
             sendToClients(clients, parsed);
             runParallelHook('onNewEntry', parsed).catch(() => {});
             if (isMainAgentEntry(parsed) && !parsed.inProgress) {
-              const cached = extractCachedContent(parsed);
-              if (cached) {
-                sendEventToClients(clients, 'kv_cache_content', cached);
-              }
               const usage = parsed.response?.body?.usage;
               if (usage) {
-                const contextSize = getContextSizeForModel(parsed.body?.model);
-                const cwData = buildContextWindowEvent(usage, contextSize);
+                const cwData = buildContextWindowEvent(usage);
                 if (cwData) {
                   sendEventToClients(clients, 'context_window', cwData);
                 }

package/lib/main-agent-entry.js

@@ -0,0 +1,68 @@
+import { getInputItemText, getInstructionsText, getResponseConversationItems, getResponseInstructions, getResponseTools } from './openai-body.js';
+
+const SUBAGENT_INSTRUCTIONS_RE = /command execution specialist|file search specialist|planning specialist|general-purpose agent|security monitor|performing a web search/i;
+const TEAMMATE_INSTRUCTIONS_RE = /running as an agent in a team|Agent Teammate Communication/i;
+const CURRENT_CODEX_TOOL_NAMES = new Set([
+  'shell_command',
+  'apply_patch',
+  'view_image',
+  'update_plan',
+  'request_user_input',
+  'get_goal',
+  'create_goal',
+  'update_goal',
+  'tool_search',
+  'list_mcp_resources',
+  'list_mcp_resource_templates',
+  'read_mcp_resource',
+  'web_search',
+  'image_generation',
+]);
+
+function getToolName(tool) {
+  if (!tool || typeof tool !== 'object') return null;
+  return tool.name || tool.type || tool.function?.name || null;
+}
+
+export function isMainAgentEntry(entry) {
+  if (!entry) return false;
+
+  if (entry.teammate) return false;
+  const instructionsText = getInstructionsText(entry.body || {});
+  if (TEAMMATE_INSTRUCTIONS_RE.test(instructionsText)) return false;
+
+  if (entry.mainAgent === true) {
+    if (SUBAGENT_INSTRUCTIONS_RE.test(instructionsText)) return false;
+    return true;
+  }
+
+  const body = entry.body || {};
+  const instructions = getResponseInstructions(body);
+  const tools = getResponseTools(body);
+  if (!instructions || tools.length === 0) return false;
+
+  if (!instructionsText.includes('You are Codex')) return false;
+  if (SUBAGENT_INSTRUCTIONS_RE.test(instructionsText)) return false;
+
+  const isInstructionsArray = Array.isArray(instructions);
+  const toolNames = new Set(tools.map(getToolName).filter(Boolean));
+  const hasToolSearch = toolNames.has('ToolSearch') || toolNames.has('tool_search');
+  if (isInstructionsArray && hasToolSearch) {
+    const input = getResponseConversationItems(body);
+    const firstInputContent = input.length > 0 ? getInputItemText(input[0]) : '';
+    if (firstInputContent.includes('<available-deferred-tools>')) return true;
+  }
+
+  for (const name of CURRENT_CODEX_TOOL_NAMES) {
+    if (toolNames.has(name)) return true;
+  }
+
+  if (tools.length > 5) {
+    const hasPatch = toolNames.has('apply_patch');
+    const hasShell = toolNames.has('shell_command');
+    const hasDiscovery = toolNames.has('tool_search');
+    if (hasPatch && hasShell && hasDiscovery) return true;
+  }
+
+  return false;
+}