feat(api): update user settings handling and integrate default model management

- Modified the user settings retrieval and update logic to exclude defaultModel, which is now managed via the plugin.
- Implemented functionality to push the user's default model to OpenClaw when updated.
- Enhanced the ConnectionDO to handle default model updates and broadcast changes to connected clients.
- Updated the plugin to process default model settings and ensure proper integration with OpenClaw configuration.

Author: Daniel-Robbins

packages/api/src/do/connection-do.ts

@@ -270,6 +270,15 @@ export class ConnectionDO implements DurableObject {
       );
     }
 
+    // Plugin applied BotsChat default model to OpenClaw config — update and broadcast
+    if (msg.type === "defaultModel.updated" && typeof msg.model === "string") {
+      this.defaultModel = msg.model;
+      await this.state.storage.put("defaultModel", this.defaultModel);
+      this.broadcastToBrowsers(
+        JSON.stringify({ type: "connection.status", openclawConnected: true, defaultModel: this.defaultModel, models: this.cachedModels }),
+      );
+    }
+
     // Handle job updates from plugin — persist and forward to browsers
     if (msg.type === "job.update") {
       await this.handleJobUpdate(msg);

packages/api/src/index.ts

@@ -104,11 +104,14 @@ protectedApp.get("/me", async (c) => {
       created_at: number;
     }>();
   if (!row) return c.json({ error: "User not found" }, 404);
+  const settings = JSON.parse(row.settings_json || "{}");
+  // defaultModel is not stored in D1 — it comes from the plugin (connection.status).
+  delete settings.defaultModel;
   return c.json({
     id: row.id,
     email: row.email,
     displayName: row.display_name,
-    settings: JSON.parse(row.settings_json || "{}"),
+    settings,
     createdAt: row.created_at,
   });
 });
@@ -117,25 +120,44 @@ protectedApp.patch("/me", async (c) => {
   const userId = c.get("userId");
   const body = await c.req.json<{ defaultModel?: string }>();
 
+  // defaultModel is not stored in D1 — get/set only via plugin (connection.status / push).
   const existing = await c.env.DB.prepare(
     "SELECT settings_json FROM users WHERE id = ?",
   )
     .bind(userId)
     .first<{ settings_json: string }>();
 
   const settings = JSON.parse(existing?.settings_json || "{}");
-
-  if (body.defaultModel !== undefined) {
-    settings.defaultModel = body.defaultModel;
-  }
-
+  delete settings.defaultModel;
+  // Persist other settings (if any) to D1; defaultModel is never written.
   await c.env.DB.prepare(
     "UPDATE users SET settings_json = ? WHERE id = ?",
   )
     .bind(JSON.stringify(settings), userId)
     .run();
 
-  return c.json({ ok: true, settings });
+  if (body.defaultModel !== undefined) {
+    try {
+      const doId = c.env.CONNECTION_DO.idFromName(userId);
+      const stub = c.env.CONNECTION_DO.get(doId);
+      await stub.fetch(
+        new Request("https://internal/send", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            type: "settings.defaultModel",
+            defaultModel: body.defaultModel ?? "",
+          }),
+        }),
+      );
+    } catch (err) {
+      console.error("Failed to push default model to OpenClaw:", err);
+    }
+  }
+
+  const outSettings = { ...settings };
+  delete outSettings.defaultModel;
+  return c.json({ ok: true, settings: outSettings });
 });
 
 // OpenClaw scan data — schedule/instructions/model cached in the ConnectionDO.

packages/api/src/routes/auth.ts

@@ -287,11 +287,14 @@ auth.get("/me", async (c) => {
 
   if (!row) return c.json({ error: "User not found" }, 404);
 
+  const settings = JSON.parse(row.settings_json || "{}");
+  delete settings.defaultModel; // not in D1 — comes from plugin (connection.status)
+
   return c.json({
     id: row.id,
     email: row.email,
     displayName: row.display_name,
-    settings: JSON.parse(row.settings_json || "{}"),
+    settings,
     createdAt: row.created_at,
   });
 });

packages/plugin/src/channel.ts

@@ -602,6 +602,21 @@ async function handleCloudMessage(
       await handleModelsRequest(ctx);
       break;
 
+    case "settings.defaultModel": {
+      const model = typeof msg.defaultModel === "string" ? msg.defaultModel.trim() : "";
+      if (model) {
+        ctx.log?.info(`[${ctx.accountId}] Setting OpenClaw default model to: ${model}`);
+        const result = await openclawConfigSetDefaultModel(model, ctx.log);
+        if (result.ok) {
+          const client = getCloudClient(ctx.accountId);
+          if (client?.connected) {
+            client.send({ type: "defaultModel.updated", model });
+          }
+        }
+      }
+      break;
+    }
+
     default:
       break;
   }
@@ -642,6 +657,33 @@ function parseScheduleToOpenClaw(schedule: string): { kind: string; everyMs?: nu
   return null;
 }
 
+/**
+ * Run `openclaw config set agents.defaults.model.primary <model>` so the
+ * user's default model choice in BotsChat takes effect on the OpenClaw gateway.
+ */
+async function openclawConfigSetDefaultModel(
+  model: string,
+  log?: { info: (m: string) => void; warn: (m: string) => void; error: (m: string) => void },
+): Promise<{ ok: boolean; error?: string }> {
+  if (!model || !model.trim()) return { ok: true };
+  const { execFile } = await import("child_process");
+  const { promisify } = await import("util");
+  const execFileAsync = promisify(execFile);
+  const args = ["config", "set", "agents.defaults.model.primary", model.trim()];
+  log?.info(`Running: openclaw ${args.join(" ")}`);
+  try {
+    await execFileAsync("openclaw", args, {
+      timeout: 10_000,
+      env: { ...process.env, PATH: `/opt/homebrew/bin:${process.env.PATH}` },
+    });
+    return { ok: true };
+  } catch (err: unknown) {
+    const message = err instanceof Error ? err.message : String(err);
+    log?.error(`openclaw config set default model failed: ${message}`);
+    return { ok: false, error: message };
+  }
+}
+
 /**
  * Run `openclaw cron edit` to hot-update the CronService.
  * This uses the gateway's RPC (via CLI) so the in-memory scheduler is updated

packages/plugin/src/types.ts

@@ -110,7 +110,9 @@ export type CloudOutbound =
   // Models list — plugin reports available providers/models
   | { type: "models.list"; models: Array<{ id: string; name: string; provider: string }> }
   // Model changed — plugin notifies that /model command switched the active model
-  | { type: "model.changed"; model: string; sessionKey: string };
+  | { type: "model.changed"; model: string; sessionKey: string }
+  // Default model updated — plugin applied BotsChat default model to OpenClaw config
+  | { type: "defaultModel.updated"; model: string };
 
 /** Cloud → Plugin (inbound, user messages) */
 export type CloudInbound =
@@ -171,6 +173,8 @@ export type CloudInbound =
   // Task scan request — cloud asks plugin to scan existing cron jobs
   | { type: "task.scan.request" }
   // Models request — cloud asks plugin for available models/providers
-  | { type: "models.request" };
+  | { type: "models.request" }
+  // Default model — cloud pushes user's default model so plugin applies it in OpenClaw config
+  | { type: "settings.defaultModel"; defaultModel: string };
 
 export type CloudMessage = CloudOutbound | CloudInbound;

packages/web/src/App.tsx

@@ -122,9 +122,7 @@ export default function App() {
         .then((user) => {
           dlog.info("Auth", `Logged in as ${user.email} (${user.id})`);
           dispatch({ type: "SET_USER", user });
-          if (user.settings?.defaultModel) {
-            dispatch({ type: "SET_DEFAULT_MODEL", model: user.settings.defaultModel });
-          }
+          // defaultModel comes from plugin via connection.status, not from user.settings
         })
         .catch((err) => {
           dlog.warn("Auth", `Auto-login failed: ${err}`);

packages/web/src/store.ts

@@ -302,12 +302,12 @@ export function appReducer(state: AppState, action: AppAction): AppState {
       };
     }
     case "SET_OPENCLAW_CONNECTED":
-      // connection.status carries the global defaultModel from OpenClaw config.
-      // It never touches sessionModel — that's per-session and managed separately.
+      // connection.status carries the gateway defaultModel (OpenClaw primary).
+      // Prefer user's saved default (from API/settings); only use gateway default when user has not set one.
       return {
         ...state,
         openclawConnected: action.connected,
-        defaultModel: action.defaultModel ?? state.defaultModel,
+        defaultModel: state.defaultModel ?? action.defaultModel ?? null,
       };
     case "SET_SESSION_MODEL":
       return { ...state, sessionModel: action.model };

scripts/dev.sh

@@ -58,16 +58,16 @@ do_start() {
 }
 
 do_sync_plugin() {
-  local REMOTE="mini.local"
+  local REMOTE_USER="mini.local"
   local REMOTE_DIR="~/Projects/botsChat/packages/plugin"
 
-  info "Syncing plugin to $REMOTE…"
+  info "Syncing plugin to mini.local…"
   rsync -avz --exclude node_modules --exclude .git --exclude dist --exclude .wrangler \
-    packages/plugin/ "$REMOTE:$REMOTE_DIR/"
+    packages/plugin/ "$REMOTE_USER:$REMOTE_DIR/"
   ok "Plugin files synced"
 
   info "Building plugin, deploying to extensions, restarting gateway on mini.local…"
-  ssh "$REMOTE" 'export PATH="/opt/homebrew/bin:$PATH"
+  ssh "$REMOTE_USER" 'export PATH="/opt/homebrew/bin:$PATH"
 cd ~/Projects/botsChat/packages/plugin
 npm run build
 EXT_DIR=~/.openclaw/extensions/botschat
@@ -83,7 +83,7 @@ echo "Gateway restarted (PID=$!)"'
 
   sleep 4
   info "Checking connection…"
-  ssh "$REMOTE" 'tail -5 /tmp/openclaw-gateway.log | grep -i "authenticated\|error\|Task scan"'
+  ssh "$REMOTE_USER" 'tail -5 /tmp/openclaw-gateway.log | grep -i "authenticated\|error\|Task scan"'
 }
 
 do_logs() {