@botcord/daemon 0.2.77 → 0.2.78

package/src/gateway/__tests__/deepseek-tui-adapter.test.ts

@@ -106,7 +106,12 @@ async function startMockDeepseekServer(opts?: {
   };
 }
 
-function runAdapter(serverUrl: string, authToken: string, sessionId: string | null = null) {
+function runAdapter(
+  serverUrl: string,
+  authToken: string,
+  sessionId: string | null = null,
+  extraArgs?: string[],
+) {
   const adapter = new DeepseekTuiAdapter({ serverUrl, authToken });
   const ctrl = new AbortController();
   const blocks: string[] = [];
@@ -118,6 +123,7 @@ function runAdapter(serverUrl: string, authToken: string, sessionId: string | nu
     cwd: tmpRoot,
     signal: ctrl.signal,
     trustLevel: "owner",
+    extraArgs,
     systemContext: "runtime memory",
     onBlock: (b) => blocks.push(b.kind),
     onStatus: (e) => {
@@ -184,6 +190,29 @@ describe("DeepseekTuiAdapter", () => {
     }
   });
 
+  it("passes selected model and reasoning effort through HTTP payloads", async () => {
+    const server = await startMockDeepseekServer();
+    try {
+      const { result } = runAdapter(server.baseUrl, server.token, null, [
+        "--model",
+        "deepseek-v4-pro",
+        "--reasoning-effort",
+        "auto",
+      ]);
+      await result;
+      expect(server.calls.find((c) => c.method === "POST" && c.url === "/v1/threads")?.body).toMatchObject({
+        model: "deepseek-v4-pro",
+        reasoning_effort: "auto",
+      });
+      expect(server.calls.find((c) => c.method === "POST" && c.url.endsWith("/turns"))?.body).toMatchObject({
+        model: "deepseek-v4-pro",
+        reasoning_effort: "auto",
+      });
+    } finally {
+      await server.close();
+    }
+  });
+
   it("clears stale session ids when DeepSeek reports the thread missing", async () => {
     const server = await startMockDeepseekServer({ threadId: "thr_other" });
     try {

package/src/gateway/runtimes/deepseek-tui.ts

@@ -260,6 +260,9 @@ export class DeepseekTuiAdapter implements RuntimeAdapter {
       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<any>(`${baseUrl}/v1/threads`, {
       method: "POST",
@@ -306,18 +309,22 @@ export class DeepseekTuiAdapter implements RuntimeAdapter {
     });
     let turnId = "";
     try {
+      const selection = parseDeepseekRuntimeSelection(opts.extraArgs);
+      const body: Record<string, unknown> = {
+        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<any>(
         `${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,
         },
       );
@@ -535,6 +542,41 @@ function authHeaders(token: string): HeadersInit {
   return token ? { authorization: `Bearer ${token}` } : {};
 }
 
+function parseDeepseekRuntimeSelection(
+  extraArgs: string[] | undefined,
+): { model?: string; reasoningEffort?: string } {
+  const out: { model?: string; reasoningEffort?: string } = {};
+  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: 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 poolKey(opts: RuntimeRunOptions): string {
   return opts.accountId || "default";
 }

package/src/provision.ts

@@ -72,6 +72,11 @@ import {
 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";
 
 /**
  * Information passed to {@link OnAgentInstalledHook} after a successful
@@ -1057,6 +1062,11 @@ function upsertManagedRouteForCredentials(
     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,
@@ -1169,6 +1179,10 @@ async function materializeCredentials(
     if (c.token) record.token = c.token;
     if (typeof c.tokenExpiresAt === "number") 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) record.openclawGateway = openclawSel.gateway;
@@ -1203,6 +1217,10 @@ async function materializeCredentials(
     tokenExpiresAt: reg.expiresAt,
   };
   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) record.openclawGateway = openclawSel.gateway;
@@ -1784,6 +1802,10 @@ export function collectRuntimeSnapshot(opts: { force?: boolean } = {}): ListRunt
     // style used above.
     if (entry.result.version) 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
@@ -1841,6 +1863,8 @@ export function attachRuntimeHealth(
 
 /** 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;
 
 /** Injection seam for L2 + L3 endpoint probes — kept testable + side-effect-free. */
 export type WsEndpointProbeFn = (args: {
@@ -2511,20 +2535,34 @@ export async function reloadConfig(ctx: { gateway: Gateway }): Promise<ReloadRes
  */
 function readAgentRuntimesFromCredentials(
   agentIds: string[],
-): Record<string, { runtime?: string; cwd?: string; openclawGateway?: string; openclawAgent?: string; hermesProfile?: string }> {
-  const out: Record<string, { runtime?: string; cwd?: string; openclawGateway?: string; openclawAgent?: string; hermesProfile?: string }> = {};
+): Record<string, { runtime?: string; runtimeModel?: string; reasoningEffort?: string; thinking?: boolean; cwd?: string; openclawGateway?: string; openclawAgent?: string; hermesProfile?: string }> {
+  const out: Record<string, { runtime?: string; runtimeModel?: string; reasoningEffort?: string; thinking?: boolean; cwd?: string; openclawGateway?: string; openclawAgent?: string; hermesProfile?: string }> = {};
   for (const id of agentIds) {
     const file = defaultCredentialsFile(id);
     try {
       if (!existsSync(file)) continue;
       const creds = loadStoredCredentials(file);
-      const entry: { runtime?: string; cwd?: string; openclawGateway?: string; openclawAgent?: string; hermesProfile?: string } = {};
+      const entry: { runtime?: string; runtimeModel?: string; reasoningEffort?: string; thinking?: boolean; cwd?: string; openclawGateway?: string; openclawAgent?: string; hermesProfile?: string } = {};
       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;
       if (creds.hermesProfile) entry.hermesProfile = creds.hermesProfile;
-      if (entry.runtime || entry.cwd || entry.openclawGateway || entry.openclawAgent || entry.hermesProfile) out[id] = entry;
+      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
     }
@@ -2769,6 +2807,33 @@ function pickRuntime(params: ProvisionAgentParams): string | undefined {
   return undefined;
 }
 
+function pickRuntimeSelection(
+  params: ProvisionAgentParams,
+): { runtimeModel?: string; reasoningEffort?: string; thinking?: boolean } {
+  const out: { runtimeModel?: string; reasoningEffort?: string; thinking?: boolean } = {};
+  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: Array<string | undefined>): string | undefined {
+  for (const value of values) {
+    const trimmed = value?.trim();
+    if (trimmed) return trimmed;
+  }
+  return undefined;
+}
+
 function assertKnownRuntime(runtime: string): void {
   const mod = getAdapterModule(runtime);
   if (!mod) {