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

package/node_modules/@mininglamp-oss/octo-runtime-extra-channel-gateway/dist/presentation/run-projector.js

@@ -0,0 +1,358 @@
+import { sanitizePublicValue } from "@mininglamp-oss/octo-runtime-adapter-sdk";
+import { fromMarkdown } from "mdast-util-from-markdown";
+const publicExposures = new Set(["public_reasoning", "public_summary", "public_plan"]);
+export class ImRunProjector {
+    runId;
+    allowToolPreview;
+    #items = new Map();
+    #messages = new Map();
+    #toolInputs = new Map();
+    #currentStep;
+    #seq = 0;
+    #phase = "accepted";
+    #label;
+    #startedAt;
+    #endedAt;
+    #terminal;
+    #failure;
+    #failureMessage;
+    #failureDetail;
+    #providerDiagnostic;
+    #retryNoticeCount = 0;
+    #finalReply;
+    #replyAssessment;
+    constructor(runId, allowToolPreview = false) {
+        this.runId = runId;
+        this.allowToolPreview = allowToolPreview;
+    }
+    accept(event, now = Date.now()) {
+        // 终态后不再接纳迟到帧，防止完成卡片被旧进度改回执行中。
+        if (this.#terminal)
+            return;
+        this.#seq++;
+        const p = event.payload;
+        // 实际协议以 activity/model_step 启动计时，不能只等待历史 run.started。
+        if (event.type === "activity.started" || event.type === "model_step.started")
+            this.#startedAt ??= now;
+        if (event.type === "run.started") {
+            this.#startedAt ??= now;
+            this.#phase = "model";
+            this.#label = undefined;
+        }
+        if (event.type === "run.queued")
+            this.#phase = "accepted";
+        if (event.type === "model_step.started") {
+            const p = event.payload;
+            this.#currentStep = p.stepId;
+            this.#item(`step:${p.stepId}`, "model_step", p.stepId).startedAtMs = p.startedAtMs;
+            this.#phase = "model";
+            this.#label = undefined;
+        }
+        if (event.type === "model_step.finished") {
+            const p = event.payload;
+            const item = this.#item(`step:${p.stepId}`, "model_step", p.stepId);
+            item.status = p.status;
+            item.finishReason = p.finishReason;
+            if (item.startedAtMs !== undefined && p.endedAtMs !== undefined)
+                item.durationMs = Math.max(0, p.endedAtMs - item.startedAtMs);
+        }
+        if (event.type.startsWith("message.")) {
+            const id = p.messageId ??
+                `unidentified:${p.stepId ?? this.#currentStep ?? "run"}:${p.channel ?? "final"}`;
+            const previous = this.#messages.get(id);
+            const channel = p.channel ?? previous?.channel ?? "final";
+            // analysis 必须显式声明可公开；历史片段也清除，避免后续快照泄漏。
+            if (channel === "analysis" && !publicExposures.has(p.exposure ?? "")) {
+                this.#messages.delete(id);
+                this.#items.delete(`message:${id}`);
+                return;
+            }
+            if (!["analysis", "commentary", "final"].includes(channel) ||
+                (p.role && p.role !== "assistant"))
+                return;
+            const text = typeof p.text !== "string"
+                ? (previous?.text ?? "")
+                : event.type === "message.delta"
+                    ? (previous?.text ?? "") + p.text
+                    : p.text;
+            const stepId = p.stepId ?? previous?.stepId ?? this.#currentStep;
+            this.#messages.set(id, { channel, text, stepId });
+            if (channel !== "final") {
+                const item = this.#item(`message:${id}`, channel === "analysis" ? "reasoning" : "commentary", stepId);
+                item.content = text;
+                item.status = event.type === "message.update" ? "completed" : "running";
+            }
+            if (channel === "final" && stepId && this.#items.has(`step:${stepId}`)) {
+                this.#items.get(`step:${stepId}`).content = [...this.#messages.values()]
+                    .filter((message) => message.channel === "final" && message.stepId === stepId)
+                    .map((message) => message.text)
+                    .join("\n\n");
+            }
+            this.#phase =
+                channel === "final" ? "answering" : channel === "analysis" ? "thinking" : "commentary";
+            this.#label = undefined;
+        }
+        if (event.type === "tool_call.create") {
+            const p = event.payload;
+            const item = this.#item(`tool:${p.id}`, "tool", p.stepId ?? this.#currentStep);
+            item.toolName = p.name;
+            item.startedAtMs = now;
+            if (this.allowToolPreview)
+                item.summary = toolPreview(p.name, p.args);
+            const command = stringArg(p.args.command ?? p.args.cmd);
+            if (command.length <= 8192)
+                this.#toolInputs.set(p.id, { command });
+            this.#phase = "tool";
+            this.#label = undefined;
+        }
+        if (event.type === "tool_call.update") {
+            const p = event.payload;
+            const item = this.#item(`tool:${p.id}`, "tool", p.stepId ?? this.#currentStep);
+            item.status = p.status;
+            item.exitCode = p.exitCode;
+            item.durationMs =
+                p.durationMs ??
+                    (item.startedAtMs === undefined ? undefined : Math.max(0, now - item.startedAtMs));
+            const input = this.#toolInputs.get(p.id);
+            if (p.status === "failed" && p.exitCode === 2 && input && detectorFindings(input, p.output))
+                item.outcome = "check_findings";
+            this.#toolInputs.delete(p.id);
+            this.#phase = "tool";
+            this.#label = "工具调用完成";
+        }
+        if (event.type === "activity.started") {
+            const p = event.payload;
+            const phases = {
+                thinking: "thinking",
+                executing_tool: "tool",
+                responding: "answering",
+                starting: "accepted",
+                waiting_input: "waiting",
+                waiting_approval: "waiting",
+                compacting: "model",
+                retrying: "model",
+                working: "model"
+            };
+            this.#phase = phases[p.kind] ?? "model";
+            this.#label = undefined;
+        }
+        if (event.type === "interaction.requested") {
+            this.#phase = "waiting";
+            this.#label = "等待你的确认或输入";
+        }
+        if (event.type === "interaction.resolved") {
+            this.#phase = "model";
+            this.#label = undefined;
+        }
+        if (event.type === "run.notice") {
+            const p = event.payload;
+            if (p.code === "provider_diagnostic" && !this.#providerDiagnostic) {
+                this.#providerDiagnostic = {
+                    adapter: String(p.params.adapter),
+                    diagnosticId: String(p.params.diagnosticId),
+                    category: String(p.params.category),
+                    message: String(sanitizePublicValue(p.params.message))
+                };
+            }
+            if (p.code === "retry_scheduled")
+                this.#retryNoticeCount = Math.min(65535, this.#retryNoticeCount + 1);
+            const labels = {
+                retry_scheduled: "正在重试",
+                context_compacted: "上下文已压缩",
+                model_rerouted: "已切换模型",
+                config_warning: "执行配置提示",
+                provider_diagnostic: "执行遇到问题，等待最终结果"
+            };
+            this.#label = labels[p.code];
+        }
+        if (event.type === "run.completed" ||
+            event.type === "run.failed" ||
+            event.type === "run.cancelled") {
+            this.#terminal =
+                event.type === "run.completed"
+                    ? "completed"
+                    : event.type === "run.failed"
+                        ? "failed"
+                        : "cancelled";
+            this.#endedAt = now;
+            this.#label = undefined;
+            this.#failure = p.failure;
+            if (event.type === "run.failed") {
+                const message = sanitizePublicValue(p.message);
+                const error = sanitizePublicValue(p.error);
+                this.#failureMessage = typeof message === "string" && message.trim() ? message : undefined;
+                const detail = typeof error === "string"
+                    ? error
+                    : error && typeof error === "object"
+                        ? JSON.stringify(error, null, 2)
+                        : undefined;
+                this.#failureDetail =
+                    detail && detail !== this.#failureMessage
+                        ? [this.#failureMessage, detail].filter(Boolean).join("\n")
+                        : this.#failureMessage || detail;
+            }
+            this.#selectFinalReply();
+            for (const item of this.#items.values())
+                if (item.status === "running")
+                    item.status = this.#terminal === "completed" ? "completed" : "cancelled";
+        }
+        if (this.#items.size > 512 ||
+            this.#messages.size > 512 ||
+            [...this.#messages.values()].reduce((size, message) => size + Buffer.byteLength(message.text), 0) >
+                256 * 1024)
+            throw new Error("IM_RESULT_TOO_LARGE");
+    }
+    #item(id, kind, stepId) {
+        let item = this.#items.get(id);
+        if (!item) {
+            item = { id, kind, stepId, status: "running", content: "" };
+            this.#items.set(id, item);
+        }
+        return item;
+    }
+    get finalText() {
+        return [...this.#messages.values()]
+            .filter((m) => m.channel === "final")
+            .map((m) => m.text)
+            .filter(Boolean)
+            .join("\n\n");
+    }
+    // 只在终态选择一次；有故障证据的轮次才解析可见 Markdown 内容。
+    #selectFinalReply() {
+        let text;
+        let allowMention = false;
+        if (this.#terminal === "completed") {
+            const selected = this.finalText;
+            const diagnosed = !!this.#providerDiagnostic || this.#retryNoticeCount > 0;
+            const visible = diagnosed ? hasVisibleReply(selected) : !!selected.trim();
+            this.#replyAssessment = visible ? "ready" : diagnosed ? "needs_verification" : "empty";
+            allowMention = visible;
+            text = visible
+                ? selected
+                : diagnosed
+                    ? "执行已结束，但未收到可确认的回复。请核查任务结果，避免重复执行。" +
+                        (this.#providerDiagnostic
+                            ? `\n原因：${this.#providerDiagnostic.message}\n诊断编号：${this.#providerDiagnostic.diagnosticId}`
+                            : "")
+                    : "执行已结束，未返回文本。";
+        }
+        else
+            text =
+                this.#terminal === "cancelled"
+                    ? "本轮执行已中断。"
+                    : `执行失败：${clampRunes(this.#failureDetail || "系统未返回具体原因，请查看运行记录。", 8000)}`;
+        this.#finalReply = { text, allowMention };
+    }
+    get finalReply() {
+        return (this.#finalReply ?? {
+            text: "本轮执行结果未知，请查看运行记录，避免重复执行。",
+            allowMention: false
+        });
+    }
+    snapshot(now = Date.now()) {
+        const items = structuredClone([...this.#items.values()]);
+        return {
+            runId: this.runId,
+            seq: this.#seq,
+            phase: this.#phase,
+            label: this.#label,
+            terminal: this.#terminal,
+            elapsedMs: this.#startedAt === undefined
+                ? undefined
+                : Math.max(0, (this.#endedAt ?? now) - this.#startedAt),
+            items,
+            reasoningCount: items.filter((i) => i.kind === "reasoning").length,
+            toolCallCount: items.filter((i) => i.kind === "tool").length,
+            modelStepCount: items.filter((i) => i.kind === "model_step").length,
+            failure: this.#failure,
+            failureMessage: this.#failureMessage,
+            failureDetail: this.#failureDetail,
+            replyAssessment: this.#replyAssessment,
+            providerDiagnostic: this.#providerDiagnostic && { ...this.#providerDiagnostic },
+            ...(this.#retryNoticeCount ? { retryNoticeCount: this.#retryNoticeCount } : {})
+        };
+    }
+}
+function hasVisibleReply(text) {
+    const visible = (value) => !!value.replace(/[\s\p{Default_Ignorable_Code_Point}]/gu, "");
+    if (!visible(text))
+        return false;
+    const tree = fromMarkdown(text);
+    const definitions = new Set();
+    const collectDefinitions = (node) => {
+        if (node.type === "definition" && node.url && node.identifier)
+            definitions.add(node.identifier);
+        for (const child of node.children ?? [])
+            collectDefinitions(child);
+    };
+    collectDefinitions(tree);
+    const visit = (node) => {
+        if (node.type === "definition")
+            return false;
+        if (node.type === "html")
+            return visible((node.value ?? "").replace(/<!--[\s\S]*?-->/g, ""));
+        if (["text", "code", "inlineCode"].includes(node.type))
+            return visible(node.value ?? "");
+        if (node.type === "image")
+            return !!node.url;
+        if (node.type === "imageReference")
+            return definitions.has(node.identifier ?? "");
+        return (node.children ?? []).some(visit);
+    };
+    return visit(tree);
+}
+export function clampRunes(value, maximum) {
+    const runes = Array.from(value);
+    return runes.length <= maximum ? value : runes.slice(0, Math.max(0, maximum - 1)).join("") + "…";
+}
+export function compactRunes(value, maximum) {
+    const runes = Array.from(value);
+    if (runes.length <= maximum)
+        return value;
+    const head = Math.floor(((maximum - 3) * 2) / 3);
+    return runes.slice(0, head).join("") + " … " + runes.slice(-(maximum - 3 - head)).join("");
+}
+export function toolPreview(name, args) {
+    const sensitive = /token|secret|password|passwd|credential|authorization|cookie|api_key|apikey|\.env|id_rsa|id_ed25519|private_key|sk-|bf_|ghp_|xoxb-/i;
+    if (["exec_command", "shell", "bash", "sh", "zsh"].includes(name.toLowerCase())) {
+        let command = stringArg(args.command ?? args.cmd).trim();
+        if (sensitive.test(command) || command.includes("\0"))
+            return "";
+        command = command.replace(/^(?:\S*\/)?(?:sh|bash|zsh|dash|ksh|fish)\s+-[a-z]*c[a-z]*\s+(['"])([\s\S]*)\1$/, "$2");
+        return clampRunes(command.replace(/\s+/g, " ").trim(), 42);
+    }
+    if (["read", "read_file", "write_file", "file_read", "file_write"].includes(name.toLowerCase())) {
+        const path = stringArg(args.path ?? args.file_path ?? args.filePath).replace(/\\/g, "/");
+        if (sensitive.test(path) || /:\/\/|[\r\n\0]/.test(path))
+            return "";
+        const parts = path
+            .split("/")
+            .filter((p) => p && p !== "." && p !== "..")
+            .slice(-2);
+        return parts.every((p) => /^[\p{L}\p{N}._+~ -]+$/u.test(p)) && parts.length
+            ? clampRunes("…/" + parts.join("/"), 96)
+            : "";
+    }
+    return "";
+}
+function detectorFindings(input, output) {
+    const command = stringArg(input.command ?? input.cmd);
+    if (!/\bdetect\b/.test(command) || !/--json\b/.test(command))
+        return false;
+    try {
+        const findings = typeof output === "string" ? JSON.parse(output) : output;
+        return (Array.isArray(findings) &&
+            findings.some((f) => {
+                if (!f || typeof f !== "object")
+                    return false;
+                const value = f.antipattern;
+                return typeof value === "string" && !!value.trim();
+            }));
+    }
+    catch {
+        return false;
+    }
+}
+function stringArg(value) {
+    return typeof value === "string" ? value : "";
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Typing 租约：按会话共享续期任务，避免一个 Run 结束后误停另一个 Run 的状态。
+ * 每个 Run 独立释放，租约有最长寿命；关闭连接时同时取消计时器和在途发送。
+ */
+import type { ImAddress } from "../contracts.js";
+export declare class TypingController {
+    #private;
+    readonly send: (address: ImAddress, signal: AbortSignal) => Promise<void>;
+    readonly onError: () => void;
+    readonly intervalMs: number;
+    readonly maxLifetimeMs: number;
+    constructor(send: (address: ImAddress, signal: AbortSignal) => Promise<void>, onError: () => void, intervalMs?: number, maxLifetimeMs?: number);
+    acquire(address: ImAddress, leaseId: string): () => void;
+    close(): Promise<void>;
+    get activeAddresses(): number;
+}

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

@@ -0,0 +1,83 @@
+export class TypingController {
+    send;
+    onError;
+    intervalMs;
+    maxLifetimeMs;
+    #entries = new Map();
+    #closed = false;
+    #closing;
+    #tasks = new Set();
+    constructor(send, onError, intervalMs = 5_000, maxLifetimeMs = 600_000) {
+        this.send = send;
+        this.onError = onError;
+        this.intervalMs = intervalMs;
+        this.maxLifetimeMs = maxLifetimeMs;
+    }
+    acquire(address, leaseId) {
+        if (this.#closed)
+            return () => { };
+        const key = `${address.channelType}:${address.channelId}`;
+        let entry = this.#entries.get(key);
+        if (!entry) {
+            const abort = new AbortController();
+            const tick = () => {
+                const active = this.#entries.get(key);
+                if (!active || active.sending)
+                    return;
+                active.sending = true;
+                const task = this.send(address, abort.signal)
+                    .catch(() => this.onError())
+                    .finally(() => {
+                    active.sending = false;
+                    this.#tasks.delete(task);
+                });
+                this.#tasks.add(task);
+            };
+            entry = {
+                leases: new Map(),
+                timer: setInterval(tick, this.intervalMs),
+                abort,
+                sending: false
+            };
+            entry.timer.unref();
+            this.#entries.set(key, entry);
+            tick();
+        }
+        const previous = entry.leases.get(leaseId);
+        if (previous)
+            clearTimeout(previous);
+        const release = () => {
+            const current = this.#entries.get(key);
+            const timer = current?.leases.get(leaseId);
+            if (timer)
+                clearTimeout(timer);
+            current?.leases.delete(leaseId);
+            if (current && !current.leases.size) {
+                clearInterval(current.timer);
+                current.abort.abort();
+                this.#entries.delete(key);
+            }
+        };
+        const timer = setTimeout(release, this.maxLifetimeMs);
+        timer.unref();
+        entry.leases.set(leaseId, timer);
+        return release;
+    }
+    close() {
+        if (this.#closing)
+            return this.#closing;
+        this.#closed = true;
+        for (const entry of this.#entries.values()) {
+            clearInterval(entry.timer);
+            entry.abort.abort();
+            for (const timer of entry.leases.values())
+                clearTimeout(timer);
+        }
+        this.#entries.clear();
+        this.#closing = Promise.all([...this.#tasks]).then(() => undefined);
+        return this.#closing;
+    }
+    get activeAddresses() {
+        return this.#entries.size;
+    }
+}

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

@@ -0,0 +1,128 @@
+/**
+ * 卡片 API：读取 Bot 的有效能力配置，按模板引用发送/编辑卡片。
+ * 展示数据需符合服务端合同；模板选择与 Run 状态转换由卡片层负责。
+ */
+import type { ChannelType } from "./types.js";
+import { type SendMessageResult } from "./types.js";
+export interface CardTemplateRef {
+    id: string;
+    version: string;
+}
+/** Effective per-bot card policy returned by GET /v1/bot/card/profile. */
+export interface BotCardConfig {
+    card_enabled: boolean;
+    display_enabled: boolean;
+    interaction_enabled: boolean;
+    reasoning_enabled: boolean;
+    reasoning_template_ref: CardTemplateRef | null;
+}
+export interface CardTemplateViewCapability {
+    name: string;
+    states: string[];
+    wire_profile: string;
+    submit_actions: string[];
+}
+export interface CardTemplateCapability {
+    id: string;
+    version: string;
+    available?: boolean;
+    views: CardTemplateViewCapability[];
+}
+export interface CardTemplatingCapability {
+    supported: boolean;
+    wire: string;
+    templates: CardTemplateCapability[];
+}
+/**
+ * Send one Registry-authored type-17 card without any Model B render-owned fields.
+ *
+ * `onBehalfOf` is intentionally absent (unlike {@link sendCardMessage}): Registry template cards
+ * are bot-authored by design, and OBO + type-17 is rejected by P1 Decision 2b — persona-clone
+ * turns skip progress cards entirely in `card-progress.ts`.
+ */
+export declare function sendTemplateCardMessage(params: {
+    apiUrl: string;
+    botToken: string;
+    channelId: string;
+    channelType: ChannelType;
+    templateRef: CardTemplateRef;
+    state: string;
+    data: object;
+    clientMsgNo?: string;
+    signal?: AbortSignal;
+    /**
+     * Forwarded to postJson. A transient progress frame passes false: it is discardable,
+     * and holding the flush while we back off would block the frames behind it. A finalize
+     * frame leaves it unset, because that state has to land.
+     */
+    retryOn429?: boolean;
+}): Promise<SendMessageResult | undefined>;
+/** Replace one Registry-authored card frame; raw content_edit is intentionally unavailable. */
+export declare function editTemplateCardMessage(params: {
+    apiUrl: string;
+    botToken: string;
+    messageId: string;
+    channelId: string;
+    channelType: ChannelType;
+    templateRef: CardTemplateRef;
+    state: string;
+    data: object;
+    cardSeq: number;
+    transient?: boolean;
+    signal?: AbortSignal;
+    /**
+     * Forwarded to postJson. A transient progress frame passes false: it is discardable,
+     * and holding the flush while we back off would block the frames behind it. A finalize
+     * frame leaves it unset, because that state has to land.
+     */
+    retryOn429?: boolean;
+}): Promise<void>;
+/**
+ * D12 生产者能力发现 manifest（octo-server PR #525 P2 D12，additive-only）。
+ */
+export interface CardProfileManifest {
+    /**
+     * D12 manifest 端点是否**已部署并响应**（非 404）。`false` 时所有卡片能力 fail
+     * closed；插件不再使用本地开关或本地推理卡模板兜底。
+     */
+    available: boolean;
+    /** 兼容保留的 manifest 总闸；实际发送使用 `config` 中服务端已 AND 的有效值。 */
+    enabled: boolean;
+    /** 支持的 profile 列表，如 `["octo/v1"]`（P2 增 `"octo/v2"`）。 */
+    profiles?: string[];
+    card_version?: string;
+    /**
+     * 服务端 advertise 的元素/输入白名单（源自 pkg/cardmsg 权威，additive）。producer 据此按
+     * 元素/输入粒度协商 —— 即便 card_version 停在 1.5，也能探测该部署到底吃不吃某元素/输入。
+     * 旧部署不返这两字段（undefined）→ 消费方回退保守基线。
+     */
+    elements?: string[];
+    inputs?: string[];
+    /**
+     * 本地/导航动作白名单(pkg/cardmsg 权威):`Action.ToggleVisibility`/
+     * `Action.CopyToClipboard`/`Action.OpenUrl`。回流 `Action.Submit` 不在此数组中；它由
+     * `profiles` 包含 `octo/v2` 表示，也不得放进展示卡 selectAction。
+     * 旧部署不返该字段(undefined) → 消费方保守视为不支持任何 action。
+     */
+    actions?: string[];
+    /** 尺寸/结构上限（node/depth/body caps 等）。 */
+    limits?: Record<string, unknown>;
+    /** Optional Registry template-ref/v1 capability and explicit Bot catalog. */
+    templating?: CardTemplatingCapability;
+    /** Effective per-bot policy. Each feature flag already includes the server's global gate. */
+    config?: BotCardConfig;
+}
+/**
+ * GET /v1/bot/card/profile — D12 能力发现。发卡前 feature-detect，避免用发送试探
+ * （一个 400 无法区分「disabled」与「invalid」）。
+ *
+ * 返回 `available` 区分端点未部署与已部署；两者都由调用方 fail closed：
+ *   - 端点未部署（404）→ `{ available:false }`。
+ *   - 端点已部署但缺失/非法 `config` → `{ available:true }` 且无 `config`。
+ * 传输 / 5xx 抛错，交由调用方重试节奏处理。
+ */
+export declare function getCardProfile(params: {
+    apiUrl: string;
+    botToken: string;
+    signal?: AbortSignal;
+}): Promise<CardProfileManifest>;