@the-open-engine/zeroshot 6.16.0 → 6.18.0

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

@@ -1,3 +1,9 @@
+import { randomUUID } from 'node:crypto';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+import { UnsupportedProviderCapabilityError } from '../errors';
 import { appendJsonSchemaPrompt } from '../schema';
 import {
   getOrStringFromKeys,
@@ -16,7 +22,7 @@ import {
   type ModelCatalogEntry,
   type ModelLevel,
   type OutputEvent,
-  type ProviderAdapter,
+  type StructuredOutputRecoveryAdapter,
   type ProviderParserState,
   type ResolvedModelSpec,
   type WarningMetadata,
@@ -52,6 +58,7 @@ function detectCliFeatures(helpText?: string | null): GeminiCliFeatures {
     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),
+    supportsAdminPolicy: !unknown && /--admin-policy\b/.test(help),
     unknown,
   };
 }
@@ -109,6 +116,75 @@ function buildCommand(context: string, options: BuildProviderCommandOptions = {}
   });
 }
 
+function standardAdminPolicyDirectory(): string {
+  if (process.platform === 'darwin') {
+    return '/Library/Application Support/GeminiCli/policies';
+  }
+  if (process.platform === 'win32') {
+    return path.join(process.env.ProgramData || 'C:\\ProgramData', 'gemini-cli', 'policies');
+  }
+  return '/etc/gemini-cli/policies';
+}
+
+function assertSupplementalAdminPolicyEffective(): void {
+  const directory = standardAdminPolicyDirectory();
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(directory, { withFileTypes: true });
+  } catch (error) {
+    if (isRecord(error) && error.code === 'ENOENT') return;
+    throw new UnsupportedProviderCapabilityError(
+      'gemini',
+      'structuredOutputRecovery',
+      `Gemini structured-output recovery cannot inspect the standard admin-policy directory ${directory}; refuse a supplemental policy that may be ignored.`
+    );
+  }
+  if (!entries.some((entry) => entry.isFile() && entry.name.endsWith('.toml'))) return;
+  throw new UnsupportedProviderCapabilityError(
+    'gemini',
+    'structuredOutputRecovery',
+    `Gemini ignores --admin-policy when ${directory} contains TOML policies. Remove the conflict or use an administrator-managed deny-all policy before retrying.`
+  );
+}
+
+function writeRecoveryAdminPolicy(): string {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'zeroshot-gemini-policy-'));
+  const policyPath = path.join(directory, `${randomUUID()}.toml`);
+  fs.writeFileSync(policyPath, '[[rule]]\ntoolName = "*"\ndecision = "deny"\npriority = 999\n', {
+    flag: 'wx',
+    mode: 0o600,
+  });
+  return policyPath;
+}
+
+function buildStructuredOutputRecoveryCommand(
+  context: string,
+  options: BuildProviderCommandOptions = {}
+): CommandSpec {
+  if (optionFeatures(options).supportsAdminPolicy !== true) {
+    throw new UnsupportedProviderCapabilityError(
+      'gemini',
+      'structuredOutputRecovery',
+      'Gemini structured-output recovery requires CLI evidence for --admin-policy. Upgrade @google/gemini-cli before retrying.'
+    );
+  }
+  assertSupplementalAdminPolicyEffective();
+  const recoveryOptions = { ...options };
+  delete recoveryOptions.resumeSessionId;
+  delete recoveryOptions.continueSession;
+  const spec = buildCommand(context, { ...recoveryOptions, autoApprove: false });
+  const policyPath = writeRecoveryAdminPolicy();
+  return {
+    ...spec,
+    args: ['--admin-policy', policyPath, ...spec.args],
+    cleanup: [...(spec.cleanup || []), policyPath],
+    cleanupMetadata: [
+      ...spec.cleanupMetadata,
+      { kind: 'temp-file', provider: 'gemini', path: policyPath, reason: 'admin-policy' },
+    ],
+  };
+}
+
 function normalizeMessageContent(content: unknown): string {
   if (typeof content === 'string') return content;
   if (Array.isArray(content)) {
@@ -148,6 +224,11 @@ function parseToolUseEvent(
   };
 }
 
+function geminiErrorMessage(event: Record<string, unknown>, fallback: string): string {
+  const error = isRecord(event.error) ? event.error : null;
+  return (error && getString(error, 'message')) || getString(event, 'message') || fallback;
+}
+
 function parseToolResultEvent(
   event: Record<string, unknown>,
   state: ProviderParserState
@@ -157,20 +238,32 @@ function parseToolResultEvent(
     ['tool_call_id', 'tool_id', 'id'],
     state.lastToolId
   );
+  const isError = getString(event, 'status') === 'error';
   return {
     type: 'tool_result',
     toolId,
-    content: event.output ?? event.content ?? '',
-    isError: event.success === false,
+    content: event.output ?? (isError ? geminiErrorMessage(event, 'Tool failed') : ''),
+    isError,
   };
 }
 
 function parseResultEvent(event: Record<string, unknown>): OutputEvent {
+  const success = getString(event, 'status') === 'success';
   return {
     type: 'result',
-    success: event.success !== false,
+    success,
     result: event.result || '',
-    error: event.success === false ? (getString(event, 'error') ?? 'Result failed') : null,
+    error: success ? null : geminiErrorMessage(event, 'Result failed'),
+  };
+}
+
+function parseErrorEvent(event: Record<string, unknown>): OutputEvent | null {
+  if (getString(event, 'severity') !== 'error') return null;
+  return {
+    type: 'result',
+    success: false,
+    result: '',
+    error: getString(event, 'message') || 'Gemini CLI error',
   };
 }
 
@@ -189,6 +282,8 @@ function parseEvent(line: string, state: ProviderParserState): OutputEvent | nul
       return parseToolResultEvent(event, state);
     case 'result':
       return parseResultEvent(event);
+    case 'error':
+      return parseErrorEvent(event);
     default:
       return null;
   }
@@ -229,7 +324,7 @@ function classifyError(error: unknown): ErrorClassification {
   );
 }
 
-export const geminiAdapter: ProviderAdapter = {
+export const geminiAdapter: StructuredOutputRecoveryAdapter = {
   id: 'gemini',
   displayName: 'Gemini',
   binary: 'gemini',
@@ -242,6 +337,7 @@ export const geminiAdapter: ProviderAdapter = {
   defaultMinLevel: 'level1',
   detectCliFeatures,
   buildCommand,
+  buildStructuredOutputRecoveryCommand,
   parseEvent,
   createParserState: () => createParserState('gemini'),
   resolveModelSpec,

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

@@ -0,0 +1,448 @@
+import { appendJsonSchemaPrompt } from '../schema';
+import { contractError } from '../contract-errors';
+import {
+  getArray,
+  getBoolean,
+  getNumber,
+  getOptionalString,
+  getRecord,
+  getString,
+  isRecord,
+  tryParseJson,
+  unknownToMessage,
+} from '../json';
+import {
+  type BuildProviderCommandOptions,
+  type CommandSpec,
+  type ErrorClassification,
+  type LevelModelSpec,
+  type LevelOverrides,
+  type ModelCatalogEntry,
+  type ModelLevel,
+  type OmpCliFeatures,
+  type OutputEvent,
+  type ProviderAdapter,
+  type ProviderParserState,
+  type ResolvedModelSpec,
+  type WarningMetadata,
+} from '../types';
+import {
+  classifyBaseProviderError,
+  commandSpec,
+  createParserState,
+  optionFeatures,
+  resolveModelSpecWithConfig,
+  warning,
+} from './common';
+
+const MODEL_CATALOG: Readonly<Record<string, ModelCatalogEntry>> = {};
+
+const LEVEL_MAPPING: Readonly<Record<ModelLevel, LevelModelSpec>> = {
+  level1: { rank: 1, model: null, reasoningEffort: 'low' },
+  level2: { rank: 2, model: null, reasoningEffort: 'medium' },
+  level3: { rank: 3, model: null, reasoningEffort: 'high' },
+};
+
+const IGNORED_EVENT_TYPES = new Set([
+  'session',
+  'agent_start',
+  'agent_end',
+  'turn_start',
+  'queue_update',
+  'compaction_start',
+  'compaction_end',
+  'auto_retry_start',
+  'auto_retry_end',
+]);
+
+function detectCliFeatures(helpText?: string | null): OmpCliFeatures {
+  const help = helpText ?? '';
+  const unknown = !help;
+  return {
+    provider: 'omp',
+    supportsModeJson: unknown ? true : /--mode\b/.test(help) && /\bjson\b/.test(help),
+    supportsPrint: unknown ? true : /-p\b/.test(help) || /--print\b/.test(help),
+    supportsCwd: unknown ? true : /--cwd\b/.test(help),
+    supportsAutoApprove: unknown ? true : /--auto-approve\b/.test(help),
+    supportsModel: unknown ? true : /--model\b/.test(help),
+    supportsThinking: unknown ? true : /--thinking\b/.test(help),
+    supportsNoExtensions: unknown ? true : /--no-extensions\b/.test(help),
+    supportsNoSkills: unknown ? true : /--no-skills\b/.test(help),
+    supportsNoRules: unknown ? true : /--no-rules\b/.test(help),
+    supportsNoTitle: unknown ? true : /--no-title\b/.test(help),
+    unknown,
+  };
+}
+
+function assertRequiredOmpFeatures(options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  const required: ReadonlyArray<readonly [boolean | undefined, string]> = [
+    [features.supportsModeJson, '--mode json'],
+    [features.supportsPrint, '-p/--print'],
+    [features.supportsCwd, '--cwd'],
+    [features.supportsAutoApprove, '--auto-approve'],
+  ];
+  const missing = required.filter(([supported]) => supported === false).map(([, flag]) => flag);
+  if (missing.length === 0) return;
+  throw contractError({
+    code: 'unsupported-provider-cli',
+    exitCode: 2,
+    message:
+      'omp CLI is missing required non-interactive flag(s): ' +
+      missing.join(', ') +
+      '. Update/install @oh-my-pi/pi-coding-agent; Zeroshot will not silently fall back to Pi or another provider.',
+  });
+}
+
+function failClosedUnsupportedSessionControl(options: BuildProviderCommandOptions): void {
+  const hasResumeSessionId = options.resumeSessionId !== undefined;
+  if (!hasResumeSessionId && !options.continueSession) return;
+  const field = hasResumeSessionId ? 'options.resumeSessionId' : 'options.continueSession';
+  throw contractError({
+    code: 'invalid-field',
+    field,
+    exitCode: 2,
+    message:
+      'OMP CLI does not support resume/continue session control; fail closed and start a fresh run instead.',
+  });
+}
+
+function addOptionalFlags(args: string[], options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (features.supportsNoExtensions !== false) args.push('--no-extensions');
+  if (features.supportsNoSkills !== false) args.push('--no-skills');
+  if (features.supportsNoRules !== false) args.push('--no-rules');
+  if (features.supportsNoTitle !== false) args.push('--no-title');
+}
+
+function addModelArgs(args: string[], options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (options.modelSpec?.model && features.supportsModel !== false) {
+    args.push('--model', options.modelSpec.model);
+  }
+  if (options.modelSpec?.reasoningEffort && features.supportsThinking !== false) {
+    args.push('--thinking', options.modelSpec.reasoningEffort);
+  }
+}
+
+function collectWarnings(options: BuildProviderCommandOptions): WarningMetadata[] {
+  const features = optionFeatures(options);
+  const warnings: WarningMetadata[] = [];
+
+  if (options.jsonSchema) {
+    warnings.push(
+      warning(
+        'omp',
+        'omp-jsonschema',
+        'OMP CLI does not support provider-native JSON schema; appending schema instructions to the prompt.'
+      )
+    );
+  }
+  if (options.modelSpec?.model && features.supportsModel === false) {
+    warnings.push(
+      warning(
+        'omp',
+        'omp-model-unsupported',
+        "OMP CLI does not advertise --model; continuing with OMP's own configured model."
+      )
+    );
+  }
+  if (options.modelSpec?.reasoningEffort && features.supportsThinking === false) {
+    warnings.push(
+      warning(
+        'omp',
+        'omp-thinking-unsupported',
+        'OMP CLI does not advertise --thinking; continuing without a reasoning-effort override.'
+      )
+    );
+  }
+  return warnings;
+}
+
+function buildCommand(context: string, options: BuildProviderCommandOptions = {}): CommandSpec {
+  assertRequiredOmpFeatures(options);
+  failClosedUnsupportedSessionControl(options);
+  const finalContext = options.jsonSchema
+    ? appendJsonSchemaPrompt(context, options.jsonSchema)
+    : context;
+  const args: string[] = ['--mode', 'json', '-p'];
+
+  if (options.cwd) args.push('--cwd', options.cwd);
+  args.push('--auto-approve');
+  addOptionalFlags(args, options);
+  addModelArgs(args, options);
+  args.push(finalContext);
+
+  return commandSpec({
+    binary: 'omp',
+    args,
+    env: {},
+    ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+    warnings: collectWarnings(options),
+  });
+}
+
+function createOmpState(): ProviderParserState {
+  return {
+    ...createParserState('omp'),
+    lastAssistantText: '',
+    lastAssistantThinking: '',
+  };
+}
+
+function assistantSnapshot(message: Record<string, unknown>): { text: string; thinking: string } {
+  if (getString(message, 'role') !== 'assistant') return { text: '', thinking: '' };
+
+  let text = '';
+  let thinking = '';
+  for (const item of getArray(message, 'content')) {
+    if (!isRecord(item)) continue;
+    const type = getString(item, 'type');
+    if (type === 'text') {
+      text += getString(item, 'text') ?? '';
+    } else if (type === 'thinking') {
+      thinking += getString(item, 'thinking') ?? '';
+    }
+  }
+
+  return { text, thinking };
+}
+
+function snapshotDelta(previous: string, current: string): string | null {
+  if (!current) return null;
+  if (previous === current) return null;
+  if (current.startsWith(previous)) return current.slice(previous.length) || null;
+  return current;
+}
+
+function emitAssistantSnapshot(
+  message: Record<string, unknown>,
+  state: ProviderParserState
+): readonly OutputEvent[] {
+  const snapshot = assistantSnapshot(message);
+  const events: OutputEvent[] = [];
+
+  const textDelta = snapshotDelta(state.lastAssistantText ?? '', snapshot.text);
+  if (textDelta) events.push({ type: 'text', text: textDelta });
+  state.lastAssistantText = snapshot.text;
+
+  const thinkingDelta = snapshotDelta(state.lastAssistantThinking ?? '', snapshot.thinking);
+  if (thinkingDelta) events.push({ type: 'thinking', text: thinkingDelta });
+  state.lastAssistantThinking = snapshot.thinking;
+
+  return events;
+}
+
+function parseAssistantEvent(
+  event: Record<string, unknown>,
+  state: ProviderParserState
+): OutputEvent | null {
+  const type = getString(event, 'type');
+  if (type === 'text_delta') {
+    const delta = getString(event, 'delta');
+    if (!delta) return null;
+    state.lastAssistantText += delta;
+    return { type: 'text', text: delta };
+  }
+  if (type === 'thinking_delta') {
+    const delta = getString(event, 'delta');
+    if (!delta) return null;
+    state.lastAssistantThinking += delta;
+    return { type: 'thinking', text: delta };
+  }
+  return null;
+}
+
+function parseToolExecutionStart(
+  event: Record<string, unknown>,
+  state: ProviderParserState
+): OutputEvent {
+  const toolId = getOptionalString(event, 'toolCallId');
+  state.lastToolId = toolId;
+  return {
+    type: 'tool_call',
+    toolName: getOptionalString(event, 'toolName'),
+    toolId,
+    input: event.args ?? {},
+  };
+}
+
+function parseToolExecutionUpdate(
+  event: Record<string, unknown>,
+  state: ProviderParserState
+): OutputEvent | null {
+  const toolId = getOptionalString(event, 'toolCallId') ?? state.lastToolId;
+  if (toolId !== undefined) state.lastToolId = toolId;
+  if (!Object.prototype.hasOwnProperty.call(event, 'partialResult')) return null;
+  return {
+    type: 'tool_result',
+    toolId,
+    content: event.partialResult,
+    isError: false,
+  };
+}
+
+function parseToolExecutionEnd(
+  event: Record<string, unknown>,
+  state: ProviderParserState
+): OutputEvent {
+  const toolId = getOptionalString(event, 'toolCallId') ?? state.lastToolId;
+  return {
+    type: 'tool_result',
+    toolId,
+    content: event.result ?? '',
+    isError: getBoolean(event, 'isError') ?? false,
+  };
+}
+
+function parseTurnEnd(
+  event: Record<string, unknown>,
+  state: ProviderParserState
+): readonly OutputEvent[] {
+  const message = getRecord(event, 'message');
+  const events: OutputEvent[] = [];
+  if (message !== null) {
+    events.push(...emitAssistantSnapshot(message, state));
+  }
+
+  const usage = message ? getRecord(message, 'usage') ?? {} : {};
+  const stopReason = message ? getString(message, 'stopReason') : null;
+  const errorMessage = message ? getString(message, 'errorMessage') : null;
+  const snapshot = message ? assistantSnapshot(message) : { text: '', thinking: '' };
+  const success = stopReason !== 'error' && stopReason !== 'aborted' && !errorMessage;
+  events.push({
+    type: 'result',
+    success,
+    result: success ? snapshot.text || null : null,
+    error: success ? null : (errorMessage ?? stopReason ?? 'OMP turn failed'),
+    inputTokens: getNumber(usage, 'input') ?? 0,
+    outputTokens: getNumber(usage, 'output') ?? 0,
+    cacheReadInputTokens: getNumber(usage, 'cacheRead') ?? 0,
+    cacheCreationInputTokens: getNumber(usage, 'cacheWrite') ?? 0,
+    cost: getRecord(usage, 'cost') ?? null,
+    modelUsage: usage,
+  });
+  return events;
+}
+
+function parseMessageEvent(
+  type: string,
+  event: Record<string, unknown>,
+  state: ProviderParserState
+): readonly OutputEvent[] | OutputEvent | null | undefined {
+  if (type === 'message_start') {
+    const message = getRecord(event, 'message');
+    if (message !== null && getString(message, 'role') === 'assistant') {
+      state.lastAssistantText = '';
+      state.lastAssistantThinking = '';
+    }
+    return null;
+  }
+
+  if (type === 'message_update') {
+    const assistantMessageEvent = getRecord(event, 'assistantMessageEvent');
+    if (assistantMessageEvent !== null) {
+      const assistantEvent = parseAssistantEvent(assistantMessageEvent, state);
+      if (assistantEvent !== null) return assistantEvent;
+    }
+    const message = getRecord(event, 'message');
+    return message === null ? null : emitAssistantSnapshot(message, state);
+  }
+
+  if (type !== 'message_end') return undefined;
+  const message = getRecord(event, 'message');
+  return message === null ? null : emitAssistantSnapshot(message, state);
+}
+
+function parseToolEvent(
+  type: string,
+  event: Record<string, unknown>,
+  state: ProviderParserState
+): OutputEvent | null | undefined {
+  if (type === 'tool_execution_start') return parseToolExecutionStart(event, state);
+  if (type === 'tool_execution_update') return parseToolExecutionUpdate(event, state);
+  if (type === 'tool_execution_end') return parseToolExecutionEnd(event, state);
+  return undefined;
+}
+
+function parseEvent(
+  line: string,
+  state: ProviderParserState
+): readonly OutputEvent[] | OutputEvent | null {
+  const parsed = tryParseJson(line);
+  if (!isRecord(parsed)) return null;
+
+  const type = getString(parsed, 'type');
+  if (type === null || IGNORED_EVENT_TYPES.has(type)) return null;
+
+  const messageEvent = parseMessageEvent(type, parsed, state);
+  if (messageEvent !== undefined) return messageEvent;
+
+  const toolEvent = parseToolEvent(type, parsed, state);
+  if (toolEvent !== undefined) return toolEvent;
+
+  if (type === 'turn_end') return parseTurnEnd(parsed, state);
+  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 {
+  if (modelId === undefined || modelId === null) return modelId;
+  if (typeof modelId !== 'string') {
+    throw new Error(`Invalid model "${unknownToMessage(modelId)}" for provider "omp".`);
+  }
+  return modelId;
+}
+
+function classifyError(error: unknown): ErrorClassification {
+  return classifyBaseProviderError(
+    error,
+    [
+      /\brate(?:[_ -]?limit| limited)\b/i,
+      /\bquota\b/i,
+      /\bresource[_ -]?exhausted\b/i,
+      /\btemporar(?:y|ily)\b/i,
+      /\boverloaded\b/i,
+      /\bservice unavailable\b/i,
+    ],
+    [
+      /\b(cancelled|canceled|aborted|interrupted)\b/i,
+      /\brun\s*\/login\b/i,
+      /\bmissing api key\b/i,
+      /\bno valid authentication\b/i,
+      /\bunknown option\b/i,
+      /\bfailed to load\b/i,
+      /\bcannot find module\b/i,
+      /\bno such file or directory\b/i,
+    ]
+  );
+}
+
+export const ompAdapter: ProviderAdapter = {
+  id: 'omp',
+  displayName: 'OMP',
+  binary: 'omp',
+  adapterVersion: '1',
+  credentialEnvKeys: [],
+  modelCatalog: MODEL_CATALOG,
+  levelMapping: LEVEL_MAPPING,
+  defaultLevel: 'level2',
+  defaultMaxLevel: 'level3',
+  defaultMinLevel: 'level1',
+  detectCliFeatures,
+  buildCommand,
+  parseEvent,
+  createParserState: createOmpState,
+  resolveModelSpec,
+  validateModelId,
+  classifyError,
+};