@botcord/daemon 0.2.48 → 0.2.50

package/src/__tests__/turn-text.test.ts

@@ -57,6 +57,33 @@ describe("composeBotCordUserTurn", () => {
     expect(out).toContain("mentioned: true");
   });
 
+  it("renders structured room context outside the human message body", () => {
+    const out = composeBotCordUserTurn(
+      makeMessage({
+        sender: { id: "hu_alice", name: "Alice", kind: "user" },
+        text: "@Harry(ag_973dfb9193eb) 今天的AI日报发一下呢",
+        conversation: { id: "rm_news", kind: "group", title: "AI News Daily Brief" },
+        raw: {
+          room_id: "rm_news",
+          room_name: "AI News Daily Brief",
+          room_member_count: 6,
+          room_member_names: ["Alice", "Harry"],
+          my_role: "member",
+          my_can_send: true,
+          room_rule: "Post concise daily summaries.",
+        },
+      }),
+    );
+    const roomIdx = out.indexOf("[BotCord Room]");
+    const tagIdx = out.indexOf('<human-message sender="Alice" sender_kind="human">');
+    const closeIdx = out.indexOf("</human-message>");
+    expect(roomIdx).toBeGreaterThan(-1);
+    expect(roomIdx).toBeLessThan(tagIdx);
+    expect(out).toContain("[Room Rule] Post concise daily summaries.");
+    expect(out.slice(tagIdx, closeIdx)).not.toContain("[BotCord Room]");
+    expect(out.slice(tagIdx, closeIdx)).toContain("@Harry(ag_973dfb9193eb)");
+  });
+
   it("emits the direct-chat hint (not the group hint) for DM conversations", () => {
     const out = composeBotCordUserTurn(
       makeMessage({

package/src/daemon.ts

@@ -48,10 +48,11 @@ import { PolicyResolver } from "./gateway/policy-resolver.js";
 import { scanMention } from "./mention-scan.js";
 
 /**
- * Matches the 10-minute turn timeout the legacy daemon dispatcher used, so
- * long-running CLI turns behave the same way under the gateway core.
+ * Default hard cap for a single runtime turn. Long-running coding/research
+ * tasks routinely exceed 10 minutes, so daemon-hosted agents get a larger
+ * window before the dispatcher aborts the runtime.
  */
-const DEFAULT_TURN_TIMEOUT_MS = 10 * 60 * 1000;
+const DEFAULT_TURN_TIMEOUT_MS = 30 * 60 * 1000;
 
 /**
  * Default cadence for writing `gateway.snapshot()` to disk. Override via

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

@@ -0,0 +1,212 @@
+import { afterAll, describe, expect, it } from "vitest";
+import http, { type ServerResponse } from "node:http";
+import { mkdtempSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { DeepseekTuiAdapter } from "../runtimes/deepseek-tui.js";
+
+const tmpRoot = mkdtempSync(path.join(os.tmpdir(), "gateway-deepseek-tui-"));
+
+afterAll(() => {
+  rmSync(tmpRoot, { recursive: true, force: true });
+});
+
+function sse(event: string, data: unknown): string {
+  return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+
+async function startMockDeepseekServer(opts?: {
+  token?: string;
+  threadId?: string;
+  turnId?: string;
+  events?: Array<{ event: string; data: unknown }>;
+}) {
+  const token = opts?.token ?? "test-token";
+  const threadId = opts?.threadId ?? "thr_test";
+  const turnId = opts?.turnId ?? "turn_test";
+  const events =
+    opts?.events ??
+    [
+      { event: "turn.started", data: { thread_id: threadId, turn_id: turnId } },
+      { event: "tool.started", data: { id: "tool_1", name: "shell", input: { command: "pwd" } } },
+      { event: "tool.completed", data: { id: "tool_1", success: true, output: "/tmp" } },
+      { event: "message.delta", data: { thread_id: threadId, turn_id: turnId, content: "hello " } },
+      { event: "message.delta", data: { thread_id: threadId, turn_id: turnId, content: "deepseek" } },
+      { event: "turn.completed", data: { thread_id: threadId, turn_id: turnId, usage: {} } },
+    ];
+
+  const calls: Array<{ method: string; url: string; body?: any; auth?: string }> = [];
+  let eventRes: ServerResponse | null = null;
+
+  const server = http.createServer((req, res) => {
+    const chunks: Buffer[] = [];
+    req.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+    req.on("end", () => {
+      const rawBody = Buffer.concat(chunks).toString("utf8");
+      const body = rawBody ? JSON.parse(rawBody) : undefined;
+      calls.push({
+        method: req.method ?? "",
+        url: req.url ?? "",
+        body,
+        auth: req.headers.authorization,
+      });
+
+      if (req.url === "/health") {
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ status: "ok" }));
+        return;
+      }
+      if (req.headers.authorization !== `Bearer ${token}`) {
+        res.writeHead(401, { "content-type": "application/json" });
+        res.end(JSON.stringify({ error: "unauthorized" }));
+        return;
+      }
+      if (req.method === "POST" && req.url === "/v1/threads") {
+        res.writeHead(201, { "content-type": "application/json" });
+        res.end(JSON.stringify({ id: threadId }));
+        return;
+      }
+      if (req.method === "PATCH" && req.url === `/v1/threads/${threadId}`) {
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ id: threadId }));
+        return;
+      }
+      if (req.method === "GET" && req.url === `/v1/threads/${threadId}/events?since_seq=0`) {
+        res.writeHead(200, {
+          "content-type": "text/event-stream",
+          "cache-control": "no-cache",
+          connection: "keep-alive",
+        });
+        eventRes = res;
+        return;
+      }
+      if (req.method === "POST" && req.url === `/v1/threads/${threadId}/turns`) {
+        res.writeHead(201, { "content-type": "application/json" });
+        res.end(JSON.stringify({ thread: { id: threadId }, turn: { id: turnId } }));
+        setTimeout(() => {
+          for (const ev of events) eventRes?.write(sse(ev.event, ev.data));
+          eventRes?.end();
+        }, 5);
+        return;
+      }
+      res.writeHead(404, { "content-type": "application/json" });
+      res.end(JSON.stringify({ error: "not found" }));
+    });
+  });
+
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const addr = server.address();
+  if (!addr || typeof addr !== "object") throw new Error("server did not bind");
+  return {
+    baseUrl: `http://127.0.0.1:${addr.port}`,
+    token,
+    threadId,
+    calls,
+    close: () => new Promise<void>((resolve) => server.close(() => resolve())),
+  };
+}
+
+function runAdapter(serverUrl: string, authToken: string, sessionId: string | null = null) {
+  const adapter = new DeepseekTuiAdapter({ serverUrl, authToken });
+  const ctrl = new AbortController();
+  const blocks: string[] = [];
+  const status: Array<{ phase: string; label?: string }> = [];
+  const result = adapter.run({
+    text: "hi",
+    sessionId,
+    accountId: "ag_deepseek",
+    cwd: tmpRoot,
+    signal: ctrl.signal,
+    trustLevel: "owner",
+    systemContext: "runtime memory",
+    onBlock: (b) => blocks.push(b.kind),
+    onStatus: (e) => {
+      if (e.kind === "thinking") status.push({ phase: e.phase, label: e.label });
+    },
+  });
+  return { result, blocks, status };
+}
+
+describe("DeepseekTuiAdapter", () => {
+  it("creates a thread, starts a turn, parses SSE assistant text, and emits tool blocks", async () => {
+    const server = await startMockDeepseekServer();
+    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("tool_use");
+      expect(blocks).toContain("tool_result");
+      expect(blocks).toContain("assistant_text");
+      expect(status).toContainEqual({ phase: "started", label: "Thinking" });
+      expect(status).toContainEqual({ phase: "updated", label: "shell" });
+      expect(status.at(-1)).toEqual({ phase: "stopped", label: undefined });
+      expect(server.calls.find((c) => c.method === "POST" && c.url === "/v1/threads")?.body).toMatchObject({
+        workspace: tmpRoot,
+        system_prompt: "runtime memory",
+        auto_approve: true,
+      });
+    } 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 {
+      const { result } = runAdapter(server.baseUrl, server.token, "thr_existing");
+      const res = await result;
+      expect(res.newSessionId).toBe("thr_existing");
+      expect(server.calls.some((c) => c.method === "POST" && c.url === "/v1/threads")).toBe(false);
+      const patch = server.calls.find((c) => c.method === "PATCH");
+      expect(patch?.url).toBe("/v1/threads/thr_existing");
+      expect(patch?.body).toEqual({ system_prompt: "runtime memory" });
+    } finally {
+      await server.close();
+    }
+  });
+
+  it("clears stale session ids when DeepSeek reports the thread missing", async () => {
+    const server = await startMockDeepseekServer({ threadId: "thr_other" });
+    try {
+      const adapter = new DeepseekTuiAdapter({ serverUrl: server.baseUrl, authToken: server.token });
+      const ctrl = new AbortController();
+      const res = await adapter.run({
+        text: "hi",
+        sessionId: "thr_missing",
+        accountId: "ag_deepseek",
+        cwd: tmpRoot,
+        signal: ctrl.signal,
+        trustLevel: "owner",
+      });
+      expect(res.newSessionId).toBe("");
+      expect(res.error).toMatch(/HTTP 404/);
+    } finally {
+      await server.close();
+    }
+  });
+
+  it("returns a runtime error when DeepSeek completes the turn as failed", async () => {
+    const server = await startMockDeepseekServer({
+      events: [
+        { event: "turn.started", data: { thread_id: "thr_test", turn_id: "turn_test" } },
+        {
+          event: "turn.completed",
+          data: {
+            thread_id: "thr_test",
+            turn_id: "turn_test",
+            payload: { turn: { status: "failed", error: "missing api key" } },
+          },
+        },
+      ],
+    });
+    try {
+      const { result } = runAdapter(server.baseUrl, server.token);
+      const res = await result;
+      expect(res.text).toBe("");
+      expect(res.newSessionId).toBe("thr_test");
+      expect(res.error).toBe("missing api key");
+    } finally {
+      await server.close();
+    }
+  });
+});

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,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

@@ -28,7 +28,7 @@ import type {
   UserTurnBuilder,
 } from "./types.js";
 
-const DEFAULT_TURN_TIMEOUT_MS = 10 * 60 * 1000;
+const DEFAULT_TURN_TIMEOUT_MS = 30 * 60 * 1000;
 
 /**
  * Owner-chat room prefix. Reply-text gating: only rooms with this prefix get
@@ -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,