@rynx-ai/plugin-channel-lark 0.1.9

package/dist/lark-card-stream.js

@@ -0,0 +1,1335 @@
+import { Buffer } from "node:buffer";
+import { randomUUID } from "node:crypto";
+const OUTPUT_MAX_BYTES = 2048;
+const REASONING_MAX_BYTES = 4096;
+const AGENT_MESSAGE_MAX_BYTES = 8192;
+const DIFF_MAX_BYTES = 6144;
+export function createInitialCardState({ localThreadId, model, runtime, resumeShortId, effort, startedAt = new Date().toISOString(), }) {
+    return {
+        status: "starting",
+        statusReason: null,
+        plan: null,
+        reasoningSummary: "",
+        toolCalls: [],
+        turnDiff: null,
+        agentMessage: "",
+        finalAnswer: null,
+        errorMessage: null,
+        localThreadId,
+        codexThreadId: null,
+        resumeShortId: resumeShortId ?? null,
+        turnId: null,
+        runtime: runtime ?? null,
+        model,
+        effort: effort ?? null,
+        usage: null,
+        startedAt,
+    };
+}
+export function applyEventToCardState(state, event) {
+    switch (event.type) {
+        case "meta":
+            return state;
+        case "session_bound":
+            return {
+                ...state,
+                codexThreadId: event.runtimeSessionId ?? state.codexThreadId,
+                status: state.status === "starting" ? "running" : state.status,
+            };
+        case "turn_started":
+            return { ...state, turnId: event.turnId ?? state.turnId, status: "running" };
+        case "turn_completed":
+            return {
+                ...state,
+                status: state.status === "failed" || state.status === "cancelled" ? state.status : "completed",
+                usage: event.usage ?? state.usage,
+            };
+        case "session_notice":
+            return event.kind === "session.expired"
+                ? { ...state, statusReason: "session.expired" }
+                : state;
+        case "message_completed":
+            return event.text ? { ...state, agentMessage: event.text } : state;
+        case "reasoning_delta": {
+            if (!event.text) {
+                return state;
+            }
+            return {
+                ...state,
+                reasoningSummary: tailBytes(state.reasoningSummary + event.text, REASONING_MAX_BYTES),
+            };
+        }
+        case "plan":
+            return { ...state, plan: event.steps ?? null };
+        case "turn_diff":
+            return event.diff.trim()
+                ? { ...state, turnDiff: tailBytes(event.diff, DIFF_MAX_BYTES) }
+                : state;
+        case "file_change": {
+            // Per-item patches also arrive aggregated as `turn_diff`; only use these
+            // as a fallback when no turn diff exists.
+            if (state.turnDiff) {
+                return state;
+            }
+            const composed = event.changes
+                .filter((change) => typeof change.diff === "string" && change.diff)
+                .map((change) => change.diff)
+                .join("\n");
+            return composed ? { ...state, turnDiff: tailBytes(composed, DIFF_MAX_BYTES) } : state;
+        }
+        case "status":
+        case "reasoning_completed":
+        case "runtime_debug":
+            return state;
+        case "token": {
+            const text = event.text ?? "";
+            if (!text) {
+                return state;
+            }
+            const next = state.agentMessage + text;
+            return {
+                ...state,
+                status: state.status === "starting" ? "running" : state.status,
+                agentMessage: tailBytes(next, AGENT_MESSAGE_MAX_BYTES),
+            };
+        }
+        case "tool":
+            return applyToolEvent(state, event);
+        case "tool_output_delta": {
+            if (!event.delta) {
+                return state;
+            }
+            return mergeToolCall(state, event.callId, (tool) => ({
+                ...tool,
+                output: tailBytes((tool.output ?? "") + event.delta, OUTPUT_MAX_BYTES),
+            }));
+        }
+        case "final":
+            return {
+                ...state,
+                finalAnswer: event.answer || state.agentMessage || null,
+            };
+        case "done":
+            return state;
+        default:
+            return state;
+    }
+}
+function applyToolEvent(state, event) {
+    const name = event.name ?? "tool";
+    const kind = classifyToolKind(name);
+    const data = event.data;
+    const itemId = event.input?.id ??
+        event.output?.id ??
+        data?.item?.id ??
+        `${kind}:${state.toolCalls.length}`;
+    if (event.event === "on_tool_start") {
+        const command = event.input?.command ?? undefined;
+        const label = command ?? deriveToolLabel(kind, event.input);
+        const exists = state.toolCalls.find((tool) => tool.itemId === itemId);
+        if (exists) {
+            return mergeToolCall(state, itemId, (tool) => ({
+                ...tool,
+                status: "inProgress",
+            }));
+        }
+        return {
+            ...state,
+            toolCalls: [
+                ...state.toolCalls,
+                {
+                    itemId,
+                    kind,
+                    label,
+                    status: "inProgress",
+                    command,
+                    output: undefined,
+                },
+            ],
+        };
+    }
+    if (event.event === "on_tool_end") {
+        const output = event.output;
+        const status = output?.status === "completed"
+            ? "completed"
+            : output?.status === "failed"
+                ? "failed"
+                : output?.status === "declined"
+                    ? "declined"
+                    : "completed";
+        return mergeToolCall(state, itemId, (tool) => ({
+            ...tool,
+            status,
+            command: tool.command ?? output?.command,
+            output: output?.aggregatedOutput
+                ? tailBytes(output.aggregatedOutput, OUTPUT_MAX_BYTES)
+                : tool.output,
+            exitCode: output?.exitCode ?? null,
+        }));
+    }
+    return state;
+}
+function classifyToolKind(name) {
+    if (name === "command_execution")
+        return "command_execution";
+    if (name === "file_change")
+        return "file_change";
+    if (name.startsWith("mcp:"))
+        return "mcp_tool_call";
+    if (name.startsWith("dynamic:"))
+        return "dynamic_tool_call";
+    if (name === "web_search")
+        return "web_search";
+    return "other";
+}
+function deriveToolLabel(kind, input) {
+    switch (kind) {
+        case "command_execution":
+            return "shell";
+        case "file_change":
+            return "file change";
+        case "mcp_tool_call":
+            return "mcp tool";
+        case "dynamic_tool_call":
+            return "tool";
+        case "web_search":
+            return input?.query ?? "web search";
+        default:
+            return "tool";
+    }
+}
+function mergeToolCall(state, itemId, mutator) {
+    const index = state.toolCalls.findIndex((tool) => tool.itemId === itemId);
+    if (index < 0) {
+        return {
+            ...state,
+            toolCalls: [
+                ...state.toolCalls,
+                mutator({
+                    itemId,
+                    kind: "other",
+                    label: "tool",
+                    status: "inProgress",
+                }),
+            ],
+        };
+    }
+    const updated = [...state.toolCalls];
+    updated[index] = mutator(updated[index]);
+    return { ...state, toolCalls: updated };
+}
+function tailBytes(value, maxBytes) {
+    if (Buffer.byteLength(value, "utf8") <= maxBytes) {
+        return value;
+    }
+    let bytes = 0;
+    let cut = value.length;
+    for (let i = value.length - 1; i >= 0; i--) {
+        const ch = value.charCodeAt(i);
+        bytes += ch < 0x80 ? 1 : ch < 0x800 ? 2 : 3;
+        if (bytes > maxBytes) {
+            cut = i + 1;
+            break;
+        }
+    }
+    return `…${value.slice(cut)}`;
+}
+const STATUS_LABELS = {
+    starting: "正在准备",
+    running: "正在处理",
+    completed: "已完成",
+    failed: "失败",
+    cancelled: "已停止",
+};
+const STATUS_EMOJI = {
+    starting: "⏳",
+    running: "⏳",
+    completed: "✅",
+    failed: "❌",
+    cancelled: "⏹",
+};
+const ELEMENT_IDS = {
+    // Top status row is a column_set: left column holds the status markdown,
+    // optional right column holds the stop button. Inner markdown is updated
+    // via partial_update_element on `status` so the row container stays put.
+    status_row: "status_row",
+    status: "status",
+    stop_column: "stop_column",
+    plan: "plan",
+    // Container panels appear at the body level; their inner markdowns
+    // (reasoning, tools, output) live inside them and are only ever updated
+    // via partial_update_element on the inner element_id (so the user's
+    // expand/collapse state stays put).
+    reasoning_panel: "reasoning_panel",
+    reasoning: "reasoning",
+    tools_panel: "tools_panel",
+    tools: "tools",
+    output: "output",
+    diff_panel: "diff_panel",
+    diff: "diff",
+    message: "message",
+    error: "error",
+};
+/** For each container id, the inner element ids whose content should be
+ *  diffed via partial_update_element instead of replacing the container. */
+const PANEL_INNERS = {
+    status_row: ["status"],
+    reasoning_panel: ["reasoning"],
+    tools_panel: ["tools", "output"],
+    diff_panel: ["diff"],
+};
+function isCollapsiblePanelId(id) {
+    return id === "reasoning_panel" || id === "tools_panel" || id === "diff_panel";
+}
+export function renderStatusMarkdown(state) {
+    const head = `${STATUS_EMOJI[state.status]} **${STATUS_LABELS[state.status]}**`;
+    const meta = [];
+    if (state.runtime) {
+        meta.push(state.runtime);
+    }
+    if (state.model) {
+        meta.push(state.model);
+    }
+    if (state.effort) {
+        meta.push(state.effort);
+    }
+    if (state.resumeShortId) {
+        // The conversation's stable `/resume <id>` short id — shown so that what's
+        // on the card is exactly what the user types to jump back here. (Derived
+        // from the conversation key, so it survives restarts and session
+        // rotations, unlike the volatile codex thread id.) Kept muted grey so it
+        // doesn't draw the user's eye.
+        meta.push(state.resumeShortId);
+    }
+    if (meta.length === 0) {
+        return head;
+    }
+    return `${head}  <font color='grey'>· ${meta.join(" · ")}</font>`;
+}
+export function renderPlanMarkdown(plan) {
+    if (!plan || plan.length === 0) {
+        return "";
+    }
+    return plan
+        .map((step) => {
+        const icon = step.status === "completed"
+            ? "✅"
+            : step.status === "inProgress"
+                ? "⏳"
+                : "⏸";
+        return `${icon} ${step.step}`;
+    })
+        .join("\n");
+}
+export function renderReasoningMarkdown(summary) {
+    return summary.trim();
+}
+export function renderToolsMarkdown(toolCalls) {
+    if (toolCalls.length === 0) {
+        return "";
+    }
+    return toolCalls
+        .map((tool) => {
+        const icon = tool.status === "completed"
+            ? "✅"
+            : tool.status === "failed"
+                ? "❌"
+                : tool.status === "declined"
+                    ? "🚫"
+                    : "⏳";
+        const head = `${icon} \`${tool.kind}\` ${truncate(tool.label, 200)}`;
+        return head;
+    })
+        .join("\n");
+}
+export function renderOutputMarkdown(toolCalls) {
+    const tail = [...toolCalls]
+        .reverse()
+        .find((tool) => tool.output && tool.output.length > 0);
+    if (!tail || !tail.output) {
+        return "";
+    }
+    const fence = "```";
+    return `${fence}\n${tail.output}\n${fence}`;
+}
+export function renderDiffMarkdown(turnDiff) {
+    if (!turnDiff || !turnDiff.trim()) {
+        return "";
+    }
+    const fence = "```";
+    return `${fence}diff\n${turnDiff}\n${fence}`;
+}
+export function renderMessageMarkdown(state) {
+    const content = state.finalAnswer ?? state.agentMessage;
+    return content.trim() ? content : "";
+}
+export function renderErrorMarkdown(state) {
+    if (!state.errorMessage) {
+        return "";
+    }
+    return `> ${state.errorMessage}`;
+}
+function renderElement(elementId, state) {
+    switch (elementId) {
+        case "status":
+            return renderStatusMarkdown(state);
+        case "plan":
+            return renderPlanMarkdown(state.plan);
+        case "reasoning":
+            return renderReasoningMarkdown(state.reasoningSummary);
+        case "tools":
+            return renderToolsMarkdown(state.toolCalls);
+        case "output":
+            return renderOutputMarkdown(state.toolCalls);
+        case "diff":
+            return renderDiffMarkdown(state.turnDiff);
+        case "message":
+            return renderMessageMarkdown(state);
+        case "error":
+            return renderErrorMarkdown(state);
+        case "status_row":
+        case "stop_column":
+        case "reasoning_panel":
+        case "tools_panel":
+        case "diff_panel":
+            // Container elements don't have a flat markdown content — diff
+            // iterates their inner ids instead. Returning "" here is a safety
+            // net for callers that go through the generic renderer.
+            return "";
+    }
+}
+function shouldMountElement(elementId, state) {
+    switch (elementId) {
+        case "status_row":
+            return true;
+        case "message": {
+            const content = state.finalAnswer ?? state.agentMessage;
+            return content.trim().length > 0;
+        }
+        case "plan":
+            return Boolean(state.plan && state.plan.length > 0);
+        case "reasoning_panel":
+            return state.reasoningSummary.trim().length > 0;
+        case "tools_panel":
+            return state.toolCalls.length > 0;
+        case "diff_panel":
+            return Boolean(state.turnDiff && state.turnDiff.trim().length > 0);
+        case "error":
+            return Boolean(state.errorMessage);
+        // Inner ids are mounted as part of their parent container, not at the
+        // body level — diffCardActions treats them via partial_update_element.
+        case "status":
+        case "stop_column":
+        case "reasoning":
+        case "tools":
+        case "output":
+        case "diff":
+            return false;
+    }
+}
+/** Body-level order. Inner markdowns (status/reasoning/tools/output) are
+ *  not here because they only ever appear inside their parent container. */
+const ELEMENT_ORDER = [
+    ELEMENT_IDS.status_row,
+    ELEMENT_IDS.plan,
+    ELEMENT_IDS.reasoning_panel,
+    ELEMENT_IDS.tools_panel,
+    ELEMENT_IDS.diff_panel,
+    ELEMENT_IDS.message,
+    ELEMENT_IDS.error,
+];
+function findInsertTarget(elementId, mounted) {
+    if (elementId === ELEMENT_IDS.error) {
+        return { type: "append" };
+    }
+    const index = ELEMENT_ORDER.indexOf(elementId);
+    for (let i = index + 1; i < ELEMENT_ORDER.length; i++) {
+        const candidate = ELEMENT_ORDER[i];
+        if (mounted.has(candidate)) {
+            return { type: "insert_before", target_element_id: candidate };
+        }
+    }
+    return { type: "append" };
+}
+function buildPanelElement(id, state) {
+    if (id === "diff_panel") {
+        return {
+            tag: "collapsible_panel",
+            element_id: "diff_panel",
+            // Diffs can be long; start collapsed so they don't dominate the card.
+            expanded: false,
+            header: {
+                title: { tag: "plain_text", content: "📝 代码改动" },
+                vertical_align: "center",
+                icon: { tag: "standard_icon", token: "down-small-ccm_outlined" },
+            },
+            elements: [
+                {
+                    tag: "markdown",
+                    element_id: "diff",
+                    content: renderDiffMarkdown(state.turnDiff),
+                },
+            ],
+        };
+    }
+    if (id === "reasoning_panel") {
+        return {
+            tag: "collapsible_panel",
+            element_id: "reasoning_panel",
+            expanded: true,
+            header: {
+                title: { tag: "plain_text", content: "🧠 思考过程" },
+                vertical_align: "center",
+                icon: { tag: "standard_icon", token: "down-small-ccm_outlined" },
+            },
+            elements: [
+                {
+                    tag: "markdown",
+                    element_id: "reasoning",
+                    content: renderReasoningMarkdown(state.reasoningSummary),
+                },
+            ],
+        };
+    }
+    return {
+        tag: "collapsible_panel",
+        element_id: "tools_panel",
+        expanded: true,
+        header: {
+            title: { tag: "plain_text", content: "🔧 工具调用" },
+            vertical_align: "center",
+            icon: { tag: "standard_icon", token: "down-small-ccm_outlined" },
+        },
+        // Both inner markdowns are mounted up-front so subsequent updates can
+        // target them via partial_update_element by element_id. Empty content
+        // is fine — markdown elements with empty content render as nothing.
+        elements: [
+            {
+                tag: "markdown",
+                element_id: "tools",
+                content: renderToolsMarkdown(state.toolCalls),
+            },
+            {
+                tag: "markdown",
+                element_id: "output",
+                content: renderOutputMarkdown(state.toolCalls),
+            },
+        ],
+    };
+}
+function buildStatusRowElement(state, stopButton) {
+    const columns = [
+        {
+            tag: "column",
+            width: "weighted",
+            weight: 1,
+            vertical_align: "center",
+            elements: [
+                {
+                    tag: "markdown",
+                    element_id: "status",
+                    content: renderStatusMarkdown(state),
+                },
+            ],
+        },
+    ];
+    if (stopButton) {
+        columns.push({
+            tag: "column",
+            element_id: "stop_column",
+            width: "auto",
+            vertical_align: "center",
+            elements: [buildStopButtonElement(stopButton)],
+        });
+    }
+    return {
+        tag: "column_set",
+        element_id: "status_row",
+        flex_mode: "none",
+        horizontal_align: "left",
+        columns,
+    };
+}
+function buildBodyElement(id, state, ctx = {}) {
+    if (id === "status_row") {
+        return buildStatusRowElement(state, ctx.stopButton);
+    }
+    if (isCollapsiblePanelId(id)) {
+        return buildPanelElement(id, state);
+    }
+    return {
+        tag: "markdown",
+        element_id: id,
+        content: renderElement(id, state),
+    };
+}
+function buildStopButtonElement(opts) {
+    return {
+        tag: "button",
+        type: "text",
+        size: "small",
+        icon: {
+            tag: "standard_icon",
+            token: "stop_outlined",
+        },
+        hover_tips: {
+            tag: "plain_text",
+            content: opts.hoverTip ?? "停止",
+        },
+        behaviors: [
+            {
+                type: "callback",
+                value: { kind: "stop_turn", sessionKey: opts.sessionKey },
+            },
+        ],
+    };
+}
+export function createInitialCardJson(state, opts = {}) {
+    const elements = [];
+    const mounted = new Set();
+    for (const id of ELEMENT_ORDER) {
+        if (!shouldMountElement(id, state)) {
+            continue;
+        }
+        elements.push(buildBodyElement(id, state, { stopButton: opts.stopButton }));
+        mounted.add(id);
+    }
+    const card = {
+        schema: "2.0",
+        config: {
+            streaming_mode: true,
+            summary: { content: "" },
+            streaming_config: {
+                print_frequency_ms: { default: 70 },
+                print_step: { default: 1 },
+                print_strategy: "fast",
+            },
+        },
+        body: { elements },
+    };
+    return { cardJson: JSON.stringify(card), mounted };
+}
+export function buildTerminalSettingsAction() {
+    return {
+        action: "partial_update_setting",
+        params: {
+            settings: {
+                config: { streaming_mode: false },
+            },
+        },
+    };
+}
+export function buildStopColumnDeleteAction() {
+    return {
+        action: "delete_elements",
+        params: { element_ids: [ELEMENT_IDS.stop_column] },
+    };
+}
+export function diffCardActions(prev, next, mounted) {
+    const actions = [];
+    const nextMounted = new Set(mounted);
+    for (const id of ELEMENT_ORDER) {
+        const wantMounted = shouldMountElement(id, next);
+        if (!nextMounted.has(id)) {
+            if (!wantMounted) {
+                continue;
+            }
+            const target = findInsertTarget(id, nextMounted);
+            actions.push({
+                action: "add_elements",
+                params: {
+                    type: target.type,
+                    ...(target.target_element_id
+                        ? { target_element_id: target.target_element_id }
+                        : {}),
+                    elements: [buildBodyElement(id, next)],
+                },
+            });
+            nextMounted.add(id);
+            continue;
+        }
+        // Already mounted. Container elements (status_row, panels) diff their
+        // inner ids individually so we never replace the container itself
+        // (which would either reset expand/collapse state or wipe the embedded
+        // stop button). Flat markdowns: diff content as before.
+        const innerIds = PANEL_INNERS[id];
+        if (innerIds) {
+            for (const innerId of innerIds) {
+                const prevContent = renderElement(innerId, prev);
+                const nextContent = renderElement(innerId, next);
+                if (prevContent !== nextContent) {
+                    actions.push({
+                        action: "partial_update_element",
+                        params: {
+                            element_id: innerId,
+                            partial_element: { content: nextContent },
+                        },
+                    });
+                }
+            }
+            continue;
+        }
+        const prevContent = renderElement(id, prev);
+        const nextContent = renderElement(id, next);
+        if (prevContent !== nextContent) {
+            actions.push({
+                action: "partial_update_element",
+                params: { element_id: id, partial_element: { content: nextContent } },
+            });
+        }
+    }
+    return { actions, mounted: nextMounted };
+}
+function truncate(value, max) {
+    if (value.length <= max) {
+        return value;
+    }
+    return `${value.slice(0, max - 1)}…`;
+}
+export class LarkTurnCardController {
+    sender;
+    session;
+    throttleMs;
+    logger;
+    stopButton;
+    state;
+    cardId = null;
+    sequence = 0;
+    flushTimer = null;
+    flushChain = Promise.resolve();
+    lastFlushedState;
+    mounted = new Set();
+    dirty = false;
+    closed = false;
+    terminal = false;
+    stopButtonMounted = false;
+    constructor({ sender, session, initialState, throttleMs = 250, logger, stopButton, }) {
+        this.sender = sender;
+        this.session = session;
+        this.state = initialState;
+        this.lastFlushedState = initialState;
+        this.throttleMs = throttleMs;
+        this.logger = logger;
+        this.stopButton = stopButton ?? null;
+    }
+    async start() {
+        if (!this.session.messageId) {
+            // No inbound message to quote — fall back to a standalone send.
+            return this.startStandalone();
+        }
+        const { cardJson, mounted } = createInitialCardJson(this.state, {
+            stopButton: this.stopButton ?? undefined,
+        });
+        this.mounted = mounted;
+        this.stopButtonMounted = Boolean(this.stopButton);
+        const { cardId } = await this.sender.createCard({ cardJson });
+        this.cardId = cardId;
+        const uuid = randomUUID();
+        // Always reply to the user's message so the card is quoted under their @
+        // (reply in thread only when the message is itself in a topic thread).
+        await this.sender.replyInteractive({
+            messageId: this.session.messageId,
+            cardId,
+            uuid,
+            replyInThread: Boolean(this.session.threadId),
+        });
+        this.lastFlushedState = this.state;
+    }
+    /**
+     * Post the card as a standalone chat message instead of a quote-reply. Used
+     * to mirror a CLI-driven turn, where there is no inbound Feishu message to
+     * reply to. `sendInteractive` targets the chat (no thread-targeting param),
+     * so for topic-thread conversations the card lands at chat level.
+     */
+    async startStandalone() {
+        const { cardJson, mounted } = createInitialCardJson(this.state, {
+            stopButton: this.stopButton ?? undefined,
+        });
+        this.mounted = mounted;
+        this.stopButtonMounted = Boolean(this.stopButton);
+        const { cardId } = await this.sender.createCard({ cardJson });
+        this.cardId = cardId;
+        await this.sender.sendInteractive({
+            chatId: this.session.chatId,
+            cardId,
+            uuid: randomUUID(),
+        });
+        this.lastFlushedState = this.state;
+    }
+    async ingestEvent(event) {
+        if (this.closed || !this.cardId) {
+            return;
+        }
+        this.state = applyEventToCardState(this.state, event);
+        this.scheduleFlush();
+    }
+    async finalize(opts) {
+        if (this.closed) {
+            return;
+        }
+        this.state = {
+            ...this.state,
+            status: opts.status,
+            finalAnswer: opts.finalAnswer ?? this.state.finalAnswer ?? this.state.agentMessage ?? null,
+            errorMessage: opts.error ?? this.state.errorMessage,
+        };
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        this.terminal = true;
+        this.dirty = true;
+        await this.flush();
+        this.closed = true;
+    }
+    getState() {
+        return this.state;
+    }
+    scheduleFlush() {
+        this.dirty = true;
+        if (this.flushTimer) {
+            return;
+        }
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            void this.flush();
+        }, this.throttleMs);
+    }
+    flush() {
+        const cardId = this.cardId;
+        if (!cardId || !this.dirty) {
+            return this.flushChain;
+        }
+        const nextState = this.state;
+        const { actions, mounted } = diffCardActions(this.lastFlushedState, nextState, this.mounted);
+        if (this.terminal) {
+            if (this.stopButtonMounted) {
+                actions.push(buildStopColumnDeleteAction());
+                this.stopButtonMounted = false;
+            }
+            actions.push(buildTerminalSettingsAction());
+        }
+        this.dirty = false;
+        if (actions.length === 0) {
+            return this.flushChain;
+        }
+        const sequence = ++this.sequence;
+        this.lastFlushedState = nextState;
+        this.mounted = mounted;
+        this.flushChain = this.flushChain
+            .catch(() => undefined)
+            .then(async () => {
+            try {
+                await this.sender.batchUpdateCard({
+                    cardId,
+                    sequence,
+                    actions: JSON.stringify(actions),
+                    uuid: randomUUID(),
+                });
+            }
+            catch (error) {
+                this.logger?.log({
+                    event: "card.batch_update_failed",
+                    cardId,
+                    sequence,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
+        return this.flushChain;
+    }
+}
+const TOOL_ICON = {
+    running: "⏳",
+    completed: "✅",
+    failed: "❌",
+};
+function itemContainerId(item) {
+    return item.elId;
+}
+/** The inner element ids + content for an item (what the diff updates in place). */
+function itemInners(item) {
+    const container = itemContainerId(item);
+    switch (item.kind) {
+        case "message":
+            return [{ id: container, content: item.text }];
+        case "error":
+            return [{ id: container, content: item.message ? `> ${item.message}` : "" }];
+        case "reasoning":
+            return [{ id: `${container}_b`, content: item.summary.trim() }];
+        case "tool": {
+            const head = `${TOOL_ICON[item.status]} \`${item.name || "tool"}\`${item.label ? ` ${truncate(item.label, 200)}` : ""}`;
+            const out = item.output ? `\`\`\`\n${item.output}\n\`\`\`` : "";
+            return [
+                { id: `${container}_h`, content: head },
+                { id: `${container}_o`, content: out },
+            ];
+        }
+    }
+}
+function renderSessionStatus(status, meta, note) {
+    const head = `${STATUS_EMOJI[status]} **${STATUS_LABELS[status]}**`;
+    // A transient note (e.g. an API-retry banner) is shown in amber so a stalled
+    // turn reads as "still working / retrying" rather than frozen.
+    const noteSuffix = note ? `  <font color='orange'>· ${note}</font>` : "";
+    const parts = [meta.runtime, meta.model, meta.effort, meta.resumeShortId].filter((p) => Boolean(p));
+    const metaSuffix = parts.length ? `  <font color='grey'>· ${parts.join(" · ")}</font>` : "";
+    return `${head}${noteSuffix}${metaSuffix}`;
+}
+function buildSessionStatusRow(statusContent, stopButton) {
+    const columns = [
+        {
+            tag: "column",
+            width: "weighted",
+            weight: 1,
+            vertical_align: "center",
+            elements: [{ tag: "markdown", element_id: ELEMENT_IDS.status, content: statusContent }],
+        },
+    ];
+    if (stopButton) {
+        columns.push({
+            tag: "column",
+            element_id: ELEMENT_IDS.stop_column,
+            width: "auto",
+            vertical_align: "center",
+            elements: [buildStopButtonElement(stopButton)],
+        });
+    }
+    return {
+        tag: "column_set",
+        element_id: ELEMENT_IDS.status_row,
+        flex_mode: "none",
+        horizontal_align: "left",
+        columns,
+    };
+}
+function buildItemBodyElement(item) {
+    const container = itemContainerId(item);
+    const inners = itemInners(item);
+    if (item.kind === "message" || item.kind === "error") {
+        return { tag: "markdown", element_id: container, content: inners[0].content };
+    }
+    const title = item.kind === "reasoning" ? "🧠 思考过程" : "🔧 工具调用";
+    return {
+        tag: "collapsible_panel",
+        element_id: container,
+        expanded: true,
+        header: {
+            title: { tag: "plain_text", content: title },
+            vertical_align: "center",
+            icon: { tag: "standard_icon", token: "down-small-ccm_outlined" },
+        },
+        elements: inners.map((inner) => ({ tag: "markdown", element_id: inner.id, content: inner.content })),
+    };
+}
+function contentText(parts) {
+    return parts.map((p) => p.text).join("");
+}
+/** A compact label for a tool head, derived from its JSON arguments. */
+function toolLabel(argumentsJson) {
+    let args = {};
+    try {
+        const parsed = JSON.parse(argumentsJson);
+        if (parsed && typeof parsed === "object")
+            args = parsed;
+    }
+    catch {
+        return "";
+    }
+    const pick = (key) => {
+        const value = args[key];
+        return typeof value === "string" && value.trim() ? value : undefined;
+    };
+    return (pick("command") ??
+        pick("query") ??
+        pick("file_path") ??
+        pick("path") ??
+        pick("pattern") ??
+        pick("url") ??
+        pick("prompt") ??
+        "");
+}
+const SESSION_CARD_CONFIG = {
+    schema: "2.0",
+    config: {
+        streaming_mode: true,
+        summary: { content: "" },
+        streaming_config: {
+            print_frequency_ms: { default: 70 },
+            print_step: { default: 1 },
+            print_strategy: "fast",
+        },
+    },
+};
+/**
+ * Renders ONE response as a streaming Feishu card: a status row plus an ordered
+ * list of item blocks appended as they arrive. Keeps the legacy controller's
+ * throttle / sequence / serialized-flush machinery; only the state model + diff
+ * differ (an append-mostly ordered list rather than fixed panels).
+ */
+export class LarkResponseCardController {
+    sender;
+    chatId;
+    meta;
+    throttleMs;
+    logger;
+    stopButton;
+    cardId = null;
+    sequence = 0;
+    flushTimer = null;
+    flushChain = Promise.resolve();
+    dirty = false;
+    terminal = false;
+    closed = false;
+    stopButtonMounted = false;
+    status = "running";
+    /** Transient status banner (e.g. API-retry); cleared once progress resumes. */
+    statusNote = null;
+    elIdSeq = 0;
+    items = [];
+    byItemId = new Map();
+    byCallId = new Map();
+    mounted = new Set();
+    lastRendered = new Map();
+    constructor(opts) {
+        this.sender = opts.sender;
+        this.chatId = opts.chatId;
+        this.meta = opts.meta;
+        this.throttleMs = opts.throttleMs ?? 250;
+        this.logger = opts.logger;
+        this.stopButton = opts.stopButton ?? null;
+    }
+    /** Create the card (status row only) and reply/send it. Returns the posted
+     *  message id so the orchestrator can chain the next response's card under it. */
+    async start(replyTo) {
+        const statusRow = buildSessionStatusRow(renderSessionStatus("running", this.meta), this.stopButton ?? undefined);
+        const card = { ...SESSION_CARD_CONFIG, body: { elements: [statusRow] } };
+        const { cardId } = await this.sender.createCard({ cardJson: JSON.stringify(card) });
+        this.cardId = cardId;
+        this.mounted.add(ELEMENT_IDS.status_row);
+        this.stopButtonMounted = Boolean(this.stopButton);
+        this.lastRendered.set(ELEMENT_IDS.status, renderSessionStatus("running", this.meta));
+        const uuid = randomUUID();
+        if (replyTo.messageId) {
+            const { messageId } = await this.sender.replyInteractive({
+                messageId: replyTo.messageId,
+                cardId,
+                uuid,
+                replyInThread: replyTo.replyInThread,
+            });
+            return { messageId };
+        }
+        const { messageId } = await this.sender.sendInteractive({ chatId: this.chatId, cardId, uuid });
+        return { messageId };
+    }
+    applyEvent(event) {
+        if (this.closed || !this.cardId) {
+            return;
+        }
+        switch (event.type) {
+            case "response.output_text.delta": {
+                this.clearStatusNote();
+                const item = this.ensureMessage(event.itemId);
+                item.text = tailBytes(item.text + event.delta, AGENT_MESSAGE_MAX_BYTES);
+                this.scheduleFlush();
+                break;
+            }
+            case "response.reasoning_summary_text.delta": {
+                this.clearStatusNote();
+                const item = this.ensureReasoning(event.itemId);
+                item.summary = tailBytes(item.summary + event.delta, REASONING_MAX_BYTES);
+                this.scheduleFlush();
+                break;
+            }
+            case "response.output_item.done": {
+                this.clearStatusNote();
+                this.applyItem(event.item);
+                this.scheduleFlush();
+                break;
+            }
+            default:
+                // lifecycle events are handled by the orchestrator (start / finalize)
+                break;
+        }
+    }
+    /** Set/replace the transient status banner (amber note in the status row). */
+    setStatusNote(note) {
+        if (this.closed || this.statusNote === note) {
+            return;
+        }
+        this.statusNote = note;
+        this.scheduleFlush();
+    }
+    clearStatusNote() {
+        if (this.statusNote !== null) {
+            this.statusNote = null;
+        }
+    }
+    async finalize(status) {
+        if (this.closed) {
+            return;
+        }
+        this.status = status;
+        this.statusNote = null; // terminal card: drop any pending retry banner
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        this.terminal = true;
+        this.dirty = true;
+        await this.flush();
+        this.closed = true;
+    }
+    applyItem(item) {
+        switch (item.type) {
+            case "message": {
+                this.ensureMessage(item.id).text = tailBytes(contentText(item.data.content), AGENT_MESSAGE_MAX_BYTES);
+                break;
+            }
+            case "reasoning": {
+                this.ensureReasoning(item.id).summary = tailBytes(contentText(item.data.summary), REASONING_MAX_BYTES);
+                break;
+            }
+            case "function_call": {
+                const tool = this.ensureTool(item.data.callId);
+                tool.name = item.data.name;
+                tool.label = toolLabel(item.data.arguments);
+                if (tool.status !== "completed" && tool.status !== "failed") {
+                    tool.status = "running";
+                }
+                break;
+            }
+            case "function_call_output": {
+                const tool = this.ensureTool(item.data.callId);
+                tool.status = item.data.status === "failed" ? "failed" : "completed";
+                tool.output = tailBytes(item.data.output, OUTPUT_MAX_BYTES);
+                break;
+            }
+            case "error": {
+                this.items.push({ kind: "error", id: item.id, elId: this.nextElId("e"), message: item.data.message });
+                break;
+            }
+        }
+    }
+    /** A fresh, Feishu-legal element_id (letter-prefixed, ≤ 20 chars). */
+    nextElId(prefix) {
+        return `${prefix}${(this.elIdSeq += 1)}`;
+    }
+    ensureMessage(id) {
+        const existing = this.byItemId.get(id);
+        if (existing && existing.kind === "message") {
+            return existing;
+        }
+        const item = { kind: "message", id, elId: this.nextElId("m"), text: "" };
+        this.byItemId.set(id, item);
+        this.items.push(item);
+        return item;
+    }
+    ensureReasoning(id) {
+        const existing = this.byItemId.get(id);
+        if (existing && existing.kind === "reasoning") {
+            return existing;
+        }
+        const item = { kind: "reasoning", id, elId: this.nextElId("r"), summary: "" };
+        this.byItemId.set(id, item);
+        this.items.push(item);
+        return item;
+    }
+    ensureTool(callId) {
+        const existing = this.byCallId.get(callId);
+        if (existing) {
+            return existing;
+        }
+        const item = {
+            kind: "tool",
+            id: callId,
+            elId: this.nextElId("t"),
+            callId,
+            name: "",
+            label: "",
+            status: "running",
+            output: "",
+        };
+        this.byCallId.set(callId, item);
+        this.items.push(item);
+        return item;
+    }
+    scheduleFlush() {
+        this.dirty = true;
+        if (this.flushTimer) {
+            return;
+        }
+        this.flushTimer = setTimeout(() => {
+            this.flushTimer = null;
+            void this.flush();
+        }, this.throttleMs);
+    }
+    flush() {
+        const cardId = this.cardId;
+        if (!cardId || !this.dirty) {
+            return this.flushChain;
+        }
+        const actions = [];
+        const statusContent = renderSessionStatus(this.status, this.meta, this.statusNote);
+        if (this.lastRendered.get(ELEMENT_IDS.status) !== statusContent) {
+            actions.push({
+                action: "partial_update_element",
+                params: { element_id: ELEMENT_IDS.status, partial_element: { content: statusContent } },
+            });
+            this.lastRendered.set(ELEMENT_IDS.status, statusContent);
+        }
+        for (const item of this.items) {
+            const container = itemContainerId(item);
+            const inners = itemInners(item);
+            if (!this.mounted.has(container)) {
+                actions.push({ action: "add_elements", params: { type: "append", elements: [buildItemBodyElement(item)] } });
+                this.mounted.add(container);
+                for (const inner of inners) {
+                    this.lastRendered.set(inner.id, inner.content);
+                }
+                continue;
+            }
+            for (const inner of inners) {
+                if (this.lastRendered.get(inner.id) !== inner.content) {
+                    actions.push({
+                        action: "partial_update_element",
+                        params: { element_id: inner.id, partial_element: { content: inner.content } },
+                    });
+                    this.lastRendered.set(inner.id, inner.content);
+                }
+            }
+        }
+        if (this.terminal) {
+            if (this.stopButtonMounted) {
+                actions.push({ action: "delete_elements", params: { element_ids: [ELEMENT_IDS.stop_column] } });
+                this.stopButtonMounted = false;
+            }
+            actions.push({ action: "partial_update_setting", params: { settings: { config: { streaming_mode: false } } } });
+        }
+        this.dirty = false;
+        if (actions.length === 0) {
+            return this.flushChain;
+        }
+        const sequence = ++this.sequence;
+        this.flushChain = this.flushChain
+            .catch(() => undefined)
+            .then(async () => {
+            try {
+                await this.sender.batchUpdateCard({
+                    cardId,
+                    sequence,
+                    actions: JSON.stringify(actions),
+                    uuid: randomUUID(),
+                });
+            }
+            catch (error) {
+                this.logger?.log({
+                    event: "card.batch_update_failed",
+                    cardId,
+                    sequence,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
+        return this.flushChain;
+    }
+}
+/**
+ * Orchestrates a turn's {@link SessionEvent} stream into a sequence of per-
+ * response cards. Each `response.created` opens a new card (replied under the
+ * previous one, forming a thread); item/lifecycle events route by `responseId`.
+ */
+export class LarkSessionCardController {
+    opts;
+    cards = new Map();
+    current = null;
+    anchorMessageId;
+    replyInThread;
+    notedRuntimeSession = false;
+    started = false;
+    /** Accumulated assistant text, used only as a chat fallback if no card opened. */
+    fallback = "";
+    constructor(opts) {
+        this.opts = opts;
+        this.anchorMessageId = opts.session.messageId;
+        this.replyInThread = Boolean(opts.session.threadId);
+    }
+    /** Whether at least one response card was successfully posted. */
+    get cardStarted() {
+        return this.started;
+    }
+    /** The assistant text (for a plain-text reply when no card could be shown). */
+    get fallbackText() {
+        return this.fallback;
+    }
+    async ingest(event) {
+        switch (event.type) {
+            case "response.created": {
+                const card = new LarkResponseCardController({
+                    sender: this.opts.sender,
+                    chatId: this.opts.session.chatId,
+                    meta: this.opts.meta,
+                    throttleMs: this.opts.throttleMs,
+                    logger: this.opts.logger,
+                    stopButton: this.opts.stopButton,
+                });
+                this.cards.set(event.responseId, card);
+                this.current = card;
+                try {
+                    const { messageId } = await card.start({
+                        messageId: this.anchorMessageId,
+                        replyInThread: this.replyInThread,
+                    });
+                    if (messageId) {
+                        this.anchorMessageId = messageId;
+                    }
+                    this.started = true;
+                }
+                catch (error) {
+                    // A failed card post must not abandon the run: keep draining the
+                    // stream (so the runtime turn completes) and fall back to a text reply.
+                    this.current = null;
+                    this.opts.logger?.log({
+                        event: "card.start_failed",
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+                break;
+            }
+            case "session.status": {
+                if (event.runtimeSessionId && !this.notedRuntimeSession) {
+                    this.notedRuntimeSession = true;
+                    this.opts.onRuntimeSession?.(event.runtimeSessionId);
+                }
+                if (event.note !== undefined) {
+                    this.current?.setStatusNote(event.note);
+                }
+                break;
+            }
+            case "response.output_item.done":
+                if (event.item.type === "message") {
+                    this.fallback = contentText(event.item.data.content);
+                }
+                (this.cards.get(event.responseId) ?? this.current)?.applyEvent(event);
+                break;
+            case "response.output_text.delta":
+            case "response.reasoning_summary_text.delta":
+                (this.cards.get(event.responseId) ?? this.current)?.applyEvent(event);
+                break;
+            case "response.completed":
+                await (this.cards.get(event.responseId) ?? this.current)?.finalize("completed");
+                break;
+            case "response.failed":
+                await (this.cards.get(event.responseId) ?? this.current)?.finalize(event.error.code === "codex_cancelled" ? "cancelled" : "failed");
+                break;
+            case "session.input.consumed":
+                break;
+        }
+    }
+    /** Finalize any still-open cards (safety net on stream end / throw). */
+    async finalizeAll(status) {
+        for (const card of this.cards.values()) {
+            await card.finalize(status);
+        }
+    }
+}