@botcord/daemon 0.2.77 → 0.2.79

package/src/daemon.ts

@@ -39,6 +39,7 @@ import { createDaemonSystemContextBuilder } from "./system-context.js";
 import { readWorkingMemorySnapshot } from "./working-memory.js";
 import { createRoomStaticContextBuilder } from "./room-context.js";
 import { createRoomContextFetcher } from "./room-context-fetcher.js";
+import { createRecentRoomMessagesRecoveryBuilder } from "./room-recovery-context.js";
 import {
   buildLoopRiskPrompt,
   loopRiskSessionKey,
@@ -50,6 +51,7 @@ import { UserAuthManager } from "./user-auth.js";
 import { PolicyResolver, type DaemonAttentionPolicy } from "./gateway/policy-resolver.js";
 import { scanMention } from "./mention-scan.js";
 import { createDiagnosticBundle, uploadDiagnosticBundle } from "./diagnostics.js";
+import { createAttentionPolicyFetcher } from "./attention-policy-fetcher.js";
 
 /**
  * Default hard cap for a single runtime turn. Long-running coding/research
@@ -364,6 +366,13 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
     fetchRoomInfo: roomContextFetcher,
     log: logger,
   });
+  const buildRuntimeRecoveryContext = createRecentRoomMessagesRecoveryBuilder({
+    credentialPathByAgentId,
+    ...(opts.credentialsPath ? { defaultCredentialsPath: opts.credentialsPath } : {}),
+    ...(opts.hubBaseUrl ? { hubBaseUrl: opts.hubBaseUrl } : {}),
+    limit: 20,
+    log: logger,
+  });
 
   // Cache one system-context builder per configured agentId. The gateway
   // calls this with each inbound message and we pick the right builder by
@@ -442,13 +451,20 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
     });
   };
 
-  // Per-agent attention policy cache (PR3, design §4.2 / §5). Seeded from
-  // the optional `defaultAttention` / `attentionKeywords` carried by
-  // `provision_agent`, refreshed in-place by the `policy_updated` control
-  // frame. PR2 will plug per-room overrides into `fetchEffective`; PR3
-  // leaves it absent so the resolver collapses to per-agent state.
+  // Per-agent attention policy cache (design §4.2 / §5). It is seeded from
+  // `provision_agent` / `policy_updated` frames when available and falls back
+  // to Hub on cold misses, so daemon restarts preserve dashboard policy.
+  const fetchAttentionPolicy = createAttentionPolicyFetcher({
+    credentialPathByAgentId,
+    defaultCredentialsPath: opts.credentialsPath,
+    hubBaseUrl: opts.hubBaseUrl,
+    log: logger,
+  });
   const policyResolver = new PolicyResolver({
-    fetchGlobal: async (_agentId: string) => undefined,
+    fetchGlobal: async (agentId: string) =>
+      fetchAttentionPolicy({ agentId, roomId: null }),
+    fetchEffective: async (agentId: string, roomId: string) =>
+      fetchAttentionPolicy({ agentId, roomId }),
   });
 
   // Display-name lookup for the mention text-fallback. Populated from boot
@@ -528,6 +544,7 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
     turnTimeoutMs: DEFAULT_TURN_TIMEOUT_MS,
     buildSystemContext,
     buildMemoryContext,
+    buildRuntimeRecoveryContext,
     onInbound,
     onOutbound,
     onRuntimeCircuitBreakerChange: pushLiveRuntimeSnapshot,
@@ -684,7 +701,7 @@ export async function startDaemon(opts: DaemonRuntimeOptions): Promise<DaemonHan
  */
 export interface BootBackfillResult {
   credentialPathByAgentId: Map<string, string>;
-  agentRuntimes: Record<string, { runtime?: string; cwd?: string; openclawGateway?: string; openclawAgent?: string; hermesProfile?: string }>;
+  agentRuntimes: Record<string, { runtime?: string; runtimeModel?: string; reasoningEffort?: string; thinking?: boolean; cwd?: string; openclawGateway?: string; openclawAgent?: string; hermesProfile?: string }>;
 }
 
 /**
@@ -703,13 +720,25 @@ export function backfillBootAgents(
 ): BootBackfillResult {
   const ensure = opts.ensure ?? ensureAgentWorkspace;
   const credentialPathByAgentId = new Map<string, string>();
-  const agentRuntimes: Record<string, { runtime?: string; cwd?: string }> = {};
+  const agentRuntimes: Record<string, { runtime?: string; runtimeModel?: string; reasoningEffort?: string; thinking?: boolean; cwd?: string; openclawGateway?: string; openclawAgent?: string; hermesProfile?: string }> = {};
   const failed: string[] = [];
   for (const a of agents) {
     if (a.credentialsFile) credentialPathByAgentId.set(a.agentId, a.credentialsFile);
-    if (a.runtime || a.cwd || a.openclawGateway || a.openclawAgent || a.hermesProfile) {
+    if (
+      a.runtime ||
+      a.runtimeModel ||
+      a.reasoningEffort ||
+      typeof a.thinking === "boolean" ||
+      a.cwd ||
+      a.openclawGateway ||
+      a.openclawAgent ||
+      a.hermesProfile
+    ) {
       agentRuntimes[a.agentId] = {
         ...(a.runtime ? { runtime: a.runtime } : {}),
+        ...(a.runtimeModel ? { runtimeModel: a.runtimeModel } : {}),
+        ...(a.reasoningEffort ? { reasoningEffort: a.reasoningEffort } : {}),
+        ...(typeof a.thinking === "boolean" ? { thinking: a.thinking } : {}),
         ...(a.cwd ? { cwd: a.cwd } : {}),
         ...(a.openclawGateway ? { openclawGateway: a.openclawGateway } : {}),
         ...(a.openclawAgent ? { openclawAgent: a.openclawAgent } : {}),

package/src/gateway/__tests__/botcord-channel.test.ts

@@ -925,6 +925,103 @@ describe("createBotCordChannel — streamBlock()", () => {
     }
   });
 
+  it("normalizes current DeepSeek item.delta assistant text", async () => {
+    const fetchSpy = vi.fn().mockResolvedValue(new Response(null, { status: 204 }));
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = fetchSpy as unknown as typeof fetch;
+    try {
+      const client = makeClient({
+        getHubUrl: vi.fn().mockReturnValue("https://hub.example.com"),
+      });
+      const channel = createBotCordChannel({
+        id: "botcord-main",
+        accountId: "ag_self",
+        agentId: "ag_self",
+        client,
+        hubBaseUrl: "https://hub.example.com",
+      });
+      await channel.streamBlock!({
+        traceId: "m_trace",
+        accountId: "ag_self",
+        conversationId: "rm_oc_1",
+        block: {
+          kind: "assistant_text",
+          seq: 6,
+          raw: {
+            event: "item.delta",
+            payload: { thread_id: "thr_1", turn_id: "turn_1", kind: "agent_message", delta: "hello" },
+          },
+        },
+        log: silentLog,
+      });
+      const [, init] = fetchSpy.mock.calls[0];
+      const body = JSON.parse(init.body as string);
+      expect(body.block).toEqual({
+        kind: "assistant",
+        seq: 6,
+        payload: { text: "hello" },
+      });
+    } finally {
+      globalThis.fetch = realFetch;
+    }
+  });
+
+  it("normalizes current DeepSeek item.started tool input", () => {
+    expect(
+      __normalizeBlockForHubForTests(
+        {
+          kind: "tool_use",
+          seq: 7,
+          raw: {
+            event: "item.started",
+            payload: {
+              item: { id: "item_tool", kind: "tool_call", status: "in_progress" },
+              tool: { id: "call_1", name: "web_search", input: { query: "上海天气" } },
+            },
+          },
+        },
+        7,
+      ),
+    ).toEqual({
+      kind: "tool_call",
+      seq: 7,
+      payload: {
+        id: "call_1",
+        name: "web_search",
+        params: { query: "上海天气" },
+        status: "in_progress",
+      },
+    });
+  });
+
+  it("normalizes current DeepSeek agent_reasoning details", () => {
+    expect(
+      __normalizeBlockForHubForTests(
+        {
+          kind: "thinking",
+          seq: 8,
+          raw: {
+            event: "item.completed",
+            payload: {
+              item: {
+                id: "item_reasoning",
+                kind: "agent_reasoning",
+                status: "completed",
+                summary: "I should answer briefly.",
+                detail: "I should answer briefly.",
+              },
+            },
+          },
+        },
+        8,
+      ),
+    ).toEqual({
+      kind: "thinking",
+      seq: 8,
+      payload: { details: "I should answer briefly." },
+    });
+  });
+
   it("marks DeepSeek terminal events for owner-chat stream cleanup", async () => {
     const fetchSpy = vi.fn().mockResolvedValue(new Response(null, { status: 204 }));
     const realFetch = globalThis.fetch;

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

@@ -106,7 +106,12 @@ async function startMockDeepseekServer(opts?: {
   };
 }
 
-function runAdapter(serverUrl: string, authToken: string, sessionId: string | null = null) {
+function runAdapter(
+  serverUrl: string,
+  authToken: string,
+  sessionId: string | null = null,
+  extraArgs?: string[],
+) {
   const adapter = new DeepseekTuiAdapter({ serverUrl, authToken });
   const ctrl = new AbortController();
   const blocks: string[] = [];
@@ -118,6 +123,7 @@ function runAdapter(serverUrl: string, authToken: string, sessionId: string | nu
     cwd: tmpRoot,
     signal: ctrl.signal,
     trustLevel: "owner",
+    extraArgs,
     systemContext: "runtime memory",
     onBlock: (b) => blocks.push(b.kind),
     onStatus: (e) => {
@@ -169,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 {
@@ -184,6 +367,29 @@ describe("DeepseekTuiAdapter", () => {
     }
   });
 
+  it("passes selected model and reasoning effort through HTTP payloads", async () => {
+    const server = await startMockDeepseekServer();
+    try {
+      const { result } = runAdapter(server.baseUrl, server.token, null, [
+        "--model",
+        "deepseek-v4-pro",
+        "--reasoning-effort",
+        "auto",
+      ]);
+      await result;
+      expect(server.calls.find((c) => c.method === "POST" && c.url === "/v1/threads")?.body).toMatchObject({
+        model: "deepseek-v4-pro",
+        reasoning_effort: "auto",
+      });
+      expect(server.calls.find((c) => c.method === "POST" && c.url.endsWith("/turns"))?.body).toMatchObject({
+        model: "deepseek-v4-pro",
+        reasoning_effort: "auto",
+      });
+    } finally {
+      await server.close();
+    }
+  });
+
   it("clears stale session ids when DeepSeek reports the thread missing", async () => {
     const server = await startMockDeepseekServer({ threadId: "thr_other" });
     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;
   }
 
   /**