@the-open-engine/zeroshot 5.4.0

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

@@ -0,0 +1,124 @@
+import {
+  basePermanentErrorPatterns,
+  baseRetryableErrorPatterns,
+  classifyErrorWithPatterns,
+} from '../errors';
+import {
+  InvalidProviderModelError,
+  type BuildProviderCommandOptions,
+  type CliFeatureOverrides,
+  type CleanupMetadata,
+  type CommandSpec,
+  type ErrorClassification,
+  type LevelModelSpec,
+  type LevelOverrides,
+  type ModelCatalogEntry,
+  type ModelLevel,
+  type ProviderId,
+  type ProviderParserState,
+  type RedactionMetadata,
+  type ResolvedModelSpec,
+  type WarningMetadata,
+} from '../types';
+
+export function createParserState(provider: ProviderId): ProviderParserState {
+  return {
+    provider,
+    lastToolId: undefined,
+  };
+}
+
+export function commandSpec(input: {
+  readonly binary: string;
+  readonly args: readonly string[];
+  readonly env?: Readonly<Record<string, string>>;
+  readonly cwd?: string;
+  readonly cleanup?: readonly string[];
+  readonly cleanupMetadata?: readonly CleanupMetadata[];
+  readonly warnings?: readonly WarningMetadata[];
+  readonly redactions?: readonly RedactionMetadata[];
+}): CommandSpec {
+  const spec = {
+    binary: input.binary,
+    args: input.args,
+    env: input.env ?? {},
+    cleanupMetadata: input.cleanupMetadata ?? [],
+    warnings: input.warnings ?? [],
+    redactions: input.redactions ?? [],
+  };
+  const specWithCwd = input.cwd === undefined ? spec : { ...spec, cwd: input.cwd };
+  if (input.cleanup === undefined) return specWithCwd;
+  return { ...specWithCwd, cleanup: input.cleanup };
+}
+
+export function warning(provider: ProviderId, code: string, message: string): WarningMetadata {
+  return { provider, code, message };
+}
+
+export function unsupportedSessionControlWarnings(
+  provider: ProviderId,
+  options: BuildProviderCommandOptions
+): WarningMetadata[] {
+  if (!options.resumeSessionId && !options.continueSession) return [];
+  return [
+    warning(
+      provider,
+      'unsupported-session-control',
+      'resume/continue is only supported for Claude CLI; ignoring.'
+    ),
+  ];
+}
+
+export function envRedactions(env: Readonly<Record<string, string>>): readonly RedactionMetadata[] {
+  return Object.keys(env).map((key) => ({ kind: 'env', key }));
+}
+
+interface ModelResolutionConfig {
+  readonly mapping: Readonly<Record<ModelLevel, LevelModelSpec>>;
+  readonly defaultLevel: ModelLevel;
+  readonly level: ModelLevel;
+  readonly overrides: LevelOverrides | undefined;
+  readonly validateModelId: (modelId: string | null | undefined) => string | null | undefined;
+}
+
+export function resolveModelSpecWithConfig(config: ModelResolutionConfig): ResolvedModelSpec {
+  const base = config.mapping[config.level] ?? config.mapping[config.defaultLevel];
+  const override = config.overrides?.[config.level];
+  const selectedModel = override?.model || base.model;
+  const validatedModel = config.validateModelId(selectedModel);
+  return {
+    level: config.level,
+    model: validatedModel ?? null,
+    reasoningEffort: override?.reasoningEffort || base.reasoningEffort,
+  };
+}
+
+export function validateModelIdFromCatalog(
+  provider: ProviderId,
+  catalog: Readonly<Record<string, ModelCatalogEntry>>,
+  modelId: string | null | undefined
+): string | null | undefined {
+  if (!modelId) return modelId;
+  if (catalog[modelId] !== undefined) return modelId;
+  throw new InvalidProviderModelError(
+    `Invalid model "${modelId}" for provider "${provider}". Use a model listed in provider settings/catalog.`
+  );
+}
+
+export function classifyBaseProviderError(
+  error: unknown,
+  retryablePatterns: readonly RegExp[],
+  permanentPatterns: readonly RegExp[]
+): ErrorClassification {
+  return classifyErrorWithPatterns(
+    error,
+    [...baseRetryableErrorPatterns(), ...retryablePatterns],
+    [...basePermanentErrorPatterns(), ...permanentPatterns]
+  );
+}
+
+export function optionFeatures(
+  options: BuildProviderCommandOptions | undefined
+): CliFeatureOverrides {
+  return options?.cliFeatures ?? {};
+}

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

@@ -0,0 +1,243 @@
+import { appendJsonSchemaPrompt } from '../schema';
+import {
+  getOrStringFromKeys,
+  getOrStringFromKeysWithFallback,
+  getString,
+  isRecord,
+  tryParseJson,
+} from '../json';
+import {
+  type BuildProviderCommandOptions,
+  type CommandSpec,
+  type ErrorClassification,
+  type GeminiCliFeatures,
+  type LevelModelSpec,
+  type LevelOverrides,
+  type ModelCatalogEntry,
+  type ModelLevel,
+  type OutputEvent,
+  type ProviderAdapter,
+  type ProviderParserState,
+  type ResolvedModelSpec,
+  type WarningMetadata,
+} from '../types';
+import {
+  classifyBaseProviderError,
+  commandSpec,
+  createParserState,
+  optionFeatures,
+  resolveModelSpecWithConfig,
+  unsupportedSessionControlWarnings,
+  validateModelIdFromCatalog,
+  warning,
+} from './common';
+
+const MODEL_CATALOG: Readonly<Record<string, ModelCatalogEntry>> = {
+  'gemini-2.5-pro': { rank: 3 },
+  'gemini-2.0-flash': { rank: 1 },
+};
+
+const LEVEL_MAPPING: Readonly<Record<ModelLevel, LevelModelSpec>> = {
+  level1: { rank: 1, model: null },
+  level2: { rank: 2, model: null },
+  level3: { rank: 3, model: null },
+};
+
+function detectCliFeatures(helpText?: string | null): GeminiCliFeatures {
+  const help = helpText ?? '';
+  const unknown = !help;
+  return {
+    provider: 'gemini',
+    supportsStreamJson: unknown ? true : /--output-format\b/.test(help),
+    supportsAutoApprove: unknown ? true : /--yolo\b/.test(help),
+    supportsCwd: unknown ? true : /--cwd\b/.test(help),
+    supportsModel: unknown ? true : /\s-m\b/.test(help) || /--model\b/.test(help),
+    unknown,
+  };
+}
+
+function addGeminiOptionalArgs(args: string[], options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (
+    (options.outputFormat === 'stream-json' || options.outputFormat === 'json') &&
+    features.supportsStreamJson
+  ) {
+    args.push('--output-format', 'stream-json');
+  }
+
+  if (options.modelSpec?.model) {
+    args.push('-m', options.modelSpec.model);
+  }
+
+  if (options.cwd && features.supportsCwd) {
+    args.push('--cwd', options.cwd);
+  }
+
+  if (options.autoApprove && features.supportsAutoApprove) {
+    args.push('--yolo');
+  }
+}
+
+function collectGeminiWarnings(options: BuildProviderCommandOptions): WarningMetadata[] {
+  const features = optionFeatures(options);
+  const warnings: WarningMetadata[] = unsupportedSessionControlWarnings('gemini', options);
+  if (options.autoApprove && features.supportsAutoApprove === false) {
+    warnings.push(
+      warning(
+        'gemini',
+        'gemini-auto-approve',
+        'Gemini CLI does not support --yolo; continuing without auto-approve.'
+      )
+    );
+  }
+  return warnings;
+}
+
+function buildCommand(context: string, options: BuildProviderCommandOptions = {}): CommandSpec {
+  const finalContext = options.jsonSchema
+    ? appendJsonSchemaPrompt(context, options.jsonSchema)
+    : context;
+  const args: string[] = ['-p', finalContext];
+  addGeminiOptionalArgs(args, options);
+
+  return commandSpec({
+    binary: 'gemini',
+    args,
+    env: {},
+    ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+    warnings: collectGeminiWarnings(options),
+  });
+}
+
+function normalizeMessageContent(content: unknown): string {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((item) => {
+        if (typeof item === 'string') return item;
+        if (isRecord(item)) return getString(item, 'text') ?? '';
+        return '';
+      })
+      .join('');
+  }
+  if (isRecord(content)) return getString(content, 'text') ?? '';
+  return '';
+}
+
+function parseMessageEvent(event: Record<string, unknown>): OutputEvent | null {
+  if (getString(event, 'role') !== 'assistant') return null;
+  const text = normalizeMessageContent(event.content);
+  return text ? { type: 'text', text } : null;
+}
+
+function parseToolUseEvent(
+  event: Record<string, unknown>,
+  state: ProviderParserState
+): OutputEvent {
+  const toolId = getOrStringFromKeysWithFallback(
+    event,
+    ['tool_call_id', 'tool_id', 'id'],
+    state.lastToolId
+  );
+  state.lastToolId = toolId;
+  return {
+    type: 'tool_call',
+    toolName: getOrStringFromKeys(event, ['tool_name', 'name']),
+    toolId,
+    input: event.parameters ?? event.input ?? {},
+  };
+}
+
+function parseToolResultEvent(
+  event: Record<string, unknown>,
+  state: ProviderParserState
+): OutputEvent {
+  const toolId = getOrStringFromKeysWithFallback(
+    event,
+    ['tool_call_id', 'tool_id', 'id'],
+    state.lastToolId
+  );
+  return {
+    type: 'tool_result',
+    toolId,
+    content: event.output ?? event.content ?? '',
+    isError: event.success === false,
+  };
+}
+
+function parseResultEvent(event: Record<string, unknown>): OutputEvent {
+  return {
+    type: 'result',
+    success: event.success !== false,
+    result: event.result || '',
+    error: event.success === false ? (getString(event, 'error') ?? 'Result failed') : null,
+  };
+}
+
+function parseEvent(line: string, state: ProviderParserState): OutputEvent | null {
+  const event = tryParseJson(line);
+  if (!isRecord(event)) return null;
+
+  switch (getString(event, 'type')) {
+    case 'init':
+      return null;
+    case 'message':
+      return parseMessageEvent(event);
+    case 'tool_use':
+      return parseToolUseEvent(event, state);
+    case 'tool_result':
+      return parseToolResultEvent(event, state);
+    case 'result':
+      return parseResultEvent(event);
+    default:
+      return null;
+  }
+}
+
+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('gemini', MODEL_CATALOG, modelId);
+}
+
+function classifyError(error: unknown): ErrorClassification {
+  return classifyBaseProviderError(
+    error,
+    [
+      /\bRESOURCE_EXHAUSTED\b/i,
+      /\bUNAVAILABLE\b/i,
+      /\bDEADLINE_EXCEEDED\b/i,
+      /No capacity available/i,
+      /quota.?exceeded/i,
+    ],
+    [/\bINVALID_ARGUMENT\b/i, /\bPERMISSION_DENIED\b/i, /\bNOT_FOUND\b/i]
+  );
+}
+
+export const geminiAdapter: ProviderAdapter = {
+  id: 'gemini',
+  displayName: 'Gemini',
+  binary: 'gemini',
+  adapterVersion: '1',
+  credentialEnvKeys: ['GEMINI_API_KEY', 'GOOGLE_API_KEY'],
+  modelCatalog: MODEL_CATALOG,
+  levelMapping: LEVEL_MAPPING,
+  defaultLevel: 'level2',
+  defaultMaxLevel: 'level3',
+  defaultMinLevel: 'level1',
+  detectCliFeatures,
+  buildCommand,
+  parseEvent,
+  createParserState: () => createParserState('gemini'),
+  resolveModelSpec,
+  validateModelId,
+  classifyError,
+};

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

@@ -0,0 +1,126 @@
+import { stripTimestampPrefix } from '../log-prefix';
+import type {
+  BuildProviderCommandOptions,
+  CommandSpec,
+  ErrorClassification,
+  KnownProviderName,
+  LevelOverrides,
+  ModelLevel,
+  OutputEvent,
+  ProviderAdapter,
+  ProviderId,
+  ResolvedModelSpec,
+} from '../types';
+import { claudeAdapter } from './claude';
+export {
+  NO_MESSAGES_RETURNED,
+  STREAMING_MODE_ERROR,
+  detectProviderFatalError,
+  detectProviderStreamingModeError,
+  recoverProviderStructuredOutput,
+  supportsProviderStructuredOutputRecovery,
+  type StreamingModeError,
+  type StructuredOutputRecovery,
+} from './claude-recovery';
+import { codexAdapter } from './codex';
+import { geminiAdapter } from './gemini';
+import { opencodeAdapter } from './opencode';
+
+const ADAPTERS: Readonly<Record<ProviderId, ProviderAdapter>> = {
+  claude: claudeAdapter,
+  codex: codexAdapter,
+  gemini: geminiAdapter,
+  opencode: opencodeAdapter,
+};
+
+const PROVIDER_IDS: readonly ProviderId[] = ['claude', 'codex', 'gemini', 'opencode'];
+
+function isOutputEventArray(
+  event: OutputEvent | readonly OutputEvent[]
+): event is readonly OutputEvent[] {
+  return Array.isArray(event);
+}
+
+function normalizeProviderName(name: string): ProviderId | string {
+  const normalized = name.toLowerCase();
+  switch (normalized) {
+    case 'anthropic':
+    case 'claude':
+      return 'claude';
+    case 'openai':
+    case 'codex':
+      return 'codex';
+    case 'google':
+    case 'gemini':
+      return 'gemini';
+    case 'opencode':
+      return 'opencode';
+    default:
+      return name;
+  }
+}
+
+function adapterForProviderId(provider: ProviderId): ProviderAdapter {
+  return ADAPTERS[provider];
+}
+
+function isProviderId(name: string): name is ProviderId {
+  return name === 'claude' || name === 'codex' || name === 'gemini' || name === 'opencode';
+}
+
+export function getProviderAdapter(name: KnownProviderName | string): ProviderAdapter {
+  const normalized = normalizeProviderName(name || '');
+  if (isProviderId(normalized)) return adapterForProviderId(normalized);
+  throw new Error(`Unknown provider: ${name}. Valid: ${PROVIDER_IDS.join(', ')}`);
+}
+
+export function listProviderAdapters(): readonly ProviderId[] {
+  return PROVIDER_IDS;
+}
+
+export function buildProviderCommand(
+  providerName: KnownProviderName | string,
+  context: string,
+  options?: BuildProviderCommandOptions
+): CommandSpec {
+  return getProviderAdapter(providerName).buildCommand(context, options);
+}
+
+export function parseProviderChunk(
+  providerName: KnownProviderName | string,
+  chunk: string
+): readonly OutputEvent[] {
+  const adapter = getProviderAdapter(providerName || 'claude');
+  const state = adapter.createParserState();
+  const events: OutputEvent[] = [];
+  const lines = chunk.split('\n');
+
+  for (const line of lines) {
+    const content = stripTimestampPrefix(line);
+    if (!content) continue;
+    const event = adapter.parseEvent(content, state);
+    if (!event) continue;
+    if (isOutputEventArray(event)) {
+      events.push(...event);
+    } else {
+      events.push(event);
+    }
+  }
+
+  return events;
+}
+
+export function resolveModelSpec(
+  providerName: KnownProviderName | string,
+  level: ModelLevel,
+  overrides?: LevelOverrides
+): ResolvedModelSpec {
+  return getProviderAdapter(providerName).resolveModelSpec(level, overrides);
+}
+
+export function classifyProviderError(
+  providerName: KnownProviderName | string,
+  error: unknown
+): ErrorClassification {
+  return getProviderAdapter(providerName).classifyError(error);
+}