@mininglamp-oss/octo-runtime 1.1.0 → 1.1.2

package/node_modules/@mininglamp-oss/octo-runtime-adapter-grok-build/dist/adapter.js

@@ -0,0 +1,399 @@
+import { spawnGrokBuildAcpClient as spawnAcpClient } from "./client.js";
+import { GrokBuildInteractionBridge as AcpApprovalBridge } from "./interactions.js";
+import { acpModelSelectionRequest, acpActmodeSelectionRequest, normalizeAcpUpdate } from "@mininglamp-oss/octo-runtime-adapter-acp";
+import { acpLoadSessionParams, acpNewSessionParams, acpPromptParams } from "@mininglamp-oss/octo-runtime-acp-client";
+import { initialControlInstructions, actmodeEvidence, AcpTurnNormalizer, defineAdapter, invocationEnvironment, invocationMcpServers, assertMcpOptions, probeCommand } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+import { canonicalTerminalStatus, contextActmode, providerInputParts } from "@mininglamp-oss/octo-runtime-protocol";
+function sessionModel(session) {
+    const modelOption = arrayField(session, "configOptions")
+        .map(recordValue)
+        .find((option) => stringField(option, "id") === "model" || stringField(option, "category") === "model");
+    return (stringField(modelOption ?? {}, "currentValue") ??
+        stringField(recordValue(session.models), "currentModelId") ??
+        stringField(session, "model"));
+}
+export function createGrokBuildAcpAdapter(definition, { acpClientFactory = spawnAcpClient, command = definition.command } = {}) {
+    const responders = new Map();
+    return defineAdapter({
+        metadata: {
+            mcp: true,
+            type: definition.type,
+            agentSources: ["provisioned"]
+        },
+        probe: definition.probe ?? (() => probeCommand(command)),
+        async respondInteraction(invocationId, response) {
+            const bridge = responders.get(invocationId);
+            if (!bridge)
+                throw new Error("INTERACTION_NOT_ACTIVE");
+            await bridge.respond(response);
+        },
+        async *invoke(request, context) {
+            if (request.approvalMode !== "ask" && request.approvalMode !== "full_access")
+                throw new Error("APPROVAL_MODE_UNSUPPORTED: this ACP adapter has no assisted policy");
+            if (responders.has(request.invocationId))
+                throw new Error("INVOCATION_ALREADY_ACTIVE");
+            const bridge = new AcpApprovalBridge(request);
+            responders.set(request.invocationId, bridge);
+            try {
+                yield* bridge.stream(execute(request, bridge, context));
+            }
+            finally {
+                bridge.close("execution_lost");
+                responders.delete(request.invocationId);
+            }
+        }
+    }, definition.reasoningLevels ?? null);
+    async function* execute(request, bridge, context) {
+        const args = typeof definition.args === "function"
+            ? definition.args(request)
+            : (definition.args ?? ["acp"]);
+        const runEnv = invocationEnvironment(request, definition.env?.(request));
+        const mcp = invocationMcpServers(request, runEnv);
+        assertMcpOptions(mcp, definition.type, []);
+        const servers = Object.entries(mcp).map(([name, server]) => server.type === "stdio"
+            ? {
+                name,
+                command: server.command,
+                args: server.args ?? [],
+                env: Object.entries(server.env ?? {}).map(([name, value]) => ({ name, value }))
+            }
+            : {
+                name,
+                type: "http",
+                url: server.url,
+                headers: Object.entries(server.headers ?? {}).map(([name, value]) => ({ name, value }))
+            });
+        const client = acpClientFactory({
+            command,
+            args: [...args],
+            env: runEnv,
+            cwd: request.workdir,
+            ...definition.clientOptions?.(request, bridge),
+            permissionHandler: (params) => bridge.requestPermission(params),
+            onPermissionResponseWritten: (params) => bridge.responseWritten(params),
+            onPermissionResponseFailed: (params, error) => bridge.responseFailed(params, error),
+            ...(context?.streamLimits ? { streamLimits: context.streamLimits } : {})
+        });
+        let sessionId;
+        let terminal = false;
+        let abortClose;
+        const closeAfterAbort = () => {
+            // 审批桥和 signal 共用关闭过程，先给取消通知留出发送窗口，再回收进程。
+            abortClose ??= (async () => {
+                if (sessionId)
+                    client.cancel(sessionId);
+                await new Promise((resolve) => setTimeout(resolve, 250));
+                await client.close();
+            })();
+            return abortClose;
+        };
+        bridge.bindTransport(() => (request.signal?.aborted ? closeAfterAbort() : client.close()));
+        const abort = () => {
+            void closeAfterAbort().catch(() => undefined);
+        };
+        if (request.signal?.aborted)
+            abort();
+        else
+            request.signal?.addEventListener("abort", abort, { once: true });
+        try {
+            const initialization = recordValue(await client.initialize({ protocolVersion: definition.protocolVersion ?? 1 }));
+            await definition.initialize?.(client, initialization, request, runEnv);
+            if (servers.some((server) => server.type === "http") &&
+                recordValue(recordValue(initialization.agentCapabilities).mcpCapabilities).http !== true)
+                throw new Error(`MCP_TRANSPORT_UNSUPPORTED: ${definition.type}: http`);
+            const imageSupported = recordValue(recordValue(initialization.agentCapabilities).promptCapabilities).image ===
+                true;
+            const inputs = [
+                providerInputParts(request),
+                ...(request.providerSession ? [providerInputParts(request, true)] : [])
+            ];
+            if (!imageSupported && inputs.some((parts) => parts.some((part) => part.type === "image"))) {
+                throw new Error("UNSUPPORTED_INPUT_MODALITY: ACP agent did not advertise promptCapabilities.image");
+            }
+            const requestedSessionId = request.providerSession?.sessionId;
+            let providerModel;
+            let resumeFallback;
+            let sessionMethod = requestedSessionId ? "session/load" : "session/new";
+            let sessionParams = requestedSessionId
+                ? acpLoadSessionParams(requestedSessionId, { cwd: request.workdir })
+                : acpNewSessionParams({ cwd: request.workdir });
+            sessionParams.mcpServers = servers;
+            sessionParams =
+                definition.sessionParams?.(sessionParams, request, !requestedSessionId) ?? sessionParams;
+            let sessionRequestId = client.reserveRequestId();
+            let sessionResult = {};
+            let result = await client
+                .request(sessionMethod, sessionParams, {
+                requestId: sessionRequestId,
+                ...(requestedSessionId ? { timeoutMs: 600_000 } : {})
+            })
+                .catch((error) => {
+                if (requestedSessionId && definition.isMissingSessionError?.(error))
+                    return null;
+                throw error;
+            });
+            const initialSessionId = requestedSessionId ?? (isRecord(result) ? stringField(result, "sessionId") : undefined);
+            if (!initialSessionId)
+                throw new Error("ACP session/new returned no sessionId");
+            const missingLoadedSession = requestedSessionId &&
+                (result === null ||
+                    (definition.emptyLoadResultMeansMissing === true &&
+                        isRecord(result) &&
+                        Object.keys(result).length === 0));
+            if (missingLoadedSession) {
+                resumeFallback = "session_load_not_found";
+                sessionMethod = "session/new";
+                sessionParams = acpNewSessionParams({ cwd: request.workdir });
+                sessionParams.mcpServers = servers;
+                sessionParams = definition.sessionParams?.(sessionParams, request, true) ?? sessionParams;
+                sessionRequestId = client.reserveRequestId();
+                result = await client.request(sessionMethod, sessionParams, {
+                    requestId: sessionRequestId
+                });
+                const freshSessionId = stringField(result, "sessionId");
+                if (!freshSessionId)
+                    throw new Error("ACP session/new returned no sessionId");
+            }
+            sessionResult = isRecord(result) ? result : {};
+            sessionId = resumeFallback
+                ? stringField(sessionResult, "sessionId")
+                : (requestedSessionId ?? stringField(sessionResult, "sessionId"));
+            if (!sessionId)
+                throw new Error("ACP session/new returned no sessionId");
+            const requestedMode = contextActmode(request.context);
+            if (requestedMode !== undefined) {
+                const selection = (definition.selectActmode ?? acpActmodeSelectionRequest)(sessionResult, sessionId, requestedMode);
+                if (!selection.unchanged)
+                    await client.request(selection.method, selection.params);
+                yield actmodeEvidence({
+                    requested: requestedMode,
+                    effective: selection.effective,
+                    nativeMode: selection.nativeMode,
+                    status: selection.effective === requestedMode ? "applied" : "fallback",
+                    ...(selection.effective !== requestedMode
+                        ? { reason: "provider_unsupported" }
+                        : {})
+                });
+            }
+            const requestedModel = nonEmptyString(request.agentConfig?.model);
+            if (requestedModel) {
+                const selection = acpModelSelectionRequest(sessionResult, sessionId, requestedModel);
+                if (selection) {
+                    const selectionRequestId = client.reserveRequestId();
+                    const selected = recordValue(await client.request(selection.method, selection.params, {
+                        requestId: selectionRequestId
+                    }));
+                    if (Array.isArray(selected.configOptions))
+                        sessionResult.configOptions = selected.configOptions;
+                }
+                providerModel = requestedModel;
+            }
+            else {
+                providerModel = sessionModel(sessionResult);
+            }
+            if (definition.configureSession)
+                yield* definition.configureSession(client, sessionResult, sessionId, request);
+            yield {
+                protocolVersion: 2,
+                type: "session.update",
+                payload: {
+                    providerSession: {
+                        sessionId,
+                        resumable: true,
+                        ...(resumeFallback
+                            ? {
+                                resumeOutcome: "fresh_fallback",
+                                resumeFallback,
+                                contextInputVariant: request.freshFallbackModelInputParts || request.freshFallbackModelInput
+                                    ? "recovery"
+                                    : "primary"
+                            }
+                            : {}),
+                        ...(providerModel ? { model: providerModel } : {})
+                    }
+                }
+            };
+            const input = providerInputParts(request, resumeFallback !== undefined);
+            const instructions = definition.controlInstructions === "session"
+                ? ""
+                : initialControlInstructions(request, !requestedSessionId || resumeFallback !== undefined);
+            // Preserve the legacy text call while mixed prompts retain every block's position.
+            const prompt = input.length === 1 && input[0]?.type === "text"
+                ? `${input[0].text}${instructions ? `\n\n${instructions}` : ""}`
+                : [
+                    ...input,
+                    ...(instructions
+                        ? [
+                            {
+                                type: "text",
+                                text: instructions
+                            }
+                        ]
+                        : [])
+                ];
+            const promptParams = acpPromptParams(sessionId, prompt);
+            const promptRequestId = client.reserveRequestId();
+            let stopReason;
+            let finishReason;
+            let promptResultPublicText;
+            let producedFinalOutput = false;
+            const activeTools = new Set();
+            const turn = new AcpTurnNormalizer(definition.provider);
+            for await (const update of client.prompt(sessionId, prompt, {
+                requestId: promptRequestId,
+                params: promptParams
+            })) {
+                if (update.type === "prompt_result") {
+                    for (const event of definition.validatePromptResult?.(update) ?? [])
+                        yield event;
+                    stopReason = update.stopReason;
+                    finishReason = update.finishReason;
+                    promptResultPublicText = promptResultText(update);
+                    continue;
+                }
+                const standardUpdate = update;
+                const events = turn.normalize(standardUpdate.sessionUpdate ?? standardUpdate.type, normalizeAcpUpdate(standardUpdate, definition.provider));
+                for (const event of events) {
+                    const id = stringField(event.payload, "id");
+                    if (event.type === "message.delta" &&
+                        event.payload.channel !== "analysis" &&
+                        typeof event.payload.text === "string" &&
+                        event.payload.text.length > 0) {
+                        producedFinalOutput = true;
+                    }
+                    if (event.type === "tool_call.create" && id)
+                        activeTools.add(id);
+                    if (event.type === "tool_call.update" && id && isTerminalToolStatus(event.payload.status))
+                        activeTools.delete(id);
+                    yield event;
+                }
+            }
+            const cancelled = request.signal?.aborted || isCancelledStopReason(stopReason);
+            if (!cancelled && !producedFinalOutput && promptResultPublicText) {
+                const fallbackEvents = turn.normalize("agent_message_chunk", normalizeAcpUpdate({
+                    type: "prompt_result",
+                    sessionUpdate: "agent_message_chunk",
+                    content: { text: promptResultPublicText }
+                }, definition.provider));
+                for (const event of fallbackEvents)
+                    yield event;
+                producedFinalOutput = true;
+            }
+            if (cancelled) {
+                for (const id of activeTools)
+                    yield {
+                        protocolVersion: 2,
+                        type: "tool_call.update",
+                        payload: { id, status: canonicalTerminalStatus("cancelled") }
+                    };
+            }
+            if (!cancelled && !producedFinalOutput) {
+                for (const event of turn.finish("no-final-output", "failed"))
+                    yield event;
+                yield {
+                    protocolVersion: 2,
+                    type: "message.update",
+                    payload: { role: "assistant", status: "failed" }
+                };
+                terminal = true;
+                yield {
+                    protocolVersion: 2,
+                    type: "run.failed",
+                    payload: {
+                        code: "ACP_NO_FINAL_OUTPUT",
+                        message: `${definition.provider} completed without assistant output`,
+                        adapterType: definition.type
+                    }
+                };
+                return;
+            }
+            for (const event of turn.finish(stopReason ?? finishReason, cancelled ? "stopped" : "completed"))
+                yield event;
+            yield {
+                protocolVersion: 2,
+                type: "message.update",
+                payload: { role: "assistant", status: cancelled ? "stopped" : "completed" }
+            };
+            terminal = true;
+            yield cancelled
+                ? {
+                    protocolVersion: 2,
+                    type: "run.cancelled",
+                    payload: {
+                        reason: stopReason ?? String(request.signal?.reason ?? "cancelled"),
+                        ...(finishReason ? { finishReason } : {})
+                    }
+                }
+                : { protocolVersion: 2, type: "run.completed", payload: {} };
+        }
+        catch (error) {
+            if (!terminal && request.signal?.aborted) {
+                yield {
+                    protocolVersion: 2,
+                    type: "run.cancelled",
+                    payload: { reason: String(request.signal.reason ?? "cancelled") }
+                };
+            }
+            else {
+                throw error;
+            }
+        }
+        finally {
+            request.signal?.removeEventListener("abort", abort);
+            if (request.signal?.aborted)
+                await closeAfterAbort();
+            else
+                await client.close();
+        }
+    }
+}
+function contentText(value) {
+    if (isRecord(value) && typeof value.text === "string")
+        return value.text;
+    if (!Array.isArray(value))
+        return undefined;
+    const text = value
+        .filter(isRecord)
+        .map((item) => (typeof item.text === "string" ? item.text : ""))
+        .join("");
+    return text || undefined;
+}
+function promptResultText(update) {
+    for (const value of [
+        update.text,
+        update.content,
+        update.output,
+        update.response,
+        update.message
+    ]) {
+        if (typeof value === "string" && value)
+            return value;
+        const text = contentText(value);
+        if (text)
+            return text;
+    }
+    return undefined;
+}
+function isTerminalToolStatus(status) {
+    return (typeof status === "string" &&
+        ["completed", "failed", "error", "cancelled", "canceled", "stopped"].includes(status.toLowerCase()));
+}
+function isCancelledStopReason(reason) {
+    return (typeof reason === "string" &&
+        ["cancelled", "canceled", "interrupted", "aborted"].includes(reason.toLowerCase()));
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function recordValue(value) {
+    return isRecord(value) ? value : {};
+}
+function arrayField(value, key) {
+    return Array.isArray(value[key]) ? value[key] : [];
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function stringField(value, key) {
+    return typeof value[key] === "string" ? value[key] : undefined;
+}

package/node_modules/@mininglamp-oss/octo-runtime-adapter-grok-build/dist/client.d.ts

@@ -0,0 +1,14 @@
+import { AcpClient, type SpawnAcpClientOptions } from "@mininglamp-oss/octo-runtime-acp-client";
+type JsonRecord = Record<string, unknown>;
+export interface SpawnGrokBuildClientOptions extends SpawnAcpClientOptions {
+    requestHandler?: (method: string, params: JsonRecord) => unknown;
+    onRequestResponseWritten?: (params: JsonRecord) => void;
+    onRequestResponseFailed?: (params: JsonRecord, error: Error) => void;
+}
+export declare class GrokBuildRpcError extends Error {
+    readonly code: unknown;
+    readonly data: unknown;
+    constructor(error: JsonRecord);
+}
+export declare function spawnGrokBuildAcpClient(options: SpawnGrokBuildClientOptions): AcpClient;
+export {};

package/node_modules/@mininglamp-oss/octo-runtime-adapter-grok-build/dist/client.js

@@ -0,0 +1,156 @@
+import { AcpClient } from "@mininglamp-oss/octo-runtime-acp-client";
+import { INVOKE_REQUEST_MAX_BYTES } from "@mininglamp-oss/octo-runtime-protocol";
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+export class GrokBuildRpcError extends Error {
+    code;
+    data;
+    constructor(error) {
+        super(typeof error.message === "string" ? error.message : "Grok Build ACP request failed");
+        this.code = error.code;
+        this.data = error.data;
+    }
+}
+/** 标准 RPC 和更新队列沿用通用客户端；此实例只补充 Grok Build 的反向请求和错误信息。 */
+class GrokBuildAcpClient extends AcpClient {
+    child;
+    options;
+    #rpcErrors = new Map();
+    #activeRequests = new Set();
+    #reader;
+    #stderr = "";
+    #disconnected = false;
+    #closing = false;
+    constructor(child, options) {
+        super({ ...options, child, processGroup: process.platform !== "win32" });
+        this.child = child;
+        this.options = options;
+        child.stderr.on("data", this.#captureStderr);
+        child.stdout.once("end", this.#disconnect);
+        this.#reader = createInterface({ input: child.stdout });
+        this.#reader.on("error", () => undefined);
+        this.#reader.on("line", (line) => {
+            // 通用客户端在解析前执行容量守卫；旁路观察器也不解析超过协议上限的帧。
+            if (Buffer.byteLength(line) > INVOKE_REQUEST_MAX_BYTES)
+                return;
+            let message;
+            try {
+                message = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            if (!isRecord(message))
+                return;
+            if (typeof message.id === "number" && isRecord(message.error)) {
+                if (this.#activeRequests.has(message.id))
+                    this.#rpcErrors.set(message.id, message.error);
+                return;
+            }
+            if ((typeof message.id !== "number" && typeof message.id !== "string") ||
+                typeof message.method !== "string" ||
+                message.method === "session/request_permission")
+                return;
+            const params = isRecord(message.params) ? message.params : {};
+            void Promise.resolve()
+                .then(() => {
+                if (!options.requestHandler)
+                    throw new Error("GROK_CLIENT_METHOD_UNSUPPORTED");
+                return options.requestHandler(message.method, params);
+            })
+                .then((result) => this.#reply({ id: message.id, result }, params), () => this.#reply({
+                id: message.id,
+                error: { code: -32603, message: "Grok Build client request failed" }
+            }));
+        });
+    }
+    #captureStderr = (value) => {
+        this.#stderr = (this.#stderr + value.toString()).slice(-8192);
+    };
+    #disconnect = () => {
+        if (this.#closing)
+            return;
+        this.#disconnected = true;
+        setImmediate(() => {
+            void this.close().catch(() => undefined);
+        });
+    };
+    #reply(message, params) {
+        if (this.#closing)
+            return;
+        const failed = (error) => {
+            if (params)
+                this.options.onRequestResponseFailed?.(params, error);
+            void this.close().catch(() => undefined);
+        };
+        try {
+            this.child.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", ...message })}\n`, (error) => {
+                if (error)
+                    failed(error);
+                else if (params)
+                    this.options.onRequestResponseWritten?.(params);
+            });
+        }
+        catch (error) {
+            failed(error instanceof Error ? error : new Error("Grok Build response delivery failed"));
+        }
+    }
+    async request(method, params, options = {}) {
+        const requestId = options.requestId ?? this.reserveRequestId();
+        this.#activeRequests.add(requestId);
+        try {
+            return await super.request(method, params, { ...options, requestId });
+        }
+        catch (error) {
+            const rpcError = this.#rpcErrors.get(requestId);
+            if (rpcError)
+                throw new GrokBuildRpcError(rpcError);
+            if (this.#disconnected && error instanceof Error && error.message === "ACP client closed")
+                throw new Error(this.#stderr.trim() || "ACP stdout disconnected", { cause: error });
+            throw error;
+        }
+        finally {
+            this.#activeRequests.delete(requestId);
+            this.#rpcErrors.delete(requestId);
+        }
+    }
+    close() {
+        this.#closing = true;
+        this.child.stdout.removeListener("end", this.#disconnect);
+        this.child.stderr.removeListener("data", this.#captureStderr);
+        this.#reader.close();
+        return super.close();
+    }
+    async *prompt(...args) {
+        try {
+            yield* super.prompt(...args);
+        }
+        catch (error) {
+            if (this.#disconnected && error instanceof Error && error.message === "ACP client closed")
+                throw new Error(this.#stderr.trim() || "ACP stdout disconnected", { cause: error });
+            throw error;
+        }
+    }
+}
+export function spawnGrokBuildAcpClient(options) {
+    const child = spawn(options.command, options.args ?? [], {
+        cwd: options.cwd,
+        env: { ...process.env, ...options.env },
+        stdio: ["pipe", "pipe", "pipe"],
+        detached: process.platform !== "win32"
+    });
+    const client = new GrokBuildAcpClient(child, options);
+    if (options.signal?.aborted)
+        void client.close().catch(() => undefined);
+    else if (options.signal) {
+        const abort = () => {
+            void client.close().catch(() => undefined);
+        };
+        options.signal.addEventListener("abort", abort, { once: true });
+        child.once("exit", () => options.signal?.removeEventListener("abort", abort));
+    }
+    return client;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

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

@@ -0,0 +1,29 @@
+import { spawnGrokBuildAcpClient } from "./client.js";
+import { type CanonicalEvent, type InvokeRequest } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+import type { InteractionResponse } from "@mininglamp-oss/octo-runtime-protocol";
+export declare const GROK_BUILD_TESTED_VERSION = "1.0.67";
+/** 宿主可指定已安装命令；每次调用拥有独立 ACP 子进程，不连接用户常驻 leader。 */
+export declare function createGrokBuildAdapter({ command, acpClientFactory }?: {
+    command?: string;
+    acpClientFactory?: typeof spawnGrokBuildAcpClient;
+}): Readonly<{
+    invoke(request: InvokeRequest, context?: Parameters<(request: InvokeRequest, context?: import("@mininglamp-oss/octo-runtime-adapter-sdk").AdapterInvocationContext) => AsyncGenerator<CanonicalEvent>>[1]): AsyncGenerator<CanonicalEvent, void, any>;
+    metadata: {
+        mcp: true;
+        type: string;
+        agentSources: "provisioned"[];
+    };
+    probe: () => Promise<import("@mininglamp-oss/octo-runtime-adapter-sdk").ProbeResult>;
+    respondInteraction: (invocationId: string, response: InteractionResponse) => Promise<void>;
+}>;
+export declare const grokBuildAdapter: Readonly<{
+    invoke(request: InvokeRequest, context?: Parameters<(request: InvokeRequest, context?: import("@mininglamp-oss/octo-runtime-adapter-sdk").AdapterInvocationContext) => AsyncGenerator<CanonicalEvent>>[1]): AsyncGenerator<CanonicalEvent, void, any>;
+    metadata: {
+        mcp: true;
+        type: string;
+        agentSources: "provisioned"[];
+    };
+    probe: () => Promise<import("@mininglamp-oss/octo-runtime-adapter-sdk").ProbeResult>;
+    respondInteraction: (invocationId: string, response: InteractionResponse) => Promise<void>;
+}>;
+export default grokBuildAdapter;