@botcord/daemon 0.2.78 → 0.2.80

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

@@ -175,6 +175,232 @@ 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("infers current DeepSeek tool status labels without a payload.tool object", 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_exec",
+                kind: "tool_call",
+                status: "in_progress",
+                summary: "exec_shell started",
+                detail: "{\"cmd\":\"botcord-daemon --version\"}",
+              },
+            },
+          },
+        },
+        {
+          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", "assistant_text"]));
+      expect(status).toContainEqual({ phase: "updated", label: "exec_shell" });
+    } 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 {
@@ -233,6 +459,43 @@ describe("DeepseekTuiAdapter", () => {
     }
   });
 
+  it("surfaces a diagnostic error when DeepSeek completes a turn with no assistant_message", async () => {
+    const server = await startMockDeepseekServer({
+      events: [
+        { event: "turn.started", data: { thread_id: "thr_test", turn_id: "turn_test" } },
+        {
+          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: "thinking...",
+              },
+            },
+          },
+        },
+        {
+          event: "turn.completed",
+          data: { thread_id: "thr_test", turn_id: "turn_test", payload: { turn: { status: "completed" } } },
+        },
+      ],
+    });
+    try {
+      const { result } = runAdapter(server.baseUrl, server.token);
+      const res = await result;
+      expect(res.text).toBe("");
+      expect(res.newSessionId).toBe("thr_test");
+      expect(res.error).toMatch(/no assistant_message/);
+    } finally {
+      await server.close();
+    }
+  });
+
   it("returns a runtime error when DeepSeek completes the turn as failed", async () => {
     const server = await startMockDeepseekServer({
       events: [

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

@@ -977,16 +977,19 @@ export { normalizeBlockForHub as __normalizeBlockForHubForTests };
 function normalizeBlockForHub(
   block: { raw?: unknown; kind?: string; seq?: number } | undefined,
   seq: number,
-): { kind: string; seq: number; payload: Record<string, unknown> } {
+): { kind: string; seq: number; payload: Record<string, unknown>; raw?: unknown } {
   const raw = (block?.raw ?? {}) as any;
   const kind = block?.kind ?? "other";
   const payload: Record<string, unknown> = {};
+  const withRaw = (out: { kind: string; seq: number; payload: Record<string, unknown> }) => (
+    block && "raw" in block ? { ...out, raw: block.raw } : out
+  );
 
   if (kind === "assistant_text") {
     // 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 +1002,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 } };
   }
@@ -1018,7 +1025,7 @@ function normalizeBlockForHub(
       if (call.id) payload.id = call.id;
       if (call.status) payload.status = call.status;
     }
-    return { kind: "tool_call", seq, payload };
+    return withRaw({ kind: "tool_call", seq, payload });
   }
 
   if (kind === "tool_result") {
@@ -1028,7 +1035,7 @@ function normalizeBlockForHub(
       payload.result = result.result;
       if (result.id) payload.tool_use_id = result.id;
     }
-    return { kind: "tool_result", seq, payload };
+    return withRaw({ kind: "tool_result", seq, payload });
   }
 
   if (kind === "system") {
@@ -1036,7 +1043,7 @@ function normalizeBlockForHub(
     if (typeof raw?.session_id === "string") payload.session_id = raw.session_id;
     if (typeof raw?.model === "string") payload.model = raw.model;
     payload.details = formatBlockDetails(raw);
-    return { kind: "system", seq, payload };
+    return withRaw({ kind: "system", seq, payload });
   }
 
   if (kind === "thinking") {
@@ -1048,7 +1055,7 @@ function normalizeBlockForHub(
     if (typeof raw?.label === "string") payload.label = raw.label;
     if (typeof raw?.source === "string") payload.source = raw.source;
     payload.details = formatBlockDetails(raw);
-    return { kind: "thinking", seq, payload };
+    return withRaw({ kind: "thinking", seq, payload });
   }
 
   // "other" — e.g. Claude Code `type:"result"` end-of-turn summary.
@@ -1058,14 +1065,14 @@ function normalizeBlockForHub(
     const event = typeof raw?.event === "string" ? raw.event : undefined;
     const embedded = typeof raw?.payload?.event === "string" ? raw.payload.event : undefined;
     if (event || embedded) payload.event = event ?? embedded;
-    return { kind: "other", seq, payload };
+    return withRaw({ kind: "other", seq, payload });
   }
   if (raw?.type === "result") {
     if (typeof raw.result === "string") payload.text = raw.result;
     if (typeof raw.subtype === "string") payload.subtype = raw.subtype;
     if (typeof raw.total_cost_usd === "number") payload.total_cost_usd = raw.total_cost_usd;
   }
-  return { kind: "other", seq, payload };
+  return withRaw({ kind: "other", seq, payload });
 }
 
 function isTerminalRuntimeBlock(raw: any): boolean {
@@ -1200,25 +1207,41 @@ 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;
+    const itemParams = parseMaybeJson(item?.input ?? item?.arguments ?? item?.detail);
+    const detailParams =
+      itemParams !== undefined
+        ? itemParams
+        : typeof item?.detail === "string" && item.detail.trim()
+          ? item.detail.trim()
+          : undefined;
     return {
       name:
         stringField(tool, "name") ??
         stringField(inner, "name") ??
         stringField(item, "name") ??
+        inferDeepseekToolName(item) ??
         stringField(item, "type") ??
         "tool",
       params: parseMaybeJson(
         tool?.input ??
           tool?.rawInput ??
           tool?.arguments ??
+          tool?.params ??
           inner.input ??
+          inner.arguments ??
+          inner.params ??
           item?.input ??
           item?.arguments,
-      ) ?? tool ?? item,
+      ) ?? detailParams ?? tool ?? item,
       id: stringField(tool, "id") ?? stringField(inner, "id") ?? stringField(item, "id"),
       status: stringField(tool, "status") ?? stringField(inner, "status") ?? stringField(item, "status"),
     };
@@ -1240,8 +1263,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 ??
@@ -1256,7 +1289,11 @@ function extractDeepseekToolResult(raw: any): { name?: string; result: string; i
       item ??
       inner;
     return {
-      name: stringField(item, "name") ?? stringField(item, "type") ?? stringField(inner, "name"),
+      name:
+        stringField(item, "name") ??
+        inferDeepseekToolName(item) ??
+        stringField(inner, "name") ??
+        stringField(item, "type"),
       result: stringifyToolResult(result),
       id: stringField(item, "id") ?? stringField(inner, "id"),
     };
@@ -1273,6 +1310,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;
 
@@ -1368,6 +1410,16 @@ function parseMaybeJson(value: unknown): unknown {
   }
 }
 
+function inferDeepseekToolName(item: any): string | undefined {
+  const candidates = [stringField(item, "summary"), stringField(item, "detail")];
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    const match = candidate.match(/^([A-Za-z0-9_.:-]+)\s*(?:started|completed|failed|returned|:)/);
+    if (match?.[1] && match[1] !== "tool_call") return match[1];
+  }
+  return undefined;
+}
+
 function isEmptyRecord(value: unknown): boolean {
   return !!value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
 }

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";