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

package/node_modules/@mininglamp-oss/octo-runtime-adapter-host/dist/host-run-service.d.ts

@@ -0,0 +1,44 @@
+import type { AdapterHostRpc } from "./rpc.js";
+import { type HostFrame, type HostRunReceipt, type InvokeInput, type InvokeEnvironment, type NativeInteractionResponse, type InteractionResponse } from "@mininglamp-oss/octo-runtime-protocol";
+export interface SourceEvent {
+    seq: number;
+    event: HostFrame;
+    bytes: number;
+    at: number;
+}
+/** One process-local event authority around the existing adapter-host IPC client. */
+export declare class HostRunService implements AdapterHostRpc {
+    #private;
+    readonly transport: AdapterHostRpc;
+    readonly invoke: import("@mininglamp-oss/octo-runtime-protocol").InputInvoke;
+    constructor(transport: AdapterHostRpc);
+    get status(): {
+        draining: boolean;
+        activeRuns: number;
+        admittingRuns: number;
+    };
+    list(...args: Parameters<AdapterHostRpc["list"]>): ReturnType<AdapterHostRpc["list"]>;
+    probe(...args: Parameters<AdapterHostRpc["probe"]>): Promise<unknown>;
+    cancel(invocationId: string, reason?: string): ReturnType<AdapterHostRpc["cancel"]>;
+    respondInteraction(invocationId: string, response: InteractionResponse): Promise<void>;
+    respondNative(invocationId: string, response: NativeInteractionResponse): Promise<void>;
+    invokeFrames(input: InvokeInput, environment?: InvokeEnvironment): AsyncGenerator<HostFrame>;
+    submit(input: InvokeInput, environment?: InvokeEnvironment): Promise<HostRunReceipt>;
+    get(runId: string): HostRunReceipt & {
+        oldest_seq: number;
+        latest_seq: number;
+        terminal?: HostFrame;
+    };
+    read(runId: string, streamId: string | undefined, after: number): ReturnType<HostRunService["get"]> & {
+        events: SourceEvent[];
+    };
+    cancelRun(runId: string, reason?: string): ReturnType<AdapterHostRpc["cancel"]>;
+    respond(runId: string, response: InteractionResponse): Promise<void>;
+    respondNativeRun(runId: string, response: NativeInteractionResponse): Promise<void>;
+    acquireSubscription(): () => void;
+    beginDrain(): void;
+    drain(timeoutMs: number): Promise<{
+        drained: boolean;
+    }>;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,293 @@
+import { createInputInvoke, assertInvokeRequestSize, identifyInvokeInput, assertHostFrameIdentity, isHostTerminal } from "@mininglamp-oss/octo-runtime-protocol";
+const TTL = 120_000, MAX_RUN_BYTES = 4 << 20, MAX_BYTES = 64 << 20, MAX_EVENTS = 4096;
+/** One process-local event authority around the existing adapter-host IPC client. */
+export class HostRunService {
+    transport;
+    invoke = createInputInvoke((input, environment) => this.invokeFrames(input, environment));
+    #runs = new Map();
+    #bytes = 0;
+    #subscribers = 0;
+    #draining = false;
+    #tasks = new Set();
+    #starting = new Set();
+    #cleanup;
+    constructor(transport) {
+        this.transport = transport;
+        this.#cleanup = setInterval(() => this.#prune(), 10_000);
+        this.#cleanup.unref();
+    }
+    get status() {
+        return {
+            draining: this.#draining,
+            activeRuns: [...this.#runs.values()].filter((run) => !run.terminal).length,
+            admittingRuns: this.#starting.size
+        };
+    }
+    list(...args) {
+        return this.transport.list(...args);
+    }
+    probe(...args) {
+        return this.transport.probe(...args);
+    }
+    cancel(invocationId, reason) {
+        return this.transport.cancel(invocationId, reason);
+    }
+    respondInteraction(invocationId, response) {
+        return this.transport.respondInteraction(invocationId, response);
+    }
+    respondNative(invocationId, response) {
+        return this.transport.respondNative(invocationId, response);
+    }
+    async #begin(input, environment) {
+        assertInvokeRequestSize(input, environment);
+        this.#prune();
+        if (this.#draining)
+            throw new Error("DAEMON_DRAINING");
+        if (this.#runs.has(input.runId) || this.#starting.has(input.runId))
+            throw new Error("RUN_ALREADY_ACCEPTED");
+        if (this.#runs.size + this.#starting.size >= 128)
+            throw new Error("RUN_CAPACITY_EXHAUSTED");
+        const source = this.transport.invokeFrames(input, environment);
+        this.#starting.add(input.runId);
+        let first;
+        try {
+            const frame = await source.next();
+            if (frame.done)
+                throw new Error("HOST_ENDED_WITHOUT_RECEIPT");
+            first = frame.value;
+        }
+        catch (error) {
+            await source.return(undefined).catch(() => undefined);
+            throw error;
+        }
+        finally {
+            this.#starting.delete(input.runId);
+        }
+        if (this.#draining) {
+            await source.return(undefined);
+            throw new Error("HOST_DRAINING");
+        }
+        const { run_id, invocation_id, stream_id, agent_session_id, session_generation, protocol_mode, protocol } = first;
+        const receipt = {
+            run_id,
+            invocation_id,
+            stream_id,
+            agent_session_id,
+            session_generation,
+            protocol_mode,
+            protocol
+        };
+        const run = {
+            receipt,
+            source,
+            first,
+            streamId: receipt.stream_id,
+            invocationId: input.invocationId,
+            next: 1,
+            bytes: 0,
+            updated: Date.now(),
+            events: []
+        };
+        this.#runs.set(input.runId, run);
+        return run;
+    }
+    async *invokeFrames(input, environment = {}) {
+        const run = await this.#begin(identifyInvokeInput(input), environment);
+        yield* this.#execute(run);
+    }
+    async *#execute(run) {
+        try {
+            this.#append(run, run.first);
+            yield run.first;
+            for await (const event of run.source) {
+                this.#append(run, event);
+                yield event;
+            }
+            if (!run.terminal)
+                throw new Error("HOST_ENDED_WITHOUT_TERMINAL");
+        }
+        catch (error) {
+            if (!run.terminal) {
+                this.#append(run, {
+                    ...run.receipt,
+                    seq: run.next,
+                    kind: "control",
+                    control: {
+                        type: "error",
+                        code: "HOST_EXECUTION_FAILED",
+                        message: "Host execution failed"
+                    }
+                });
+                this.#append(run, {
+                    ...run.receipt,
+                    seq: run.next,
+                    kind: "control",
+                    control: { type: "state", state: "lost" }
+                });
+            }
+            throw error;
+        }
+        finally {
+            await run.source.return(undefined).catch(() => undefined);
+            // A consumer abandoning the generator cannot leave a live provider behind.
+            if (!run.terminal) {
+                await this.transport
+                    .cancel(run.invocationId, "Host stream consumer closed")
+                    .catch(() => undefined);
+                this.#append(run, {
+                    ...run.receipt,
+                    seq: run.next,
+                    kind: "control",
+                    control: { type: "state", state: "cancelled" }
+                });
+            }
+        }
+    }
+    async submit(input, environment = {}) {
+        const run = await this.#begin(identifyInvokeInput(input), environment);
+        const task = (async () => {
+            for await (const event of this.#execute(run))
+                void event;
+        })().catch(() => undefined);
+        this.#tasks.add(task);
+        void task.finally(() => this.#tasks.delete(task));
+        return { ...run.receipt };
+    }
+    #append(run, event) {
+        if (run.terminal)
+            throw new Error("HOST_FRAME_AFTER_TERMINAL");
+        assertHostFrameIdentity(event, run.receipt);
+        if (event.seq !== run.next)
+            throw new Error("STREAM_GAP");
+        // Consumers own persistence and presentation filtering; replay retains the complete event.
+        const safe = structuredClone(event), bytes = Buffer.byteLength(JSON.stringify(safe));
+        if (bytes > 256 << 10)
+            throw new Error("STREAM_EVENT_TOO_LARGE");
+        const now = Date.now();
+        run.updated = now;
+        run.events.push({ seq: run.next++, event: safe, bytes, at: now });
+        run.bytes += bytes;
+        this.#bytes += bytes;
+        if (isHostTerminal(safe))
+            run.terminal = safe;
+        while (run.bytes > MAX_RUN_BYTES || run.events.length > MAX_EVENTS)
+            this.#drop(run);
+        while (this.#bytes > MAX_BYTES) {
+            const oldest = [...this.#runs.values()]
+                .filter((value) => value.events.length)
+                .sort((a, b) => a.events[0].at - b.events[0].at)[0];
+            if (!oldest)
+                break;
+            this.#drop(oldest);
+        }
+        this.#prune();
+    }
+    #drop(run) {
+        const event = run.events.shift();
+        if (event) {
+            run.bytes -= event.bytes;
+            this.#bytes -= event.bytes;
+        }
+    }
+    #prune() {
+        const now = Date.now();
+        for (const [id, run] of this.#runs) {
+            while (run.events[0] && now - run.events[0].at >= TTL)
+                this.#drop(run);
+            if (run.terminal && now - run.updated >= TTL) {
+                this.#bytes -= run.bytes;
+                this.#runs.delete(id);
+            }
+        }
+    }
+    #get(runId) {
+        this.#prune();
+        const run = this.#runs.get(runId);
+        if (!run)
+            throw new Error("RUN_NOT_AVAILABLE");
+        return run;
+    }
+    get(runId) {
+        const run = this.#get(runId);
+        return {
+            ...run.receipt,
+            oldest_seq: run.events[0]?.seq ?? run.next,
+            latest_seq: run.next - 1,
+            ...(run.terminal ? { terminal: structuredClone(run.terminal) } : {})
+        };
+    }
+    read(runId, streamId, after) {
+        const info = this.get(runId), run = this.#get(runId);
+        if (streamId && streamId !== info.stream_id)
+            throw new Error("STREAM_EXPIRED");
+        if (!Number.isSafeInteger(after) || after < 0 || after > info.latest_seq)
+            throw new Error("STREAM_CURSOR_INVALID");
+        if (after + 1 < info.oldest_seq && after < info.latest_seq)
+            throw Object.assign(new Error("STREAM_GAP"), {
+                data: {
+                    requested_after_seq: after,
+                    oldest_seq: info.oldest_seq,
+                    latest_seq: info.latest_seq
+                }
+            });
+        return {
+            ...info,
+            events: run.events
+                .filter((event) => event.seq > after)
+                .slice(0, 32)
+                .map((event) => structuredClone(event))
+        };
+    }
+    cancelRun(runId, reason) {
+        return this.cancel(this.#get(runId).invocationId, reason);
+    }
+    respond(runId, response) {
+        const run = this.#get(runId);
+        if (run.terminal)
+            throw new Error("INTERACTION_EXPIRED");
+        return this.respondInteraction(run.invocationId, response);
+    }
+    respondNativeRun(runId, response) {
+        const run = this.#get(runId);
+        if (run.terminal || run.receipt.protocol_mode !== "native")
+            throw new Error("INTERACTION_NOT_ACTIVE");
+        return this.respondNative(run.invocationId, response);
+    }
+    acquireSubscription() {
+        if (this.#subscribers >= 16)
+            throw new Error("STREAM_SUBSCRIBER_LIMIT");
+        this.#subscribers++;
+        let released = false;
+        return () => {
+            if (!released) {
+                released = true;
+                this.#subscribers--;
+            }
+        };
+    }
+    beginDrain() {
+        this.#draining = true;
+    }
+    async drain(timeoutMs) {
+        if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 60000)
+            throw new Error("DRAIN_TIMEOUT_INVALID");
+        this.beginDrain();
+        const deadline = Date.now() + timeoutMs;
+        while (this.#starting.size || this.status.activeRuns || this.#tasks.size) {
+            if (Date.now() >= deadline)
+                throw new Error("HOST_DRAIN_TIMEOUT");
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+        return { drained: true };
+    }
+    async close() {
+        clearInterval(this.#cleanup);
+        this.beginDrain();
+        await Promise.allSettled([...this.#runs.values()]
+            .filter((run) => !run.terminal)
+            .map((run) => this.cancel(run.invocationId, "Host shutdown")));
+        await Promise.allSettled([...this.#tasks]);
+        this.#runs.clear();
+        this.#bytes = 0;
+    }
+}

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

@@ -0,0 +1,70 @@
+export { HostRunService } from "./host-run-service.js";
+export { readAdapterConfigurations } from "./runtime-configuration.js";
+export { startHostSocketServer, streamHostRun, type HostSocketRequest } from "./socket-server.js";
+export { prepareRunContext, type PreparedRunContext, type WorkspaceAssignments } from "./execution-preparation.js";
+import type { AdapterInvocationContext, AdapterProbeOptions, AdapterOutput } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+import { type InvokeInput, type InvokeEnvironment, type AdapterProtocolSupport, type HostFrame, type NativeInteractionResponse, type InteractionResponse, type InvokeRequest } from "@mininglamp-oss/octo-runtime-protocol";
+import { type RuntimeLog } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+/** Provider-neutral metadata the Host uses for registration and capability discovery. */
+export interface HostedAdapterMetadata {
+    /** False skips Runtime workspace preparation for this Provider. */
+    workspace?: boolean;
+    protocolSupport?: AdapterProtocolSupport;
+    type: string;
+    agentSources: ("preset" | "provisioned")[];
+    processModel?: string;
+    transport?: string;
+    providerVersion?: string | null;
+    providerPath?: string | null;
+    available?: boolean;
+    unavailableReason?: string | null;
+}
+/**
+ * The minimal contract any Octo Runtime adapter must implement.
+ * invoke may wrap a CLI subprocess, ACP, WebSocket or an in-process
+ * implementation, as long as it emits a canonical event stream.
+ */
+export interface HostedAdapter {
+    metadata: HostedAdapterMetadata;
+    probe?: (options?: AdapterProbeOptions) => unknown;
+    /** Execute a turn and report progress for host deadline enforcement. */
+    invoke(request: InvokeRequest, context?: AdapterInvocationContext): AsyncIterable<AdapterOutput>;
+    /** Resume a provider request that paused this exact active invocation. */
+    respondInteraction?(invocationId: string, response: InteractionResponse): Promise<void>;
+    respondNative?(invocationId: string, response: NativeInteractionResponse): Promise<void>;
+}
+/**
+ * The in-process registry and lifecycle gatekeeper for adapters.
+ * It validates plugin input/output, fills in the message lifecycle, guarantees
+ * a single terminal, and turns cancellation into an AbortSignal.
+ */
+export declare class AdapterHost {
+    #private;
+    constructor(options?: {
+        log?: RuntimeLog;
+    });
+    readonly invoke: import("@mininglamp-oss/octo-runtime-protocol").InputInvoke;
+    /** Register an adapter by `metadata.type`; the same type cannot be overwritten twice. */
+    register(adapter: HostedAdapter): void;
+    /** List registered adapters, for Agent registration and control-plane display. */
+    list(): HostedAdapterMetadata[];
+    /** Report installed provider identity separately from adapter registration. */
+    describe(configurations?: Record<string, AdapterProbeOptions>): Promise<HostedAdapterMetadata[]>;
+    /** Public invocations default to native; canonical consumers explicitly select their view. */
+    invokeFrames(input: InvokeInput, environment?: InvokeEnvironment): AsyncGenerator<HostFrame>;
+    /** Run the adapter's own environment probe; return an unchecked-available status when there is no probe. */
+    probe(adapterType: string, options?: AdapterProbeOptions): unknown;
+    /** Abort an active invocation; returns false when that invocation no longer exists or has already ended. */
+    cancel(invocationId: string, reason?: string): boolean;
+    /** Route an answer only to the adapter instance that owns the active invocation. */
+    respondInteraction(invocationId: string, response: InteractionResponse): Promise<void>;
+    respondNative(invocationId: string, response: NativeInteractionResponse): Promise<void>;
+    /** Abort every invocation and wait briefly for adapter cleanup to reap its
+     * provider processes. Used when the RPC parent disappears or shuts down. */
+    shutdown(reason?: string, timeoutMs?: number): Promise<void>;
+}
+export { spawnAdapterHost } from "./process.js";
+export { serveAdapterHost } from "./serve.js";
+export type { AdapterHostProcess, SpawnAdapterHostOptions } from "./process.js";
+export { AdapterHostRpcClient, AdapterHostRpcServer, type AdapterHostRpc, type RpcTrace, type RpcTraceDirection } from "./rpc.js";
+export { DEFAULT_RUNTIME_LIMITS } from "./watchdog.js";