@the-open-engine/zeroshot 5.4.0

package/src/agent-cli-provider/adapters/claude.ts

@@ -0,0 +1,247 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { getString, isRecord, stringifyJson } from '../json';
+import {
+  type BuildProviderCommandOptions,
+  type ClaudeCliFeatures,
+  type CommandSpec,
+  type ErrorClassification,
+  InvalidProviderModelError,
+  type LevelModelSpec,
+  type LevelOverrides,
+  type ModelCatalogEntry,
+  type ModelLevel,
+  type ProviderAdapter,
+  type ResolvedModelSpec,
+  type WarningMetadata,
+} from '../types';
+import {
+  classifyBaseProviderError,
+  commandSpec,
+  createParserState,
+  envRedactions,
+  optionFeatures,
+  resolveModelSpecWithConfig,
+  validateModelIdFromCatalog,
+  warning,
+} from './common';
+import { parseClaudeEvent } from './claude-parser';
+
+const MODEL_CATALOG: Readonly<Record<string, ModelCatalogEntry>> = {
+  haiku: { rank: 1 },
+  sonnet: { rank: 2 },
+  opus: { rank: 3 },
+};
+
+const LEVEL_MAPPING: Readonly<Record<ModelLevel, LevelModelSpec>> = {
+  level1: { rank: 1, model: 'haiku' },
+  level2: { rank: 2, model: 'sonnet' },
+  level3: { rank: 3, model: 'opus' },
+};
+
+function detectCliFeatures(helpText?: string | null): ClaudeCliFeatures {
+  const help = helpText ?? '';
+  const unknown = !help;
+  return {
+    provider: 'claude',
+    supportsOutputFormat: unknown ? true : /--output-format/.test(help),
+    supportsStreamJson: unknown ? true : /stream-json/.test(help),
+    supportsJsonSchema: unknown ? true : /--json-schema/.test(help),
+    supportsAutoApprove: unknown ? true : /--dangerously-skip-permissions/.test(help),
+    supportsIncludePartials: unknown ? true : /--include-partial-messages/.test(help),
+    supportsVerbose: unknown ? true : /--verbose/.test(help),
+    supportsModel: unknown ? true : /--model/.test(help),
+    unknown,
+  };
+}
+
+function addOutputArgs(args: string[], options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (options.outputFormat && features.supportsOutputFormat !== false) {
+    args.push('--output-format', options.outputFormat);
+  }
+  if (options.outputFormat === 'stream-json') {
+    if (features.supportsVerbose !== false) args.push('--verbose');
+    if (features.supportsIncludePartials !== false) args.push('--include-partial-messages');
+  }
+}
+
+function addSchemaArgs(args: string[], options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (
+    options.jsonSchema &&
+    options.outputFormat === 'json' &&
+    features.supportsJsonSchema !== false
+  ) {
+    args.push(
+      '--json-schema',
+      typeof options.jsonSchema === 'string'
+        ? options.jsonSchema
+        : stringifyJson(options.jsonSchema)
+    );
+  }
+}
+
+function addModelArgs(args: string[], options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (options.modelSpec?.model && features.supportsModel !== false) {
+    args.push('--model', options.modelSpec.model);
+  }
+}
+
+function addAutoApproveArgs(args: string[], options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (options.autoApprove && features.supportsAutoApprove !== false) {
+    args.push('--dangerously-skip-permissions');
+  }
+}
+
+function addSessionArgs(args: string[], options: BuildProviderCommandOptions): void {
+  if (options.resumeSessionId) {
+    args.push('--resume', options.resumeSessionId);
+    return;
+  }
+  if (options.continueSession) {
+    args.push('--continue');
+  }
+}
+
+function readConfiguredClaudeCommand(): string {
+  if (process.env.ZEROSHOT_CLAUDE_COMMAND?.trim()) {
+    return process.env.ZEROSHOT_CLAUDE_COMMAND;
+  }
+
+  const settingsPath =
+    process.env.ZEROSHOT_SETTINGS_FILE || join(homedir(), '.zeroshot', 'settings.json');
+  if (!existsSync(settingsPath)) return 'claude';
+
+  try {
+    const settings: unknown = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    const configured = isRecord(settings) ? getString(settings, 'claudeCommand') : null;
+    if (configured?.trim()) return configured;
+  } catch {
+    return 'claude';
+  }
+
+  return 'claude';
+}
+
+function resolveClaudeCommand(): { readonly command: string; readonly args: readonly string[] } {
+  const parts = readConfiguredClaudeCommand().trim().split(/\s+/);
+  return {
+    command: parts[0] ?? 'claude',
+    args: parts.slice(1),
+  };
+}
+
+function collectWarnings(options: BuildProviderCommandOptions): WarningMetadata[] {
+  const features = optionFeatures(options);
+  const warnings: WarningMetadata[] = [];
+  if (options.jsonSchema && options.outputFormat !== 'json' && !options.strictSchema) {
+    warnings.push(
+      warning(
+        'claude',
+        'claude-jsonschema-stream',
+        'jsonSchema requested with stream output; schema enforcement will be post-validated.'
+      )
+    );
+  }
+  if (
+    options.jsonSchema &&
+    options.outputFormat === 'json' &&
+    features.supportsJsonSchema === false
+  ) {
+    warnings.push(
+      warning(
+        'claude',
+        'claude-jsonschema-flag',
+        'Claude CLI does not support --json-schema; skipping schema flag.'
+      )
+    );
+  }
+  if (options.autoApprove && features.supportsAutoApprove === false) {
+    warnings.push(
+      warning(
+        'claude',
+        'claude-auto-approve',
+        'Claude CLI does not support --dangerously-skip-permissions; continuing without auto-approve.'
+      )
+    );
+  }
+  return warnings;
+}
+
+function buildCommand(context: string, options: BuildProviderCommandOptions = {}): CommandSpec {
+  const { command, args: commandPrefix } = resolveClaudeCommand();
+  const args: string[] = [...commandPrefix, '--print', '--input-format', 'text'];
+  const authEnv = options.authEnv ?? {};
+
+  addOutputArgs(args, options);
+  addSchemaArgs(args, options);
+  addModelArgs(args, options);
+  addAutoApproveArgs(args, options);
+  addSessionArgs(args, options);
+
+  args.push(context);
+
+  return commandSpec({
+    binary: command,
+    args,
+    env: authEnv,
+    ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+    warnings: collectWarnings(options),
+    redactions: envRedactions(authEnv),
+  });
+}
+
+function resolveModelSpec(level: ModelLevel, overrides?: LevelOverrides): ResolvedModelSpec {
+  return resolveModelSpecWithConfig({
+    mapping: LEVEL_MAPPING,
+    defaultLevel: 'level2',
+    level,
+    overrides,
+    validateModelId,
+  });
+}
+
+function validateModelId(modelId: string | null | undefined): string | null | undefined {
+  try {
+    return validateModelIdFromCatalog('claude', MODEL_CATALOG, modelId);
+  } catch (error) {
+    if (modelId && (modelId === 'opus-4.6' || modelId === 'claude-opus-4-6')) {
+      throw new InvalidProviderModelError(
+        `Invalid model "${modelId}" for provider "claude". Use canonical model ids: haiku, sonnet, opus.`
+      );
+    }
+    throw error;
+  }
+}
+
+function classifyError(error: unknown): ErrorClassification {
+  return classifyBaseProviderError(
+    error,
+    [/no messages returned/i, /\boverloaded\b/i, /\brate[_ -]?limit\b/i],
+    [/invalid_request_error/i, /model_not_available/i]
+  );
+}
+
+export const claudeAdapter: ProviderAdapter = {
+  id: 'claude',
+  displayName: 'Claude',
+  binary: 'claude',
+  adapterVersion: '1',
+  credentialEnvKeys: ['ANTHROPIC_API_KEY', 'CLAUDE_API_KEY'],
+  modelCatalog: MODEL_CATALOG,
+  levelMapping: LEVEL_MAPPING,
+  defaultLevel: 'level2',
+  defaultMaxLevel: 'level3',
+  defaultMinLevel: 'level1',
+  detectCliFeatures,
+  buildCommand,
+  parseEvent: parseClaudeEvent,
+  createParserState: () => createParserState('claude'),
+  resolveModelSpec,
+  validateModelId,
+  classifyError,
+};

package/src/agent-cli-provider/adapters/codex-parser.ts

@@ -0,0 +1,211 @@
+import {
+  getNumber,
+  getOptionalString,
+  getOrStringFromKeys,
+  getRecord,
+  getString,
+  isRecord,
+  parseJson,
+  tryParseJson,
+} from '../json';
+import type { OutputEvent, ProviderParseResult } from '../types';
+
+function safeJsonParse(value: string, fallback: unknown): unknown {
+  try {
+    return parseJson(value);
+  } catch {
+    return fallback;
+  }
+}
+
+function parseAssistantMessage(item: Record<string, unknown>): OutputEvent[] {
+  const rawContent = item.content;
+  const content = Array.isArray(rawContent) ? rawContent : [{ type: 'text', text: rawContent }];
+  const records = content.filter(isRecord);
+  const text = records
+    .filter((contentItem) => getString(contentItem, 'type') === 'text')
+    .map((contentItem) => getString(contentItem, 'text') ?? '')
+    .join('');
+  const thinking = records
+    .filter((contentItem) => {
+      const type = getString(contentItem, 'type');
+      return type === 'thinking' || type === 'reasoning';
+    })
+    .map((contentItem) => getString(contentItem, 'text') ?? '')
+    .join('');
+
+  const events: OutputEvent[] = [];
+  if (text) events.push({ type: 'text', text });
+  if (thinking) events.push({ type: 'thinking', text: thinking });
+  return events;
+}
+
+function parseFunctionCall(item: Record<string, unknown>): OutputEvent {
+  const argumentValue = item.arguments;
+  const input =
+    typeof argumentValue === 'string' ? safeJsonParse(argumentValue, {}) : (argumentValue ?? {});
+  return {
+    type: 'tool_call',
+    toolName: getOptionalString(item, 'name'),
+    toolId: getOrStringFromKeys(item, ['call_id', 'id', 'tool_call_id', 'tool_id']),
+    input,
+  };
+}
+
+function parseFunctionCallOutput(item: Record<string, unknown>): OutputEvent {
+  return {
+    type: 'tool_result',
+    toolId: getOrStringFromKeys(item, ['call_id', 'id', 'tool_call_id', 'tool_id']),
+    content: item.output ?? item.result ?? item.content ?? '',
+    isError: Boolean(item.error),
+  };
+}
+
+function commandFromItem(item: Record<string, unknown>): string | null {
+  const input = getRecord(item, 'input');
+  if (input !== null) {
+    return (
+      getString(item, 'command') ??
+      getString(item, 'cmd') ??
+      getString(input, 'command') ??
+      getString(input, 'cmd')
+    );
+  }
+  return getString(item, 'command') ?? getString(item, 'cmd');
+}
+
+function commandExecutionResultIsError(item: Record<string, unknown>): boolean {
+  const exitCode = getNumber(item, 'exit_code') ?? getNumber(item, 'exitCode');
+  if (exitCode !== null) return exitCode !== 0;
+  return Boolean(item.error);
+}
+
+function parseCommandExecutionItem(
+  item: Record<string, unknown>,
+  phase: 'started' | 'completed'
+): OutputEvent {
+  const command = commandFromItem(item);
+  const toolId = getOptionalString(item, 'id');
+
+  if (phase === 'started') {
+    return {
+      type: 'tool_call',
+      toolName: 'Bash',
+      toolId,
+      input: command ? { command } : {},
+    };
+  }
+
+  return {
+    type: 'tool_result',
+    toolId,
+    content: item.aggregated_output ?? item.output ?? item.result ?? '',
+    isError: commandExecutionResultIsError(item),
+  };
+}
+
+function parseReasoningItem(item: Record<string, unknown>): OutputEvent | null {
+  const text = getString(item, 'text') ?? getString(item, 'content') ?? '';
+  return text ? { type: 'thinking', text } : null;
+}
+
+function normalizeItemEvents(events: OutputEvent[]): ProviderParseResult {
+  if (events.length === 1) return events[0] ?? null;
+  if (events.length > 1) return events;
+  return null;
+}
+
+function phaseForEventType(eventType: string): 'started' | 'completed' | null {
+  if (eventType === 'item.started') return 'started';
+  if (eventType === 'item.completed') return 'completed';
+  return null;
+}
+
+function pushMaybe(events: OutputEvent[], event: OutputEvent | null): void {
+  if (event !== null) events.push(event);
+}
+
+function parseItem(item: Record<string, unknown>, eventType: string): ProviderParseResult {
+  const events: OutputEvent[] = [];
+  const itemType = getString(item, 'type');
+  const phase = phaseForEventType(eventType);
+
+  if (itemType === 'message' && getString(item, 'role') === 'assistant') {
+    events.push(...parseAssistantMessage(item));
+  }
+  if (itemType === 'agent_message') {
+    const text = getString(item, 'text');
+    if (text) events.push({ type: 'text', text });
+  }
+  if (itemType === 'reasoning') pushMaybe(events, parseReasoningItem(item));
+  if (itemType === 'command_execution' && phase !== null) {
+    events.push(parseCommandExecutionItem(item, phase));
+  }
+  if (itemType === 'function_call') events.push(parseFunctionCall(item));
+  if (itemType === 'function_call_output') events.push(parseFunctionCallOutput(item));
+
+  return normalizeItemEvents(events);
+}
+
+function parseErrorEvent(event: Record<string, unknown>): OutputEvent {
+  const error = getRecord(event, 'error');
+  return {
+    type: 'result',
+    success: false,
+    error: error
+      ? (getString(error, 'message') ?? getString(event, 'message') ?? event.error ?? 'Error')
+      : (getString(event, 'message') ?? event.error ?? 'Error'),
+  };
+}
+
+function parseTurnCompleted(event: Record<string, unknown>): OutputEvent {
+  const response = getRecord(event, 'response');
+  const usage = getRecord(event, 'usage') ?? (response ? getRecord(response, 'usage') : null) ?? {};
+  return {
+    type: 'result',
+    success: true,
+    inputTokens: getNumber(usage, 'input_tokens') ?? 0,
+    outputTokens: getNumber(usage, 'output_tokens') ?? 0,
+  };
+}
+
+function parseTurnFailed(event: Record<string, unknown>): OutputEvent {
+  const error = getRecord(event, 'error');
+  return {
+    type: 'result',
+    success: false,
+    error: error
+      ? (getString(error, 'message') ?? event.error ?? 'Turn failed')
+      : (event.error ?? 'Turn failed'),
+  };
+}
+
+function parseStartedItem(event: Record<string, unknown>): ProviderParseResult {
+  const item = getRecord(event, 'item');
+  if (item === null || getString(item, 'type') !== 'command_execution') return null;
+  return parseItem(item, 'item.started');
+}
+
+function parseCreatedOrCompletedItem(
+  event: Record<string, unknown>,
+  type: string
+): ProviderParseResult {
+  const item = getRecord(event, 'item');
+  return item === null ? null : parseItem(item, type);
+}
+
+export function parseCodexEvent(line: string): ProviderParseResult {
+  const event = tryParseJson(line);
+  if (!isRecord(event)) return null;
+
+  const type = getString(event, 'type');
+  if (type === 'error') return parseErrorEvent(event);
+  if (type === 'thread.started' || type === 'turn.started') return null;
+  if (type === 'item.started') return parseStartedItem(event);
+  if (type === 'item.created' || type === 'item.completed') {
+    return parseCreatedOrCompletedItem(event, type);
+  }
+  if (type === 'turn.completed') return parseTurnCompleted(event);
+  if (type === 'turn.failed') return parseTurnFailed(event);
+  return null;
+}

package/src/agent-cli-provider/adapters/codex.ts

@@ -0,0 +1,217 @@
+import { appendJsonSchemaPrompt, writeStrictOutputSchemaFile } from '../schema';
+import {
+  type BuildProviderCommandOptions,
+  type CodexCliFeatures,
+  type CommandSpec,
+  type ErrorClassification,
+  type LevelModelSpec,
+  type LevelOverrides,
+  type ModelCatalogEntry,
+  type ModelLevel,
+  type ProviderAdapter,
+  type ResolvedModelSpec,
+  type WarningMetadata,
+} from '../types';
+import {
+  classifyBaseProviderError,
+  commandSpec,
+  createParserState,
+  optionFeatures,
+  resolveModelSpecWithConfig,
+  unsupportedSessionControlWarnings,
+  validateModelIdFromCatalog,
+  warning,
+} from './common';
+import { parseCodexEvent } from './codex-parser';
+
+const MODEL_CATALOG: Readonly<Record<string, ModelCatalogEntry>> = {
+  'gpt-5.4': { rank: 2 },
+  'gpt-5.5': { rank: 3 },
+};
+
+const LEVEL_MAPPING: Readonly<Record<ModelLevel, LevelModelSpec>> = {
+  level1: { rank: 1, model: 'gpt-5.4', reasoningEffort: 'medium' },
+  level2: { rank: 2, model: 'gpt-5.4', reasoningEffort: 'high' },
+  level3: { rank: 3, model: 'gpt-5.4', reasoningEffort: 'xhigh' },
+};
+
+function supports(help: string, pattern: RegExp): boolean {
+  return help ? pattern.test(help) : true;
+}
+
+function detectCliFeatures(helpText?: string | null): CodexCliFeatures {
+  const help = helpText ?? '';
+  const unknown = !help;
+  return {
+    provider: 'codex',
+    supportsJson: supports(help, /--json\b/),
+    supportsOutputSchema: supports(help, /--output-schema\b/),
+    supportsAutoApprove: supports(help, /--dangerously-bypass-approvals-and-sandbox\b/),
+    supportsCwd: supports(help, /\s-C\b/) || supports(help, /--cwd\b/),
+    supportsConfigOverride: supports(help, /--config\b/),
+    supportsModel: supports(help, /\s-m\b/) || supports(help, /--model\b/),
+    supportsSkipGitRepoCheck: supports(help, /--skip-git-repo-check\b/),
+    unknown,
+  };
+}
+
+function addOutputArgs(args: string[], options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (
+    (options.outputFormat === 'stream-json' || options.outputFormat === 'json') &&
+    features.supportsJson
+  ) {
+    args.push('--json');
+  }
+}
+
+function addModelArgs(args: string[], options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (options.modelSpec?.model) {
+    args.push('-m', options.modelSpec.model);
+  }
+  if (options.modelSpec?.reasoningEffort && features.supportsConfigOverride) {
+    args.push('--config', `model_reasoning_effort="${options.modelSpec.reasoningEffort}"`);
+  }
+}
+
+function addCwdArgs(args: string[], options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (options.cwd && features.supportsCwd) {
+    args.push('-C', options.cwd);
+  }
+}
+
+function addAutoApproveArgs(args: string[], options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (options.autoApprove && features.supportsAutoApprove) {
+    args.push('--dangerously-bypass-approvals-and-sandbox');
+  }
+}
+
+function addSkipGitArgs(args: string[], options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (features.supportsSkipGitRepoCheck !== false) {
+    args.push('--skip-git-repo-check');
+  }
+}
+
+function applySchemaArgs(
+  args: string[],
+  cleanup: string[],
+  context: string,
+  options: BuildProviderCommandOptions
+): string {
+  const features = optionFeatures(options);
+  if (options.jsonSchema && features.supportsOutputSchema) {
+    const schemaFile = writeStrictOutputSchemaFile(options.jsonSchema);
+    cleanup.push(schemaFile);
+    args.push('--output-schema', schemaFile);
+    return context;
+  }
+  return options.jsonSchema ? appendJsonSchemaPrompt(context, options.jsonSchema) : context;
+}
+
+function collectWarnings(options: BuildProviderCommandOptions): WarningMetadata[] {
+  const features = optionFeatures(options);
+  const warnings: WarningMetadata[] = unsupportedSessionControlWarnings('codex', options);
+  if (options.autoApprove && features.supportsAutoApprove === false) {
+    warnings.push(
+      warning(
+        'codex',
+        'codex-auto-approve',
+        'Codex CLI does not support auto-approve; continuing without bypass flag.'
+      )
+    );
+  }
+  if (options.jsonSchema && features.supportsOutputSchema === false) {
+    warnings.push(
+      warning(
+        'codex',
+        'codex-jsonschema',
+        'Codex CLI does not support --output-schema; skipping schema flag.'
+      )
+    );
+  }
+  if (options.modelSpec?.reasoningEffort && features.supportsConfigOverride === false) {
+    warnings.push(
+      warning(
+        'codex',
+        'codex-reasoning',
+        'Codex CLI does not support --config overrides; skipping reasoningEffort.'
+      )
+    );
+  }
+  return warnings;
+}
+
+function buildCommand(context: string, options: BuildProviderCommandOptions = {}): CommandSpec {
+  const args: string[] = ['exec'];
+  const cleanup: string[] = [];
+
+  addOutputArgs(args, options);
+  addModelArgs(args, options);
+  addCwdArgs(args, options);
+  addAutoApproveArgs(args, options);
+  addSkipGitArgs(args, options);
+  const finalContext = applySchemaArgs(args, cleanup, context, options);
+
+  args.push(finalContext);
+
+  return commandSpec({
+    binary: 'codex',
+    args,
+    env: {},
+    ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+    cleanup,
+    cleanupMetadata: cleanup.map((schemaFile) => ({
+      kind: 'temp-file',
+      provider: 'codex',
+      path: schemaFile,
+      reason: 'output-schema',
+    })),
+    warnings: collectWarnings(options),
+  });
+}
+
+function resolveModelSpec(level: ModelLevel, overrides?: LevelOverrides): ResolvedModelSpec {
+  return resolveModelSpecWithConfig({
+    mapping: LEVEL_MAPPING,
+    defaultLevel: 'level2',
+    level,
+    overrides,
+    validateModelId,
+  });
+}
+
+function validateModelId(modelId: string | null | undefined): string | null | undefined {
+  return validateModelIdFromCatalog('codex', MODEL_CATALOG, modelId);
+}
+
+function classifyError(error: unknown): ErrorClassification {
+  return classifyBaseProviderError(
+    error,
+    [/rate_limit_exceeded/i, /\bserver_error\b/i, /\bservice_unavailable\b/i],
+    [/\binsufficient_quota\b/i, /\bmodel_not_found\b/i, /\bcontext_length_exceeded\b/i]
+  );
+}
+
+export const codexAdapter: ProviderAdapter = {
+  id: 'codex',
+  displayName: 'Codex',
+  binary: 'codex',
+  adapterVersion: '1',
+  credentialEnvKeys: ['OPENAI_API_KEY', 'CODEX_API_KEY'],
+  modelCatalog: MODEL_CATALOG,
+  levelMapping: LEVEL_MAPPING,
+  defaultLevel: 'level2',
+  defaultMaxLevel: 'level3',
+  defaultMinLevel: 'level1',
+  detectCliFeatures,
+  buildCommand,
+  parseEvent: parseCodexEvent,
+  createParserState: () => createParserState('codex'),
+  resolveModelSpec,
+  validateModelId,
+  classifyError,
+};