@botcord/daemon 0.2.78 → 0.2.79

package/src/gateway/__tests__/deepseek-tui-adapter.test.ts

@@ -175,6 +175,183 @@ describe("DeepseekTuiAdapter", () => {
     }
   });
 
+  it("parses current DeepSeek item.delta agent_message events as assistant text", async () => {
+    const server = await startMockDeepseekServer({
+      events: [
+        {
+          event: "turn.started",
+          data: {
+            seq: 1,
+            thread_id: "thr_test",
+            turn_id: "turn_test",
+            event: "turn.started",
+            payload: { turn: { status: "in_progress" } },
+          },
+        },
+        {
+          event: "item.started",
+          data: {
+            seq: 2,
+            thread_id: "thr_test",
+            turn_id: "turn_test",
+            item_id: "item_msg",
+            event: "item.started",
+            payload: { item: { id: "item_msg", kind: "agent_message", status: "in_progress" } },
+          },
+        },
+        {
+          event: "item.delta",
+          data: {
+            seq: 3,
+            thread_id: "thr_test",
+            turn_id: "turn_test",
+            item_id: "item_msg",
+            event: "item.delta",
+            payload: { kind: "agent_message", delta: "hello " },
+          },
+        },
+        {
+          event: "item.delta",
+          data: {
+            seq: 4,
+            thread_id: "thr_test",
+            turn_id: "turn_test",
+            item_id: "item_msg",
+            event: "item.delta",
+            payload: { kind: "agent_message", delta: "deepseek" },
+          },
+        },
+        {
+          event: "turn.completed",
+          data: {
+            seq: 5,
+            thread_id: "thr_test",
+            turn_id: "turn_test",
+            event: "turn.completed",
+            payload: { turn: { status: "completed" } },
+          },
+        },
+      ],
+    });
+    try {
+      const { result, blocks, status } = runAdapter(server.baseUrl, server.token);
+      const res = await result;
+      expect(res).toEqual({ text: "hello deepseek", newSessionId: server.threadId });
+      expect(blocks).toContain("assistant_text");
+      expect(status.at(-1)).toEqual({ phase: "stopped", label: undefined });
+    } finally {
+      await server.close();
+    }
+  });
+
+  it("parses current DeepSeek item.started/item.completed tool events", async () => {
+    const server = await startMockDeepseekServer({
+      events: [
+        {
+          event: "turn.started",
+          data: { thread_id: "thr_test", turn_id: "turn_test", event: "turn.started" },
+        },
+        {
+          event: "item.started",
+          data: {
+            thread_id: "thr_test",
+            turn_id: "turn_test",
+            event: "item.started",
+            payload: {
+              item: { id: "item_tool", kind: "tool_call", status: "in_progress" },
+              tool: { id: "call_1", name: "web_search", input: { query: "Shanghai weather" } },
+            },
+          },
+        },
+        {
+          event: "item.completed",
+          data: {
+            thread_id: "thr_test",
+            turn_id: "turn_test",
+            event: "item.completed",
+            payload: {
+              item: {
+                id: "item_tool",
+                kind: "tool_call",
+                status: "completed",
+                detail: "Found 5 result(s)",
+              },
+            },
+          },
+        },
+        {
+          event: "item.delta",
+          data: {
+            thread_id: "thr_test",
+            turn_id: "turn_test",
+            event: "item.delta",
+            payload: { kind: "agent_message", delta: "done" },
+          },
+        },
+        {
+          event: "turn.completed",
+          data: { thread_id: "thr_test", turn_id: "turn_test", event: "turn.completed" },
+        },
+      ],
+    });
+    try {
+      const { result, blocks, status } = runAdapter(server.baseUrl, server.token);
+      await expect(result).resolves.toMatchObject({ text: "done" });
+      expect(blocks).toEqual(expect.arrayContaining(["tool_use", "tool_result", "assistant_text"]));
+      expect(status).toContainEqual({ phase: "updated", label: "web_search" });
+    } finally {
+      await server.close();
+    }
+  });
+
+  it("emits current DeepSeek agent_reasoning completions as thinking blocks", async () => {
+    const server = await startMockDeepseekServer({
+      events: [
+        {
+          event: "turn.started",
+          data: { thread_id: "thr_test", turn_id: "turn_test", event: "turn.started" },
+        },
+        {
+          event: "item.completed",
+          data: {
+            thread_id: "thr_test",
+            turn_id: "turn_test",
+            event: "item.completed",
+            payload: {
+              item: {
+                id: "item_reasoning",
+                kind: "agent_reasoning",
+                status: "completed",
+                summary: "I should answer briefly.",
+                detail: "I should answer briefly.",
+              },
+            },
+          },
+        },
+        {
+          event: "item.delta",
+          data: {
+            thread_id: "thr_test",
+            turn_id: "turn_test",
+            event: "item.delta",
+            payload: { kind: "agent_message", delta: "hi" },
+          },
+        },
+        {
+          event: "turn.completed",
+          data: { thread_id: "thr_test", turn_id: "turn_test", event: "turn.completed" },
+        },
+      ],
+    });
+    try {
+      const { result, blocks } = runAdapter(server.baseUrl, server.token);
+      await expect(result).resolves.toMatchObject({ text: "hi" });
+      expect(blocks).toContain("thinking");
+    } finally {
+      await server.close();
+    }
+  });
+
   it("reuses an existing DeepSeek thread id and patches per-turn system context", async () => {
     const server = await startMockDeepseekServer({ threadId: "thr_existing" });
     try {

package/src/gateway/__tests__/dispatcher.test.ts

@@ -244,6 +244,7 @@ describe("Dispatcher", () => {
     turnTimeoutMs?: number;
     runtimeAuthFailureThreshold?: number;
     runtimeAuthFailureCooldownMs?: number;
+    buildRuntimeRecoveryContext?: (message: GatewayInboundMessage) => Promise<string | null> | string | null;
   }) {
     const { store, dir } = await makeStore();
     tempDirs.push(dir);
@@ -258,6 +259,7 @@ describe("Dispatcher", () => {
       turnTimeoutMs: args.turnTimeoutMs,
       runtimeAuthFailureThreshold: args.runtimeAuthFailureThreshold,
       runtimeAuthFailureCooldownMs: args.runtimeAuthFailureCooldownMs,
+      buildRuntimeRecoveryContext: args.buildRuntimeRecoveryContext,
     });
     return { dispatcher, channel, store };
   }
@@ -460,6 +462,60 @@ describe("Dispatcher", () => {
     expect(channel.sends[0].message.type).toBe("error");
   });
 
+  it("codex: retries a poisoned resumed session in a fresh session with recent room context", async () => {
+    let factoryCall = 0;
+    const recoveryRuntime: RuntimeAdapter = {
+      id: "codex",
+      run: vi.fn(async (opts: RuntimeRunOptions): Promise<RuntimeRunResult> => {
+        if ((recoveryRuntime.run as any).mock.calls.length === 1) {
+          expect(opts.sessionId).toBe("sid-1");
+          return {
+            text: "",
+            newSessionId: "sid-1",
+            error: "Codex context compaction failed: maximum context length exceeded",
+          };
+        }
+        expect(opts.sessionId).toBe(null);
+        expect(opts.text).toContain("[BotCord Runtime Recovery Notice]");
+        expect(opts.text).toContain("[Recent Room Messages]");
+        expect(opts.text).toContain("Alice: deploy is failing");
+        expect(opts.text).toContain("[Current User Turn]");
+        expect(opts.text).toContain("continue");
+        return { text: "recovered", newSessionId: "sid-2" };
+      }) as RuntimeAdapter["run"],
+    };
+    const runtimeFactory: RuntimeFactory = () => {
+      factoryCall += 1;
+      if (factoryCall === 1) {
+        return new FakeRuntime({ id: "codex", reply: "ok", newSessionId: "sid-1" });
+      }
+      return recoveryRuntime;
+    };
+    const { dispatcher, store, channel } = await scaffold({
+      config: baseConfig({ defaultRoute: { runtime: "codex", cwd: "/tmp/default" } }),
+      runtimeFactory,
+      buildRuntimeRecoveryContext: () =>
+        "[Recent Room Messages]\n- Alice: deploy is failing\n- Bot: I am checking logs",
+    });
+
+    await dispatcher.handle(
+      makeEnvelope({ id: "msg_1", conversation: { id: "rm_oc_recover", kind: "direct" } }),
+    );
+    expect(store.all()[0].runtimeSessionId).toBe("sid-1");
+
+    await dispatcher.handle(
+      makeEnvelope({
+        id: "msg_2",
+        text: "continue",
+        conversation: { id: "rm_oc_recover", kind: "direct" },
+      }),
+    );
+
+    expect(recoveryRuntime.run).toHaveBeenCalledTimes(2);
+    expect(store.all()[0].runtimeSessionId).toBe("sid-2");
+    expect(channel.sends.map((s) => s.message.text)).toEqual(["ok", "recovered"]);
+  });
+
   it("treats auth failure text as an error and does not persist the failed session", async () => {
     let callNo = 0;
     const runtimeFactory: RuntimeFactory = () => {

package/src/gateway/channels/botcord.ts

@@ -986,7 +986,7 @@ function normalizeBlockForHub(
     // Claude Code: {type:"assistant", message:{content:[{type:"text",text}]}}
     // Codex:       {type:"item.completed", item:{type:"agent_message", text}}
     // DeepSeek:    {event:"message.delta", payload:{content}} or
-    //              {event:"item.delta", payload:{payload:{kind:"agent_message", delta}}}
+    //              {event:"item.delta", payload:{kind:"agent_message", delta}}
     let text = "";
     const contents = Array.isArray(raw?.message?.content) ? raw.message.content : [];
     for (const c of contents) {
@@ -999,10 +999,14 @@ function normalizeBlockForHub(
     if (
       !text &&
       raw?.event === "item.delta" &&
-      raw?.payload?.payload?.kind === "agent_message" &&
-      typeof raw?.payload?.payload?.delta === "string"
+      (raw?.payload?.kind === "agent_message" || raw?.payload?.payload?.kind === "agent_message")
     ) {
-      text = raw.payload.payload.delta;
+      text =
+        typeof raw?.payload?.delta === "string"
+          ? raw.payload.delta
+          : typeof raw?.payload?.payload?.delta === "string"
+            ? raw.payload.payload.delta
+            : "";
     }
     return { kind: "assistant", seq, payload: { text } };
   }
@@ -1200,8 +1204,13 @@ function extractDeepseekToolCall(raw: any): { name: string; params?: unknown; id
     };
   }
 
-  if (payload.event === "item.started") {
-    const inner = payload.payload && typeof payload.payload === "object" ? payload.payload : {};
+  if (raw?.event === "item.started" || payload.event === "item.started") {
+    const inner =
+      raw?.event === "item.started"
+        ? payload
+        : payload.payload && typeof payload.payload === "object"
+          ? payload.payload
+          : {};
     const item = inner.item && typeof inner.item === "object" ? inner.item : undefined;
     const tool = inner.tool && typeof inner.tool === "object" ? inner.tool : item?.tool;
     return {
@@ -1240,8 +1249,18 @@ function extractDeepseekToolResult(raw: any): { name?: string; result: string; i
     };
   }
 
-  if (payload.event === "item.completed" || payload.event === "item.failed") {
-    const inner = payload.payload && typeof payload.payload === "object" ? payload.payload : {};
+  if (
+    raw?.event === "item.completed" ||
+    raw?.event === "item.failed" ||
+    payload.event === "item.completed" ||
+    payload.event === "item.failed"
+  ) {
+    const inner =
+      raw?.event === "item.completed" || raw?.event === "item.failed"
+        ? payload
+        : payload.payload && typeof payload.payload === "object"
+          ? payload.payload
+          : {};
     const item = inner.item && typeof inner.item === "object" ? inner.item : undefined;
     const result =
       item?.output ??
@@ -1273,6 +1292,11 @@ function formatBlockDetails(raw: unknown): string {
     : typeof r.message === "string" ? r.message
     : typeof r.summary === "string" ? r.summary
     : typeof r.label === "string" ? r.label
+    : typeof r.payload?.delta === "string" ? r.payload.delta
+    : typeof r.payload?.item?.detail === "string" ? r.payload.item.detail
+    : typeof r.payload?.item?.summary === "string" ? r.payload.item.summary
+    : typeof r.payload?.payload?.item?.detail === "string" ? r.payload.payload.item.detail
+    : typeof r.payload?.payload?.item?.summary === "string" ? r.payload.payload.item.summary
     : "";
   if (direct) return direct;
 

package/src/gateway/channels/login-session.ts

@@ -77,10 +77,28 @@ export class LoginSessionStore {
     return session;
   }
 
+  /**
+   * Distinguish whether `loginId` is unknown to the store ("missing") vs
+   * known-but-past-TTL ("expired"). When the entry is expired this also
+   * evicts it from the internal map so callers do not need to follow up
+   * with a separate `delete`. Use this when the caller wants to surface
+   * a precise error code to the user; prefer `get` when a single nullable
+   * result is enough.
+   */
+  resolve(loginId: string): { state: "live" | "expired" | "missing"; session?: LoginSession } {
+    const s = this.sessions.get(loginId);
+    if (!s) return { state: "missing" };
+    if (s.expiresAt <= this.now()) {
+      this.sessions.delete(loginId);
+      return { state: "expired" };
+    }
+    return { state: "live", session: s };
+  }
+
   /** Get a non-expired session by id, or `null` when missing/expired. */
   get(loginId: string): LoginSession | null {
-    this.sweep();
-    return this.sessions.get(loginId) ?? null;
+    const { state, session } = this.resolve(loginId);
+    return state === "live" && session ? session : null;
   }
 
   /**

package/src/gateway/channels/sanitize.ts

@@ -1,68 +1,10 @@
 /**
- * Sanitize untrusted inbound content before handing it off to a local runtime.
- *
- * Copied from `packages/daemon/src/sanitize.ts` so the gateway channel adapter
- * does not depend back on the daemon package. Keep these two files in sync —
- * any new structural marker added in one place should be mirrored in the other.
- *
- * Neutralizes:
- *   - BotCord structural markers the channel itself emits (so peers can't forge them).
- *   - Common LLM prompt-injection patterns (<system>, [INST], <<SYS>>, <|im_start|>, etc.).
- *   - Wrapper XML tags the channel uses to frame inbound content
- *     (<agent-message>, <human-message>, <room-rule>).
+ * Thin re-export — `sanitizeUntrustedContent` / `sanitizeSenderName` live
+ * in `@botcord/protocol-core` so the daemon channel adapters and the
+ * `gateway-ingress` provider adapters use one canonical implementation.
+ * Existing imports of this module keep working unchanged.
  */
-
-export function sanitizeUntrustedContent(text: string): string {
-  let s = text;
-  s = s.replace(
-    /<\/?a[\s]*g[\s]*e[\s]*n[\s]*t[\s]*-[\s]*m[\s]*e[\s]*s[\s]*s[\s]*a[\s]*g[\s]*e[\s\S]*?>/gi,
-    "[⚠ stripped: agent-message tag]",
-  );
-  s = s.replace(
-    /<\/?h[\s]*u[\s]*m[\s]*a[\s]*n[\s]*-[\s]*m[\s]*e[\s]*s[\s]*s[\s]*a[\s]*g[\s]*e[\s\S]*?>/gi,
-    "[⚠ stripped: human-message tag]",
-  );
-  s = s.replace(
-    /<\/?r[\s]*o[\s]*o[\s]*m[\s]*-[\s]*r[\s]*u[\s]*l[\s]*e[\s\S]*?>/gi,
-    "[⚠ stripped: room-rule tag]",
-  );
-
-  return s
-    .split(/\r?\n/)
-    .map((line) => {
-      let l = line;
-      l = l.replace(/^\[(BotCord (?:Message|Notification))\]/i, "[⚠ fake: $1]");
-      l = l.replace(/^\[Room Rule\]/i, "[⚠ fake: Room Rule]");
-      l = l.replace(/^\[房间规则\]/i, "[⚠ fake: 房间规则]");
-      l = l.replace(/^\[系统提示\]/i, "[⚠ fake: 系统提示]");
-      l = l.replace(/^\[BotCord\s+([^\]\r\n]+)\]/i, (_m, label) => {
-        const head = String(label).split(":")[0].trim() || String(label).trim();
-        return `[⚠ fake: BotCord ${head}]`;
-      });
-      l = l.replace(/^\[(System|SYSTEM|Assistant|ASSISTANT|User|USER)\]/, "[⚠ fake: $1]");
-      l = l.replace(/<\/?\s*system(?:-reminder)?\s*>/gi, "[⚠ stripped: system tag]");
-      l = l.replace(/<\|im_start\|>/gi, "[⚠ stripped: im_start]");
-      l = l.replace(/<\|im_end\|>/gi, "[⚠ stripped: im_end]");
-      l = l.replace(/\[\/?INST\]/gi, "[⚠ stripped: INST]");
-      l = l.replace(/<<\/?SYS>>/gi, "[⚠ stripped: SYS]");
-      l = l.replace(/<\s*\/?\|(?:system|user|assistant)\|?\s*>/gi, "[⚠ stripped: role tag]");
-      return l;
-    })
-    .join("\n");
-}
-
-/**
- * Sanitize a sender label so it's safe to embed inside
- * `<agent-message sender="...">`. Must not contain newlines, structural
- * markers, or characters that could break the XML attribute boundary.
- */
-export function sanitizeSenderName(name: string): string {
-  return name
-    .replace(/[\n\r]/g, " ")
-    .replace(/\[/g, "⟦")
-    .replace(/\]/g, "⟧")
-    .replace(/"/g, "'")
-    .replace(/</g, "＜")
-    .replace(/>/g, "＞")
-    .slice(0, 100);
-}
+export {
+  sanitizeUntrustedContent,
+  sanitizeSenderName,
+} from "@botcord/protocol-core";

package/src/gateway/channels/text-split.ts

@@ -1,29 +1,7 @@
 /**
- * Split a long message into chunks <= `limit` characters each. Prefers to cut
- * on newline boundaries so multi-paragraph replies don't fragment mid-line.
- *
- * Shared by third-party channel adapters (Telegram, WeChat) which both have a
- * per-message size cap from upstream and no native streaming. WeChat caller
- * passes a smaller `limit` (~1800), Telegram a larger one (~4000, since the
- * raw Telegram limit is 4096).
- *
- * Empty input returns `[""]` so callers can iterate uniformly without a length
- * check.
+ * Thin re-export — `splitText` lives in `@botcord/protocol-core` so the
+ * daemon channel adapters and the `gateway-ingress` provider adapters use
+ * one canonical implementation. Existing imports of this module keep
+ * working unchanged.
  */
-export function splitText(text: string, limit: number): string[] {
-  if (limit <= 0) return [text];
-  if (text.length === 0) return [""];
-  if (text.length <= limit) return [text];
-
-  const out: string[] = [];
-  let remaining = text;
-  while (remaining.length > limit) {
-    let cut = remaining.lastIndexOf("\n", limit);
-    if (cut <= 0) cut = limit;
-    out.push(remaining.slice(0, cut));
-    // Drop the leading newline so the next chunk doesn't start with a blank line.
-    remaining = remaining.slice(cut).replace(/^\n/, "");
-  }
-  if (remaining.length > 0) out.push(remaining);
-  return out;
-}
+export { splitText } from "@botcord/protocol-core";