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

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/application/session-store.d.ts

@@ -0,0 +1,36 @@
+import type { ImInvocationInput } from "../execution/dispatcher.js";
+import type { ProviderSession } from "@mininglamp-oss/octo-runtime-protocol";
+import type { ImTaskAttempt } from "../contracts.js";
+export interface ImSessionOccurrence {
+    text: string;
+    sessionId: string;
+    runId: string;
+    snapshot?: ImInvocationInput;
+    attempts?: ImTaskAttempt[];
+}
+export interface ImSessionBinding {
+    id?: string;
+    generation: number;
+    providerSession?: ProviderSession;
+    lastEventId?: string;
+    lastRunId?: string;
+    initialContextPrepared?: boolean;
+}
+export interface ImSessionStore {
+    read(key: string): ImSessionBinding | undefined;
+    save(key: string, binding: ImSessionBinding): void;
+    reset(key: string, controlId: string): ImSessionBinding;
+    occurrence(key: string, id: string): ImSessionOccurrence | undefined;
+    remember(key: string, id: string, value: ImSessionOccurrence): void;
+    close?(): void;
+}
+export declare class MemoryImSessionStore implements ImSessionStore {
+    #private;
+    constructor();
+    read(key: string): ImSessionBinding | undefined;
+    save(key: string, value: ImSessionBinding): void;
+    reset(key: string, id: string): ImSessionBinding;
+    occurrence(key: string, id: string): ImSessionOccurrence | undefined;
+    remember(key: string, id: string, value: ImSessionOccurrence): void;
+    close(): void;
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/application/session-store.js

@@ -0,0 +1,93 @@
+/** Bounded process-local mappings; eviction never restores an older session. */
+class BoundedEntries {
+    count;
+    bytes;
+    ttl;
+    #entries = new Map();
+    #bytes = 0;
+    constructor(count, bytes, ttl) {
+        this.count = count;
+        this.bytes = bytes;
+        this.ttl = ttl;
+    }
+    get(key) {
+        this.prune();
+        const entry = this.#entries.get(key);
+        return entry && structuredClone(entry.value);
+    }
+    set(key, value) {
+        const bytes = Buffer.byteLength(key) + Buffer.byteLength(JSON.stringify(value));
+        if (bytes > this.bytes)
+            throw new Error("IM_SESSION_ENTRY_TOO_LARGE");
+        this.prune();
+        this.#delete(key);
+        while (this.#entries.size >= this.count || this.#bytes + bytes > this.bytes)
+            this.#delete(this.#entries.keys().next().value);
+        this.#entries.set(key, {
+            value: structuredClone(value),
+            bytes,
+            expires: Date.now() + this.ttl
+        });
+        this.#bytes += bytes;
+    }
+    prune() {
+        const now = Date.now();
+        for (const [key, entry] of this.#entries)
+            if (entry.expires <= now)
+                this.#delete(key);
+    }
+    #delete(key) {
+        const previous = this.#entries.get(key);
+        if (previous)
+            this.#bytes -= previous.bytes;
+        this.#entries.delete(key);
+    }
+    clear() {
+        this.#entries.clear();
+        this.#bytes = 0;
+    }
+}
+export class MemoryImSessionStore {
+    #bindings = new BoundedEntries(1024, 4 << 20, 24 * 60 * 60_000);
+    #controls = new BoundedEntries(4096, 1 << 20, 120_000);
+    #occurrences = new BoundedEntries(4096, 16 << 20, 120_000);
+    #cleanup = setInterval(() => {
+        this.#bindings.prune();
+        this.#controls.prune();
+        this.#occurrences.prune();
+    }, 10_000);
+    constructor() {
+        this.#cleanup.unref();
+    }
+    read(key) {
+        return this.#bindings.get(key);
+    }
+    save(key, value) {
+        this.#bindings.set(key, value);
+    }
+    reset(key, id) {
+        const controlKey = JSON.stringify([key, id]);
+        if (this.#controls.get(controlKey)) {
+            const current = this.read(key);
+            if (!current)
+                throw new Error("IM_SESSION_EXPIRED");
+            return current;
+        }
+        const binding = { generation: (this.read(key)?.generation ?? 1) + 1 };
+        this.save(key, binding);
+        this.#controls.set(controlKey, true);
+        return binding;
+    }
+    occurrence(key, id) {
+        return this.#occurrences.get(JSON.stringify([key, id]));
+    }
+    remember(key, id, value) {
+        this.#occurrences.set(JSON.stringify([key, id]), value);
+    }
+    close() {
+        clearInterval(this.#cleanup);
+        this.#bindings.clear();
+        this.#controls.clear();
+        this.#occurrences.clear();
+    }
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/contracts.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Octo gateway 配置、入站消息、执行端口和投递回执。
+ */
+import type { ApprovalMode, ContextEnvelope, ContextItem, CanonicalEvent, InteractionResponse, InteractionRequestedPayload, InvokeInput, InvokeEnvironment, ModelInputPart, ProviderSession } from "@mininglamp-oss/octo-runtime-protocol";
+import type { RunPresentation } from "./presentation/run-projector.js";
+export interface ImAdapterConfig {
+    adapter_type?: string;
+    workdir?: string;
+    model?: string;
+    effort?: string;
+    provider_agent_id?: string;
+}
+export interface ImCommonConfig {
+    bot_id: string;
+    bot_name?: string;
+    enabled?: boolean;
+    adapter: ImAdapterConfig;
+    context?: ContextEnvelope;
+    approval_mode?: ApprovalMode;
+    run_timeout_ms?: number;
+    /** Codex 专用的故障恢复预算；不会让其他 Adapter 自动重跑。 */
+    codex_retry?: {
+        enabled?: boolean;
+        max_consecutive_retries?: number;
+        max_total_retries?: number;
+        recovery_timeout_ms?: number;
+        initial_delay_ms?: number;
+        max_delay_ms?: number;
+    };
+    allowed_sender_ids?: string[];
+}
+export interface OctoBotConfig extends ImCommonConfig {
+    api_url: string;
+    bf_token?: string;
+    /** .octospec/tasks/channel-group-admission/plan.md：群/话题入口开关，省略为 true，不影响私聊。 */
+    groups_enabled?: boolean;
+    /** 仅约束群范围；省略、null、[] 均不增加限制，关闭入口使用 groups_enabled=false。 */
+    group_ids?: string[] | null;
+    cards?: boolean;
+    typing?: boolean;
+}
+export type ImBotConfig = OctoBotConfig;
+/** Authenticated scope, resolved from octo-auth rather than caller configuration. */
+export type ScopedOctoBotConfig = OctoBotConfig & {
+    spaceId: string;
+};
+/** 平台归一化后的单条消息。平台回调身份与正文保留在 connector 的闭包内。 */
+export interface ImInboundMessage {
+    markRead?(signal: AbortSignal): Promise<void>;
+    messageId: string;
+    senderId: string;
+    conversationId: string;
+    conversationKind: "direct" | "group" | "thread";
+    text: string;
+    buildInputs?(signal: AbortSignal): Promise<ModelInputPart[]>;
+    reply(text: string, effectKey?: string): Promise<void>;
+    replyFinal?(text: string, effectKey: string): Promise<void>;
+    replyFailure?(event: CanonicalEvent, effectKey: string): Promise<void>;
+    replyDeliveryUnknown?(event: CanonicalEvent, effectKey: string, replyEffectKey: string, signal: AbortSignal): Promise<void>;
+    isReplyDelivered?(effectKey: string): boolean;
+    buildContext(signal: AbortSignal, options?: {
+        initialSession: boolean;
+        mentionGuidance?: boolean;
+        configuredItems?: readonly ContextItem[];
+    }): Promise<ContextEnvelope>;
+    executionEnvironment?(): InvokeEnvironment;
+    runMetadata?: Record<string, unknown>;
+    beginPresentation?(runId: string, onDiagnostic: (code: string) => void, controls: ImRunControls): ImPresentation;
+}
+export interface ImPresentation {
+    interaction?(request: InteractionRequestedPayload): Promise<boolean>;
+    resolveInteraction?(id: string, status: string): Promise<void>;
+    update(snapshot: RunPresentation): void;
+    finish(): Promise<void>;
+}
+/** 控制原执行；平台连接器先验证真实操作者和原卡片身份。 */
+export interface ImRunControls {
+    respond?(response: InteractionResponse): Promise<void>;
+    cancel(): Promise<boolean>;
+    retry(senderId: string, occurrenceId: string): boolean;
+}
+export interface ImTaskAttempt {
+    runId: string;
+    invocationId: string;
+    outcome: string;
+    failureCode?: string;
+    diagnosticId?: string;
+}
+export interface ChannelCallbacks {
+    authorizeSpace?: (spaceId: string) => void;
+    onMessage(message: ImInboundMessage): void;
+    onDisconnect(code: string, retryable?: boolean): void;
+    onDiagnostic?(code: string): void;
+}
+export interface ImAddress {
+    channelId: string;
+    channelType: number;
+}
+export type ImConnectionState = "stopped" | "connecting" | "online" | "retrying" | "failed";
+export interface ImExecutionPort {
+    invoke(input: InvokeInput & {
+        protocol_mode: "canonical";
+    }, environment?: InvokeEnvironment): AsyncIterable<CanonicalEvent>;
+    cancel(invocationId: string, reason?: string): Promise<{
+        cancelled: boolean;
+    }>;
+    respondInteraction(invocationId: string, response: InteractionResponse): Promise<void>;
+}
+export interface ImSession {
+    id?: string;
+    generation: number;
+    providerSession?: ProviderSession;
+    lastEventId?: string;
+    lastRunId?: string;
+    activeInvocationId?: string;
+    pending: number;
+    tail: Promise<void>;
+    /** 同代次排队快照共享资格对象；reset 替换对象，不修改旧请求。 */
+    initialization?: {
+        attempted: boolean;
+    };
+}
+export type DeliveryState = "pending" | "delivered" | "failed" | "unknown";
+export interface ImDeliveryReceipt {
+    effectKey: string;
+    state: DeliveryState;
+    messageId?: string;
+    code?: string;
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/contracts.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/daemon-module.d.ts

@@ -0,0 +1,8 @@
+import type { DaemonModule, DaemonModuleContext } from "@mininglamp-oss/octo-runtime-daemon";
+import type { ImBotConfig } from "./contracts.js";
+import type { ImCredentialSource } from "./ports.js";
+export interface ImModuleConfig {
+    bots?: ImBotConfig[];
+    credentials?: ImCredentialSource;
+}
+export declare function createImModule(context: DaemonModuleContext, input: unknown): DaemonModule;

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/daemon-module.js

@@ -0,0 +1,64 @@
+import { ImChannelManager } from "./lifecycle/manager.js";
+import { MemoryImSessionStore } from "./application/session-store.js";
+export function createImModule(context, input) {
+    const config = input;
+    if (!config ||
+        typeof config !== "object" ||
+        (config.bots !== undefined && !Array.isArray(config.bots)))
+        throw new Error("IM_MODULE_CONFIG_INVALID");
+    const sessions = new MemoryImSessionStore();
+    const im = new ImChannelManager({
+        host: context.host,
+        log: context.log,
+        sessions,
+        ...(context.account
+            ? {
+                authorizeSpace: (spaceId) => {
+                    if (!context.account.profiles.some((profile) => profile.tenantId === spaceId))
+                        throw new Error("IM_TENANT_NOT_ACTIVE");
+                }
+            }
+            : {}),
+        ...(config.credentials ? { credentials: config.credentials } : {})
+    });
+    let closed = false;
+    const upsert = (bot) => {
+        return im.upsert(bot);
+    };
+    return {
+        get status() {
+            return im.status;
+        },
+        async start() {
+            for (const bot of config.bots ?? []) {
+                context.signal.throwIfAborted();
+                await upsert(bot);
+            }
+        },
+        async handle(request) {
+            if (closed)
+                throw new Error("IM_MODULE_STOPPED");
+            const params = request.params ?? {};
+            switch (request.method) {
+                case "status":
+                    return im.status;
+                case "upsert":
+                    return upsert(params.config);
+                case "remove":
+                    if (typeof params.connection_key !== "string" || !params.connection_key)
+                        throw new Error("IM_CONNECTION_KEY_REQUIRED");
+                    await im.remove(params.connection_key);
+                    return { removed: true };
+                default:
+                    throw new Error("IM_MODULE_METHOD_NOT_FOUND");
+            }
+        },
+        async close() {
+            if (closed)
+                return;
+            closed = true;
+            await im.close();
+            sessions.close();
+        }
+    };
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/delivery/dispatcher.d.ts

@@ -0,0 +1,15 @@
+/**
+ * 投递回执与重试：按 effectKey 记录发送结果，避免已确认的消息重复投递。
+ * 只重试投递操作；执行失败或网络结果未知都不能由此触发 AgentRun 重跑。
+ */
+import type { ImDeliveryReceipt } from "../contracts.js";
+export declare class ImDeliveryDispatcher {
+    #private;
+    readonly signal: AbortSignal;
+    constructor(signal: AbortSignal);
+    get receipts(): ImDeliveryReceipt[];
+    deliver(effectKey: string, operation: () => Promise<string | void>, options?: {
+        transient?: boolean;
+        obsolete?: () => boolean;
+    }): Promise<ImDeliveryReceipt>;
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/delivery/dispatcher.js

@@ -0,0 +1,85 @@
+import { OctoApiError } from "../transport/api/errors.js";
+import { ImSendError } from "./text-send.js";
+export class ImDeliveryDispatcher {
+    signal;
+    #receipts = new Map();
+    constructor(signal) {
+        this.signal = signal;
+    }
+    get receipts() {
+        return [...this.#receipts.values()].map((r) => ({ ...r }));
+    }
+    async deliver(effectKey, operation, options = {}) {
+        const previous = this.#receipts.get(effectKey);
+        if (previous?.state === "delivered")
+            return { ...previous };
+        const attempts = options.transient ? 1 : 3;
+        let receipt = { effectKey, state: "pending" };
+        this.#record(receipt);
+        for (let attempt = 0; attempt < attempts && !this.signal.aborted; attempt++) {
+            if (options.obsolete?.())
+                break;
+            try {
+                const messageId = await operation();
+                receipt = { effectKey, state: "delivered", ...(messageId ? { messageId } : {}) };
+                this.#record(receipt);
+                return receipt;
+            }
+            catch (error) {
+                const status = error instanceof OctoApiError ? error.status : undefined;
+                // 无 HTTP 回应时可能已经送达；保留 unknown，不能把网络异常当作确定未发送。
+                const state = error instanceof ImSendError ? error.state : status ? "failed" : "unknown";
+                receipt = {
+                    effectKey,
+                    state: receipt.state === "unknown" ? "unknown" : state,
+                    code: error instanceof ImSendError
+                        ? error.code
+                        : status
+                            ? `IM_HTTP_${status}`
+                            : "IM_DELIVERY_UNKNOWN"
+                };
+                this.#record(receipt);
+                // WS 已在同一确认窗口完成四次预算，不再叠乘 REST 的重试次数。
+                if (error instanceof ImSendError)
+                    break;
+                if (status && status !== 429 && status < 500)
+                    break;
+                if (attempt + 1 === attempts)
+                    break;
+                const delay = error instanceof OctoApiError && status === 429
+                    ? error.retryAfterMs
+                    : 200 * (attempt + 1);
+                if (delay > 3_000)
+                    break;
+                try {
+                    await new Promise((resolve, reject) => {
+                        const abort = () => {
+                            clearTimeout(timer);
+                            this.signal.removeEventListener("abort", abort);
+                            reject(new Error("IM_DELIVERY_CANCELLED"));
+                        };
+                        const timer = setTimeout(() => {
+                            this.signal.removeEventListener("abort", abort);
+                            resolve();
+                        }, delay);
+                        this.signal.addEventListener("abort", abort, { once: true });
+                        if (this.signal.aborted)
+                            abort();
+                    });
+                }
+                catch {
+                    break;
+                }
+            }
+        }
+        if (receipt.state === "pending")
+            receipt = { effectKey, state: "failed", code: "IM_DELIVERY_CANCELLED" };
+        this.#record(receipt);
+        return receipt;
+    }
+    #record(receipt) {
+        this.#receipts.set(receipt.effectKey, receipt);
+        if (this.#receipts.size > 512)
+            this.#receipts.delete(this.#receipts.keys().next().value);
+    }
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/delivery/scheduler.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 进度调度：合并高频快照并串行发送，避免卡片更新乱序或请求堆积。
+ * 终态替换尚未发送的旧进度；flush 等待在途请求与最后一次更新完成。
+ */
+export declare class ProgressScheduler<T> {
+    #private;
+    readonly send: (value: T) => Promise<void>;
+    readonly onError: () => void;
+    readonly intervalMs: number;
+    constructor(send: (value: T) => Promise<void>, onError: () => void, intervalMs?: number);
+    enqueue(value: T, terminal?: boolean): void;
+    flush(): Promise<void>;
+    get terminal(): boolean;
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/delivery/scheduler.js

@@ -0,0 +1,88 @@
+/**
+ * 进度调度：合并高频快照并串行发送，避免卡片更新乱序或请求堆积。
+ * 终态替换尚未发送的旧进度；flush 等待在途请求与最后一次更新完成。
+ */
+export class ProgressScheduler {
+    send;
+    onError;
+    intervalMs;
+    #pending;
+    #running = false;
+    #terminal = false;
+    #flushing = false;
+    #lastSend = 0;
+    #timer;
+    #waiters = [];
+    constructor(send, onError, intervalMs = 500) {
+        this.send = send;
+        this.onError = onError;
+        this.intervalMs = intervalMs;
+    }
+    enqueue(value, terminal = false) {
+        if (this.#terminal)
+            return;
+        // 快照包含累计进度，覆盖 pending 不会丢过程；终态一旦入队就拒绝后续旧帧。
+        this.#terminal = terminal;
+        this.#pending = value;
+        if (terminal && this.#timer) {
+            clearTimeout(this.#timer);
+            this.#timer = undefined;
+        }
+        this.#schedule();
+    }
+    #schedule() {
+        if (this.#running || this.#timer || this.#pending === undefined)
+            return;
+        if (this.#terminal || this.#flushing) {
+            void this.#drain();
+            return;
+        }
+        const delay = this.#lastSend
+            ? Math.max(0, this.#lastSend + this.intervalMs - Date.now())
+            : this.intervalMs;
+        this.#timer = setTimeout(() => {
+            this.#timer = undefined;
+            void this.#drain();
+        }, delay);
+        this.#timer.unref();
+    }
+    async #drain() {
+        if (this.#running || this.#pending === undefined)
+            return;
+        this.#running = true;
+        this.#lastSend = Date.now();
+        const value = this.#pending;
+        this.#pending = undefined;
+        try {
+            await this.send(value);
+        }
+        catch {
+            this.onError();
+        }
+        finally {
+            this.#running = false;
+            if (this.#pending !== undefined)
+                this.#schedule();
+            else {
+                this.#flushing = false;
+                for (const resolve of this.#waiters.splice(0))
+                    resolve();
+            }
+        }
+    }
+    async flush() {
+        if (this.#timer) {
+            clearTimeout(this.#timer);
+            this.#timer = undefined;
+        }
+        if (!this.#running && this.#pending === undefined)
+            return;
+        this.#flushing = true;
+        const done = new Promise((resolve) => this.#waiters.push(resolve));
+        this.#schedule();
+        await done;
+    }
+    get terminal() {
+        return this.#terminal;
+    }
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/delivery/text-send.d.ts

@@ -0,0 +1,19 @@
+/** WS 逻辑消息的确认窗口；不重连、不重新执行模型。 */
+export declare class ImSendError extends Error {
+    readonly code: string;
+    readonly state: "failed" | "unknown";
+    constructor(code: string, state: "failed" | "unknown");
+}
+/** F27：.octospec/tasks/gateway-august-feature-assessment/assessment.md */
+export declare class ImTextSend {
+    #private;
+    readonly send: () => void;
+    readonly finish: (state: "delivered" | "failed" | "unknown") => void;
+    readonly signal: AbortSignal;
+    readonly result: Promise<string>;
+    constructor(send: () => void, finish: (state: "delivered" | "failed" | "unknown") => void, signal: AbortSignal);
+    start(): void;
+    ack(id: string, reason: number): void;
+    fail(code: string): void;
+    disconnected(): void;
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/delivery/text-send.js

@@ -0,0 +1,86 @@
+/** WS 逻辑消息的确认窗口；不重连、不重新执行模型。 */
+export class ImSendError extends Error {
+    code;
+    state;
+    constructor(code, state) {
+        super(code);
+        this.code = code;
+        this.state = state;
+    }
+}
+/** F27：.octospec/tasks/gateway-august-feature-assessment/assessment.md */
+export class ImTextSend {
+    send;
+    finish;
+    signal;
+    #timer;
+    #attempt = 0;
+    #unknown = false;
+    #settled = false;
+    #resolve;
+    #reject;
+    result = new Promise((resolve, reject) => {
+        this.#resolve = resolve;
+        this.#reject = reject;
+    });
+    constructor(send, finish, signal) {
+        this.send = send;
+        this.finish = finish;
+        this.signal = signal;
+    }
+    start() {
+        this.signal.addEventListener("abort", this.#abort, { once: true });
+        if (this.signal.aborted)
+            this.#abort();
+        else
+            this.#send();
+    }
+    ack(id, reason) {
+        if (this.#settled)
+            return;
+        if (reason === 1) {
+            this.#settle("delivered");
+            this.#resolve(id);
+        }
+        else
+            this.fail(`IM_SEND_REJECTED_${reason}`);
+    }
+    fail(code) {
+        if (this.#settled)
+            return;
+        const state = this.#unknown ? "unknown" : "failed";
+        this.#settle(state);
+        this.#reject(new ImSendError(code, state));
+    }
+    disconnected() {
+        if (this.#attempt)
+            this.#unknown = true;
+        this.fail("IM_DISCONNECTED");
+    }
+    #abort = () => this.fail("IM_DELIVERY_CANCELLED");
+    #send() {
+        if (this.#settled)
+            return;
+        this.#attempt++;
+        this.#timer = setTimeout(() => {
+            this.#unknown = true;
+            const delay = [1000, 5000, 10000][this.#attempt - 1];
+            if (delay === undefined)
+                this.fail("IM_SEND_TIMEOUT");
+            else
+                this.#timer = setTimeout(() => this.#send(), delay);
+        }, 15_000);
+        try {
+            this.send();
+        }
+        catch (error) {
+            this.fail(error instanceof ImSendError ? error.code : "IM_SEND_FAILED");
+        }
+    }
+    #settle(state) {
+        this.#settled = true;
+        clearTimeout(this.#timer);
+        this.signal.removeEventListener("abort", this.#abort);
+        this.finish(state);
+    }
+}

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/execution/dispatcher.d.ts

@@ -0,0 +1,12 @@
+import { type ContextEnvelope, type InvokeInput } from "@mininglamp-oss/octo-runtime-protocol";
+import type { ImBotConfig, ImInboundMessage, ImSession } from "../contracts.js";
+export type ImInvocationInput = InvokeInput & {
+    runId: string;
+    invocationId: string;
+    sessionId: string;
+    protocol_mode: "canonical";
+};
+export declare function createImInvocation(config: ImBotConfig, message: ImInboundMessage, context: ContextEnvelope, sessionKey: string, session: ImSession, _signal: AbortSignal, occurrenceId?: string): {
+    request: ImInvocationInput;
+    adapterType: string;
+};