@botcord/daemon 0.2.78 → 0.2.80

package/dist/attention-policy-fetcher.d.ts

@@ -0,0 +1,14 @@
+import type { DaemonAttentionPolicy } from "./gateway/policy-resolver.js";
+export interface AttentionPolicyFetcherOptions {
+    credentialPathByAgentId: Map<string, string>;
+    defaultCredentialsPath?: string;
+    hubBaseUrl?: string;
+    log?: {
+        warn: (msg: string, meta?: Record<string, unknown>) => void;
+    };
+}
+export type AttentionPolicyFetcher = (args: {
+    agentId: string;
+    roomId?: string | null;
+}) => Promise<DaemonAttentionPolicy | undefined>;
+export declare function createAttentionPolicyFetcher(opts: AttentionPolicyFetcherOptions): AttentionPolicyFetcher;

package/dist/attention-policy-fetcher.js

@@ -0,0 +1,59 @@
+import { BotCordClient, defaultCredentialsFile, loadStoredCredentials, updateCredentialsToken, } from "@botcord/protocol-core";
+export function createAttentionPolicyFetcher(opts) {
+    const clients = new Map();
+    function getClient(agentId) {
+        const existing = clients.get(agentId);
+        if (existing)
+            return existing.client;
+        const credentialsPath = opts.credentialPathByAgentId.get(agentId) ??
+            opts.defaultCredentialsPath ??
+            defaultCredentialsFile(agentId);
+        try {
+            const creds = loadStoredCredentials(credentialsPath);
+            const client = new BotCordClient({
+                hubUrl: opts.hubBaseUrl ?? creds.hubUrl,
+                agentId: creds.agentId,
+                keyId: creds.keyId,
+                privateKey: creds.privateKey,
+                ...(creds.token ? { token: creds.token } : {}),
+                ...(creds.tokenExpiresAt !== undefined
+                    ? { tokenExpiresAt: creds.tokenExpiresAt }
+                    : {}),
+            });
+            client.onTokenRefresh = (token, expiresAt) => {
+                try {
+                    updateCredentialsToken(credentialsPath, token, expiresAt);
+                }
+                catch {
+                    // Persistence failures are non-fatal; the next refresh retries.
+                }
+            };
+            clients.set(agentId, { client, credentialsPath });
+            return client;
+        }
+        catch (err) {
+            opts.log?.warn("daemon.attention-policy.client-init-failed", {
+                agentId,
+                credentialsPath,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return null;
+        }
+    }
+    return async ({ agentId, roomId }) => {
+        const client = getClient(agentId);
+        if (!client)
+            return undefined;
+        try {
+            return await client.getAttentionPolicy({ roomId });
+        }
+        catch (err) {
+            opts.log?.warn("daemon.attention-policy.fetch-failed", {
+                agentId,
+                roomId: roomId ?? null,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return undefined;
+        }
+    };
+}

package/dist/cloud-daemon.js

@@ -23,6 +23,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 { composeBotCordUserTurn } from "./turn-text.js";
 import { PolicyResolver } from "./gateway/policy-resolver.js";
 import { scanMention } from "./mention-scan.js";
@@ -92,6 +93,12 @@ export async function startCloudDaemon(opts) {
         fetchRoomInfo: roomContextFetcher,
         log: logger,
     });
+    const buildRuntimeRecoveryContext = createRecentRoomMessagesRecoveryBuilder({
+        credentialPathByAgentId,
+        hubBaseUrl: cloudCfg.hubUrl,
+        limit: 20,
+        log: logger,
+    });
     const scBuilders = new Map();
     const buildSystemContext = (message) => {
         const b = scBuilders.get(message.accountId);
@@ -180,6 +187,7 @@ export async function startCloudDaemon(opts) {
         turnTimeoutMs: DEFAULT_TURN_TIMEOUT_MS,
         buildSystemContext,
         buildMemoryContext,
+        buildRuntimeRecoveryContext,
         onInbound,
         onTurnComplete,
         composeUserTurn: composeBotCordUserTurn,

package/dist/cloud-gateway-runtime.d.ts

@@ -0,0 +1,29 @@
+import { type GatewayInboundFrame } from "@botcord/protocol-core";
+import type { Gateway, GatewayLogger } from "./gateway/index.js";
+export interface CloudGatewayRuntimeResult {
+    accepted: boolean;
+    eventId: string;
+    gatewayId: string;
+    agentId: string;
+    conversationId: string;
+    turnId: string;
+    outbound?: {
+        finalText: string;
+        providerMessageId?: string | null;
+    };
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+/**
+ * Execute one ingress-originated runtime frame through the normal Gateway
+ * dispatcher while keeping provider I/O outside the cloud sandbox.
+ *
+ * The temporary channel is scoped to this call and implements only the
+ * dispatcher-facing send/status surface. Its send() method captures the
+ * final runtime reply; the Hub relay converts that into
+ * gateway_outbound_complete for gateway-ingress, which then calls the real
+ * provider API.
+ */
+export declare function handleCloudGatewayRuntimeInbound(gateway: Gateway, frame: GatewayInboundFrame, log?: GatewayLogger): Promise<CloudGatewayRuntimeResult>;

package/dist/cloud-gateway-runtime.js

@@ -0,0 +1,122 @@
+import { RUNTIME_FRAME_TYPES, } from "@botcord/protocol-core";
+/**
+ * Execute one ingress-originated runtime frame through the normal Gateway
+ * dispatcher while keeping provider I/O outside the cloud sandbox.
+ *
+ * The temporary channel is scoped to this call and implements only the
+ * dispatcher-facing send/status surface. Its send() method captures the
+ * final runtime reply; the Hub relay converts that into
+ * gateway_outbound_complete for gateway-ingress, which then calls the real
+ * provider API.
+ */
+export async function handleCloudGatewayRuntimeInbound(gateway, frame, log) {
+    if (frame.type !== RUNTIME_FRAME_TYPES.GATEWAY_INBOUND) {
+        return rejected(frame, "bad_frame_type", `unsupported frame type "${frame.type}"`);
+    }
+    if (!frame.gateway_id || !frame.agent_id || !frame.event_id) {
+        return rejected(frame, "bad_frame", "gateway_id, agent_id and event_id are required");
+    }
+    if (frame.message.accountId !== frame.agent_id) {
+        return rejected(frame, "account_mismatch", "message.accountId does not match frame.agent_id");
+    }
+    if (frame.message.channel !== frame.gateway_id) {
+        return rejected(frame, "channel_mismatch", "message.channel does not match frame.gateway_id");
+    }
+    let accepted = false;
+    let outboundText = null;
+    let providerMessageId;
+    const channel = createRuntimeRelayChannel({
+        id: frame.gateway_id,
+        provider: frame.provider,
+        accountId: frame.agent_id,
+        onSend: async (ctx) => {
+            outboundText = ctx.message.text ?? "";
+            providerMessageId = ctx.message.traceId ?? null;
+            return { providerMessageId };
+        },
+    });
+    const message = {
+        ...frame.message,
+        raw: {
+            source_type: "cloud_gateway_ingress",
+            provider: frame.provider,
+            event_id: frame.event_id,
+            gateway_id: frame.gateway_id,
+        },
+    };
+    try {
+        await gateway.injectInboundThrough(message, channel, {
+            accept: async () => {
+                accepted = true;
+            },
+        });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        log?.warn("cloud gateway runtime dispatch failed", {
+            eventId: frame.event_id,
+            gatewayId: frame.gateway_id,
+            agentId: frame.agent_id,
+            error: message,
+        });
+        return rejected(frame, "dispatch_failed", message);
+    }
+    return {
+        accepted,
+        eventId: frame.event_id,
+        gatewayId: frame.gateway_id,
+        agentId: frame.agent_id,
+        conversationId: frame.message.conversation.id,
+        turnId: `turn_${frame.event_id}`,
+        ...(outboundText !== null
+            ? {
+                outbound: {
+                    finalText: outboundText,
+                    providerMessageId: providerMessageId ?? null,
+                },
+            }
+            : {}),
+        ...(!accepted
+            ? { error: { code: "not_accepted", message: "dispatcher did not accept inbound" } }
+            : {}),
+    };
+}
+function createRuntimeRelayChannel(opts) {
+    let lastSendAt;
+    return {
+        id: opts.id,
+        type: opts.provider,
+        async start() {
+            return undefined;
+        },
+        async stop() {
+            return undefined;
+        },
+        async send(ctx) {
+            lastSendAt = Date.now();
+            return opts.onSend(ctx);
+        },
+        status() {
+            return {
+                channel: opts.id,
+                accountId: opts.accountId,
+                running: true,
+                connected: true,
+                authorized: true,
+                provider: opts.provider,
+                ...(lastSendAt ? { lastSendAt } : {}),
+            };
+        },
+    };
+}
+function rejected(frame, code, message) {
+    return {
+        accepted: false,
+        eventId: frame.event_id ?? "",
+        gatewayId: frame.gateway_id ?? "",
+        agentId: frame.agent_id ?? "",
+        conversationId: frame.message?.conversation.id ?? "",
+        turnId: frame.event_id ? `turn_${frame.event_id}` : "turn_unknown",
+        error: { code, message },
+    };
+}

package/dist/daemon-singleton.d.ts

@@ -4,6 +4,14 @@ export interface SingletonLogger {
 }
 export declare function readPid(pidPath?: string): number | null;
 export declare function pidAlive(pid: number): boolean;
+export interface DaemonProcessInfo {
+    pid: number;
+    command: string;
+}
+export declare function parseDaemonProcesses(psOutput: string, currentPid?: number): DaemonProcessInfo[];
+export declare function findOtherDaemonProcesses(opts?: {
+    currentPid?: number;
+}): DaemonProcessInfo[];
 export declare function waitForPidExit(pid: number, timeoutMs: number): Promise<boolean>;
 export declare function stopExistingDaemonForRestart(pid: number, opts?: {
     pidPath?: string;
@@ -15,6 +23,11 @@ export declare function stopDaemonFromPidFileForRestart(opts?: {
     currentPid?: number;
     logger?: SingletonLogger;
 }): Promise<void>;
+export declare function stopOtherDaemonProcessesForRestart(opts?: {
+    currentPid?: number;
+    logger?: SingletonLogger;
+    processes?: DaemonProcessInfo[];
+}): Promise<DaemonProcessInfo[]>;
 export declare function ensureNoOtherDaemonFromPidFile(opts?: {
     pidPath?: string;
     currentPid?: number;

package/dist/daemon-singleton.js

@@ -1,3 +1,4 @@
+import { execFileSync } from "node:child_process";
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { PID_PATH } from "./config.js";
 const noopLogger = {
@@ -24,6 +25,36 @@ export function pidAlive(pid) {
         return false;
     }
 }
+export function parseDaemonProcesses(psOutput, currentPid = process.pid) {
+    const out = [];
+    for (const line of psOutput.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        const match = /^(\d+)\s+(.+)$/.exec(trimmed);
+        if (!match)
+            continue;
+        const pid = Number(match[1]);
+        if (!Number.isFinite(pid) || pid <= 0 || pid === currentPid)
+            continue;
+        const command = match[2] ?? "";
+        if (!isBotCordDaemonStartCommand(command))
+            continue;
+        out.push({ pid, command });
+    }
+    return out;
+}
+export function findOtherDaemonProcesses(opts = {}) {
+    const currentPid = opts.currentPid ?? process.pid;
+    try {
+        const output = execFileSync("ps", ["-axo", "pid=,command="], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return parseDaemonProcesses(output, currentPid).filter((p) => pidAlive(p.pid));
+    }
+    catch {
+        return [];
+    }
+}
 export async function waitForPidExit(pid, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
@@ -66,6 +97,36 @@ export async function stopDaemonFromPidFileForRestart(opts = {}) {
         await stopExistingDaemonForRestart(existing, opts);
     }
 }
+export async function stopOtherDaemonProcessesForRestart(opts = {}) {
+    const currentPid = opts.currentPid ?? process.pid;
+    const logger = opts.logger ?? noopLogger;
+    const processes = opts.processes ?? findOtherDaemonProcesses({ currentPid });
+    for (const proc of processes) {
+        logger.info("additional daemon process found; restarting", {
+            pid: proc.pid,
+            command: proc.command,
+        });
+        try {
+            process.kill(proc.pid, "SIGTERM");
+        }
+        catch {
+            continue;
+        }
+        if (!(await waitForPidExit(proc.pid, 5_000))) {
+            logger.warn("additional daemon did not stop after SIGTERM; sending SIGKILL", {
+                pid: proc.pid,
+            });
+            try {
+                process.kill(proc.pid, "SIGKILL");
+            }
+            catch {
+                // ignore
+            }
+            await waitForPidExit(proc.pid, 2_000);
+        }
+    }
+    return processes;
+}
 export function ensureNoOtherDaemonFromPidFile(opts = {}) {
     const pidPath = opts.pidPath ?? PID_PATH;
     const currentPid = opts.currentPid ?? process.pid;
@@ -86,6 +147,13 @@ export function removePidFile(pidPath = PID_PATH) {
         // ignore
     }
 }
+function isBotCordDaemonStartCommand(command) {
+    if (!/\bstart\b/.test(command))
+        return false;
+    return (command.includes("botcord-daemon") ||
+        /(?:^|\s)\S*botcord\S*\/daemon\/dist\/index\.js(?:\s|$)/.test(command) ||
+        /(?:^|\s)\S*packages\/daemon\/dist\/index\.js(?:\s|$)/.test(command));
+}
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/dist/daemon.js

@@ -14,12 +14,14 @@ 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, recordInboundText as recordLoopRiskInbound, recordOutboundText as recordLoopRiskOutbound, } from "./loop-risk.js";
 import { composeBotCordUserTurn } from "./turn-text.js";
 import { UserAuthManager } from "./user-auth.js";
 import { PolicyResolver } 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
  * tasks routinely exceed 10 minutes, so daemon-hosted agents get a larger
@@ -233,6 +235,13 @@ export async function startDaemon(opts) {
         fetchRoomInfo: roomContextFetcher,
         log: logger,
     });
+    const buildRuntimeRecoveryContext = createRecentRoomMessagesRecoveryBuilder({
+        credentialPathByAgentId,
+        ...(opts.credentialsPath ? { defaultCredentialsPath: opts.credentialsPath } : {}),
+        ...(opts.hubBaseUrl ? { hubBaseUrl: opts.hubBaseUrl } : {}),
+        limit: 20,
+        log: logger,
+    });
     const scBuilders = new Map();
     const loopRiskBuilder = (msg) => buildLoopRiskPrompt({
         sessionKey: loopRiskSessionKey({
@@ -296,13 +305,18 @@ export async function startDaemon(opts) {
             text: out.text,
         });
     };
-    // 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) => undefined,
+        fetchGlobal: async (agentId) => fetchAttentionPolicy({ agentId, roomId: null }),
+        fetchEffective: async (agentId, roomId) => fetchAttentionPolicy({ agentId, roomId }),
     });
     // Display-name lookup for the mention text-fallback. Populated from boot
     // credentials; multi-agent daemons can reuse the same map via accountId.
@@ -374,6 +388,7 @@ export async function startDaemon(opts) {
         turnTimeoutMs: DEFAULT_TURN_TIMEOUT_MS,
         buildSystemContext,
         buildMemoryContext,
+        buildRuntimeRecoveryContext,
         onInbound,
         onOutbound,
         onRuntimeCircuitBreakerChange: pushLiveRuntimeSnapshot,

package/dist/gateway/channels/botcord.d.ts

@@ -133,4 +133,5 @@ declare function normalizeBlockForHub(block: {
     kind: string;
     seq: number;
     payload: Record<string, unknown>;
+    raw?: unknown;
 };

package/dist/gateway/channels/botcord.js

@@ -838,11 +838,12 @@ function normalizeBlockForHub(block, seq) {
     const raw = (block?.raw ?? {});
     const kind = block?.kind ?? "other";
     const payload = {};
+    const withRaw = (out) => (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) {
@@ -856,9 +857,13 @@ function normalizeBlockForHub(block, seq) {
         }
         if (!text &&
             raw?.event === "item.delta" &&
-            raw?.payload?.payload?.kind === "agent_message" &&
-            typeof raw?.payload?.payload?.delta === "string") {
-            text = raw.payload.payload.delta;
+            (raw?.payload?.kind === "agent_message" || raw?.payload?.payload?.kind === "agent_message")) {
+            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 } };
     }
@@ -876,7 +881,7 @@ function normalizeBlockForHub(block, seq) {
             if (call.status)
                 payload.status = call.status;
         }
-        return { kind: "tool_call", seq, payload };
+        return withRaw({ kind: "tool_call", seq, payload });
     }
     if (kind === "tool_result") {
         const result = extractToolResult(raw);
@@ -887,7 +892,7 @@ function normalizeBlockForHub(block, seq) {
             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") {
         if (typeof raw?.subtype === "string")
@@ -897,7 +902,7 @@ function normalizeBlockForHub(block, seq) {
         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") {
         // Daemon-synthesized lifecycle marker. `raw` carries `{ phase, label?, source? }`
@@ -911,7 +916,7 @@ function normalizeBlockForHub(block, seq) {
         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.
     if (isTerminalRuntimeBlock(raw)) {
@@ -921,7 +926,7 @@ function normalizeBlockForHub(block, seq) {
         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")
@@ -931,7 +936,7 @@ function normalizeBlockForHub(block, seq) {
         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) {
     const event = typeof raw?.event === "string" ? raw.event : undefined;
@@ -1048,22 +1053,36 @@ function extractDeepseekToolCall(raw) {
             status: stringField(payload, "status") ?? stringField(tool, "status"),
         };
     }
-    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,
+                item?.arguments) ?? detailParams ?? tool ?? item,
             id: stringField(tool, "id") ?? stringField(inner, "id") ?? stringField(item, "id"),
             status: stringField(tool, "status") ?? stringField(inner, "status") ?? stringField(item, "status"),
         };
@@ -1082,8 +1101,15 @@ function extractDeepseekToolResult(raw) {
             id: stringField(payload, "id"),
         };
     }
-    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 ??
             item?.result ??
@@ -1097,7 +1123,10 @@ function extractDeepseekToolResult(raw) {
             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"),
         };
@@ -1112,7 +1141,12 @@ function formatBlockDetails(raw) {
         : 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;
     const contentText = extractContentText(r.content ?? r.message?.content ?? r.params?.update?.content);
@@ -1212,6 +1246,17 @@ function parseMaybeJson(value) {
         return value;
     }
 }
+function inferDeepseekToolName(item) {
+    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) {
     return !!value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
 }

package/dist/gateway/channels/login-session.d.ts

@@ -60,6 +60,18 @@ export declare class LoginSessionStore {
     create(input: Omit<LoginSession, "expiresAt"> & {
         expiresAt?: number;
     }): LoginSession;
+    /**
+     * 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;
+    };
     /** Get a non-expired session by id, or `null` when missing/expired. */
     get(loginId: string): LoginSession | null;
     /**