ai-cli-mcp 2.14.1 → 2.16.0

package/src/model-catalog.ts

@@ -20,6 +20,7 @@ export const GEMINI_MODELS = [
   'gemini-3-flash-preview',
 ] as const;
 export const FORGE_MODELS = ['forge'] as const;
+export const OPENCODE_MODELS = ['opencode'] as const;
 
 export const MODEL_ALIASES: Record<string, string> = {
   'claude-ultra': 'opus',
@@ -33,6 +34,13 @@ export const MODEL_ALIAS_DETAILS = [
   { name: 'gemini-ultra', resolvesTo: 'gemini-3.1-pro-preview', agent: 'gemini' },
 ] as const;
 
+export interface DynamicModelBackendDescription {
+  explicitPrefix: string;
+  explicitPattern: string;
+  discoveryCommand: string;
+  modelsAreDynamic: boolean;
+}
+
 export function getSupportedModelsDescription(): string {
   return [
     '"claude-ultra", "codex-ultra", "gemini-ultra"',
@@ -40,11 +48,13 @@ export function getSupportedModelsDescription(): string {
     ...CODEX_MODELS.map((model) => `"${model}"`),
     ...GEMINI_MODELS.map((model) => `"${model}"`),
     ...FORGE_MODELS.map((model) => `"${model}"`),
+    ...OPENCODE_MODELS.map((model) => `"${model}"`),
+    '"oc-<provider/model>"',
   ].join(', ');
 }
 
 export function getModelParameterDescription(): string {
-  return `The model to use. Aliases: "claude-ultra" (auto high effort), "codex-ultra" (auto xhigh reasoning), "gemini-ultra". Standard: ${[...CLAUDE_MODELS, ...CODEX_MODELS, ...GEMINI_MODELS, ...FORGE_MODELS].map((model) => `"${model}"`).join(', ')}. "forge" is a provider key, not a Forge model family selector.`;
+  return `The model to use. Aliases: "claude-ultra" (auto high effort), "codex-ultra" (auto xhigh reasoning), "gemini-ultra". Standard: ${[...CLAUDE_MODELS, ...CODEX_MODELS, ...GEMINI_MODELS, ...FORGE_MODELS, ...OPENCODE_MODELS].map((model) => `"${model}"`).join(', ')}. OpenCode also accepts explicit dynamic models using "oc-<provider/model>". "forge" is a provider key, not a Forge model family selector.`;
 }
 
 export function getModelsPayload(): {
@@ -53,6 +63,10 @@ export function getModelsPayload(): {
   codex: ReadonlyArray<string>;
   gemini: ReadonlyArray<string>;
   forge: ReadonlyArray<string>;
+  opencode: ReadonlyArray<string>;
+  dynamicModelBackends: {
+    opencode: DynamicModelBackendDescription;
+  };
 } {
   return {
     aliases: MODEL_ALIAS_DETAILS,
@@ -60,5 +74,14 @@ export function getModelsPayload(): {
     codex: CODEX_MODELS,
     gemini: GEMINI_MODELS,
     forge: FORGE_MODELS,
+    opencode: OPENCODE_MODELS,
+    dynamicModelBackends: {
+      opencode: {
+        explicitPrefix: 'oc-',
+        explicitPattern: 'oc-<provider/model>',
+        discoveryCommand: 'opencode models',
+        modelsAreDynamic: true,
+      },
+    },
   };
 }

package/src/parsers.ts

@@ -1,18 +1,141 @@
 import { debugLog } from './cli-utils.js';
 
-/**
- * Parse Codex NDJSON output to extract the last agent message and token count
- */
+export interface PeekMessage {
+  ts: string;
+  text: string;
+}
+
+type PeekAgent = 'claude' | 'codex' | string | null;
+
+function isGeminiAssistantMessageEvent(parsed: any): boolean {
+  return parsed.type === 'message' && parsed.role === 'assistant' && typeof parsed.content === 'string';
+}
+
+const GEMINI_STREAM_EVENT_TYPES = new Set([
+  'init',
+  'message',
+  'tool_use',
+  'tool_result',
+  'result',
+  'error',
+  'stats',
+]);
+
+function isGeminiStreamJsonEvent(parsed: any): boolean {
+  return parsed && typeof parsed === 'object' && !Array.isArray(parsed) && GEMINI_STREAM_EVENT_TYPES.has(parsed.type);
+}
+
+function extractPeekMessagesFromParsedEvent(agent: PeekAgent, parsed: any, observedAt: string): PeekMessage[] {
+  if (agent === 'codex') {
+    if (parsed.item?.type === 'agent_message' && typeof parsed.item.text === 'string' && parsed.item.text.trim()) {
+      return [{ ts: observedAt, text: parsed.item.text }];
+    }
+    if (parsed.msg?.type === 'agent_message' && typeof parsed.msg.message === 'string' && parsed.msg.message.trim()) {
+      return [{ ts: observedAt, text: parsed.msg.message }];
+    }
+    return [];
+  }
+
+  if (agent === 'claude' && parsed.type === 'assistant' && Array.isArray(parsed.message?.content)) {
+    return parsed.message.content
+      .filter((content: any) => content?.type === 'text' && typeof content.text === 'string' && content.text.trim())
+      .map((content: any) => ({ ts: observedAt, text: content.text }));
+  }
+
+  if (agent === 'opencode' && parsed.type === 'text' && parsed.part?.type === 'text' && typeof parsed.part.text === 'string' && parsed.part.text.trim()) {
+    return [{ ts: observedAt, text: parsed.part.text }];
+  }
+
+  return [];
+}
+
+export class PeekMessageExtractor {
+  private pending = '';
+  private geminiAssistantBuffer = '';
+
+  constructor(private readonly agent: PeekAgent) {}
+
+  push(chunk: string, observedAt = new Date().toISOString()): PeekMessage[] {
+    if (!chunk) {
+      return [];
+    }
+
+    const lines = `${this.pending}${chunk}`.split(/\r?\n/);
+    this.pending = lines.pop() || '';
+    return this.extractLines(lines, observedAt);
+  }
+
+  flush(observedAt = new Date().toISOString()): PeekMessage[] {
+    const messages: PeekMessage[] = [];
+
+    if (this.pending) {
+      const line = this.pending;
+      this.pending = '';
+      messages.push(...this.extractLines([line], observedAt));
+    }
+
+    messages.push(...this.flushGeminiAssistantBuffer(observedAt));
+    return messages;
+  }
+
+  private extractLines(lines: string[], observedAt: string): PeekMessage[] {
+    const messages: PeekMessage[] = [];
+
+    for (const line of lines) {
+      if (!line.trim()) {
+        continue;
+      }
+
+      try {
+        messages.push(...this.extractParsedEvent(JSON.parse(line), observedAt));
+      } catch {
+        debugLog(`[Debug] Skipping invalid peek JSON line: ${line}`);
+        messages.push(...this.flushGeminiAssistantBuffer(observedAt));
+      }
+    }
+
+    return messages;
+  }
+
+  private extractParsedEvent(parsed: any, observedAt: string): PeekMessage[] {
+    if (this.agent !== 'gemini') {
+      return extractPeekMessagesFromParsedEvent(this.agent, parsed, observedAt);
+    }
+
+    if (isGeminiAssistantMessageEvent(parsed)) {
+      this.geminiAssistantBuffer += parsed.content;
+      return [];
+    }
+
+    return this.flushGeminiAssistantBuffer(observedAt);
+  }
+
+  private flushGeminiAssistantBuffer(observedAt: string): PeekMessage[] {
+    if (this.agent !== 'gemini' || !this.geminiAssistantBuffer) {
+      return [];
+    }
+
+    const text = this.geminiAssistantBuffer;
+    this.geminiAssistantBuffer = '';
+
+    if (!text.trim()) {
+      return [];
+    }
+
+    return [{ ts: observedAt, text }];
+  }
+}
+
 export function parseCodexOutput(stdout: string): any {
   if (!stdout) return null;
-  
+
   try {
     const lines = stdout.trim().split('\n');
     let lastMessage = null;
     let tokenCount = null;
     let threadId = null;
     const tools: any[] = [];
-    
+
     for (const line of lines) {
       if (line.trim()) {
         try {
@@ -24,14 +147,13 @@ export function parseCodexOutput(stdout: string): any {
           } else if (parsed.msg?.type === 'agent_message') {
             lastMessage = parsed.msg.message;
           } else if (parsed.item?.type === 'reasoning') {
-            // Ignore reasoning-only items for message selection.
           } else if (parsed.msg?.type === 'token_count') {
             tokenCount = parsed.msg;
           } else if (parsed.type === 'item.completed' && parsed.item?.type === 'mcp_tool_call') {
             tools.push({
               server: parsed.item.server,
               tool: parsed.item.tool,
-              input: parsed.item.arguments, // Map arguments to input to match common patterns
+              input: parsed.item.arguments,
               output: parsed.item.result
             });
           } else if (parsed.type === 'item.completed' && parsed.item?.type === 'command_execution') {
@@ -43,12 +165,11 @@ export function parseCodexOutput(stdout: string): any {
             });
           }
         } catch (e) {
-          // Skip invalid JSON lines
           debugLog(`[Debug] Skipping invalid JSON line: ${line}`);
         }
       }
     }
-    
+
     if (lastMessage || tokenCount || threadId || tools.length > 0) {
       return {
         message: lastMessage,
@@ -60,28 +181,23 @@ export function parseCodexOutput(stdout: string): any {
   } catch (e) {
     debugLog(`[Debug] Failed to parse Codex NDJSON output: ${e}`);
   }
-  
+
   return null;
 }
 
-/**
- * Parse Claude Output (supports both JSON and stream-json/NDJSON)
- */
 export function parseClaudeOutput(stdout: string): any {
   if (!stdout) return null;
 
-  // First try parsing as a single JSON object (backward compatibility)
   try {
     return JSON.parse(stdout);
   } catch (e) {
-    // If not valid single JSON, proceed to parse as NDJSON
   }
 
   try {
     const lines = stdout.trim().split('\n');
     let lastMessage = null;
     let sessionId = null;
-    const toolsMap = new Map<string, any>(); // Map by tool_use id for matching results
+    const toolsMap = new Map<string, any>();
 
     for (const line of lines) {
       if (!line.trim()) continue;
@@ -89,36 +205,31 @@ export function parseClaudeOutput(stdout: string): any {
       try {
         const parsed = JSON.parse(line);
 
-        // Extract session ID from any message that has it
         if (parsed.session_id) {
           sessionId = parsed.session_id;
         }
 
-        // Extract final result message
         if (parsed.type === 'result' && parsed.result) {
           lastMessage = parsed.result;
         }
 
-        // Extract tool usage from assistant messages
         if (parsed.type === 'assistant' && parsed.message?.content) {
           for (const content of parsed.message.content) {
             if (content.type === 'tool_use') {
               toolsMap.set(content.id, {
                 tool: content.name,
                 input: content.input,
-                output: null // Will be filled when tool_result is found
+                output: null
               });
             }
           }
         }
 
-        // Match tool results from user messages
         if (parsed.type === 'user' && parsed.message?.content) {
           for (const content of parsed.message.content) {
             if (content.type === 'tool_result' && content.tool_use_id) {
               const tool = toolsMap.get(content.tool_use_id);
               if (tool) {
-                // Extract text from content array
                 if (Array.isArray(content.content)) {
                   const textContent = content.content.find((c: any) => c.type === 'text');
                   tool.output = textContent?.text || null;
@@ -135,12 +246,11 @@ export function parseClaudeOutput(stdout: string): any {
       }
     }
 
-    // Convert Map to array
     const tools = Array.from(toolsMap.values());
 
     if (lastMessage || sessionId || tools.length > 0) {
       return {
-        message: lastMessage, // This is the final result text
+        message: lastMessage,
         session_id: sessionId,
         tools: tools.length > 0 ? tools : undefined
       };
@@ -150,27 +260,115 @@ export function parseClaudeOutput(stdout: string): any {
     debugLog(`[Debug] Failed to parse Claude NDJSON output: ${e}`);
     return null;
   }
-  
+
   return null;
 }
 
-/**
- * Parse Gemini JSON output
- */
 export function parseGeminiOutput(stdout: string): any {
   if (!stdout) return null;
 
   try {
-    return JSON.parse(stdout);
+    const parsed = JSON.parse(stdout.trim());
+    if (!isGeminiStreamJsonEvent(parsed)) {
+      return parsed;
+    }
   } catch (e) {
     debugLog(`[Debug] Failed to parse Gemini JSON output: ${e}`);
-    return null;
   }
+
+  let sessionId: string | null = null;
+  let assistantBuffer = '';
+  let lastMessage: string | null = null;
+  let stats: any = null;
+  const toolsById = new Map<string, any>();
+  const toolsWithoutId: any[] = [];
+  const flushAssistantMessage = () => {
+    if (assistantBuffer.trim()) {
+      lastMessage = assistantBuffer;
+    }
+    assistantBuffer = '';
+  };
+
+  for (const line of stdout.split('\n')) {
+    if (!line.trim()) {
+      continue;
+    }
+
+    let parsed: any;
+    try {
+      parsed = JSON.parse(line);
+    } catch (e) {
+      debugLog(`[Debug] Skipping invalid Gemini stream-json line: ${line}`);
+      flushAssistantMessage();
+      continue;
+    }
+
+    if (parsed.type === 'init' && typeof parsed.session_id === 'string' && parsed.session_id) {
+      sessionId = parsed.session_id;
+      continue;
+    }
+
+    if (isGeminiAssistantMessageEvent(parsed)) {
+      assistantBuffer += parsed.content;
+      continue;
+    }
+
+    flushAssistantMessage();
+
+    if (parsed.type === 'result') {
+      if (parsed.stats) {
+        stats = parsed.stats;
+      }
+      continue;
+    }
+
+    if (parsed.type === 'tool_use') {
+      const tool = {
+        tool: parsed.tool_name || parsed.name || 'tool_use',
+        input: parsed.parameters ?? parsed.input ?? null,
+        output: null,
+        status: null,
+      };
+      if (typeof parsed.tool_id === 'string' && parsed.tool_id) {
+        toolsById.set(parsed.tool_id, tool);
+      } else {
+        toolsWithoutId.push(tool);
+      }
+      continue;
+    }
+
+    if (parsed.type === 'tool_result') {
+      const toolId = typeof parsed.tool_id === 'string' ? parsed.tool_id : '';
+      const tool = toolId ? toolsById.get(toolId) : null;
+      if (tool) {
+        tool.output = parsed.output ?? parsed.result ?? null;
+        tool.status = parsed.status ?? null;
+      } else {
+        toolsWithoutId.push({
+          tool: 'tool_result',
+          input: null,
+          output: parsed.output ?? parsed.result ?? null,
+          status: parsed.status ?? null,
+        });
+      }
+    }
+  }
+
+  flushAssistantMessage();
+  const tools = [...toolsById.values(), ...toolsWithoutId];
+
+  if (lastMessage || sessionId || stats || tools.length > 0) {
+    return {
+      message: lastMessage,
+      session_id: sessionId,
+      stats: stats || undefined,
+      tools: tools.length > 0 ? tools : undefined,
+    };
+  }
+
+  return null;
 }
 
-/**
- * Parse Forge output framed by Initialize/Continue/Finished markers.
- */
 export function parseForgeOutput(stdout: string): any {
   if (!stdout) return null;
 
@@ -228,3 +426,71 @@ export function parseForgeOutput(stdout: string): any {
     session_id: lastConversationId,
   };
 }
+
+export function parseOpenCodeOutput(stdout: string): any {
+  if (!stdout) {
+    return null;
+  }
+
+  let sessionId: string | null = null;
+  let currentStepBuffer = '';
+  let latestCompletedStep: {
+    message: string;
+    session_id?: string;
+    tokens?: any;
+    cost?: number;
+  } | null = null;
+  let hasStepFinish = false;
+  let hasParseableAssistantText = false;
+
+  for (const line of stdout.split('\n')) {
+    if (!line.trim()) {
+      continue;
+    }
+
+    let parsed: any;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+
+    if (typeof parsed.sessionID === 'string' && parsed.sessionID) {
+      sessionId = parsed.sessionID;
+    }
+
+    if (parsed.type === 'step_start') {
+      currentStepBuffer = '';
+      continue;
+    }
+
+    if (parsed.type === 'text' && parsed.part?.type === 'text' && typeof parsed.part.text === 'string') {
+      currentStepBuffer += parsed.part.text;
+      hasParseableAssistantText = true;
+      continue;
+    }
+
+    if (parsed.type === 'step_finish') {
+      hasStepFinish = true;
+      latestCompletedStep = {
+        message: currentStepBuffer,
+        session_id: sessionId || undefined,
+        tokens: parsed.part?.tokens,
+        cost: parsed.part?.cost,
+      };
+    }
+  }
+
+  if (hasStepFinish && latestCompletedStep) {
+    return latestCompletedStep;
+  }
+
+  if (hasParseableAssistantText) {
+    return {
+      message: currentStepBuffer,
+      session_id: sessionId || undefined,
+    };
+  }
+
+  return null;
+}

package/src/peek.ts

@@ -0,0 +1,88 @@
+import type { PeekMessage } from './parsers.js';
+import type { AgentType, ProcessStatus } from './process-service.js';
+
+export const DEFAULT_PEEK_TIME_SEC = 10;
+export const MAX_PEEK_TIME_SEC = 60;
+export const MAX_PEEK_PIDS = 32;
+export const PEEK_MESSAGE_CAP = 50;
+
+export type PeekStatus = ProcessStatus | 'not_found';
+export type PeekAgent = AgentType | string | null;
+
+export interface PeekProcessResult {
+  pid: number;
+  agent: PeekAgent;
+  status: PeekStatus;
+  messages: PeekMessage[];
+  truncated: boolean;
+  error: string | null;
+}
+
+export interface PeekResponse {
+  peek_started_at: string;
+  observed_duration_sec: number;
+  processes: PeekProcessResult[];
+}
+
+export function validatePeekPids(value: unknown): number[] {
+  if (!Array.isArray(value)) {
+    throw new Error('Missing or invalid required parameter: pids (must be an array of positive safe integers)');
+  }
+
+  const deduped: number[] = [];
+  const seen = new Set<number>();
+
+  for (const pid of value) {
+    if (typeof pid !== 'number' || !Number.isSafeInteger(pid) || pid <= 0) {
+      throw new Error('All pids must be positive safe integers');
+    }
+
+    if (!seen.has(pid)) {
+      seen.add(pid);
+      deduped.push(pid);
+    }
+  }
+
+  if (deduped.length === 0 || deduped.length > MAX_PEEK_PIDS) {
+    throw new Error(`pids must contain 1..${MAX_PEEK_PIDS} entries after dedupe`);
+  }
+
+  return deduped;
+}
+
+export function validatePeekTimeSec(value: unknown): number {
+  if (value === undefined || value === null) {
+    return DEFAULT_PEEK_TIME_SEC;
+  }
+
+  if (typeof value !== 'number' || !Number.isSafeInteger(value) || value <= 0 || value > MAX_PEEK_TIME_SEC) {
+    throw new Error(`peek_time_sec must be a positive integer no greater than ${MAX_PEEK_TIME_SEC}`);
+  }
+
+  return value;
+}
+
+export function buildNotFoundPeekProcess(pid: number): PeekProcessResult {
+  return {
+    pid,
+    agent: null,
+    status: 'not_found',
+    messages: [],
+    truncated: false,
+    error: 'process not found',
+  };
+}
+
+export function appendPeekMessages(target: PeekProcessResult, messages: PeekMessage[]): void {
+  for (const message of messages) {
+    if (target.messages.length < PEEK_MESSAGE_CAP) {
+      target.messages.push(message);
+    } else {
+      target.truncated = true;
+    }
+  }
+}
+
+export function observedDurationSec(startedAtMs: number, endedAtMs = Date.now()): number {
+  return Number(((endedAtMs - startedAtMs) / 1000).toFixed(2));
+}

package/src/process-result.ts

@@ -45,6 +45,10 @@ function hasMeaningfulParsedOutput(agentOutput: any): boolean {
   });
 }
 
+function shouldPreserveRawFailureOutput(context: ProcessResultContext): boolean {
+  return context.agent === 'opencode' && context.status === 'failed';
+}
+
 export function buildProcessResult(context: ProcessResultContext, agentOutput: any, verbose = false): any {
   const response: any = {
     pid: context.pid,
@@ -65,15 +69,20 @@ export function buildProcessResult(context: ProcessResultContext, agentOutput: a
   }
 
   const shapedAgentOutput = verbose ? agentOutput : compactAgentOutput(agentOutput);
+  const preserveRawFailureOutput = shouldPreserveRawFailureOutput(context);
 
-  if (hasMeaningfulParsedOutput(shapedAgentOutput)) {
+  if (hasMeaningfulParsedOutput(shapedAgentOutput) && (verbose || !preserveRawFailureOutput)) {
     response.agentOutput = shapedAgentOutput;
   }
 
-  if (!response.agentOutput) {
+  if (!response.agentOutput || preserveRawFailureOutput) {
     response.stdout = context.stdout;
     response.stderr = context.stderr;
   }
 
+  if (verbose && preserveRawFailureOutput && hasMeaningfulParsedOutput(shapedAgentOutput)) {
+    response.agentOutput = shapedAgentOutput;
+  }
+
   return response;
 }