@botcord/daemon 0.2.78 → 0.2.79

package/src/provision.ts

@@ -26,6 +26,7 @@ import {
   type RuntimeProbeResult,
   type StoredBotCordCredentials,
   type UpdateAgentParams,
+  type GatewayInboundFrame,
 } from "@botcord/protocol-core";
 import type { Gateway } from "./gateway/index.js";
 import type { GatewayInboundMessage } from "./gateway/index.js";
@@ -77,6 +78,7 @@ import {
   buildRuntimeSelectionExtraArgs,
   mergeRuntimeExtraArgs,
 } from "./runtime-route-options.js";
+import { handleCloudGatewayRuntimeInbound } from "./cloud-gateway-runtime.js";
 
 /**
  * Information passed to {@link OnAgentInstalledHook} after a successful
@@ -164,7 +166,7 @@ export function createProvisioner(opts: ProvisionerOptions): (
 
       case CONTROL_FRAME_TYPES.HELLO: {
         const params = (frame.params ?? {}) as unknown as HelloParams;
-        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,
@@ -186,12 +188,19 @@ export function createProvisioner(opts: ProvisionerOptions): (
           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: {
@@ -419,6 +428,31 @@ export function createProvisioner(opts: ProvisionerOptions): (
         );
       }
 
+      case "cloud_gateway_runtime_inbound": {
+        const params = (frame.params ?? {}) as { frame?: unknown };
+        const runtimeFrame = params.frame as GatewayInboundFrame | undefined;
+        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 ?? {}) as unknown as ListAgentFilesParams;
         if (!params.agentId) {
@@ -2410,10 +2444,100 @@ interface HelloIdentityResult {
   skipped: number;
 }
 
+interface RuntimeSnapshotResult {
+  changed: boolean;
+  skipped?: string;
+  routeUpdated?: boolean;
+}
+
+interface RuntimeSnapshotCtx {
+  gateway?: Gateway;
+}
+
+function hasOwnField(obj: object, key: string): boolean {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
+
+function cleanNullableString(value: string | null | undefined): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const trimmed = value.trim();
+  return trimmed || undefined;
+}
+
+function applyAgentRuntimeSnapshot(
+  snapshot: AgentIdentitySnapshot,
+  ctx: RuntimeSnapshotCtx = {},
+): RuntimeSnapshotResult {
+  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
@@ -2423,6 +2547,7 @@ interface HelloIdentityResult {
  */
 export function applyHelloIdentitySnapshot(
   snapshot: AgentIdentitySnapshot[] | undefined,
+  ctx: RuntimeSnapshotCtx = {},
 ): HelloIdentityResult {
   const out: HelloIdentityResult = { updated: 0, skipped: 0 };
   if (!Array.isArray(snapshot)) return out;
@@ -2436,7 +2561,8 @@ export function applyHelloIdentitySnapshot(
         displayName: entry.displayName,
         bio: entry.bio,
       });
-      if (result.changed) out.updated += 1;
+      const runtimeResult = applyAgentRuntimeSnapshot(entry, ctx);
+      if (result.changed || runtimeResult.changed) out.updated += 1;
       else out.skipped += 1;
     } catch (err) {
       out.skipped += 1;

package/src/room-recovery-context.ts

@@ -0,0 +1,131 @@
+/**
+ * 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";
+import type { GatewayInboundMessage } from "./gateway/index.js";
+
+interface CachedClient {
+  client: BotCordClient;
+  credentialsPath: string;
+}
+
+export interface RecentRoomMessagesRecoveryOptions {
+  credentialPathByAgentId: Map<string, string>;
+  defaultCredentialsPath?: string;
+  hubBaseUrl?: string;
+  limit?: number;
+  log?: {
+    warn: (msg: string, meta?: Record<string, unknown>) => void;
+  };
+}
+
+interface RoomMessage {
+  from?: string;
+  from_name?: string;
+  text?: string;
+  type?: string;
+  ts?: string;
+  topic_id?: string | null;
+  topic_title?: string | null;
+}
+
+const DEFAULT_RECENT_LIMIT = 20;
+const MAX_MESSAGE_TEXT_CHARS = 1200;
+
+function stripNewlines(s: string): string {
+  return s.replace(/[\r\n]+/g, " ");
+}
+
+function messageLabel(m: RoomMessage): string {
+  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: RoomMessage[]): string {
+  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: RecentRoomMessagesRecoveryOptions,
+): (message: GatewayInboundMessage) => Promise<string | null> {
+  const clients = new Map<string, CachedClient>();
+  const limit = opts.limit ?? DEFAULT_RECENT_LIMIT;
+
+  function getClient(accountId: string): BotCordClient | null {
+    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 as RoomMessage[] : [];
+      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;
+    }
+  };
+}