@botcord/daemon 0.2.49 → 0.2.51

package/dist/gateway/channels/botcord.js

@@ -768,6 +768,8 @@ function normalizeBlockForHub(block, seq) {
     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}}}
         let text = "";
         const contents = Array.isArray(raw?.message?.content) ? raw.message.content : [];
         for (const c of contents) {
@@ -776,6 +778,15 @@ function normalizeBlockForHub(block, seq) {
         }
         if (!text && typeof raw?.item?.text === "string")
             text = raw.item.text;
+        if (!text && raw?.event === "message.delta" && typeof raw?.payload?.content === "string") {
+            text = raw.payload.content;
+        }
+        if (!text &&
+            raw?.event === "item.delta" &&
+            raw?.payload?.payload?.kind === "agent_message" &&
+            typeof raw?.payload?.payload?.delta === "string") {
+            text = raw.payload.payload.delta;
+        }
         return { kind: "assistant", seq, payload: { text } };
     }
     if (kind === "tool_use") {

package/dist/gateway/dispatcher.js

@@ -24,6 +24,13 @@ const MAX_BATCH_BUFFER_CHARS = 16000;
  * cancel-previous bursts on a fast user can otherwise trip 429 silently.
  */
 const TYPING_DEBOUNCE_MS = 2000;
+/**
+ * Most provider typing APIs are short-lived one-shots. Telegram's
+ * `sendChatAction(typing)`, for example, must be refreshed while the runtime
+ * is still working or the visible typing indicator disappears before the
+ * reply lands.
+ */
+const TYPING_REFRESH_MS = 4000;
 /** LRU cap on the typing-recency map so long-running daemons don't grow unbounded. */
 const TYPING_RECENCY_CAP = 1024;
 /**
@@ -591,7 +598,9 @@ export class Dispatcher {
         const trustLevel = route.trustLevel ?? "trusted";
         const streamable = msg.trace?.streamable === true;
         const traceId = msg.trace?.id;
-        const canType = streamable && typeof traceId === "string" && typeof channel.typing === "function";
+        const canType = typeof traceId === "string" &&
+            typeof channel.typing === "function" &&
+            (streamable || !isBotCordChannel(channel));
         const canStream = streamable && typeof traceId === "string" && typeof channel.streamBlock === "function";
         const recordBlock = (block) => {
             const summary = { type: block.kind };
@@ -611,7 +620,8 @@ export class Dispatcher {
         // arrival), and `thinking` is auto-synthesized on the first non-assistant
         // block so adapters that emit nothing-but-blocks still drive the
         // "Thinking..." UI.
-        let typingFired = false;
+        let typingLoopStarted = false;
+        let typingRefreshTimer = null;
         let thinkingActive = false;
         /**
          * Sticky: once we've forwarded any assistant_text to the wire, we stop
@@ -670,10 +680,9 @@ export class Dispatcher {
             // actually emitted, not daemon-synthesized lifecycle frames.
             forwardBlockToChannel(synth);
         };
-        const fireTypingIfNeeded = () => {
-            if (!canType || typingFired)
+        const sendTypingPing = () => {
+            if (!canType)
                 return;
-            typingFired = true;
             const key = `${msg.accountId}:${msg.conversation.id}`;
             const now = Date.now();
             const last = this.recentTypingPings.get(key);
@@ -719,7 +728,22 @@ export class Dispatcher {
                 });
             }
         };
-        const onStatus = canStream
+        const fireTypingIfNeeded = () => {
+            if (!canType || typingLoopStarted)
+                return;
+            typingLoopStarted = true;
+            sendTypingPing();
+            typingRefreshTimer = setInterval(sendTypingPing, TYPING_REFRESH_MS);
+            if (typeof typingRefreshTimer.unref === "function")
+                typingRefreshTimer.unref();
+        };
+        const stopTypingRefresh = () => {
+            if (!typingRefreshTimer)
+                return;
+            clearInterval(typingRefreshTimer);
+            typingRefreshTimer = null;
+        };
+        const onStatus = canType || canStream
             ? (event) => {
                 // Drop runtime callbacks after this turn's controller aborts —
                 // NDJSON/ACP adapters keep parsing stdout until the child exits
@@ -1123,6 +1147,7 @@ export class Dispatcher {
             });
         }
         finally {
+            stopTypingRefresh();
             // Emit a final thinking.stopped on terminal paths so the frontend
             // never sticks at "Thinking..." when no assistant_text ever landed
             // (timeout, error, gated reply). Skipped on cancel-previous: the

package/dist/gateway/index.d.ts

@@ -12,6 +12,8 @@ export { createTranscriptWriter, resolveTranscriptEnabled, defaultTranscriptRoot
 export { safePathSegment, transcriptFilePath, transcriptRoomDir, transcriptAgentRoot, } from "./transcript-paths.js";
 export { ClaudeCodeAdapter, probeClaude, resolveClaudeCommand, } from "./runtimes/claude-code.js";
 export { CodexAdapter, probeCodex, resolveCodexCommand } from "./runtimes/codex.js";
+export { DeepseekTuiAdapter, probeDeepseekTui, resolveDeepseekCommand, } from "./runtimes/deepseek-tui.js";
+export { KimiAdapter, probeKimi, resolveKimiCommand } from "./runtimes/kimi.js";
 export { GeminiAdapter, probeGemini, resolveGeminiCommand } from "./runtimes/gemini.js";
 export { NdjsonStreamAdapter, type NdjsonEventCtx, type NdjsonRunState, } from "./runtimes/ndjson-stream.js";
 export { firstExistingPath, readCommandVersion, resolveCommandOnPath, resolveHomePath, type ProbeDeps, } from "./runtimes/probe.js";

package/dist/gateway/index.js

@@ -12,6 +12,8 @@ export { createTranscriptWriter, resolveTranscriptEnabled, defaultTranscriptRoot
 export { safePathSegment, transcriptFilePath, transcriptRoomDir, transcriptAgentRoot, } from "./transcript-paths.js";
 export { ClaudeCodeAdapter, probeClaude, resolveClaudeCommand, } from "./runtimes/claude-code.js";
 export { CodexAdapter, probeCodex, resolveCodexCommand } from "./runtimes/codex.js";
+export { DeepseekTuiAdapter, probeDeepseekTui, resolveDeepseekCommand, } from "./runtimes/deepseek-tui.js";
+export { KimiAdapter, probeKimi, resolveKimiCommand } from "./runtimes/kimi.js";
 export { GeminiAdapter, probeGemini, resolveGeminiCommand } from "./runtimes/gemini.js";
 export { NdjsonStreamAdapter, } from "./runtimes/ndjson-stream.js";
 export { firstExistingPath, readCommandVersion, resolveCommandOnPath, resolveHomePath, } from "./runtimes/probe.js";

package/dist/gateway/runtimes/deepseek-tui.d.ts

@@ -0,0 +1,44 @@
+import { spawn } from "node:child_process";
+import { type ProbeDeps } from "./probe.js";
+import type { RuntimeAdapter, RuntimeProbeResult, RuntimeRunOptions, RuntimeRunResult } from "../types.js";
+interface DeepseekAdapterDeps {
+    binary?: string;
+    /** Test seam: use an already-running compatible server instead of spawning `deepseek`. */
+    serverUrl?: string;
+    authToken?: string;
+    fetchFn?: typeof fetch;
+    spawnFn?: typeof spawn;
+}
+/** Resolve the `deepseek` dispatcher CLI on PATH. */
+export declare function resolveDeepseekCommand(deps?: ProbeDeps): string | null;
+/** Probe whether DeepSeek TUI is installed and report its version. */
+export declare function probeDeepseekTui(deps?: ProbeDeps): RuntimeProbeResult;
+/**
+ * DeepSeek TUI adapter.
+ *
+ * Drives the headless runtime API exposed by `deepseek serve --http`, not the
+ * interactive TUI and not ACP. The HTTP/SSE API is the documented complete
+ * runtime surface; ACP is currently a conservative editor baseline.
+ */
+export declare class DeepseekTuiAdapter implements RuntimeAdapter {
+    readonly id: "deepseek-tui";
+    private readonly explicitBinary;
+    private readonly explicitServerUrl;
+    private readonly explicitAuthToken;
+    private readonly fetchFn;
+    private readonly spawnFn;
+    private resolvedBinary;
+    constructor(deps?: DeepseekAdapterDeps);
+    probe(): RuntimeProbeResult;
+    run(opts: RuntimeRunOptions): Promise<RuntimeRunResult>;
+    private resolveBinary;
+    private acquireHandle;
+    private spawnEnv;
+    private createThread;
+    private patchThreadSystemContext;
+    private startTurnAndReadEvents;
+    private readEvents;
+    private requestJson;
+}
+export declare function __resetDeepseekTuiPoolForTests(): void;
+export {};