@botcord/daemon 0.2.77 → 0.2.78

package/dist/agent-discovery.d.ts

@@ -22,6 +22,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). */

package/dist/agent-discovery.js

@@ -96,6 +96,12 @@ export function discoverAgentCredentials(opts = {}) {
             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)

package/dist/daemon-config-map.d.ts

@@ -3,6 +3,12 @@ import type { DaemonConfig, OpenclawGatewayProfile } from "./config.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;

package/dist/daemon-config-map.js

@@ -4,6 +4,7 @@ import path from "node:path";
 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";
 function expandHome(p) {
     if (p === "~")
         return homedir();
@@ -259,10 +260,10 @@ export function buildManagedRoutes(agentIds, agentRuntimes, defaultRoute, opencl
             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.

package/dist/daemon.d.ts

@@ -121,6 +121,9 @@ export interface BootBackfillResult {
     credentialPathByAgentId: Map<string, string>;
     agentRuntimes: Record<string, {
         runtime?: string;
+        runtimeModel?: string;
+        reasoningEffort?: string;
+        thinking?: boolean;
         cwd?: string;
         openclawGateway?: string;
         openclawAgent?: string;

package/dist/daemon.js

@@ -527,9 +527,19 @@ export function backfillBootAgents(agents, opts) {
     for (const a of agents) {
         if (a.credentialsFile)
             credentialPathByAgentId.set(a.agentId, a.credentialsFile);
-        if (a.runtime || a.cwd || a.openclawGateway || a.openclawAgent || a.hermesProfile) {
+        if (a.runtime ||
+            a.runtimeModel ||
+            a.reasoningEffort ||
+            typeof a.thinking === "boolean" ||
+            a.cwd ||
+            a.openclawGateway ||
+            a.openclawAgent ||
+            a.hermesProfile) {
             agentRuntimes[a.agentId] = {
                 ...(a.runtime ? { runtime: a.runtime } : {}),
+                ...(a.runtimeModel ? { runtimeModel: a.runtimeModel } : {}),
+                ...(a.reasoningEffort ? { reasoningEffort: a.reasoningEffort } : {}),
+                ...(typeof a.thinking === "boolean" ? { thinking: a.thinking } : {}),
                 ...(a.cwd ? { cwd: a.cwd } : {}),
                 ...(a.openclawGateway ? { openclawGateway: a.openclawGateway } : {}),
                 ...(a.openclawAgent ? { openclawAgent: a.openclawAgent } : {}),

package/dist/gateway/runtimes/deepseek-tui.js

@@ -202,6 +202,11 @@ export class DeepseekTuiAdapter {
             auto_approve: opts.trustLevel !== "public",
             archived: false,
         };
+        const selection = parseDeepseekRuntimeSelection(opts.extraArgs);
+        if (selection.model)
+            body.model = selection.model;
+        if (selection.reasoningEffort)
+            body.reasoning_effort = selection.reasoningEffort;
         if (opts.systemContext)
             body.system_prompt = opts.systemContext;
         const res = await this.requestJson(`${baseUrl}/v1/threads`, {
@@ -236,16 +241,22 @@ export class DeepseekTuiAdapter {
         });
         let turnId = "";
         try {
+            const selection = parseDeepseekRuntimeSelection(opts.extraArgs);
+            const body = {
+                prompt: opts.text,
+                mode: "agent",
+                allow_shell: opts.trustLevel !== "public",
+                trust_mode: opts.trustLevel !== "public",
+                auto_approve: opts.trustLevel !== "public",
+            };
+            if (selection.model)
+                body.model = selection.model;
+            if (selection.reasoningEffort)
+                body.reasoning_effort = selection.reasoningEffort;
             const started = await this.requestJson(`${baseUrl}/v1/threads/${encodeURIComponent(threadId)}/turns`, {
                 method: "POST",
                 headers,
-                body: JSON.stringify({
-                    prompt: opts.text,
-                    mode: "agent",
-                    allow_shell: opts.trustLevel !== "public",
-                    trust_mode: opts.trustLevel !== "public",
-                    auto_approve: opts.trustLevel !== "public",
-                }),
+                body: JSON.stringify(body),
                 signal,
             });
             turnId = stringField(started?.turn, "id") ?? stringField(started, "turn_id") ?? "";
@@ -457,6 +468,43 @@ function parseSseFrame(raw) {
 function authHeaders(token) {
     return token ? { authorization: `Bearer ${token}` } : {};
 }
+function parseDeepseekRuntimeSelection(extraArgs) {
+    const out = {};
+    if (!extraArgs?.length)
+        return out;
+    for (let i = 0; i < extraArgs.length; i += 1) {
+        const arg = extraArgs[i];
+        if (arg === "--model") {
+            const value = nextArgValue(extraArgs, i);
+            if (value !== undefined) {
+                out.model = value;
+                i += 1;
+            }
+        }
+        else if (arg.startsWith("--model=")) {
+            out.model = arg.slice("--model=".length);
+        }
+        else if (arg === "--reasoning-effort") {
+            const value = nextArgValue(extraArgs, i);
+            if (value !== undefined) {
+                out.reasoningEffort = value;
+                i += 1;
+            }
+        }
+        else if (arg.startsWith("--reasoning-effort=")) {
+            out.reasoningEffort = arg.slice("--reasoning-effort=".length);
+        }
+    }
+    return out;
+}
+function nextArgValue(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 poolKey(opts) {
     return opts.accountId || "default";
 }

package/dist/provision.d.ts

@@ -107,6 +107,8 @@ export declare function collectRuntimeSnapshot(opts?: {
 export declare function attachRuntimeHealth(snapshot: ListRuntimesResult, live: GatewayRuntimeSnapshot): ListRuntimesResult;
 /** Maximum number of `endpoints[]` entries persisted per runtime (RFC §3.8.2). */
 export declare const RUNTIME_ENDPOINTS_CAP = 32;
+export declare const RUNTIME_MODELS_CAP = 128;
+export declare const RUNTIME_PARAMETERS_CAP = 64;
 /** Injection seam for L2 + L3 endpoint probes — kept testable + side-effect-free. */
 export type WsEndpointProbeFn = (args: {
     url: string;

package/dist/provision.js

@@ -18,6 +18,8 @@ import { hermesProfileHomeDir, isValidHermesProfileName, listHermesProfiles, } f
 import { log as daemonLog } from "./log.js";
 import { discoverAgentCredentials } from "./agent-discovery.js";
 import { resolveMemoryDir } from "./working-memory.js";
+import { discoverRuntimeModelCatalog } from "./runtime-models.js";
+import { buildRuntimeSelectionExtraArgs, mergeRuntimeExtraArgs, } from "./runtime-route-options.js";
 /**
  * Build a dispatcher function that routes a `ControlFrame` to the right
  * handler. Returned function signature matches
@@ -783,6 +785,9 @@ function upsertManagedRouteForCredentials(credentials, cfg, gateway) {
         runtime: credentials.runtime ?? cfg.defaultRoute.adapter,
         cwd: credentials.cwd ?? agentWorkspaceDir(credentials.agentId),
     };
+    const extraArgs = mergeRuntimeExtraArgs(cfg.defaultRoute.extraArgs, buildRuntimeSelectionExtraArgs(synthRoute.runtime, credentials));
+    if (extraArgs)
+        synthRoute.extraArgs = extraArgs;
     if (synthRoute.runtime === "openclaw-acp") {
         const profile = (cfg.openclawGateways ?? []).find((g) => g.name === credentials.openclawGateway);
         if (profile) {
@@ -887,6 +892,13 @@ async function materializeCredentials(params, cfg, ctx, explicitCwd) {
             record.tokenExpiresAt = c.tokenExpiresAt;
         if (runtime)
             record.runtime = runtime;
+        const runtimeSelection = pickRuntimeSelection(params);
+        if (runtimeSelection.runtimeModel)
+            record.runtimeModel = runtimeSelection.runtimeModel;
+        if (runtimeSelection.reasoningEffort)
+            record.reasoningEffort = runtimeSelection.reasoningEffort;
+        if (typeof runtimeSelection.thinking === "boolean")
+            record.thinking = runtimeSelection.thinking;
         record.cwd = cwd;
         const openclawSel = pickOpenclawSelection(params);
         if (openclawSel.gateway)
@@ -922,6 +934,13 @@ async function materializeCredentials(params, cfg, ctx, explicitCwd) {
     };
     if (runtime)
         record.runtime = runtime;
+    const runtimeSelection = pickRuntimeSelection(params);
+    if (runtimeSelection.runtimeModel)
+        record.runtimeModel = runtimeSelection.runtimeModel;
+    if (runtimeSelection.reasoningEffort)
+        record.reasoningEffort = runtimeSelection.reasoningEffort;
+    if (typeof runtimeSelection.thinking === "boolean")
+        record.thinking = runtimeSelection.thinking;
     record.cwd = cwd;
     const openclawSel = pickOpenclawSelection(params);
     if (openclawSel.gateway)
@@ -1449,6 +1468,12 @@ export function collectRuntimeSnapshot(opts = {}) {
             record.version = entry.result.version;
         if (entry.result.path)
             record.path = entry.result.path;
+        const catalog = discoverRuntimeModelCatalog(entry);
+        const models = catalog.models;
+        if (models?.length)
+            record.models = models.slice(0, RUNTIME_MODELS_CAP);
+        if (catalog.parameters?.length)
+            record.parameters = catalog.parameters.slice(0, RUNTIME_PARAMETERS_CAP);
         // Gateway's probe surface doesn't expose an `error` string today — it
         // already swallows throws into `{available: false}`. We leave the wire
         // field blank in that case and let callers treat `!available` as reason
@@ -1502,6 +1527,8 @@ export function attachRuntimeHealth(snapshot, live) {
 }
 /** Maximum number of `endpoints[]` entries persisted per runtime (RFC §3.8.2). */
 export const RUNTIME_ENDPOINTS_CAP = 32;
+export const RUNTIME_MODELS_CAP = 128;
+export const RUNTIME_PARAMETERS_CAP = 64;
 export function classifyOpenclawAuthError(message) {
     const text = (message ?? "").toLowerCase();
     if (!text)
@@ -2096,6 +2123,12 @@ function readAgentRuntimesFromCredentials(agentIds) {
             const entry = {};
             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)
@@ -2104,8 +2137,16 @@ function readAgentRuntimesFromCredentials(agentIds) {
                 entry.openclawAgent = creds.openclawAgent;
             if (creds.hermesProfile)
                 entry.hermesProfile = creds.hermesProfile;
-            if (entry.runtime || entry.cwd || entry.openclawGateway || entry.openclawAgent || entry.hermesProfile)
+            if (entry.runtime ||
+                entry.runtimeModel ||
+                entry.reasoningEffort ||
+                typeof entry.thinking === "boolean" ||
+                entry.cwd ||
+                entry.openclawGateway ||
+                entry.openclawAgent ||
+                entry.hermesProfile) {
                 out[id] = entry;
+            }
         }
         catch {
             // best-effort — skip agents with unreadable credentials
@@ -2309,6 +2350,30 @@ function pickRuntime(params) {
     }
     return undefined;
 }
+function pickRuntimeSelection(params) {
+    const out = {};
+    const runtimeModel = pickString(params.runtimeModel, params.credentials?.runtimeModel);
+    const reasoningEffort = pickString(params.reasoningEffort, params.credentials?.reasoningEffort);
+    if (runtimeModel)
+        out.runtimeModel = runtimeModel;
+    if (reasoningEffort)
+        out.reasoningEffort = reasoningEffort;
+    if (typeof params.thinking === "boolean") {
+        out.thinking = params.thinking;
+    }
+    else if (typeof params.credentials?.thinking === "boolean") {
+        out.thinking = params.credentials.thinking;
+    }
+    return out;
+}
+function pickString(...values) {
+    for (const value of values) {
+        const trimmed = value?.trim();
+        if (trimmed)
+            return trimmed;
+    }
+    return undefined;
+}
 function assertKnownRuntime(runtime) {
     const mod = getAdapterModule(runtime);
     if (!mod) {

package/dist/runtime-models.d.ts

@@ -0,0 +1,17 @@
+import type { RuntimeModelProbe, RuntimeParameterProbe } from "@botcord/protocol-core";
+import type { RuntimeProbeEntry } from "./adapters/runtimes.js";
+export interface RuntimeModelDiscovery {
+    models?: RuntimeModelProbe[];
+    parameters?: RuntimeParameterProbe[];
+}
+export declare function discoverRuntimeModelCatalog(entry: RuntimeProbeEntry): RuntimeModelDiscovery;
+export declare function discoverRuntimeModels(entry: RuntimeProbeEntry): RuntimeModelProbe[] | undefined;
+export declare function discoverRuntimeParameters(entry: RuntimeProbeEntry): RuntimeParameterProbe[] | undefined;
+export declare function discoverClaudeModels(): RuntimeModelProbe[];
+export declare function discoverCodexModels(command: string | undefined): RuntimeModelProbe[] | undefined;
+export declare function parseCodexModelCatalog(raw: string): RuntimeModelProbe[] | undefined;
+export declare function discoverDeepseekModels(command: string | undefined): RuntimeModelProbe[] | undefined;
+export declare function parseDeepseekModelList(raw: string): RuntimeModelProbe[] | undefined;
+export declare function discoverKimiModels(): RuntimeModelProbe[] | undefined;
+export declare function parseKimiConfigModels(raw: string): RuntimeModelProbe[] | undefined;
+export declare function parseKimiRuntimeParameters(raw: string): RuntimeParameterProbe[];