@the-open-engine/zeroshot 6.4.0 → 6.5.0

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

@@ -0,0 +1,166 @@
+// Copilot `--output-format json` emits JSONL; payload under `data`, dot-namespaced `type` (verified
+// v1.0.69). Unknown types are ignored (fail-open). Mapping:
+//   assistant.message_delta/message → text, or thinking when phase==='commentary' (final answer is
+//     the result text). assistant.reasoning → thinking. tool.execution_start → tool_call.
+//   tool.execution_complete → tool_result. result → terminal (success = top-level exitCode === 0).
+import { getBoolean, getNumber, getRecord, getString, isRecord, tryParseJson } from '../json';
+import type { OutputEvent, ProviderParseResult, ProviderParserState } from '../types';
+
+const IGNORED_TYPES = new Set([
+  'user.message',
+  'assistant.turn_start',
+  'assistant.turn_end',
+  'assistant.idle',
+  'assistant.tool_call_delta',
+  'tool.execution_partial_result',
+]);
+
+function messageTextMap(state: ProviderParserState): Map<string, string> {
+  if (!state.assistantTextByMessageId) state.assistantTextByMessageId = new Map();
+  return state.assistantTextByMessageId;
+}
+
+function messagePhaseMap(state: ProviderParserState): Map<string, string> {
+  if (!state.messagePhaseById) state.messagePhaseById = new Map();
+  return state.messagePhaseById;
+}
+
+// `commentary` = the model narrating its plan (thinking); anything else is user-facing output.
+function isCommentaryPhase(phase: string | null | undefined): boolean {
+  return phase === 'commentary';
+}
+
+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 accrueOutputTokens(state: ProviderParserState, data: Record<string, unknown>): void {
+  const tokens = getNumber(data, 'outputTokens');
+  if (tokens === null) return;
+  const usage = state.usage ?? {};
+  state.usage = { ...usage, outputTokens: (usage.outputTokens ?? 0) + tokens };
+}
+
+function parseMessageStart(data: Record<string, unknown>, state: ProviderParserState): null {
+  const messageId = getString(data, 'messageId');
+  if (messageId === null) return null;
+  messageTextMap(state).set(messageId, '');
+  const phase = getString(data, 'phase');
+  if (phase !== null) messagePhaseMap(state).set(messageId, phase);
+  return null;
+}
+
+function parseMessageDelta(
+  data: Record<string, unknown>,
+  state: ProviderParserState
+): OutputEvent | null {
+  const delta = getString(data, 'deltaContent');
+  if (!delta) return null;
+  const messageId = getString(data, 'messageId') ?? '';
+  const map = messageTextMap(state);
+  map.set(messageId, (map.get(messageId) ?? '') + delta);
+  const commentary = isCommentaryPhase(messagePhaseMap(state).get(messageId));
+  return commentary ? { type: 'thinking', text: delta } : { type: 'text', text: delta };
+}
+
+function parseMessage(
+  data: Record<string, unknown>,
+  state: ProviderParserState
+): OutputEvent | null {
+  const content = getString(data, 'content') ?? '';
+  accrueOutputTokens(state, data);
+  const messageId = getString(data, 'messageId') ?? '';
+  const map = messageTextMap(state);
+  const delta = snapshotDelta(map.get(messageId) ?? '', content);
+  map.set(messageId, content);
+  const commentary = isCommentaryPhase(getString(data, 'phase') ?? messagePhaseMap(state).get(messageId));
+  // Only the final answer (not commentary narration) is the run's result text.
+  if (content && !commentary) state.lastAssistantText = content;
+  if (!delta) return null;
+  return commentary ? { type: 'thinking', text: delta } : { type: 'text', text: delta };
+}
+
+function parseReasoning(data: Record<string, unknown>): OutputEvent | null {
+  const text = getString(data, 'content');
+  return text ? { type: 'thinking', text } : null;
+}
+
+function parseToolExecutionStart(
+  data: Record<string, unknown>,
+  state: ProviderParserState
+): OutputEvent {
+  const toolId = getString(data, 'toolCallId');
+  state.lastToolId = toolId;
+  return {
+    type: 'tool_call',
+    toolName: getString(data, 'toolName'),
+    toolId,
+    input: Object.prototype.hasOwnProperty.call(data, 'arguments') ? data.arguments : {},
+  };
+}
+
+function toolResultContent(data: Record<string, unknown>): unknown {
+  const result = getRecord(data, 'result');
+  if (result !== null) return result.content ?? result.detailedContent ?? '';
+  return data.result ?? '';
+}
+
+function parseToolExecutionComplete(
+  data: Record<string, unknown>,
+  state: ProviderParserState
+): OutputEvent {
+  const success = getBoolean(data, 'success');
+  return {
+    type: 'tool_result',
+    toolId: getString(data, 'toolCallId') ?? state.lastToolId,
+    content: toolResultContent(data),
+    isError: success === false,
+  };
+}
+
+function parseResult(event: Record<string, unknown>, state: ProviderParserState): OutputEvent {
+  const exitCode = getNumber(event, 'exitCode') ?? 0;
+  const success = exitCode === 0;
+  const usage = state.usage ?? {};
+  return {
+    type: 'result',
+    success,
+    result: success ? (state.lastAssistantText ?? null) : null,
+    error: success ? null : `Copilot exited with code ${exitCode}`,
+    inputTokens: usage.inputTokens ?? 0,
+    outputTokens: usage.outputTokens ?? 0,
+    cacheReadInputTokens: usage.cacheReadInputTokens ?? 0,
+    cacheCreationInputTokens: usage.cacheCreationInputTokens ?? 0,
+  };
+}
+
+export function parseCopilotEvent(line: string, state: ProviderParserState): ProviderParseResult {
+  const event = tryParseJson(line);
+  if (!isRecord(event)) return null;
+
+  const type = getString(event, 'type');
+  if (type === null || type.startsWith('session.') || IGNORED_TYPES.has(type)) return null;
+
+  if (type === 'result') return parseResult(event, state);
+
+  const data = getRecord(event, 'data') ?? {};
+  switch (type) {
+    case 'assistant.message_start':
+      return parseMessageStart(data, state);
+    case 'assistant.message_delta':
+      return parseMessageDelta(data, state);
+    case 'assistant.message':
+      return parseMessage(data, state);
+    case 'assistant.reasoning':
+      return parseReasoning(data);
+    case 'tool.execution_start':
+      return parseToolExecutionStart(data, state);
+    case 'tool.execution_complete':
+      return parseToolExecutionComplete(data, state);
+    default:
+      return null;
+  }
+}

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

@@ -0,0 +1,231 @@
+import { appendJsonSchemaPrompt } from '../schema';
+import { unknownToMessage } from '../json';
+import {
+  type BuildProviderCommandOptions,
+  type CommandSpec,
+  type CopilotCliFeatures,
+  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,
+  warning,
+} from './common';
+import { parseCopilotEvent } from './copilot-parser';
+import type { ProviderParserState } from '../types';
+
+// Empty catalog: Copilot's models are plan-dependent, so modelLevel is a no-op (uses Copilot's
+// default). Pin a model via the `model` field or COPILOT_MODEL.
+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 },
+};
+
+function createCopilotState(): ProviderParserState {
+  return {
+    ...createParserState('copilot'),
+    lastAssistantText: '',
+    messagePhaseById: new Map(),
+    assistantTextByMessageId: new Map(),
+    usage: { outputTokens: 0 },
+  };
+}
+
+function supports(help: string, pattern: RegExp): boolean {
+  return help ? pattern.test(help) : true;
+}
+
+function detectCliFeatures(helpText?: string | null): CopilotCliFeatures {
+  const help = helpText ?? '';
+  const unknown = !help;
+  return {
+    provider: 'copilot',
+    supportsJsonOutput: supports(help, /--output-format\b/),
+    supportsModel: supports(help, /--model\b/),
+    supportsAllowAll: supports(help, /--allow-all\b/),
+    supportsNoAskUser: supports(help, /--no-ask-user\b/),
+    supportsAddDir: supports(help, /--add-dir\b/),
+    supportsMcpConfig: supports(help, /--additional-mcp-config\b/),
+    unknown,
+  };
+}
+
+function addOutputArgs(args: string[], options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (
+    (options.outputFormat === 'json' || options.outputFormat === 'stream-json') &&
+    features.supportsJsonOutput !== false
+  ) {
+    args.push('--output-format', 'json');
+  }
+}
+
+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 addAddDirArgs(args: string[], options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (options.cwd && features.supportsAddDir !== false) {
+    args.push('--add-dir', options.cwd);
+  }
+}
+
+function addAutoApproveArgs(args: string[], options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (!options.autoApprove) return;
+  if (features.supportsAllowAll !== false) args.push('--allow-all');
+  if (features.supportsNoAskUser !== false) args.push('--no-ask-user');
+}
+
+// Copilot consumes MCP servers via the `--additional-mcp-config` CLI flag (each value augments the
+// session config from ~/.copilot/mcp-config.json). Unlike Claude — which reads a `.mcp.json` file
+// overlaid into its config dir — Copilot's config lives under $HOME/.copilot, unreachable by the
+// worktree overlay, so the CLI flag is the only delivery path. Copilot and Claude share the same
+// `{"mcpServers": {...}}` envelope, so entries are forwarded verbatim (inline JSON string or
+// `@<path>`) with no translation.
+function addMcpArgs(args: string[], options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (!options.mcpConfig || options.mcpConfig.length === 0) return;
+  if (features.supportsMcpConfig === false) return;
+  for (const entry of options.mcpConfig) {
+    args.push('--additional-mcp-config', entry);
+  }
+}
+
+function collectWarnings(options: BuildProviderCommandOptions): WarningMetadata[] {
+  const features = optionFeatures(options);
+  const warnings: WarningMetadata[] = unsupportedSessionControlWarnings('copilot', options);
+
+  if (options.jsonSchema) {
+    warnings.push(
+      warning(
+        'copilot',
+        'copilot-jsonschema',
+        'Copilot CLI does not support provider-native JSON schema; appending schema instructions to the prompt.'
+      )
+    );
+  }
+  if (options.autoApprove && features.supportsAllowAll === false) {
+    warnings.push(
+      warning(
+        'copilot',
+        'copilot-auto-approve',
+        'Copilot CLI does not advertise --allow-all; continuing without the tool auto-approve flag.'
+      )
+    );
+  }
+  if (options.mcpConfig && options.mcpConfig.length > 0 && features.supportsMcpConfig === false) {
+    warnings.push(
+      warning(
+        'copilot',
+        'copilot-mcp-config',
+        'Copilot CLI does not advertise --additional-mcp-config; ignoring the requested MCP server config.'
+      )
+    );
+  }
+  return warnings;
+}
+
+function buildCommand(context: string, options: BuildProviderCommandOptions = {}): CommandSpec {
+  const finalContext = options.jsonSchema
+    ? appendJsonSchemaPrompt(context, options.jsonSchema)
+    : context;
+  const args: string[] = [];
+
+  addOutputArgs(args, options);
+  addModelArgs(args, options);
+  addAddDirArgs(args, options);
+  addAutoApproveArgs(args, options);
+  addMcpArgs(args, options);
+  args.push('-p', finalContext);
+
+  return commandSpec({
+    binary: 'copilot',
+    args,
+    env: {},
+    ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+    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 {
+  if (modelId === undefined || modelId === null) return modelId;
+  if (typeof modelId !== 'string') {
+    throw new Error(`Invalid model "${unknownToMessage(modelId)}" for provider "copilot".`);
+  }
+  return modelId;
+}
+
+function classifyError(error: unknown): ErrorClassification {
+  return classifyBaseProviderError(
+    error,
+    [
+      /\brate(?:[_ -]?limit| limited)\b/i,
+      /\b429\b/,
+      /\boverloaded\b/i,
+      /\bservice unavailable\b/i,
+      /\b503\b/,
+      /\btemporar(?:y|ily)\b/i,
+      /\btimeout\b/i,
+    ],
+    [
+      /\bunauthorized\b/i,
+      /\bforbidden\b/i,
+      /\bbad credentials\b/i,
+      /\bauthentication\b/i,
+      /\binvalid token\b/i,
+      /\b(GH_TOKEN|GITHUB_TOKEN|COPILOT_GITHUB_TOKEN)\b/,
+      /\bquota\b/i,
+      /\b(cancelled|canceled|aborted|interrupted)\b/i,
+      /\bunknown option\b/i,
+    ]
+  );
+}
+
+export const copilotAdapter: ProviderAdapter = {
+  id: 'copilot',
+  displayName: 'Copilot',
+  binary: 'copilot',
+  adapterVersion: '1',
+  credentialEnvKeys: ['COPILOT_GITHUB_TOKEN', 'GH_TOKEN', 'GITHUB_TOKEN'],
+  modelCatalog: MODEL_CATALOG,
+  levelMapping: LEVEL_MAPPING,
+  defaultLevel: 'level2',
+  defaultMaxLevel: 'level3',
+  defaultMinLevel: 'level1',
+  detectCliFeatures,
+  buildCommand,
+  parseEvent: parseCopilotEvent,
+  createParserState: createCopilotState,
+  resolveModelSpec,
+  validateModelId,
+  classifyError,
+};

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

@@ -0,0 +1,186 @@
+import path from 'node:path';
+import {
+  type BuildProviderCommandOptions,
+  type CommandSpec,
+  type ErrorClassification,
+  type GatewayCliFeatures,
+  type LevelModelSpec,
+  type LevelOverrides,
+  type ModelCatalogEntry,
+  type ModelLevel,
+  type OutputEvent,
+  type ProviderAdapter,
+  type ProviderParserState,
+  type ResolvedModelSpec,
+  InvalidProviderModelError,
+} from '../types';
+import { classifyBaseProviderError, commandSpec, createParserState, envRedactions } from './common';
+import { resolveGatewayConfiguration, validateGatewaySettings } from '../gateway-tools';
+import { getBoolean, getString, isRecord, tryParseJson } from '../json';
+
+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 },
+};
+
+export const gatewaySettingsDefaults: Readonly<Record<string, unknown>> = Object.freeze({
+  baseUrl: null,
+  apiKey: null,
+  headers: null,
+  model: null,
+  toolPolicy: null,
+});
+
+export { validateGatewaySettings };
+
+function detectCliFeatures(): GatewayCliFeatures {
+  return {
+    provider: 'gateway',
+    supportsBundledRunner: true,
+    unknown: false,
+  };
+}
+
+function buildCommand(context: string, options: BuildProviderCommandOptions = {}): CommandSpec {
+  const cwd = options.cwd ?? process.cwd();
+  const gateway = resolveGatewayConfiguration(options.gateway, 'options.gateway', cwd);
+  const headerEnv = buildGatewayHeaderEnv(gateway.headers);
+  const request = {
+    context,
+    cwd,
+    gateway: {
+      baseUrl: gateway.baseUrl,
+      model: gateway.model,
+      toolPolicy: gateway.toolPolicy,
+    },
+    ...(Object.keys(headerEnv.mapping).length === 0 ? {} : { gatewayHeaderEnv: headerEnv.mapping }),
+  };
+  const env = {
+    ZEROSHOT_GATEWAY_REQUEST: JSON.stringify(request),
+    ZEROSHOT_GATEWAY_API_KEY: gateway.apiKey,
+    ...headerEnv.values,
+  };
+
+  return commandSpec({
+    binary: process.execPath,
+    args: [gatewayRunnerPath()],
+    env,
+    ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+    redactions: envRedactions(env),
+  });
+}
+
+function gatewayRunnerPath(): string {
+  return path.resolve(__dirname, '..', 'gateway-runner.js');
+}
+
+function buildGatewayHeaderEnv(headers: Readonly<Record<string, string>>): {
+  readonly mapping: Readonly<Record<string, string>>;
+  readonly values: Readonly<Record<string, string>>;
+} {
+  const mapping: Record<string, string> = {};
+  const values: Record<string, string> = {};
+  let index = 0;
+  for (const [name, value] of Object.entries(headers)) {
+    const envKey = `ZEROSHOT_GATEWAY_HEADER_${index}`;
+    index += 1;
+    mapping[name] = envKey;
+    values[envKey] = value;
+  }
+  return { mapping, values };
+}
+
+function parseEvent(line: string, _state: ProviderParserState): OutputEvent | null {
+  const parsed = tryParseJson(line);
+  if (!isRecord(parsed)) return null;
+  const type = getString(parsed, 'type');
+  if (type === 'text') {
+    const text = getString(parsed, 'text');
+    return text === null ? null : { type: 'text', text };
+  }
+  if (type === 'tool_call') {
+    if (!Object.prototype.hasOwnProperty.call(parsed, 'toolName')) return null;
+    return {
+      type: 'tool_call',
+      toolName: getString(parsed, 'toolName'),
+      toolId: getString(parsed, 'toolId'),
+      input: parsed.input ?? null,
+    };
+  }
+  if (type === 'tool_result') {
+    if (!Object.prototype.hasOwnProperty.call(parsed, 'content')) return null;
+    return {
+      type: 'tool_result',
+      toolId: getString(parsed, 'toolId'),
+      content: parsed.content ?? null,
+      isError: getBoolean(parsed, 'isError') ?? false,
+    };
+  }
+  if (type === 'result') {
+    return {
+      type: 'result',
+      success: getBoolean(parsed, 'success') ?? false,
+      ...(Object.prototype.hasOwnProperty.call(parsed, 'result') ? { result: parsed.result } : {}),
+      ...(Object.prototype.hasOwnProperty.call(parsed, 'error') ? { error: parsed.error } : {}),
+    };
+  }
+  return null;
+}
+
+function resolveModelSpec(level: ModelLevel, overrides?: LevelOverrides): ResolvedModelSpec {
+  const override = overrides?.[level];
+  return {
+    level,
+    model: override?.model ?? null,
+    reasoningEffort: override?.reasoningEffort,
+  };
+}
+
+function validateModelId(modelId: string | null | undefined): string | null | undefined {
+  if (modelId === undefined || modelId === null) return modelId;
+  const normalized = modelId.trim();
+  if (normalized) return normalized;
+  throw new InvalidProviderModelError(
+    'Invalid model "" for provider "gateway". Use a non-empty model identifier.'
+  );
+}
+
+function classifyError(error: unknown): ErrorClassification {
+  return classifyBaseProviderError(
+    error,
+    [/rate[_ -]?limit/i, /\b429\b/i, /\b5\d{2}\b/, /\btimed out\b/i],
+    [
+      /invalid[_ -]?api[_ -]?key/i,
+      /\bunauthorized\b/i,
+      /\bforbidden\b/i,
+      /\bmodel not found\b/i,
+      /\bmust be a valid url\b/i,
+      /\btoolpolicy\b/i,
+      /\bnon-empty model identifier\b/i,
+      /\bgateway\.(?:baseUrl|apiKey|model|toolPolicy)\b/i,
+    ]
+  );
+}
+
+export const gatewayAdapter: ProviderAdapter = {
+  id: 'gateway',
+  displayName: 'Gateway',
+  binary: process.execPath,
+  adapterVersion: '1',
+  credentialEnvKeys: ['ZEROSHOT_GATEWAY_API_KEY'],
+  modelCatalog: MODEL_CATALOG,
+  levelMapping: LEVEL_MAPPING,
+  defaultLevel: 'level2',
+  defaultMaxLevel: 'level3',
+  defaultMinLevel: 'level1',
+  detectCliFeatures,
+  buildCommand,
+  parseEvent,
+  createParserState: () => createParserState('gateway'),
+  resolveModelSpec,
+  validateModelId,
+  classifyError,
+};

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

@@ -103,7 +103,7 @@ function buildCommand(context: string, options: BuildProviderCommandOptions = {}
   return commandSpec({
     binary: 'gemini',
     args,
-    env: {},
+    env: { GEMINI_CLI_TRUST_WORKSPACE: 'true' },
     ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
     warnings: collectGeminiWarnings(options),
   });
@@ -218,7 +218,14 @@ function classifyError(error: unknown): ErrorClassification {
       /No capacity available/i,
       /quota.?exceeded/i,
     ],
-    [/\bINVALID_ARGUMENT\b/i, /\bPERMISSION_DENIED\b/i, /\bNOT_FOUND\b/i]
+    [
+      /\bINVALID_ARGUMENT\b/i,
+      /\bPERMISSION_DENIED\b/i,
+      /\bNOT_FOUND\b/i,
+      /\bIneligibleTierError\b/i,
+      /\bUNSUPPORTED_CLIENT\b/i,
+      /\bno longer supported\b/i,
+    ]
   );
 }
 

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

@@ -1,4 +1,5 @@
 import { stripTimestampPrefix } from '../log-prefix';
+import { getProviderRegistryEntry, normalizeProviderName, providerIds } from '../provider-registry';
 import type {
   BuildProviderCommandOptions,
   CommandSpec,
@@ -11,7 +12,6 @@ import type {
   ProviderId,
   ResolvedModelSpec,
 } from '../types';
-import { claudeAdapter } from './claude';
 export {
   NO_MESSAGES_RETURNED,
   STREAMING_MODE_ERROR,
@@ -22,18 +22,6 @@ export {
   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[]
@@ -41,41 +29,22 @@ function isOutputEventArray(
   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];
+  return getProviderRegistryEntry(provider).adapter;
 }
 
 function isProviderId(name: string): name is ProviderId {
-  return name === 'claude' || name === 'codex' || name === 'gemini' || name === 'opencode';
+  return (providerIds as readonly string[]).includes(name);
 }
 
 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(', ')}`);
+  throw new Error(`Unknown provider: ${name}. Valid: ${providerIds.join(', ')}`);
 }
 
 export function listProviderAdapters(): readonly ProviderId[] {
-  return PROVIDER_IDS;
+  return providerIds;
 }
 
 export function buildProviderCommand(