@agentex/agent 0.0.23 → 0.0.26

package/src/providers/opencode/execute.ts

@@ -0,0 +1,251 @@
+import * as path from "node:path";
+import type { ExecutionContext, ExecutionResult } from "../../types.js";
+import { findBinary } from "../../utils/binary.js";
+import { buildEnv, ensurePathInEnv } from "../../utils/env.js";
+import { runChildProcess, deriveErrorCode } from "../../utils/process.js";
+import { injectHomeSkills } from "../../utils/skills.js";
+import { resolveInstructions } from "../../utils/instructions.js";
+import { prepareWorkspace } from "../../utils/workspace.js";
+import type { PreparedWorkspace } from "../../utils/workspace.js";
+import { uuidv7 } from "../../utils/uuid.js";
+import {
+  parseOpenCodeJsonl,
+  parseOpenCodeStreamLine,
+  isOpenCodeUnknownSessionError,
+  isOpenCodeAuthRequired,
+} from "./parse.js";
+
+export async function executeOpenCodeProvider(ctx: ExecutionContext): Promise<ExecutionResult> {
+  const runId = ctx.runId ?? uuidv7();
+  let cwd = ctx.cwd ?? process.cwd();
+  const model = ctx.model ?? ctx.config?.model ?? "";
+  const config = ctx.config ?? {};
+  const startedAt = new Date().toISOString();
+
+  // 1. Resolve binary
+  ctx.onLifecycle?.({ phase: "preparing", step: "binary" });
+  let resolvedBinary;
+  try {
+    resolvedBinary = await findBinary("opencode", config.command);
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : "Binary not found";
+    ctx.onLifecycle?.({ phase: "error", message: errorMessage });
+    return {
+      runId,
+      exitCode: null,
+      signal: null,
+      status: "failed" as const,
+      startedAt,
+      completedAt: new Date().toISOString(),
+      durationMs: Date.now() - new Date(startedAt).getTime(),
+      errorMessage,
+      errorCode: "binary_not_found",
+      costUsd: null,
+      model: null,
+      summary: null,
+      sessionParams: null,
+      sessionDisplayId: null,
+      clearSession: false,
+      billingType: null,
+    };
+  }
+
+  // 2. Workspace isolation
+  let workspace: PreparedWorkspace | undefined;
+  if (config.workspace) {
+    ctx.onLifecycle?.({ phase: "preparing", step: "workspace" });
+    workspace = await prepareWorkspace(cwd, config.workspace);
+    cwd = workspace.cwd;
+  }
+
+  // 3. Build env
+  const env = buildEnv(ctx.env);
+  ensurePathInEnv(env);
+
+  // 3. Resolve instructions
+  ctx.onLifecycle?.({ phase: "preparing", step: "instructions" });
+  const instructions = await resolveInstructions(config.instructionsFile);
+  const fullPrompt = instructions ? `${instructions}\n\n${ctx.prompt}` : ctx.prompt;
+
+  // 4. Inject skills into ~/.claude/skills/ (OpenCode shares Claude's skills dir)
+  ctx.onLifecycle?.({ phase: "preparing", step: "skills" });
+  if (config.skillDirs && config.skillDirs.length > 0) {
+    try {
+      await injectHomeSkills(config.skillDirs, "opencode");
+    } catch {
+      // Non-fatal
+    }
+  }
+
+  // 4. Determine session resume
+  const sessionParams = ctx.sessionParams ?? null;
+  const sessionId = (() => {
+    if (!sessionParams) return null;
+    const id =
+      (sessionParams["sessionId"] as string | undefined) ??
+      (sessionParams["session_id"] as string | undefined) ??
+      (sessionParams["sessionID"] as string | undefined);
+    if (!id || typeof id !== "string") return null;
+    const sessionCwd = sessionParams["cwd"] as string | undefined;
+    if (sessionCwd && path.resolve(sessionCwd) !== path.resolve(cwd)) return null;
+    return id;
+  })();
+
+  // 5. Build args
+  const buildArgs = (resumeSessionId: string | null): string[] => {
+    const args = [...resolvedBinary.prefixArgs, "run", "--format", "json"];
+    if (resumeSessionId) args.push("--session", resumeSessionId);
+    if (model) args.push("--model", model);
+    if (config.extraArgs) args.push(...config.extraArgs);
+    return args;
+  };
+
+  // 6. Run attempt
+  const runAttempt = async (resumeSessionId: string | null) => {
+    const args = buildArgs(resumeSessionId);
+    let lineBuffer = "";
+
+    ctx.onLifecycle?.({ phase: "spawning" });
+    const proc = await runChildProcess({
+      runId,
+      command: resolvedBinary.bin,
+      args,
+      cwd,
+      env,
+      stdin: fullPrompt,
+      timeoutSec: config.timeoutSec,
+      graceSec: config.graceSec,
+      onStart: (pid) => {
+        ctx.onLifecycle?.({ phase: "running", pid });
+        ctx.onStart?.(pid);
+      },
+      signal: ctx.signal,
+      onOutput: async (stream, chunk) => {
+        if (ctx.onOutput) {
+          try { await ctx.onOutput(stream, chunk); } catch { /* swallow */ }
+        }
+
+        if (stream === "stdout" && ctx.onEvent) {
+          lineBuffer += chunk;
+          const lines = lineBuffer.split("\n");
+          lineBuffer = lines.pop() ?? "";
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) continue;
+            const event = parseOpenCodeStreamLine(trimmed);
+            if (event) {
+              try { await ctx.onEvent(event); } catch { /* swallow */ }
+            }
+          }
+        }
+      },
+    });
+
+    if (lineBuffer.trim() && ctx.onEvent) {
+      const event = parseOpenCodeStreamLine(lineBuffer.trim());
+      if (event) {
+        try { await ctx.onEvent(event); } catch { /* swallow */ }
+      }
+    }
+
+    return proc;
+  };
+
+  // 7. Initial attempt
+  let proc = await runAttempt(sessionId);
+  let clearSession = false;
+
+  // 8. Check for unknown session — retry once
+  if (
+    sessionId &&
+    !proc.timedOut &&
+    (proc.exitCode ?? 0) !== 0 &&
+    isOpenCodeUnknownSessionError(proc.stdout, proc.stderr)
+  ) {
+    proc = await runAttempt(null);
+    clearSession = true;
+  }
+
+  // 9. Parse result
+  const parsed = parseOpenCodeJsonl(proc.stdout);
+  const processErrorCode = deriveErrorCode(proc);
+
+  let errorCode = processErrorCode;
+  if (!errorCode && parsed.errorMessage) {
+    errorCode = "execution_error";
+  }
+  if (!errorCode && isOpenCodeAuthRequired(proc.stdout, proc.stderr)) {
+    errorCode = "auth_required";
+    if (ctx.onEvent) {
+      try {
+        await ctx.onEvent({
+          type: "auth_required",
+          httpStatus: null,
+          reason: "missing",
+          loginCommand: "opencode auth login",
+          message: parsed.errorMessage,
+          timestamp: new Date().toISOString(),
+          providerType: "opencode",
+          sessionId: parsed.sessionId,
+          messageId: null,
+          eventId: null,
+          turnId: null,
+          parentToolCallId: null,
+          raw: {},
+        });
+      } catch { /* swallow */ }
+    }
+  }
+
+  const errorMessage = (() => {
+    if (proc.timedOut) return `Timed out after ${config.timeoutSec ?? 0}s`;
+    if (errorCode === "auth_required") return "OpenCode requires API key configuration.";
+    if (parsed.errorMessage) return parsed.errorMessage;
+    if ((proc.exitCode ?? 0) !== 0 && !parsed.summary) {
+      const stderrLine = proc.stderr.split(/\r?\n/).map((l) => l.trim()).find(Boolean);
+      return stderrLine ?? `OpenCode exited with code ${proc.exitCode ?? -1}`;
+    }
+    return null;
+  })();
+
+  const resolvedSessionId = parsed.sessionId;
+  const resultSessionParams = resolvedSessionId ? { sessionId: resolvedSessionId, cwd } : null;
+  const completedAt = new Date().toISOString();
+  const resolvedModel = model || null;
+  const status = proc.aborted ? "aborted" as const
+    : proc.timedOut ? "timeout" as const
+    : (errorCode || errorMessage) ? "failed" as const
+    : "completed" as const;
+
+  if (status === "completed") {
+    ctx.onLifecycle?.({ phase: "completed" });
+  } else if (status === "aborted") {
+    ctx.onLifecycle?.({ phase: "cancelled" });
+  } else {
+    ctx.onLifecycle?.({ phase: "error", message: errorMessage ?? "Unknown error" });
+  }
+
+  return {
+    runId,
+    exitCode: proc.exitCode,
+    signal: proc.signal ?? null,
+    status,
+    startedAt,
+    completedAt,
+    durationMs: new Date(completedAt).getTime() - new Date(startedAt).getTime(),
+    errorMessage,
+    errorCode,
+    usage: parsed.usage && resolvedModel
+      ? { [resolvedModel]: { inputTokens: parsed.usage.inputTokens, outputTokens: parsed.usage.outputTokens, cachedInputTokens: parsed.usage.cachedInputTokens } }
+      : undefined,
+    costUsd: parsed.costUsd,
+    model: resolvedModel,
+    summary: parsed.summary,
+    sessionParams: resultSessionParams,
+    sessionDisplayId: resolvedSessionId,
+    clearSession,
+    billingType: "api",
+    raw: null,
+    workspace,
+  };
+}

package/src/providers/opencode/http-session.ts

@@ -0,0 +1,427 @@
+import type {
+  AgentSession,
+  CancelResult,
+  ClearGoalResult,
+  GoalOptions,
+  GoalState,
+  StopTaskResult,
+  SendHandle,
+  SendOptions,
+  SessionContext,
+  SessionState,
+  SetGoalResult,
+  StreamEvent,
+  TurnResult,
+} from "../../types.js";
+import { GoalController, EMULATED_GOAL_CAPABILITY } from "../../goals/index.js";
+import { findBinary } from "../../utils/binary.js";
+import { buildEnv, ensurePathInEnv } from "../../utils/env.js";
+import { uuidv7 } from "../../utils/uuid.js";
+import { acquireOpenCodeServer, type OpenCodeServerHandle } from "./server.js";
+import { opencodeSessionCodec } from "./codec.js";
+import {
+  assistantTextFromParts,
+  mapOpenCodePart,
+  mapOpenCodeToolCall,
+  turnStatusFromMessage,
+  usageFromMessage,
+  type OcBaseInfo,
+} from "./event-parse.js";
+
+function str(v: unknown): string | null {
+  return typeof v === "string" && v.length > 0 ? v : null;
+}
+function num(v: unknown): number | null {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function rec(v: unknown): Record<string, unknown> | null {
+  return v && typeof v === "object" && !Array.isArray(v) ? (v as Record<string, unknown>) : null;
+}
+
+/** Parse a "providerID/modelID" string into opencode's model param. */
+function parseModel(model: string | undefined): { providerID: string; modelID: string } | null {
+  if (!model) return null;
+  const idx = model.indexOf("/");
+  if (idx <= 0) return null;
+  return { providerID: model.slice(0, idx), modelID: model.slice(idx + 1) };
+}
+
+function readResumeId(sessionParams: Record<string, unknown> | null | undefined): string | null {
+  const decoded = opencodeSessionCodec.deserialize(sessionParams ?? null);
+  const id = decoded?.["sessionId"];
+  return typeof id === "string" && id.length > 0 ? id : null;
+}
+
+/** Create + connect an OpenCode HTTP/SSE session. */
+export async function createOpenCodeSession(ctx: SessionContext): Promise<AgentSession> {
+  const session = new OpenCodeSession(ctx);
+  await session.connect();
+  return session;
+}
+
+class OpenCodeSession implements AgentSession {
+  private _state: SessionState = "idle";
+  private _sessionId: string | null = null;
+  private server: OpenCodeServerHandle | null = null;
+  private url = "";
+  private readonly model: { providerID: string; modelID: string } | null;
+
+  private _turnActive = false;
+  private _inFlight: Promise<TurnResult> | null = null;
+  private _draining = false;
+  /** AbortController for the in-flight `POST /message`, so `close()` can cancel it. */
+  private _activeController: AbortController | null = null;
+
+  // Live-stream dedup state (the global SSE feed re-sends full parts as they grow).
+  // Cleared at the start of every turn so a prior turn's part ids can't suppress
+  // this turn's events.
+  private readonly _seenTextLen = new Map<string, number>();
+  private readonly _emittedToolCall = new Set<string>();
+  private readonly _emittedToolResult = new Set<string>();
+  private _sse: AbortController | null = null;
+
+  /** Goal engine. OpenCode has no native goal surface — always emulated. */
+  private readonly _goals: GoalController;
+
+  constructor(private readonly ctx: SessionContext) {
+    this.model = parseModel(ctx.config?.model);
+    this._goals = new GoalController({
+      providerType: "opencode",
+      capability: EMULATED_GOAL_CAPABILITY,
+      getSessionId: () => this._sessionId,
+      send: (m) => this.send(m),
+      dispatch: (event: StreamEvent) => {
+        if (this.ctx.onEvent) void Promise.resolve(this.ctx.onEvent(event)).catch(() => {});
+      },
+    });
+  }
+
+  get sessionId(): string | null {
+    return this._sessionId;
+  }
+  get state(): SessionState {
+    return this._state;
+  }
+
+  async connect(): Promise<void> {
+    const config = this.ctx.config ?? {};
+    const resolved = await findBinary("opencode", config.command);
+    const env = buildEnv(this.ctx.env);
+    ensurePathInEnv(env);
+    const cwd = this.ctx.cwd ?? process.cwd();
+
+    this.server = await acquireOpenCodeServer(resolved.bin, resolved.prefixArgs, env, cwd);
+    this.url = this.server.url;
+
+    // Everything after acquiring the server must release it on failure, or the
+    // pooled `opencode serve` process leaks (refCount stuck at 1 forever).
+    try {
+      const resumeId = readResumeId(this.ctx.sessionParams);
+      if (resumeId) {
+        this._sessionId = resumeId;
+      } else {
+        const res = await fetch(`${this.url}/session`, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify({}),
+        });
+        if (!res.ok) throw new Error(`opencode: failed to create session (${res.status})`);
+        const data = (await res.json()) as Record<string, unknown>;
+        this._sessionId = str(data["id"]);
+      }
+
+      // Live event stream (global; filtered to our session).
+      this._sse = new AbortController();
+      void this.readSse(this._sse.signal);
+    } catch (err) {
+      if (this._sse) {
+        try {
+          this._sse.abort();
+        } catch {
+          /* ignore */
+        }
+        this._sse = null;
+      }
+      this.server.release();
+      this.server = null;
+      this._state = "closed";
+      throw err;
+    }
+
+    if (this.ctx.signal) {
+      if (this.ctx.signal.aborted) void this.close();
+      else this.ctx.signal.addEventListener("abort", () => void this.close(), { once: true });
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // SSE live stream
+  // -------------------------------------------------------------------------
+
+  private async readSse(signal: AbortSignal): Promise<void> {
+    try {
+      const res = await fetch(`${this.url}/global/event`, { signal });
+      if (!res.body) return;
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buf = "";
+      for (;;) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buf += decoder.decode(value, { stream: true });
+        let nl: number;
+        while ((nl = buf.indexOf("\n")) >= 0) {
+          const line = buf.slice(0, nl).trimEnd();
+          buf = buf.slice(nl + 1);
+          if (line.startsWith("data:")) {
+            const json = line.slice(5).trim();
+            if (json) await this.handleSse(json);
+          }
+        }
+      }
+    } catch {
+      // Stream closed/aborted — the POST /message response remains authoritative.
+    }
+  }
+
+  private async handleSse(json: string): Promise<void> {
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(json);
+    } catch {
+      return;
+    }
+    const payload = rec(rec(parsed)?.["payload"]);
+    if (!payload || payload["type"] !== "message.part.updated") return;
+    const props = rec(payload["properties"]);
+    const part = rec(props?.["part"]);
+    if (!part || str(part["sessionID"]) !== this._sessionId) return;
+    await this.emitPart(part);
+  }
+
+  private async emitPart(part: Record<string, unknown>): Promise<void> {
+    // The SSE feed is global and async: drop stragglers that arrive while no turn
+    // is active so a finished turn's late parts don't surface against the next one.
+    if (!this._turnActive) return;
+    const info: OcBaseInfo = {
+      provider: "opencode",
+      sessionId: this._sessionId,
+      timestamp: new Date().toISOString(),
+    };
+    const id = str(part["id"]) ?? "";
+    const type = part["type"];
+
+    if (type === "text" || type === "reasoning") {
+      if (part["synthetic"] === true || part["ignored"] === true) return;
+      const full = typeof part["text"] === "string" ? part["text"] : "";
+      const seen = this._seenTextLen.get(id) ?? 0;
+      if (full.length <= seen) return;
+      this._seenTextLen.set(id, full.length);
+      const ev = mapOpenCodePart(part, info, full.slice(seen));
+      await this.emit(ev);
+    } else if (type === "tool") {
+      const callId = str(part["callID"]) ?? id;
+      const status = str(rec(part["state"])?.["status"]);
+      if (!this._emittedToolCall.has(callId)) {
+        this._emittedToolCall.add(callId);
+        await this.emit(mapOpenCodeToolCall(part, info));
+      }
+      if ((status === "completed" || status === "error") && !this._emittedToolResult.has(callId)) {
+        this._emittedToolResult.add(callId);
+        await this.emit(mapOpenCodePart(part, info));
+      }
+    }
+  }
+
+  private async emit(ev: ReturnType<typeof mapOpenCodePart>): Promise<void> {
+    if (ev && this.ctx.onEvent) {
+      try {
+        await this.ctx.onEvent(ev);
+      } catch {
+        /* a throwing handler must not break the stream */
+      }
+    }
+  }
+
+  // -------------------------------------------------------------------------
+  // Public API
+  // -------------------------------------------------------------------------
+
+  async send(message: string, options?: SendOptions): Promise<SendHandle> {
+    if (this._state === "closed") throw new Error("Session is closed");
+    if (this._draining) throw new Error("Session is draining — no new sends accepted");
+    if (this._turnActive) {
+      throw new Error("OpenCode session is busy — a turn is already in progress (concurrentSend not supported)");
+    }
+    const uuid = uuidv7();
+    this._turnActive = true;
+    this._state = "thinking";
+    const result = this.runTurn(message, options);
+    this._inFlight = result;
+    // Advance any emulated goal loop once the turn settles (finishTurn runs in
+    // runTurn's finally, so the session is idle by the time this fires).
+    void result.then((r) => this._goals.onTurnSettled(r)).catch(() => {});
+    return { uuid, result };
+  }
+
+  private finishTurn(): void {
+    this._turnActive = false;
+    this._inFlight = null;
+    if (this._state !== "closed") this._state = "idle";
+  }
+
+  private async runTurn(message: string, options?: SendOptions): Promise<TurnResult> {
+    if (!this._sessionId) {
+      this.finishTurn();
+      return {
+        summary: null,
+        costUsd: null,
+        status: "failed",
+        errorCode: "not_initialized",
+        errorMessage: "OpenCode session is not initialized",
+      };
+    }
+
+    // Fresh per-turn live-stream dedup so a previous turn's part ids can't
+    // suppress this turn's events.
+    this._seenTextLen.clear();
+    this._emittedToolCall.clear();
+    this._emittedToolResult.clear();
+
+    const ac = new AbortController();
+    this._activeController = ac;
+    const timeoutSec = options?.timeoutSec ?? this.ctx.config?.timeoutSec;
+    const timer =
+      timeoutSec && timeoutSec > 0 ? setTimeout(() => ac.abort("timeout"), timeoutSec * 1000) : null;
+    const onAbort = (): void => ac.abort("aborted");
+    options?.signal?.addEventListener("abort", onAbort, { once: true });
+
+    const body: Record<string, unknown> = { parts: [{ type: "text", text: message }] };
+    if (this.model) body["model"] = this.model;
+
+    try {
+      const res = await fetch(`${this.url}/session/${this._sessionId}/message`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+        signal: ac.signal,
+      });
+      if (!res.ok) {
+        const text = await res.text().catch(() => "");
+        return {
+          summary: null,
+          costUsd: null,
+          status: "failed",
+          errorCode: "http_error",
+          errorMessage: `opencode message failed: ${res.status} ${text}`.trim(),
+        };
+      }
+      const data = (await res.json()) as Record<string, unknown>;
+      const info = rec(data["info"]);
+      const status = turnStatusFromMessage(info);
+      const usage = usageFromMessage(info);
+      return {
+        summary: assistantTextFromParts(data["parts"]) || null,
+        ...(usage ? { usage } : {}),
+        costUsd: info ? num(info["cost"]) : null,
+        status,
+        errorCode: status === "failed" ? "agent_error" : null,
+        errorMessage: status === "failed" ? JSON.stringify(info?.["error"] ?? null) : null,
+      };
+    } catch (err) {
+      if (ac.signal.aborted) {
+        // Don't POST /abort if we're tearing the whole session down (close()
+        // already killed the server); only interrupt on timeout/caller-abort.
+        const reason = ac.signal.reason === "timeout" ? "timeout" : ac.signal.reason === "closed" ? "aborted" : "aborted";
+        if (ac.signal.reason !== "closed") await this.interrupt().catch(() => {});
+        return {
+          summary: null,
+          costUsd: null,
+          status: reason,
+          errorCode: reason,
+          errorMessage: reason === "timeout" ? "Turn exceeded its timeout" : "Turn aborted",
+        };
+      }
+      return {
+        summary: null,
+        costUsd: null,
+        status: "failed",
+        errorCode: "request_error",
+        errorMessage: err instanceof Error ? err.message : String(err),
+      };
+    } finally {
+      if (timer) clearTimeout(timer);
+      options?.signal?.removeEventListener("abort", onAbort);
+      if (this._activeController === ac) this._activeController = null;
+      this.finishTurn();
+    }
+  }
+
+  async cancel(_uuid: string): Promise<CancelResult> {
+    return { cancelled: false };
+  }
+
+  async stopTask(_taskId: string): Promise<StopTaskResult> {
+    // OpenCode has no per-task stop control; capabilities.stopTask is false.
+    return { stopped: false };
+  }
+
+  setGoal(objective: string, options?: GoalOptions): Promise<SetGoalResult> {
+    return this._goals.setGoal(objective, options);
+  }
+
+  clearGoal(options?: { reason?: "cleared" | "blocked" }): Promise<ClearGoalResult> {
+    return this._goals.clearGoal(options);
+  }
+
+  getGoal(): GoalState | null {
+    return this._goals.getGoal();
+  }
+
+  async interrupt(): Promise<void> {
+    if (!this._sessionId) return;
+    try {
+      await fetch(`${this.url}/session/${this._sessionId}/abort`, { method: "POST" });
+    } catch {
+      /* best effort */
+    }
+  }
+
+  async drain(): Promise<void> {
+    this._draining = true;
+    if (this._inFlight) {
+      try {
+        await this._inFlight;
+      } catch {
+        /* ignore */
+      }
+    }
+    await this.close();
+  }
+
+  async close(): Promise<void> {
+    this._state = "closed";
+    // Abort an in-flight POST /message so close() doesn't leave it racing a
+    // killed server (and so the turn settles as aborted, not a confusing error).
+    if (this._activeController) {
+      try {
+        this._activeController.abort("closed");
+      } catch {
+        /* ignore */
+      }
+      this._activeController = null;
+    }
+    if (this._sse) {
+      try {
+        this._sse.abort();
+      } catch {
+        /* ignore */
+      }
+      this._sse = null;
+    }
+    if (this.server) {
+      this.server.release();
+      this.server = null;
+    }
+  }
+}

package/src/providers/opencode/index.ts

@@ -0,0 +1,30 @@
+import type { ProviderModule, SessionContext, AgentSession } from "../../types.js";
+import { opencodeSessionCodec } from "./codec.js";
+import { resolveAuthForProvider } from "../../utils/auth.js";
+import { EMULATED_GOAL_CAPABILITY } from "../../goals/index.js";
+
+export const opencodeProvider: ProviderModule = {
+  type: "opencode",
+  capabilities: {
+    sessions: true,
+    modelDiscovery: false,
+    quotaProbing: false,
+    mcp: false,
+    skills: true,
+    instructions: true,
+    workspace: true,
+    planMode: false,
+    concurrentSend: false,
+    cancelQueuedMessage: false,
+    stopTask: false,
+    modes: false,
+    goals: EMULATED_GOAL_CAPABILITY,
+  },
+  // One-shot `opencode run` for execute(); live HTTP/SSE sessions via the
+  // `opencode serve` daemon for createSession(). Both load lazily on first use.
+  execute: async (ctx) => (await import("./execute.js")).executeOpenCodeProvider(ctx),
+  createSession: async (ctx: SessionContext): Promise<AgentSession> =>
+    (await import("./http-session.js")).createOpenCodeSession(ctx),
+  resolveAuth: (ctx) => resolveAuthForProvider("opencode", ctx),
+  sessionCodec: opencodeSessionCodec,
+};