akm-cli 0.10.261012-beta → 0.10.261014-beta

package/dist/integrations/agent/runner-dispatch.js

@@ -2,58 +2,41 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
- * Run a built execution: the one place credentials are read. A direct LLM
- * goes to `chatCompletion`, an agent engine to `runAgent` (the harness builder
- * turns the request into argv), an SDK engine to `runOpencodeSdk`. Every
- * credential and passthrough value that could reach the child is redacted
- * from the result.
+ * Run a built execution: the one place credentials are read. Model work on a
+ * connection goes to `chatCompletion`, a harness to `runAgent` (the harness
+ * builder turns the request into argv), and agent work on a connection to
+ * akm's own runtime (`agentRuntime`). The key of the connection a run used is
+ * redacted from its result.
  */
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { assertNever } from "../../core/assert.js";
+import { resolveApiKey } from "../../core/config/credentials.js";
 import { UsageError } from "../../core/errors.js";
-import { collectSensitiveValues, isEnvPassthroughValueSafeToExpose, redactSensitiveText, redactSensitiveValue, } from "../../core/redaction.js";
-import { MODEL_WORK_POLICY_ID } from "../../execution/source.js";
+import { collectInferredSecretValues, collectSensitiveValues, redactSensitiveText } from "../../core/redaction.js";
 import { chatCompletion, LlmCallError } from "../../llm/client.js";
 import { emitLlmUsage } from "../../llm/usage-telemetry.js";
-import { getHarness } from "../harnesses/index.js";
-import { closeServer as disposeOpencodeSdkServers, runOpencodeSdk } from "../harnesses/opencode-sdk/sdk-runner.js";
-import { modelFromArgs } from "./builder-shared.js";
-import { lookupApiKeyFileValue, lookupApiKeySecretRefValue, lookupCredentialFromEnv, resolveEngine, } from "./engine-resolution.js";
-import { materializeLlmRunnerConnection, materializeSdkFallbackConnection } from "./runner.js";
+import { modelFromArgs } from "../harnesses/harness.js";
+import { harnessProfile, runtimeProfile } from "./profiles.js";
+import { mergeLayerInference, resolveTarget } from "./resolution.js";
+import { agentRuntime } from "./runtime.js";
 import { runAgent } from "./spawn.js";
-const OPERATIONAL_OPTIONS = [
-    "stdio",
-    "parseOutput",
-    "signal",
-    "envSource",
-    "spawn",
-    "setTimeoutFn",
-    "clearTimeoutFn",
-    "onEvent",
-];
-/** Every value that can reach one dispatch and must never be echoed back: credentials and secret-looking env. */
-export function collectDispatchSensitiveValues(runner, opts, envSource = opts.envSource ?? process.env) {
-    const values = [];
-    if (runner.kind === "llm") {
-        values.push(runner.connection.apiKey, lookupCredentialFromEnv(runner.credential, envSource), runner.apiKeyFile ? lookupApiKeyFileValue(runner.apiKeyFile) : undefined, runner.apiKeySecretRef ? lookupApiKeySecretRefValue(runner.apiKeySecretRef) : undefined);
-    }
-    else {
-        if (runner.kind === "sdk") {
-            values.push(runner.fallbackConnection?.apiKey, lookupCredentialFromEnv(runner.fallbackCredential, envSource), runner.fallbackApiKeyFile ? lookupApiKeyFileValue(runner.fallbackApiKeyFile) : undefined, runner.fallbackApiKeySecretRef ? lookupApiKeySecretRefValue(runner.fallbackApiKeySecretRef) : undefined);
-        }
-        values.push(...Object.values(runner.profile.env ?? {}));
-        for (const name of runner.profile.envPassthrough) {
-            if (!isEnvPassthroughValueSafeToExpose(name, envSource[name]))
-                values.push(envSource[name]);
-        }
-    }
-    for (const [name, value] of Object.entries(opts.env ?? {})) {
-        if (!isEnvPassthroughValueSafeToExpose(name, value))
-            values.push(value);
-    }
-    return collectSensitiveValues(values);
+/**
+ * The value a dispatch must never echo back: the key of the connection it runs on.
+ * A harness is the user's own program and holds no key of akm's, so there is none.
+ * A request's own `env` is configuration; a caller's secret values are redacted
+ * through its own sensitive set.
+ */
+export function collectDispatchSensitiveValues(runner, envSource = process.env) {
+    // The child inherits akm's environment, so a reply that echoes a credential-named variable's value is scrubbed
+    // of it, as the connection's own key is.
+    const inherited = collectInferredSecretValues(envSource);
+    if (runner.kind !== "connection")
+        return collectSensitiveValues(inherited);
+    return collectSensitiveValues([
+        resolveApiKey(runner.apiKey, { connection: runner.name }, runner.endpoint, envSource, true, runner.storedKey !== false),
+        ...inherited,
+    ]);
 }
 function redactResult(result, sensitiveValues) {
     return {
@@ -61,7 +44,6 @@ function redactResult(result, sensitiveValues) {
         stdout: redactSensitiveText(result.stdout, sensitiveValues),
         stderr: redactSensitiveText(result.stderr, sensitiveValues),
         ...(result.error !== undefined ? { error: redactSensitiveText(result.error, sensitiveValues) } : {}),
-        ...(result.parsed !== undefined ? { parsed: redactSensitiveValue(result.parsed, sensitiveValues) } : {}),
     };
 }
 function llmFailureReason(error) {
@@ -88,16 +70,14 @@ const USAGE_ERROR_CODES = {
     llm_rate_limit: "rate_limited",
 };
 /**
- * The model an agent or SDK dispatch ran: the request's, else the one an agent
- * CLI's own `args` select, which its command carries when the request names
- * none. An SDK server never sees `args`, so an SDK engine with no model named
- * has none to report: opencode picks it.
+ * The model an agent or runtime dispatch ran: the request's, else the one a
+ * harness's own `args` select, which its command carries when the request names none.
  */
 function dispatchedModel({ request, runner }) {
-    return request.model?.resolved ?? (runner.kind === "agent" ? modelFromArgs(runner.profile.args) : undefined);
+    return request.model?.model ?? (runner.kind === "harness" ? modelFromArgs(runner.args) : undefined);
 }
 /**
- * One usage record for an agent or SDK dispatch, through the same sink and
+ * One usage record for an agent or runtime dispatch, through the same sink and
  * ambient `withLlmStage` attribution as the LLM transport's per-HTTP-attempt
  * records: the model it ran, and tokens when the runner reported them.
  */
@@ -117,159 +97,154 @@ function recordDispatchUsage(execution, result) {
         ...(result.ok ? {} : { errorCode: (result.reason && USAGE_ERROR_CODES[result.reason]) ?? "unknown_error" }),
     });
 }
-async function dispatchRunner(runner, prompt, opts, seams, llm) {
-    const envSource = opts.envSource ?? process.env;
-    const secrets = collectDispatchSensitiveValues(runner, opts, envSource);
+/**
+ * The chat connection a connection runner stands for: its key read now, and the
+ * portable settings of the runner's choosing layers and of this call's request
+ * (the request's nearer), which the client translates. The one place a
+ * connection's key is read for a call.
+ */
+export function materializeConnection(runner, inference, envSource = process.env) {
+    const apiKey = resolveApiKey(runner.apiKey, { connection: runner.name }, runner.endpoint, envSource, false, runner.storedKey !== false);
+    const settings = mergeLayerInference([
+        { inference: runner.inference },
+        { inference: inference },
+    ]);
+    return {
+        endpoint: runner.endpoint,
+        model: runner.model,
+        request: runner.request,
+        ...(settings ? { inference: settings } : {}),
+        timeoutMs: runner.timeoutMs,
+        ...(runner.contextLength !== undefined ? { contextLength: runner.contextLength } : {}),
+        ...(apiKey ? { apiKey } : {}),
+    };
+}
+/** `llm` is given for a direct chat; without it a connection runs akm's internal runtime. */
+async function dispatchRunner({ runner, profile, inference, confined }, opts, seams, llm) {
+    const secrets = collectDispatchSensitiveValues(runner);
     let result;
-    switch (runner.kind) {
-        case "llm": {
-            if (!llm)
-                throw new Error("an llm runner dispatches only a built execution's chat messages");
-            const connection = materializeLlmRunnerConnection(runner, envSource);
-            if (connection.apiKey)
-                secrets.push(connection.apiKey);
-            result = await llm(connection, opts);
-            break;
-        }
-        case "agent":
-            result = await (seams.runAgent ?? runAgent)(runner.profile, prompt, opts);
-            break;
-        case "sdk": {
-            const fallbackConnection = materializeSdkFallbackConnection(runner, envSource);
-            if (fallbackConnection?.apiKey)
-                secrets.push(fallbackConnection.apiKey);
-            result = await (seams.runSdk ?? runOpencodeSdk)(runner.profile, prompt, opts, fallbackConnection);
-            break;
-        }
-        default:
-            return assertNever(runner);
+    if (runner.kind === "harness") {
+        const harnessRunProfile = profile ?? harnessProfile(runner);
+        const spawn = (spawnOpts) => (seams.runAgent ?? runAgent)(harnessRunProfile, spawnOpts);
+        result = await (confined ? inScratchDirectory(opts, spawn) : spawn(opts));
+    }
+    else {
+        const connection = materializeConnection(runner, inference);
+        if (connection.apiKey)
+            secrets.push(connection.apiKey);
+        result = llm
+            ? await llm(connection, opts)
+            : await (seams.runSdk ?? agentRuntime.run)(profile ?? runtimeProfile(runner), opts, connection);
     }
     return redactResult(result, collectSensitiveValues(secrets));
 }
 /**
- * The scratch working directory for one model-work dispatch on an agent or SDK
- * engine, so the edit the model-work tool policy grants never reaches the
- * stash.
- */
-function createModelWorkDirectory() {
-    return fs.mkdtempSync(path.join(os.tmpdir(), "akm-model-work-"));
-}
-/**
- * Run a built execution. Credentials are read here, once per call, and never
- * returned. Model work on an agent or SDK engine runs in a scratch working
- * directory that akm creates for the dispatch and removes after it, and must
- * end with an answer: an agent that stops with none (opencode at its step
- * limit, for one) has failed with `parse_error`.
+ * Run `work` in a scratch working directory that akm creates for it and removes
+ * after, so the edit that model work on a CLI harness cannot be denied never
+ * reaches the stash. This function owns the directory's lifecycle: nothing else,
+ * the test tooling included, removes an `akm-model-work-*` directory.
  */
-export async function runExecution(execution, options = {}) {
-    const scratch = execution.runner.kind !== "llm" && execution.request.authorization.policy?.id === MODEL_WORK_POLICY_ID
-        ? createModelWorkDirectory()
-        : undefined;
+async function inScratchDirectory(opts, work) {
+    const scratch = fs.mkdtempSync(path.join(os.tmpdir(), "akm-model-work-"));
     try {
-        return await runBuiltExecution(execution, options, scratch);
+        return await work({ ...opts, cwd: scratch });
     }
     finally {
-        if (scratch)
-            fs.rmSync(scratch, { recursive: true, force: true });
+        fs.rmSync(scratch, { recursive: true, force: true });
     }
 }
-/** A successful reply's text, unwrapped from its harness's framing (claude's `--output-format json` result envelope, for one). */
-export function unwrapHarnessReply(runner, result) {
-    const extractor = runner.kind === "agent" ? getHarness(runner.profile.platform ?? runner.profile.name)?.resultExtractor : undefined;
-    return extractor ? extractor(result) : { text: result.stdout };
+/** Whether this execution is model work that runs an agent (not a direct chat). */
+function isConfinedAgentWork(execution) {
+    return execution.request.modelWork && execution.messages === undefined;
 }
-/** A model-work reply's answer: its harness's framing stripped, and no answer is a `parse_error`. */
+/** A model-work reply must end with an answer: an agent that stops with none (opencode at its step limit, for one) has failed. */
 function modelWorkAnswer(runner, result) {
-    const extracted = unwrapHarnessReply(runner, result);
-    const answer = {
-        ...result,
-        stdout: extracted.text,
-        ...(extracted.sessionId ? { sessionId: extracted.sessionId } : {}),
-    };
-    if (extracted.text.trim() !== "")
-        return answer;
-    return { ...answer, ok: false, reason: "parse_error", error: `Engine "${runner.engine}" returned no answer.` };
+    if (result.stdout.trim() !== "")
+        return result;
+    return { ...result, ok: false, reason: "parse_error", error: `"${runner.name}" returned no answer.` };
 }
-/** `scratch` is the model-work working directory, set only for model work on an agent or SDK engine. */
-async function runBuiltExecution(execution, options, scratch) {
-    const opts = { ...execution.options, ...(scratch ? { cwd: scratch } : {}) };
-    const operational = options.runOptions ?? {};
-    for (const key of OPERATIONAL_OPTIONS) {
-        if (operational[key] !== undefined)
-            opts[key] = operational[key];
-    }
-    if (options.eventSource !== undefined) {
-        opts.env = { ...execution.options.env, AKM_EVENT_SOURCE: options.eventSource };
+/**
+ * Run a built execution. Credentials are read here, once per call, and never
+ * returned. Model work on a harness runs confined: in a scratch working
+ * directory, and it must end with an answer: an agent that stops with none
+ * (opencode at its step limit, for one) has failed with `parse_error`.
+ */
+export async function runExecution(execution, options = {}) {
+    const confined = isConfinedAgentWork(execution);
+    const opts = { ...execution.options };
+    if (options.signal)
+        opts.signal = options.signal;
+    // Model work is akm's own traffic: its reads and its agents' commands are the improve pipeline's, never the
+    // user's demand. A caller's source (a task, say) wins, as does one the unit's own `env:` binds.
+    const eventSource = options.eventSource ??
+        (execution.request.modelWork && execution.options.env?.AKM_EVENT_SOURCE === undefined ? "improve" : undefined);
+    if (eventSource !== undefined) {
+        opts.env = { ...execution.options.env, AKM_EVENT_SOURCE: eventSource };
     }
     const chat = options.chat ?? chatCompletion;
-    const llm = async (connection, callOpts) => {
-        const started = Date.now();
-        try {
-            const stdout = await chat(connection, [...(execution.messages ?? [])], {
-                ...execution.chatOptions,
-                ...(Object.hasOwn(callOpts, "timeoutMs") ? { timeoutMs: callOpts.timeoutMs } : {}),
-                ...(callOpts.signal ? { signal: callOpts.signal } : {}),
-                ...(options.onRetryAttempt ? { onRetryAttempt: options.onRetryAttempt } : {}),
-            });
-            return { ok: true, exitCode: 0, stdout, stderr: "", durationMs: Date.now() - started };
-        }
-        catch (error) {
-            // Returned rather than thrown so the redaction below covers provider bodies.
-            return {
-                ok: false,
-                exitCode: null,
-                stdout: "",
-                stderr: "",
-                durationMs: Date.now() - started,
-                error: error instanceof Error ? error.message : String(error),
-                reason: llmFailureReason(error),
-                ...(error instanceof LlmCallError ? { llmErrorCode: error.code } : {}),
-            };
-        }
-    };
-    let result = await dispatchRunner(execution.runner, execution.prompt, opts, options, llm);
-    if (scratch !== undefined && result.ok)
+    const llm = execution.messages === undefined
+        ? undefined
+        : async (connection, callOpts) => {
+            const started = Date.now();
+            try {
+                const stdout = await chat(connection, [...(execution.messages ?? [])], {
+                    ...execution.chatOptions,
+                    ...(Object.hasOwn(callOpts, "timeoutMs") ? { timeoutMs: callOpts.timeoutMs } : {}),
+                    ...(callOpts.signal ? { signal: callOpts.signal } : {}),
+                    ...(options.onRetryAttempt ? { onRetryAttempt: options.onRetryAttempt } : {}),
+                });
+                return { ok: true, exitCode: 0, stdout, stderr: "", durationMs: Date.now() - started };
+            }
+            catch (error) {
+                // Returned rather than thrown so the redaction below covers provider bodies.
+                return {
+                    ok: false,
+                    exitCode: null,
+                    stdout: "",
+                    stderr: "",
+                    durationMs: Date.now() - started,
+                    error: error instanceof Error ? error.message : String(error),
+                    reason: llmFailureReason(error),
+                    ...(error instanceof LlmCallError ? { llmErrorCode: error.code } : {}),
+                };
+            }
+        };
+    let result = await dispatchRunner({
+        runner: execution.runner,
+        ...(execution.profile ? { profile: execution.profile } : {}),
+        inference: execution.request.inference,
+        confined,
+    }, opts, options, llm);
+    if (confined && result.ok)
         result = modelWorkAnswer(execution.runner, result);
     // The LLM transport records each HTTP attempt itself.
-    if (execution.runner.kind !== "llm")
+    if (llm === undefined)
         recordDispatchUsage(execution, result);
     return result;
 }
-/** `akm agent`: launch an agent engine interactively, with no prompt of its own. */
+/**
+ * `akm agent` with no prompt: start the harness for a person to use, with the terminal
+ * inherited and nothing to run (no `-p`, no empty turn). A connection has nothing
+ * interactive to start, so it is refused rather than billed for an empty turn.
+ */
 export async function executeInteractiveAgentInvocation(input, seams = {}) {
-    const runner = resolveEngine(input.engine, input.config);
-    if (runner.kind === "llm") {
-        throw new UsageError(`Engine "${input.engine}" is an LLM engine; akm agent requires an agent engine.`, "INVALID_FLAG_VALUE");
+    const runner = resolveTarget({
+        config: input.config,
+        layers: [
+            ...(input.connection === undefined ? [] : [{ connection: input.connection }]),
+            ...(input.harness === undefined ? [] : [{ harness: input.harness }]),
+            ...(input.engine === undefined ? [] : [{ engine: input.engine }]),
+            ...(input.model === undefined ? [] : [{ model: input.model }]),
+        ],
+    });
+    if (runner.kind === "connection") {
+        throw new UsageError(`"${runner.name}" is a connection, which has nothing to start interactively: pass --prompt, or name a harness.`, "MISSING_REQUIRED_ARGUMENT", "Pass --prompt to run a task on the connection, or name a harness with --harness to start it interactively.");
     }
     const opts = {
-        stdio: runner.kind === "sdk" ? runner.profile.stdio : "interactive",
-        parseOutput: "text",
-        ...(input.timeoutMs !== undefined
-            ? { timeoutMs: input.timeoutMs }
-            : runner.timeoutMs !== undefined
-                ? { timeoutMs: runner.timeoutMs }
-                : {}),
-        ...(input.cwd ? { cwd: input.cwd } : runner.profile.workspace ? { cwd: runner.profile.workspace } : {}),
+        stdio: "interactive",
+        timeoutMs: input.timeoutMs ?? runner.timeoutMs,
+        ...(input.cwd ? { cwd: input.cwd } : runner.workspace ? { cwd: runner.workspace } : {}),
+        dispatch: { ...(runner.model ? { model: runner.model } : {}), ...(runner.agent ? { agent: runner.agent } : {}) },
     };
-    return { engine: input.engine, result: await dispatchRunner(runner, "", opts, seams) };
-}
-/**
- * Close the `opencode serve` children the SDK runner keeps for reuse. Its own
- * teardown hangs off `process.once("exit")`, which never fires while a child
- * holds the event loop open, so the CLI and workflow engine call this in
- * `finally` blocks. A no-op when no SDK server was started.
- */
-export async function disposeDispatchResources() {
-    await disposeOpencodeSdkServers();
-}
-/**
- * Fail fast, before an operation makes any durable change, when `runner`'s
- * required credential is missing. Reads it and keeps nothing: every dispatch
- * reads it again.
- */
-export function assertRunnerCredentials(runner, envSource) {
-    if (runner.kind === "llm")
-        materializeLlmRunnerConnection(runner, envSource);
-    if (runner.kind === "sdk")
-        materializeSdkFallbackConnection(runner, envSource);
+    return { engine: runner.name, result: await dispatchRunner({ runner }, opts, seams) };
 }

package/dist/integrations/agent/runner.js

@@ -1,78 +1,28 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-import { materializeLlmConnection } from "./engine-resolution.js";
-/** The symbolic LLM use behind one llm runner; nothing is read here. */
-export function llmUseFromRunner(runner) {
-    return {
-        engine: runner.engine,
-        connection: runner.connection,
-        ...(runner.credential ? { credential: runner.credential } : {}),
-        ...(runner.apiKeyFile ? { apiKeyFile: runner.apiKeyFile } : {}),
-        ...(runner.apiKeySecretRef ? { apiKeySecretRef: runner.apiKeySecretRef } : {}),
-        timeoutMs: runner.timeoutMs ?? null,
-    };
-}
-/** The symbolic LLM use behind an sdk runner's provider fallback, when it has one. */
-export function sdkFallbackUseFromRunner(runner) {
-    if (!runner.fallbackConnection)
-        return undefined;
-    return {
-        engine: runner.engine,
-        connection: runner.fallbackConnection,
-        ...(runner.fallbackCredential ? { credential: runner.fallbackCredential } : {}),
-        ...(runner.fallbackApiKeyFile ? { apiKeyFile: runner.fallbackApiKeyFile } : {}),
-        ...(runner.fallbackApiKeySecretRef ? { apiKeySecretRef: runner.fallbackApiKeySecretRef } : {}),
-        timeoutMs: runner.fallbackTimeoutMs !== undefined ? runner.fallbackTimeoutMs : (runner.fallbackConnection.timeoutMs ?? null),
-    };
-}
-/** Read the current credential and inject it: the dispatch boundary for one llm runner. */
-export function materializeLlmRunnerConnection(runner, envSource = process.env) {
-    return materializeLlmConnection(llmUseFromRunner(runner), envSource);
-}
-/** The same for an sdk runner's provider fallback, when it has one. */
-export function materializeSdkFallbackConnection(runner, envSource = process.env) {
-    const use = sdkFallbackUseFromRunner(runner);
-    return use ? materializeLlmConnection(use, envSource) : undefined;
-}
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
+import { isRecord } from "../../core/common.js";
 /**
- * Read a journaled runner back. Tolerant: unknown keys are kept and missing
- * profile defaults are filled in; only a shape nothing could dispatch is refused.
+ * Read a journaled runner back. A current runner is kept as stored. An earlier
+ * release's `llm`, `agent` and `sdk` runners are not read: they fall through to
+ * the last case and the plan that holds one cannot be decoded, so its run starts
+ * afresh.
  */
 export function decodeFrozenRunnerSpec(value) {
-    if (!isRecord(value) || typeof value.engine !== "string") {
-        throw new TypeError("a frozen runner must be an object with an engine name");
-    }
-    if (value.kind === "llm") {
-        if (!isRecord(value.connection) || typeof value.connection.endpoint !== "string") {
-            throw new TypeError("a frozen llm runner must carry connection.endpoint");
-        }
-        return value;
+    if (!isRecord(value))
+        throw new TypeError("a frozen runner must be an object");
+    switch (value.kind) {
+        case "connection":
+            if (typeof value.name !== "string" || typeof value.endpoint !== "string" || typeof value.model !== "string") {
+                throw new TypeError("a frozen connection runner must carry name, endpoint and model");
+            }
+            return value;
+        case "harness":
+            if (typeof value.name !== "string" || typeof value.platform !== "string" || typeof value.bin !== "string") {
+                throw new TypeError("a frozen harness runner must carry name, platform and bin");
+            }
+            return { args: [], ...value };
+        default:
+            throw new TypeError("a frozen runner's kind must be connection or harness");
     }
-    if (value.kind !== "agent" && value.kind !== "sdk") {
-        throw new TypeError("a frozen runner's kind must be llm, agent, or sdk");
-    }
-    const profile = value.profile;
-    if (!isRecord(profile) || typeof profile.name !== "string" || typeof profile.bin !== "string") {
-        throw new TypeError("a frozen agent runner must carry profile.name and profile.bin");
-    }
-    return {
-        ...value,
-        profile: { args: [], envPassthrough: [], stdio: "captured", parseOutput: "text", ...profile },
-    };
-}
-export function runnerIsLlm(runner) {
-    return runner.kind === "llm";
-}
-/**
- * The LLM connection behind a runner, whatever its kind: an llm runner's own,
- * an sdk runner's provider fallback, none for an agent CLI.
- */
-export function runnerLlmConnection(runner) {
-    if (runner.kind === "llm")
-        return runner.connection;
-    return runner.kind === "sdk" ? runner.fallbackConnection : undefined;
 }

package/dist/integrations/agent/runtime-port.js

@@ -0,0 +1,4 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+export {};

package/dist/integrations/agent/runtime.js

@@ -0,0 +1,10 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * The one place akm's agent runtime is chosen. Lowering and dispatch use
+ * {@link agentRuntime} and import nothing of the implementation; replacing the
+ * runtime is a change to this line and the folder it names.
+ */
+import { opencodeRuntime } from "../harnesses/opencode/runtime/index.js";
+export const agentRuntime = opencodeRuntime;