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

package/node_modules/@mininglamp-oss/octo-runtime-adapter-host/dist/watchdog.js

@@ -0,0 +1,366 @@
+import { isTerminal } from "@mininglamp-oss/octo-runtime-protocol";
+import { performance } from "node:perf_hooks";
+export const DEFAULT_RUNTIME_LIMITS = {
+    firstFrameTimeoutMs: 60_000,
+    modelIdleTimeoutMs: 300_000,
+    modelIdleWarningMs: 120_000,
+    modelIdlePolicy: "enforce",
+    toolTimeoutMs: 600_000,
+    runTimeoutMs: 10_800_000,
+    cancelGraceMs: 1_000,
+    enforcement: "enforce"
+};
+export function normalizeRuntimeLimits(value) {
+    return { ...DEFAULT_RUNTIME_LIMITS, ...value };
+}
+const clock = {
+    now: () => performance.now(),
+    schedule: (callback, delayMs) => {
+        const timer = setTimeout(callback, delayMs);
+        timer.unref?.();
+        return () => clearTimeout(timer);
+    }
+};
+/** One autonomous timer per invocation. Neither consumer pulls nor logging drive deadlines. */
+export class InvocationWatchdog {
+    controller;
+    diagnostic;
+    time;
+    limits;
+    #startedAt;
+    #tools = new Map();
+    #interactions = new Set();
+    #waitingSince;
+    #nativeProgressSeen = false;
+    #modelStarted = false;
+    #phase = "starting";
+    #phaseAt;
+    #progressAt;
+    #canonicalAt;
+    #transportAt;
+    #maxCanonicalGapMs = 0;
+    #maxProgressGapMs = 0;
+    #lastMethod = "none";
+    #retryCount = 0;
+    #warned = false;
+    #activityLoggedAt = -Infinity;
+    #finished = false;
+    #terminalSnapshot;
+    #cancelTimer;
+    #unsubscribe;
+    constructor(limits, controller, diagnostic = () => { }, time = clock) {
+        this.controller = controller;
+        this.diagnostic = diagnostic;
+        this.time = time;
+        this.limits = normalizeRuntimeLimits(limits);
+        this.#startedAt =
+            this.#phaseAt =
+                this.#progressAt =
+                    this.#canonicalAt =
+                        this.#transportAt =
+                            time.now();
+        const cancel = () => {
+            this.#phase = "cancelling";
+            this.#cancelTimer?.();
+        };
+        controller.signal.addEventListener("abort", cancel, { once: true });
+        this.#unsubscribe = () => controller.signal.removeEventListener("abort", cancel);
+        this.#emit("started", {
+            effectiveLimits: this.limits,
+            limitsSource: limits ? "request_with_defaults" : "host_defaults"
+        });
+        this.#arm();
+    }
+    activity(activity) {
+        if (!this.#active())
+            return;
+        const valid = activity.kind === "turn_started"
+            ? activity.method === "turn_start"
+            : activity.kind === "turn_progress"
+                ? ["text_delta", "tool_delta", "item_lifecycle", "usage"].includes(activity.method)
+                : activity.kind === "transport_response"
+                    ? activity.method === "rpc_response"
+                    : activity.kind === "retry_notice" && activity.method === "retry";
+        if (!valid ||
+            (activity.toolCallId !== undefined &&
+                (typeof activity.toolCallId !== "string" || !activity.toolCallId)) ||
+            (activity.toolState !== undefined &&
+                (activity.kind !== "turn_progress" ||
+                    activity.method !== "item_lifecycle" ||
+                    !activity.toolCallId ||
+                    !["started", "completed"].includes(activity.toolState))))
+            return;
+        const now = this.time.now();
+        if (activity.kind === "turn_started" || activity.kind === "turn_progress")
+            this.#nativeProgressSeen = true;
+        if (activity.toolCallId && activity.toolState === "started") {
+            if (!this.#tools.has(activity.toolCallId))
+                this.#tools.set(activity.toolCallId, { startedAt: now, progressAt: now });
+        }
+        if (activity.toolCallId && activity.toolState === "completed") {
+            this.#tools.delete(activity.toolCallId);
+        }
+        this.#transportAt = now;
+        this.#lastMethod = activity.method;
+        if (activity.kind === "turn_started") {
+            if (!this.#modelStarted)
+                this.#progress();
+        }
+        else if (activity.kind === "turn_progress") {
+            this.#progress(activity.toolCallId);
+        }
+        else if (activity.kind === "retry_notice")
+            this.#retryCount++;
+        this.#syncPhase();
+        if (this.time.now() - this.#activityLoggedAt >= 1000) {
+            this.#activityLoggedAt = this.time.now();
+            this.#emit("activity");
+        }
+        this.#arm();
+    }
+    canonical(event) {
+        if (!this.#active())
+            return;
+        const now = this.time.now();
+        this.#maxCanonicalGapMs = Math.max(this.#maxCanonicalGapMs, now - this.#canonicalAt);
+        this.#canonicalAt = now;
+        if (isTerminal(event)) {
+            this.#terminalSnapshot = this.snapshot();
+            this.#phase = "terminal";
+            this.dispose();
+            return;
+        }
+        const rawID = event.payload.toolCallId ?? event.payload.id ?? event.payload.itemId;
+        const id = typeof rawID === "string" && rawID ? rawID : undefined;
+        let toolChanged = false;
+        if (event.type === "tool_call.create" && id && !this.#tools.has(id)) {
+            this.#tools.set(id, { startedAt: now, progressAt: now });
+            this.#modelStarted = toolChanged = true;
+        }
+        if (event.type === "tool_call.update" &&
+            id &&
+            ["completed", "failed", "cancelled", "stopped"].includes(String(event.payload.status))) {
+            toolChanged = this.#tools.delete(id);
+        }
+        if (event.type === "interaction.requested" && typeof event.payload.interactionId === "string") {
+            this.#interaction(event.payload.interactionId, true);
+        }
+        if (event.type === "interaction.resolved" && typeof event.payload.interactionId === "string") {
+            this.#interaction(event.payload.interactionId, false);
+        }
+        const hasText = (value) => typeof value === "string" && value.length > 0;
+        const toolProgress = event.payload.progress;
+        const progress = toolChanged ||
+            (event.type.startsWith("message.") && hasText(event.payload.text)) ||
+            event.type === "model_step.started" ||
+            event.type === "model_step.finished" ||
+            (event.type === "tool_call.delta" &&
+                [event.payload.argsDelta, event.payload.outputDelta, event.payload.outputSnapshot].some(hasText)) ||
+            (event.type === "tool_call.progress" &&
+                typeof toolProgress === "object" &&
+                toolProgress !== null &&
+                !Array.isArray(toolProgress) &&
+                (("message" in toolProgress && hasText(toolProgress.message)) ||
+                    ("completed" in toolProgress && typeof toolProgress.completed === "number")));
+        // Only real turn work exits startup. Bookkeeping and empty placeholders do not.
+        if (!this.#nativeProgressSeen && progress) {
+            this.#progress(event.type.startsWith("tool_call.") ? id : undefined);
+        }
+        this.#syncPhase();
+        this.#arm();
+    }
+    /** Lifetime evidence is independent of provider payload conversion. */
+    interaction(requestId, pending) {
+        if (!this.#active())
+            return;
+        this.#interaction(`${typeof requestId}:${requestId}`, pending);
+        this.#syncPhase();
+        this.#arm();
+    }
+    #interaction(id, pending) {
+        const now = this.time.now();
+        if (pending) {
+            if (!this.#interactions.size)
+                this.#waitingSince = now;
+            this.#interactions.add(id);
+        }
+        else {
+            this.#interactions.delete(id);
+            if (!this.#interactions.size && this.#waitingSince !== undefined) {
+                // Each timestamp is suspended only for its own overlap with the wait.
+                this.#progressAt += now - Math.max(this.#waitingSince, this.#progressAt);
+                for (const tool of this.#tools.values()) {
+                    tool.startedAt += now - Math.max(this.#waitingSince, tool.startedAt);
+                    tool.progressAt += now - Math.max(this.#waitingSince, tool.progressAt);
+                }
+                this.#waitingSince = undefined;
+            }
+        }
+    }
+    terminal() {
+        this.#terminalSnapshot = this.snapshot();
+        this.#phase = "terminal";
+        this.dispose();
+    }
+    snapshot() {
+        const now = this.time.now();
+        const age = (at) => Math.max(0, Math.floor(now - at));
+        return {
+            phase: this.#phase,
+            elapsedMs: age(this.#startedAt),
+            phaseAgeMs: age(this.#phaseAt),
+            lastCanonicalAgeMs: age(this.#canonicalAt),
+            lastProgressAgeMs: age(this.#progressAt),
+            lastTransportAgeMs: age(this.#transportAt),
+            maxCanonicalGapMs: Math.floor(Math.max(this.#maxCanonicalGapMs, now - this.#canonicalAt)),
+            maxProgressGapMs: Math.floor(Math.max(this.#maxProgressGapMs, now - this.#progressAt)),
+            openToolCount: this.#tools.size,
+            pendingInteractionCount: this.#interactions.size,
+            retryCount: this.#retryCount,
+            lastMethod: this.#lastMethod,
+            activitySupport: this.#nativeProgressSeen ? "native_progress" : "canonical_only",
+            modelIdlePolicy: this.limits.modelIdlePolicy
+        };
+    }
+    finish(outcome = "stopped") {
+        if (this.#finished)
+            return;
+        this.#finished = true;
+        this.#emit("finished", { ...this.#terminalSnapshot, outcome });
+        this.#phase = "terminal";
+        this.dispose();
+    }
+    dispose() {
+        this.#cancelTimer?.();
+        this.#cancelTimer = undefined;
+        this.#unsubscribe();
+    }
+    #active() {
+        return (this.#phase !== "terminal" && this.#phase !== "cancelling" && !this.controller.signal.aborted);
+    }
+    #progress(toolCallId) {
+        const now = this.time.now();
+        this.#maxProgressGapMs = Math.max(this.#maxProgressGapMs, now - this.#progressAt);
+        this.#progressAt = now;
+        this.#modelStarted = true;
+        const tool = toolCallId ? this.#tools.get(toolCallId) : undefined;
+        if (tool)
+            tool.progressAt = now;
+        if (this.#warned) {
+            this.#warned = false;
+            this.#emit("progress_resumed");
+        }
+    }
+    #syncPhase() {
+        const phase = this.#interactions.size
+            ? "waiting_approval"
+            : this.#tools.size
+                ? "tool_active"
+                : this.#modelStarted
+                    ? "model_active"
+                    : "starting";
+        if (phase === this.#phase)
+            return;
+        if (this.#phase === "tool_active" && phase === "model_active")
+            this.#progressAt = this.time.now();
+        this.#phase = phase;
+        this.#phaseAt = this.time.now();
+        this.#warned = false;
+    }
+    #arm() {
+        this.#cancelTimer?.();
+        if (!this.#active() || this.limits.enforcement === "observe")
+            return; // legacy opt-out
+        const now = this.time.now();
+        const deadlines = [
+            {
+                at: this.#startedAt + this.limits.runTimeoutMs,
+                reason: "run_deadline",
+                budget: this.limits.runTimeoutMs
+            }
+        ];
+        if (this.#phase === "starting")
+            deadlines.push({
+                at: this.#startedAt + this.limits.firstFrameTimeoutMs,
+                reason: "first_frame",
+                budget: this.limits.firstFrameTimeoutMs
+            });
+        if (this.#phase === "model_active" && this.limits.modelIdlePolicy === "enforce")
+            deadlines.push({
+                at: this.#progressAt + this.limits.modelIdleTimeoutMs,
+                reason: "model_silence",
+                budget: this.limits.modelIdleTimeoutMs
+            });
+        for (const tool of this.#phase === "waiting_approval" ? [] : this.#tools.values()) {
+            deadlines.push({
+                at: tool.progressAt + this.limits.toolTimeoutMs,
+                reason: "tool_idle",
+                budget: this.limits.toolTimeoutMs
+            });
+            if (this.limits.toolWallTimeoutMs !== undefined)
+                deadlines.push({
+                    at: tool.startedAt + this.limits.toolWallTimeoutMs,
+                    reason: "tool_deadline",
+                    budget: this.limits.toolWallTimeoutMs
+                });
+        }
+        // Overall resource deadline wins ties, independently of the phase name.
+        const due = deadlines.find((d) => d.reason === "run_deadline" && d.at <= now) ??
+            deadlines.filter((d) => d.at <= now).sort((a, b) => a.at - b.at)[0];
+        if (due) {
+            const stage = due.reason === "run_deadline" ? "run_deadline" : this.#phase;
+            const evidence = this.snapshot();
+            const error = new AdapterWatchdogTimeoutError(stage, due.budget, due.reason, evidence);
+            this.#phase = "cancelling";
+            this.#emit("timeout", {
+                ...evidence,
+                timeoutStage: stage,
+                timeoutMs: due.budget,
+                timeoutReason: due.reason
+            });
+            this.controller.abort(error);
+            return;
+        }
+        if (this.#phase === "model_active" &&
+            !this.#warned &&
+            now >= this.#progressAt + this.limits.modelIdleWarningMs) {
+            this.#warned = true;
+            this.#emit("model_silence");
+        }
+        let nextAt = Math.min(...deadlines.map((d) => d.at));
+        if (this.#phase === "model_active" && !this.#warned)
+            nextAt = Math.min(nextAt, this.#progressAt + this.limits.modelIdleWarningMs);
+        this.#cancelTimer = this.time.schedule(() => this.#arm(), Math.max(1, nextAt - this.time.now()));
+    }
+    #emit(event, extra = {}) {
+        try {
+            this.diagnostic({ event, data: { ...this.snapshot(), ...extra } });
+        }
+        catch {
+            /* diagnostic sinks cannot affect execution */
+        }
+    }
+}
+export class AdapterWatchdogTimeoutError extends Error {
+    timeoutStage;
+    timeoutMs;
+    timeoutReason;
+    evidence;
+    code;
+    constructor(timeoutStage, timeoutMs, timeoutReason, evidence = {}) {
+        super(`adapter watchdog exceeded ${timeoutReason} budget`);
+        this.timeoutStage = timeoutStage;
+        this.timeoutMs = timeoutMs;
+        this.timeoutReason = timeoutReason;
+        this.evidence = evidence;
+        this.name = "AdapterWatchdogTimeoutError";
+        this.code = {
+            first_frame: "ADAPTER_FIRST_FRAME_TIMEOUT",
+            model_silence: "ADAPTER_MODEL_IDLE_TIMEOUT",
+            tool_idle: "ADAPTER_TOOL_IDLE_TIMEOUT",
+            tool_deadline: "ADAPTER_TOOL_DEADLINE",
+            run_deadline: "ADAPTER_RUN_DEADLINE",
+            cleanup_timeout: "ADAPTER_CLEANUP_TIMEOUT"
+        }[timeoutReason];
+    }
+}

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

@@ -0,0 +1,37 @@
+{
+  "name": "@mininglamp-oss/octo-runtime-adapter-host",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./runner": {
+      "types": "./dist/runner.d.ts",
+      "import": "./dist/runner.js"
+    }
+  },
+  "dependencies": {
+    "@mininglamp-oss/octo-runtime-core": "1.0.0",
+    "@mininglamp-oss/octo-runtime-adapter-antigravity": "1.0.0",
+    "@mininglamp-oss/octo-runtime-adapter-claude-code": "1.0.0",
+    "@mininglamp-oss/octo-runtime-adapter-codebuddy": "1.0.0",
+    "@mininglamp-oss/octo-runtime-adapter-codex": "1.0.0",
+    "@mininglamp-oss/octo-runtime-adapter-hermes": "1.0.0",
+    "@mininglamp-oss/octo-runtime-adapter-kimi-code": "1.0.0",
+    "@mininglamp-oss/octo-runtime-adapter-mcode": "1.0.0",
+    "@mininglamp-oss/octo-runtime-adapter-openclaw": "1.0.0",
+    "@mininglamp-oss/octo-runtime-adapter-opencode": "1.0.0",
+    "@mininglamp-oss/octo-runtime-adapter-qodercli": "1.0.0",
+    "@mininglamp-oss/octo-runtime-adapter-qoderclicn": "1.0.0",
+    "@mininglamp-oss/octo-runtime-adapter-zcode-gui": "1.0.0",
+    "@mininglamp-oss/octo-runtime-protocol": "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-kimi-code/dist/index.d.ts

@@ -0,0 +1,11 @@
+export declare const kimiCodeAdapter: 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 kimiCodeAdapter;

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

@@ -0,0 +1,8 @@
+import { createAcpAdapter } from "@mininglamp-oss/octo-runtime-adapter-acp";
+export const kimiCodeAdapter = createAcpAdapter({
+    type: "kimi-code",
+    provider: "kimi-code",
+    command: "kimi",
+    args: ["acp"]
+});
+export default kimiCodeAdapter;

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

@@ -0,0 +1,14 @@
+{
+  "name": "@mininglamp-oss/octo-runtime-adapter-kimi-code",
+  "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-mcode/dist/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * MiniMax Code ACP adapter. Launches `mcode 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.
+ *
+ * MiniMax Code owns model selection itself and advertises no per-session model
+ * option, so no `session/set_model` is sent — the model configured on the
+ * runtime governs. It also advertises `loadSession: false`; a resume whose
+ * `session/load` returns an empty result is treated as a missing session and
+ * falls back to a fresh session (`emptyLoadResultMeansMissing`).
+ */
+export declare const mcodeAdapter: 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 mcodeAdapter;

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

@@ -0,0 +1,21 @@
+import { createAcpAdapter } from "@mininglamp-oss/octo-runtime-adapter-acp";
+/**
+ * MiniMax Code ACP adapter. Launches `mcode 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.
+ *
+ * MiniMax Code owns model selection itself and advertises no per-session model
+ * option, so no `session/set_model` is sent — the model configured on the
+ * runtime governs. It also advertises `loadSession: false`; a resume whose
+ * `session/load` returns an empty result is treated as a missing session and
+ * falls back to a fresh session (`emptyLoadResultMeansMissing`).
+ */
+export const mcodeAdapter = createAcpAdapter({
+    type: "mcode",
+    provider: "mcode",
+    command: "mcode",
+    args: ["acp"],
+    emptyLoadResultMeansMissing: true
+});
+export default mcodeAdapter;

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

@@ -0,0 +1,14 @@
+{
+  "name": "@mininglamp-oss/octo-runtime-adapter-mcode",
+  "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-openclaw/dist/gateway.d.ts

@@ -0,0 +1,45 @@
+export interface OpenClawDeviceIdentity {
+    deviceId: string;
+    publicKey: string;
+    privateKey: string;
+}
+export interface OpenClawGatewayOptions {
+    url: string;
+    token: string;
+    device: OpenClawDeviceIdentity;
+    connectTimeoutMs?: number;
+    requestTimeoutMs?: number;
+}
+export interface OpenClawGatewayEvent {
+    event: string;
+    payload: unknown;
+}
+export interface OpenClawGatewayHello {
+    type: "hello-ok";
+    protocol: number;
+    features?: {
+        methods?: string[];
+        events?: string[];
+    };
+    auth?: {
+        deviceToken?: string;
+        scopes?: string[];
+        role?: string;
+    };
+}
+export declare function createOpenClawDeviceIdentity(): OpenClawDeviceIdentity;
+/** Minimal authenticated Gateway RPC client. One instance owns exactly one WebSocket. */
+export declare class OpenClawGatewayClient {
+    #private;
+    constructor(options: OpenClawGatewayOptions);
+    get hello(): OpenClawGatewayHello | undefined;
+    onEvent(listener: (event: OpenClawGatewayEvent) => void): () => void;
+    connect(): Promise<OpenClawGatewayHello>;
+    request(method: string, params: Record<string, unknown>, options?: {
+        expectFinal?: boolean;
+        timeoutMs?: number | null;
+        signal?: AbortSignal;
+        onAccepted?: (value: unknown) => void;
+    }): Promise<unknown>;
+    close(): Promise<void>;
+}