@the-open-engine/zeroshot 6.15.0 → 6.17.0

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

@@ -1,3 +1,4 @@
+import { UnsupportedProviderCapabilityError } from '../errors';
 import { getString, isRecord, tryParseJson } from '../json';
 import { appendJsonSchemaPrompt, writeStrictOutputSchemaFile } from '../schema';
 import {
@@ -17,6 +18,7 @@ import {
   classifyBaseProviderError,
   commandSpec,
   createParserState,
+  isCliVersionAtLeast,
   optionFeatures,
   resolveModelSpecWithConfig,
   validateModelIdFromCatalog,
@@ -46,19 +48,25 @@ function supports(help: string, pattern: RegExp): boolean {
   return help ? pattern.test(help) : true;
 }
 
-function detectCliFeatures(helpText?: string | null): CodexCliFeatures {
+function detectCliFeatures(
+  helpText?: string | null,
+  versionText?: string | null
+): CodexCliFeatures {
   const help = helpText ?? '';
   const unknown = !help;
+  const supportsConfigOverride = supports(help, /--config\b/);
   return {
     provider: 'codex',
     supportsJson: supports(help, /--json\b/),
     supportsOutputSchema: supports(help, /--output-schema\b/),
     supportsAutoApprove: supports(help, /--dangerously-bypass-approvals-and-sandbox\b/),
     supportsCwd: supports(help, /\s-C\b/) || supports(help, /--cwd\b/),
-    supportsConfigOverride: supports(help, /--config\b/),
+    supportsConfigOverride,
     supportsModel: supports(help, /\s-m\b/) || supports(help, /--model\b/),
     supportsSkipGitRepoCheck: supports(help, /--skip-git-repo-check\b/),
     supportsResume: supports(help, /\bresume\b/),
+    supportsWebSearch:
+      !unknown && supportsConfigOverride && isCliVersionAtLeast(versionText, '0.146.0'),
     unknown,
   };
 }
@@ -178,6 +186,18 @@ function collectWarnings(options: BuildProviderCommandOptions): WarningMetadata[
   return warnings;
 }
 
+function addWebSearchArgs(args: string[], options: BuildProviderCommandOptions): void {
+  if (options.webSearch !== true) return;
+  if (optionFeatures(options).supportsWebSearch !== true) {
+    throw new UnsupportedProviderCapabilityError(
+      'codex',
+      'webSearch',
+      'Codex web search requires nonempty `codex exec --help` support for `--config` and a parseable Codex CLI version >= 0.146.0. Update @openai/codex or set providerSettings.codex.webSearch to false.'
+    );
+  }
+  args.push('--config', 'web_search="live"');
+}
+
 function buildCommand(context: string, options: BuildProviderCommandOptions = {}): CommandSpec {
   if (options.resumeSessionId && optionFeatures(options).supportsResume === false) {
     throw new Error(
@@ -190,6 +210,7 @@ function buildCommand(context: string, options: BuildProviderCommandOptions = {}
     options.resumeSessionId && optionFeatures(options).supportsResume !== false
       ? options.resumeSessionId
       : null;
+  addWebSearchArgs(args, options);
   if (resumeSessionId) {
     args.push('resume');
   }

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

@@ -123,3 +123,17 @@ export function optionFeatures(
 ): CliFeatureOverrides {
   return options?.cliFeatures ?? {};
 }
+
+export function isCliVersionAtLeast(versionText: string | null | undefined, floor: string): boolean {
+  const actualMatch = /(?:^|[^\w.])v?(\d+)\.(\d+)\.(\d+)(?![\w.-])/.exec(
+    versionText ?? ''
+  );
+  const floorMatch = /^(\d+)\.(\d+)\.(\d+)$/.exec(floor);
+  if (!actualMatch || !floorMatch) return false;
+  for (let index = 1; index <= 3; index += 1) {
+    const actual = Number(actualMatch[index]);
+    const minimum = Number(floorMatch[index]);
+    if (actual !== minimum) return actual > minimum;
+  }
+  return true;
+}

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

@@ -1,5 +1,11 @@
 import { stripTimestampPrefix } from '../log-prefix';
-import { getProviderRegistryEntry, normalizeProviderName, providerIds } from '../provider-registry';
+import { UnsupportedProviderCapabilityError } from '../errors';
+import {
+  getProviderRegistryEntry,
+  normalizeProviderName,
+  providerIds,
+  supportsProviderCapability,
+} from '../provider-registry';
 import type {
   BuildProviderCommandOptions,
   CommandSpec,
@@ -52,7 +58,15 @@ export function buildProviderCommand(
   context: string,
   options?: BuildProviderCommandOptions
 ): CommandSpec {
-  return getProviderAdapter(providerName).buildCommand(context, options);
+  const adapter = getProviderAdapter(providerName);
+  if (options?.webSearch !== undefined && !supportsProviderCapability(adapter.id, 'webSearch')) {
+    throw new UnsupportedProviderCapabilityError(
+      adapter.id,
+      'webSearch',
+      `Provider ${adapter.id} does not expose provider-controlled native web search; remove options.webSearch.`
+    );
+  }
+  return adapter.buildCommand(context, options);
 }
 
 export function parseProviderChunk(

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

@@ -0,0 +1,448 @@
+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 OmpCliFeatures,
+  type OutputEvent,
+  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, reasoningEffort: 'low' },
+  level2: { rank: 2, model: null, reasoningEffort: 'medium' },
+  level3: { rank: 3, model: null, reasoningEffort: 'high' },
+};
+
+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): OmpCliFeatures {
+  const help = helpText ?? '';
+  const unknown = !help;
+  return {
+    provider: 'omp',
+    supportsModeJson: unknown ? true : /--mode\b/.test(help) && /\bjson\b/.test(help),
+    supportsPrint: unknown ? true : /-p\b/.test(help) || /--print\b/.test(help),
+    supportsCwd: unknown ? true : /--cwd\b/.test(help),
+    supportsAutoApprove: unknown ? true : /--auto-approve\b/.test(help),
+    supportsModel: unknown ? true : /--model\b/.test(help),
+    supportsThinking: unknown ? true : /--thinking\b/.test(help),
+    supportsNoExtensions: unknown ? true : /--no-extensions\b/.test(help),
+    supportsNoSkills: unknown ? true : /--no-skills\b/.test(help),
+    supportsNoRules: unknown ? true : /--no-rules\b/.test(help),
+    supportsNoTitle: unknown ? true : /--no-title\b/.test(help),
+    unknown,
+  };
+}
+
+function assertRequiredOmpFeatures(options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  const required: ReadonlyArray<readonly [boolean | undefined, string]> = [
+    [features.supportsModeJson, '--mode json'],
+    [features.supportsPrint, '-p/--print'],
+    [features.supportsCwd, '--cwd'],
+    [features.supportsAutoApprove, '--auto-approve'],
+  ];
+  const missing = required.filter(([supported]) => supported === false).map(([, flag]) => flag);
+  if (missing.length === 0) return;
+  throw contractError({
+    code: 'unsupported-provider-cli',
+    exitCode: 2,
+    message:
+      'omp CLI is missing required non-interactive flag(s): ' +
+      missing.join(', ') +
+      '. Update/install @oh-my-pi/pi-coding-agent; Zeroshot will not silently fall back to Pi or another provider.',
+  });
+}
+
+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:
+      'OMP CLI does not support resume/continue session control; fail closed and start a fresh run instead.',
+  });
+}
+
+function addOptionalFlags(args: string[], options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (features.supportsNoExtensions !== false) args.push('--no-extensions');
+  if (features.supportsNoSkills !== false) args.push('--no-skills');
+  if (features.supportsNoRules !== false) args.push('--no-rules');
+  if (features.supportsNoTitle !== false) args.push('--no-title');
+}
+
+function addModelArgs(args: string[], options: BuildProviderCommandOptions): void {
+  const features = optionFeatures(options);
+  if (options.modelSpec?.model && features.supportsModel !== false) {
+    args.push('--model', options.modelSpec.model);
+  }
+  if (options.modelSpec?.reasoningEffort && features.supportsThinking !== false) {
+    args.push('--thinking', options.modelSpec.reasoningEffort);
+  }
+}
+
+function collectWarnings(options: BuildProviderCommandOptions): WarningMetadata[] {
+  const features = optionFeatures(options);
+  const warnings: WarningMetadata[] = [];
+
+  if (options.jsonSchema) {
+    warnings.push(
+      warning(
+        'omp',
+        'omp-jsonschema',
+        'OMP CLI does not support provider-native JSON schema; appending schema instructions to the prompt.'
+      )
+    );
+  }
+  if (options.modelSpec?.model && features.supportsModel === false) {
+    warnings.push(
+      warning(
+        'omp',
+        'omp-model-unsupported',
+        "OMP CLI does not advertise --model; continuing with OMP's own configured model."
+      )
+    );
+  }
+  if (options.modelSpec?.reasoningEffort && features.supportsThinking === false) {
+    warnings.push(
+      warning(
+        'omp',
+        'omp-thinking-unsupported',
+        'OMP CLI does not advertise --thinking; continuing without a reasoning-effort override.'
+      )
+    );
+  }
+  return warnings;
+}
+
+function buildCommand(context: string, options: BuildProviderCommandOptions = {}): CommandSpec {
+  assertRequiredOmpFeatures(options);
+  failClosedUnsupportedSessionControl(options);
+  const finalContext = options.jsonSchema
+    ? appendJsonSchemaPrompt(context, options.jsonSchema)
+    : context;
+  const args: string[] = ['--mode', 'json', '-p'];
+
+  if (options.cwd) args.push('--cwd', options.cwd);
+  args.push('--auto-approve');
+  addOptionalFlags(args, options);
+  addModelArgs(args, options);
+  args.push(finalContext);
+
+  return commandSpec({
+    binary: 'omp',
+    args,
+    env: {},
+    ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
+    warnings: collectWarnings(options),
+  });
+}
+
+function createOmpState(): ProviderParserState {
+  return {
+    ...createParserState('omp'),
+    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 ?? '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,
+  });
+  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 "omp".`);
+  }
+  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 ompAdapter: ProviderAdapter = {
+  id: 'omp',
+  displayName: 'OMP',
+  binary: 'omp',
+  adapterVersion: '1',
+  credentialEnvKeys: [],
+  modelCatalog: MODEL_CATALOG,
+  levelMapping: LEVEL_MAPPING,
+  defaultLevel: 'level2',
+  defaultMaxLevel: 'level3',
+  defaultMinLevel: 'level1',
+  detectCliFeatures,
+  buildCommand,
+  parseEvent,
+  createParserState: createOmpState,
+  resolveModelSpec,
+  validateModelId,
+  classifyError,
+};

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

@@ -1,3 +1,5 @@
+import { contractError } from '../contract-errors';
+import { UnsupportedProviderCapabilityError } from '../errors';
 import { appendJsonSchemaPrompt } from '../schema';
 import {
   getNumber,
@@ -20,8 +22,8 @@ import {
   classifyBaseProviderError,
   commandSpec,
   createParserState,
+  isCliVersionAtLeast,
   optionFeatures,
-  unsupportedSessionControlWarnings,
   warning,
 } from './common';
 import {
@@ -32,7 +34,10 @@ import {
   validateModelId,
 } from './opencode-models';
 
-function detectCliFeatures(helpText?: string | null): OpencodeCliFeatures {
+function detectCliFeatures(
+  helpText?: string | null,
+  versionText?: string | null
+): OpencodeCliFeatures {
   const help = helpText ?? '';
   const unknown = !help;
   return {
@@ -43,6 +48,8 @@ function detectCliFeatures(helpText?: string | null): OpencodeCliFeatures {
     supportsDir: unknown ? false : /--dir\b/.test(help),
     supportsCwd: unknown ? false : /--cwd\b/.test(help),
     supportsAutoApprove: false,
+    supportsResume: !unknown && /--session\b/.test(help) && /--continue\b/.test(help),
+    supportsWebSearch: isCliVersionAtLeast(versionText, '1.0.137'),
     unknown,
   };
 }
@@ -76,7 +83,7 @@ function addOpencodeOptionalArgs(args: string[], options: BuildProviderCommandOp
 
 function collectOpencodeWarnings(options: BuildProviderCommandOptions): WarningMetadata[] {
   const features = optionFeatures(options);
-  const warnings: WarningMetadata[] = unsupportedSessionControlWarnings('opencode', options);
+  const warnings: WarningMetadata[] = [];
   if (options.modelSpec?.reasoningEffort && features.supportsVariant === false) {
     warnings.push(
       warning(
@@ -89,19 +96,67 @@ function collectOpencodeWarnings(options: BuildProviderCommandOptions): WarningM
   return warnings;
 }
 
+function addSessionArgs(args: string[], options: BuildProviderCommandOptions): void {
+  const hasResumeSessionId = options.resumeSessionId !== undefined;
+  if (!hasResumeSessionId && !options.continueSession) return;
+  const field = hasResumeSessionId ? 'options.resumeSessionId' : 'options.continueSession';
+  if (hasResumeSessionId && options.resumeSessionId?.trim().length === 0) {
+    throw contractError({
+      code: 'invalid-field',
+      field,
+      exitCode: 2,
+      message: 'options.resumeSessionId must be a non-empty OpenCode session ID.',
+    });
+  }
+  if (optionFeatures(options).supportsResume === false) {
+    throw contractError({
+      code: 'invalid-field',
+      field,
+      exitCode: 2,
+      message:
+        'OpenCode CLI cannot safely run continuation context because this installation lacks run --session/--continue.',
+    });
+  }
+  if (options.resumeSessionId) {
+    args.push('--session', options.resumeSessionId);
+  } else {
+    args.push('--continue');
+  }
+}
+
+function webSearchEnv(options: BuildProviderCommandOptions): Readonly<Record<string, string>> {
+  if (options.webSearch !== true) return {};
+  if (optionFeatures(options).supportsWebSearch !== true) {
+    throw new UnsupportedProviderCapabilityError(
+      'opencode',
+      'webSearch',
+      'OpenCode web search requires a parseable OpenCode CLI version >= 1.0.137. Update OpenCode or set providerSettings.opencode.webSearch to false.'
+    );
+  }
+  return { OPENCODE_ENABLE_EXA: '1' };
+}
+
+function extractSessionId(line: string): string | null {
+  const event = tryParseJson(line.trim());
+  if (!isRecord(event)) return null;
+  const sessionId = getString(event, 'sessionID') ?? getString(event, 'sessionId');
+  return sessionId?.trim() || null;
+}
+
 function buildCommand(context: string, options: BuildProviderCommandOptions = {}): CommandSpec {
   const finalContext = options.jsonSchema
     ? appendJsonSchemaPrompt(context, options.jsonSchema)
     : context;
   const args: string[] = ['run'];
   addOpencodeOptionalArgs(args, options);
+  addSessionArgs(args, options);
 
   args.push(finalContext);
 
   return commandSpec({
     binary: 'opencode',
     args,
-    env: {},
+    env: webSearchEnv(options),
     ...(options.cwd === undefined ? {} : { cwd: options.cwd }),
     warnings: collectOpencodeWarnings(options),
   });
@@ -226,6 +281,7 @@ export const opencodeAdapter: ProviderAdapter = {
   defaultMinLevel: 'level1',
   detectCliFeatures,
   buildCommand,
+  extractSessionId,
   parseEvent,
   createParserState: () => createParserState('opencode'),
   resolveModelSpec,