@the-open-engine/zeroshot 6.30.2 → 6.31.1

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

@@ -1,16 +1,21 @@
 import { buildAcpPrompt } from './adapters/acp';
 import { buildOmpPrompt } from './adapters/omp';
 import { runAcpStdioPrompt } from './acp-stdio-runner';
-import { runOmpRpcTask } from './omp-rpc-driver';
-import { ABORT_GRACE_MS, EXIT_GRACE_MS } from './omp-rpc-bounds';
-import { OMP_SUPPORTED_VERSION } from './omp-release';
+import { runOmpRpcTask } from './omp/rpc-driver';
+import { ABORT_GRACE_MS, EXIT_GRACE_MS } from './omp/rpc-bounds';
+import { OMP_SUPPORTED_VERSION } from './omp/release';
 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 { isRecord, unknownToMessage } from './json';
-import { getProviderRegistryEntry } from './provider-registry';
+import {
+  invokeEvidence,
+  isContractOmpSdkProcessResult,
+  ompSdkFailureClassification,
+} from './omp/sdk-contract';
+import { runOmpSdkProcess } from './omp/sdk-process-runner';
 import type { CommandSpec } from './types';
 import type { ProcessResult, ProcessRunner, ProcessRunnerOptions } from './process-runner';
 
@@ -123,27 +128,66 @@ export async function runInvoke(
   runner: ProcessRunner,
   runtimeSettings?: Record<string, unknown>
 ): Promise<ContractEnvelope> {
-  const { adapter, commandSpec, context, options } = buildCommandSpec(request, runtimeSettings);
+  const prepared = buildCommandSpec(request, runtimeSettings);
+  const { adapter, commandSpec, context, options } = prepared;
   const timeoutMs = optionalNumber(request.raw, 'timeoutMs');
   const runnerOptions = timeoutMs === undefined ? {} : { timeoutMs };
-  const invokeSpec = getProviderRegistryEntry(adapter.id).invoke;
-  const invokeRunner: ProcessRunner =
-    invokeSpec.lane === 'acp-stdio'
-      ? (spec: CommandSpec, invokeOptions?: ProcessRunnerOptions): Promise<ProcessResult> =>
-          runAcpStdioPrompt(adapter.id, spec, buildAcpPrompt(context, options), invokeOptions)
-      : invokeSpec.lane === 'rpc-stdio'
-        ? (spec: CommandSpec, invokeOptions?: ProcessRunnerOptions): Promise<ProcessResult> =>
-            runOmpRpcContractPrompt(spec, buildOmpPrompt(context, options), invokeOptions)
-        : runner;
-  const { result, cleanup } = await runAndCleanup(commandSpec, invokeRunner, runnerOptions);
-  const parsed = parseOutputEvents(adapter, {
-    chunk: [result.stdout, result.stderr].join('\n'),
-    sources: [
-      { name: 'stdout', value: result.stdout },
-      { name: 'stderr', value: result.stderr },
-    ],
-  });
-  const classification = providerFailureClassification(adapter, result, parsed.events);
+  let result: ProcessResult;
+  let cleanup: readonly CleanupResult[];
+  if (prepared.invoke.parser === 'omp-sdk-ndjson') {
+    const privateArtifacts = prepared.privateArtifacts;
+    if (privateArtifacts === undefined) {
+      throw new Error('OMP SDK prepared invocation is missing private artifact ownership.');
+    }
+    const sdkResult = await runOmpSdkProcess(prepared, runnerOptions);
+    result = sdkResult;
+    cleanup = [
+      {
+        path: privateArtifacts.root,
+        removed: sdkResult.cleanupAttestation.clean,
+      },
+    ];
+  } else {
+    let invokeRunner: ProcessRunner;
+    switch (prepared.invoke.lane) {
+      case 'spawn':
+        invokeRunner = runner;
+        break;
+      case 'acp-stdio':
+        invokeRunner = (
+          spec: CommandSpec,
+          invokeOptions?: ProcessRunnerOptions
+        ): Promise<ProcessResult> =>
+          runAcpStdioPrompt(adapter.id, spec, buildAcpPrompt(context, options), invokeOptions);
+        break;
+      case 'rpc-stdio':
+        invokeRunner = (
+          spec: CommandSpec,
+          invokeOptions?: ProcessRunnerOptions
+        ): Promise<ProcessResult> =>
+          runOmpRpcContractPrompt(spec, buildOmpPrompt(context, options), invokeOptions);
+        break;
+    }
+    ({ result, cleanup } = await runAndCleanup(commandSpec, invokeRunner, runnerOptions));
+  }
+  const sdkResult = isContractOmpSdkProcessResult(result) ? result : null;
+  const parsed =
+    sdkResult === null
+      ? parseOutputEvents(adapter, {
+          chunk: [result.stdout, result.stderr].join('\n'),
+          sources: [
+            { name: 'stdout', value: result.stdout },
+            { name: 'stderr', value: result.stderr },
+          ],
+        })
+      : {
+          events: sdkResult.terminal.type === 'result' ? [sdkResult.terminal.event] : [],
+          diagnostics: [],
+        };
+  const classification =
+    sdkResult === null
+      ? providerFailureClassification(adapter, result, parsed.events)
+      : ompSdkFailureClassification(sdkResult);
   return successEnvelope({
     command: request.command ?? 'invoke',
     adapter,
@@ -154,10 +198,16 @@ export async function runInvoke(
       commandSpec,
       outputFormat: options.outputFormat ?? null,
       schemaMode: schemaMode(options),
-      evidence: {
-        stdout: result.stdout,
-        stderr: result.stderr,
-      },
+      evidence:
+        sdkResult === null
+          ? { stdout: result.stdout, stderr: result.stderr }
+          : {
+              stdout: '',
+              stderr: sdkResult.diagnosticStderr,
+              terminal: sdkResult.terminal.frame,
+              progress: sdkResult.progress,
+              cleanupAttestation: sdkResult.cleanupAttestation,
+            },
       events: parsed.events,
       diagnostics: parsed.diagnostics,
       exitCode: result.exitCode,
@@ -170,16 +220,3 @@ export async function runInvoke(
     },
   });
 }
-
-function invokeEvidence(
-  result: ProcessResult,
-  timeoutMs: number | undefined
-): Record<string, unknown> {
-  return {
-    exitCode: result.exitCode,
-    signal: result.signal,
-    durationMs: result.durationMs,
-    timedOut: result.timedOut ?? false,
-    timeoutMs: result.timeoutMs ?? timeoutMs ?? null,
-  };
-}

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

@@ -1,8 +1,13 @@
+import * as fs from 'node:fs';
+
 import { getProviderAdapter } from './adapters';
 import { getString, isRecord, parseJson } from './json';
 import { mergeRedactions } from './redaction';
 import { requestOptions } from './contract-options';
-import { prepareSingleAgentProviderCommand } from './single-agent-runtime';
+import {
+  prepareSingleAgentProviderCommand,
+  type PreparedSingleAgentProviderCommand,
+} from './single-agent-runtime';
 import type { BuildProviderCommandOptions, CommandSpec, ProviderAdapter } from './types';
 export {
   contractError,
@@ -90,19 +95,60 @@ function findReservedCommandEnvKey(
 function buildOptions(request: RequestData): BuildProviderCommandOptions {
   const options = requestOptions(request.raw.options);
   const cwd = optionalString(request.raw, 'cwd');
-  if (cwd === undefined || options.cwd !== undefined) return options;
-  return { ...options, cwd };
+  const rawOptionExecutionContext = isRecord(request.raw.options)
+    ? request.raw.options.executionContext
+    : undefined;
+  if (
+    rawOptionExecutionContext !== undefined &&
+    typeof rawOptionExecutionContext !== 'string'
+  ) {
+    throw contractError({
+      code: 'invalid-field',
+      message:
+        'options.executionContext must be "host", "detached", "docker", or "benchmark".',
+      exitCode: 2,
+      field: 'options.executionContext',
+    });
+  }
+  const topLevelExecutionContext = optionalString(request.raw, 'executionContext');
+  const rawExecutionContext = rawOptionExecutionContext ?? topLevelExecutionContext;
+  let executionContext: BuildProviderCommandOptions['executionContext'];
+  if (
+    rawExecutionContext === undefined ||
+    rawExecutionContext === 'host' ||
+    rawExecutionContext === 'detached' ||
+    rawExecutionContext === 'docker' ||
+    rawExecutionContext === 'benchmark'
+  ) {
+    executionContext = rawExecutionContext;
+  } else {
+    throw contractError({
+      code: 'invalid-field',
+      message: `${
+        rawOptionExecutionContext === undefined ? 'executionContext' : 'options.executionContext'
+      } must be "host", "detached", "docker", or "benchmark".`,
+      exitCode: 2,
+      field:
+        rawOptionExecutionContext === undefined
+          ? 'executionContext'
+          : 'options.executionContext',
+    });
+  }
+  return {
+    ...options,
+    ...(cwd === undefined || options.cwd !== undefined ? {} : { cwd }),
+    ...(executionContext === undefined ? {} : { executionContext }),
+  };
+}
+
+export interface PreparedCommandSpec extends PreparedSingleAgentProviderCommand {
+  readonly context: string;
 }
 
 export function buildCommandSpec(
   request: RequestData,
   runtimeSettings?: Record<string, unknown>
-): {
-  readonly adapter: ProviderAdapter;
-  readonly commandSpec: CommandSpec;
-  readonly options: BuildProviderCommandOptions;
-  readonly context: string;
-} {
+): PreparedCommandSpec {
   const adapter = adapterForProvider(request.provider);
   const context = requiredString(request.raw, 'context');
   const options = buildOptions(request);
@@ -114,11 +160,36 @@ export function buildCommandSpec(
     },
     runtimeSettings
   );
+  if (prepared.invoke.parser === 'omp-sdk-ndjson' && Object.keys(request.env).length > 0) {
+    const privateRoot = prepared.privateArtifacts?.root;
+    if (privateRoot !== undefined) {
+      try {
+        fs.rmSync(privateRoot, { recursive: true, force: true });
+        if (fs.existsSync(privateRoot)) throw new Error('private root still exists');
+      } catch {
+        throw contractError({
+          code: 'invalid-request',
+          message: 'OMP SDK private request cleanup failed before spawn.',
+          exitCode: 1,
+          field: 'env',
+        });
+      }
+    }
+    throw contractError({
+      code: 'forbidden-field',
+      message:
+        'env is not accepted for OMP SDK requests; the final spawn owner resolves only credential names declared by providerSettings.omp.auth.',
+      exitCode: 2,
+      field: 'env',
+    });
+  }
   return {
-    adapter: prepared.adapter,
+    ...prepared,
     context,
-    options: prepared.options,
-    commandSpec: mergeCommandSpec(prepared.commandSpec, request.env),
+    commandSpec:
+      prepared.invoke.parser === 'omp-sdk-ndjson'
+        ? prepared.commandSpec
+        : mergeCommandSpec(prepared.commandSpec, request.env),
   };
 }
 

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

@@ -40,12 +40,20 @@ export {
   type OmpRpcTaskHooks,
   type OmpRpcTaskRequest,
   type OmpRpcTaskResult,
-} from './omp-rpc-driver';
+} from './omp/rpc-driver';
 export { buildOmpPrompt } from './adapters/omp';
-export { DEFAULT_OMP_RPC_DECODER_LIMITS } from './omp-rpc-protocol';
-export { ABORT_GRACE_MS, EXIT_GRACE_MS } from './omp-rpc-bounds';
-export { OMP_SUPPORTED_VERSION } from './omp-release';
-export type { OmpSessionLaunch, VerifiedOmpPartition, VerifiedOmpSessionFile } from './omp-rpc-session';
+export { DEFAULT_OMP_RPC_DECODER_LIMITS } from './omp/rpc-protocol';
+export { ABORT_GRACE_MS, EXIT_GRACE_MS } from './omp/rpc-bounds';
+export { OMP_SUPPORTED_VERSION } from './omp/release';
+export type { OmpSessionLaunch, VerifiedOmpPartition, VerifiedOmpSessionFile } from './omp/rpc-session';
+export {
+  OmpSdkProcessRunnerError,
+  runOmpSdkProcess,
+  spawnOmpSdkProcess,
+  type OmpSdkProcessResult,
+  type OmpSdkProcessRunnerOptions,
+  type OmpSdkRunningProcess,
+} from './omp/sdk-process-runner';
 export {
   detectRuntimeProviderCliFeatures,
   prepareSingleAgentProviderCommand,
@@ -69,6 +77,46 @@ export {
   supportsProviderCapability,
   supportsProviderOutputReformatting,
 } from './provider-registry';
+export {
+  createOmpSdkProtocolCollector,
+  decodeOmpSdkProtocolFrame,
+  decodeOmpSdkSidecarRequest,
+  normalizeOmpSdkResultFrame,
+  ompSdkOutputSchemaForRequest,
+  parseOmpSdkProtocolFrame,
+  parseOmpSdkSidecarRequest,
+  validateOmpSdkProtocolResultFrame,
+  OMP_SDK_BACKEND_VERSION,
+  OMP_SDK_BUN_VERSION,
+  OMP_SDK_ERROR_CODES,
+  OMP_SDK_MAX_FRAME_BYTES,
+  OMP_SDK_MAX_REQUEST_BYTES,
+  OMP_SDK_MAX_STDOUT_BYTES,
+  OMP_SDK_PROGRESS_STAGES,
+  OMP_SDK_PROTOCOL_VERSION,
+  OMP_SDK_TEXT_OUTPUT_SCHEMA,
+  OMP_SDK_TOOL_IDS,
+  type OmpSdkCollectedTerminal,
+  type OmpSdkErrorCategory,
+  type OmpSdkErrorCode,
+  type OmpSdkJsonSidecarRequest,
+  type OmpSdkModelsConfig,
+  type OmpSdkOutputMode,
+  type OmpSdkProgressStage,
+  type OmpSdkProtocolCollector,
+  type OmpSdkProtocolCollectorOptions,
+  type OmpSdkProtocolErrorFrame,
+  type OmpSdkProtocolFrame,
+  type OmpSdkProtocolProgressFrame,
+  type OmpSdkProtocolResultFrame,
+  type OmpSdkProtocolTerminalFrame,
+  type OmpSdkRequestAuth,
+  type OmpSdkSafeError,
+  type OmpSdkSidecarRequest,
+  type OmpSdkTextSidecarRequest,
+  type OmpSdkToolId,
+} from './omp/sdk-protocol';
+
 
 export type {
   AgentCliProviderHelperMetadata,
@@ -88,12 +136,19 @@ export type {
   GatewayToolPolicy,
   GeminiCliFeatures,
   KnownProviderName,
+  InvocationLane,
+  InvocationLaneMetadata,
   LevelModelSpec,
   LevelOverrides,
   ModelCatalogEntry,
   ModelLevel,
   ModelSpec,
   OmpCliFeatures,
+  OmpSdkRequestedIdentity,
+  OmpSdkResolvedIdentity,
+  OmpSdkStrictOutputEvidence,
+  OmpSdkTerminalEvidence,
+  OmpSdkUsageEvidence,
   OpencodeCliFeatures,
   OutputEvent,
   OutputFormat,

package/src/agent-cli-provider/omp/auth-policy.ts

@@ -0,0 +1,126 @@
+import { chmodSync, constants, copyFileSync, lstatSync } from 'node:fs';
+import { join } from 'node:path';
+
+export type OmpAuthStorageMode = 'environment' | 'broker' | 'none' | 'omp-home';
+
+interface ClosableAuthStorage {
+  close(): void;
+}
+
+interface BrokerCredentials {
+  readonly token?: string | undefined;
+  readonly url?: string | undefined;
+}
+
+interface OmpAuthStoragePolicyOptions<T extends ClosableAuthStorage> {
+  readonly mode: OmpAuthStorageMode;
+  readonly sourceDirectory?: unknown;
+  readonly privateAgentDirectory: string;
+  readonly privateDatabasePath: string;
+  readonly brokerCachePath: string;
+  readonly brokerCredentials?: BrokerCredentials;
+  readonly sourceLabel: string;
+  readonly createDatabase: (databasePath: string) => Promise<T>;
+  readonly discoverBroker: (
+    agentDirectory: string,
+    options: { cachePath: string; sourceLabel: string }
+  ) => Promise<T>;
+}
+
+
+/**
+ * Snapshot only OMP's credential database. Configuration, broker token, and
+ * other files in the source home are deliberately outside this policy.
+ */
+export function snapshotOmpAuthDatabase(
+  sourceDirectory: unknown,
+  privateDatabasePath: string
+): void {
+  if (typeof sourceDirectory !== 'string' || sourceDirectory.length === 0) {
+    throw new Error('OMP local auth source must be a non-empty directory path');
+  }
+  const sourceDatabasePath = join(sourceDirectory, 'agent.db');
+  let sourceStat;
+  try {
+    sourceStat = lstatSync(sourceDatabasePath);
+  } catch (error) {
+    const code =
+      error !== null &&
+      typeof error === 'object' &&
+      'code' in error &&
+      typeof error.code === 'string'
+        ? error.code
+        : undefined;
+    if (code === 'ENOENT') {
+      throw new Error(`OMP local auth source is missing agent.db at ${sourceDatabasePath}`);
+    }
+    throw error;
+  }
+  if (!sourceStat.isFile() || sourceStat.isSymbolicLink()) {
+    throw new Error(`OMP local auth source must be a regular agent.db file at ${sourceDatabasePath}`);
+  }
+  copyFileSync(sourceDatabasePath, privateDatabasePath, constants.COPYFILE_EXCL);
+  chmodSync(privateDatabasePath, 0o600);
+
+  for (const suffix of ['-wal', '-shm']) {
+    const sourceSidecar = `${sourceDatabasePath}${suffix}`;
+    const privateSidecar = `${privateDatabasePath}${suffix}`;
+    try {
+      const sidecarStat = lstatSync(sourceSidecar);
+      if (!sidecarStat.isFile() || sidecarStat.isSymbolicLink()) {
+        throw new Error(`OMP local auth source sidecar must be a regular file: ${sourceSidecar}`);
+      }
+      copyFileSync(sourceSidecar, privateSidecar, constants.COPYFILE_EXCL);
+      chmodSync(privateSidecar, 0o600);
+    } catch (error) {
+      const code =
+        error !== null &&
+        typeof error === 'object' &&
+        'code' in error &&
+        typeof error.code === 'string'
+          ? error.code
+          : undefined;
+      if (code !== 'ENOENT') throw error;
+    }
+  }
+}
+
+/** Open auth through one fail-closed policy shared by diagnostics and execution. */
+export async function openOmpAuthStorage<T extends ClosableAuthStorage>(
+  options: OmpAuthStoragePolicyOptions<T>
+): Promise<T> {
+  if (options.mode === 'omp-home') {
+    snapshotOmpAuthDatabase(options.sourceDirectory, options.privateDatabasePath);
+    return options.createDatabase(options.privateDatabasePath);
+  }
+  if (options.mode !== 'broker') {
+    return options.createDatabase(options.privateDatabasePath);
+  }
+
+  const url = options.brokerCredentials?.url;
+  const token = options.brokerCredentials?.token;
+  if (
+    typeof url !== 'string' ||
+    url.length === 0 ||
+    typeof token !== 'string' ||
+    token.length === 0
+  ) {
+    throw new Error('OMP broker credentials are missing');
+  }
+
+  const previousUrl = process.env.OMP_AUTH_BROKER_URL;
+  const previousToken = process.env.OMP_AUTH_BROKER_TOKEN;
+  process.env.OMP_AUTH_BROKER_URL = url;
+  process.env.OMP_AUTH_BROKER_TOKEN = token;
+  try {
+    return await options.discoverBroker(options.privateAgentDirectory, {
+      cachePath: options.brokerCachePath,
+      sourceLabel: options.sourceLabel,
+    });
+  } finally {
+    if (previousUrl === undefined) delete process.env.OMP_AUTH_BROKER_URL;
+    else process.env.OMP_AUTH_BROKER_URL = previousUrl;
+    if (previousToken === undefined) delete process.env.OMP_AUTH_BROKER_TOKEN;
+    else process.env.OMP_AUTH_BROKER_TOKEN = previousToken;
+  }
+}

package/src/agent-cli-provider/omp/rpc-driver-channel.ts

@@ -0,0 +1,144 @@
+import type { ChildProcessWithoutNullStreams } from 'node:child_process';
+
+import { MAX_LIFETIME_REQUEST_IDS, MAX_PENDING_REQUESTS } from './rpc-bounds';
+import {
+  DEFAULT_OMP_RPC_DECODER_LIMITS,
+  encodeOmpRpcCommand,
+  type OmpRpcCommand,
+  type OmpRpcInboundFrame,
+} from './rpc-protocol';
+import { getBoolean, getOptionalString, getString } from '../json';
+import { OmpRpcTaskFailure, UI_RESPONDERS, type DriverState } from './rpc-driver-state';
+
+export class OmpRpcChannel {
+  constructor(
+    private readonly child: ChildProcessWithoutNullStreams,
+    private readonly state: DriverState
+  ) {}
+
+  registerLifetimeId(id: string): boolean {
+    if (this.state.lifetimeRequestIds.has(id)) return true;
+    if (this.state.lifetimeRequestIds.size >= MAX_LIFETIME_REQUEST_IDS) return false;
+    this.state.lifetimeRequestIds.add(id);
+    return true;
+  }
+
+  writeFrame(frame: OmpRpcCommand): void {
+    if (this.child.stdin.destroyed) return;
+    try {
+      this.child.stdin.write(
+        encodeOmpRpcCommand(frame, DEFAULT_OMP_RPC_DECODER_LIMITS.maxPhysicalFrameBytes)
+      );
+    } catch {
+      // Stdin already closed; the close handler settles the task.
+    }
+  }
+
+  sendCommand(command: OmpRpcCommand): Promise<Record<string, unknown>> {
+    const id = command.id ?? '';
+    if (!this.registerLifetimeId(id)) {
+      return Promise.reject(
+        new OmpRpcTaskFailure(
+          'lifetime-request-id-exceeded',
+          `command id "${id}" exceeds the lifetime request-id bound.`
+        )
+      );
+    }
+    if (this.state.pending.size >= MAX_PENDING_REQUESTS) {
+      return Promise.reject(
+        new OmpRpcTaskFailure(
+          'pending-request-exceeded',
+          'too many concurrent outbound RPC commands are awaiting a response.'
+        )
+      );
+    }
+    return new Promise<Record<string, unknown>>((resolve, reject) => {
+      this.state.pending.set(id, { resolve, reject });
+      this.writeFrame(command);
+    });
+  }
+
+  assertSuccessfulResponse(response: Record<string, unknown>, command: string, id: string): void {
+    if (getString(response, 'command') !== command || getString(response, 'id') !== id) {
+      throw new OmpRpcTaskFailure(
+        'malformed-response',
+        `Expected a ${command} response with id "${id}".`
+      );
+    }
+    if (getBoolean(response, 'success') !== true) {
+      throw new OmpRpcTaskFailure(
+        'unsafe-config',
+        getString(response, 'error') ?? `${command} was rejected.`
+      );
+    }
+  }
+
+  handleResponse(frame: OmpRpcInboundFrame): void {
+    const id = getOptionalString(frame, 'id');
+    if (!id) return;
+    const command = this.state.pending.get(id);
+    if (command === undefined) return;
+    this.state.pending.delete(id);
+    command.resolve(frame);
+  }
+
+  handleExtensionUiRequest(frame: OmpRpcInboundFrame): void {
+    const id = getString(frame, 'id');
+    const method = getString(frame, 'method');
+    if (id === null || method === null) {
+      throw new OmpRpcTaskFailure(
+        'malformed-extension-ui-request',
+        'extension_ui_request is missing id/method.'
+      );
+    }
+    this.assertInboundId(id);
+    const responder = UI_RESPONDERS[method];
+    if (responder === undefined) {
+      throw new OmpRpcTaskFailure(
+        'unsupported-ui-method',
+        `extension_ui_request used unsupported method "${method}".`
+      );
+    }
+    this.writeFrame(responder(id));
+  }
+
+  handleHostToolCall(frame: OmpRpcInboundFrame): void {
+    const id = this.inboundId(frame, 'malformed-host-tool-call', 'host_tool_call is missing id.');
+    this.writeFrame({
+      type: 'host_tool_result',
+      id,
+      isError: true,
+      result: { content: [{ type: 'text', text: 'Zeroshot declares no host tools' }] },
+    });
+  }
+
+  handleHostUriRequest(frame: OmpRpcInboundFrame): void {
+    const id = this.inboundId(
+      frame,
+      'malformed-host-uri-request',
+      'host_uri_request is missing id.'
+    );
+    this.writeFrame({
+      type: 'host_uri_result',
+      id,
+      isError: true,
+      error: 'Zeroshot declares no host URI schemes',
+    });
+  }
+
+  private inboundId(frame: OmpRpcInboundFrame, code: string, message: string): string {
+    const id = getString(frame, 'id');
+    if (id === null) throw new OmpRpcTaskFailure(code, message);
+    this.assertInboundId(id);
+    return id;
+  }
+
+  private assertInboundId(id: string): void {
+    if (!this.registerLifetimeId(id)) {
+      throw new OmpRpcTaskFailure(
+        'lifetime-request-id-exceeded',
+        `inbound request id "${id}" exceeds the lifetime request-id bound.`
+      );
+    }
+  }
+}