@botcord/daemon 0.2.49 → 0.2.51

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

@@ -27,6 +27,7 @@ function silentLogger(): GatewayLogger {
 
 interface FakeChannelOptions {
   id?: string;
+  type?: string;
   withStream?: boolean;
   withTyping?: boolean;
   sendImpl?: (ctx: ChannelSendContext) => Promise<ChannelSendResult> | ChannelSendResult;
@@ -36,7 +37,7 @@ interface FakeChannelOptions {
 
 class FakeChannel implements ChannelAdapter {
   readonly id: string;
-  readonly type = "fake";
+  readonly type: string;
   readonly sends: ChannelSendContext[] = [];
   readonly streams: ChannelStreamBlockContext[] = [];
   readonly typings: ChannelTypingContext[] = [];
@@ -48,6 +49,7 @@ class FakeChannel implements ChannelAdapter {
 
   constructor(opts: FakeChannelOptions = {}) {
     this.id = opts.id ?? "botcord";
+    this.type = opts.type ?? "fake";
     this.sendImpl = opts.sendImpl;
     this.streamImpl = opts.streamImpl;
     this.typingImpl = opts.typingImpl;
@@ -659,8 +661,21 @@ describe("Dispatcher", () => {
     expect(channel.sends.length).toBe(1);
   });
 
-  it("typing: not fired when streamable is false", async () => {
-    const channel = new FakeChannel();
+  it("typing: fires for non-BotCord channels even when streamable is false", async () => {
+    const channel = new FakeChannel({ id: "gw_provider", type: "telegram" });
+    const { dispatcher } = await scaffold({
+      channel,
+      runtimeFactory: () => new FakeRuntime({ reply: "ok", newSessionId: "sid" }),
+    });
+
+    await dispatcher.handle(
+      makeEnvelope({ channel: "gw_provider", trace: { id: "t1", streamable: false } }),
+    );
+    expect(channel.typings.length).toBe(1);
+  });
+
+  it("typing: not fired for BotCord rooms when streamable is false", async () => {
+    const channel = new FakeChannel({ type: "botcord" });
     const { dispatcher } = await scaffold({
       channel,
       runtimeFactory: () => new FakeRuntime({ reply: "ok", newSessionId: "sid" }),
@@ -672,6 +687,41 @@ describe("Dispatcher", () => {
     expect(channel.typings.length).toBe(0);
   });
 
+  it("typing: refreshes while a provider turn is still running", async () => {
+    vi.useFakeTimers();
+    try {
+      const channel = new FakeChannel({ id: "gw_tg", type: "telegram" });
+      const runtime = new FakeRuntime({ delayMs: 8500, reply: "ok", newSessionId: "sid" });
+      const { dispatcher } = await scaffold({ channel, runtimeFactory: () => runtime });
+
+      const pending = dispatcher.handle(
+        makeEnvelope({
+          channel: "gw_tg",
+          conversation: { id: "telegram:user:42", kind: "direct" },
+          trace: { id: "telegram:42:1", streamable: true },
+        }),
+      );
+
+      await vi.advanceTimersByTimeAsync(0);
+      expect(channel.typings.length).toBe(1);
+
+      await vi.advanceTimersByTimeAsync(4000);
+      expect(channel.typings.length).toBe(2);
+
+      await vi.advanceTimersByTimeAsync(4000);
+      expect(channel.typings.length).toBe(3);
+
+      await vi.advanceTimersByTimeAsync(500);
+      await pending;
+
+      await vi.advanceTimersByTimeAsync(4000);
+      expect(channel.typings.length).toBe(3);
+      expect(channel.sends.length).toBe(1);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
   it("typing: not fired when channel has no typing capability", async () => {
     const channel = new FakeChannel({ withTyping: false });
     const { dispatcher } = await scaffold({

package/src/gateway/__tests__/kimi-adapter.test.ts

@@ -0,0 +1,258 @@
+import { afterAll, describe, expect, it } from "vitest";
+import { mkdtempSync, rmSync, writeFileSync, chmodSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { KimiAdapter } from "../runtimes/kimi.js";
+import { createRuntime, envVarForRuntime, listRuntimeIds } from "../runtimes/registry.js";
+
+const tmpRoot = mkdtempSync(path.join(os.tmpdir(), "gateway-kimi-"));
+
+function makeScript(name: string, body: string): string {
+  const p = path.join(tmpRoot, name);
+  writeFileSync(p, `#!/usr/bin/env node\n${body}\n`, { mode: 0o755 });
+  chmodSync(p, 0o755);
+  return p;
+}
+
+afterAll(() => {
+  rmSync(tmpRoot, { recursive: true, force: true });
+});
+
+function runAdapter(script: string, sessionId: string | null = null, extraArgs?: string[]) {
+  const adapter = new KimiAdapter({ binary: script });
+  const ctrl = new AbortController();
+  return adapter.run({
+    text: "hi",
+    sessionId,
+    accountId: "ag_test",
+    cwd: tmpRoot,
+    signal: ctrl.signal,
+    trustLevel: "owner",
+    extraArgs,
+  });
+}
+
+describe("KimiAdapter", () => {
+  it("is registered as a runnable runtime", () => {
+    expect(listRuntimeIds()).toContain("kimi-cli");
+    expect(envVarForRuntime("kimi-cli")).toBe("BOTCORD_KIMI_CLI_BIN");
+    expect(createRuntime("kimi-cli")).toBeInstanceOf(KimiAdapter);
+  });
+
+  it("parses final assistant text and persists the generated --session id", async () => {
+    const script = makeScript(
+      "happy.js",
+      `
+process.stdout.write(JSON.stringify({role:"assistant", content:"hello from kimi"}) + "\\n");
+`,
+    );
+    const res = await runAdapter(script);
+    expect(res.newSessionId).toMatch(/^[0-9a-f-]{36}$/);
+    expect(res.text).toBe("hello from kimi");
+    expect(res.error).toBeUndefined();
+  });
+
+  it("passes an existing session id through --session", async () => {
+    const script = makeScript(
+      "resume-argv.js",
+      `
+const argv = process.argv.slice(2);
+process.stdout.write(JSON.stringify({role:"assistant", content:JSON.stringify(argv)}) + "\\n");
+`,
+    );
+    const res = await runAdapter(script, "sid-123");
+    const argv = JSON.parse(res.text) as string[];
+    const idx = argv.indexOf("--session");
+    expect(idx).toBeGreaterThanOrEqual(0);
+    expect(argv[idx + 1]).toBe("sid-123");
+    expect(argv).toContain("--print");
+    expect(argv).toContain("stream-json");
+    expect(argv).toContain("--afk");
+  });
+
+  it("drops non-Kimi inherited extraArgs and their values", async () => {
+    const script = makeScript(
+      "filter-foreign-argv.js",
+      `
+const argv = process.argv.slice(2);
+process.stdout.write(JSON.stringify({role:"assistant", content:JSON.stringify(argv)}) + "\\n");
+`,
+    );
+    const res = await runAdapter(script, "sid-123", [
+      "--permission-mode",
+      "bypassPermissions",
+      "--model",
+      "kimi-k2",
+    ]);
+    const argv = JSON.parse(res.text) as string[];
+    expect(argv).not.toContain("--permission-mode");
+    expect(argv).not.toContain("bypassPermissions");
+    expect(argv).toContain("--model");
+    expect(argv[argv.indexOf("--model") + 1]).toBe("kimi-k2");
+  });
+
+  it("preserves Kimi value flags with negative numeric values", async () => {
+    const script = makeScript(
+      "negative-value-argv.js",
+      `
+const argv = process.argv.slice(2);
+process.stdout.write(JSON.stringify({role:"assistant", content:JSON.stringify(argv)}) + "\\n");
+`,
+    );
+    const res = await runAdapter(script, "sid-123", [
+      "--max-ralph-iterations",
+      "-1",
+      "--max-steps-per-turn=3",
+    ]);
+    const argv = JSON.parse(res.text) as string[];
+    expect(argv).toContain("--max-ralph-iterations");
+    expect(argv[argv.indexOf("--max-ralph-iterations") + 1]).toBe("-1");
+    expect(argv).toContain("--max-steps-per-turn=3");
+  });
+
+  it("drops incomplete Kimi value flags instead of passing invalid argv", async () => {
+    const script = makeScript(
+      "incomplete-value-argv.js",
+      `
+const argv = process.argv.slice(2);
+process.stdout.write(JSON.stringify({role:"assistant", content:JSON.stringify(argv)}) + "\\n");
+`,
+    );
+    const res = await runAdapter(script, "sid-123", ["--model", "--plan"]);
+    const argv = JSON.parse(res.text) as string[];
+    expect(argv).not.toContain("--model");
+    expect(argv).toContain("--plan");
+  });
+
+  it("does not let extraArgs override adapter-owned stream/session/prompt flags", async () => {
+    const script = makeScript(
+      "filter-owned-argv.js",
+      `
+const argv = process.argv.slice(2);
+process.stdout.write(JSON.stringify({role:"assistant", content:JSON.stringify(argv)}) + "\\n");
+`,
+    );
+    const res = await runAdapter(script, "real-session", [
+      "--output-format",
+      "text",
+      "--session",
+      "evil-session",
+      "--prompt",
+      "evil prompt",
+      "--plan",
+    ]);
+    const argv = JSON.parse(res.text) as string[];
+    expect(argv.filter((a) => a === "--output-format")).toHaveLength(1);
+    expect(argv[argv.indexOf("--output-format") + 1]).toBe("stream-json");
+    expect(argv.filter((a) => a === "--session")).toHaveLength(1);
+    expect(argv[argv.indexOf("--session") + 1]).toBe("real-session");
+    expect(argv.filter((a) => a === "--prompt")).toHaveLength(1);
+    expect(argv[argv.indexOf("--prompt") + 1]).toBe("hi");
+    expect(argv).toContain("--plan");
+    expect(argv).not.toContain("evil-session");
+    expect(argv).not.toContain("evil prompt");
+  });
+
+  it("rejects session ids that could be parsed as flags", async () => {
+    const script = makeScript(
+      "should-not-spawn.js",
+      `
+process.stdout.write(JSON.stringify({role:"assistant", content:"spawned"}) + "\\n");
+`,
+    );
+    const res = await runAdapter(script, "--bad");
+    expect(res.newSessionId).toBe("");
+    expect(res.text).toBe("");
+    expect(res.error).toMatch(/invalid sessionId/);
+  });
+
+  it("prefixes systemContext as a system-reminder in the prompt", async () => {
+    const script = makeScript(
+      "echo-prompt.js",
+      `
+const argv = process.argv.slice(2);
+const prompt = argv[argv.indexOf("--prompt") + 1];
+process.stdout.write(JSON.stringify({role:"assistant", content:prompt}) + "\\n");
+`,
+    );
+    const adapter = new KimiAdapter({ binary: script });
+    const ctrl = new AbortController();
+    const res = await adapter.run({
+      text: "do the thing",
+      sessionId: null,
+      accountId: "ag_test",
+      cwd: tmpRoot,
+      signal: ctrl.signal,
+      trustLevel: "owner",
+      systemContext: "MEMORY: remember X",
+    });
+    expect(res.text).toContain("<system-reminder>");
+    expect(res.text).toContain("MEMORY: remember X");
+    expect(res.text).toContain("do the thing");
+  });
+
+  it("recognizes tool_use and tool_result blocks", async () => {
+    const script = makeScript(
+      "tools.js",
+      `
+const lines = [
+  {role:"assistant", content:null, tool_calls:[{id:"tc1", function:{name:"Bash", arguments:"{}"}}]},
+  {role:"tool", tool_call_id:"tc1", content:"ok"},
+  {role:"assistant", content:[{type:"text", text:"done"}]},
+];
+for (const l of lines) process.stdout.write(JSON.stringify(l) + "\\n");
+`,
+    );
+    const adapter = new KimiAdapter({ binary: script });
+    const ctrl = new AbortController();
+    const seen: string[] = [];
+    const res = await adapter.run({
+      text: "x",
+      sessionId: null,
+      accountId: "ag_test",
+      cwd: tmpRoot,
+      signal: ctrl.signal,
+      trustLevel: "owner",
+      onBlock: (b) => seen.push(b.kind),
+    });
+    expect(res.text).toBe("done");
+    expect(seen).toContain("tool_use");
+    expect(seen).toContain("tool_result");
+    expect(seen).toContain("assistant_text");
+  });
+
+  it("emits thinking status for think, tool call, tool result, and final text", async () => {
+    const script = makeScript(
+      "thinkflow.js",
+      `
+const lines = [
+  {role:"assistant", content:[{type:"think", think:"working"}]},
+  {role:"assistant", content:null, tool_calls:[{id:"tc1", function:{name:"ReadFile", arguments:"{}"}}]},
+  {role:"tool", tool_call_id:"tc1", content:"ok"},
+  {role:"assistant", content:"done"},
+];
+for (const l of lines) process.stdout.write(JSON.stringify(l) + "\\n");
+`,
+    );
+    const adapter = new KimiAdapter({ binary: script });
+    const ctrl = new AbortController();
+    const status: Array<{ phase: string; label?: string }> = [];
+    await adapter.run({
+      text: "x",
+      sessionId: null,
+      accountId: "ag_test",
+      cwd: tmpRoot,
+      signal: ctrl.signal,
+      trustLevel: "owner",
+      onStatus: (e) => {
+        if (e.kind === "thinking") status.push({ phase: e.phase, label: e.label });
+      },
+    });
+    expect(status).toEqual([
+      { phase: "started", label: "Thinking" },
+      { phase: "updated", label: "ReadFile" },
+      { phase: "updated", label: "Tool result" },
+      { phase: "stopped", label: undefined },
+    ]);
+  });
+});

package/src/gateway/channels/botcord.ts

@@ -907,12 +907,25 @@ function normalizeBlockForHub(
   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) {
       if (c?.type === "text" && typeof c.text === "string") text += c.text;
     }
     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 } };
   }
 

package/src/gateway/dispatcher.ts

@@ -55,6 +55,14 @@ const MAX_BATCH_BUFFER_CHARS = 16000;
  */
 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;
 
@@ -804,7 +812,9 @@ export class Dispatcher {
     const streamable = msg.trace?.streamable === true;
     const traceId = msg.trace?.id;
     const canType =
-      streamable && typeof traceId === "string" && typeof channel.typing === "function";
+      typeof traceId === "string" &&
+      typeof channel.typing === "function" &&
+      (streamable || !isBotCordChannel(channel));
     const canStream =
       streamable && typeof traceId === "string" && typeof channel.streamBlock === "function";
     const recordBlock = (block: StreamBlock): void => {
@@ -824,7 +834,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: NodeJS.Timeout | null = null;
     let thinkingActive = false;
     /**
      * Sticky: once we've forwarded any assistant_text to the wire, we stop
@@ -887,9 +898,8 @@ export class Dispatcher {
       forwardBlockToChannel(synth);
     };
 
-    const fireTypingIfNeeded = (): void => {
-      if (!canType || typingFired) return;
-      typingFired = true;
+    const sendTypingPing = (): void => {
+      if (!canType) return;
       const key = `${msg.accountId}:${msg.conversation.id}`;
       const now = Date.now();
       const last = this.recentTypingPings.get(key);
@@ -934,7 +944,21 @@ export class Dispatcher {
       }
     };
 
-    const onStatus = canStream
+    const fireTypingIfNeeded = (): void => {
+      if (!canType || typingLoopStarted) return;
+      typingLoopStarted = true;
+      sendTypingPing();
+      typingRefreshTimer = setInterval(sendTypingPing, TYPING_REFRESH_MS);
+      if (typeof typingRefreshTimer.unref === "function") typingRefreshTimer.unref();
+    };
+
+    const stopTypingRefresh = (): void => {
+      if (!typingRefreshTimer) return;
+      clearInterval(typingRefreshTimer);
+      typingRefreshTimer = null;
+    };
+
+    const onStatus = canType || canStream
       ? (event: RuntimeStatusEvent) => {
           // Drop runtime callbacks after this turn's controller aborts —
           // NDJSON/ACP adapters keep parsing stdout until the child exits
@@ -1342,6 +1366,7 @@ export class Dispatcher {
         blocks: slot.blocks,
       });
     } 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/src/gateway/index.ts

@@ -39,6 +39,12 @@ export {
   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,