@the-open-engine/zeroshot 6.4.0 → 6.5.0

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

@@ -84,6 +84,7 @@ function detectCliFeatures(helpText?: string | null): OpencodeCliFeatures {
     supportsJson: unknown ? true : /--format\b/.test(help),
     supportsModel: unknown ? true : /--model\b/.test(help),
     supportsVariant: unknown ? true : /--variant\b/.test(help),
+    supportsDir: unknown ? false : /--dir\b/.test(help),
     supportsCwd: unknown ? false : /--cwd\b/.test(help),
     supportsAutoApprove: false,
     unknown,
@@ -107,7 +108,9 @@ function addOpencodeOptionalArgs(args: string[], options: BuildProviderCommandOp
     args.push('--variant', options.modelSpec.reasoningEffort);
   }
 
-  if (options.cwd && features.supportsCwd) {
+  if (options.cwd && features.supportsDir) {
+    args.push('--dir', options.cwd);
+  } else if (options.cwd && features.supportsCwd) {
     args.push('--cwd', options.cwd);
   }
 }

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

@@ -0,0 +1,410 @@
+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 OutputEvent,
+  type PiCliFeatures,
+  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 },
+  level2: { rank: 2, model: null },
+  level3: { rank: 3, model: null },
+};
+
+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): PiCliFeatures {
+  const help = helpText ?? '';
+  const unknown = !help;
+  return {
+    provider: 'pi',
+    supportsJsonMode: unknown ? true : /--mode\b/.test(help) && /\bjson\b/.test(help),
+    supportsModel: unknown ? true : /--model\b/.test(help),
+    supportsNoSession: unknown ? true : /--no-session\b/.test(help),
+    supportsNoExtensions: unknown ? true : /--no-extensions\b/.test(help),
+    supportsNoSkills: unknown ? true : /--no-skills\b/.test(help),
+    supportsNoPromptTemplates: unknown ? true : /--no-prompt-templates\b/.test(help),
+    supportsNoContextFiles: unknown ? true : /--no-context-files\b/.test(help),
+    supportsNoApprove: unknown ? true : /--no-approve\b/.test(help),
+    unknown,
+  };
+}
+
+function addRequiredArgs(args: string[], options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (features.supportsJsonMode !== false) args.push('--mode', 'json');
+  if (features.supportsNoSession !== false) args.push('--no-session');
+  if (features.supportsNoExtensions !== false) args.push('--no-extensions');
+  if (features.supportsNoSkills !== false) args.push('--no-skills');
+  if (features.supportsNoPromptTemplates !== false) args.push('--no-prompt-templates');
+  if (features.supportsNoContextFiles !== false) args.push('--no-context-files');
+  if (features.supportsNoApprove !== false) args.push('--no-approve');
+}
+
+function addOptionalArgs(args: string[], options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (options.modelSpec?.model && features.supportsModel !== false) {
+    args.push('--model', options.modelSpec.model);
+  }
+}
+
+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:
+      'Pi CLI does not support resume/continue session control; fail closed and start a fresh run instead.',
+  });
+}
+
+function collectWarnings(options: BuildProviderCommandOptions): WarningMetadata[] {
+  const features = optionFeatures(options);
+  const warnings: WarningMetadata[] = [];
+
+  if (options.jsonSchema) {
+    warnings.push(
+      warning(
+        'pi',
+        'pi-jsonschema',
+        'Pi CLI does not support provider-native JSON schema; appending schema instructions to the prompt.'
+      )
+    );
+  }
+  if (features.supportsJsonMode === false) {
+    warnings.push(
+      warning('pi', 'pi-json-mode', 'Pi CLI does not advertise --mode json; continuing anyway.')
+    );
+  }
+  return warnings;
+}
+
+function buildCommand(context: string, options: BuildProviderCommandOptions = {}): CommandSpec {
+  failClosedUnsupportedSessionControl(options);
+  const finalContext = options.jsonSchema
+    ? appendJsonSchemaPrompt(context, options.jsonSchema)
+    : context;
+  const args: string[] = [];
+
+  addRequiredArgs(args, options);
+  addOptionalArgs(args, options);
+  args.push(finalContext);
+
+  return commandSpec({
+    binary: 'pi',
+    args,
+    env: {},
+    ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+    warnings: collectWarnings(options),
+  });
+}
+
+function createPiState(): ProviderParserState {
+  return {
+    ...createParserState('pi'),
+    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 ?? 'Pi 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 "pi".`);
+  }
+  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 piAdapter: ProviderAdapter = {
+  id: 'pi',
+  displayName: 'Pi',
+  binary: 'pi',
+  adapterVersion: '1',
+  credentialEnvKeys: [],
+  modelCatalog: MODEL_CATALOG,
+  levelMapping: LEVEL_MAPPING,
+  defaultLevel: 'level2',
+  defaultMaxLevel: 'level3',
+  defaultMinLevel: 'level1',
+  detectCliFeatures,
+  buildCommand,
+  parseEvent,
+  createParserState: createPiState,
+  resolveModelSpec,
+  validateModelId,
+  classifyError,
+};

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

@@ -0,0 +1,47 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+function settingsFilePath(): string {
+  return process.env.ZEROSHOT_SETTINGS_FILE || join(homedir(), '.zeroshot', 'settings.json');
+}
+
+export function readConfiguredClaudeCommand(): string {
+  if (process.env.ZEROSHOT_CLAUDE_COMMAND?.trim()) {
+    return process.env.ZEROSHOT_CLAUDE_COMMAND;
+  }
+
+  const settingsPath = settingsFilePath();
+  if (!existsSync(settingsPath)) return 'claude';
+
+  try {
+    const settings: unknown = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    if (
+      settings !== null &&
+      typeof settings === 'object' &&
+      'claudeCommand' in settings &&
+      typeof settings.claudeCommand === 'string' &&
+      settings.claudeCommand.trim()
+    ) {
+      return settings.claudeCommand;
+    }
+  } catch {
+    return 'claude';
+  }
+
+  return 'claude';
+}
+
+export function resolveClaudeCommand(): {
+  readonly command: string;
+  readonly args: readonly string[];
+} {
+  const parts = readConfiguredClaudeCommand()
+    .trim()
+    .split(/\s+/)
+    .filter((part) => part.length > 0);
+  return {
+    command: parts[0] ?? 'claude',
+    args: parts.slice(1),
+  };
+}

package/src/agent-cli-provider/contract-actions.ts

@@ -15,8 +15,9 @@ import {
   schemaMode,
   type RequestData,
 } from './contract-support';
-import { detectRuntimeProviderCliFeatures } from './single-agent-runtime';
-import { getNumber, getRecord, getString, isRecord, unknownToMessage } from './json';
+import { extractErrorStatus } from './errors';
+import { probeRuntimeProviderCli } from './single-agent-runtime';
+import { getString, isRecord, unknownToMessage } from './json';
 import type { ErrorClassification } from './types';
 import type { ProcessRunner } from './process-runner';
 
@@ -42,8 +43,11 @@ function runBuildCommand(request: RequestData): ContractEnvelope {
 function runProbe(request: RequestData): ContractEnvelope {
   const adapter = adapterForProvider(request.provider);
   const helpText = typeof request.raw.helpText === 'string' ? request.raw.helpText : null;
+  const runtimeProbe = helpText === null ? probeRuntimeProviderCli(adapter.id) : null;
   const capabilities =
-    helpText === null ? detectRuntimeProviderCliFeatures(adapter.id) : adapter.detectCliFeatures(helpText);
+    runtimeProbe === null
+      ? adapter.detectCliFeatures(helpText)
+      : runtimeProbe.capabilities;
   return successEnvelope({
     command: request.command ?? 'probe',
     adapter,
@@ -56,6 +60,9 @@ function runProbe(request: RequestData): ContractEnvelope {
       },
       contractVersion: providerExecutableSchemaVersion,
       adapterVersion: adapter.adapterVersion,
+      available: runtimeProbe?.available ?? true,
+      helpText: runtimeProbe?.helpText ?? helpText,
+      versionText: runtimeProbe?.versionText ?? null,
       capabilities,
       credentials: adapter.credentialEnvKeys.map((key) => ({
         key,
@@ -65,24 +72,14 @@ function runProbe(request: RequestData): ContractEnvelope {
   });
 }
 
-function statusFromError(error: unknown): number | null {
-  if (!isRecord(error)) return null;
-  const directStatus = getNumber(error, 'status') ?? getNumber(error, 'statusCode');
-  if (directStatus !== null) return directStatus;
-
-  const response = getRecord(error, 'response');
-  if (response === null) return null;
-  return getNumber(response, 'status') ?? getNumber(response, 'statusCode');
-}
-
 function categoryForClassification(classification: ErrorClassification, error: unknown): string {
-  const status = statusFromError(error);
+  const status = extractErrorStatus(error);
   if (status === 401 || status === 403) return 'auth';
   if (status === 429) return 'rate-limit';
   const message = unknownToMessage(error);
   if (/auth|api[_ -]?key|unauthorized|forbidden|permission/i.test(message)) return 'auth';
   if (/rate|429|quota|resource_exhausted/i.test(message)) return 'rate-limit';
-  if (/schema|json|parse|format/i.test(message)) return 'schema';
+  if (/schema|json|parse|format|malformed/i.test(message)) return 'schema';
   return classification.retryable ? 'retryable' : 'permanent';
 }
 
@@ -90,10 +87,10 @@ function errorEvidence(error: unknown): ContractEvidence {
   const evidence: Record<string, unknown> = {
     message: unknownToMessage(error),
   };
+  const status = extractErrorStatus(error);
+  if (status !== null) evidence.status = status;
   if (isRecord(error)) {
-    const status = statusFromError(error);
     const code = getString(error, 'code');
-    if (status !== null) evidence.status = status;
     if (code !== null) evidence.code = code;
   }
   return evidence;

package/src/agent-cli-provider/contract-invoke.ts

@@ -1,10 +1,13 @@
 import { unlink } from 'node:fs/promises';
+import { buildAcpPrompt } from './adapters/acp';
+import { runAcpStdioPrompt } from './acp-stdio-runner';
 import { commandRedactions } from './contract-env';
 import { successEnvelope, type ContractEnvelope } from './contract-envelope';
 import { buildCommandSpec, optionalNumber, schemaMode, type RequestData } from './contract-support';
 import { providerFailureClassification } from './invoke-evidence';
 import { parseOutputEvents } from './contract-parse';
 import { unknownToMessage } from './json';
+import { getProviderRegistryEntry } from './provider-registry';
 import type { CommandSpec } from './types';
 import type { ProcessResult, ProcessRunner, ProcessRunnerOptions } from './process-runner';
 
@@ -51,10 +54,16 @@ export async function runInvoke(
   request: RequestData,
   runner: ProcessRunner
 ): Promise<ContractEnvelope> {
-  const { adapter, commandSpec, options } = buildCommandSpec(request);
+  const { adapter, commandSpec, context, options } = buildCommandSpec(request);
   const timeoutMs = optionalNumber(request.raw, 'timeoutMs');
   const runnerOptions = timeoutMs === undefined ? {} : { timeoutMs };
-  const { result, cleanup } = await runAndCleanup(commandSpec, runner, runnerOptions);
+  const invokeSpec = getProviderRegistryEntry(adapter.id).invoke;
+  const invokeRunner =
+    invokeSpec.lane === 'acp-stdio'
+      ? (spec: CommandSpec, invokeOptions?: ProcessRunnerOptions): Promise<ProcessResult> =>
+          runAcpStdioPrompt(adapter.id, spec, buildAcpPrompt(context, options), invokeOptions)
+      : runner;
+  const { result, cleanup } = await runAndCleanup(commandSpec, invokeRunner, runnerOptions);
   const parsed = parseOutputEvents(adapter, {
     chunk: [result.stdout, result.stderr].join('\n'),
     sources: [
@@ -62,7 +71,7 @@ export async function runInvoke(
       { name: 'stderr', value: result.stderr },
     ],
   });
-  const classification = providerFailureClassification(adapter, result);
+  const classification = providerFailureClassification(adapter, result, parsed.events);
   return successEnvelope({
     command: request.command ?? 'invoke',
     adapter,