@botcord/daemon 0.2.49 → 0.2.50

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

@@ -0,0 +1,174 @@
+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) {
+  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",
+  });
+}
+
+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("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/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,