@botcord/daemon 0.2.76 → 0.2.78

package/dist/runtime-route-options.d.ts

@@ -0,0 +1,7 @@
+export interface RuntimeSelectionOptions {
+    runtimeModel?: string;
+    reasoningEffort?: string;
+    thinking?: boolean;
+}
+export declare function buildRuntimeSelectionExtraArgs(runtime: string | undefined, selection: RuntimeSelectionOptions): string[];
+export declare function mergeRuntimeExtraArgs(inherited: string[] | undefined, selected: string[]): string[] | undefined;

package/dist/runtime-route-options.js

@@ -0,0 +1,45 @@
+export function buildRuntimeSelectionExtraArgs(runtime, selection) {
+    if (!runtime)
+        return [];
+    const out = [];
+    const model = cleanString(selection.runtimeModel);
+    const reasoningEffort = cleanString(selection.reasoningEffort);
+    if (runtime === "claude-code") {
+        if (model)
+            out.push("--model", model);
+        if (reasoningEffort)
+            out.push("--effort", reasoningEffort);
+    }
+    else if (runtime === "codex") {
+        if (model)
+            out.push("--model", model);
+        if (reasoningEffort) {
+            out.push("-c", `model_reasoning_effort=${quoteCodexConfigValue(reasoningEffort)}`);
+        }
+    }
+    else if (runtime === "deepseek-tui") {
+        if (model)
+            out.push("--model", model);
+        if (reasoningEffort)
+            out.push("--reasoning-effort", reasoningEffort);
+    }
+    else if (runtime === "kimi-cli") {
+        if (model)
+            out.push("--model", model);
+        if (typeof selection.thinking === "boolean") {
+            out.push(selection.thinking ? "--thinking" : "--no-thinking");
+        }
+    }
+    return out;
+}
+export function mergeRuntimeExtraArgs(inherited, selected) {
+    const out = [...(inherited ?? []), ...selected];
+    return out.length ? out : undefined;
+}
+function cleanString(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function quoteCodexConfigValue(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/daemon",
-  "version": "0.2.76",
+  "version": "0.2.78",
   "description": "BotCord local daemon — bridges Hub inbox push to local Claude Code / Codex / Gemini CLIs",
   "type": "module",
   "bin": {
@@ -28,7 +28,7 @@
   },
   "dependencies": {
     "@botcord/cli": "^0.1.7",
-    "@botcord/protocol-core": "file:../protocol-core",
+    "@botcord/protocol-core": "^0.2.9",
     "@larksuiteoapi/node-sdk": "^1.63.1",
     "ws": "^8.20.1"
   },

package/src/__tests__/daemon-config-map.test.ts

@@ -416,6 +416,32 @@ describe("buildManagedRoutes", () => {
     expect(map.get("ag_one")?.extraArgs).not.toBe(withExtraArgs.extraArgs);
   });
 
+  it("appends per-agent model and reasoning selections to inherited extraArgs", () => {
+    const withExtraArgs: GatewayRoute = {
+      runtime: "codex",
+      cwd: "/home/default",
+      extraArgs: ["--skip-git-repo-check"],
+    };
+    const map = buildManagedRoutes(
+      ["ag_one"],
+      {
+        ag_one: {
+          runtime: "codex",
+          runtimeModel: "gpt-5.2",
+          reasoningEffort: "high",
+        },
+      },
+      withExtraArgs,
+    );
+    expect(map.get("ag_one")?.extraArgs).toEqual([
+      "--skip-git-repo-check",
+      "--model",
+      "gpt-5.2",
+      "-c",
+      'model_reasoning_effort="high"',
+    ]);
+  });
+
   it("omits extraArgs when defaultRoute has none", () => {
     const map = buildManagedRoutes(["ag_one"], {}, defaultRoute);
     expect(map.get("ag_one")).not.toHaveProperty("extraArgs");
@@ -492,4 +518,3 @@ describe("openclawGateways resolution", () => {
     expect(gw.managedRoutes).toEqual([]);
   });
 });
-

package/src/__tests__/provision.test.ts

@@ -660,6 +660,65 @@ describe("provision_agent handler writes runtime + cwd", () => {
     }
   });
 
+  it("persists model options and hot-adds them to the managed route", async () => {
+    const os = await import("node:os");
+    const fs = await import("node:fs");
+    const nodePath = await import("node:path");
+
+    const tmp = fs.mkdtempSync(nodePath.join(os.tmpdir(), "daemon-provision-"));
+    const prevHome = process.env.HOME;
+    process.env.HOME = tmp;
+    try {
+      mockState.cfg = {
+        defaultRoute: {
+          adapter: "codex",
+          cwd: tmp,
+          extraArgs: ["--skip-git-repo-check"],
+        },
+        routes: [],
+        streamBlocks: true,
+      };
+      const gw = makeFakeGateway();
+      const provisioner = createProvisioner({
+        gateway: gw as unknown as Parameters<typeof createProvisioner>[0]["gateway"],
+      });
+      const privateKey = Buffer.alloc(32, 8).toString("base64");
+
+      const ack = await provisioner({
+        id: "req_model",
+        type: CONTROL_FRAME_TYPES.PROVISION_AGENT,
+        params: {
+          runtime: "codex",
+          runtimeModel: "gpt-5.2",
+          reasoningEffort: "high",
+          credentials: {
+            agentId: "ag_model",
+            keyId: "k_model",
+            privateKey,
+            hubUrl: "https://hub.example",
+          },
+        },
+      });
+
+      expect(ack.ok).toBe(true);
+      const credFile = nodePath.join(tmp, ".botcord", "credentials", "ag_model.json");
+      const saved = JSON.parse(fs.readFileSync(credFile, "utf8")) as Record<string, unknown>;
+      expect(saved.runtimeModel).toBe("gpt-5.2");
+      expect(saved.reasoningEffort).toBe("high");
+      expect(gw.listManagedRoutes()[0].extraArgs).toEqual([
+        "--skip-git-repo-check",
+        "--model",
+        "gpt-5.2",
+        "-c",
+        'model_reasoning_effort="high"',
+      ]);
+    } finally {
+      if (prevHome === undefined) delete process.env.HOME;
+      else process.env.HOME = prevHome;
+      fs.rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
   it("rejects unknown runtime ids before touching disk", async () => {
     const gw = makeFakeGateway();
     const provisioner = createProvisioner({

package/src/__tests__/runtime-discovery.test.ts

@@ -76,15 +76,74 @@ describe("collectRuntimeSnapshot", () => {
       },
     ]);
     const snap = collectRuntimeSnapshot();
-    expect(snap.runtimes).toEqual([
-      {
-        id: "claude-code",
-        available: true,
-        version: "1.2.3",
-        path: "/usr/local/bin/claude",
-      },
-      { id: "codex", available: false },
-    ]);
+    expect(snap.runtimes[0]).toMatchObject({
+      id: "claude-code",
+      available: true,
+      version: "1.2.3",
+      path: "/usr/local/bin/claude",
+    });
+    const claudeModels = (snap.runtimes[0] as { models?: Array<{ id: string }> }).models;
+    expect(claudeModels?.map((m) => m.id)).toContain("sonnet");
+    expect(claudeModels?.map((m) => m.id)).toContain("opus");
+    expect(snap.runtimes[1]).toEqual({ id: "codex", available: false });
+  });
+
+  it("adds Kimi models from the local config file", () => {
+    const tmp = mkdtempSync(path.join(tmpdir(), "daemon-runtime-kimi-"));
+    const prevHome = process.env.HOME;
+    process.env.HOME = tmp;
+    try {
+      mkdirSync(path.join(tmp, ".kimi"), { recursive: true });
+      writeFileSync(
+        path.join(tmp, ".kimi", "config.toml"),
+        [
+          'default_model = "kimi-code/kimi-for-coding"',
+          "",
+          '[models."kimi-code/kimi-for-coding"]',
+          'provider = "managed:kimi-code"',
+          'model = "kimi-for-coding"',
+          "max_context_size = 262144",
+          'capabilities = ["thinking", "image_in"]',
+          'display_name = "Kimi-k2.6"',
+          "",
+        ].join("\n"),
+      );
+      setRuntimes([
+        {
+          id: "kimi-cli",
+          displayName: "Kimi",
+          binary: "kimi",
+          supportsRun: true,
+          result: { available: true },
+        },
+      ]);
+      const [runtime] = collectRuntimeSnapshot().runtimes;
+      expect((runtime as { models?: unknown[] }).models).toEqual([
+        {
+          id: "kimi-code/kimi-for-coding",
+          source: "config",
+          isDefault: true,
+          provider: "managed:kimi-code",
+          displayName: "Kimi-k2.6",
+          contextLength: 262144,
+          capabilities: ["thinking", "image_in"],
+          metadata: { model: "kimi-for-coding" },
+          parameters: [
+            {
+              id: "thinking",
+              displayName: "Thinking",
+              type: "boolean",
+              flag: "--thinking/--no-thinking",
+              source: "cli",
+            },
+          ],
+        },
+      ]);
+    } finally {
+      if (prevHome === undefined) delete process.env.HOME;
+      else process.env.HOME = prevHome;
+      rmSync(tmp, { recursive: true, force: true });
+    }
   });
 
   it("omits optional fields rather than emitting explicit undefineds", () => {

package/src/__tests__/runtime-models.test.ts

@@ -0,0 +1,333 @@
+import { describe, expect, it } from "vitest";
+import { mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import {
+  discoverRuntimeModelCatalog,
+  parseCodexModelCatalog,
+  parseDeepseekModelList,
+  parseKimiConfigModels,
+  parseKimiRuntimeParameters,
+} from "../runtime-models.js";
+
+describe("runtime model discovery parsers", () => {
+  it("parses visible Codex models and trims heavyweight catalog fields", () => {
+    const models = parseCodexModelCatalog(
+      JSON.stringify({
+        models: [
+          {
+            slug: "gpt-5.5",
+            display_name: "GPT-5.5",
+            visibility: "list",
+            supported_in_api: true,
+            default_reasoning_level: "medium",
+            supported_reasoning_levels: [{ effort: "low" }, { effort: "medium" }],
+            base_instructions: "large prompt text should not be copied into metadata",
+          },
+          {
+            slug: "internal-hidden",
+            display_name: "Internal",
+            visibility: "hide",
+          },
+        ],
+      }),
+    );
+
+    expect(models).toEqual([
+      {
+        id: "gpt-5.5",
+        displayName: "GPT-5.5",
+        provider: "openai",
+        source: "cli",
+        metadata: {
+          supportedInApi: true,
+          defaultReasoningLevel: "medium",
+          supportedReasoningLevels: ["low", "medium"],
+        },
+        parameters: [
+          {
+            id: "reasoning_effort",
+            displayName: "Reasoning effort",
+            type: "enum",
+            flag: "-c model_reasoning_effort=<value>",
+            values: ["low", "medium"],
+            defaultValue: "medium",
+            source: "cli",
+          },
+        ],
+      },
+    ]);
+  });
+
+  it("parses Codex CLI cache descriptions", () => {
+    expect(
+      parseCodexModelCatalog(
+        JSON.stringify({
+          models: [
+            {
+              slug: "gpt-cache",
+              description: "Cached GPT",
+              visibility: "list",
+              supported_in_api: true,
+            },
+          ],
+        }),
+      ),
+    ).toEqual([
+      {
+        id: "gpt-cache",
+        displayName: "Cached GPT",
+        provider: "openai",
+        source: "cli",
+        metadata: { supportedInApi: true },
+      },
+    ]);
+  });
+
+  it("uses the Codex CLI model cache when live discovery is unavailable", () => {
+    const tmp = mkdtempSync(path.join(tmpdir(), "daemon-codex-cache-"));
+    const prevHome = process.env.HOME;
+    const prevCodexHome = process.env.CODEX_HOME;
+    try {
+      const codexHome = path.join(tmp, "codex-home");
+      mkdirSync(codexHome, { recursive: true });
+      process.env.HOME = path.join(tmp, "home");
+      process.env.CODEX_HOME = codexHome;
+      writeFileSync(
+        path.join(codexHome, "models_cache.json"),
+        JSON.stringify({
+          models: [
+            {
+              slug: "gpt-cache",
+              description: "Cached GPT",
+              visibility: "list",
+            },
+          ],
+        }),
+      );
+
+      const catalog = discoverRuntimeModelCatalog({
+        id: "codex",
+        displayName: "Codex",
+        binary: "codex",
+        supportsRun: true,
+        result: { available: true, path: path.join(tmp, "missing-codex") },
+      });
+
+      expect(catalog.models).toEqual([
+        {
+          id: "gpt-cache",
+          displayName: "Cached GPT",
+          provider: "openai",
+          source: "cli",
+        },
+      ]);
+    } finally {
+      if (prevHome === undefined) delete process.env.HOME;
+      else process.env.HOME = prevHome;
+      if (prevCodexHome === undefined) delete process.env.CODEX_HOME;
+      else process.env.CODEX_HOME = prevCodexHome;
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
+  it("falls back to built-in Codex models and persists the runtime catalog cache", () => {
+    const tmp = mkdtempSync(path.join(tmpdir(), "daemon-runtime-catalog-"));
+    const prevHome = process.env.HOME;
+    const prevCodexHome = process.env.CODEX_HOME;
+    const prevCacheDir = process.env.BOTCORD_RUNTIME_CATALOG_CACHE_DIR;
+    try {
+      const codexHome = path.join(tmp, "codex-home");
+      const cacheDir = path.join(tmp, "catalog-cache");
+      mkdirSync(codexHome, { recursive: true });
+      process.env.HOME = path.join(tmp, "home");
+      process.env.CODEX_HOME = codexHome;
+      process.env.BOTCORD_RUNTIME_CATALOG_CACHE_DIR = cacheDir;
+
+      const catalog = discoverRuntimeModelCatalog({
+        id: "codex",
+        displayName: "Codex",
+        binary: "codex",
+        supportsRun: true,
+        result: { available: true, path: path.join(tmp, "missing-codex") },
+      });
+
+      expect(catalog.models?.map((m) => m.id)).toContain("gpt-5.2");
+      expect(readdirSync(cacheDir)).toEqual(["codex.json"]);
+      const payload = JSON.parse(readFileSync(path.join(cacheDir, "codex.json"), "utf8"));
+      expect(payload.runtimeId).toBe("codex");
+      expect(payload.catalog.models.map((m: { id: string }) => m.id)).toContain("gpt-5.2");
+    } finally {
+      if (prevHome === undefined) delete process.env.HOME;
+      else process.env.HOME = prevHome;
+      if (prevCodexHome === undefined) delete process.env.CODEX_HOME;
+      else process.env.CODEX_HOME = prevCodexHome;
+      if (prevCacheDir === undefined) delete process.env.BOTCORD_RUNTIME_CATALOG_CACHE_DIR;
+      else process.env.BOTCORD_RUNTIME_CATALOG_CACHE_DIR = prevCacheDir;
+      rmSync(tmp, { recursive: true, force: true });
+    }
+  });
+
+  it("parses DeepSeek model list output", () => {
+    expect(
+      parseDeepseekModelList(
+        [
+          "deepseek-v4-pro (deepseek)",
+          "gpt-4.1-mini (openai)",
+          "deepseek-coder:1.3b (ollama)",
+        ].join("\n"),
+      ),
+    ).toEqual([
+      {
+        id: "deepseek-v4-pro",
+        displayName: "deepseek-v4-pro",
+        provider: "deepseek",
+        source: "cli",
+      },
+      {
+        id: "gpt-4.1-mini",
+        displayName: "gpt-4.1-mini",
+        provider: "openai",
+        source: "cli",
+      },
+      {
+        id: "deepseek-coder:1.3b",
+        displayName: "deepseek-coder:1.3b",
+        provider: "ollama",
+        source: "cli",
+      },
+    ]);
+  });
+
+  it("parses Kimi models from config.toml", () => {
+    expect(
+      parseKimiConfigModels(
+        [
+          'default_model = "kimi-code/kimi-for-coding"',
+          "default_thinking = true",
+          "",
+          '[models."kimi-code/kimi-for-coding"]',
+          'provider = "managed:kimi-code"',
+          'model = "kimi-for-coding"',
+          "max_context_size = 262144",
+          'capabilities = ["thinking", "video_in", "image_in"]',
+          'display_name = "Kimi-k2.6"',
+        ].join("\n"),
+      ),
+    ).toEqual([
+      {
+        id: "kimi-code/kimi-for-coding",
+        source: "config",
+        isDefault: true,
+        provider: "managed:kimi-code",
+        displayName: "Kimi-k2.6",
+        contextLength: 262144,
+        capabilities: ["thinking", "video_in", "image_in"],
+        metadata: { model: "kimi-for-coding" },
+        parameters: [
+          {
+            id: "thinking",
+            displayName: "Thinking",
+            type: "boolean",
+            flag: "--thinking/--no-thinking",
+            defaultValue: true,
+            source: "config",
+          },
+        ],
+      },
+    ]);
+  });
+
+  it("parses Kimi runtime parameters from config.toml", () => {
+    expect(
+      parseKimiRuntimeParameters(
+        [
+          'default_model = "kimi-code/kimi-for-coding"',
+          "default_thinking = true",
+          "default_yolo = false",
+          "default_plan_mode = false",
+          "show_thinking_stream = true",
+          "max_steps_per_turn = 1000",
+          "max_retries_per_step = 3",
+          "max_ralph_iterations = 0",
+          "reserved_context_size = 50000",
+        ].join("\n"),
+      ),
+    ).toEqual([
+      {
+        id: "model",
+        displayName: "Default model",
+        type: "string",
+        flag: "-m, --model",
+        defaultValue: "kimi-code/kimi-for-coding",
+        source: "config",
+      },
+      {
+        id: "thinking",
+        displayName: "Thinking",
+        type: "boolean",
+        flag: "--thinking/--no-thinking",
+        defaultValue: true,
+        source: "config",
+      },
+      {
+        id: "show_thinking_stream",
+        displayName: "Show thinking stream",
+        type: "boolean",
+        defaultValue: true,
+        source: "config",
+      },
+      {
+        id: "yolo",
+        displayName: "Auto approve",
+        type: "boolean",
+        flag: "--yolo, --yes, -y",
+        defaultValue: false,
+        source: "config",
+      },
+      {
+        id: "plan_mode",
+        displayName: "Plan mode",
+        type: "boolean",
+        flag: "--plan",
+        defaultValue: false,
+        source: "config",
+      },
+      {
+        id: "max_steps_per_turn",
+        displayName: "Max steps per turn",
+        type: "integer",
+        flag: "--max-steps-per-turn",
+        defaultValue: 1000,
+        minimum: 1,
+        source: "config",
+      },
+      {
+        id: "max_retries_per_step",
+        displayName: "Max retries per step",
+        type: "integer",
+        flag: "--max-retries-per-step",
+        defaultValue: 3,
+        minimum: 1,
+        source: "config",
+      },
+      {
+        id: "max_ralph_iterations",
+        displayName: "Max Ralph iterations",
+        type: "integer",
+        flag: "--max-ralph-iterations",
+        defaultValue: 0,
+        minimum: -1,
+        source: "config",
+      },
+      {
+        id: "reserved_context_size",
+        displayName: "Reserved context size",
+        type: "integer",
+        defaultValue: 50000,
+        minimum: 0,
+        source: "config",
+      },
+    ]);
+  });
+});

package/src/agent-discovery.ts

@@ -36,6 +36,12 @@ export interface DiscoveredAgentCredential {
    * in that case.
    */
   runtime?: string;
+  /** Runtime model id/alias selected for this agent. */
+  runtimeModel?: string;
+  /** Runtime reasoning effort selected for this agent. */
+  reasoningEffort?: string;
+  /** Kimi-style thinking toggle selected for this agent. */
+  thinking?: boolean;
   /** Working directory cached alongside `runtime`. */
   cwd?: string;
   /** OpenClaw gateway profile name from credentials (only meaningful for openclaw-acp). */
@@ -181,6 +187,9 @@ export function discoverAgentCredentials(
     };
     if (creds.displayName) entry.displayName = creds.displayName;
     if (creds.runtime) entry.runtime = creds.runtime;
+    if (creds.runtimeModel) entry.runtimeModel = creds.runtimeModel;
+    if (creds.reasoningEffort) entry.reasoningEffort = creds.reasoningEffort;
+    if (typeof creds.thinking === "boolean") entry.thinking = creds.thinking;
     if (creds.cwd) entry.cwd = creds.cwd;
     if (creds.openclawGateway) entry.openclawGateway = creds.openclawGateway;
     if (creds.openclawAgent) entry.openclawAgent = creds.openclawAgent;

package/src/daemon-config-map.ts

@@ -18,10 +18,20 @@ import type {
 import { resolveAgentIds } from "./config.js";
 import { agentWorkspaceDir } from "./agent-workspace.js";
 import { log as daemonLog } from "./log.js";
+import {
+  buildRuntimeSelectionExtraArgs,
+  mergeRuntimeExtraArgs,
+} from "./runtime-route-options.js";
 
 /** Per-agent metadata cached from credentials, used by `buildManagedRoutes`. */
 export interface AgentRuntimeMeta {
   runtime?: string;
+  /** Runtime model id/alias selected for this agent. */
+  runtimeModel?: string;
+  /** Runtime reasoning effort selected for this agent. */
+  reasoningEffort?: string;
+  /** Kimi-style thinking toggle selected for this agent. */
+  thinking?: boolean;
   cwd?: string;
   /** OpenClaw gateway profile name to lookup in the registry. */
   openclawGateway?: string;
@@ -346,10 +356,13 @@ export function buildManagedRoutes(
       match: { accountId: agentId },
       runtime,
       cwd: meta.cwd || agentWorkspaceDir(agentId),
-      // Inherit defaultRoute's extraArgs so synthesized per-agent routes
-      // pick up operator-wide flags (e.g. `--permission-mode bypassPermissions`)
-      // that would otherwise apply only to agents listed in `cfg.routes[]`.
-      ...(defaultRoute.extraArgs ? { extraArgs: defaultRoute.extraArgs.slice() } : {}),
+      ...(() => {
+        const extraArgs = mergeRuntimeExtraArgs(
+          defaultRoute.extraArgs,
+          buildRuntimeSelectionExtraArgs(runtime, meta),
+        );
+        return extraArgs ? { extraArgs } : {};
+      })(),
     };
     if (runtime === "openclaw-acp") {
       // Per RFC §3.4: prefer credentials, fall back to defaultRoute.gateway.