@the-open-engine/zeroshot 6.22.0 → 6.24.0

package/src/agent-cli-provider/omp-rpc-events.ts

@@ -0,0 +1,318 @@
+import { OmpRpcProtocolError, type OmpRpcInboundFrame } from './omp-rpc-protocol';
+import { MAX_NORMALIZED_OUTPUT_BYTES } from './omp-rpc-bounds';
+import {
+  getArray,
+  getBoolean,
+  getNumber,
+  getOptionalString,
+  getRecord,
+  getString,
+  isRecord,
+  stringifyContent,
+  tryParseJson,
+} from './json';
+import type { OutputEvent, ProviderParseResult, ProviderParserState } from './types';
+
+export interface OmpRpcEventState {
+  lastAssistantText: string;
+  lastAssistantThinking: string;
+  lastToolId: string | null | undefined;
+  normalizedBytes: number;
+}
+
+export function createOmpRpcEventState(): OmpRpcEventState {
+  return {
+    lastAssistantText: '',
+    lastAssistantThinking: '',
+    lastToolId: undefined,
+    normalizedBytes: 0,
+  };
+}
+
+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 || previous === current) return null;
+  if (current.startsWith(previous)) return current.slice(previous.length) || null;
+  return current;
+}
+
+function chargeBytes(state: OmpRpcEventState, value: unknown): void {
+  const byteLength = Buffer.byteLength(stringifyContent(value), 'utf8');
+  state.normalizedBytes += byteLength;
+  if (state.normalizedBytes > MAX_NORMALIZED_OUTPUT_BYTES) {
+    throw new OmpRpcProtocolError(
+      'output-bound-exceeded',
+      `Normalized OMP RPC output exceeded the ${MAX_NORMALIZED_OUTPUT_BYTES}-byte cap for this task.`
+    );
+  }
+}
+
+function emitText(state: OmpRpcEventState, text: string): OutputEvent {
+  chargeBytes(state, text);
+  return { type: 'text', text };
+}
+
+function emitThinking(state: OmpRpcEventState, text: string): OutputEvent {
+  chargeBytes(state, text);
+  return { type: 'thinking', text };
+}
+
+function normalizeMessageStart(
+  frame: OmpRpcInboundFrame,
+  state: OmpRpcEventState
+): readonly OutputEvent[] {
+  const message = getRecord(frame, 'message');
+  if (message !== null && getString(message, 'role') === 'assistant') {
+    state.lastAssistantText = '';
+    state.lastAssistantThinking = '';
+  }
+  return [];
+}
+
+function normalizeAssistantMessageEvent(
+  event: Record<string, unknown>,
+  state: OmpRpcEventState
+): readonly OutputEvent[] {
+  const type = getString(event, 'type');
+  if (type === 'text_delta') {
+    const delta = getString(event, 'delta');
+    if (!delta) return [];
+    state.lastAssistantText += delta;
+    return [emitText(state, delta)];
+  }
+  if (type === 'thinking_delta') {
+    const delta = getString(event, 'delta');
+    if (!delta) return [];
+    state.lastAssistantThinking += delta;
+    return [emitThinking(state, delta)];
+  }
+  return [];
+}
+
+function normalizeMessageSnapshot(
+  message: Record<string, unknown>,
+  state: OmpRpcEventState
+): readonly OutputEvent[] {
+  const snapshot = assistantSnapshot(message);
+  const events: OutputEvent[] = [];
+
+  const textDelta = snapshotDelta(state.lastAssistantText, snapshot.text);
+  if (textDelta) events.push(emitText(state, textDelta));
+  if (snapshot.text) state.lastAssistantText = snapshot.text;
+
+  const thinkingDelta = snapshotDelta(state.lastAssistantThinking, snapshot.thinking);
+  if (thinkingDelta) events.push(emitThinking(state, thinkingDelta));
+  if (snapshot.thinking) state.lastAssistantThinking = snapshot.thinking;
+
+  return events;
+}
+
+function normalizeMessageUpdate(
+  frame: OmpRpcInboundFrame,
+  state: OmpRpcEventState
+): readonly OutputEvent[] {
+  const assistantMessageEvent = getRecord(frame, 'assistantMessageEvent');
+  if (assistantMessageEvent !== null) {
+    const events = normalizeAssistantMessageEvent(assistantMessageEvent, state);
+    if (events.length > 0) return events;
+  }
+  const message = getRecord(frame, 'message');
+  return message === null ? [] : normalizeMessageSnapshot(message, state);
+}
+
+function normalizeMessageEnd(
+  frame: OmpRpcInboundFrame,
+  state: OmpRpcEventState
+): readonly OutputEvent[] {
+  const message = getRecord(frame, 'message');
+  return message === null ? [] : normalizeMessageSnapshot(message, state);
+}
+
+function normalizeToolExecutionStart(
+  frame: OmpRpcInboundFrame,
+  state: OmpRpcEventState
+): readonly OutputEvent[] {
+  const toolId = getOptionalString(frame, 'toolCallId');
+  state.lastToolId = toolId;
+  const input = frame.args ?? {};
+  chargeBytes(state, input);
+  return [
+    {
+      type: 'tool_call',
+      toolName: getOptionalString(frame, 'toolName'),
+      toolId,
+      input,
+    },
+  ];
+}
+
+function normalizeToolExecutionUpdate(
+  frame: OmpRpcInboundFrame,
+  state: OmpRpcEventState
+): readonly OutputEvent[] {
+  const toolId = getOptionalString(frame, 'toolCallId') ?? state.lastToolId;
+  if (toolId !== undefined) state.lastToolId = toolId;
+  if (!Object.prototype.hasOwnProperty.call(frame, 'partialResult')) return [];
+  chargeBytes(state, frame.partialResult);
+  return [
+    {
+      type: 'tool_result',
+      toolId,
+      content: frame.partialResult,
+      isError: false,
+    },
+  ];
+}
+
+function normalizeToolExecutionEnd(
+  frame: OmpRpcInboundFrame,
+  state: OmpRpcEventState
+): readonly OutputEvent[] {
+  const toolId = getOptionalString(frame, 'toolCallId') ?? state.lastToolId;
+  const content = frame.result ?? '';
+  chargeBytes(state, content);
+  return [
+    {
+      type: 'tool_result',
+      toolId,
+      content,
+      isError: getBoolean(frame, 'isError') ?? false,
+    },
+  ];
+}
+
+function normalizeTurnEnd(
+  frame: OmpRpcInboundFrame,
+  state: OmpRpcEventState
+): readonly OutputEvent[] {
+  const message = getRecord(frame, 'message');
+  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;
+  const result = success ? snapshot.text || state.lastAssistantText || null : null;
+  chargeBytes(state, { result, error: errorMessage ?? stopReason ?? null });
+  return [
+    {
+      type: 'result',
+      success,
+      result,
+      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,
+    },
+  ];
+}
+
+/**
+ * Normalize one decoded OMP RPC v2 event frame into zero or more OutputEvents. Only the frame
+ * types below produce output; every other known-pre-negotiation frame (agent_start/agent_end,
+ * turn_start, ready, response, session_info_update, subagent_*, ...) is protocol/control plumbing
+ * the driver consumes directly and must never leak into log/attach/ledger output.
+ */
+export function normalizeOmpRpcFrame(
+  frame: OmpRpcInboundFrame,
+  state: OmpRpcEventState
+): readonly OutputEvent[] {
+  switch (frame.type) {
+    case 'message_start':
+      return normalizeMessageStart(frame, state);
+    case 'message_update':
+      return normalizeMessageUpdate(frame, state);
+    case 'message_end':
+      return normalizeMessageEnd(frame, state);
+    case 'tool_execution_start':
+      return normalizeToolExecutionStart(frame, state);
+    case 'tool_execution_update':
+      return normalizeToolExecutionUpdate(frame, state);
+    case 'tool_execution_end':
+      return normalizeToolExecutionEnd(frame, state);
+    case 'turn_end':
+      return normalizeTurnEnd(frame, state);
+    default:
+      return [];
+  }
+}
+
+/**
+ * Parse one line of the rpc-stdio lane's already-normalized OutputEvent JSON stream (produced
+ * from `OmpRpcTaskResult.events` by `contract-invoke.ts` / `rpc-watcher.js`). This is the
+ * `ProviderAdapter.parseEvent` counterpart to `normalizeOmpRpcFrame` above: the driver normalizes
+ * raw RPC frames to OutputEvent once, and this function is a validating passthrough over that
+ * already-normalized shape so generic log/attach tooling built on `adapter.parseEvent` keeps
+ * working for the omp provider without re-deriving events from raw frames. Each case rebuilds a
+ * literal matching its OutputEvent variant instead of casting the parsed record, so an
+ * unexpectedly-shaped line fails closed (returns null) rather than passing through untyped.
+ */
+export function parseNormalizedOmpRpcEventLine(
+  line: string,
+  _state: ProviderParserState
+): ProviderParseResult {
+  const parsed = tryParseJson(line);
+  if (!isRecord(parsed)) return null;
+  switch (parsed.type) {
+    case 'text':
+    case 'thinking': {
+      const text = getString(parsed, 'text');
+      return text === null ? null : { type: parsed.type, text };
+    }
+    case 'tool_call':
+      return {
+        type: 'tool_call',
+        toolName: getOptionalString(parsed, 'toolName'),
+        toolId: getOptionalString(parsed, 'toolId'),
+        input: parsed.input,
+      };
+    case 'tool_result':
+      return {
+        type: 'tool_result',
+        toolId: getOptionalString(parsed, 'toolId'),
+        content: parsed.content,
+        isError: parsed.isError,
+      };
+    case 'result': {
+      if (typeof parsed.success !== 'boolean') return null;
+      const inputTokens = getNumber(parsed, 'inputTokens');
+      const outputTokens = getNumber(parsed, 'outputTokens');
+      const cacheReadInputTokens = getNumber(parsed, 'cacheReadInputTokens');
+      const cacheCreationInputTokens = getNumber(parsed, 'cacheCreationInputTokens');
+      return {
+        type: 'result',
+        success: parsed.success,
+        result: parsed.result,
+        error: parsed.error,
+        cost: parsed.cost,
+        duration: parsed.duration,
+        ...(inputTokens === null ? {} : { inputTokens }),
+        ...(outputTokens === null ? {} : { outputTokens }),
+        ...(cacheReadInputTokens === null ? {} : { cacheReadInputTokens }),
+        ...(cacheCreationInputTokens === null ? {} : { cacheCreationInputTokens }),
+        modelUsage: parsed.modelUsage,
+      };
+    }
+    default:
+      return null;
+  }
+}

package/src/agent-cli-provider/omp-rpc-protocol.ts

@@ -218,7 +218,11 @@ export class OmpRpcFrameDecoder {
     this.inflightReassemblyBytes = 0;
   }
 
-  push(chunk: Uint8Array): readonly OmpRpcInboundFrame[] {
+  // `negotiatedV2` defaults to true so callers that don't care about pre-negotiation gating
+  // (e.g. the fixture-replay tests below) see unchanged behavior; the RPC driver passes its
+  // live negotiation state so a bare `rpc_chunk` physical frame is rejected before negotiation
+  // succeeds, even though the decoder would otherwise buffer it silently pending reassembly.
+  push(chunk: Uint8Array, negotiatedV2 = true): readonly OmpRpcInboundFrame[] {
     if (this.finished) {
       throw new OmpRpcProtocolError('decoder-finished', 'push() called after finish().');
     }
@@ -247,7 +251,7 @@ export class OmpRpcFrameDecoder {
         );
       }
 
-      const frame = this.consumeLine(lineBytes);
+      const frame = this.consumeLine(lineBytes, negotiatedV2);
       if (frame !== null) frames.push(frame);
     }
 
@@ -270,7 +274,7 @@ export class OmpRpcFrameDecoder {
     }
   }
 
-  private consumeLine(lineBytes: Buffer): OmpRpcInboundFrame | null {
+  private consumeLine(lineBytes: Buffer, negotiatedV2: boolean): OmpRpcInboundFrame | null {
     let value: unknown;
     try {
       value = JSON.parse(lineBytes.toString('utf8'));
@@ -285,6 +289,7 @@ export class OmpRpcFrameDecoder {
     }
 
     const type = getString(value, 'type');
+    assertNoPreNegotiationRpcChunk(type ?? '', negotiatedV2);
     if (type !== 'rpc_chunk') {
       if (this.pendingReassemblies.size > 0) {
         throw new OmpRpcProtocolError(

package/src/agent-cli-provider/omp-rpc-session.ts

@@ -0,0 +1,20 @@
+// Session-launch types for the OMP RPC v2 driver. This slice launches sessionless
+// (`--no-session`) only; `fresh`/`resume` are typed for Subissue 4's session-flag activation but
+// are unreachable from any caller in this slice.
+
+export interface VerifiedOmpPartition {
+  readonly path: string;
+}
+
+export interface VerifiedOmpSessionFile {
+  readonly path: string;
+}
+
+export type OmpSessionLaunch =
+  | { readonly kind: 'none' }
+  | { readonly kind: 'fresh'; readonly partition: VerifiedOmpPartition }
+  | {
+      readonly kind: 'resume';
+      readonly partition: VerifiedOmpPartition;
+      readonly file: VerifiedOmpSessionFile;
+    };

package/src/agent-cli-provider/provider-registry.ts

@@ -2,13 +2,22 @@ import { createAcpAdapter } from './adapters/acp';
 import { claudeAdapter } from './adapters/claude';
 import { codexAdapter } from './adapters/codex';
 import { copilotAdapter } from './adapters/copilot';
-import { gatewayAdapter, gatewaySettingsDefaults, validateGatewaySettings } from './adapters/gateway';
+import {
+  gatewayAdapter,
+  gatewaySettingsDefaults,
+  validateGatewaySettings,
+} from './adapters/gateway';
 import { geminiAdapter } from './adapters/gemini';
 import { opencodeAdapter } from './adapters/opencode';
 import { ompAdapter } from './adapters/omp';
 import { piAdapter } from './adapters/pi';
 import { resolveClaudeCommand } from './claude-command';
-import { OMP_INSTALL_COMMAND } from './omp-release';
+import {
+  OMP_AUTH_INSTRUCTIONS,
+  OMP_DOCKER_INSTALL_COMMAND,
+  OMP_DOCKER_PLATFORM,
+  OMP_INSTALL_COMMAND,
+} from './omp-release';
 import type { ModelLevel, ProviderAdapter, StructuredOutputRecoveryAdapter } from './types';
 
 export type ProviderCapabilityState = boolean | 'experimental';
@@ -44,7 +53,15 @@ export interface AcpStdioProviderInvokeSpec {
   readonly transport: 'stdio';
 }
 
-export type ProviderInvokeSpec = SpawnProviderInvokeSpec | AcpStdioProviderInvokeSpec;
+export interface RpcStdioProviderInvokeSpec {
+  readonly lane: 'rpc-stdio';
+  readonly protocol: 'omp-v2';
+}
+
+export type ProviderInvokeSpec =
+  | SpawnProviderInvokeSpec
+  | AcpStdioProviderInvokeSpec
+  | RpcStdioProviderInvokeSpec;
 
 export type ProviderCommandSpec = FixedProviderCommandSpec | ConfiguredClaudeCommandSpec;
 
@@ -59,8 +76,24 @@ export interface ProviderDockerMountPreset {
   readonly readonly: boolean;
 }
 
+export interface ProviderDockerEnvAuth {
+  // At least one of these env vars must carry a usable (non-empty, non-whitespace) value for the
+  // effective container plan to be considered automatically authenticated. This is the AUTOMATIC
+  // allowlist only; a registry-known credential outside it is accepted when — and only when — the
+  // user explicitly opted it in (dockerEnvPassthrough / --mount).
+  // Providers with no `mount` (env-only) fail closed when nothing is satisfied.
+  readonly requireOneOf: readonly string[];
+  // Each inner group must be all-set-or-all-unset (e.g. a broker URL + token pair); a partial
+  // group is treated as malformed auth, not "missing".
+  readonly requireTogether?: readonly (readonly string[])[];
+  // Env vars whose value must parse as an absolute http(s) URL to count as set. A non-URL value
+  // is malformed auth, not "missing".
+  readonly requireUrl?: readonly string[];
+}
+
 export interface ProviderDockerMetadata {
-  readonly mount: ProviderDockerMountPreset;
+  // Omitted for env-only providers with zero automatic credential mounts (e.g. omp).
+  readonly mount?: ProviderDockerMountPreset;
   readonly envPassthrough: readonly string[];
   // False when the mounted dir doesn't hold the secret (auth is via an envPassthrough token).
   readonly credentialInMount?: boolean;
@@ -68,6 +101,14 @@ export interface ProviderDockerMetadata {
   // a docker-cached build layer for the per-provider image variant. Omit for providers already
   // baked into the base image (e.g. Claude) or not installable via a single command.
   readonly install?: string;
+  // Docker platform (e.g. 'linux/amd64') passed to both image build and container run. Omitted
+  // providers keep today's unset (host-native) behavior.
+  readonly platform?: string;
+  // $HOME-placeholder directories created owner-only inside the container for this provider's
+  // config/session state (never mounted/copied from the host).
+  readonly configRoots?: readonly string[];
+  // Fail-closed env/broker auth requirement, checked against the effective container env plan.
+  readonly envAuth?: ProviderDockerEnvAuth;
 }
 
 interface ProviderRegistryEntryBase {
@@ -146,6 +187,10 @@ const ACP_STDIO_INVOKE = Object.freeze({
   lane: 'acp-stdio',
   transport: 'stdio',
 }) as AcpStdioProviderInvokeSpec;
+const RPC_STDIO_INVOKE = Object.freeze({
+  lane: 'rpc-stdio',
+  protocol: 'omp-v2',
+}) as RpcStdioProviderInvokeSpec;
 
 const kiroAdapter = createAcpAdapter({
   provider: 'kiro',
@@ -393,8 +438,7 @@ export const providerRegistry = [
     binary: 'pi',
     command: { kind: 'fixed', command: 'pi', args: [] },
     invoke: SPAWN_INVOKE,
-    installInstructions:
-      'npm install -g --ignore-scripts @earendil-works/pi-coding-agent@0.80.3',
+    installInstructions: 'npm install -g --ignore-scripts @earendil-works/pi-coding-agent@0.80.3',
     authInstructions: 'pi\n/login',
     credentialPaths: ['~/.pi'],
     credentialEnvKeys: piAdapter.credentialEnvKeys,
@@ -428,34 +472,79 @@ export const providerRegistry = [
   {
     id: 'omp',
     default: false,
-    aliases: [],
-    displayName: 'OMP',
+    aliases: ['oh-my-pi'],
+    displayName: 'OMP (Oh My Pi)',
     binary: 'omp',
     command: { kind: 'fixed', command: 'omp', args: [] },
-    invoke: SPAWN_INVOKE,
+    invoke: RPC_STDIO_INVOKE,
     installInstructions: OMP_INSTALL_COMMAND,
-    authInstructions: 'omp\n/login',
+    authInstructions: OMP_AUTH_INSTRUCTIONS,
     credentialPaths: ['~/.omp'],
     credentialEnvKeys: ompAdapter.credentialEnvKeys,
     settingsFields: [],
     availabilityProbe: 'help-or-version',
+    // Written out explicitly rather than spread from STANDARD_CAPABILITIES, which defaults
+    // dockerIsolation to true; OMP's Docker path is env/broker-only and sessionless (see
+    // AGENTS.md OMP Docker section) rather than the standard credential-mount + resume shape.
     capabilities: {
-      ...STANDARD_CAPABILITIES,
+      dockerIsolation: true,
+      worktreeIsolation: true,
       mcpServers: false,
       jsonSchema: false,
+      streamJson: true,
+      thinkingMode: true,
       reasoningEffort: true,
+      sessionResume: false,
+      webSearch: false,
     },
     docs: {
       label: 'OMP',
       setupHeading: 'OMP Setup',
     },
     docker: {
-      mount: {
-        host: '~/.omp',
-        container: '$HOME/.omp',
-        readonly: true,
+      // No `mount`: OMP's Docker credential surface is env/broker-only with zero automatic
+      // mounts. `~/.omp`, agent.db, WAL/SHM files, and host refresh tokens are never mounted or
+      // copied into the container.
+      //
+      // envPassthrough is deliberately narrower than `credentialEnvKeys` above (the full adapter
+      // credential inventory, used for host inspection/redaction). Exact 5-name automatic
+      // allowlist per the maintainer's authoritative clarification (verified verbatim via
+      // `gh api repos/the-open-engine/zeroshot/issues/comments/5160272623`): "the exact automatic
+      // OMP Docker environment allowlist is only ANTHROPIC_API_KEY, OPENAI_API_KEY,
+      // GEMINI_API_KEY, OMP_AUTH_BROKER_URL, and OMP_AUTH_BROKER_TOKEN ... ANTHROPIC_OAUTH_TOKEN,
+      // ANTHROPIC_FOUNDRY_API_KEY, GOOGLE_API_KEY, OPENROUTER_API_KEY, and every other
+      // credential/path require explicit dockerEnvPassthrough/mount opt-in; OAuth users should
+      // prefer the auth broker so host refresh/access tokens do not cross automatically." This
+      // supersedes PLAN_READY step 2's nine-name list. Any validator flagging this as missing the
+      // four excluded names is checking stale plan text against a clarification it never read.
+      platform: OMP_DOCKER_PLATFORM,
+      install: OMP_DOCKER_INSTALL_COMMAND,
+      configRoots: ['$HOME/.omp'],
+      credentialInMount: false,
+      envPassthrough: [
+        'ANTHROPIC_API_KEY',
+        'GEMINI_API_KEY',
+        'OMP_AUTH_BROKER_TOKEN',
+        'OMP_AUTH_BROKER_URL',
+        'OPENAI_API_KEY',
+      ],
+      envAuth: {
+        // The four automatic *credential* names (the fifth allowlist entry, OMP_AUTH_BROKER_URL,
+        // is a locator, not a credential — it authenticates nothing on its own). Any other
+        // registry-known OMP credential (ANTHROPIC_OAUTH_TOKEN, OPENROUTER_API_KEY, …) is usable
+        // only via explicit dockerEnvPassthrough/--mount opt-in, never automatic forwarding.
+        requireOneOf: [
+          'ANTHROPIC_API_KEY',
+          'GEMINI_API_KEY',
+          'OMP_AUTH_BROKER_TOKEN',
+          'OPENAI_API_KEY',
+        ],
+        requireTogether: [['OMP_AUTH_BROKER_URL', 'OMP_AUTH_BROKER_TOKEN']],
+        // Per OMP v17.2.1 docs/environment-variables.md, OMP_AUTH_BROKER_URL is the broker's base
+        // URL (e.g. https://broker.tailnet:8765); anything that is not an http(s) URL is
+        // malformed broker config, and OMP hard-errors on a broker URL with no resolvable token.
+        requireUrl: ['OMP_AUTH_BROKER_URL'],
       },
-      envPassthrough: [],
     },
     defaultLevels: {
       min: ompAdapter.defaultMinLevel,
@@ -559,12 +648,16 @@ function validateWebSearchSettings(
 type RegistryProviderId = (typeof providerRegistry)[number]['id'];
 type RegistryProviderAlias = (typeof providerRegistry)[number]['aliases'][number];
 
-export const providerIds = providerRegistry.map((entry) => entry.id) as readonly RegistryProviderId[];
-export const providerAliases = providerRegistry.flatMap((entry) => entry.aliases) as readonly RegistryProviderAlias[];
-export const knownProviderNames = providerRegistry.flatMap((entry) => [entry.id, ...entry.aliases]) as readonly (
-  | RegistryProviderId
-  | RegistryProviderAlias
-)[];
+export const providerIds = providerRegistry.map(
+  (entry) => entry.id
+) as readonly RegistryProviderId[];
+export const providerAliases = providerRegistry.flatMap(
+  (entry) => entry.aliases
+) as readonly RegistryProviderAlias[];
+export const knownProviderNames = providerRegistry.flatMap((entry) => [
+  entry.id,
+  ...entry.aliases,
+]) as readonly (RegistryProviderId | RegistryProviderAlias)[];
 
 export const providerAliasMap: Readonly<Record<string, RegistryProviderId>> = Object.freeze(
   providerRegistry.reduce<Record<string, RegistryProviderId>>((result, entry) => {
@@ -602,7 +695,9 @@ export function listProviderRegistryEntries(): readonly ProviderRegistryEntry[]
   return providerRegistry;
 }
 
-export function findProviderRegistryEntry(name: string | null | undefined): ProviderRegistryEntry | undefined {
+export function findProviderRegistryEntry(
+  name: string | null | undefined
+): ProviderRegistryEntry | undefined {
   if (!name) return undefined;
   const normalized = normalizeProviderName(name);
   return providerRegistry.find((entry) => entry.id === normalized);

package/src/agent-cli-provider/types.ts

@@ -168,16 +168,16 @@ export interface PiCliFeatures extends BaseCliFeatures {
 
 export interface OmpCliFeatures extends BaseCliFeatures {
   readonly provider: 'omp';
-  readonly supportsModeJson: boolean;
-  readonly supportsPrint: boolean;
-  readonly supportsCwd: boolean;
-  readonly supportsAutoApprove: boolean;
+  readonly supportsRpcMode: boolean;
+  readonly supportsConfig: boolean;
   readonly supportsModel: boolean;
   readonly supportsThinking: boolean;
-  readonly supportsNoExtensions: boolean;
-  readonly supportsNoSkills: boolean;
-  readonly supportsNoRules: boolean;
+  readonly supportsApprovalMode: boolean;
   readonly supportsNoTitle: boolean;
+  readonly supportsNoSession: boolean;
+  readonly supportsSessionDir: boolean;
+  readonly supportsResume: boolean;
+  readonly versionMatches: boolean;
 }
 
 export interface CopilotCliFeatures extends BaseCliFeatures {
@@ -256,11 +256,13 @@ export interface CliFeatureOverrides {
   readonly supportsRecoveryIsolation?: boolean;
   readonly supportsNoContextFiles?: boolean;
   readonly supportsNoApprove?: boolean;
-  readonly supportsModeJson?: boolean;
-  readonly supportsPrint?: boolean;
+  readonly supportsRpcMode?: boolean;
+  readonly supportsConfig?: boolean;
   readonly supportsThinking?: boolean;
-  readonly supportsNoRules?: boolean;
+  readonly supportsApprovalMode?: boolean;
   readonly supportsNoTitle?: boolean;
+  readonly supportsSessionDir?: boolean;
+  readonly versionMatches?: boolean;
   readonly supportsJsonOutput?: boolean;
   readonly supportsAllowAll?: boolean;
   readonly supportsNoAskUser?: boolean;
@@ -412,7 +414,8 @@ export type ErrorClassificationKind =
   | 'code-retryable'
   | 'permanent-pattern'
   | 'retryable-pattern'
-  | 'unknown-retryable';
+  | 'unknown-retryable'
+  | 'cancelled';
 
 export interface ErrorClassification {
   readonly retryable: boolean;