@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/channel-telegram/dist/telegram-session-watcher.js

@@ -0,0 +1,184 @@
+import { createChannelStreamProjector } from "@codebridge/router";
+import { CoalescingMessageWriter } from "./coalescing-message-writer.js";
+import { chunkTelegramText } from "./telegram-api.js";
+class TelegramRunRenderer {
+    api;
+    chatId;
+    topicId;
+    pendingMessageId;
+    projector;
+    liveWriter;
+    constructor(api, chatId, topicId, pendingMessageId, showThinking, onLog) {
+        this.api = api;
+        this.chatId = chatId;
+        this.topicId = topicId;
+        this.pendingMessageId = pendingMessageId;
+        this.projector = createChannelStreamProjector({ showThinking });
+        this.liveWriter = new CoalescingMessageWriter(async (text) => {
+            await this.api.editMessage(this.chatId, this.pendingMessageId, text);
+        }, (error) => onLog(`telegram 实时消息更新失败，将由终态覆盖：${error instanceof Error ? error.message : String(error)}`));
+    }
+    onAgentEvent(event) {
+        this.projector.apply(event);
+    }
+    async onPermissionRequest(title) {
+        await this.api.sendMessage(this.chatId, `🔐 Agent 请求权限：${title}\n回复 /approve 允许，/deny 拒绝。`, this.topicId);
+    }
+    appendError(message) {
+        this.projector.apply({ type: "error", message });
+    }
+    async finalize() {
+        await this.liveWriter.flush();
+        this.liveWriter.close();
+        const agent = this.projector.snapshot();
+        const chunks = chunkTelegramText(agent.finalText);
+        try {
+            await this.api.editMessage(this.chatId, this.pendingMessageId, chunks[0]);
+        }
+        catch {
+            await this.api.sendMessage(this.chatId, chunks[0], this.topicId);
+        }
+        for (const chunk of chunks.slice(1)) {
+            await this.api.sendMessage(this.chatId, chunk, this.topicId);
+        }
+    }
+}
+/** 每 Session 一个持久 events 订阅，单订阅路由 Turn / Run / Delivery。 */
+export class TelegramSessionWatcher {
+    api;
+    ingress;
+    sessionId;
+    instanceId;
+    onLog;
+    abortController = new AbortController();
+    afterSequence = 0;
+    started = false;
+    runs = new Map();
+    pendingTurns = new Map();
+    deliveries = new Map();
+    fatalAgentErrorRuns = new Set();
+    constructor(api, ingress, sessionId, instanceId, onLog) {
+        this.api = api;
+        this.ingress = ingress;
+        this.sessionId = sessionId;
+        this.instanceId = instanceId;
+        this.onLog = onLog;
+    }
+    start(afterSequence) {
+        if (this.started)
+            return;
+        this.started = true;
+        this.afterSequence = afterSequence;
+        void this.run().catch((err) => {
+            this.onLog(`telegram watcher 退出: ${err instanceof Error ? err.message : String(err)}`);
+        });
+    }
+    registerPendingTurn(turnId, turn) {
+        this.pendingTurns.set(turnId, turn);
+    }
+    /** 恢复 delivering：用已有消息 id 重放事件累积最终回答。 */
+    resumeRun(runId, surfaceMessageId, turnId, owner, showThinking, chatId, topicId) {
+        const pendingMessageId = Number(surfaceMessageId);
+        if (!Number.isSafeInteger(pendingMessageId))
+            return;
+        const renderer = new TelegramRunRenderer(this.api, chatId, topicId, pendingMessageId, showThinking, this.onLog);
+        this.runs.set(runId, renderer);
+        this.deliveries.set(runId, { turnId, owner });
+    }
+    async openRun(runId, turn) {
+        if (this.runs.has(runId))
+            return;
+        const owner = `telegram:${this.instanceId}:${runId}`;
+        const claimed = await this.ingress.claimDelivery(turn.turnId, owner);
+        if (!claimed)
+            return;
+        const pending = await this.api.sendMessage(turn.chatId, "⏳ Agent 正在处理…", turn.topicId);
+        const renderer = new TelegramRunRenderer(this.api, turn.chatId, turn.topicId, pending.message_id, turn.showThinking, this.onLog);
+        this.runs.set(runId, renderer);
+        const acked = await this.ingress.ackDelivery(turn.turnId, owner, String(pending.message_id));
+        if (!acked) {
+            this.runs.delete(runId);
+            throw new Error(`ack delivery failed for run ${runId}`);
+        }
+        this.deliveries.set(runId, { turnId: turn.turnId, owner });
+    }
+    async run() {
+        while (!this.abortController.signal.aborted) {
+            try {
+                for await (const event of this.ingress.events(this.sessionId, {
+                    afterSequence: this.afterSequence,
+                    signal: this.abortController.signal,
+                })) {
+                    await this.handle(event);
+                    this.afterSequence = event.sequence;
+                }
+            }
+            catch (err) {
+                if (this.abortController.signal.aborted)
+                    return;
+                this.onLog(`telegram watcher 断线，按 sequence ${this.afterSequence} 重连：${err instanceof Error ? err.message : String(err)}`);
+                await new Promise((resolve) => setTimeout(resolve, 250));
+            }
+        }
+    }
+    async handle(event) {
+        if (event.type === "TURN_DISPATCHED" && event.runId && event.target) {
+            const turn = this.pendingTurns.get(event.target);
+            if (turn) {
+                await this.openRun(event.runId, turn);
+                this.pendingTurns.delete(event.target);
+            }
+            return;
+        }
+        if (event.type === "AGENT_EVENT" && event.runId) {
+            const renderer = this.runs.get(event.runId);
+            const agentEvent = event.payload.event;
+            if (agentEvent?.type === "error" && agentEvent.fatal && event.runId) {
+                this.fatalAgentErrorRuns.add(event.runId);
+            }
+            if (renderer && agentEvent && agentEvent.type !== "done") {
+                if (agentEvent.type === "permission_request") {
+                    await renderer.onPermissionRequest(agentEvent.title);
+                }
+                else {
+                    renderer.onAgentEvent(agentEvent);
+                }
+            }
+            return;
+        }
+        if (event.type === "STEP_FAILED" && event.runId) {
+            if (!this.fatalAgentErrorRuns.has(event.runId)) {
+                const message = String(event.payload?.error ?? "Step failed");
+                this.runs.get(event.runId)?.appendError(message);
+            }
+            return;
+        }
+        if ((event.type === "RUN_SUCCEEDED"
+            || event.type === "RUN_FAILED"
+            || event.type === "RUN_CANCELLED"
+            || event.type === "RUN_INTERRUPTED")
+            && event.runId) {
+            const renderer = this.runs.get(event.runId);
+            if (renderer) {
+                await renderer.finalize();
+                this.runs.delete(event.runId);
+            }
+            const delivery = this.deliveries.get(event.runId);
+            if (delivery) {
+                const completed = await this.ingress.completeDelivery(delivery.turnId, delivery.owner);
+                if (completed) {
+                    this.deliveries.delete(event.runId);
+                }
+                else {
+                    throw new Error(`complete delivery returned false for run ${event.runId}`);
+                }
+            }
+        }
+    }
+    abort() {
+        this.abortController.abort();
+        this.runs.clear();
+        this.pendingTurns.clear();
+    }
+}
+//# sourceMappingURL=telegram-session-watcher.js.map

package/node_modules/@codebridge/channel-telegram/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@codebridge/channel-telegram",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@codebridge/core": "0.1.0",
+    "@codebridge/router": "0.1.0"
+  }
+}