@botcord/daemon 0.2.35 → 0.2.37

package/dist/gateway/runtimes/openclaw-acp.js

@@ -127,6 +127,7 @@ export class OpenclawAcpAdapter {
         let assistantBytes = 0;
         let capped = false;
         let finalText = "";
+        const assistantTextFilter = createAssistantTextFilter();
         const emitBlock = (block) => {
             try {
                 opts.onBlock?.(block);
@@ -138,13 +139,9 @@ export class OpenclawAcpAdapter {
             }
         };
         const onNotification = (note) => {
-            seq += 1;
-            // Forward raw notification as a stream block for downstream visibility.
-            const kind = classifyAcpUpdate(note);
-            emitBlock({ raw: note, kind, seq });
             const update = note.params?.update;
             if (update?.sessionUpdate === "agent_message_chunk") {
-                const text = extractText(update.content);
+                const text = assistantTextFilter.push(extractText(update.content));
                 if (text && !capped) {
                     const bytes = Buffer.byteLength(text, "utf8");
                     if (assistantBytes + bytes > ASSISTANT_TEXT_CAP) {
@@ -155,7 +152,16 @@ export class OpenclawAcpAdapter {
                         assistantBytes += bytes;
                     }
                 }
+                if (!text)
+                    return;
+                seq += 1;
+                emitBlock({ raw: sanitizeAssistantChunk(note, text), kind: "assistant_text", seq });
+                return;
             }
+            seq += 1;
+            // Forward raw non-assistant notifications as stream blocks for downstream visibility.
+            const kind = classifyAcpUpdate(note);
+            emitBlock({ raw: note, kind, seq });
         };
         let abortListener;
         try {
@@ -248,7 +254,29 @@ export class OpenclawAcpAdapter {
             // OpenClaw's prompt response shape isn't strictly fixed; pull a final
             // text out of common locations and otherwise fall back to the streamed
             // chunks accumulated above.
-            finalText = pickFinalText(promptResult) ?? assistantText;
+            const tailText = assistantTextFilter.flush();
+            if (tailText && !capped) {
+                const bytes = Buffer.byteLength(tailText, "utf8");
+                if (assistantBytes + bytes <= ASSISTANT_TEXT_CAP) {
+                    assistantText += tailText;
+                    assistantBytes += bytes;
+                    seq += 1;
+                    emitBlock({
+                        raw: {
+                            method: "session/update",
+                            params: {
+                                sessionId: acpSessionId,
+                                update: { sessionUpdate: "agent_message_chunk", content: [{ type: "text", text: tailText }] },
+                            },
+                        },
+                        kind: "assistant_text",
+                        seq,
+                    });
+                }
+            }
+            const pickedText = normalizeAssistantText(pickFinalText(promptResult));
+            const streamedText = normalizeAssistantText(assistantText);
+            finalText = pickedText && !looksLikeReasoningLeak(pickedText) ? pickedText : streamedText;
             if (capped) {
                 log.warn("openclaw-acp.assistant-text-capped", { sessionId: acpSessionId });
             }
@@ -529,6 +557,9 @@ function extractText(content) {
     }
     if (typeof content === "object") {
         const c = content;
+        const type = typeof c.type === "string" ? c.type.toLowerCase() : "";
+        if (type === "thinking" || type === "reasoning" || type === "thought")
+            return "";
         if (typeof c.text === "string")
             return c.text;
         if (typeof c.content === "string")
@@ -538,16 +569,190 @@ function extractText(content) {
     }
     return "";
 }
+function sanitizeAssistantChunk(note, text) {
+    return {
+        ...note,
+        params: {
+            ...note.params,
+            update: {
+                ...note.params?.update,
+                content: [{ type: "text", text }],
+            },
+        },
+    };
+}
+function normalizeAssistantText(text) {
+    if (!text)
+        return "";
+    const finalMatch = text.match(/<final>([\s\S]*?)<\/final>/i);
+    const selected = finalMatch ? finalMatch[1] : text;
+    if (!finalMatch && selected.trimStart().toLowerCase().startsWith("<think")) {
+        return "";
+    }
+    return selected
+        .replace(/<think[^>]*>[\s\S]*?<\/think>/gi, "")
+        .replace(/<\/?final>/gi, "")
+        .trim();
+}
+function createAssistantTextFilter() {
+    let pending = "";
+    let inThink = false;
+    let inFinal = false;
+    let seenFinal = false;
+    let fallback = "";
+    const consume = (flush) => {
+        let out = "";
+        while (pending.length > 0) {
+            if (inThink) {
+                const close = pending.search(/<\/think>/i);
+                if (close === -1) {
+                    if (flush)
+                        pending = "";
+                    return out;
+                }
+                pending = pending.slice(close).replace(/^<\/think>/i, "");
+                inThink = false;
+                continue;
+            }
+            if (inFinal) {
+                const close = pending.search(/<\/final>/i);
+                if (close === -1) {
+                    out += pending;
+                    pending = "";
+                    return out;
+                }
+                out += pending.slice(0, close);
+                pending = pending.slice(close).replace(/^<\/final>/i, "");
+                inFinal = false;
+                continue;
+            }
+            const lt = pending.indexOf("<");
+            if (lt === -1) {
+                if (seenFinal) {
+                    out += pending;
+                }
+                else {
+                    fallback += pending;
+                }
+                pending = "";
+                return out;
+            }
+            if (lt > 0) {
+                if (seenFinal) {
+                    out += pending.slice(0, lt);
+                }
+                else {
+                    fallback += pending.slice(0, lt);
+                }
+                pending = pending.slice(lt);
+                continue;
+            }
+            const lower = pending.toLowerCase();
+            if (lower.startsWith("<think")) {
+                const end = pending.indexOf(">");
+                if (end === -1) {
+                    if (flush)
+                        pending = "";
+                    return out;
+                }
+                pending = pending.slice(end + 1);
+                inThink = true;
+                continue;
+            }
+            if (lower.startsWith("</think")) {
+                const end = pending.indexOf(">");
+                if (end === -1) {
+                    if (flush)
+                        pending = "";
+                    return out;
+                }
+                pending = pending.slice(end + 1);
+                continue;
+            }
+            if (lower.startsWith("<final")) {
+                const end = pending.indexOf(">");
+                if (end === -1) {
+                    if (flush)
+                        pending = "";
+                    return out;
+                }
+                pending = pending.slice(end + 1);
+                seenFinal = true;
+                fallback = "";
+                inFinal = true;
+                continue;
+            }
+            if (lower.startsWith("</final")) {
+                const end = pending.indexOf(">");
+                if (end === -1) {
+                    if (flush)
+                        pending = "";
+                    return out;
+                }
+                pending = pending.slice(end + 1);
+                inFinal = false;
+                continue;
+            }
+            const knownPrefixes = ["<think", "</think", "<final", "</final"];
+            if (!flush && knownPrefixes.some((prefix) => prefix.startsWith(lower))) {
+                return out;
+            }
+            out += "<";
+            pending = pending.slice(1);
+        }
+        if (flush && !seenFinal && fallback) {
+            const text = normalizeAssistantText(fallback);
+            fallback = "";
+            if (!looksLikeReasoningLeak(text))
+                return text;
+        }
+        return out;
+    };
+    return {
+        push(text) {
+            if (!text)
+                return "";
+            pending += text;
+            return consume(false);
+        },
+        flush() {
+            return consume(true);
+        },
+    };
+}
 function pickFinalText(result) {
     if (!result || typeof result !== "object")
         return undefined;
     const r = result;
+    if (Array.isArray(r.assistantTexts)) {
+        const text = r.assistantTexts.filter((x) => typeof x === "string").join("\n");
+        if (text.length > 0)
+            return text;
+    }
+    const contentText = extractText(r.content);
+    if (contentText.length > 0)
+        return contentText;
+    const outputText = extractText(r.output);
+    if (outputText.length > 0)
+        return outputText;
+    const responseText = extractText(r.response);
+    if (responseText.length > 0)
+        return responseText;
     if (typeof r.text === "string" && r.text.length > 0)
         return r.text;
     if (typeof r.message === "string" && r.message.length > 0)
         return r.message;
     return undefined;
 }
+function looksLikeReasoningLeak(text) {
+    const t = text.trim();
+    if (!t)
+        return false;
+    return (/^the user (said|asked|wants|is asking)\b/i.test(t) ||
+        /^i('|’)m .*\b(i('|’)ll|i will|need to|should|going to)\b/i.test(t) ||
+        /\bi('|’)ll respond\b/i.test(t) ||
+        /\bi need to\b/i.test(t));
+}
 function stringField(bag, key) {
     if (!bag)
         return undefined;

package/dist/gateway/types.d.ts

@@ -160,6 +160,16 @@ export interface ChannelStatusSnapshot {
     lastStartAt?: number;
     lastStopAt?: number;
     lastError?: string | null;
+    /** Third-party provider id when this channel is not the built-in BotCord. */
+    provider?: "wechat" | "telegram";
+    /** Last time the adapter polled the upstream provider (ms epoch). */
+    lastPollAt?: number;
+    /** Last time the adapter accepted an inbound message (ms epoch). */
+    lastInboundAt?: number;
+    /** Last time the adapter successfully sent a reply (ms epoch). */
+    lastSendAt?: number;
+    /** Whether the adapter currently holds a usable provider credential. */
+    authorized?: boolean;
 }
 /** Per-turn status snapshot describing a currently-executing runtime invocation. */
 export interface TurnStatusSnapshot {

package/dist/gateway-control.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Daemon-side handlers for the third-party gateway control frames defined
+ * in `packages/protocol-core/src/control-frame.ts`. Kept separate from
+ * `provision.ts` so the BotCord-agent provisioning logic and the third-
+ * party adapter management stay independently testable.
+ *
+ * All handlers take a {@link GatewayControlContext} so callers can swap the
+ * gateway, login-session store, fetch impl, and config I/O — `provision.ts`
+ * wires the production defaults.
+ */
+import type { ControlAck, GatewayLoginStartParams, GatewayLoginStatusParams, RemoveGatewayParams, TestGatewayParams, UpsertGatewayParams } from "@botcord/protocol-core";
+import type { Gateway } from "./gateway/index.js";
+import { type DaemonConfig } from "./config.js";
+import { LoginSessionStore } from "./gateway/channels/login-session.js";
+import { getBotQrcode, getQrcodeStatus } from "./gateway/channels/wechat-login.js";
+import type { FetchLike } from "./gateway/channels/http-types.js";
+type AckBody = Omit<ControlAck, "id">;
+export type { FetchLike };
+export interface GatewayControlContext {
+    gateway: Gateway;
+    /** Override `loadConfig`/`saveConfig`. Tests pass an in-memory pair. */
+    configIO?: {
+        load: () => DaemonConfig;
+        save: (cfg: DaemonConfig) => void;
+    };
+    /** Shared login-session store. Created lazily when not supplied. */
+    loginSessions?: LoginSessionStore;
+    /**
+     * Override the iLink HTTP client. Defaults to the helpers in
+     * `wechat-login.ts` (which themselves read `globalThis.fetch`).
+     */
+    wechatLoginClient?: {
+        getBotQrcode: typeof getBotQrcode;
+        getQrcodeStatus: typeof getQrcodeStatus;
+    };
+    /** Override the global fetch — used by `test_gateway` for Telegram getMe. */
+    fetchImpl?: FetchLike;
+}
+/**
+ * Build a closure carrying the production / test defaults. Returned object
+ * exposes one `handle*` method per frame type so `provision.ts` can route by
+ * `frame.type` without re-resolving dependencies on every dispatch.
+ */
+export declare function createGatewayControl(ctx: GatewayControlContext): {
+    handleList: () => AckBody;
+    handleUpsert: (params: UpsertGatewayParams) => Promise<AckBody>;
+    handleRemove: (params: RemoveGatewayParams) => Promise<AckBody>;
+    handleTest: (params: TestGatewayParams) => Promise<AckBody>;
+    handleLoginStart: (params: GatewayLoginStartParams) => Promise<AckBody>;
+    handleLoginStatus: (params: GatewayLoginStatusParams) => Promise<AckBody>;
+    /** Exposed for tests — direct access to the in-memory session map. */
+    _sessions: LoginSessionStore;
+};