@botcord/daemon 0.2.76 → 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/channels/botcord.js

@@ -57,11 +57,12 @@ function defaultClientFactory(input) {
 function isOwnerTrust(msg) {
     if (msg.room_id?.startsWith(OWNER_CHAT_PREFIX))
         return true;
-    if (msg.source_type === "dashboard_user_chat")
+    const sourceType = msg.source_type;
+    if (sourceType === "dashboard_user_chat")
         return true;
     // Cloud Agent run tasks are Hub-issued on the user's behalf, same
     // trust posture as owner chat.
-    if (msg.source_type === "cloud_agent_run")
+    if (sourceType === "cloud_agent_run")
         return true;
     return false;
 }
@@ -100,9 +101,10 @@ function normalizeInbox(msg, options) {
     // run completes). All other envelope types (notification, system,
     // contact_added/removed, …) are still filtered out — they belong in
     // a separate push-notification path that daemon does not yet implement.
-    if (env.type !== "message" &&
-        env.type !== "contact_request" &&
-        env.type !== "cloud_run")
+    const envType = env.type;
+    if (envType !== "message" &&
+        envType !== "contact_request" &&
+        envType !== "cloud_run")
         return null;
     if (!msg.room_id)
         return null;
@@ -113,7 +115,8 @@ function normalizeInbox(msg, options) {
     const text = ownerTrust ? rawText : sanitizeUntrustedContent(rawText);
     const isDm = msg.room_id.startsWith(DM_ROOM_PREFIX);
     const isOwnerChat = msg.room_id.startsWith(OWNER_CHAT_PREFIX);
-    const senderKind = ownerTrust || msg.source_type === "dashboard_human_room" ? "user" : "agent";
+    const sourceType = msg.source_type;
+    const senderKind = ownerTrust || sourceType === "dashboard_human_room" ? "user" : "agent";
     const senderName = msg.source_user_name ?? undefined;
     const threadId = msg.topic_id ?? msg.topic ?? null;
     const streamable = isOwnerChat;
@@ -860,55 +863,29 @@ function normalizeBlockForHub(block, seq) {
         return { kind: "assistant", seq, payload: { text } };
     }
     if (kind === "tool_use") {
-        // Claude Code: assistant message w/ content[].type === "tool_use" → {id,name,input}
-        // Codex:       item.started for command_execution, file_change, mcp_tool_call, web_search
-        const contents = Array.isArray(raw?.message?.content) ? raw.message.content : [];
-        const tu = contents.find((c) => c?.type === "tool_use");
-        if (tu) {
-            payload.name = typeof tu.name === "string" ? tu.name : "tool";
-            if (tu.input && typeof tu.input === "object")
-                payload.params = tu.input;
-            if (typeof tu.id === "string")
-                payload.id = tu.id;
-        }
-        else if (raw?.item && typeof raw.item === "object") {
-            payload.name = typeof raw.item.type === "string" ? raw.item.type : "tool";
-            const params = codexToolParams(raw.item);
-            if (Object.keys(params).length > 0)
-                payload.params = params;
-            if (typeof raw.item.id === "string")
-                payload.id = raw.item.id;
-            if (typeof raw.item.status === "string")
-                payload.status = raw.item.status;
+        // Claude Code, Codex, DeepSeek TUI, Kimi, and ACP all expose tool calls
+        // with slightly different field names. Preserve the real invocation input
+        // so the dashboard can show more than a bare "tool" label.
+        const call = extractToolCall(raw);
+        if (call) {
+            payload.name = call.name;
+            if (call.params !== undefined && !isEmptyRecord(call.params))
+                payload.params = call.params;
+            if (call.id)
+                payload.id = call.id;
+            if (call.status)
+                payload.status = call.status;
         }
         return { kind: "tool_call", seq, payload };
     }
     if (kind === "tool_result") {
-        // Claude Code: {type:"user", message:{content:[{type:"tool_result",tool_use_id,content}]}}
-        // Codex:       item.completed for command_execution, file_change, mcp_tool_call, web_search
-        const contents = Array.isArray(raw?.message?.content) ? raw.message.content : [];
-        const tr = contents.find((c) => c?.type === "tool_result");
-        if (tr) {
-            let resultStr = "";
-            if (typeof tr.content === "string") {
-                resultStr = tr.content;
-            }
-            else if (Array.isArray(tr.content)) {
-                resultStr = tr.content
-                    .map((c) => (typeof c?.text === "string" ? c.text : JSON.stringify(c)))
-                    .join("\n");
-            }
-            payload.result = resultStr;
-            if (typeof tr.tool_use_id === "string")
-                payload.tool_use_id = tr.tool_use_id;
-        }
-        else if (raw?.item && typeof raw.item === "object") {
-            payload.name = typeof raw.item.type === "string" ? raw.item.type : "tool";
-            if (typeof raw.item.id === "string")
-                payload.tool_use_id = raw.item.id;
-            const result = codexToolResult(raw.item);
-            if (result)
-                payload.result = result;
+        const result = extractToolResult(raw);
+        if (result) {
+            if (result.name)
+                payload.name = result.name;
+            payload.result = result.result;
+            if (result.id)
+                payload.tool_use_id = result.id;
         }
         return { kind: "tool_result", seq, payload };
     }
@@ -965,6 +942,168 @@ function isTerminalRuntimeBlock(raw) {
         terminal === "turn.done" ||
         terminal === "done");
 }
+function extractToolCall(raw) {
+    const contents = Array.isArray(raw?.message?.content) ? raw.message.content : [];
+    const tu = contents.find((c) => c?.type === "tool_use");
+    if (tu) {
+        return {
+            name: stringField(tu, "name") ?? "tool",
+            params: parseMaybeJson(tu.input ?? tu.arguments),
+            id: stringField(tu, "id"),
+        };
+    }
+    const deepseek = extractDeepseekToolCall(raw);
+    if (deepseek)
+        return deepseek;
+    const item = raw?.item;
+    if (item && typeof item === "object") {
+        const params = codexToolParams(item);
+        return {
+            name: stringField(item, "type") ?? stringField(item, "name") ?? "tool",
+            params,
+            id: stringField(item, "id"),
+            status: stringField(item, "status"),
+        };
+    }
+    const toolCalls = Array.isArray(raw?.tool_calls) ? raw.tool_calls : [];
+    const toolCall = toolCalls.find((t) => t && typeof t === "object");
+    if (toolCall) {
+        const fn = toolCall.function && typeof toolCall.function === "object" ? toolCall.function : undefined;
+        return {
+            name: stringField(fn, "name") ?? stringField(toolCall, "name") ?? "tool",
+            params: parseMaybeJson(fn?.arguments ?? toolCall.arguments ?? toolCall.input ?? toolCall.rawInput),
+            id: stringField(toolCall, "id"),
+        };
+    }
+    const update = raw?.params?.update ?? raw?.update;
+    const acpTool = update?.toolCall ?? update?.tool_call ?? update?.tool;
+    if (acpTool && typeof acpTool === "object") {
+        return {
+            name: stringField(acpTool, "name") ?? stringField(update, "name") ?? "tool",
+            params: parseMaybeJson(acpTool.rawInput ??
+                acpTool.raw_input ??
+                acpTool.input ??
+                acpTool.arguments ??
+                acpTool.args ??
+                acpTool.params) ?? acpTool,
+            id: stringField(acpTool, "id") ?? stringField(update, "toolCallId"),
+        };
+    }
+    return null;
+}
+function extractToolResult(raw) {
+    const contents = Array.isArray(raw?.message?.content) ? raw.message.content : [];
+    const tr = contents.find((c) => c?.type === "tool_result");
+    if (tr) {
+        return {
+            result: stringifyToolResult(tr.content),
+            id: stringField(tr, "tool_use_id"),
+        };
+    }
+    const deepseek = extractDeepseekToolResult(raw);
+    if (deepseek)
+        return deepseek;
+    const item = raw?.item;
+    if (item && typeof item === "object") {
+        const result = codexToolResult(item);
+        return {
+            name: stringField(item, "type") ?? stringField(item, "name"),
+            result: result || stringifyToolResult(item),
+            id: stringField(item, "id"),
+        };
+    }
+    if (raw?.role === "tool") {
+        return {
+            result: stringifyToolResult(raw.content),
+            id: stringField(raw, "tool_call_id"),
+        };
+    }
+    const update = raw?.params?.update ?? raw?.update;
+    const acpTool = update?.toolCall ?? update?.tool_call ?? update?.tool;
+    if (acpTool && typeof acpTool === "object") {
+        const result = acpTool.output ??
+            acpTool.result ??
+            acpTool.content ??
+            acpTool.error ??
+            update.content ??
+            update;
+        return {
+            name: stringField(acpTool, "name") ?? stringField(update, "name"),
+            result: stringifyToolResult(result),
+            id: stringField(acpTool, "id") ?? stringField(update, "toolCallId"),
+        };
+    }
+    return null;
+}
+function extractDeepseekToolCall(raw) {
+    const payload = raw?.payload;
+    if (!payload || typeof payload !== "object")
+        return null;
+    if (raw?.event === "tool.started") {
+        const tool = payload.tool && typeof payload.tool === "object" ? payload.tool : undefined;
+        return {
+            name: stringField(payload, "name") ?? stringField(tool, "name") ?? "tool",
+            params: parseMaybeJson(payload.input ?? payload.arguments ?? payload.params ?? tool?.input ?? tool?.rawInput),
+            id: stringField(payload, "id") ?? stringField(tool, "id"),
+            status: stringField(payload, "status") ?? stringField(tool, "status"),
+        };
+    }
+    if (payload.event === "item.started") {
+        const inner = payload.payload && typeof payload.payload === "object" ? payload.payload : {};
+        const item = inner.item && typeof inner.item === "object" ? inner.item : undefined;
+        const tool = inner.tool && typeof inner.tool === "object" ? inner.tool : item?.tool;
+        return {
+            name: stringField(tool, "name") ??
+                stringField(inner, "name") ??
+                stringField(item, "name") ??
+                stringField(item, "type") ??
+                "tool",
+            params: parseMaybeJson(tool?.input ??
+                tool?.rawInput ??
+                tool?.arguments ??
+                inner.input ??
+                item?.input ??
+                item?.arguments) ?? tool ?? item,
+            id: stringField(tool, "id") ?? stringField(inner, "id") ?? stringField(item, "id"),
+            status: stringField(tool, "status") ?? stringField(inner, "status") ?? stringField(item, "status"),
+        };
+    }
+    return null;
+}
+function extractDeepseekToolResult(raw) {
+    const payload = raw?.payload;
+    if (!payload || typeof payload !== "object")
+        return null;
+    if (raw?.event === "tool.completed") {
+        const result = payload.output ?? payload.result ?? payload.content ?? payload.error ?? payload;
+        return {
+            name: stringField(payload, "name"),
+            result: stringifyToolResult(result),
+            id: stringField(payload, "id"),
+        };
+    }
+    if (payload.event === "item.completed" || payload.event === "item.failed") {
+        const inner = payload.payload && typeof payload.payload === "object" ? payload.payload : {};
+        const item = inner.item && typeof inner.item === "object" ? inner.item : undefined;
+        const result = item?.output ??
+            item?.result ??
+            item?.content ??
+            item?.detail ??
+            item?.summary ??
+            item?.error ??
+            inner.output ??
+            inner.result ??
+            inner.error ??
+            item ??
+            inner;
+        return {
+            name: stringField(item, "name") ?? stringField(item, "type") ?? stringField(inner, "name"),
+            result: stringifyToolResult(result),
+            id: stringField(item, "id") ?? stringField(inner, "id"),
+        };
+    }
+    return null;
+}
 function formatBlockDetails(raw) {
     if (!raw || typeof raw !== "object")
         return "";
@@ -1034,6 +1173,52 @@ function codexToolResult(item) {
     }
     return parts.join("\n");
 }
+function stringifyToolResult(value) {
+    if (value == null)
+        return "";
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value)) {
+        return value
+            .map((c) => {
+            if (typeof c === "string")
+                return c;
+            if (typeof c?.text === "string")
+                return c.text;
+            return stringifyToolResult(c);
+        })
+            .filter(Boolean)
+            .join("\n");
+    }
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+function parseMaybeJson(value) {
+    if (typeof value !== "string")
+        return value;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return value;
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("["))
+        return value;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return value;
+    }
+}
+function isEmptyRecord(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0;
+}
+function stringField(obj, key) {
+    const value = obj?.[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
 function extractContentText(content) {
     if (!content)
         return "";

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) {