akm-cli 0.9.31 → 0.10.261002-beta

package/dist/integrations/harnesses/opencode-sdk/sdk-runner.js

@@ -16,6 +16,17 @@
  * 'opencode-sdk'`). It is the dispatch path for SDK runner specs; it exposes
  * no native session logs of its own (`capabilities.sessionLogs = false`).
  *
+ * ## Two OpenCode majors, one runner (#1049)
+ *
+ * This file owns what both majors share: the managed `opencode serve` child
+ * (spawn, port, registry, cleanup, {@link closeServer}), the child environment,
+ * per-workspace isolation, deadlines, abort handling and result shaping. The
+ * per-major wire protocol is an adapter behind `./wire.ts`, chosen once per
+ * dispatch from the major the engine's binary reports
+ * (`../opencode/version.ts`); the major is part of the server registry key.
+ * Where the sections below name an OpenCode 1 wire shape (`query.directory`,
+ * the prompt body), `v2-adapter.ts` has the OpenCode 2 equivalent.
+ *
  * ## Sessions are kept (#1100)
  *
  * One session is created per dispatch and is NEVER deleted: it stays in
@@ -84,7 +95,7 @@
  * until the child ACTUALLY exits — and a real `opencode serve` (a live HTTP
  * server with provider children) can outlive SIGTERM long enough to hang the
  * caller indefinitely. {@link createManagedOpencode} therefore owns the spawn
- * (the SDK package is used only for `createOpencodeClient`).
+ * (the SDK package is used only for its client).
  *
  * Owning the spawn changes the LIFECYCLE, not the REQUIREMENT: the SDK's
  * `createOpencodeServer` is itself a `spawn("opencode", ["serve", ...])`, and
@@ -102,11 +113,14 @@
  */
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
-import { isRecord } from "../../../core/common.js";
 import { COMMON_SPAWN_ENV_PASSTHROUGH, OPENCODE_ENV_PASSTHROUGH, spawnEnvNamesFor } from "../../../core/spawn-env.js";
 import { DEFAULT_AGENT_TIMEOUT_MS } from "../../agent/config.js";
 import { opencodeInferenceConfig } from "../opencode/model-config.js";
 import { MODEL_WORK_OPENCODE_AGENT, modelWorkOpencodeConfig, modelWorkPluginEnv } from "../opencode/model-work-agent.js";
+import { detectOpencodeMajor } from "../opencode/version.js";
+import { V1_ADAPTER } from "./v1-adapter.js";
+import { V2_ADAPTER } from "./v2-adapter.js";
+import { parseReadiness, } from "./wire.js";
 // Server registry — one server per complete server-material signature. Caller
 // deadlines race the shared promise independently; they never become startup
 // configuration inherited by later callers.
@@ -299,9 +313,10 @@ export function buildSdkConfig(profile, llmConfig, modelWork = false, requestInf
     }
     return modelWork ? { ...sdkConfig, ...modelWorkOpencodeConfig(agentOptions) } : sdkConfig;
 }
-/** Digest the executable and exact environment received by the child. */
-function serverRegistryKey(profile, env) {
-    const material = { bin: profile.bin, env };
+/** Digest the OpenCode major, the executable and the exact environment received by the child. */
+function serverRegistryKey(adapter, profile, env) {
+    // The major is part of the identity: a v1 and a v2 server never share an entry.
+    const material = { major: adapter.major, bin: profile.bin, env };
     return createHash("sha256")
         .update(JSON.stringify(canonicalize(material)))
         .digest("hex");
@@ -425,13 +440,13 @@ export function __setServeCommand(argv) {
  *   - handshake failure → the child is killed and unref'ed before rejecting.
  */
 async function createManagedOpencode(options) {
-    const { createOpencodeClient } = (await import("@opencode-ai/sdk").catch(() => {
-        throw new Error("OpenCode SDK not available. Install @opencode-ai/sdk or configure a CLI agent instead.");
-    }));
+    const { adapter } = options;
     const port = options.port ?? DEFAULT_SDK_PORT;
-    const argv = _serveCommand ?? [options.bin ?? "opencode", "serve", "--hostname=127.0.0.1", `--port=${port}`];
+    const argv = _serveCommand ?? adapter.serveArgv(options.bin ?? "opencode", port);
+    // The adapter may add to the child's environment (V2: the server password akm chose).
+    const authorization = adapter.authorize();
     const proc = spawn(argv[0], argv.slice(1), {
-        env: options.env,
+        env: { ...options.env, ...authorization.env },
         stdio: ["ignore", "pipe", "pipe"],
     });
     let closeStarted = false;
@@ -516,15 +531,14 @@ async function createManagedOpencode(options) {
         const onStdoutData = (chunk) => {
             output += chunk.toString();
             for (const line of output.split("\n")) {
-                if (line.startsWith("opencode server listening")) {
-                    const match = line.match(/on\s+(https?:\/\/\S+)/);
-                    if (!match?.[1]) {
-                        fail(new Error(`Failed to parse the OpenCode server url from: ${line}`));
-                        return;
-                    }
-                    succeed(match[1]);
-                    return;
-                }
+                const verdict = parseReadiness(line, adapter.major);
+                if (!verdict)
+                    continue;
+                if ("error" in verdict)
+                    fail(new Error(verdict.error));
+                else
+                    succeed(verdict.url);
+                return;
             }
         };
         const onStderrData = (chunk) => {
@@ -553,62 +567,18 @@ async function createManagedOpencode(options) {
     proc.stdout?.destroy();
     proc.stderr?.destroy();
     proc.unref();
-    const client = createOpencodeClient({ baseUrl: url });
-    client.event = { subscribe: (args) => subscribeEvents(url, args) };
-    return { client, server: { close: closeManaged } };
-}
-/**
- * Subscribe to the server's event stream. The SDK's own `event.subscribe`
- * cannot be closed safely: aborting it leaves an unhandled `AbortError`
- * rejection (from its un-awaited `reader.cancel()`), which akm's global
- * handler turns into a process exit. This reader ends quietly on abort.
- */
-async function subscribeEvents(baseUrl, args) {
-    const eventUrl = new URL("/event", baseUrl);
-    if (args.query?.directory)
-        eventUrl.searchParams.set("directory", args.query.directory);
-    const response = await fetch(eventUrl, { signal: args.signal, headers: { accept: "text/event-stream" } });
-    if (!response.ok || !response.body)
-        throw new Error(`OpenCode event stream failed: HTTP ${response.status}`);
-    const reader = response.body.getReader();
-    async function* stream() {
-        const decoder = new TextDecoder();
-        let buffer = "";
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done)
-                    return;
-                buffer += decoder.decode(value, { stream: true });
-                const frames = buffer.split("\n\n");
-                buffer = frames.pop() ?? "";
-                for (const frame of frames) {
-                    const data = frame
-                        .split("\n")
-                        .filter((line) => line.startsWith("data:"))
-                        .map((line) => line.replace(/^data:\s*/, ""))
-                        .join("\n");
-                    if (!data)
-                        continue;
-                    try {
-                        yield JSON.parse(data);
-                    }
-                    catch {
-                        /* not JSON: not an event we act on */
-                    }
-                }
-            }
-        }
-        catch (err) {
-            if (!args.signal.aborted)
-                throw err;
-        }
+    try {
+        return { client: await adapter.connect(url, authorization.credentials), server: { close: closeManaged } };
+    }
+    catch (err) {
+        closeManaged();
+        throw err;
     }
-    return { stream: stream() };
 }
-async function startServer(profile, sdkConfig, env, registryKey, startupSignal) {
+async function startServer(adapter, profile, sdkConfig, env, registryKey, startupSignal) {
     const factory = _serverFactory ?? createManagedOpencode;
     const options = {
+        adapter,
         bin: profile.bin,
         ...(Object.keys(sdkConfig).length > 0 ? { config: sdkConfig } : {}),
         env,
@@ -651,17 +621,17 @@ async function startServer(profile, sdkConfig, env, registryKey, startupSignal)
  * start (the registry stores the in-flight promise). A failed start is
  * evicted so the next call can retry instead of caching the error forever.
  */
-function getOrStartServer(profile, llmConfig, env, envSource = process.env, modelWork = false, inference) {
+function getOrStartServer(adapter, profile, llmConfig, env, envSource = process.env, modelWork = false, inference) {
     if (_testServer)
         return { promise: Promise.resolve(_testServer), release() { } };
     const sdkConfig = buildSdkConfig(profile, llmConfig, modelWork, inference);
     const serverEnv = buildServerEnv(profile, sdkConfig, env, envSource, modelWork);
-    const key = serverRegistryKey(profile, serverEnv);
+    const key = serverRegistryKey(adapter, profile, serverEnv);
     let entry = _servers.get(key);
     if (!entry) {
         const controller = new AbortController();
         entry = {
-            promise: startServer(profile, sdkConfig, serverEnv, key, controller.signal),
+            promise: startServer(adapter, profile, sdkConfig, serverEnv, key, controller.signal),
             controller,
             waiters: 0,
         };
@@ -699,25 +669,6 @@ function getOrStartServer(profile, llmConfig, env, envSource = process.env, mode
         },
     };
 }
-/**
- * Extract best-effort token usage from a prompt response. Only numeric
- * fields the server actually reported are copied; returns undefined when
- * nothing usable is present (older servers, test fakes).
- */
-function extractUsage(info) {
-    const tokens = info?.tokens;
-    if (!tokens)
-        return undefined;
-    const usage = {};
-    if (typeof tokens.input === "number" && Number.isFinite(tokens.input))
-        usage.inputTokens = tokens.input;
-    if (typeof tokens.output === "number" && Number.isFinite(tokens.output))
-        usage.outputTokens = tokens.output;
-    if (typeof tokens.reasoning === "number" && Number.isFinite(tokens.reasoning)) {
-        usage.reasoningTokens = tokens.reasoning;
-    }
-    return Object.keys(usage).length > 0 ? usage : undefined;
-}
 const SDK_OPERATION_TIMED_OUT = Symbol("opencode-sdk-operation-timeout");
 const SDK_OPERATION_ABORTED = Symbol("opencode-sdk-operation-aborted");
 async function raceSdkOperation(operation, opts) {
@@ -753,29 +704,6 @@ async function raceSdkOperation(operation, opts) {
 function errorText(err) {
     return err instanceof Error ? err.message : String(err);
 }
-/**
- * Map an SDK `{ error }` result or a reply's `info.error` onto a failure
- * (#1015). Both are opencode NamedErrors, `{ name, data: { message } }`. An
- * aborted message is `aborted`, a reply cut off at the output limit is
- * `parse_error`, and every other error (auth, API, unknown, an HTTP error
- * body) is `non_zero_exit`.
- */
-function sdkErrorFailure(error) {
-    if (!isRecord(error) || typeof error.name !== "string") {
-        return { reason: "non_zero_exit", message: typeof error === "string" ? error : JSON.stringify(error) };
-    }
-    const detail = isRecord(error.data) ? error.data.message : undefined;
-    const message = typeof detail === "string" ? `${error.name}: ${detail}` : error.name;
-    if (error.name === "MessageAbortedError")
-        return { reason: "aborted", message };
-    if (error.name === "MessageOutputLengthError")
-        return { reason: "parse_error", message };
-    return { reason: "non_zero_exit", message };
-}
-/** Stop a server-side session that the dispatch has given up on, so it stops calling the model. */
-function abortSessionBestEffort(client, sessionId, query) {
-    void client.session.abort?.({ path: { id: sessionId }, ...(query ? { query } : {}) }).catch(() => { });
-}
 /**
  * Answer every OpenCode permission request of the dispatch's session (and of
  * the sub-sessions it spawns) with "reject", once each. This is what a
@@ -785,78 +713,52 @@ function abortSessionBestEffort(client, sessionId, query) {
  * model as a tool error it can work around. Each request and answer is
  * appended to `notes`. The same stream reports OpenCode's retries (#1108):
  * each is noted, and one caused by a usage limit, or due after `deadline`,
- * ends the run through `stopForRetry` instead of a silent wait. `ready` (absent when the client has no event surface)
+ * ends the run through `stopForRetry` instead of a silent wait. `ready`
  * settles once the subscription is open and never rejects; `stop` closes it.
+ * The wire format (event shapes, the reject call) is the adapter's.
  */
-function rejectPermissionRequests(client, sessionId, query, notes, deadline, stopForRetry) {
-    const subscribe = client.event?.subscribe;
-    const reply = client.postSessionIdPermissionsPermissionId;
+function rejectPermissionRequests(adapter, client, sessionId, spec, notes, deadline, stopForRetry) {
     const controller = new AbortController();
     const stop = () => controller.abort();
-    if (!subscribe || !reply)
+    if (adapter.canWatch?.(client) === false)
         return { stop };
     const sessions = new Set([sessionId]);
     const answered = new Set();
     const consume = async (stream) => {
-        for await (const event of stream) {
-            if (!isRecord(event) || !isRecord(event.properties))
+        for await (const raw of stream) {
+            const event = adapter.decodeEvent(raw);
+            if (!event)
                 continue;
-            const props = event.properties;
-            if (event.type === "session.created" && isRecord(props.info)) {
-                const { id, parentID } = props.info;
-                if (typeof id === "string" && typeof parentID === "string" && sessions.has(parentID))
-                    sessions.add(id);
+            if (event.kind === "session") {
+                if (event.parentId !== undefined && sessions.has(event.parentId))
+                    sessions.add(event.id);
                 continue;
             }
-            if (event.type === "session.status") {
-                const { sessionID, status } = props;
-                if (typeof sessionID !== "string" || !sessions.has(sessionID) || !isRecord(status) || status.type !== "retry") {
-                    continue;
-                }
-                const attempt = typeof status.attempt === "number" ? status.attempt : "unknown";
-                const message = typeof status.message === "string" ? status.message : "OpenCode is retrying";
-                const next = typeof status.next === "number" ? status.next : undefined;
-                const retryAt = next === undefined ? "unknown time" : new Date(next).toISOString();
-                // `action` is not present in the SDK's retry type yet, but current
-                // OpenCode servers include it for provider/account limits.
-                const action = isRecord(status.action) ? status.action : undefined;
-                const provider = typeof action?.provider === "string" ? action.provider : undefined;
-                notes.push(`OpenCode retry attempt ${attempt}${provider ? ` (${provider})` : ""}: ${message}; retrying at ${retryAt}`);
-                if (action?.reason === "account_rate_limit") {
-                    stopForRetry(`OpenCode provider limit stopped this run${provider ? ` (${provider})` : ""}: ${message}; reset at ${retryAt}`);
+            if (!sessions.has(event.sessionId))
+                continue;
+            if (event.kind === "retry") {
+                const retryAt = event.next === undefined ? "unknown time" : new Date(event.next).toISOString();
+                notes.push(`OpenCode retry attempt ${event.attempt ?? "unknown"}${event.provider ? ` (${event.provider})` : ""}: ${event.message}; retrying at ${retryAt}`);
+                if (event.accountLimit) {
+                    stopForRetry(`OpenCode provider limit stopped this run${event.provider ? ` (${event.provider})` : ""}: ${event.message}; reset at ${retryAt}`);
                 }
-                else if (next !== undefined && deadline !== null && next > deadline) {
-                    stopForRetry(`OpenCode's next retry (${retryAt}) is after this run's deadline: ${message}`);
+                else if (event.next !== undefined && deadline !== null && event.next > deadline) {
+                    stopForRetry(`OpenCode's next retry (${retryAt}) is after this run's deadline: ${event.message}`);
                 }
                 continue;
             }
-            // `permission.asked` (OpenCode >= 1.3) / `permission.updated` (older).
-            if (event.type !== "permission.asked" && event.type !== "permission.updated")
+            if (answered.has(event.requestId))
                 continue;
-            const { id, sessionID } = props;
-            if (typeof id !== "string" || typeof sessionID !== "string")
-                continue;
-            if (!sessions.has(sessionID) || answered.has(id))
-                continue;
-            answered.add(id);
-            const patterns = Array.isArray(props.patterns) ? props.patterns : props.pattern ? [props.pattern] : [];
-            notes.push(`permission requested: ${String(props.permission ?? props.type ?? "unknown")} (${patterns.join(", ")}); auto-rejecting`);
-            reply
-                .call(client, {
-                path: { id: sessionID, permissionID: id },
-                body: { response: "reject" },
-                ...(query ? { query } : {}),
-            })
-                .then((r) => {
-                if (r.error)
-                    notes.push(`permission reply for ${id} failed: ${JSON.stringify(r.error)}`);
-            })
-                .catch((err) => notes.push(`permission reply for ${id} failed: ${errorText(err)}`));
+            answered.add(event.requestId);
+            notes.push(`permission requested: ${event.description}; auto-rejecting`);
+            adapter.rejectPermission(client, event, spec).catch((err) => {
+                notes.push(`permission reply for ${event.requestId} failed: ${errorText(err)}`);
+            });
         }
     };
-    const ready = subscribe
-        .call(client.event, { ...(query ? { query } : {}), signal: controller.signal })
-        .then(({ stream }) => {
+    const ready = adapter
+        .subscribe(client, spec, controller.signal)
+        .then((stream) => {
         void consume(stream).catch((err) => {
             if (!controller.signal.aborted)
                 notes.push(`permission event stream ended: ${errorText(err)}`);
@@ -867,6 +769,11 @@ function rejectPermissionRequests(client, sessionId, query, notes, deadline, sto
     });
     return { ready, stop };
 }
+const ADAPTERS = { 1: V1_ADAPTER, 2: V2_ADAPTER };
+/** The wire adapter for the OpenCode major the engine's binary reports. */
+function adapterFor(profile) {
+    return ADAPTERS[detectOpencodeMajor(profile.bin).major];
+}
 function abortedBeforeSdkStart(profile) {
     return {
         ok: false,
@@ -888,12 +795,13 @@ export async function runOpencodeSdk(profile, prompt, opts = {}, llmConfig) {
     if (opts.signal?.aborted)
         return abortedBeforeSdkStart(profile);
     const modelWork = opts.dispatch?.modelWork === true;
+    const adapter = adapterFor(profile);
     let client;
     if (_testServer) {
         client = _testServer.client;
     }
     else {
-        const startupHandle = getOrStartServer(profile, llmConfig, opts.env, opts.envSource, modelWork, opts.dispatch?.inference);
+        const startupHandle = getOrStartServer(adapter, profile, llmConfig, opts.env, opts.envSource, modelWork, opts.dispatch?.inference);
         try {
             const startup = await raceSdkOperation(startupHandle.promise, {
                 timeoutMs: remainingTimeoutMs(),
@@ -945,10 +853,23 @@ export async function runOpencodeSdk(profile, prompt, opts = {}, llmConfig) {
     // local-model endpoint or wedged server could block the caller indefinitely.
     // The same absolute deadline covers server startup, session creation, and
     // prompting. null disables every dispatch timer.
-    // Per-call working directory (module doc): forwarded as the SDK's
-    // `query.directory` on every session call, so worktree-isolated units run
-    // in their own checkout without a per-cwd server.
-    const query = opts.cwd ? { directory: opts.cwd } : undefined;
+    // Per-call working directory (module doc): the adapter scopes the session to
+    // it, so worktree-isolated units run in their own checkout without a
+    // per-cwd server.
+    // Forward the exact native agent selector, systemPrompt, and tools from the abstract
+    // dispatch request. Both were once accepted on AgentDispatchRequest but silently dropped
+    // on the SDK path (#564). Model work runs the confined agent its server config defines;
+    // its tools are that agent's.
+    const dispatch = opts.dispatch;
+    const agent = modelWork ? MODEL_WORK_OPENCODE_AGENT : dispatch?.agent;
+    const system = dispatch?.systemPrompt;
+    const tools = toolsToSdkAllowlist(dispatch?.tools);
+    const spec = {
+        ...(opts.cwd ? { directory: opts.cwd } : {}),
+        ...(agent ? { agent } : {}),
+        ...(system ? { system } : {}),
+        ...(tools ? { tools } : {}),
+    };
     // One session per call — do NOT reuse (history accumulates, token costs grow).
     // Session creation is startup plumbing, so failures map to spawn_failed rather
     // than bubbling out as a generic workflow dispatch exception.
@@ -962,7 +883,7 @@ export async function runOpencodeSdk(profile, prompt, opts = {}, llmConfig) {
     const abortSignal = runController.signal;
     let sessionId;
     try {
-        const created = await raceSdkOperation(client.session.create({ body: { title: "akm" }, ...(query ? { query } : {}) }), {
+        const created = await raceSdkOperation(adapter.createSession(client, spec), {
             timeoutMs: remainingTimeoutMs(),
             setTimeoutFn: setTimeoutImpl,
             clearTimeoutFn: clearTimeoutImpl,
@@ -990,7 +911,7 @@ export async function runOpencodeSdk(profile, prompt, opts = {}, llmConfig) {
                 error: `opencode-sdk agent "${profile.name}" timed out creating a session after ${timeoutMs}ms`,
             };
         }
-        sessionId = created.data?.id;
+        sessionId = created;
     }
     catch (err) {
         return {
@@ -1014,27 +935,11 @@ export async function runOpencodeSdk(profile, prompt, opts = {}, llmConfig) {
             error: "Failed to create OpenCode session",
         };
     }
-    // Forward the exact native agent selector, systemPrompt, and tools from the abstract
-    // dispatch request. Both were previously accepted on AgentDispatchRequest but
-    // silently dropped on the SDK path, so SDK-mode dispatch ignored agent-asset
-    // system prompts and tool policies entirely (the CLI path honours both).
-    // Model work runs the confined agent its server config defines; its tools are that agent's.
-    const dispatch = opts.dispatch;
-    const agent = modelWork ? MODEL_WORK_OPENCODE_AGENT : dispatch?.agent;
-    const system = dispatch?.systemPrompt;
-    const tools = toolsToSdkAllowlist(dispatch?.tools);
-    const body = { parts: [{ type: "text", text: prompt }] };
-    if (agent)
-        body.agent = agent;
-    if (system)
-        body.system = system;
-    if (tools)
-        body.tools = tools;
     let result;
     // Subscribed before the prompt so no request can be missed; closed in `finally`.
     const permissionNotes = [];
     let retryFailure;
-    const permissions = rejectPermissionRequests(client, sessionId, query, permissionNotes, deadline, (failure) => {
+    const permissions = rejectPermissionRequests(adapter, client, sessionId, spec, permissionNotes, deadline, (failure) => {
         retryFailure ??= failure;
         runController.abort();
     });
@@ -1048,7 +953,7 @@ export async function runOpencodeSdk(profile, prompt, opts = {}, llmConfig) {
                 signal: abortSignal,
             });
         }
-        const prompted = await raceSdkOperation(client.session.prompt({ path: { id: sessionId }, body, ...(query ? { query } : {}) }), {
+        const prompted = await raceSdkOperation(adapter.prompt(client, sessionId, prompt, spec, abortSignal), {
             timeoutMs: remainingTimeoutMs(),
             setTimeoutFn: setTimeoutImpl,
             clearTimeoutFn: clearTimeoutImpl,
@@ -1056,7 +961,7 @@ export async function runOpencodeSdk(profile, prompt, opts = {}, llmConfig) {
         });
         // A session the dispatch stops early is aborted on the server too.
         if (prompted === SDK_OPERATION_ABORTED || prompted === SDK_OPERATION_TIMED_OUT) {
-            abortSessionBestEffort(client, sessionId, query);
+            adapter.abort(client, sessionId, spec);
         }
         if (prompted === SDK_OPERATION_ABORTED && retryFailure) {
             result = {
@@ -1095,16 +1000,8 @@ export async function runOpencodeSdk(profile, prompt, opts = {}, llmConfig) {
             };
         }
         else {
-            const parts = prompted.data?.parts ?? [];
-            // The last text part is the answer; earlier ones narrate the steps before it.
-            const stdout = parts.filter((p) => p.type === "text").at(-1)?.text ?? "";
-            // Token accounting from the AssistantMessage (previously discarded) —
-            // the seam that makes workflow budget.maxTokens meterable on the
-            // default sdk runner.
-            const usage = extractUsage(prompted.data?.info);
-            const sdkError = prompted.error ?? prompted.data?.info?.error;
-            if (sdkError) {
-                const failure = sdkErrorFailure(sdkError);
+            const { text: stdout, usage, failure } = prompted;
+            if (failure) {
                 result = {
                     ok: false,
                     stdout,
@@ -1145,6 +1042,8 @@ export async function runOpencodeSdk(profile, prompt, opts = {}, llmConfig) {
     finally {
         permissions.stop();
         callerSignal?.removeEventListener("abort", abortForCaller);
+        // The dispatch is over: cancel any request still in flight.
+        runController.abort();
     }
     if (permissionNotes.length > 0) {
         result.stderr = [result.stderr, ...permissionNotes].filter(Boolean).join("\n");