@mininglamp-oss/octo-runtime 0.0.0-stage → 1.0.0

package/node_modules/@mininglamp-oss/octo-runtime-adapter-opencode/dist/index.d.ts

@@ -0,0 +1,88 @@
+import { type AdapterInvocationContext, type CanonicalEvent, type InvokeRequest } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+/** A single OpenCode stream part; tool lifecycle is carried in `state.status` (running -> completed/error). */
+interface OpenCodePart {
+    sessionID?: string;
+    messageID?: string;
+    type?: string;
+    text?: string;
+    reason?: string;
+    callID?: string;
+    id?: string;
+    tool?: string;
+    state?: {
+        status?: string;
+        input?: unknown;
+        output?: unknown;
+        error?: unknown;
+        time?: {
+            start?: unknown;
+            end?: unknown;
+        };
+    };
+    tokens?: Record<string, unknown>;
+    cost?: unknown;
+    time?: {
+        start?: unknown;
+        end?: unknown;
+    };
+}
+/** A top-level OpenCode event, which may wrap a part and carries session/usage/error at the envelope level. */
+interface OpenCodeNativeEvent extends OpenCodePart {
+    sessionID?: string;
+    sessionId?: string;
+    part?: OpenCodePart;
+    timestamp?: unknown;
+    usage?: Record<string, unknown>;
+    error?: {
+        data?: {
+            message?: string;
+        };
+        message?: string;
+    };
+}
+/**
+ * Build the OpenCode CLI argv/env for one invocation.
+ *
+ * Runtime context is injected as an extra entry in OpenCode's `instructions`
+ * config (a temp markdown file) delivered through OPENCODE_CONFIG_CONTENT,
+ * merged onto any inline config so the user's existing OpenCode config is not
+ * overwritten. Returns a `cleanup` that removes the temp directory.
+ *
+ */
+export declare function buildOpenCodeCommand(req: InvokeRequest, command?: string): Promise<{
+    command: string;
+    args: string[];
+    env: {
+        OPENCODE_CONFIG_CONTENT: string;
+        OPENCODE_CLIENT: string;
+    };
+    rpcMethod: string;
+    providerSessionId: string | undefined;
+    cleanup: () => Promise<void>;
+}>;
+/** Translate one OpenCode native event/part into canonical events; unrelated events yield an empty list. */
+export declare function normalizeOpenCodeEvent(native: OpenCodeNativeEvent): CanonicalEvent[];
+/**
+ * Create an OpenCode adapter over the JSON CLI helper. OpenCode's stream ends
+ * without an explicit terminal, so `onSuccess` synthesizes the closing
+ * message.update/run.completed; run.failed is emitted inline by the normalizer.
+ */
+export declare class OpenCodeEventNormalizer {
+    #private;
+    normalize(native: OpenCodeNativeEvent): CanonicalEvent[];
+}
+export declare function createOpenCodeAdapter({ command }?: {
+    command?: string;
+}): {
+    respondInteraction: (invocationId: string, response: import("@mininglamp-oss/octo-runtime-protocol").InteractionResponse) => Promise<void>;
+    invoke(request: InvokeRequest, context?: AdapterInvocationContext): AsyncGenerator<CanonicalEvent>;
+    metadata: import("@mininglamp-oss/octo-runtime-adapter-sdk").AdapterMetadata;
+    probe?: (options?: import("@mininglamp-oss/octo-runtime-adapter-sdk").AdapterProbeOptions) => Promise<import("@mininglamp-oss/octo-runtime-adapter-sdk").ProbeResult>;
+};
+export declare const opencodeAdapter: {
+    respondInteraction: (invocationId: string, response: import("@mininglamp-oss/octo-runtime-protocol").InteractionResponse) => Promise<void>;
+    invoke(request: InvokeRequest, context?: AdapterInvocationContext): AsyncGenerator<CanonicalEvent>;
+    metadata: import("@mininglamp-oss/octo-runtime-adapter-sdk").AdapterMetadata;
+    probe?: (options?: import("@mininglamp-oss/octo-runtime-adapter-sdk").AdapterProbeOptions) => Promise<import("@mininglamp-oss/octo-runtime-adapter-sdk").ProbeResult>;
+};
+export default opencodeAdapter;

package/node_modules/@mininglamp-oss/octo-runtime-adapter-opencode/dist/index.js

@@ -0,0 +1,336 @@
+import { initialControlInstructions, hasImageInput, mapReasoningEffort, invocationEnvironment, invocationMcpServers, assertMcpOptions } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+import { canonicalTerminalStatus } from "@mininglamp-oss/octo-runtime-protocol";
+/**
+ * OpenCode adapter: wraps the OpenCode CLI (`opencode run --format json
+ * --thinking --auto`) for full access and ACP for interactive approval.
+ * Both transports normalize provider output into canonical events.
+ */
+import { createAcpAdapter } from "@mininglamp-oss/octo-runtime-adapter-acp";
+import { createJsonCliAdapter, probeCommand, providerInputText } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+/**
+ * Build the OpenCode CLI argv/env for one invocation.
+ *
+ * Runtime context is injected as an extra entry in OpenCode's `instructions`
+ * config (a temp markdown file) delivered through OPENCODE_CONFIG_CONTENT,
+ * merged onto any inline config so the user's existing OpenCode config is not
+ * overwritten. Returns a `cleanup` that removes the temp directory.
+ *
+ */
+export async function buildOpenCodeCommand(req, command = "opencode") {
+    if (hasImageInput(req))
+        throw new Error("UNSUPPORTED_INPUT_MODALITY: opencode does not encode image input");
+    if (req.approvalMode !== "full_access")
+        throw new Error("APPROVAL_MODE_UNSUPPORTED: opencode permission transport is not qualified");
+    const runEnv = invocationEnvironment(req);
+    const servers = invocationMcpServers(req, runEnv);
+    assertMcpOptions(servers, "opencode", ["toolTimeoutMs"]);
+    const directory = await mkdtemp(join(tmpdir(), "octo-runtime-opencode-"));
+    const instructions = join(directory, "instructions.md");
+    await writeFile(instructions, initialControlInstructions(req), { mode: 0o600 });
+    let inline = {};
+    if (runEnv.OPENCODE_CONFIG_CONTENT)
+        inline = JSON.parse(runEnv.OPENCODE_CONFIG_CONTENT);
+    const configuredInstructions = Array.isArray(inline.instructions)
+        ? inline.instructions.filter((value) => typeof value === "string")
+        : [];
+    // Inject harness context via a temporary instructions file, without rewriting the user's existing OpenCode config.
+    if (initialControlInstructions(req))
+        inline.instructions = [...configuredInstructions, instructions];
+    if (Object.keys(servers).length) {
+        inline.mcp = {
+            ...(isRecord(inline.mcp) ? inline.mcp : {}),
+            ...Object.fromEntries(Object.entries(servers).map(([name, server]) => [
+                name,
+                {
+                    ...(server.type === "stdio"
+                        ? {
+                            type: "local",
+                            command: [server.command, ...(server.args ?? [])],
+                            environment: server.env ?? {}
+                        }
+                        : { type: "remote", url: server.url, headers: server.headers ?? {} }),
+                    enabled: true,
+                    ...(server.toolTimeoutMs !== undefined ? { timeout: server.toolTimeoutMs } : {})
+                }
+            ]))
+        };
+    }
+    // Reasoning output and non-interactive tool approval are mandatory parts of
+    // this adapter's provider contract.
+    const args = ["run", "--format", "json", "--thinking", "--auto"];
+    if (req.providerSession?.sessionId)
+        args.push("--session", req.providerSession.sessionId);
+    if (req.agentConfig?.model)
+        args.push("--model", req.agentConfig.model);
+    const variant = mapReasoningEffort("opencode", req.agentConfig?.effort);
+    if (variant && variant !== "enabled" && variant !== "disabled")
+        args.push("--variant", variant);
+    args.push(providerInputText(req));
+    return {
+        command,
+        args,
+        env: { OPENCODE_CONFIG_CONTENT: JSON.stringify(inline), OPENCODE_CLIENT: "octo-runtime" },
+        rpcMethod: "process.argv",
+        providerSessionId: req.providerSession?.sessionId,
+        cleanup: () => rm(directory, { recursive: true, force: true })
+    };
+}
+/** Translate one OpenCode native event/part into canonical events; unrelated events yield an empty list. */
+export function normalizeOpenCodeEvent(native) {
+    const events = [];
+    const part = native.part ?? native;
+    const sessionId = native.sessionID ?? native.sessionId ?? native.part?.sessionID;
+    if ((native.type === "step_start" || native.type === "session.created") && sessionId) {
+        events.push({
+            protocolVersion: 2,
+            type: "session.update",
+            payload: { providerSession: { sessionId, resumable: true } }
+        });
+    }
+    const stepId = part.messageID;
+    const timestamp = providerTimestamp(native.timestamp);
+    if ((native.type === "step_start" || part.type === "step-start") && stepId) {
+        events.push({
+            protocolVersion: 2,
+            type: "model_step.started",
+            payload: { stepId, ...(timestamp === undefined ? {} : { startedAtMs: timestamp }) }
+        });
+    }
+    const toolState = part.state;
+    const toolId = part.callID ?? part.id;
+    if ((native.type === "text" || part.type === "text") && typeof part.text === "string") {
+        events.push({
+            protocolVersion: 2,
+            type: "message.delta",
+            payload: {
+                text: part.text,
+                ...(stepId
+                    ? { stepId, messageId: `opencode:${part.id ?? `${stepId}:answer`}` }
+                    : part.id
+                        ? { messageId: `opencode:${part.id}` }
+                        : {})
+            }
+        });
+    }
+    if ((native.type === "reasoning" || part.type === "reasoning") && typeof part.text === "string") {
+        events.push({
+            protocolVersion: 2,
+            type: "message.delta",
+            payload: {
+                text: part.text,
+                ...(stepId ? { stepId, messageId: `opencode:${part.id ?? `${stepId}:reasoning`}` } : {}),
+                channel: "analysis",
+                exposure: "public_reasoning",
+                provenance: { provider: "opencode", nativeEvent: "reasoning" }
+            }
+        });
+    }
+    if (part.type === "tool" && toolState?.status === "running" && toolId && part.tool) {
+        const args = isRecord(toolState.input)
+            ? toolState.input
+            : toolState.input == null
+                ? {}
+                : { value: toolState.input };
+        events.push({
+            protocolVersion: 2,
+            type: "tool_call.create",
+            payload: {
+                status: "running",
+                id: toolId,
+                name: part.tool,
+                args,
+                ...(stepId ? { stepId } : {})
+            }
+        });
+    }
+    if (part.type === "tool" &&
+        toolId &&
+        toolState?.status &&
+        ["completed", "error"].includes(toolState.status)) {
+        const args = isRecord(toolState.input)
+            ? toolState.input
+            : toolState.input == null
+                ? {}
+                : { value: toolState.input };
+        const durationMs = toolDurationMs(toolState.time);
+        // A terminal-only OpenCode frame carries enough identity to let the
+        // projector create the item without inventing a duplicate start event.
+        events.push({
+            protocolVersion: 2,
+            type: "tool_call.update",
+            payload: {
+                id: toolId,
+                ...(part.tool ? { name: part.tool, args } : {}),
+                status: canonicalTerminalStatus(toolState.status === "error" ? "failed" : toolState.status),
+                output: toolState.output ?? toolState.error,
+                ...(stepId ? { stepId } : {}),
+                ...(durationMs === undefined ? {} : { durationMs })
+            }
+        });
+    }
+    if ((native.type === "step_finish" || part.type === "step-finish") && stepId) {
+        events.push({
+            protocolVersion: 2,
+            type: "model_step.finished",
+            payload: {
+                stepId,
+                status: canonicalTerminalStatus("completed"),
+                ...(typeof part.reason === "string" ? { finishReason: part.reason } : {}),
+                ...(timestamp === undefined ? {} : { endedAtMs: timestamp })
+            }
+        });
+    }
+    if (native.type === "step_finish" || part.type === "step-finish") {
+        events.push({
+            protocolVersion: 2,
+            type: "usage.update",
+            payload: {
+                ...(part.tokens ?? native.usage ?? {}),
+                cost: part.cost,
+                ...(stepId ? { stepId } : {})
+            }
+        });
+        if (part.reason === "stop")
+            events.push({ protocolVersion: 2, type: "run.completed", payload: {} });
+    }
+    if (native.type === "error")
+        events.push({
+            protocolVersion: 2,
+            type: "run.failed",
+            payload: {
+                message: native.error?.data?.message ?? native.error?.message ?? "OpenCode failed",
+                providerError: native.error
+            }
+        });
+    return events;
+}
+/** Narrow an unknown value to a plain object (excluding arrays), used to guard tool input before spreading it. */
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+/** Return OpenCode's provider-measured whole-millisecond tool duration. */
+function toolDurationMs(time) {
+    if (typeof time?.start !== "number" || typeof time.end !== "number")
+        return undefined;
+    if (!Number.isSafeInteger(time.start) || !Number.isSafeInteger(time.end) || time.end < time.start)
+        return undefined;
+    return time.end - time.start;
+}
+/** Preserve a provider event clock only when it is a valid Unix-millisecond value. */
+function providerTimestamp(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+/**
+ * Create an OpenCode adapter over the JSON CLI helper. OpenCode's stream ends
+ * without an explicit terminal, so `onSuccess` synthesizes the closing
+ * message.update/run.completed; run.failed is emitted inline by the normalizer.
+ */
+export class OpenCodeEventNormalizer {
+    #text = new Map();
+    #tools = new Set();
+    normalize(native) {
+        return normalizeOpenCodeEvent(native).flatMap((event) => {
+            if (event.type === "message.delta" &&
+                typeof event.payload.messageId === "string" &&
+                typeof event.payload.text === "string") {
+                const id = event.payload.messageId;
+                const previous = this.#text.get(id);
+                const text = event.payload.text;
+                this.#text.set(id, text);
+                if (previous === undefined)
+                    return [event];
+                if (previous === text)
+                    return [];
+                if (text.startsWith(previous))
+                    return [{ ...event, payload: { ...event.payload, text: text.slice(previous.length) } }];
+                return [
+                    {
+                        protocolVersion: 2,
+                        type: "message.update",
+                        payload: { ...event.payload, status: "streaming" }
+                    }
+                ];
+            }
+            if (event.type === "tool_call.create") {
+                const id = event.payload.id;
+                if (this.#tools.has(id)) {
+                    const output = (native.part ?? native).state?.output;
+                    return output === undefined
+                        ? []
+                        : [
+                            {
+                                protocolVersion: 2,
+                                type: "tool_call.delta",
+                                payload: {
+                                    id,
+                                    outputSnapshot: typeof output === "string" ? output : JSON.stringify(output)
+                                }
+                            }
+                        ];
+                }
+                this.#tools.add(id);
+            }
+            return [event];
+        });
+    }
+}
+export function createOpenCodeAdapter({ command = "opencode" } = {}) {
+    const interactive = createAcpAdapter({
+        type: "opencode",
+        provider: "opencode",
+        command,
+        args: ["acp"],
+        env: () => ({
+            OPENCODE_CLIENT: "octo-runtime",
+            OPENCODE_CONFIG_CONTENT: JSON.stringify({
+                ...(process.env.OPENCODE_CONFIG_CONTENT
+                    ? JSON.parse(process.env.OPENCODE_CONFIG_CONTENT)
+                    : {}),
+                permission: "ask"
+            })
+        })
+    });
+    const options = {
+        metadata: {
+            mcp: true,
+            type: "opencode",
+            agentSources: ["provisioned"]
+        },
+        probe: () => probeCommand(command),
+        buildCommand: (req) => buildOpenCodeCommand(req, command),
+        normalize: normalizeOpenCodeEvent,
+        onSuccess: () => [
+            {
+                protocolVersion: 2,
+                type: "message.update",
+                payload: { role: "assistant", status: "completed" }
+            },
+            { protocolVersion: 2, type: "run.completed", payload: {} }
+        ]
+    };
+    const adapter = createJsonCliAdapter(options);
+    return {
+        ...adapter,
+        respondInteraction: interactive.respondInteraction,
+        async *invoke(request, context) {
+            if (hasImageInput(request))
+                throw new Error("UNSUPPORTED_INPUT_MODALITY: opencode does not encode image input");
+            if (request.approvalMode === "assisted")
+                throw new Error("APPROVAL_MODE_UNSUPPORTED: opencode has no qualified assisted policy");
+            if (request.approvalMode === "ask") {
+                yield* interactive.invoke(request);
+                return;
+            }
+            const normalizer = new OpenCodeEventNormalizer();
+            yield* createJsonCliAdapter({
+                ...options,
+                normalize: (native) => normalizer.normalize(native)
+            }).invoke(request, context);
+        }
+    };
+}
+export const opencodeAdapter = createOpenCodeAdapter();
+export default opencodeAdapter;

package/node_modules/@mininglamp-oss/octo-runtime-adapter-opencode/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@mininglamp-oss/octo-runtime-adapter-opencode",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "exports": "./dist/index.js",
+  "dependencies": {
+    "@mininglamp-oss/octo-runtime-protocol": "1.0.0",
+    "@mininglamp-oss/octo-runtime-adapter-acp": "1.0.0",
+    "@mininglamp-oss/octo-runtime-adapter-sdk": "1.0.0"
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ]
+}

package/node_modules/@mininglamp-oss/octo-runtime-adapter-qodercli/dist/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Qoder CLI ACP adapter. Launches `qodercli --acp` and speaks the Agent
+ * Client Protocol through the shared ACP adapter, which reconstructs model
+ * steps, streams the prompt turn and normalizes `session/update` notifications
+ * into canonical events.
+ *
+ * Full access adds `--yolo`, selecting Qoder's ACP "bypass permissions" mode so headless tool runs
+ * do not block on interactive approval. Qoder advertises session loading, so a
+ * stored provider session resumes through `session/load` without a fresh
+ * fallback. Per-session model selection follows the standard ACP path when the
+ * runtime configures a model that Qoder advertises.
+ */
+export declare const qoderCliAdapter: Readonly<{
+    metadata: {
+        mcp: true;
+        type: string;
+        agentSources: "provisioned"[];
+    };
+    probe: () => Promise<import("@mininglamp-oss/octo-runtime-adapter-sdk").ProbeResult>;
+    respondInteraction(invocationId: string, response: import("@mininglamp-oss/octo-runtime-protocol").InteractionResponse): Promise<void>;
+    invoke(request: import("@mininglamp-oss/octo-runtime-protocol").InvokeRequest): AsyncGenerator<import("@mininglamp-oss/octo-runtime-protocol").CanonicalEvent>;
+}>;
+export default qoderCliAdapter;

package/node_modules/@mininglamp-oss/octo-runtime-adapter-qodercli/dist/index.js

@@ -0,0 +1,20 @@
+import { createAcpAdapter } from "@mininglamp-oss/octo-runtime-adapter-acp";
+/**
+ * Qoder CLI ACP adapter. Launches `qodercli --acp` and speaks the Agent
+ * Client Protocol through the shared ACP adapter, which reconstructs model
+ * steps, streams the prompt turn and normalizes `session/update` notifications
+ * into canonical events.
+ *
+ * Full access adds `--yolo`, selecting Qoder's ACP "bypass permissions" mode so headless tool runs
+ * do not block on interactive approval. Qoder advertises session loading, so a
+ * stored provider session resumes through `session/load` without a fresh
+ * fallback. Per-session model selection follows the standard ACP path when the
+ * runtime configures a model that Qoder advertises.
+ */
+export const qoderCliAdapter = createAcpAdapter({
+    type: "qodercli",
+    provider: "qodercli",
+    command: "qodercli",
+    args: (request) => (request.approvalMode === "full_access" ? ["--yolo", "--acp"] : ["--acp"])
+});
+export default qoderCliAdapter;

package/node_modules/@mininglamp-oss/octo-runtime-adapter-qodercli/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@mininglamp-oss/octo-runtime-adapter-qodercli",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "exports": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@mininglamp-oss/octo-runtime-adapter-acp": "1.0.0"
+  }
+}

package/node_modules/@mininglamp-oss/octo-runtime-adapter-qoderclicn/dist/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Qoder CN CLI ACP adapter. Launches `qoderclicn --acp` and speaks the
+ * Agent Client Protocol through the shared ACP adapter, which reconstructs
+ * model steps, streams the prompt turn and normalizes `session/update`
+ * notifications into canonical events.
+ *
+ * This is the China (CN) distribution of Qoder; it behaves like Qoder CLI —
+ * full access adds `--yolo` to select the ACP "bypass permissions" mode and a stored provider
+ * session resumes through `session/load` — but ships as a distinct `qoderclicn`
+ * binary and is registered as its own adapter type so a runtime can pick the CN
+ * build explicitly.
+ */
+export declare const qoderCliCnAdapter: Readonly<{
+    metadata: {
+        mcp: true;
+        type: string;
+        agentSources: "provisioned"[];
+    };
+    probe: () => Promise<import("@mininglamp-oss/octo-runtime-adapter-sdk").ProbeResult>;
+    respondInteraction(invocationId: string, response: import("@mininglamp-oss/octo-runtime-protocol").InteractionResponse): Promise<void>;
+    invoke(request: import("@mininglamp-oss/octo-runtime-protocol").InvokeRequest): AsyncGenerator<import("@mininglamp-oss/octo-runtime-protocol").CanonicalEvent>;
+}>;
+export default qoderCliCnAdapter;

package/node_modules/@mininglamp-oss/octo-runtime-adapter-qoderclicn/dist/index.js

@@ -0,0 +1,20 @@
+import { createAcpAdapter } from "@mininglamp-oss/octo-runtime-adapter-acp";
+/**
+ * Qoder CN CLI ACP adapter. Launches `qoderclicn --acp` and speaks the
+ * Agent Client Protocol through the shared ACP adapter, which reconstructs
+ * model steps, streams the prompt turn and normalizes `session/update`
+ * notifications into canonical events.
+ *
+ * This is the China (CN) distribution of Qoder; it behaves like Qoder CLI —
+ * full access adds `--yolo` to select the ACP "bypass permissions" mode and a stored provider
+ * session resumes through `session/load` — but ships as a distinct `qoderclicn`
+ * binary and is registered as its own adapter type so a runtime can pick the CN
+ * build explicitly.
+ */
+export const qoderCliCnAdapter = createAcpAdapter({
+    type: "qoderclicn",
+    provider: "qoderclicn",
+    command: "qoderclicn",
+    args: (request) => (request.approvalMode === "full_access" ? ["--yolo", "--acp"] : ["--acp"])
+});
+export default qoderCliCnAdapter;

package/node_modules/@mininglamp-oss/octo-runtime-adapter-qoderclicn/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@mininglamp-oss/octo-runtime-adapter-qoderclicn",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "exports": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@mininglamp-oss/octo-runtime-adapter-acp": "1.0.0"
+  }
+}

package/node_modules/@mininglamp-oss/octo-runtime-adapter-sdk/dist/acp-tool.d.ts

@@ -0,0 +1,15 @@
+import type { CanonicalEvent } from "@mininglamp-oss/octo-runtime-protocol";
+/** ACP updates include both progress and completion; canonical update is terminal-only. */
+export declare function acpToolTerminalStatus(value: unknown): "completed" | "failed" | "cancelled" | undefined;
+export interface AcpToolUpdate {
+    toolCallId?: string;
+    status?: string;
+    name?: string;
+    title?: string;
+    rawInput?: unknown;
+    input?: unknown;
+    rawOutput?: unknown;
+    output?: unknown;
+    content?: unknown;
+}
+export declare function normalizeAcpToolUpdate(update: AcpToolUpdate): CanonicalEvent[];

package/node_modules/@mininglamp-oss/octo-runtime-adapter-sdk/dist/acp-tool.js

@@ -0,0 +1,63 @@
+/** ACP updates include both progress and completion; canonical update is terminal-only. */
+export function acpToolTerminalStatus(value) {
+    switch (typeof value === "string" ? value.toLowerCase() : value) {
+        case "completed":
+        case "success":
+        case "succeeded":
+            return "completed";
+        case "failed":
+        case "error":
+            return "failed";
+        case "cancelled":
+        case "canceled":
+        case "stopped":
+        case "interrupted":
+            return "cancelled";
+        default:
+            return undefined;
+    }
+}
+export function normalizeAcpToolUpdate(update) {
+    const id = update.toolCallId;
+    if (!id)
+        return [];
+    const status = acpToolTerminalStatus(update.status);
+    const output = update.rawOutput ?? update.output ?? update.content;
+    if (status) {
+        const input = update.rawInput ?? update.input;
+        const name = update.name ?? update.title;
+        return [
+            {
+                protocolVersion: 2,
+                type: "tool_call.update",
+                payload: {
+                    id,
+                    status,
+                    ...(name ? { name } : {}),
+                    ...(input === undefined
+                        ? {}
+                        : {
+                            args: input !== null && typeof input === "object" && !Array.isArray(input)
+                                ? input
+                                : { value: input }
+                        }),
+                    ...(output === undefined ? {} : { output })
+                }
+            }
+        ];
+    }
+    // ACP content/rawOutput updates replace the provider's current tool result.
+    // Status-only and unknown-status notifications must not invent a terminal.
+    if (output === undefined)
+        return [];
+    return [
+        {
+            protocolVersion: 2,
+            type: "tool_call.delta",
+            payload: {
+                id,
+                outputSnapshot: typeof output === "string" ? output : JSON.stringify(output)
+            }
+        }
+    ];
+}

package/node_modules/@mininglamp-oss/octo-runtime-adapter-sdk/dist/acp-turn.d.ts

@@ -0,0 +1,13 @@
+import { type CanonicalEvent } from "@mininglamp-oss/octo-runtime-protocol";
+/**
+ * ACP standardizes the stream envelope but does not require providers to emit
+ * public thought chunks or model-round boundaries. Reconstruct conservative
+ * round boundaries from tool lifecycles and retain only already-public answer
+ * text as the card fallback when a provider exposes no reasoning.
+ */
+export declare class AcpTurnNormalizer {
+    #private;
+    constructor(provider: string);
+    normalize(nativeType: unknown, normalized: CanonicalEvent[]): CanonicalEvent[];
+    finish(finishReason: string | undefined, status: string): CanonicalEvent[];
+}