@botcord/daemon 0.2.50 → 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/runtimes/kimi.d.ts

@@ -8,7 +8,7 @@ export declare function probeKimi(deps?: ProbeDeps): RuntimeProbeResult;
 /**
  * Kimi CLI adapter — spawns:
  *
- *   kimi --work-dir <cwd> --print --output-format stream-json --session <sid> --prompt <text>
+ *   kimi --work-dir <cwd> --print --output-format stream-json --session <sid> --afk --prompt <text>
  *
  * `--session <sid>` resumes an existing session or creates a new session with
  * that id, so the adapter generates a UUID on first turn and persists it for

package/dist/gateway/runtimes/kimi.js

@@ -17,6 +17,108 @@ function isValidKimiSessionId(sessionId) {
 function invalidKimiSessionIdError() {
     return "kimi-cli: invalid sessionId (expected non-control text not starting with '-')";
 }
+const KIMI_EXTRA_FLAGS_WITH_VALUE = new Set([
+    "--add-dir",
+    "--agent",
+    "--agent-file",
+    "--config",
+    "--config-file",
+    "--max-ralph-iterations",
+    "--max-retries-per-step",
+    "--max-steps-per-turn",
+    "--mcp-config",
+    "--mcp-config-file",
+    "--model",
+    "--skills-dir",
+    "-m",
+]);
+const KIMI_EXTRA_BOOLEAN_FLAGS = new Set([
+    "--afk",
+    "--auto-approve",
+    "--debug",
+    "--no-thinking",
+    "--plan",
+    "--thinking",
+    "--verbose",
+    "--yes",
+    "--yolo",
+    "-y",
+]);
+// Flags owned by the adapter because BotCord depends on Kimi's non-interactive
+// stream-json contract, cwd isolation, prompt placement, and session routing.
+const KIMI_ADAPTER_OWNED_FLAGS = new Set([
+    "--acp",
+    "--command",
+    "--continue",
+    "--final-message-only",
+    "--help",
+    "--input-format",
+    "--output-format",
+    "--print",
+    "--prompt",
+    "--quiet",
+    "--resume",
+    "--session",
+    "--version",
+    "--wire",
+    "--work-dir",
+    "-C",
+    "-S",
+    "-V",
+    "-c",
+    "-h",
+    "-p",
+    "-r",
+    "-w",
+]);
+function flagName(arg) {
+    if (!arg.startsWith("-"))
+        return arg;
+    const eq = arg.indexOf("=");
+    return eq === -1 ? arg : arg.slice(0, eq);
+}
+function nextValue(args, index) {
+    const next = args[index + 1];
+    if (typeof next !== "string")
+        return undefined;
+    if (!next.startsWith("-"))
+        return next;
+    return /^-\d/.test(next) ? next : undefined;
+}
+function sanitizeKimiExtraArgs(extraArgs) {
+    if (!extraArgs?.length)
+        return [];
+    const out = [];
+    for (let i = 0; i < extraArgs.length; i += 1) {
+        const arg = extraArgs[i];
+        const name = flagName(arg);
+        if (KIMI_ADAPTER_OWNED_FLAGS.has(name)) {
+            if (!arg.includes("=") && nextValue(extraArgs, i) !== undefined)
+                i += 1;
+            continue;
+        }
+        if (KIMI_EXTRA_FLAGS_WITH_VALUE.has(name)) {
+            if (arg.includes("=")) {
+                out.push(arg);
+                continue;
+            }
+            const value = nextValue(extraArgs, i);
+            if (value !== undefined) {
+                out.push(arg, value);
+                i += 1;
+            }
+            continue;
+        }
+        if (KIMI_EXTRA_BOOLEAN_FLAGS.has(name)) {
+            out.push(arg);
+            continue;
+        }
+        if (arg.startsWith("-") && !arg.includes("=") && nextValue(extraArgs, i) !== undefined) {
+            i += 1;
+        }
+    }
+    return out;
+}
 /** Resolve the Kimi CLI executable on PATH. */
 export function resolveKimiCommand(deps = {}) {
     return resolveCommandOnPath("kimi", deps);
@@ -35,7 +137,7 @@ export function probeKimi(deps = {}) {
 /**
  * Kimi CLI adapter — spawns:
  *
- *   kimi --work-dir <cwd> --print --output-format stream-json --session <sid> --prompt <text>
+ *   kimi --work-dir <cwd> --print --output-format stream-json --session <sid> --afk --prompt <text>
  *
  * `--session <sid>` resumes an existing session or creates a new session with
  * that id, so the adapter generates a UUID on first turn and persists it for
@@ -83,8 +185,7 @@ export class KimiAdapter extends NdjsonStreamAdapter {
             sessionId,
             "--afk",
         ];
-        if (opts.extraArgs?.length)
-            args.push(...opts.extraArgs);
+        args.push(...sanitizeKimiExtraArgs(opts.extraArgs));
         args.push("--prompt", promptWithSystemContext(opts.text, opts.systemContext));
         return args;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.50",
+  "version": "0.2.51",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {

package/src/gateway/__tests__/botcord-channel.test.ts

@@ -618,6 +618,92 @@ describe("createBotCordChannel — streamBlock()", () => {
     }
   });
 
+  it("normalizes DeepSeek message.delta assistant text", async () => {
+    const fetchSpy = vi.fn().mockResolvedValue(new Response(null, { status: 204 }));
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = fetchSpy as unknown as typeof fetch;
+    try {
+      const client = makeClient({
+        getHubUrl: vi.fn().mockReturnValue("https://hub.example.com"),
+      });
+      const channel = createBotCordChannel({
+        id: "botcord-main",
+        accountId: "ag_self",
+        agentId: "ag_self",
+        client,
+        hubBaseUrl: "https://hub.example.com",
+      });
+      await channel.streamBlock!({
+        traceId: "m_trace",
+        accountId: "ag_self",
+        conversationId: "rm_oc_1",
+        block: {
+          kind: "assistant_text",
+          seq: 4,
+          raw: {
+            event: "message.delta",
+            payload: { thread_id: "thr_1", turn_id: "turn_1", content: "hello " },
+          },
+        },
+        log: silentLog,
+      });
+      const [, init] = fetchSpy.mock.calls[0];
+      const body = JSON.parse(init.body as string);
+      expect(body.block).toEqual({
+        kind: "assistant",
+        seq: 4,
+        payload: { text: "hello " },
+      });
+    } finally {
+      globalThis.fetch = realFetch;
+    }
+  });
+
+  it("normalizes DeepSeek item.delta assistant text", async () => {
+    const fetchSpy = vi.fn().mockResolvedValue(new Response(null, { status: 204 }));
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = fetchSpy as unknown as typeof fetch;
+    try {
+      const client = makeClient({
+        getHubUrl: vi.fn().mockReturnValue("https://hub.example.com"),
+      });
+      const channel = createBotCordChannel({
+        id: "botcord-main",
+        accountId: "ag_self",
+        agentId: "ag_self",
+        client,
+        hubBaseUrl: "https://hub.example.com",
+      });
+      await channel.streamBlock!({
+        traceId: "m_trace",
+        accountId: "ag_self",
+        conversationId: "rm_oc_1",
+        block: {
+          kind: "assistant_text",
+          seq: 5,
+          raw: {
+            event: "item.delta",
+            payload: {
+              thread_id: "thr_1",
+              turn_id: "turn_1",
+              payload: { kind: "agent_message", delta: "deepseek" },
+            },
+          },
+        },
+        log: silentLog,
+      });
+      const [, init] = fetchSpy.mock.calls[0];
+      const body = JSON.parse(init.body as string);
+      expect(body.block).toEqual({
+        kind: "assistant",
+        seq: 5,
+        payload: { text: "deepseek" },
+      });
+    } finally {
+      globalThis.fetch = realFetch;
+    }
+  });
+
   it("normalizes a thinking block with phase/label/source payload", async () => {
     const fetchSpy = vi.fn().mockResolvedValue(new Response(null, { status: 204 }));
     const realFetch = globalThis.fetch;

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

@@ -18,7 +18,7 @@ afterAll(() => {
   rmSync(tmpRoot, { recursive: true, force: true });
 });
 
-function runAdapter(script: string, sessionId: string | null = null) {
+function runAdapter(script: string, sessionId: string | null = null, extraArgs?: string[]) {
   const adapter = new KimiAdapter({ binary: script });
   const ctrl = new AbortController();
   return adapter.run({
@@ -28,6 +28,7 @@ function runAdapter(script: string, sessionId: string | null = null) {
     cwd: tmpRoot,
     signal: ctrl.signal,
     trustLevel: "owner",
+    extraArgs,
   });
 }
 
@@ -69,6 +70,89 @@ process.stdout.write(JSON.stringify({role:"assistant", content:JSON.stringify(ar
     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",

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/runtimes/kimi.ts

@@ -22,6 +22,113 @@ function invalidKimiSessionIdError(): string {
   return "kimi-cli: invalid sessionId (expected non-control text not starting with '-')";
 }
 
+const KIMI_EXTRA_FLAGS_WITH_VALUE = new Set([
+  "--add-dir",
+  "--agent",
+  "--agent-file",
+  "--config",
+  "--config-file",
+  "--max-ralph-iterations",
+  "--max-retries-per-step",
+  "--max-steps-per-turn",
+  "--mcp-config",
+  "--mcp-config-file",
+  "--model",
+  "--skills-dir",
+  "-m",
+]);
+
+const KIMI_EXTRA_BOOLEAN_FLAGS = new Set([
+  "--afk",
+  "--auto-approve",
+  "--debug",
+  "--no-thinking",
+  "--plan",
+  "--thinking",
+  "--verbose",
+  "--yes",
+  "--yolo",
+  "-y",
+]);
+
+// Flags owned by the adapter because BotCord depends on Kimi's non-interactive
+// stream-json contract, cwd isolation, prompt placement, and session routing.
+const KIMI_ADAPTER_OWNED_FLAGS = new Set([
+  "--acp",
+  "--command",
+  "--continue",
+  "--final-message-only",
+  "--help",
+  "--input-format",
+  "--output-format",
+  "--print",
+  "--prompt",
+  "--quiet",
+  "--resume",
+  "--session",
+  "--version",
+  "--wire",
+  "--work-dir",
+  "-C",
+  "-S",
+  "-V",
+  "-c",
+  "-h",
+  "-p",
+  "-r",
+  "-w",
+]);
+
+function flagName(arg: string): string {
+  if (!arg.startsWith("-")) return arg;
+  const eq = arg.indexOf("=");
+  return eq === -1 ? arg : arg.slice(0, eq);
+}
+
+function nextValue(args: string[], index: number): string | undefined {
+  const next = args[index + 1];
+  if (typeof next !== "string") return undefined;
+  if (!next.startsWith("-")) return next;
+  return /^-\d/.test(next) ? next : undefined;
+}
+
+function sanitizeKimiExtraArgs(extraArgs: string[] | undefined): string[] {
+  if (!extraArgs?.length) return [];
+  const out: string[] = [];
+  for (let i = 0; i < extraArgs.length; i += 1) {
+    const arg = extraArgs[i];
+    const name = flagName(arg);
+
+    if (KIMI_ADAPTER_OWNED_FLAGS.has(name)) {
+      if (!arg.includes("=") && nextValue(extraArgs, i) !== undefined) i += 1;
+      continue;
+    }
+
+    if (KIMI_EXTRA_FLAGS_WITH_VALUE.has(name)) {
+      if (arg.includes("=")) {
+        out.push(arg);
+        continue;
+      }
+      const value = nextValue(extraArgs, i);
+      if (value !== undefined) {
+        out.push(arg, value);
+        i += 1;
+      }
+      continue;
+    }
+
+    if (KIMI_EXTRA_BOOLEAN_FLAGS.has(name)) {
+      out.push(arg);
+      continue;
+    }
+
+    if (arg.startsWith("-") && !arg.includes("=") && nextValue(extraArgs, i) !== undefined) {
+      i += 1;
+    }
+  }
+  return out;
+}
+
 /** Resolve the Kimi CLI executable on PATH. */
 export function resolveKimiCommand(deps: ProbeDeps = {}): string | null {
   return resolveCommandOnPath("kimi", deps);
@@ -41,7 +148,7 @@ export function probeKimi(deps: ProbeDeps = {}): RuntimeProbeResult {
 /**
  * Kimi CLI adapter — spawns:
  *
- *   kimi --work-dir <cwd> --print --output-format stream-json --session <sid> --prompt <text>
+ *   kimi --work-dir <cwd> --print --output-format stream-json --session <sid> --afk --prompt <text>
  *
  * `--session <sid>` resumes an existing session or creates a new session with
  * that id, so the adapter generates a UUID on first turn and persists it for
@@ -93,7 +200,7 @@ export class KimiAdapter extends NdjsonStreamAdapter {
       sessionId,
       "--afk",
     ];
-    if (opts.extraArgs?.length) args.push(...opts.extraArgs);
+    args.push(...sanitizeKimiExtraArgs(opts.extraArgs));
     args.push("--prompt", promptWithSystemContext(opts.text, opts.systemContext));
     return args;
   }