agent-tempo 1.0.1

package/dist/adapters/opencode/config.d.ts

@@ -0,0 +1,90 @@
+/**
+ * `OPENCODE_CONFIG_CONTENT` synthesis for the opencode adapter.
+ *
+ * The adapter inlines the OpenCode config rather than writing a file —
+ * no filesystem cleanup risk, no permissions concerns, secrets-redacted
+ * stderr config-log preserves debuggability. ADR 0015 Q2.
+ *
+ * The synthesized config:
+ *   - Hardcodes `--hostname 127.0.0.1` and `mdns: false` (security
+ *     mitigation for OpenCode's no-Bearer-auth in v1.14.x). NOT
+ *     configurable — see ADR 0015 §53 + design §6.
+ *   - Auto-detects the provider from the `model` arg's `provider/...`
+ *     prefix and emits a `provider.<name>.options` block for whichever
+ *     env vars are present (mirrors OpenCode's own behavior).
+ *   - Registers agent-tempo as an OpenCode MCP child via `type: "local"`
+ *     stdio. OpenCode spawns a SECOND copy of `dist/server.js` as its
+ *     MCP subprocess and dispatches tool calls there directly — the
+ *     adapter is never on the tool-dispatch hot path.
+ *
+ * Design reference: docs/design/449-opencode-adapter.md §3.7, §4.1.
+ */
+/**
+ * Map of provider id (matches the prefix in `model: 'provider/name'`) to
+ * the env var name that holds the API key. Population is best-effort —
+ * if the env var isn't set, the corresponding `provider.X.options` block
+ * is omitted and OpenCode either falls back to its own auth chain (e.g.
+ * macOS Keychain for Anthropic OAuth) or fails the session-create with
+ * a clear error.
+ */
+export declare const PROVIDER_ENV_MAP: Readonly<Record<string, string>>;
+export type ProviderEnvMap = Readonly<Record<string, string>>;
+/**
+ * Extract the provider id from a `provider/model` string. Returns `null`
+ * when the input doesn't have a `/` (e.g. legacy claude-api ids like
+ * `claude-opus-4-7`) — caller decides whether to default to a particular
+ * provider or surface the error.
+ */
+export declare function detectProviderEnvFromModel(model: string): string | null;
+/**
+ * Inputs for {@link synthesizeOpenCodeConfig}. Each field maps to one
+ * branch of the synthesized JSON.
+ */
+export interface SynthesizeOpenCodeConfigOpts {
+    /** Combined `provider/model` recruit-arg, e.g. `'anthropic/claude-opus-4-7'`. */
+    model: string;
+    /** Probed-free port `opencode serve` will bind. */
+    port: number;
+    /** Absolute path to agent-tempo's `dist/server.js` — runs as OpenCode's MCP child. */
+    mcpServerPath: string;
+    /** Ensemble name — passed through to the MCP child env. */
+    ensemble: string;
+    /** Player name — passed through to the MCP child env. */
+    playerName: string;
+    /** Temporal address — passed through to the MCP child env. */
+    temporalAddress: string;
+    /** Temporal namespace — passed through to the MCP child env. */
+    temporalNamespace: string;
+    /**
+     * Test seam — defaults to `process.env`. Tests inject a stub map to
+     * exercise the provider-detection + env-var-presence branches without
+     * mutating the real environment.
+     */
+    env?: NodeJS.ProcessEnv;
+}
+/**
+ * Synthesize the inline `OPENCODE_CONFIG_CONTENT` JSON value. Returns the
+ * stringified JSON, ready to set as the env var on the `opencode serve`
+ * spawn. Caller passes through {@link redactSecrets} before logging.
+ *
+ * Shape per design §3.7:
+ * ```json
+ * {
+ *   "model": "anthropic/claude-opus-4-7",
+ *   "provider": { "anthropic": { "options": { "apiKey": "{env:ANTHROPIC_API_KEY}" } } },
+ *   "server": { "port": 4732, "hostname": "127.0.0.1", "mdns": false },
+ *   "mcp": {
+ *     "agent-tempo": {
+ *       "type": "local",
+ *       "command": ["node", "/abs/path/to/dist/server.js"],
+ *       "environment": { "AGENT_TEMPO_ENSEMBLE": "{env:AGENT_TEMPO_ENSEMBLE}", … }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The `{env:VAR}` markers are OpenCode-native substitutions — OpenCode
+ * resolves them at config-read time, so credentials never appear in the
+ * literal JSON we hand to the subprocess.
+ */
+export declare function synthesizeOpenCodeConfig(opts: SynthesizeOpenCodeConfigOpts): string;

package/dist/adapters/opencode/config.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * `OPENCODE_CONFIG_CONTENT` synthesis for the opencode adapter.
+ *
+ * The adapter inlines the OpenCode config rather than writing a file —
+ * no filesystem cleanup risk, no permissions concerns, secrets-redacted
+ * stderr config-log preserves debuggability. ADR 0015 Q2.
+ *
+ * The synthesized config:
+ *   - Hardcodes `--hostname 127.0.0.1` and `mdns: false` (security
+ *     mitigation for OpenCode's no-Bearer-auth in v1.14.x). NOT
+ *     configurable — see ADR 0015 §53 + design §6.
+ *   - Auto-detects the provider from the `model` arg's `provider/...`
+ *     prefix and emits a `provider.<name>.options` block for whichever
+ *     env vars are present (mirrors OpenCode's own behavior).
+ *   - Registers agent-tempo as an OpenCode MCP child via `type: "local"`
+ *     stdio. OpenCode spawns a SECOND copy of `dist/server.js` as its
+ *     MCP subprocess and dispatches tool calls there directly — the
+ *     adapter is never on the tool-dispatch hot path.
+ *
+ * Design reference: docs/design/449-opencode-adapter.md §3.7, §4.1.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_ENV_MAP = void 0;
+exports.detectProviderEnvFromModel = detectProviderEnvFromModel;
+exports.synthesizeOpenCodeConfig = synthesizeOpenCodeConfig;
+/**
+ * Map of provider id (matches the prefix in `model: 'provider/name'`) to
+ * the env var name that holds the API key. Population is best-effort —
+ * if the env var isn't set, the corresponding `provider.X.options` block
+ * is omitted and OpenCode either falls back to its own auth chain (e.g.
+ * macOS Keychain for Anthropic OAuth) or fails the session-create with
+ * a clear error.
+ */
+exports.PROVIDER_ENV_MAP = Object.freeze({
+    anthropic: 'ANTHROPIC_API_KEY',
+    openai: 'OPENAI_API_KEY',
+    groq: 'GROQ_API_KEY',
+    deepseek: 'DEEPSEEK_API_KEY',
+    google: 'GOOGLE_API_KEY',
+    mistral: 'MISTRAL_API_KEY',
+    cohere: 'COHERE_API_KEY',
+    xai: 'XAI_API_KEY',
+    // Bedrock and Vertex use AWS / GCP creds, not a single bearer token.
+    // OpenCode reads the standard AWS/GCP env chain — no `provider.X.options`
+    // block needed here.
+    bedrock: '',
+    vertex: '',
+    // Ollama is local; no API key.
+    ollama: '',
+    // GitHub Copilot via OpenCode uses OAuth; no API key in env.
+    github: '',
+});
+/**
+ * Extract the provider id from a `provider/model` string. Returns `null`
+ * when the input doesn't have a `/` (e.g. legacy claude-api ids like
+ * `claude-opus-4-7`) — caller decides whether to default to a particular
+ * provider or surface the error.
+ */
+function detectProviderEnvFromModel(model) {
+    const slash = model.indexOf('/');
+    if (slash <= 0)
+        return null;
+    return model.slice(0, slash).toLowerCase();
+}
+/**
+ * Synthesize the inline `OPENCODE_CONFIG_CONTENT` JSON value. Returns the
+ * stringified JSON, ready to set as the env var on the `opencode serve`
+ * spawn. Caller passes through {@link redactSecrets} before logging.
+ *
+ * Shape per design §3.7:
+ * ```json
+ * {
+ *   "model": "anthropic/claude-opus-4-7",
+ *   "provider": { "anthropic": { "options": { "apiKey": "{env:ANTHROPIC_API_KEY}" } } },
+ *   "server": { "port": 4732, "hostname": "127.0.0.1", "mdns": false },
+ *   "mcp": {
+ *     "agent-tempo": {
+ *       "type": "local",
+ *       "command": ["node", "/abs/path/to/dist/server.js"],
+ *       "environment": { "AGENT_TEMPO_ENSEMBLE": "{env:AGENT_TEMPO_ENSEMBLE}", … }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * The `{env:VAR}` markers are OpenCode-native substitutions — OpenCode
+ * resolves them at config-read time, so credentials never appear in the
+ * literal JSON we hand to the subprocess.
+ */
+function synthesizeOpenCodeConfig(opts) {
+    const env = opts.env ?? process.env;
+    const providerId = detectProviderEnvFromModel(opts.model);
+    const providerBlock = {};
+    if (providerId) {
+        const envVarName = exports.PROVIDER_ENV_MAP[providerId];
+        if (envVarName && env[envVarName]) {
+            const options = {
+                apiKey: `{env:${envVarName}}`,
+            };
+            // Anthropic provider supports prompt caching; opt-in via the
+            // OpenCode-native `setCacheKey` knob. Other providers don't have an
+            // analog, so we only set this for the anthropic block.
+            if (providerId === 'anthropic') {
+                options.setCacheKey = true;
+            }
+            providerBlock[providerId] = { options };
+        }
+        // Bedrock / Vertex / Ollama / GitHub-Copilot intentionally skipped —
+        // they don't use a bearer-token env var; OpenCode reads their native
+        // auth chains (AWS env vars, gcloud ADC, local server, OAuth file).
+    }
+    const config = {
+        model: opts.model,
+        ...(Object.keys(providerBlock).length > 0 ? { provider: providerBlock } : {}),
+        server: {
+            port: opts.port,
+            // SECURITY: hardcoded loopback. NOT configurable. ADR 0015 §53.
+            hostname: '127.0.0.1',
+            // SECURITY: avoid leaking session presence over Bonjour. ADR 0015 §82.
+            mdns: false,
+        },
+        mcp: {
+            'agent-tempo': {
+                type: 'local',
+                command: ['node', opts.mcpServerPath],
+                environment: {
+                    AGENT_TEMPO_ENSEMBLE: '{env:AGENT_TEMPO_ENSEMBLE}',
+                    AGENT_TEMPO_PLAYER_NAME: '{env:AGENT_TEMPO_PLAYER_NAME}',
+                    TEMPORAL_ADDRESS: '{env:TEMPORAL_ADDRESS}',
+                    TEMPORAL_NAMESPACE: '{env:TEMPORAL_NAMESPACE}',
+                },
+            },
+        },
+    };
+    return JSON.stringify(config);
+}

package/dist/adapters/opencode/helpers.d.ts

@@ -0,0 +1,40 @@
+import type { ChildProcess } from 'child_process';
+/**
+ * Probe a free TCP port on `127.0.0.1` by binding port 0 and reading the
+ * OS-assigned port. Same approach `src/http/server.ts` uses.
+ *
+ * The port is briefly bound and released — there is a TOCTOU window where
+ * another process could grab it before `opencode serve` starts. Acceptable
+ * for the v1 single-machine model: opencode is loopback-only and the
+ * single-tenant use case won't hit the race in practice.
+ */
+export declare function probeFreePort(): Promise<number>;
+/**
+ * Wait for a `ChildProcess` to exit, with a timeout. Returns the exit code
+ * (or signal-as-string) on exit, or `null` on timeout.
+ */
+export declare function waitForExit(p: ChildProcess, timeoutMs: number): Promise<number | string | null>;
+/**
+ * Redact API key substrings in a synthesized OpenCode config so the
+ * stderr config-log doesn't leak credentials. Any substring that looks
+ * like an API key (alphanumeric ≥20 chars, optionally prefixed `sk-` or
+ * `Bearer `) is replaced with `***`.
+ *
+ * Conservative: only known shapes are touched. The `{env:...}` substitution
+ * markers in the config (e.g. `"apiKey": "{env:ANTHROPIC_API_KEY}"`) are
+ * left intact because they don't contain literal credentials — OpenCode
+ * substitutes at read time.
+ */
+export declare function redactSecrets(json: string): string;
+/**
+ * Compare a runtime version string to a tilde-pinned spec (e.g. `~1.14.29`).
+ * Returns `true` when `version` is on the same `MAJOR.MINOR` line as the
+ * spec — i.e. `1.14.29`, `1.14.30`, `1.14.99` all match `~1.14.29`, but
+ * `1.15.0` does not. Matches npm tilde-range semantics.
+ *
+ * Pure string compare — no semver dep. Both `version` and `spec` must be
+ * `MAJOR.MINOR.PATCH` (extra suffixes ignored). Returns `true` on
+ * unparseable inputs to avoid false-positive WARNING noise on weird
+ * builds (e.g. `1.14.29-rc1`).
+ */
+export declare function isVersionMatch(version: string, spec: string): boolean;

package/dist/adapters/opencode/helpers.js

@@ -0,0 +1,144 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.probeFreePort = probeFreePort;
+exports.waitForExit = waitForExit;
+exports.redactSecrets = redactSecrets;
+exports.isVersionMatch = isVersionMatch;
+/**
+ * Small, self-contained helpers for the opencode adapter.
+ *
+ * Kept out of `adapter.ts` so each can be unit-tested without the full
+ * Temporal/SdkAttachment scaffolding. Mirrors the per-adapter helpers
+ * pattern used by `src/adapters/claude-api/`.
+ */
+const net = __importStar(require("net"));
+/**
+ * Probe a free TCP port on `127.0.0.1` by binding port 0 and reading the
+ * OS-assigned port. Same approach `src/http/server.ts` uses.
+ *
+ * The port is briefly bound and released — there is a TOCTOU window where
+ * another process could grab it before `opencode serve` starts. Acceptable
+ * for the v1 single-machine model: opencode is loopback-only and the
+ * single-tenant use case won't hit the race in practice.
+ */
+function probeFreePort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.unref();
+        server.on('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const addr = server.address();
+            if (typeof addr === 'object' && addr && 'port' in addr) {
+                const port = addr.port;
+                server.close((err) => (err ? reject(err) : resolve(port)));
+            }
+            else {
+                server.close();
+                reject(new Error('probeFreePort: server.address() did not return an AddressInfo'));
+            }
+        });
+    });
+}
+/**
+ * Wait for a `ChildProcess` to exit, with a timeout. Returns the exit code
+ * (or signal-as-string) on exit, or `null` on timeout.
+ */
+function waitForExit(p, timeoutMs) {
+    return new Promise((resolve) => {
+        if (p.killed && p.exitCode !== null) {
+            resolve(p.exitCode);
+            return;
+        }
+        let settled = false;
+        const onExit = (code, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(code ?? signal ?? null);
+        };
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            p.removeListener('exit', onExit);
+            resolve(null);
+        }, timeoutMs);
+        p.once('exit', onExit);
+    });
+}
+/**
+ * Redact API key substrings in a synthesized OpenCode config so the
+ * stderr config-log doesn't leak credentials. Any substring that looks
+ * like an API key (alphanumeric ≥20 chars, optionally prefixed `sk-` or
+ * `Bearer `) is replaced with `***`.
+ *
+ * Conservative: only known shapes are touched. The `{env:...}` substitution
+ * markers in the config (e.g. `"apiKey": "{env:ANTHROPIC_API_KEY}"`) are
+ * left intact because they don't contain literal credentials — OpenCode
+ * substitutes at read time.
+ */
+function redactSecrets(json) {
+    // Match: "apiKey": "sk-foo..." or "apiKey": "long-token-here"
+    return json.replace(/("(?:apiKey|api_key|token|bearer|secret)"\s*:\s*")([^"]{20,})(")/gi, (_full, pre, value, post) => {
+        // Preserve `{env:...}` markers — they're config-shape, not secrets.
+        if (value.startsWith('{env:') && value.endsWith('}'))
+            return pre + value + post;
+        return pre + '***' + post;
+    });
+}
+/**
+ * Compare a runtime version string to a tilde-pinned spec (e.g. `~1.14.29`).
+ * Returns `true` when `version` is on the same `MAJOR.MINOR` line as the
+ * spec — i.e. `1.14.29`, `1.14.30`, `1.14.99` all match `~1.14.29`, but
+ * `1.15.0` does not. Matches npm tilde-range semantics.
+ *
+ * Pure string compare — no semver dep. Both `version` and `spec` must be
+ * `MAJOR.MINOR.PATCH` (extra suffixes ignored). Returns `true` on
+ * unparseable inputs to avoid false-positive WARNING noise on weird
+ * builds (e.g. `1.14.29-rc1`).
+ */
+function isVersionMatch(version, spec) {
+    const versionMajorMinor = parseMajorMinor(version);
+    const specMajorMinor = parseMajorMinor(spec.replace(/^~/, ''));
+    if (!versionMajorMinor || !specMajorMinor)
+        return true;
+    return versionMajorMinor === specMajorMinor;
+}
+function parseMajorMinor(s) {
+    const m = /(\d+)\.(\d+)\.\d+/.exec(s);
+    return m ? `${m[1]}.${m[2]}` : null;
+}

package/dist/adapters/opencode/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * opencode adapter — barrel export.
+ *
+ * Re-exports the descriptor and class from `./adapter`. `src/adapters/index.ts`
+ * imports the descriptor here at module load and registers it with the
+ * singleton {@link AdapterRegistry}. Direct consumers should fetch from the
+ * registry, not import the descriptor directly.
+ *
+ * Same cycle-avoidance pattern as `src/adapters/claude-api/index.ts` and
+ * `src/adapters/copilot/index.ts`.
+ */
+export { OpenCodeAttachment, opencodeDescriptor } from './adapter';

package/dist/adapters/opencode/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.opencodeDescriptor = exports.OpenCodeAttachment = void 0;
+/**
+ * opencode adapter — barrel export.
+ *
+ * Re-exports the descriptor and class from `./adapter`. `src/adapters/index.ts`
+ * imports the descriptor here at module load and registers it with the
+ * singleton {@link AdapterRegistry}. Direct consumers should fetch from the
+ * registry, not import the descriptor directly.
+ *
+ * Same cycle-avoidance pattern as `src/adapters/claude-api/index.ts` and
+ * `src/adapters/copilot/index.ts`.
+ */
+var adapter_1 = require("./adapter");
+Object.defineProperty(exports, "OpenCodeAttachment", { enumerable: true, get: function () { return adapter_1.OpenCodeAttachment; } });
+Object.defineProperty(exports, "opencodeDescriptor", { enumerable: true, get: function () { return adapter_1.opencodeDescriptor; } });

package/dist/adapters/opencode/server-bridge.d.ts

@@ -0,0 +1,124 @@
+/**
+ * Thin HTTP/SSE wrapper around `opencode serve`.
+ *
+ * Hand-rolled over native `fetch` rather than `@opencode-ai/sdk` per design
+ * §8.3 LoC tightening proposal #2 — the SDK is auto-generated from
+ * OpenAPI 3.1, so it pulls in OpenAPI runtime + per-endpoint typed clients
+ * for ~50 endpoints. Our hot path uses ~5 endpoints + the `/event` SSE
+ * stream; the SDK weight isn't worth it. The architectural shape of the
+ * adapter is identical either way.
+ *
+ * The SDK is still listed as an `optionalDependency` and `require.resolve`
+ * gates the recruit pre-flight (ADR 0015 §85) — operators install it as
+ * the signal that opencode integration is intended on this host. Adapter
+ * runtime, however, never imports it.
+ *
+ * Contract surface (5 methods + 1 generator):
+ *   - `waitForHealth(timeoutMs)`
+ *   - `getHealth()`
+ *   - `createSession()`
+ *   - `promptAsync(sessionId, body)`
+ *   - `abortSession(sessionId)`
+ *   - `deleteSession(sessionId)`
+ *   - `subscribeEvents(abortSignal)` — async generator yielding parsed events
+ *
+ * Design reference: docs/design/449-opencode-adapter.md §5.3, §8.1.
+ */
+/**
+ * Health response shape from `GET /global/health`. Drift-tolerant — only
+ * the `version` field is read, everything else is forwarded as `unknown`.
+ */
+export interface OpenCodeHealth {
+    version: string;
+}
+/**
+ * Newly-created session shape from `POST /session`. Drift-tolerant — only
+ * the `id` field is read.
+ */
+export interface OpenCodeSession {
+    id: string;
+}
+/**
+ * Body for `POST /session/:id/prompt_async`. The adapter sends the system
+ * prompt + the new turn's parts (agent-tempo workflow's pendingMessages
+ * flattened into a parts array) plus the model id to use for this turn.
+ */
+export interface PromptAsyncBody {
+    model: string;
+    system?: string;
+    parts: Array<{
+        type: 'text';
+        text: string;
+    }>;
+}
+/**
+ * One SSE event from the `/event` stream. OpenCode's event surface is
+ * still labeled experimental (ADR 0015 §82) so we model it permissively
+ * — `type` is parsed, the rest forwarded as `unknown`. Consumers
+ * narrow on `type` and read the fields they need.
+ */
+export interface OpenCodeEvent {
+    type: string;
+    [key: string]: unknown;
+}
+export interface ServerBridgeOpts {
+    /** Base URL — `http://127.0.0.1:<port>` per the loopback-only model. */
+    baseUrl: string;
+    /** Logger — adapter passes its `[agent-tempo:opencode]` prefix here. */
+    log?: (...args: unknown[]) => void;
+    /**
+     * Test seam — defaults to global `fetch`. Tests inject a stub to drive
+     * canned responses without standing up a real http server.
+     */
+    fetchImpl?: typeof fetch;
+}
+export declare class OpenCodeServerBridge {
+    private readonly baseUrl;
+    private readonly log;
+    private readonly fetchImpl;
+    constructor(opts: ServerBridgeOpts);
+    /**
+     * Poll `GET /global/health` until 200 or `timeoutMs` elapses. Throws on
+     * timeout — caller is the adapter `run()` and a missing health probe
+     * means opencode didn't boot.
+     */
+    waitForHealth(timeoutMs: number): Promise<void>;
+    /** `GET /global/health` — version + healthy flag. */
+    getHealth(): Promise<OpenCodeHealth>;
+    /** `POST /session` — create a new session; returns the session id + meta. */
+    createSession(): Promise<OpenCodeSession>;
+    /**
+     * `POST /session/:id/prompt_async` — send a turn; returns 204 immediately
+     * and the turn streams over `/event` SSE. Caller is responsible for
+     * subscribing to events first.
+     */
+    promptAsync(sessionId: string, body: PromptAsyncBody): Promise<void>;
+    /**
+     * `POST /session/:id/abort` — graceful turn cancellation. The primary
+     * cancellation path on lease revocation; subprocess SIGTERM is the
+     * fallback only if this hangs.
+     *
+     * Best-effort — swallows non-2xx so the adapter's superseded path can
+     * still fall through to subprocess kill without surfacing an error.
+     */
+    abortSession(sessionId: string, opts?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /**
+     * `DELETE /session/:id` — free server-side session resources. Called on
+     * graceful detach. Best-effort — swallows non-2xx.
+     */
+    deleteSession(sessionId: string): Promise<void>;
+    /**
+     * `GET /event` — SSE stream of session events. Returns an async
+     * generator that yields parsed `OpenCodeEvent` objects until the
+     * abort signal fires or the stream closes.
+     *
+     * The caller is responsible for filtering events by session id —
+     * `/event` is global per `opencode serve` instance, but the v1
+     * subprocess-per-player model means there's only ever one session
+     * per stream anyway. Phase 2 subprocess-shared optimization would
+     * make filtering meaningful.
+     */
+    subscribeEvents(signal?: AbortSignal): AsyncGenerator<OpenCodeEvent, void, void>;
+}