@mininglamp-oss/octo-runtime 1.1.1 → 1.1.2

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;

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

@@ -0,0 +1,273 @@
+import { GrokBuildRpcError, spawnGrokBuildAcpClient } from "./client.js";
+import { createGrokBuildAcpAdapter } from "./adapter.js";
+import { initialControlInstructions, invocationEnvironment, invocationMcpServers, probeCommand } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+export const GROK_BUILD_TESTED_VERSION = "1.0.67";
+const levels = { low: "low", medium: "medium", high: "high", xhigh: "xhigh" };
+function supportedVersion(version) {
+    if (typeof version !== "string")
+        return false;
+    const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(version);
+    return !!match && Number(match[1]) === 1 && (Number(match[2]) > 0 || Number(match[3]) >= 67);
+}
+/** 宿主可指定已安装命令；每次调用拥有独立 ACP 子进程，不连接用户常驻 leader。 */
+export function createGrokBuildAdapter({ command = "grok", acpClientFactory = spawnGrokBuildAcpClient } = {}) {
+    const adapter = createGrokBuildAcpAdapter({
+        type: "grok-build",
+        provider: "grok-build",
+        command,
+        args: ["--no-auto-update", "agent", "--no-leader", "stdio"],
+        controlInstructions: "session",
+        reasoningLevels: levels,
+        async probe() {
+            const result = await probeCommand(command);
+            if (!result.available)
+                return {
+                    ...result,
+                    reason: "command_not_found: install Grok Build and put grok on PATH"
+                };
+            return supportedVersion(result.version)
+                ? result
+                : {
+                    ...result,
+                    available: false,
+                    reason: `grok_version_unsupported: install Grok Build ${GROK_BUILD_TESTED_VERSION} or a compatible 1.x release`
+                };
+        },
+        async initialize(client, init, _request, env) {
+            const version = record(init._meta).agentVersion ?? (await probeCommand(command, { env })).version;
+            if (init.protocolVersion !== 1 || !supportedVersion(version))
+                throw new Error(`GROK_VERSION_UNSUPPORTED: expected ACP v1 and Grok Build >= ${GROK_BUILD_TESTED_VERSION}, < 2.0.0`);
+            const methods = Array.isArray(init.authMethods)
+                ? init.authMethods.map((m) => record(m).id)
+                : [];
+            // 只按 harness 广告顺序协商非交互握手；凭据来源和可用性由 harness 判断。
+            const methodId = methods.find((id) => id === "xai.api_key" || id === "cached_token");
+            if (!methodId)
+                throw new Error("GROK_AUTH_REQUIRED: Grok Build did not advertise a supported non-interactive ACP authentication method; check the harness setup");
+            try {
+                await client.request("authenticate", { methodId, _meta: { headless: true } }, { timeoutMs: 30_000 });
+            }
+            catch {
+                throw new Error("GROK_AUTH_FAILED: Grok Build rejected ACP authentication; check the harness setup");
+            }
+        },
+        sessionParams(params, request, fresh) {
+            // 原生 rules 仅用于新会话；恢复不改系统指令，也不恢复工作区文件快照。
+            const rules = initialControlInstructions(request, fresh);
+            return {
+                ...params,
+                _meta: {
+                    yoloMode: request.approvalMode === "full_access",
+                    autoMode: false,
+                    ...(fresh ? (rules ? { rules } : {}) : { "x.ai/restore_code": false })
+                }
+            };
+        },
+        isMissingSessionError: (error) => error instanceof GrokBuildRpcError &&
+            error.code === -32603 &&
+            record(error.data).code === "FS_NOT_FOUND",
+        selectActmode(_session, sessionId, requested) {
+            // 1.0.67 不发布 modes，但实现标准 set_mode(default/plan)；成功响应后才发布 applied。
+            return {
+                method: "session/set_mode",
+                params: { sessionId, modeId: requested },
+                effective: requested,
+                nativeMode: requested,
+                unchanged: false
+            };
+        },
+        async *configureSession(client, session, sessionId, request) {
+            const requested = request.agentConfig.effort;
+            if (requested === undefined)
+                return;
+            const option = (Array.isArray(session.configOptions) ? session.configOptions : [])
+                .map(record)
+                .find((value) => value.id === "reasoning_effort");
+            const available = (Array.isArray(option?.options) ? option.options : []).map((value) => record(value).value);
+            const effective = available.includes(requested)
+                ? requested
+                : requested === "xhigh" && available.includes("high")
+                    ? "high"
+                    : undefined;
+            if (effective === undefined || effective !== requested)
+                yield reasoningWarning(request, effective === undefined ? "REASONING_EFFORT_NOT_APPLIED" : "REASONING_EFFORT_DOWNGRADED");
+            if (effective !== undefined && option?.currentValue !== effective) {
+                const result = record(await client.request("session/set_config_option", {
+                    sessionId,
+                    configId: "reasoning_effort",
+                    value: effective
+                }));
+                const applied = (Array.isArray(result.configOptions) ? result.configOptions : [])
+                    .map(record)
+                    .find((value) => value.id === "reasoning_effort");
+                if (applied?.currentValue !== effective)
+                    throw new Error("GROK_REASONING_UNCONFIRMED: provider did not confirm the requested effort");
+            }
+        },
+        clientOptions(_request, bridge) {
+            return {
+                requestHandler(method, original) {
+                    // ACP 扩展仅给方法名加下划线，params 仍为原生请求正文。
+                    const nativeMethod = method.startsWith("_") ? method.slice(1) : method;
+                    const params = original;
+                    if (nativeMethod === "x.ai/ask_user_question") {
+                        const questions = questionFields(params.questions);
+                        return bridge.requestQuestion(original, { questions }, (response) => questionResponse(questions, response));
+                    }
+                    if (nativeMethod === "x.ai/exit_plan_mode") {
+                        return bridge.requestQuestion(original, {
+                            questions: [
+                                {
+                                    id: "decision",
+                                    question: typeof params.planContent === "string"
+                                        ? params.planContent
+                                        : "Review the plan",
+                                    options: [{ label: "Approve" }, { label: "Abandon" }]
+                                }
+                            ]
+                        }, (response) => {
+                            if (response.outcome === "cancelled")
+                                return { outcome: "cancelled" };
+                            const answer = answerValues(response, "decision");
+                            if (answer.length !== 1 || !["Approve", "Abandon"].includes(answer[0]))
+                                throw new Error("GROK_PLAN_RESPONSE_INVALID");
+                            return { outcome: answer[0] === "Approve" ? "approved" : "abandoned" };
+                        });
+                    }
+                    throw new Error("GROK_CLIENT_METHOD_UNSUPPORTED");
+                },
+                onRequestResponseWritten: (params) => bridge.responseWritten(params),
+                onRequestResponseFailed: (params, error) => bridge.responseFailed(params, error)
+            };
+        },
+        validatePromptResult(update) {
+            const meta = record(update._meta);
+            if (meta.completionKind !== undefined)
+                throw new Error("GROK_PROMPT_INCOMPLETE: prompt was removed from the provider queue");
+            if (!["end_turn", "cancelled"].includes(String(update.stopReason)))
+                throw new Error("GROK_PROMPT_INCOMPLETE: provider did not report end_turn");
+            const usage = record(meta.usage);
+            const payload = {};
+            for (const key of [
+                "inputTokens",
+                "outputTokens",
+                "totalTokens",
+                "cachedReadTokens",
+                "reasoningTokens"
+            ]) {
+                const value = usage[key] ?? meta[key];
+                if (typeof value === "number" && Number.isFinite(value) && value >= 0)
+                    payload[key] = value;
+            }
+            if (typeof meta.modelId === "string")
+                payload.model = meta.modelId;
+            return Object.keys(payload).length
+                ? [{ protocolVersion: 2, type: "usage.update", payload }]
+                : [];
+        }
+    }, { command, acpClientFactory });
+    return Object.freeze({
+        ...adapter,
+        async *invoke(request, context) {
+            if (request.agentConfig.sandbox !== undefined)
+                throw new Error("SANDBOX_UNSUPPORTED: grok-build ACP has no per-session sandbox override");
+            // Grok 的 MCP 配置会展开模板；拒绝不能可靠保留的最终字面量，不改写用户配置。
+            const env = invocationEnvironment(request);
+            const mcp = invocationMcpServers(request, env);
+            if (JSON.stringify(mcp).includes("${"))
+                throw new Error("MCP_LITERAL_UNSUPPORTED: grok-build");
+            try {
+                yield* adapter.invoke(request, context);
+            }
+            catch (error) {
+                throw publicFailure(error, env);
+            }
+        }
+    });
+}
+function publicFailure(error, env) {
+    if (record(error).code === "ENOENT")
+        return new Error("GROK_START_FAILED: check Grok Build installation, PATH and invocation workdir");
+    // 原始 cause/stack 也可能含凭据，公开错误只保留脱敏消息，不挂回原始错误。
+    const secrets = Object.entries(env)
+        .filter(([key, value]) => value && /token|secret|password|api.?key/i.test(key))
+        .map(([, value]) => value)
+        .sort((left, right) => right.length - left.length);
+    let safe = error instanceof Error ? error.message : "Grok Build ACP invocation failed";
+    for (const secret of secrets)
+        safe = safe.split(secret).join("[REDACTED]");
+    const failure = new Error(safe);
+    const details = record(error);
+    if (typeof details.code === "string" && /^[A-Z][A-Z0-9_]*$/.test(details.code))
+        Object.assign(failure, { code: details.code });
+    for (const key of ["boundary", "measuredBytes", "limitBytes", "itemCount", "limitItems"]) {
+        const value = details[key];
+        if ((key === "boundary" && typeof value === "string" && /^[a-z0-9._-]+$/.test(value)) ||
+            (key !== "boundary" && typeof value === "number" && Number.isFinite(value)))
+            Object.assign(failure, { [key]: value });
+    }
+    return failure;
+}
+function reasoningWarning(request, warningCode) {
+    return {
+        protocolVersion: 2,
+        type: "run.notice",
+        payload: {
+            noticeId: `${request.invocationId}:grok-reasoning`,
+            code: "config_warning",
+            severity: "warning",
+            params: { warningCode }
+        }
+    };
+}
+function questionFields(value) {
+    if (!Array.isArray(value) || value.length === 0 || value.length > 16)
+        throw new Error("GROK_QUESTION_INVALID");
+    const seen = new Set();
+    return value.map((entry, index) => {
+        const question = record(entry);
+        if (typeof question.question !== "string" || !question.question || seen.has(question.question))
+            throw new Error("GROK_QUESTION_INVALID");
+        seen.add(question.question);
+        return { ...question, id: `q${index}` };
+    });
+}
+function answerValues(response, id) {
+    if (response.outcome !== "answered")
+        throw new Error("GROK_QUESTION_RESPONSE_INVALID");
+    const answers = record(record(response.value)[id]).answers;
+    if (!Array.isArray(answers) ||
+        answers.length === 0 ||
+        !answers.every((value) => typeof value === "string" && value.length > 0))
+        throw new Error("GROK_QUESTION_RESPONSE_INVALID");
+    return answers;
+}
+function questionResponse(questions, response) {
+    if (response.outcome === "cancelled")
+        return { outcome: "cancelled" };
+    const answers = {};
+    const annotations = {};
+    for (const question of questions) {
+        const values = answerValues(response, String(question.id));
+        const labels = (Array.isArray(question.options) ? question.options : []).map((option) => record(option).label);
+        const selected = values.filter((value) => labels.includes(value));
+        const custom = values.filter((value) => !labels.includes(value));
+        if (question.multiSelect !== true && values.length !== 1)
+            throw new Error("GROK_QUESTION_RESPONSE_INVALID");
+        answers[String(question.question)] = custom.length ? [...selected, "Other"] : selected;
+        if (custom.length)
+            annotations[String(question.question)] = { notes: custom.join("\n") };
+    }
+    return {
+        outcome: "accepted",
+        answers,
+        ...(Object.keys(annotations).length ? { annotations } : {})
+    };
+}
+function record(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+export const grokBuildAdapter = createGrokBuildAdapter();
+export default grokBuildAdapter;

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

@@ -0,0 +1,27 @@
+import { AcpApprovalBridge, type CanonicalEvent, type InvokeRequest } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+import type { InteractionResponse } from "@mininglamp-oss/octo-runtime-protocol";
+type JsonRecord = Record<string, unknown>;
+interface Question {
+    params: JsonRecord;
+    answer: (response: InteractionResponse) => JsonRecord;
+    resolve: (result: JsonRecord) => void;
+    reject: (error: Error) => void;
+    written: Promise<void>;
+    confirm: () => void;
+    fail: (error: Error) => void;
+    timer: NodeJS.Timeout;
+    expiresAt: number;
+    responding: boolean;
+}
+/** 标准权限沿用 SDK；原生追问和计划确认只存在于当前 Grok Build 调用。 */
+export declare class GrokBuildInteractionBridge extends AcpApprovalBridge {
+    #private;
+    constructor(request: InvokeRequest);
+    requestQuestion(params: JsonRecord, request: JsonRecord, answer: Question["answer"]): Promise<JsonRecord>;
+    respond(response: InteractionResponse): Promise<void>;
+    responseWritten(params: JsonRecord): void;
+    responseFailed(params: JsonRecord, error: Error): void;
+    stream(source: AsyncIterable<CanonicalEvent>): AsyncGenerator<CanonicalEvent>;
+    close(reason: string): void;
+}
+export {};

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

@@ -0,0 +1,161 @@
+import { AcpApprovalBridge, sanitizePublicValue } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+import { randomUUID } from "node:crypto";
+/** 标准权限沿用 SDK；原生追问和计划确认只存在于当前 Grok Build 调用。 */
+export class GrokBuildInteractionBridge extends AcpApprovalBridge {
+    #questions = new Map();
+    #events = [];
+    #wake;
+    #error;
+    #closed = false;
+    constructor(request) {
+        super(request);
+    }
+    requestQuestion(params, request, answer) {
+        if (this.#closed || this.request.signal?.aborted || this.#questions.size >= 16)
+            return Promise.reject(new Error("APPROVAL_WAIT_UNAVAILABLE"));
+        const interactionId = `interaction_${randomUUID()}`;
+        const expiresAt = Date.now() + this.timeoutMs;
+        let confirm;
+        let fail;
+        const written = new Promise((resolve, reject) => {
+            confirm = resolve;
+            fail = reject;
+        });
+        void written.catch(() => undefined);
+        const result = new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.#error = new Error("APPROVAL_EXPIRED");
+                this.#questions.delete(interactionId);
+                reject(this.#error);
+                fail(this.#error);
+                this.#resolved(interactionId, "expired", "approval_timeout");
+            }, this.timeoutMs);
+            timer.unref();
+            this.#questions.set(interactionId, {
+                params,
+                answer,
+                resolve,
+                reject,
+                written,
+                confirm,
+                fail,
+                timer,
+                expiresAt,
+                responding: false
+            });
+        });
+        this.#emit({
+            protocolVersion: 2,
+            type: "interaction.requested",
+            payload: {
+                interactionId,
+                kind: "question",
+                executionInstanceId: this.request.invocationId,
+                expiresAt: new Date(expiresAt).toISOString(),
+                request: sanitizePublicValue(request)
+            }
+        });
+        return result;
+    }
+    async respond(response) {
+        const pending = this.#questions.get(response.interactionId);
+        if (!pending)
+            return super.respond(response);
+        if (pending.responding || pending.expiresAt <= Date.now() || this.request.signal?.aborted)
+            throw new Error("INTERACTION_NOT_ACTIVE");
+        const result = pending.answer(response);
+        pending.responding = true;
+        pending.resolve(result);
+        await pending.written;
+        if (!this.#questions.has(response.interactionId) || this.#closed)
+            throw new Error("INTERACTION_NOT_ACTIVE");
+        clearTimeout(pending.timer);
+        this.#questions.delete(response.interactionId);
+        this.#emit({
+            protocolVersion: 2,
+            type: "interaction.resolved",
+            payload: {
+                interactionId: response.interactionId,
+                executionInstanceId: this.request.invocationId,
+                status: "resolved",
+                outcome: response.outcome
+            }
+        });
+    }
+    responseWritten(params) {
+        super.responseWritten(params);
+        for (const pending of this.#questions.values())
+            if (pending.params === params)
+                pending.confirm();
+    }
+    responseFailed(params, error) {
+        for (const pending of this.#questions.values())
+            if (pending.params === params)
+                pending.fail(error);
+        this.#error = error;
+        super.responseFailed(params, error);
+        this.#wake?.();
+    }
+    async *stream(source) {
+        const iterator = super.stream(source);
+        let next = iterator.next();
+        void next.catch(() => undefined);
+        try {
+            while (true) {
+                while (this.#events.length)
+                    yield this.#events.shift();
+                if (this.#error)
+                    throw this.#error;
+                const wake = new Promise((resolve) => {
+                    this.#wake = () => resolve(null);
+                });
+                const result = await Promise.race([next, wake]);
+                this.#wake = undefined;
+                if (result === null)
+                    continue;
+                while (this.#events.length)
+                    yield this.#events.shift();
+                if (result.done)
+                    return;
+                yield result.value;
+                next = iterator.next();
+                void next.catch(() => undefined);
+            }
+        }
+        catch (error) {
+            this.close("execution_lost");
+            while (this.#events.length)
+                yield this.#events.shift();
+            throw error;
+        }
+        finally {
+            this.close("execution_lost");
+            await iterator.return(undefined);
+        }
+    }
+    close(reason) {
+        super.close(reason);
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        for (const [interactionId, pending] of this.#questions) {
+            clearTimeout(pending.timer);
+            const error = new Error("INTERACTION_NOT_ACTIVE");
+            pending.reject(error);
+            pending.fail(error);
+            this.#resolved(interactionId, "invalidated", reason);
+        }
+        this.#questions.clear();
+    }
+    #resolved(interactionId, status, reasonCode) {
+        this.#emit({
+            protocolVersion: 2,
+            type: "interaction.resolved",
+            payload: { interactionId, executionInstanceId: this.request.invocationId, status, reasonCode }
+        });
+    }
+    #emit(event) {
+        this.#events.push(event);
+        this.#wake?.();
+    }
+}

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

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

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

@@ -1,6 +1,6 @@
 {
   "name": "@mininglamp-oss/octo-runtime-adapter-hermes",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "private": true,
   "type": "module",
   "exports": "./dist/index.js",
@@ -9,6 +9,6 @@
     "dist"
   ],
   "dependencies": {
-    "@mininglamp-oss/octo-runtime-adapter-acp": "1.1.1"
+    "@mininglamp-oss/octo-runtime-adapter-acp": "1.1.2"
   }
 }