@botcord/daemon 0.2.77 → 0.2.79

package/dist/gateway-control.js

@@ -108,13 +108,16 @@ export function createGatewayControl(ctx) {
             if (!loginId) {
                 return badParams("upsert_gateway: wechat requires loginId");
             }
-            const session = sessions.get(loginId);
-            if (!session) {
+            const resolved = sessions.resolve(loginId);
+            if (resolved.state !== "live") {
                 return {
                     ok: false,
-                    error: { code: "login_expired", message: `wechat login session "${loginId}" not found or expired` },
+                    error: resolved.state === "missing"
+                        ? { code: "login_missing", message: `wechat login session "${loginId}" not found` }
+                        : { code: "login_expired", message: `wechat login session "${loginId}" expired` },
                 };
             }
+            const session = resolved.session;
             if (session.provider !== "wechat") {
                 return badParams(`upsert_gateway: login session provider "${session.provider}" != "wechat"`);
             }
@@ -143,13 +146,16 @@ export function createGatewayControl(ctx) {
             if (!loginId) {
                 return badParams("upsert_gateway: feishu requires loginId");
             }
-            const session = sessions.get(loginId);
-            if (!session) {
+            const resolved = sessions.resolve(loginId);
+            if (resolved.state !== "live") {
                 return {
                     ok: false,
-                    error: { code: "login_expired", message: `feishu login session "${loginId}" not found or expired` },
+                    error: resolved.state === "missing"
+                        ? { code: "login_missing", message: `feishu login session "${loginId}" not found` }
+                        : { code: "login_expired", message: `feishu login session "${loginId}" expired` },
                 };
             }
+            const session = resolved.session;
             if (session.provider !== "feishu") {
                 return badParams(`upsert_gateway: login session provider "${session.provider}" != "feishu"`);
             }
@@ -659,13 +665,16 @@ export function createGatewayControl(ctx) {
         if (!params.accountId || typeof params.accountId !== "string") {
             return badParams("gateway_recent_senders: accountId is required");
         }
-        const session = sessions.get(params.loginId);
-        if (!session) {
+        const resolved = sessions.resolve(params.loginId);
+        if (resolved.state !== "live") {
             return {
                 ok: false,
-                error: { code: "login_expired", message: `wechat login session "${params.loginId}" not found or expired` },
+                error: resolved.state === "missing"
+                    ? { code: "login_missing", message: `wechat login session "${params.loginId}" not found` }
+                    : { code: "login_expired", message: `wechat login session "${params.loginId}" expired` },
             };
         }
+        const session = resolved.session;
         if (session.provider !== "wechat") {
             return badParams("gateway_recent_senders: provider does not match login session");
         }

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;
@@ -180,10 +182,14 @@ interface HelloIdentityResult {
     updated: number;
     skipped: number;
 }
+interface RuntimeSnapshotCtx {
+    gateway?: Gateway;
+}
 /**
  * Reconcile every agent identity carried by the `hello.agents` snapshot
- * against the on-disk `identity.md`. Best-effort: a malformed entry or a
- * file-system error for one agent never aborts the rest.
+ * against the on-disk `identity.md` and credentials runtime selectors.
+ * Best-effort: a malformed entry or a file-system error for one agent never
+ * aborts the rest.
  *
  * Identity-snapshot semantics intentionally only touch the metadata
  * line + Bio body — Role/Boundaries paragraphs the user authored locally
@@ -191,7 +197,7 @@ interface HelloIdentityResult {
  * (agent provisioned on a different daemon, or workspace cleared) are
  * silently skipped.
  */
-export declare function applyHelloIdentitySnapshot(snapshot: AgentIdentitySnapshot[] | undefined): HelloIdentityResult;
+export declare function applyHelloIdentitySnapshot(snapshot: AgentIdentitySnapshot[] | undefined, ctx?: RuntimeSnapshotCtx): HelloIdentityResult;
 interface ReloadResult {
     reloaded: true;
     added: string[];

package/dist/provision.js

@@ -18,6 +18,9 @@ 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";
+import { handleCloudGatewayRuntimeInbound } from "./cloud-gateway-runtime.js";
 /**
  * Build a dispatcher function that routes a `ControlFrame` to the right
  * handler. Returned function signature matches
@@ -39,7 +42,7 @@ export function createProvisioner(opts) {
                 return { ok: true, result: { pong: true, ts: Date.now() } };
             case CONTROL_FRAME_TYPES.HELLO: {
                 const params = (frame.params ?? {});
-                const result = applyHelloIdentitySnapshot(params.agents);
+                const result = applyHelloIdentitySnapshot(params.agents, { gateway });
                 daemonLog.debug("hello: identity snapshot applied", {
                     frameId: frame.id,
                     received: params.agents?.length ?? 0,
@@ -60,12 +63,19 @@ export function createProvisioner(opts) {
                     displayName: params.displayName,
                     bio: params.bio,
                 });
+                const runtimeResult = applyAgentRuntimeSnapshot(params, { gateway });
+                const combined = {
+                    changed: result.changed || runtimeResult.changed,
+                    identity: result,
+                    runtime: runtimeResult,
+                };
                 daemonLog.info("update_agent applied", {
                     agentId: params.agentId,
-                    changed: result.changed,
-                    skipped: result.skipped ?? null,
+                    changed: combined.changed,
+                    identitySkipped: result.skipped ?? null,
+                    runtimeSkipped: runtimeResult.skipped ?? null,
                 });
-                return { ok: true, result };
+                return { ok: true, result: combined };
             }
             case CONTROL_FRAME_TYPES.PROVISION_AGENT: {
                 const params = (frame.params ?? {});
@@ -264,6 +274,30 @@ export function createProvisioner(opts) {
                     return v.ack;
                 return gatewayControl.handleSend(v.params);
             }
+            case "cloud_gateway_runtime_inbound": {
+                const params = (frame.params ?? {});
+                const runtimeFrame = params.frame;
+                if (!runtimeFrame || typeof runtimeFrame !== "object") {
+                    return {
+                        ok: false,
+                        error: {
+                            code: "bad_params",
+                            message: "cloud_gateway_runtime_inbound requires params.frame",
+                        },
+                    };
+                }
+                const result = await handleCloudGatewayRuntimeInbound(gateway, runtimeFrame);
+                return result.accepted
+                    ? { ok: true, result }
+                    : {
+                        ok: false,
+                        result,
+                        error: result.error ?? {
+                            code: "runtime_inbound_rejected",
+                            message: "cloud gateway runtime inbound was rejected",
+                        },
+                    };
+            }
             case "list_agent_files": {
                 const params = (frame.params ?? {});
                 if (!params.agentId) {
@@ -783,6 +817,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 +924,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 +966,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 +1500,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 +1559,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)
@@ -1971,10 +2030,84 @@ function openclawBindingIndex() {
     }
     return out;
 }
+function hasOwnField(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function cleanNullableString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const trimmed = value.trim();
+    return trimmed || undefined;
+}
+function applyAgentRuntimeSnapshot(snapshot, ctx = {}) {
+    const hasRuntimeFields = (hasOwnField(snapshot, "runtime") ||
+        hasOwnField(snapshot, "runtimeModel") ||
+        hasOwnField(snapshot, "reasoningEffort") ||
+        hasOwnField(snapshot, "thinking"));
+    if (!hasRuntimeFields)
+        return { changed: false, skipped: "no_runtime_fields" };
+    const credentialsFile = defaultCredentialsFile(snapshot.agentId);
+    if (!existsSync(credentialsFile)) {
+        return { changed: false, skipped: "credentials_missing" };
+    }
+    const credentials = loadStoredCredentials(credentialsFile);
+    let changed = false;
+    if (hasOwnField(snapshot, "runtime")) {
+        const runtime = cleanNullableString(snapshot.runtime);
+        if (runtime !== credentials.runtime) {
+            if (runtime)
+                credentials.runtime = runtime;
+            else
+                delete credentials.runtime;
+            changed = true;
+        }
+    }
+    if (hasOwnField(snapshot, "runtimeModel")) {
+        const runtimeModel = cleanNullableString(snapshot.runtimeModel);
+        if (runtimeModel !== credentials.runtimeModel) {
+            if (runtimeModel)
+                credentials.runtimeModel = runtimeModel;
+            else
+                delete credentials.runtimeModel;
+            changed = true;
+        }
+    }
+    if (hasOwnField(snapshot, "reasoningEffort")) {
+        const reasoningEffort = cleanNullableString(snapshot.reasoningEffort);
+        if (reasoningEffort !== credentials.reasoningEffort) {
+            if (reasoningEffort)
+                credentials.reasoningEffort = reasoningEffort;
+            else
+                delete credentials.reasoningEffort;
+            changed = true;
+        }
+    }
+    if (hasOwnField(snapshot, "thinking")) {
+        if (typeof snapshot.thinking === "boolean") {
+            if (credentials.thinking !== snapshot.thinking) {
+                credentials.thinking = snapshot.thinking;
+                changed = true;
+            }
+        }
+        else if (typeof credentials.thinking === "boolean") {
+            delete credentials.thinking;
+            changed = true;
+        }
+    }
+    if (!changed)
+        return { changed: false };
+    writeCredentialsFile(credentialsFile, credentials);
+    if (ctx.gateway) {
+        upsertManagedRouteForCredentials(credentials, loadConfig(), ctx.gateway);
+        return { changed: true, routeUpdated: true };
+    }
+    return { changed: true };
+}
 /**
  * Reconcile every agent identity carried by the `hello.agents` snapshot
- * against the on-disk `identity.md`. Best-effort: a malformed entry or a
- * file-system error for one agent never aborts the rest.
+ * against the on-disk `identity.md` and credentials runtime selectors.
+ * Best-effort: a malformed entry or a file-system error for one agent never
+ * aborts the rest.
  *
  * Identity-snapshot semantics intentionally only touch the metadata
  * line + Bio body — Role/Boundaries paragraphs the user authored locally
@@ -1982,7 +2115,7 @@ function openclawBindingIndex() {
  * (agent provisioned on a different daemon, or workspace cleared) are
  * silently skipped.
  */
-export function applyHelloIdentitySnapshot(snapshot) {
+export function applyHelloIdentitySnapshot(snapshot, ctx = {}) {
     const out = { updated: 0, skipped: 0 };
     if (!Array.isArray(snapshot))
         return out;
@@ -1996,7 +2129,8 @@ export function applyHelloIdentitySnapshot(snapshot) {
                 displayName: entry.displayName,
                 bio: entry.bio,
             });
-            if (result.changed)
+            const runtimeResult = applyAgentRuntimeSnapshot(entry, ctx);
+            if (result.changed || runtimeResult.changed)
                 out.updated += 1;
             else
                 out.skipped += 1;
@@ -2096,6 +2230,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 +2244,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 +2457,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/room-recovery-context.d.ts

@@ -0,0 +1,11 @@
+import type { GatewayInboundMessage } from "./gateway/index.js";
+export interface RecentRoomMessagesRecoveryOptions {
+    credentialPathByAgentId: Map<string, string>;
+    defaultCredentialsPath?: string;
+    hubBaseUrl?: string;
+    limit?: number;
+    log?: {
+        warn: (msg: string, meta?: Record<string, unknown>) => void;
+    };
+}
+export declare function createRecentRoomMessagesRecoveryBuilder(opts: RecentRoomMessagesRecoveryOptions): (message: GatewayInboundMessage) => Promise<string | null>;

package/dist/room-recovery-context.js

@@ -0,0 +1,97 @@
+/**
+ * Build a compact, deterministic recovery block from recent Hub room messages.
+ * Used when a runtime-native session is discarded and the same turn is retried
+ * in a fresh session.
+ */
+import { BotCordClient, loadStoredCredentials } from "@botcord/protocol-core";
+import { sanitizeUntrustedContent } from "./gateway/index.js";
+const DEFAULT_RECENT_LIMIT = 20;
+const MAX_MESSAGE_TEXT_CHARS = 1200;
+function stripNewlines(s) {
+    return s.replace(/[\r\n]+/g, " ");
+}
+function messageLabel(m) {
+    const name = typeof m.from_name === "string" && m.from_name.trim()
+        ? m.from_name
+        : typeof m.from === "string" && m.from.trim()
+            ? m.from
+            : "unknown";
+    return sanitizeUntrustedContent(stripNewlines(name));
+}
+function formatRecentMessages(messages) {
+    if (messages.length === 0)
+        return "[Recent Room Messages]\n(none)";
+    const chronological = [...messages].reverse();
+    const lines = ["[Recent Room Messages]"];
+    for (const m of chronological) {
+        const text = typeof m.text === "string" ? m.text.trim() : "";
+        if (!text)
+            continue;
+        const ts = typeof m.ts === "string" ? m.ts : "";
+        const topic = typeof m.topic_title === "string" && m.topic_title.trim()
+            ? ` topic=${sanitizeUntrustedContent(stripNewlines(m.topic_title))}`
+            : typeof m.topic_id === "string" && m.topic_id
+                ? ` topic=${sanitizeUntrustedContent(stripNewlines(m.topic_id))}`
+                : "";
+        const safeText = sanitizeUntrustedContent(text.length > MAX_MESSAGE_TEXT_CHARS
+            ? `${text.slice(0, MAX_MESSAGE_TEXT_CHARS)}...`
+            : text);
+        lines.push(`- ${ts ? `${ts} ` : ""}${messageLabel(m)}${topic}: ${safeText}`);
+    }
+    return lines.join("\n");
+}
+export function createRecentRoomMessagesRecoveryBuilder(opts) {
+    const clients = new Map();
+    const limit = opts.limit ?? DEFAULT_RECENT_LIMIT;
+    function getClient(accountId) {
+        const existing = clients.get(accountId);
+        if (existing)
+            return existing.client;
+        const credsPath = opts.credentialPathByAgentId.get(accountId) ?? opts.defaultCredentialsPath;
+        if (!credsPath) {
+            opts.log?.warn("daemon.recovery-context.no-credentials", { accountId });
+            return null;
+        }
+        try {
+            const creds = loadStoredCredentials(credsPath);
+            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 }
+                    : {}),
+            });
+            clients.set(accountId, { client, credentialsPath: credsPath });
+            return client;
+        }
+        catch (err) {
+            opts.log?.warn("daemon.recovery-context.client-init-failed", {
+                accountId,
+                credsPath,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return null;
+        }
+    }
+    return async (message) => {
+        const client = getClient(message.accountId);
+        if (!client)
+            return null;
+        try {
+            const body = await client.roomMessages(message.conversation.id, { limit });
+            const messages = Array.isArray(body?.messages) ? body.messages : [];
+            return formatRecentMessages(messages);
+        }
+        catch (err) {
+            opts.log?.warn("daemon.recovery-context.fetch-failed", {
+                accountId: message.accountId,
+                roomId: message.conversation.id,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return null;
+        }
+    };
+}

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[];