akm-cli 0.10.261012-beta → 0.10.261014-beta

package/dist/integrations/harnesses/opencode-sdk/v1-adapter.js

@@ -1,199 +0,0 @@
-// 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/.
-/**
- * OpenCode 1 wire adapter, on `@opencode-ai/sdk` 1.2.20.
- *
- * Everything here is the V1 protocol and nothing else: the readiness line
- * (`opencode server listening on <url>`), the SDK client, `session.create` /
- * `session.prompt` / `session.abort` with the per-call `query.directory`, the
- * `/event` stream, and `postSessionIdPermissionsPermissionId`. `agent`,
- * `system` and `tools` ride on the prompt body. The shared server lifecycle
- * lives in `sdk-runner.ts`.
- */
-import { isRecord } from "../../../core/common.js";
-import { decodeRetryStatus, } from "./wire.js";
-const queryOf = (spec) => spec.directory ? { query: { directory: spec.directory } } : {};
-/**
- * Best-effort token usage from a prompt response. Only numeric fields the
- * server actually reported are copied; 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;
-}
-/**
- * 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 v1ErrorFailure(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 };
-}
-/**
- * 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;
-        }
-    }
-    return { stream: stream() };
-}
-/** The SDK `createOpencodeClient`, with the quiet event reader swapped in. */
-async function connectV1(baseUrl) {
-    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 client = createOpencodeClient({ baseUrl });
-    client.event = { subscribe: (args) => subscribeEvents(baseUrl, args) };
-    return client;
-}
-export const V1_ADAPTER = {
-    major: 1,
-    serveArgv: (bin, port) => [bin, "serve", "--hostname=127.0.0.1", `--port=${port}`],
-    // OpenCode 1 serves unauthenticated on loopback.
-    authorize: () => ({ env: {} }),
-    connect: (baseUrl) => connectV1(baseUrl),
-    async createSession(client, spec) {
-        const created = await client.session.create({ body: { title: "akm" }, ...queryOf(spec) });
-        return created.data?.id;
-    },
-    async prompt(client, sessionId, text, spec) {
-        // Forward the exact native agent selector, system prompt and tools from the
-        // abstract dispatch request (#564).
-        const body = { parts: [{ type: "text", text }] };
-        if (spec.agent)
-            body.agent = spec.agent;
-        if (spec.system)
-            body.system = spec.system;
-        if (spec.tools)
-            body.tools = spec.tools;
-        const prompted = await client.session.prompt({ path: { id: sessionId }, body, ...queryOf(spec) });
-        const parts = prompted.data?.parts ?? [];
-        // The last text part is the answer; earlier ones narrate the steps before it.
-        const textOut = parts.filter((p) => p.type === "text").at(-1)?.text ?? "";
-        const usage = extractUsage(prompted.data?.info);
-        const sdkError = prompted.error ?? prompted.data?.info?.error;
-        return {
-            text: textOut,
-            ...(usage ? { usage } : {}),
-            ...(sdkError ? { failure: v1ErrorFailure(sdkError) } : {}),
-        };
-    },
-    abort(client, sessionId, spec) {
-        void client.session.abort?.({ path: { id: sessionId }, ...queryOf(spec) }).catch(() => { });
-    },
-    canWatch(client) {
-        const c = client;
-        return Boolean(c.event?.subscribe && c.postSessionIdPermissionsPermissionId);
-    },
-    async subscribe(client, spec, signal) {
-        const events = client.event;
-        if (!events)
-            throw new Error("the client has no event surface");
-        const { stream } = await events.subscribe.call(events, { ...queryOf(spec), signal });
-        return stream;
-    },
-    decodeEvent(raw) {
-        if (!isRecord(raw) || !isRecord(raw.properties))
-            return undefined;
-        const props = raw.properties;
-        if (raw.type === "session.created" && isRecord(props.info)) {
-            const { id, parentID } = props.info;
-            if (typeof id !== "string")
-                return undefined;
-            return { kind: "session", id, ...(typeof parentID === "string" ? { parentId: parentID } : {}) };
-        }
-        // `action` is not in the SDK's retry type yet, but current servers send it for provider/account limits.
-        if (raw.type === "session.status")
-            return decodeRetryStatus(props.sessionID, props.status);
-        // `permission.asked` (OpenCode >= 1.3) / `permission.updated` (older).
-        if (raw.type !== "permission.asked" && raw.type !== "permission.updated")
-            return undefined;
-        const { id, sessionID } = props;
-        if (typeof id !== "string" || typeof sessionID !== "string")
-            return undefined;
-        const patterns = Array.isArray(props.patterns) ? props.patterns : props.pattern ? [props.pattern] : [];
-        return {
-            kind: "permission",
-            requestId: id,
-            sessionId: sessionID,
-            description: `${String(props.permission ?? props.type ?? "unknown")} (${patterns.join(", ")})`,
-        };
-    },
-    async rejectPermission(client, event, spec) {
-        const c = client;
-        const reply = c.postSessionIdPermissionsPermissionId;
-        if (!reply)
-            throw new Error("the client cannot answer permission requests");
-        const r = await reply.call(c, {
-            path: { id: event.sessionId, permissionID: event.requestId },
-            body: { response: "reject" },
-            ...queryOf(spec),
-        });
-        if (r.error)
-            throw new Error(JSON.stringify(r.error));
-    },
-};

package/dist/integrations/harnesses/opencode-sdk/v2-adapter.js

@@ -1,254 +0,0 @@
-// 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/.
-/**
- * OpenCode 2 wire adapter, on
- * `@opencode/client` 2.0.26 (the promise client, generated types).
- *
- * akm owns a private `opencode serve` child (never the v2 background
- * `service`). What differs from OpenCode 1, verified against the 2.0.26
- * binary:
- *
- *   - Readiness is `server listening on <url>` (no `opencode` prefix).
- *   - The server is basic-auth protected. akm chooses the password and hands it
- *     to the child as `OPENCODE_SERVER_PASSWORD` (and `OPENCODE_PASSWORD`,
- *     which wins when set), so nothing is scraped from stdout; the username is
- *     the server's default, `opencode`.
- *   - The working directory is the session's `location.directory`, set once at
- *     `session.create`. Later calls address the session by id.
- *   - The agent, the tool permissions (`permissions`: action/resource/effect
- *     rules) and the title are `session.create` fields. The prompt carries only
- *     text, so the system text is a session instruction entry.
- *   - `session.prompt` only enqueues. `session.wait` blocks until the session is
- *     idle, and `session.context` then holds the turn: our user message, the
- *     assistant messages and a closing `idle` message with the outcome.
- *   - Cancellation is `session.interrupt`; permission requests are answered with
- *     `permission.reply`; the event stream is global, so events are matched to
- *     the dispatch's sessions by id.
- *
- * Config (`OPENCODE_CONFIG_CONTENT`, built by the runner) keeps the V1 shape,
- * which the 2.0.26 server translates (`model`, `provider`, `agent`, `permission`).
- */
-import { randomBytes } from "node:crypto";
-import { OpenCode } from "@opencode/client";
-import { isRecord, toErrorMessage } from "../../../core/common.js";
-import { sleep } from "../../../runtime.js";
-import { parseOpencodeMajor } from "../opencode/version.js";
-import { decodeRetryStatus, OTHER_MAJOR_REMEDY, } from "./wire.js";
-/** Key of the session instruction entry carrying the dispatch's system text (`^[a-z0-9][a-z0-9._-]*$`). */
-const SYSTEM_INSTRUCTION_KEY = "akm.system";
-/** The server's default basic-auth username. */
-const SERVER_USERNAME = "opencode";
-const POLL_INTERVAL_MS = 100;
-/**
- * The turn that began with the user message `userId`, once its closing `idle`
- * message exists; undefined while the turn is still running.
- */
-export function v2Turn(messages, userId) {
-    const start = messages.findIndex((m) => m.id === userId);
-    if (start < 0)
-        return undefined;
-    const assistants = [];
-    for (const message of messages.slice(start + 1)) {
-        if (message.type === "assistant")
-            assistants.push(message);
-        else if (message.type === "idle")
-            return { outcome: message.outcome, assistants };
-    }
-    return undefined;
-}
-/**
- * The turn that began with the user message `userId`, when OpenCode 2 ended it
- * by interrupting a step instead of writing the closing `idle` message. Only
- * meaningful once `session.wait` has returned (the session is not running).
- *
- * Recorded from 2.0.26: when akm rejects a permission request the step fails
- * with `{ type: "aborted", message: "Step interrupted" }` (`finish: "error"`),
- * the tool call is `error` ("The user declined this tool call"),
- * `session.execution.interrupted` fires and the session goes idle, but no
- * `idle` message is written and `session.idle` is not emitted.
- */
-export function v2InterruptedTurn(messages, userId) {
-    const start = messages.findIndex((m) => m.id === userId);
-    if (start < 0)
-        return undefined;
-    const assistants = messages.slice(start + 1).filter((m) => m.type === "assistant");
-    const last = assistants.at(-1);
-    return last?.finish === "error" && last.error?.type === "aborted"
-        ? { outcome: "interrupted", assistants }
-        : undefined;
-}
-/** Decode a finished turn into the answer, the usage of every step and the failure, if any. */
-function v2PromptResult(turn) {
-    const text = turn.assistants
-        .flatMap((a) => a.content)
-        .filter((c) => c.type === "text")
-        .at(-1)?.text ?? "";
-    const usage = {};
-    const add = (key, value) => {
-        if (typeof value === "number" && Number.isFinite(value))
-            usage[key] = (usage[key] ?? 0) + value;
-    };
-    for (const a of turn.assistants) {
-        add("inputTokens", a.tokens?.input);
-        add("outputTokens", a.tokens?.output);
-        add("reasoningTokens", a.tokens?.reasoning);
-    }
-    const failure = v2Failure(turn);
-    return {
-        text,
-        ...(Object.keys(usage).length > 0 ? { usage } : {}),
-        ...(failure ? { failure } : {}),
-    };
-}
-function v2Failure(turn) {
-    if (turn.outcome === "interrupted") {
-        // Say why when the last step says so, e.g. "Step interrupted: The user declined this tool call".
-        const last = turn.assistants.at(-1);
-        const declined = last?.content.flatMap((c) => c.type === "tool" && c.state.status === "error" ? [c.state.error.message] : []);
-        const detail = [last?.error?.message, ...(declined ?? [])].filter(Boolean).join(": ");
-        return { reason: "aborted", message: `OpenCode session was interrupted${detail ? ` (${detail})` : ""}` };
-    }
-    const last = turn.assistants.at(-1);
-    if (turn.outcome === "failed") {
-        const error = [...turn.assistants].reverse().find((a) => a.error)?.error;
-        return {
-            reason: "non_zero_exit",
-            message: error ? `${error.type}: ${error.message}` : "OpenCode session failed",
-        };
-    }
-    // A reply cut off at the output limit has no error of its own.
-    if (last?.finish === "length") {
-        return { reason: "parse_error", message: "OpenCode reply was cut off at the output limit" };
-    }
-    return undefined;
-}
-/** Tool enable/disable map -> session permission rules. */
-function toolPermissions(tools) {
-    return Object.entries(tools ?? {}).map(([action, enabled]) => ({
-        action,
-        resource: "*",
-        effect: enabled ? "allow" : "deny",
-    }));
-}
-export const V2_ADAPTER = {
-    major: 2,
-    serveArgv: (bin, port) => [bin, "serve", "--hostname", "127.0.0.1", "--port", String(port)],
-    authorize() {
-        const password = randomBytes(24).toString("base64url");
-        return { env: { OPENCODE_SERVER_PASSWORD: password, OPENCODE_PASSWORD: password }, credentials: password };
-    },
-    async connect(baseUrl, credentials) {
-        const client = OpenCode.make({
-            baseUrl,
-            headers: { authorization: `Basic ${Buffer.from(`${SERVER_USERNAME}:${credentials ?? ""}`).toString("base64")}` },
-        });
-        let version;
-        try {
-            version = (await client.server.info()).version;
-        }
-        catch (err) {
-            throw new Error(`Could not read the OpenCode 2 server info at ${baseUrl}: ${toErrorMessage(err)}. ${OTHER_MAJOR_REMEDY}`);
-        }
-        // Only OpenCode 1 is refused: a newer major than akm knows runs on these adapters (`../opencode/version.ts`).
-        if (parseOpencodeMajor(version) === 1) {
-            throw new Error(`The server is OpenCode ${version}, not OpenCode 2. ${OTHER_MAJOR_REMEDY}`);
-        }
-        return client;
-    },
-    async createSession(client, spec) {
-        const c = client;
-        const permissions = toolPermissions(spec.tools);
-        const session = await c.session.create({
-            title: "akm",
-            ...(spec.agent ? { agent: spec.agent } : {}),
-            ...(spec.directory ? { location: { directory: spec.directory } } : {}),
-            ...(permissions.length > 0 ? { permissions } : {}),
-        });
-        if (spec.system) {
-            await c.session.instructions.entry.put({
-                sessionID: session.id,
-                key: SYSTEM_INSTRUCTION_KEY,
-                value: spec.system,
-            });
-        }
-        return session.id;
-    },
-    async prompt(client, sessionId, text, _spec, signal) {
-        const c = client;
-        const user = await c.session.prompt({ sessionID: sessionId, text }, { signal });
-        for (;;) {
-            await c.session.wait({ sessionID: sessionId }, { signal });
-            const messages = await c.session.context({ sessionID: sessionId }, { signal });
-            const turn = v2Turn(messages, user.id) ?? v2InterruptedTurn(messages, user.id);
-            if (turn)
-                return v2PromptResult(turn);
-            // `wait` can return before the queued prompt starts; look again.
-            await sleep(POLL_INTERVAL_MS);
-            if (signal.aborted)
-                throw new Error("OpenCode prompt cancelled");
-        }
-    },
-    abort(client, sessionId) {
-        void client.session.interrupt({ sessionID: sessionId }).catch(() => { });
-    },
-    async subscribe(client, _spec, signal) {
-        const source = client.event.subscribe({ signal })[Symbol.asyncIterator]();
-        // The stream's first event is `server.connected`: reading it proves the subscription is open.
-        const first = await source.next();
-        async function* stream() {
-            try {
-                if (!first.done)
-                    yield first.value;
-                while (true) {
-                    const next = await source.next();
-                    if (next.done)
-                        return;
-                    yield next.value;
-                }
-            }
-            catch (err) {
-                if (!signal.aborted)
-                    throw err;
-            }
-        }
-        return stream();
-    },
-    decodeEvent(raw) {
-        if (!isRecord(raw) || typeof raw.type !== "string" || !isRecord(raw.data))
-            return undefined;
-        // Shape-checked below, field by field; the generated `V2Event` union documents what each carries.
-        const data = raw.data;
-        if (raw.type === "session.created") {
-            if (typeof data.sessionID !== "string")
-                return undefined;
-            return {
-                kind: "session",
-                id: data.sessionID,
-                ...(typeof data.parentID === "string" ? { parentId: data.parentID } : {}),
-            };
-        }
-        if (raw.type === "session.status")
-            return decodeRetryStatus(data.sessionID, data.status);
-        if (raw.type === "permission.asked") {
-            const { id, sessionID, action, resources } = data;
-            if (typeof id !== "string" || typeof sessionID !== "string")
-                return undefined;
-            const patterns = Array.isArray(resources) ? resources : [];
-            return {
-                kind: "permission",
-                requestId: id,
-                sessionId: sessionID,
-                description: `${String(action ?? "unknown")} (${patterns.join(", ")})`,
-            };
-        }
-        return undefined;
-    },
-    async rejectPermission(client, event) {
-        await client.permission.reply({
-            sessionID: event.sessionId,
-            requestID: event.requestId,
-            decision: "reject",
-        });
-    },
-};

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

@@ -1,66 +0,0 @@
-// 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 seam between the OpenCode SDK runner and one OpenCode major's wire
- * protocol (#1049).
- *
- * `sdk-runner.ts` owns everything the two majors share: the managed
- * `opencode serve` child (spawn, port, registry, cleanup), the child
- * environment, deadlines, abort handling and result shaping. A
- * {@link OpencodeWireAdapter} owns what differs: how to ask the binary to
- * serve, how to read its readiness line, how to authenticate, and how to
- * create a session, prompt it, abort it, watch its events and answer its
- * permission requests. `v1-adapter.ts` speaks OpenCode 1 through
- * `@opencode-ai/sdk`; `v2-adapter.ts` speaks OpenCode 2 through
- * `@opencode/client`.
- *
- * Selection is by detection (`../opencode/version.ts` runs `<bin> --version`
- * once per binary). An adapter that meets a server of the other major fails and
- * names the remedy ({@link otherMajorRemedy}); it never falls back to the other
- * protocol.
- */
-import { isRecord } from "../../../core/common.js";
-/** The npm client package each major's adapter imports. Setup and health check the one the engine selects. */
-export const OPENCODE_CLIENT_PACKAGE = {
-    1: "@opencode-ai/sdk",
-    2: "@opencode/client",
-};
-/** The sentence every wrong-major failure ends with. */
-export const OTHER_MAJOR_REMEDY = `Upgrade to OpenCode 2, or set this engine's "bin" to the OpenCode binary you want to run.`;
-/** What each major's `serve` prints once it listens; the other major's line names a wrong binary. */
-const READINESS_PREFIX = {
-    1: "opencode server listening",
-    2: "server listening on",
-};
-/** Judge one output line of a server started for `own`: its readiness line, the other major's, or neither. */
-export function parseReadiness(line, own) {
-    const other = own === 1 ? 2 : 1;
-    if (line.startsWith(READINESS_PREFIX[own])) {
-        const match = line.match(/on\s+(https?:\/\/\S+)/);
-        return match?.[1] ? { url: match[1] } : { error: `Failed to parse the OpenCode server url from: ${line}` };
-    }
-    if (line.startsWith(READINESS_PREFIX[other])) {
-        return { error: `The binary is OpenCode ${other} (${line.trim()}). ${OTHER_MAJOR_REMEDY}` };
-    }
-    return undefined;
-}
-/**
- * A `session.status` payload as the runner's retry event, or undefined for any
- * other status. Both majors carry the same fields; `action` names the provider
- * and, for an account usage limit, `reason: "account_rate_limit"` (#1108).
- */
-export function decodeRetryStatus(sessionID, status) {
-    if (typeof sessionID !== "string" || !isRecord(status) || status.type !== "retry")
-        return undefined;
-    const action = isRecord(status.action) ? status.action : undefined;
-    return {
-        kind: "retry",
-        sessionId: sessionID,
-        ...(typeof status.attempt === "number" ? { attempt: status.attempt } : {}),
-        message: typeof status.message === "string" ? status.message : "OpenCode is retrying",
-        ...(typeof status.next === "number" ? { next: status.next } : {}),
-        ...(typeof action?.provider === "string" ? { provider: action.provider } : {}),
-        accountLimit: action?.reason === "account_rate_limit",
-    };
-}

package/dist/integrations/harnesses/openhands/agent-builder.js

@@ -1,120 +0,0 @@
-// 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/.
-/**
- * OpenHands CLI agent command builder (P2, plan §"The adapter contract"
- * step 2 / §"Capability matrix").
- *
- * Translates a platform-agnostic {@link AgentDispatchRequest} into the exact
- * headless argv the `openhands` CLI expects. Per the capability matrix the
- * headless invocation is:
- *
- *   openhands --headless -t "<p>" --json
- *
- * with `--json` producing the documented JSONL event stream (structured tier
- * "via prompt+validate"), workspace-state resume (no session-id flag), and
- * native MCP support.
- *
- * Platform-specific mapping decisions (all localized here, per the adapter
- * contract):
- *
- * - **prompt** — `--task` is the long form of the matrix's `-t` (used for
- *   self-documenting argv, mirroring the aider builder's `--message`). Like
- *   aider — and unlike claude/codex/pi — there is NO positional prompt and NO
- *   `--` end-of-options separator to hide behind: the task is a *flag value*.
- *   The glued `--task=<payload>` form is therefore used so a payload that
- *   begins with `-`/`--` binds to the flag lexically and can never be parsed
- *   as a separate option by the CLI's argument parser.
- * - **--headless / --json** — always emitted: `--headless` is what makes a
- *   captured, unattended run possible, and `--json` switches stdout to the
- *   JSONL event stream that `./result-extractor.ts` normalizes (the same
- *   "dispatch is the captured path" reasoning as the Claude builder's
- *   unconditional `--print`; both flags are the matrix's documented headless
- *   shape).
- * - **systemPrompt** — OpenHands headless mode has no documented
- *   system-prompt flag (agent behaviour is shaped by its own agent configs
- *   and microagents). Folded into the task payload — system text first, blank
- *   line, then the task — mirroring the aider/codex treatment.
- * - **model** — OpenHands does not take the model on the headless command
- *   line; its documented configuration channel is the `LLM_MODEL` environment
- *   variable (config.toml `[llm] model` equivalent). The alias is resolved via
- *   `resolveModel` with this platform id and returned on `BuiltCommand.env`
- *   (the seam exists precisely for platform-specific extras), NOT as an
- *   invented `--model` flag that would produce a silently broken command.
- * - **schema** — the matrix places OpenHands in the "via prompt+validate"
- *   tier (plan §"Structured-output normalization", tier "native-json"): no
- *   Codex-style `--output-schema` flag exists, so NO temp schema file is
- *   written; the JSON Schema reaches it as the instruction the shared request
- *   lowering appends to the prompt. Downstream, the extractor pulls the
- *   final message out of the JSONL stream and the engine's shared
- *   retry-until-valid loop performs the actual validation.
- * - **tools** — deliberately unconsumed. OpenHands has no per-tool allowlist
- *   flag; tool access is governed by its own runtime/sandbox configuration
- *   and (natively supported) MCP config. A restrictive policy is therefore
- *   dropped rather than approximated — never silently widened.
- * - **resume/session** — NOT expressible: per the matrix OpenHands resumes
- *   from *workspace state*, not a session-id flag, so there is no flag-shaped
- *   resume to describe. The extractor still captures a
- *   conversation/session id opportunistically when the stream reveals one;
- *   akm's `workflow_run_units` remains the durable source of truth either way
- *   (plan §"Session, MCP, and identity across harnesses").
- * - **inference** — not translated: the shared lowering reports each field of
- *   the request's inference as untranslated.
- *
- * Registered: `openhandsBuilder` is `OpenhandsHarness.agentBuilder`
- * (`./index.ts`), one of the ten harnesses `HARNESS_REGISTRY` constructs
- * (`harnesses/index.ts`); `agent/builders.ts` derives `BUILTIN_BUILDERS` from
- * that registry, so this builder is reachable under the `"openhands"`
- * platform name without any further wiring.
- */
-import { resolveDispatchModel } from "../../agent/builder-shared.js";
-import { createAgentRequestLowerer } from "../../agent/request-lowering.js";
-/** Canonical harness/platform id used for model-alias resolution. */
-export const OPENHANDS_PLATFORM = "openhands";
-/**
- * Env var OpenHands reads its LLM model from — the platform's documented
- * model-selection channel for headless runs (there is no headless model
- * flag). Exported (re-exported from `./index.ts`) so this harness's tests
- * share the one constant.
- */
-export const OPENHANDS_MODEL_ENV = "LLM_MODEL";
-/** Assemble the `--task` payload: optional system text, then the task prompt. */
-function buildTaskPayload(req) {
-    const sections = [];
-    if (req.systemPrompt)
-        sections.push(req.systemPrompt);
-    sections.push(req.prompt);
-    return sections.join("\n\n");
-}
-/**
- * OpenHands builder.
- * Command shape:
- *   openhands --headless --json --task=<[system\n\n]prompt>
- * with the resolved model (if any) carried on env as LLM_MODEL.
- */
-export const openhandsBuilder = {
-    platform: OPENHANDS_PLATFORM,
-    personaChannel: "prompt",
-    lower: createAgentRequestLowerer({
-        adapter: OPENHANDS_PLATFORM,
-        personaChannel: "prompt",
-        tools: "none",
-    }),
-    build(profile, req) {
-        const args = [...profile.args];
-        // Headless essentials (matrix shape): non-interactive run, JSONL stdout
-        // for the extractor.
-        args.push("--headless");
-        args.push("--json");
-        // Glued form: the payload is a flag VALUE (no positional prompt exists),
-        // so `=` binding keeps a dash-leading payload from parsing as an option.
-        args.push(`--task=${buildTaskPayload(req)}`);
-        let env;
-        if (req.model) {
-            const resolved = resolveDispatchModel(req, profile, OPENHANDS_PLATFORM);
-            // Model travels via env, not argv — OpenHands' documented channel.
-            env = { [OPENHANDS_MODEL_ENV]: resolved };
-        }
-        return { argv: [profile.bin, ...args], ...(env ? { env } : {}) };
-    },
-};