@the-open-engine/zeroshot 6.22.0 → 6.23.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

@@ -8,7 +8,7 @@ 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_INSTALL_COMMAND } from './omp-release';
 import type { ModelLevel, ProviderAdapter, StructuredOutputRecoveryAdapter } from './types';
 
 export type ProviderCapabilityState = boolean | 'experimental';
@@ -44,7 +44,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;
 
@@ -146,6 +154,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',
@@ -428,22 +440,29 @@ 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 stays worktree-only until Subissue 6 flips dockerIsolation.
     capabilities: {
-      ...STANDARD_CAPABILITIES,
+      dockerIsolation: false,
+      worktreeIsolation: true,
       mcpServers: false,
       jsonSchema: false,
+      streamJson: true,
+      thinkingMode: true,
       reasoningEffort: true,
+      sessionResume: false,
+      webSearch: false,
     },
     docs: {
       label: 'OMP',

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;