@botcord/daemon 0.2.77 → 0.2.79

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/attention-policy-fetcher.ts

@@ -0,0 +1,87 @@
+import {
+  BotCordClient,
+  defaultCredentialsFile,
+  loadStoredCredentials,
+  updateCredentialsToken,
+} from "@botcord/protocol-core";
+import type { DaemonAttentionPolicy } from "./gateway/policy-resolver.js";
+
+interface CachedClient {
+  client: BotCordClient;
+  credentialsPath: string;
+}
+
+export interface AttentionPolicyFetcherOptions {
+  credentialPathByAgentId: Map<string, string>;
+  defaultCredentialsPath?: string;
+  hubBaseUrl?: string;
+  log?: {
+    warn: (msg: string, meta?: Record<string, unknown>) => void;
+  };
+}
+
+export type AttentionPolicyFetcher = (args: {
+  agentId: string;
+  roomId?: string | null;
+}) => Promise<DaemonAttentionPolicy | undefined>;
+
+export function createAttentionPolicyFetcher(
+  opts: AttentionPolicyFetcherOptions,
+): AttentionPolicyFetcher {
+  const clients = new Map<string, CachedClient>();
+
+  function getClient(agentId: string): BotCordClient | null {
+    const existing = clients.get(agentId);
+    if (existing) return existing.client;
+
+    const credentialsPath =
+      opts.credentialPathByAgentId.get(agentId) ??
+      opts.defaultCredentialsPath ??
+      defaultCredentialsFile(agentId);
+
+    try {
+      const creds = loadStoredCredentials(credentialsPath);
+      const client = new BotCordClient({
+        hubUrl: opts.hubBaseUrl ?? creds.hubUrl,
+        agentId: creds.agentId,
+        keyId: creds.keyId,
+        privateKey: creds.privateKey,
+        ...(creds.token ? { token: creds.token } : {}),
+        ...(creds.tokenExpiresAt !== undefined
+          ? { tokenExpiresAt: creds.tokenExpiresAt }
+          : {}),
+      });
+      client.onTokenRefresh = (token, expiresAt) => {
+        try {
+          updateCredentialsToken(credentialsPath, token, expiresAt);
+        } catch {
+          // Persistence failures are non-fatal; the next refresh retries.
+        }
+      };
+      clients.set(agentId, { client, credentialsPath });
+      return client;
+    } catch (err) {
+      opts.log?.warn("daemon.attention-policy.client-init-failed", {
+        agentId,
+        credentialsPath,
+        error: err instanceof Error ? err.message : String(err),
+      });
+      return null;
+    }
+  }
+
+  return async ({ agentId, roomId }) => {
+    const client = getClient(agentId);
+    if (!client) return undefined;
+    try {
+      return await client.getAttentionPolicy({ roomId });
+    } catch (err) {
+      opts.log?.warn("daemon.attention-policy.fetch-failed", {
+        agentId,
+        roomId: roomId ?? null,
+        error: err instanceof Error ? err.message : String(err),
+      });
+      return undefined;
+    }
+  };
+}

package/src/cloud-daemon.ts

@@ -32,6 +32,7 @@ import { createDaemonSystemContextBuilder } from "./system-context.js";
 import { readWorkingMemorySnapshot } from "./working-memory.js";
 import { createRoomStaticContextBuilder } from "./room-context.js";
 import { createRoomContextFetcher } from "./room-context-fetcher.js";
+import { createRecentRoomMessagesRecoveryBuilder } from "./room-recovery-context.js";
 import { composeBotCordUserTurn } from "./turn-text.js";
 import { PolicyResolver, type DaemonAttentionPolicy } from "./gateway/policy-resolver.js";
 import { scanMention } from "./mention-scan.js";
@@ -143,6 +144,12 @@ export async function startCloudDaemon(
     fetchRoomInfo: roomContextFetcher,
     log: logger,
   });
+  const buildRuntimeRecoveryContext = createRecentRoomMessagesRecoveryBuilder({
+    credentialPathByAgentId,
+    hubBaseUrl: cloudCfg.hubUrl,
+    limit: 20,
+    log: logger,
+  });
 
   type PerAgentBuilder = (
     msg: GatewayInboundMessage,
@@ -258,6 +265,7 @@ export async function startCloudDaemon(
     turnTimeoutMs: DEFAULT_TURN_TIMEOUT_MS,
     buildSystemContext,
     buildMemoryContext,
+    buildRuntimeRecoveryContext,
     onInbound,
     onTurnComplete,
     composeUserTurn: composeBotCordUserTurn,

package/src/cloud-gateway-runtime.ts

@@ -0,0 +1,171 @@
+import {
+  RUNTIME_FRAME_TYPES,
+  type GatewayInboundFrame,
+} from "@botcord/protocol-core";
+
+import type {
+  ChannelAdapter,
+  ChannelSendContext,
+  ChannelSendResult,
+  ChannelStatusSnapshot,
+  Gateway,
+  GatewayInboundMessage,
+  GatewayLogger,
+} from "./gateway/index.js";
+
+export interface CloudGatewayRuntimeResult {
+  accepted: boolean;
+  eventId: string;
+  gatewayId: string;
+  agentId: string;
+  conversationId: string;
+  turnId: string;
+  outbound?: {
+    finalText: string;
+    providerMessageId?: string | null;
+  };
+  error?: {
+    code: string;
+    message: string;
+  };
+}
+
+/**
+ * Execute one ingress-originated runtime frame through the normal Gateway
+ * dispatcher while keeping provider I/O outside the cloud sandbox.
+ *
+ * The temporary channel is scoped to this call and implements only the
+ * dispatcher-facing send/status surface. Its send() method captures the
+ * final runtime reply; the Hub relay converts that into
+ * gateway_outbound_complete for gateway-ingress, which then calls the real
+ * provider API.
+ */
+export async function handleCloudGatewayRuntimeInbound(
+  gateway: Gateway,
+  frame: GatewayInboundFrame,
+  log?: GatewayLogger,
+): Promise<CloudGatewayRuntimeResult> {
+  if (frame.type !== RUNTIME_FRAME_TYPES.GATEWAY_INBOUND) {
+    return rejected(frame, "bad_frame_type", `unsupported frame type "${frame.type}"`);
+  }
+  if (!frame.gateway_id || !frame.agent_id || !frame.event_id) {
+    return rejected(frame, "bad_frame", "gateway_id, agent_id and event_id are required");
+  }
+  if (frame.message.accountId !== frame.agent_id) {
+    return rejected(frame, "account_mismatch", "message.accountId does not match frame.agent_id");
+  }
+  if (frame.message.channel !== frame.gateway_id) {
+    return rejected(frame, "channel_mismatch", "message.channel does not match frame.gateway_id");
+  }
+
+  let accepted = false;
+  let outboundText: string | null = null;
+  let providerMessageId: string | null | undefined;
+  const channel = createRuntimeRelayChannel({
+    id: frame.gateway_id,
+    provider: frame.provider,
+    accountId: frame.agent_id,
+    onSend: async (ctx) => {
+      outboundText = ctx.message.text ?? "";
+      providerMessageId = ctx.message.traceId ?? null;
+      return { providerMessageId };
+    },
+  });
+
+  const message: GatewayInboundMessage = {
+    ...frame.message,
+    raw: {
+      source_type: "cloud_gateway_ingress",
+      provider: frame.provider,
+      event_id: frame.event_id,
+      gateway_id: frame.gateway_id,
+    },
+  };
+
+  try {
+    await gateway.injectInboundThrough(message, channel, {
+      accept: async () => {
+        accepted = true;
+      },
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    log?.warn("cloud gateway runtime dispatch failed", {
+      eventId: frame.event_id,
+      gatewayId: frame.gateway_id,
+      agentId: frame.agent_id,
+      error: message,
+    });
+    return rejected(frame, "dispatch_failed", message);
+  }
+
+  return {
+    accepted,
+    eventId: frame.event_id,
+    gatewayId: frame.gateway_id,
+    agentId: frame.agent_id,
+    conversationId: frame.message.conversation.id,
+    turnId: `turn_${frame.event_id}`,
+    ...(outboundText !== null
+      ? {
+          outbound: {
+            finalText: outboundText,
+            providerMessageId: providerMessageId ?? null,
+          },
+        }
+      : {}),
+    ...(!accepted
+      ? { error: { code: "not_accepted", message: "dispatcher did not accept inbound" } }
+      : {}),
+  };
+}
+
+function createRuntimeRelayChannel(opts: {
+  id: string;
+  provider: string;
+  accountId: string;
+  onSend: (ctx: ChannelSendContext) => Promise<ChannelSendResult>;
+}): ChannelAdapter {
+  let lastSendAt: number | undefined;
+  return {
+    id: opts.id,
+    type: opts.provider,
+    async start() {
+      return undefined;
+    },
+    async stop() {
+      return undefined;
+    },
+    async send(ctx) {
+      lastSendAt = Date.now();
+      return opts.onSend(ctx);
+    },
+    status(): ChannelStatusSnapshot {
+      return {
+        channel: opts.id,
+        accountId: opts.accountId,
+        running: true,
+        connected: true,
+        authorized: true,
+        provider: opts.provider as ChannelStatusSnapshot["provider"],
+        ...(lastSendAt ? { lastSendAt } : {}),
+      };
+    },
+  };
+}
+
+function rejected(
+  frame: Partial<GatewayInboundFrame>,
+  code: string,
+  message: string,
+): CloudGatewayRuntimeResult {
+  return {
+    accepted: false,
+    eventId: frame.event_id ?? "",
+    gatewayId: frame.gateway_id ?? "",
+    agentId: frame.agent_id ?? "",
+    conversationId: frame.message?.conversation.id ?? "",
+    turnId: frame.event_id ? `turn_${frame.event_id}` : "turn_unknown",
+    error: { code, message },
+  };
+}

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.