@harness-control/runner 0.1.0

package/dist/harnesses/adapters/providers/opencode.js

@@ -0,0 +1,416 @@
+import { spawn } from "node:child_process";
+import { z } from "zod";
+import { HarnessAdapterError } from "../types.js";
+import { firstLine, processFailureMessage, spawnProviderCliProcess, } from "./cli-process.js";
+import { adapterMcpServers, assertCliMcpAttachmentProxied, cliMcpServerConfigName, normalizeProviderModels, turnFailedEvent, } from "./shared.js";
+const DEFAULT_PROBE_TIMEOUT_MS = 5_000;
+const DEFAULT_SERVER_START_TIMEOUT_MS = 10_000;
+const DEFAULT_EVENT_SETTLE_TIMEOUT_MS = 5_000;
+const sessionSchema = z.object({ id: z.string().min(1) }).passthrough();
+const promptResponseSchema = z
+    .object({
+    parts: z.array(z.object({ type: z.string(), text: z.string().optional() }).passthrough()).default([]),
+})
+    .passthrough();
+const eventSchema = z
+    .object({
+    type: z.string(),
+    properties: z.record(z.string(), z.unknown()),
+})
+    .passthrough();
+export class OpenCodeHarnessAdapter {
+    driverKind = "opencode";
+    #runtimeFactory;
+    #probeTimeoutMs;
+    #runtimes = new Map();
+    #activeTurns = new Map();
+    #stopReasons = new Map();
+    constructor(options = {}) {
+        this.#runtimeFactory = options.runtimeFactory ?? startOpenCodeRuntime;
+        this.#probeTimeoutMs = options.probeTimeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS;
+    }
+    async probe(provider) {
+        const executable = provider.executable_path ?? "opencode";
+        const result = await runProbe(executable, [...provider.launch_args, "--version"], provider, this.#probeTimeoutMs);
+        const version = firstLine(result.stdout);
+        if (result.timedOut || result.error || result.exitCode !== 0) {
+            return {
+                provider_instance_id: provider.id,
+                driver_kind: this.driverKind,
+                installed: false,
+                available: false,
+                status: "unavailable",
+                message: result.timedOut
+                    ? "OpenCode version probe timed out."
+                    : processFailureMessage(result, "OpenCode executable is not available.", provider.home ? [executable, provider.home] : [executable]),
+                models: normalizeProviderModels(provider.models),
+            };
+        }
+        return {
+            provider_instance_id: provider.id,
+            driver_kind: this.driverKind,
+            installed: true,
+            available: true,
+            status: "ready",
+            ...(version ? { version } : {}),
+            models: normalizeProviderModels(provider.models),
+        };
+    }
+    async validateStart() {
+        return;
+    }
+    async startSession(input) {
+        if (this.#runtimes.has(input.payload.session_id)) {
+            throw new HarnessAdapterError("opencode_session_exists", `OpenCode session '${input.payload.session_id}' already exists.`);
+        }
+        const mcpServers = {};
+        for (const attachment of adapterMcpServers(input.mcpServers, input.payload)) {
+            assertCliMcpAttachmentProxied(attachment, "OpenCode", "opencode");
+            const name = cliMcpServerConfigName(attachment.name, "opencode");
+            mcpServers[name] = { type: "remote", url: attachment.url, enabled: true };
+        }
+        const runtime = await this.#runtimeFactory({
+            executable: input.provider.executable_path ?? "opencode",
+            launchArgs: input.provider.launch_args,
+            cwd: input.payload.cwd,
+            env: providerEnvironment(input.provider),
+            mcpServers,
+        });
+        this.#runtimes.set(input.payload.session_id, runtime);
+        return { adapter_session_id: runtime.sessionId };
+    }
+    async sendTurn(input) {
+        const runtime = this.#requireRuntime(input.payload.session_id);
+        if (this.#activeTurns.has(input.payload.session_id)) {
+            throw new HarnessAdapterError("opencode_turn_in_progress", `OpenCode session '${input.payload.session_id}' already has an active turn.`);
+        }
+        this.#activeTurns.set(input.payload.session_id, input.payload.turn_id);
+        try {
+            const finalText = await runtime.sendTurn({
+                turnId: input.payload.turn_id,
+                input: input.payload.input,
+                model: input.payload.model_selection?.model ?? input.startPayload.model_selection.model,
+                emitEvent: input.emitEvent ?? (() => { }),
+            });
+            return [
+                {
+                    event_type: "turn.completed",
+                    turn_id: input.payload.turn_id,
+                    data: { status: "completed", final_output: { final_text: finalText } },
+                },
+            ];
+        }
+        catch (error) {
+            if (this.#stopReasons.has(input.payload.session_id))
+                return [];
+            return [
+                turnFailedEvent(input.payload.turn_id, "provider_error", "opencode_turn_failed", error instanceof Error ? error.message : "OpenCode turn failed.", false),
+            ];
+        }
+        finally {
+            this.#activeTurns.delete(input.payload.session_id);
+            this.#stopReasons.delete(input.payload.session_id);
+        }
+    }
+    async cancelTurn(input) {
+        if (this.#activeTurns.get(input.sessionId) !== input.turnId) {
+            return [];
+        }
+        this.#stopReasons.set(input.sessionId, "cancel_requested");
+        await this.#requireRuntime(input.sessionId).cancelTurn();
+        return [
+            {
+                event_type: "turn.cancelled",
+                turn_id: input.turnId,
+                data: { status: "cancelled", final_output: { exit_reason: "cancel_requested" } },
+            },
+        ];
+    }
+    async stopSession(input) {
+        const runtime = this.#runtimes.get(input.sessionId);
+        if (!runtime) {
+            return [];
+        }
+        const activeTurnId = this.#activeTurns.get(input.sessionId);
+        if (activeTurnId)
+            this.#stopReasons.set(input.sessionId, "session_stopped");
+        this.#runtimes.delete(input.sessionId);
+        await runtime.close();
+        return activeTurnId
+            ? [
+                {
+                    event_type: "turn.cancelled",
+                    turn_id: activeTurnId,
+                    data: { status: "cancelled", final_output: { exit_reason: "session_stopped" } },
+                },
+            ]
+            : [];
+    }
+    #requireRuntime(sessionId) {
+        const runtime = this.#runtimes.get(sessionId);
+        if (!runtime) {
+            throw new HarnessAdapterError("opencode_session_not_found", `OpenCode session '${sessionId}' is not active.`);
+        }
+        return runtime;
+    }
+}
+async function runProbe(executable, args, provider, timeoutMs) {
+    const handle = spawnProviderCliProcess(executable, args, { cwd: process.cwd(), env: providerEnvironment(provider) });
+    let timeout;
+    const timedOut = new Promise((resolve) => {
+        timeout = setTimeout(() => {
+            handle.kill("SIGKILL");
+            resolve({ exitCode: null, signal: "SIGKILL", stdout: "", stderr: "", error: undefined, timedOut: true });
+        }, timeoutMs);
+    });
+    const result = await Promise.race([handle.result, timedOut]);
+    if (timeout)
+        clearTimeout(timeout);
+    return result;
+}
+async function startOpenCodeRuntime(input) {
+    const config = Object.keys(input.mcpServers).length > 0 ? { mcp: input.mcpServers } : {};
+    const child = spawn(input.executable, [...input.launchArgs, "serve", "--hostname=127.0.0.1", "--port=0"], {
+        cwd: input.cwd,
+        env: { ...process.env, ...input.env, OPENCODE_CONFIG_CONTENT: JSON.stringify(config) },
+        stdio: "pipe",
+        detached: process.platform !== "win32",
+    });
+    child.stdin.end();
+    const baseUrl = await waitForServerUrl(child, DEFAULT_SERVER_START_TIMEOUT_MS);
+    try {
+        const session = sessionSchema.parse(await fetchJson(new URL(`/session?directory=${encodeURIComponent(input.cwd)}`, baseUrl), {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ title: "HCP session" }),
+        }));
+        return new HttpOpenCodeRuntime(child, baseUrl, input.cwd, session.id);
+    }
+    catch (error) {
+        terminateProcess(child);
+        throw error;
+    }
+}
+class HttpOpenCodeRuntime {
+    #child;
+    #baseUrl;
+    #cwd;
+    sessionId;
+    #activeRequest;
+    constructor(child, baseUrl, cwd, sessionId) {
+        this.#child = child;
+        this.#baseUrl = baseUrl;
+        this.#cwd = cwd;
+        this.sessionId = sessionId;
+    }
+    async sendTurn(input) {
+        if (this.#activeRequest) {
+            throw new Error(`OpenCode session '${this.sessionId}' already has an active HTTP request.`);
+        }
+        const abortController = new AbortController();
+        this.#activeRequest = abortController;
+        const streamReady = createEventStream(new URL(`/event?directory=${encodeURIComponent(this.#cwd)}`, this.#baseUrl), this.sessionId, input, abortController.signal);
+        try {
+            await streamReady.ready;
+            const model = parseModel(input.model);
+            const response = promptResponseSchema.parse(await fetchJson(new URL(`/session/${encodeURIComponent(this.sessionId)}/message?directory=${encodeURIComponent(this.#cwd)}`, this.#baseUrl), {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({
+                    parts: [{ type: "text", text: input.input }],
+                    ...(model ? { model } : {}),
+                }),
+                signal: abortController.signal,
+            }));
+            await waitWithTimeout(streamReady.settled, DEFAULT_EVENT_SETTLE_TIMEOUT_MS, "OpenCode did not emit session.idle.");
+            return response.parts
+                .filter((part) => part.type === "text" && part.text !== undefined)
+                .map((part) => part.text ?? "")
+                .join("");
+        }
+        finally {
+            abortController.abort();
+            await streamReady.completed;
+            this.#activeRequest = undefined;
+        }
+    }
+    async cancelTurn() {
+        this.#activeRequest?.abort();
+        await fetchJson(new URL(`/session/${encodeURIComponent(this.sessionId)}/abort?directory=${encodeURIComponent(this.#cwd)}`, this.#baseUrl), {
+            method: "POST",
+        });
+    }
+    async close() {
+        this.#activeRequest?.abort();
+        terminateProcess(this.#child);
+    }
+}
+function createEventStream(url, sessionId, input, signal) {
+    let markReady = () => { };
+    let rejectReady = () => { };
+    const ready = new Promise((resolve, reject) => {
+        markReady = resolve;
+        rejectReady = reject;
+    });
+    let markSettled = () => { };
+    let rejectSettled = () => { };
+    const settled = new Promise((resolve, reject) => {
+        markSettled = resolve;
+        rejectSettled = reject;
+    });
+    const completed = (async () => {
+        try {
+            const response = await fetch(url, { headers: { accept: "text/event-stream" }, signal });
+            if (!response.ok || !response.body) {
+                throw new Error(`OpenCode event stream failed with HTTP ${response.status}.`);
+            }
+            markReady();
+            await consumeSse(response.body, (value) => {
+                const outcome = emitOpenCodeEvent(value, sessionId, input);
+                if (outcome === "settled")
+                    markSettled();
+                if (outcome instanceof Error)
+                    rejectSettled(outcome);
+            });
+        }
+        catch (error) {
+            if (!signal.aborted) {
+                const normalized = error instanceof Error ? error : new Error("OpenCode event stream failed.");
+                rejectReady(normalized);
+                throw normalized;
+            }
+            markReady();
+        }
+    })();
+    return { ready, settled, completed };
+}
+async function consumeSse(stream, onData) {
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffered = "";
+    while (true) {
+        const result = await reader.read();
+        if (result.done)
+            break;
+        buffered += decoder.decode(result.value, { stream: true }).replaceAll("\r\n", "\n");
+        let boundary;
+        while ((boundary = buffered.indexOf("\n\n")) >= 0) {
+            const block = buffered.slice(0, boundary);
+            buffered = buffered.slice(boundary + 2);
+            const data = block
+                .split("\n")
+                .filter((line) => line.startsWith("data:"))
+                .map((line) => line.slice(5).trimStart())
+                .join("\n");
+            if (data.length > 0)
+                onData(JSON.parse(data));
+        }
+    }
+}
+function emitOpenCodeEvent(value, sessionId, input) {
+    const event = eventSchema.parse(value);
+    if (event.type === "session.idle") {
+        return event.properties.sessionID === sessionId ? "settled" : "continue";
+    }
+    if (event.type === "session.error" && (event.properties.sessionID === undefined || event.properties.sessionID === sessionId)) {
+        return new Error("OpenCode reported a session error.");
+    }
+    if (event.type !== "message.part.updated")
+        return "continue";
+    const part = event.properties.part;
+    const partSchema = z.object({ sessionID: z.string(), type: z.string() }).passthrough();
+    const parsedPart = partSchema.parse(part);
+    if (parsedPart.sessionID !== sessionId)
+        return "continue";
+    const delta = event.properties.delta;
+    if (typeof delta !== "string" || delta.length === 0)
+        return "continue";
+    if (parsedPart.type !== "text" && parsedPart.type !== "reasoning")
+        return "continue";
+    input.emitEvent({
+        event_type: parsedPart.type === "reasoning" ? "reasoning.delta" : "content.delta",
+        turn_id: input.turnId,
+        data: { delta },
+    });
+    return "continue";
+}
+async function fetchJson(url, init) {
+    const response = await fetch(url, init);
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`OpenCode request failed with HTTP ${response.status}${body ? `: ${body}` : "."}`);
+    }
+    return (await response.json());
+}
+function waitForServerUrl(child, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        let output = "";
+        let settled = false;
+        const timeout = setTimeout(() => {
+            settleError(new Error(`Timed out waiting ${timeoutMs}ms for OpenCode server startup.`));
+        }, timeoutMs);
+        const settleError = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            terminateProcess(child);
+            reject(error);
+        };
+        const inspect = (chunk) => {
+            if (settled)
+                return;
+            output += chunk.toString("utf8");
+            const match = output.match(/opencode server listening[^\n]*on\s+(https?:\/\/[^\s]+)/i);
+            if (!match?.[1])
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            resolve(match[1]);
+        };
+        child.stdout.on("data", inspect);
+        child.stderr.on("data", inspect);
+        child.once("error", settleError);
+        child.once("exit", (code) => {
+            settleError(new Error(`OpenCode server exited before startup with code ${code ?? "unknown"}.`));
+        });
+    });
+}
+function terminateProcess(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    if (process.platform !== "win32" && child.pid) {
+        try {
+            process.kill(-child.pid, "SIGTERM");
+            return;
+        }
+        catch (error) {
+            if (!(error instanceof Error))
+                throw error;
+        }
+    }
+    child.kill("SIGTERM");
+}
+function parseModel(model) {
+    const separator = model.indexOf("/");
+    if (separator <= 0 || separator === model.length - 1)
+        return undefined;
+    return { providerID: model.slice(0, separator), modelID: model.slice(separator + 1) };
+}
+function providerEnvironment(provider) {
+    return { ...(provider.home ? { HOME: provider.home } : {}), ...provider.env };
+}
+async function waitWithTimeout(completion, timeoutMs, message) {
+    let timeout;
+    const expired = new Promise((_resolve, reject) => {
+        timeout = setTimeout(() => reject(new Error(message)), timeoutMs);
+    });
+    try {
+        await Promise.race([completion, expired]);
+    }
+    finally {
+        if (timeout)
+            clearTimeout(timeout);
+    }
+}
+//# sourceMappingURL=opencode.js.map

package/dist/harnesses/adapters/providers/shared.d.ts

@@ -0,0 +1,9 @@
+import type { HarnessModel, HcpSessionStartPayload } from "@harness-control/protocol";
+import type { ProviderInstanceConfig } from "../../../config/index.js";
+import { type HarnessAdapterEvent, type HarnessAdapterMcpServer } from "../types.js";
+export declare function normalizeProviderModels(models: ProviderInstanceConfig["models"]): HarnessModel[];
+export declare function turnFailedEvent(turnId: string, exitReason: string, code: string, message: string, retryable: boolean, details?: Record<string, unknown>): HarnessAdapterEvent;
+export declare function assertCliMcpAttachmentProxied(attachment: HarnessAdapterMcpServer, providerLabel: string, errorPrefix: string): void;
+export declare function adapterMcpServers(resolved: HarnessAdapterMcpServer[] | undefined, payload: HcpSessionStartPayload): HarnessAdapterMcpServer[];
+export declare function cliMcpServerConfigName(name: string, errorPrefix: string): string;
+//# sourceMappingURL=shared.d.ts.map

package/dist/harnesses/adapters/providers/shared.js

@@ -0,0 +1,97 @@
+import { HarnessAdapterError, } from "../types.js";
+export function normalizeProviderModels(models) {
+    return models.map((model) => {
+        const normalized = {
+            id: model.id,
+            label: model.label,
+            capabilities: {
+                option_descriptors: model.capabilities.option_descriptors.map((option) => {
+                    const normalizedOption = {
+                        id: option.id,
+                        label: option.label,
+                        type: option.type,
+                    };
+                    if (option.values !== undefined) {
+                        normalizedOption.values = option.values;
+                    }
+                    if (option.default_value !== undefined) {
+                        normalizedOption.default_value = option.default_value;
+                    }
+                    if (option.current_value !== undefined) {
+                        normalizedOption.current_value = option.current_value;
+                    }
+                    if (option.prompt_injected_values !== undefined) {
+                        normalizedOption.prompt_injected_values = option.prompt_injected_values;
+                    }
+                    return normalizedOption;
+                }),
+            },
+        };
+        if (model.is_default !== undefined) {
+            normalized.is_default = model.is_default;
+        }
+        return normalized;
+    });
+}
+export function turnFailedEvent(turnId, exitReason, code, message, retryable, details) {
+    return {
+        event_type: "turn.failed",
+        turn_id: turnId,
+        data: {
+            status: "failed",
+            final_output: {
+                exit_reason: exitReason,
+            },
+            error: {
+                code,
+                message,
+                retryable,
+                ...(details ? { details } : {}),
+            },
+        },
+    };
+}
+export function assertCliMcpAttachmentProxied(attachment, providerLabel, errorPrefix) {
+    cliMcpServerConfigName(attachment.name, errorPrefix);
+    if (Object.keys(attachment.headers).length > 0) {
+        throw new HarnessAdapterError(`${errorPrefix}_mcp_attachment_requires_proxy`, `${providerLabel} MCP attachment '${attachment.name}' must not expose platform headers to ${providerLabel}; route it through the runner-owned proxy.`);
+    }
+    let parsedUrl;
+    try {
+        parsedUrl = new URL(attachment.url);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new HarnessAdapterError(`${errorPrefix}_mcp_attachment_url_invalid`, error.message);
+        }
+        throw error;
+    }
+    const isLoopback = parsedUrl.protocol === "http:" && (parsedUrl.hostname === "127.0.0.1" || parsedUrl.hostname === "localhost");
+    if (!isLoopback) {
+        throw new HarnessAdapterError(`${errorPrefix}_mcp_attachment_requires_proxy`, `${providerLabel} MCP attachments must be routed through a runner-owned loopback MCP proxy so HCP proof headers can be injected.`);
+    }
+}
+export function adapterMcpServers(resolved, payload) {
+    if (resolved)
+        return resolved;
+    return payload.mcp_servers.map((attachment) => {
+        if (attachment.transport !== "streamable_http") {
+            throw new HarnessAdapterError("mcp_stdio_profile_unresolved", `Runner MCP profile '${attachment.profile_id}' must be resolved before starting a provider adapter.`);
+        }
+        return {
+            name: attachment.name,
+            transport: "streamable_http",
+            url: attachment.url,
+            headers: attachment.headers,
+            ...(attachment.allowed_tools ? { allowed_tools: attachment.allowed_tools } : {}),
+            ...(attachment.denied_tools ? { denied_tools: attachment.denied_tools } : {}),
+        };
+    });
+}
+export function cliMcpServerConfigName(name, errorPrefix) {
+    if (!/^[A-Za-z0-9_-]+$/.test(name)) {
+        throw new HarnessAdapterError(`${errorPrefix}_mcp_attachment_name_invalid`, `MCP attachment name '${name}' must contain only ASCII letters, numbers, underscores, or hyphens.`);
+    }
+    return name;
+}
+//# sourceMappingURL=shared.js.map

package/dist/harnesses/adapters/registry.d.ts

@@ -0,0 +1,12 @@
+import type { ProviderInstanceConfig } from "../../config/index.js";
+import type { ProviderDriverStatus } from "../../host/provider-registry.js";
+import { type HarnessAdapter } from "./types.js";
+export declare class HarnessAdapterRegistry {
+    #private;
+    constructor(adapters: HarnessAdapter[]);
+    get(driverKind: string): HarnessAdapter | undefined;
+    require(driverKind: string): HarnessAdapter;
+    probeProviders(providers: ProviderInstanceConfig[]): Promise<ProviderDriverStatus[]>;
+}
+export declare function createDefaultHarnessAdapterRegistry(): HarnessAdapterRegistry;
+//# sourceMappingURL=registry.d.ts.map

package/dist/harnesses/adapters/registry.js

@@ -0,0 +1,47 @@
+import { ClaudeHarnessAdapter } from "./providers/claude.js";
+import { CodexHarnessAdapter } from "./providers/codex.js";
+import { MockHarnessAdapter } from "./providers/mock.js";
+import { OpenCodeHarnessAdapter } from "./providers/opencode.js";
+import { HarnessAdapterError } from "./types.js";
+export class HarnessAdapterRegistry {
+    #adapters;
+    constructor(adapters) {
+        this.#adapters = new Map(adapters.map((adapter) => [adapter.driverKind, adapter]));
+    }
+    get(driverKind) {
+        return this.#adapters.get(driverKind);
+    }
+    require(driverKind) {
+        const adapter = this.get(driverKind);
+        if (!adapter) {
+            throw new HarnessAdapterError("provider_driver_unavailable", `Provider driver '${driverKind}' is not available in this runner.`);
+        }
+        return adapter;
+    }
+    async probeProviders(providers) {
+        return await Promise.all(providers.map(async (provider) => {
+            const adapter = this.get(provider.driver_kind);
+            if (!adapter) {
+                return {
+                    provider_instance_id: provider.id,
+                    driver_kind: provider.driver_kind,
+                    installed: false,
+                    available: false,
+                    status: "unavailable",
+                    message: `Unsupported provider driver '${provider.driver_kind}'.`,
+                    models: [],
+                };
+            }
+            return adapter.probe(provider);
+        }));
+    }
+}
+export function createDefaultHarnessAdapterRegistry() {
+    return new HarnessAdapterRegistry([
+        new MockHarnessAdapter(),
+        new CodexHarnessAdapter(),
+        new ClaudeHarnessAdapter(),
+        new OpenCodeHarnessAdapter(),
+    ]);
+}
+//# sourceMappingURL=registry.js.map

package/dist/harnesses/adapters/types.d.ts

@@ -0,0 +1,54 @@
+import type { HcpEventType, HcpSessionStartPayload, HcpTurnSendPayload } from "@harness-control/protocol";
+import type { ProviderInstanceConfig } from "../../config/index.js";
+import type { ProviderDriverStatus } from "../../host/provider-registry.js";
+export type HarnessAdapterEvent = {
+    event_type: HcpEventType;
+    turn_id?: string;
+    data: Record<string, unknown>;
+};
+export type HarnessAdapterSession = {
+    adapter_session_id: string;
+};
+export type HarnessAdapterMcpServer = {
+    name: string;
+    transport: "streamable_http";
+    url: string;
+    headers: Record<string, string>;
+    allowed_tools?: string[];
+    denied_tools?: string[];
+};
+export type HarnessAdapterStartInput = {
+    payload: HcpSessionStartPayload;
+    provider: ProviderInstanceConfig;
+    mcpServers?: HarnessAdapterMcpServer[];
+};
+export type HarnessAdapterTurnInput = {
+    payload: HcpTurnSendPayload;
+    session: HarnessAdapterSession;
+    startPayload: HcpSessionStartPayload;
+    provider: ProviderInstanceConfig;
+    mcpServers?: HarnessAdapterMcpServer[];
+    emitEvent?: (event: HarnessAdapterEvent) => void;
+};
+export type HarnessAdapterCancelInput = {
+    sessionId: string;
+    turnId: string;
+};
+export type HarnessAdapterStopInput = {
+    sessionId: string;
+    reason?: string;
+};
+export type HarnessAdapter = {
+    readonly driverKind: string;
+    probe(provider: ProviderInstanceConfig): Promise<ProviderDriverStatus>;
+    validateStart(input: HarnessAdapterStartInput): Promise<void>;
+    startSession(input: HarnessAdapterStartInput): Promise<HarnessAdapterSession>;
+    sendTurn(input: HarnessAdapterTurnInput): Promise<HarnessAdapterEvent[]>;
+    cancelTurn(input: HarnessAdapterCancelInput): Promise<HarnessAdapterEvent[]>;
+    stopSession(input: HarnessAdapterStopInput): Promise<HarnessAdapterEvent[]>;
+};
+export declare class HarnessAdapterError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/harnesses/adapters/types.js

@@ -0,0 +1,9 @@
+export class HarnessAdapterError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "HarnessAdapterError";
+    }
+}
+//# sourceMappingURL=types.js.map

package/dist/harnesses/adapters.d.ts

@@ -0,0 +1,8 @@
+export { HarnessAdapterError, type HarnessAdapter, type HarnessAdapterCancelInput, type HarnessAdapterEvent, type HarnessAdapterMcpServer, type HarnessAdapterSession, type HarnessAdapterStartInput, type HarnessAdapterStopInput, type HarnessAdapterTurnInput, } from "./adapters/types.js";
+export { HarnessAdapterRegistry, createDefaultHarnessAdapterRegistry } from "./adapters/registry.js";
+export { type CliManagedProcess, type CliProcessHandle, type CliProcessResult, type CliProcessRunOptions, type CliProcessSpawner, type CodexProcessHandle, type CodexProcessResult, type CodexProcessRunOptions, type CodexProcessSpawner, spawnProviderCliProcess, startManagedCliProcess, } from "./adapters/providers/cli-process.js";
+export { MockHarnessAdapter } from "./adapters/providers/mock.js";
+export { CodexHarnessAdapter, type CodexHarnessAdapterOptions } from "./adapters/providers/codex.js";
+export { ClaudeHarnessAdapter, type ClaudeHarnessAdapterOptions } from "./adapters/providers/claude.js";
+export { OpenCodeHarnessAdapter, type OpenCodeHarnessAdapterOptions, type OpenCodeRuntime, type OpenCodeRuntimeFactory, type OpenCodeRuntimeTurnInput, } from "./adapters/providers/opencode.js";
+//# sourceMappingURL=adapters.d.ts.map

package/dist/harnesses/adapters.js

@@ -0,0 +1,8 @@
+export { HarnessAdapterError, } from "./adapters/types.js";
+export { HarnessAdapterRegistry, createDefaultHarnessAdapterRegistry } from "./adapters/registry.js";
+export { spawnProviderCliProcess, startManagedCliProcess, } from "./adapters/providers/cli-process.js";
+export { MockHarnessAdapter } from "./adapters/providers/mock.js";
+export { CodexHarnessAdapter } from "./adapters/providers/codex.js";
+export { ClaudeHarnessAdapter } from "./adapters/providers/claude.js";
+export { OpenCodeHarnessAdapter, } from "./adapters/providers/opencode.js";
+//# sourceMappingURL=adapters.js.map