@syengup/friday-channel-next 0.1.30 → 0.1.37

package/src/http/handlers/messages.ts

@@ -43,6 +43,7 @@ import {
   fridayAttachmentLookupKey,
   fridayFilesPublicUrl,
   readFile,
+  rememberInboundMediaName,
   resolveMediaAttachment,
   resolveMediaUrl,
 } from "./files.js";
@@ -76,7 +77,10 @@ const log = (
   logger[level](`[${action}] deviceId=${deviceId}${runPart}${detailPart}`);
 };
 
-function collectReplyPayloadMediaUrls(pl: { mediaUrls?: string[]; mediaUrl?: string | null }): string[] {
+function collectReplyPayloadMediaUrls(pl: {
+  mediaUrls?: string[];
+  mediaUrl?: string | null;
+}): string[] {
   const fromArr = Array.isArray(pl.mediaUrls)
     ? pl.mediaUrls.filter((u): u is string => typeof u === "string" && u.trim().length > 0)
     : [];
@@ -158,7 +162,12 @@ export function isCanvasSnapshotMediaPath(url: unknown): boolean {
 export function translateDeliverPayload(
   pl: FridayReplyPayload,
   kind: string,
-  meta?: { modelName?: string; totalTokens?: number; contextTokensUsed?: number; contextWindowMax?: number },
+  meta?: {
+    modelName?: string;
+    totalTokens?: number;
+    contextTokensUsed?: number;
+    contextWindowMax?: number;
+  },
 ): Record<string, unknown> {
   // Strip canvas-snapshot tool-result images before any media resolution (paths here are still the
   // original `/tmp/openclaw/openclaw-canvas-snapshot-*.jpg` temp paths, not yet copied to friday files).
@@ -209,7 +218,11 @@ export function translateDeliverPayload(
   if (typeof meta?.modelName === "string" && meta.modelName.trim()) {
     nextFridayNext.modelName = meta.modelName.trim();
   }
-  if (typeof meta?.totalTokens === "number" && Number.isFinite(meta.totalTokens) && meta.totalTokens > 0) {
+  if (
+    typeof meta?.totalTokens === "number" &&
+    Number.isFinite(meta.totalTokens) &&
+    meta.totalTokens > 0
+  ) {
     nextFridayNext.totalTokens = Math.floor(meta.totalTokens);
   }
   if (
@@ -259,8 +272,10 @@ function scheduleLateFinalMetaPatch(runId: string, attempts = 6): void {
             sessionKey: route.sessionKey,
             modelName: meta.modelName ?? null,
             totalTokens: typeof meta.totalTokens === "number" ? meta.totalTokens : null,
-            contextTokensUsed: typeof meta.contextTokensUsed === "number" ? meta.contextTokensUsed : null,
-            contextWindowMax: typeof meta.contextWindowMax === "number" ? meta.contextWindowMax : null,
+            contextTokensUsed:
+              typeof meta.contextTokensUsed === "number" ? meta.contextTokensUsed : null,
+            contextWindowMax:
+              typeof meta.contextWindowMax === "number" ? meta.contextWindowMax : null,
             ts: Date.now(),
           },
         },
@@ -297,11 +312,17 @@ function pickMetadataFromMessageLike(message: unknown): {
       ? usage.totalTokens
       : undefined) ??
     (typeof usage?.total === "number" && Number.isFinite(usage.total) ? usage.total : undefined) ??
-    (typeof usage?.total_tokens === "number" && Number.isFinite(usage.total_tokens) ? usage.total_tokens : undefined);
+    (typeof usage?.total_tokens === "number" && Number.isFinite(usage.total_tokens)
+      ? usage.total_tokens
+      : undefined);
   const totalFromMessage =
-    (typeof m.totalTokens === "number" && Number.isFinite(m.totalTokens) ? m.totalTokens : undefined) ??
-    (typeof m.total_tokens === "number" && Number.isFinite(m.total_tokens) ? m.total_tokens : undefined);
-  const totalTokens = Math.floor((totalFromUsage ?? totalFromMessage ?? 0));
+    (typeof m.totalTokens === "number" && Number.isFinite(m.totalTokens)
+      ? m.totalTokens
+      : undefined) ??
+    (typeof m.total_tokens === "number" && Number.isFinite(m.total_tokens)
+      ? m.total_tokens
+      : undefined);
+  const totalTokens = Math.floor(totalFromUsage ?? totalFromMessage ?? 0);
 
   let contextTokensUsed: number | undefined;
   if (usage) {
@@ -312,8 +333,12 @@ function pickMetadataFromMessageLike(message: unknown): {
   }
 
   const ctxMaxRaw =
-    (typeof m.contextWindow === "number" && Number.isFinite(m.contextWindow) ? m.contextWindow : undefined) ??
-    (typeof m.maxContextTokens === "number" && Number.isFinite(m.maxContextTokens) ? m.maxContextTokens : undefined);
+    (typeof m.contextWindow === "number" && Number.isFinite(m.contextWindow)
+      ? m.contextWindow
+      : undefined) ??
+    (typeof m.maxContextTokens === "number" && Number.isFinite(m.maxContextTokens)
+      ? m.maxContextTokens
+      : undefined);
   const contextWindowMax =
     typeof ctxMaxRaw === "number" && ctxMaxRaw > 0 ? Math.floor(ctxMaxRaw) : undefined;
 
@@ -335,9 +360,16 @@ async function resolveRunMetadataFromRuntimeSession(
   contextTokensUsed?: number;
   contextWindowMax?: number;
 } | null> {
-  const sessionApi = (runtime as unknown as {
-    subagent?: { getSessionMessages?: (params: { sessionKey: string; limit?: number }) => Promise<{ messages?: unknown[] }> };
-  }).subagent;
+  const sessionApi = (
+    runtime as unknown as {
+      subagent?: {
+        getSessionMessages?: (params: {
+          sessionKey: string;
+          limit?: number;
+        }) => Promise<{ messages?: unknown[] }>;
+      };
+    }
+  ).subagent;
   if (!sessionApi?.getSessionMessages) return null;
   try {
     const response = await sessionApi.getSessionMessages({ sessionKey, limit: 80 });
@@ -372,16 +404,23 @@ export function composeBodyWithMediaRefs(text: string, mediaRefs: string[]): str
   return trimmed ? `${trimmed}\n\n${mediaRefs.join("\n")}` : mediaRefs.join("\n");
 }
 
-async function buildBodyForAgentWithAttachments(text: string, attachmentIds: string[]): Promise<string> {
+async function buildBodyForAgentWithAttachments(
+  text: string,
+  attachmentIds: string[],
+): Promise<string> {
   if (attachmentIds.length === 0) return text.trim();
 
   const mediaRefs: string[] = [];
   for (const id of attachmentIds) {
-    const { buffer, mimeType } = readFile(fridayAttachmentLookupKey(id));
+    const { buffer, mimeType, filename } = readFile(fridayAttachmentLookupKey(id));
     if (!buffer) continue;
 
-    const saved = await saveInboundMediaBuffer(buffer, mimeType);
+    const saved = await saveInboundMediaBuffer(buffer, mimeType, filename);
     if (saved.id && saved.path) {
+      // Core's media-store renames inbound files to a bare uuid (no name/extension) and
+      // the transcript records that path — stash the original name now so history rebuild
+      // can restore it instead of surfacing the uuid.
+      if (filename) rememberInboundMediaName(saved.path, filename, mimeType);
       mediaRefs.push(`[media attached: file://${saved.path}]`);
     }
   }
@@ -534,7 +573,10 @@ export async function handleMessages(req: IncomingMessage, res: ServerResponse):
         dispatcherOptions: {
           deliver: async (pl: any, info: any) => {
             let meta = getRunMetadata(runId);
-            if (info.kind.toLowerCase() === "final" && !(meta?.modelName || typeof meta?.totalTokens === "number")) {
+            if (
+              info.kind.toLowerCase() === "final" &&
+              !(meta?.modelName || typeof meta?.totalTokens === "number")
+            ) {
               const resolved = await resolveRunMetadataFromRuntimeSession(runtime, baseSessionKey);
               if (resolved) {
                 setRunMetadata(runId, resolved);
@@ -597,10 +639,11 @@ export async function handleMessages(req: IncomingMessage, res: ServerResponse):
           // OpenClaw `pi-embedded-subscribe` gates `streamReasoning` on `typeof onReasoningStream === "function"`.
           // Without this, `emitReasoningStream` never runs and Friday SSE never sees `stream: "thinking"`.
           onReasoningStream: async (pl: unknown) => {
-            const text =
+            const rawText =
               typeof pl === "object" && pl !== null && "text" in pl
-                ? String((pl as { text?: unknown }).text ?? "")
-                : "";
+                ? (pl as { text?: unknown }).text
+                : undefined;
+            const text = typeof rawText === "string" ? rawText : "";
             log("REASONING_STREAM", normalizedDeviceId, runId, `textLen=${text.length}`);
           },
           onReasoningEnd: async () => {

package/src/http/handlers/models-list.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { EventEmitter } from "node:events";
+import { handleModelsList } from "./models-list.js";
+import { setMockRuntime } from "../../test-support/mock-runtime.js";
+import {
+  setFridayAgentForwardRuntime,
+  resetFridayAgentForwardRuntimeForTest,
+} from "../../agent-forward-runtime.js";
+
+class MockRes extends EventEmitter {
+  statusCode = 0;
+  headers: Record<string, string> = {};
+  body = "";
+  setHeader(name: string, value: string): void {
+    this.headers[name.toLowerCase()] = value;
+  }
+  end(body?: string): void {
+    if (body) this.body += body;
+  }
+}
+
+function makeReq(headers: Record<string, string> = {}, method = "GET"): any {
+  return { method, url: "/friday-next/models", headers };
+}
+
+const AUTH = { authorization: "Bearer test-token" };
+
+/** Inject config + an optional per-model thinking-policy resolver into the forward runtime. */
+function setRuntime(
+  config: unknown,
+  resolveThinkingPolicy?: (params: { provider?: string | null; model?: string | null }) => {
+    levels: Array<{ id: string; label: string }>;
+    defaultLevel?: string | null;
+  },
+): void {
+  setFridayAgentForwardRuntime({
+    runtime: {
+      agent: {
+        session: { resolveStorePath: () => "", loadSessionStore: () => ({}) },
+        ...(resolveThinkingPolicy ? { resolveThinkingPolicy } : {}),
+      },
+      config: { current: () => config },
+    },
+  } as never);
+}
+
+const CONFIG = {
+  models: {
+    providers: {
+      openai: { models: [{ id: "gpt-5.4", name: "GPT-5.4", reasoning: true }] },
+    },
+  },
+  agents: { defaults: { models: { "openai/gpt-5.4": {} }, model: "openai/gpt-5.4" } },
+};
+
+describe("handleModelsList thinking levels", () => {
+  beforeEach(() => {
+    setMockRuntime();
+  });
+
+  afterEach(() => {
+    resetFridayAgentForwardRuntimeForTest();
+  });
+
+  it("attaches the per-model thinking levels + default resolved from the runtime", async () => {
+    setRuntime(CONFIG, ({ provider, model }) => {
+      expect(provider).toBe("openai");
+      expect(model).toBe("gpt-5.4");
+      return {
+        levels: [
+          { id: "off", label: "off" },
+          { id: "low", label: "low" },
+          { id: "medium", label: "medium" },
+          { id: "high", label: "high" },
+          { id: "xhigh", label: "xhigh" },
+        ],
+        defaultLevel: "high",
+      };
+    });
+
+    const res = new MockRes();
+    await handleModelsList(makeReq(AUTH), res as any);
+
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body);
+    const model = body.models.find((m: any) => m.id === "openai/gpt-5.4");
+    expect(model.thinkingLevels.map((l: any) => l.id)).toEqual([
+      "off",
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+    ]);
+    expect(model.thinkingDefault).toBe("high");
+  });
+
+  it("falls back to the base five levels and omits thinkingDefault on a legacy gateway", async () => {
+    setRuntime(CONFIG); // no resolveThinkingPolicy
+
+    const res = new MockRes();
+    await handleModelsList(makeReq(AUTH), res as any);
+
+    const body = JSON.parse(res.body);
+    const model = body.models.find((m: any) => m.id === "openai/gpt-5.4");
+    expect(model.thinkingLevels.map((l: any) => l.id)).toEqual([
+      "off",
+      "minimal",
+      "low",
+      "medium",
+      "high",
+    ]);
+    expect(model.thinkingDefault).toBeUndefined();
+  });
+});

package/src/http/handlers/models-list.ts

@@ -1,6 +1,7 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { getFridayAgentForwardRuntime } from "../../agent-forward-runtime.js";
 import { splitModelRef } from "../../session/session-manager.js";
+import { resolveModelThinking, type ThinkingLevelOption } from "../../thinking-levels.js";
 import { extractBearerToken } from "../middleware/auth.js";
 
 export interface FridayModelEntry {
@@ -10,6 +11,10 @@ export interface FridayModelEntry {
   reasoning?: boolean;
   contextWindow?: number;
   maxTokens?: number;
+  /** Thinking levels this model supports (varies per model). Omitted when only the base set applies. */
+  thinkingLevels?: ThinkingLevelOption[];
+  /** Provider/model default thinking level, when the gateway reports one. */
+  thinkingDefault?: string;
 }
 
 interface ResolvedModels {
@@ -39,7 +44,7 @@ function resolveConfiguredModels(): ResolvedModels {
       seen.add(modelKey);
       entries.push({
         id: modelKey,
-        name: typeof info?.alias === "string" ? info.alias : meta?.name ?? split.modelId,
+        name: typeof info?.alias === "string" ? info.alias : (meta?.name ?? split.modelId),
         provider: split.provider,
         reasoning: meta?.reasoning,
         contextWindow: meta?.contextWindow,
@@ -89,16 +94,29 @@ function resolveConfiguredModels(): ResolvedModels {
     });
   }
 
+  for (const entry of entries) {
+    const split = splitModelRef(entry.id);
+    const thinking = resolveModelThinking(entry.provider || split.provider, split.modelId);
+    entry.thinkingLevels = thinking.levels;
+    if (thinking.default) entry.thinkingDefault = thinking.default;
+  }
+
   return { models: entries, defaultModel };
 }
 
-function buildProviderModelMeta(cfg: Record<string, unknown>): Map<string, {
-  name?: string;
-  reasoning?: boolean;
-  contextWindow?: number;
-  maxTokens?: number;
-}> {
-  const meta = new Map<string, { name?: string; reasoning?: boolean; contextWindow?: number; maxTokens?: number }>();
+function buildProviderModelMeta(cfg: Record<string, unknown>): Map<
+  string,
+  {
+    name?: string;
+    reasoning?: boolean;
+    contextWindow?: number;
+    maxTokens?: number;
+  }
+> {
+  const meta = new Map<
+    string,
+    { name?: string; reasoning?: boolean; contextWindow?: number; maxTokens?: number }
+  >();
   const models = cfg?.models as Record<string, unknown> | undefined;
   const providers = models?.providers as Record<string, unknown> | undefined;
   if (providers) {

package/src/http/handlers/nodes-approve.test.ts

@@ -24,8 +24,14 @@ class MockRes extends EventEmitter {
   }
 }
 
-function mockReq(method: string, headers: Record<string, string> = {}): PassThrough & { method: string; headers: Record<string, string> } {
-  const stream = new PassThrough() as unknown as PassThrough & { method: string; headers: Record<string, string> };
+function mockReq(
+  method: string,
+  headers: Record<string, string> = {},
+): PassThrough & { method: string; headers: Record<string, string> } {
+  const stream = new PassThrough() as unknown as PassThrough & {
+    method: string;
+    headers: Record<string, string>;
+  };
   stream.method = method;
   stream.headers = headers;
   return stream;
@@ -92,7 +98,10 @@ describe("handleNodesApprove", () => {
   });
 
   it("returns 404 when listNodePairing returns data without matching node", async () => {
-    mockList.mockResolvedValueOnce({ pending: [{ requestId: "x", nodeId: "UNMATCHED" }], paired: [] });
+    mockList.mockResolvedValueOnce({
+      pending: [{ requestId: "x", nodeId: "UNMATCHED" }],
+      paired: [],
+    });
 
     const req = mockReq("POST", { authorization: "Bearer test-token" });
     const res = new MockRes() as unknown as ServerResponse;
@@ -135,7 +144,9 @@ describe("handleNodesApprove", () => {
   it("returns 200 with alreadyApproved when node in paired with caps", async () => {
     mockList.mockResolvedValueOnce({
       pending: [],
-      paired: [{ nodeId: NODE_ID, approvedAtMs: 100, caps: ["canvas"], commands: ["canvas.present"] }],
+      paired: [
+        { nodeId: NODE_ID, approvedAtMs: 100, caps: ["canvas"], commands: ["canvas.present"] },
+      ],
     });
 
     const req = mockReq("POST", { authorization: "Bearer test-token" });

package/src/http/handlers/nodes-approve.ts

@@ -14,15 +14,6 @@ interface PairedNodeEntry {
   caps?: string[];
   commands?: string[];
 }
-interface NodePairingList {
-  pending: PendingNodeEntry[];
-  paired: PairedNodeEntry[];
-}
-type ApproveNodePairingResult =
-  | { requestId: string; node: PairedNodeEntry }
-  | { status: "forbidden"; missingScope: string }
-  | null;
-
 export async function handleNodesApprove(
   req: IncomingMessage,
   res: ServerResponse,
@@ -62,7 +53,7 @@ export async function handleNodesApprove(
 
   const normalizedNodeId = rawNodeId.trim().toUpperCase();
 
-let listData, listNodePairing, approveNodePairing;
+  let listData, listNodePairing, approveNodePairing;
   try {
     ({ listNodePairing, approveNodePairing } = await loadNodePairingModule());
   } catch (err) {
@@ -91,12 +82,7 @@ let listData, listNodePairing, approveNodePairing;
     const requestId = pendingMatch.requestId;
     log.info(`approving nodeId=${normalizedNodeId} requestId=${requestId}`);
 
-    const callerScopes = [
-      "operator.admin",
-      "operator.pairing",
-      "operator.read",
-      "operator.write",
-    ];
+    const callerScopes = ["operator.admin", "operator.pairing", "operator.read", "operator.write"];
 
     let approved;
     try {
@@ -105,10 +91,12 @@ let listData, listNodePairing, approveNodePairing;
       log.error(`approveNodePairing failed: ${err instanceof Error ? err.message : String(err)}`);
       res.statusCode = 502;
       res.setHeader("Content-Type", "application/json");
-      res.end(JSON.stringify({
-        error: "Node approval failed",
-        detail: err instanceof Error ? err.message : "Unknown error",
-      }));
+      res.end(
+        JSON.stringify({
+          error: "Node approval failed",
+          detail: err instanceof Error ? err.message : "Unknown error",
+        }),
+      );
       return true;
     }
 
@@ -122,18 +110,22 @@ let listData, listNodePairing, approveNodePairing;
     if ("status" in approved && approved.status === "forbidden") {
       res.statusCode = 403;
       res.setHeader("Content-Type", "application/json");
-      res.end(JSON.stringify({ error: `Node approval forbidden: ${(approved as any).missingScope ?? "unknown"}` }));
+      res.end(
+        JSON.stringify({ error: `Node approval forbidden: ${approved.missingScope ?? "unknown"}` }),
+      );
       return true;
     }
 
     res.statusCode = 200;
     res.setHeader("Content-Type", "application/json");
-    res.end(JSON.stringify({
-      ok: true,
-      nodeId: normalizedNodeId,
-      requestId: (approved as any).requestId,
-      approvedAtMs: (approved as any).node?.approvedAtMs,
-    }));
+    res.end(
+      JSON.stringify({
+        ok: true,
+        nodeId: normalizedNodeId,
+        requestId: approved.requestId,
+        approvedAtMs: approved.node?.approvedAtMs,
+      }),
+    );
     return true;
   }
 
@@ -147,26 +139,32 @@ let listData, listNodePairing, approveNodePairing;
     const caps = pairedMatch.caps ?? [];
     const commands = pairedMatch.commands ?? [];
     if (caps.length > 0 || commands.length > 0) {
-      log.info(`nodeId=${normalizedNodeId} already paired with caps=${caps.length} commands=${commands.length}`);
+      log.info(
+        `nodeId=${normalizedNodeId} already paired with caps=${caps.length} commands=${commands.length}`,
+      );
       res.statusCode = 200;
       res.setHeader("Content-Type", "application/json");
-      res.end(JSON.stringify({
-        ok: true,
-        nodeId: normalizedNodeId,
-        alreadyApproved: true,
-        approvedAtMs: pairedMatch.approvedAtMs,
-        caps,
-        commands,
-      }));
+      res.end(
+        JSON.stringify({
+          ok: true,
+          nodeId: normalizedNodeId,
+          alreadyApproved: true,
+          approvedAtMs: pairedMatch.approvedAtMs,
+          caps,
+          commands,
+        }),
+      );
       return true;
     }
   }
 
   res.statusCode = 404;
   res.setHeader("Content-Type", "application/json");
-  res.end(JSON.stringify({
-    error: "No pending node found for this nodeId",
-    nodeId: normalizedNodeId,
-  }));
+  res.end(
+    JSON.stringify({
+      error: "No pending node found for this nodeId",
+      nodeId: normalizedNodeId,
+    }),
+  );
   return true;
 }

package/src/http/handlers/plugin-info.ts

@@ -1,11 +1,7 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
 import { extractBearerToken } from "../middleware/auth.js";
 import { PLUGIN_VERSION } from "../../version.js";
-import {
-  fetchLatestVersion,
-  getInstallSource,
-  semverGreater,
-} from "../../plugin-install-info.js";
+import { fetchLatestVersion, getInstallSource, semverGreater } from "../../plugin-install-info.js";
 
 export interface PluginInfoResult {
   currentVersion: string;
@@ -17,7 +13,10 @@ export interface PluginInfoResult {
   upgradable: boolean;
 }
 
-export async function handlePluginInfo(req: IncomingMessage, res: ServerResponse): Promise<boolean> {
+export async function handlePluginInfo(
+  req: IncomingMessage,
+  res: ServerResponse,
+): Promise<boolean> {
   if (req.method !== "GET") {
     res.statusCode = 405;
     res.setHeader("Content-Type", "application/json");

package/src/http/handlers/plugin-upgrade.ts

@@ -18,7 +18,10 @@ const RESTART_DELAY_MS = 500;
  * eligible — dev (load.paths / source==="path") installs return 409 to protect
  * the dev environment from duplicate npm installs.
  */
-export async function handlePluginUpgrade(req: IncomingMessage, res: ServerResponse): Promise<boolean> {
+export async function handlePluginUpgrade(
+  req: IncomingMessage,
+  res: ServerResponse,
+): Promise<boolean> {
   if (req.method !== "POST") {
     res.statusCode = 405;
     res.setHeader("Content-Type", "application/json");

package/src/http/handlers/sessions-settings.ts

@@ -8,9 +8,9 @@ import {
 } from "../../session/session-manager.js";
 import { readJsonBody } from "../middleware/body.js";
 import { extractBearerToken } from "../middleware/auth.js";
+import { resolveModelThinkingForRef } from "../../thinking-levels.js";
 
 const VALID_REASONING = new Set(["on", "off", "stream"]);
-const VALID_THINKING = new Set(["off", "minimal", "low", "medium", "high"]);
 
 export async function handleSessionsSettings(
   req: IncomingMessage,
@@ -61,12 +61,25 @@ export async function handleSessionsSettings(
   const thinkingLevel = typeof body?.thinkingLevel === "string" ? body.thinkingLevel : undefined;
   const modelRef = typeof body?.modelRef === "string" ? body.modelRef.trim() : undefined;
 
+  // The app omits (or empties) modelRef to mean "use the agent's default model". Resolve that
+  // default and write it as an *explicit* override, identical in shape to any other selection — so
+  // the agent runs the default exactly the way it runs an explicitly-picked model. Do NOT just
+  // clear the override here: the session entry is shared with the OpenClaw core, which stamps it
+  // with provenance fields (`modelOverrideSource`, `model`, `modelProvider`); deleting only our
+  // three fields leaves those dangling and the core mis-resolves to a fallback model.
+  const effectiveModelRef = modelRef || resolveAgentDefaults(sessionKey).model;
+
   const errors: string[] = [];
   if (reasoningLevel !== undefined && !VALID_REASONING.has(reasoningLevel)) {
     errors.push(`reasoningLevel must be one of: ${[...VALID_REASONING].join(", ")}`);
   }
-  if (thinkingLevel !== undefined && !VALID_THINKING.has(thinkingLevel)) {
-    errors.push(`thinkingLevel must be one of: ${[...VALID_THINKING].join(", ")}`);
+  if (thinkingLevel !== undefined) {
+    // Thinking levels vary per model, so validate against the levels the *effective* model supports
+    // (resolved from the running gateway). Falls back to the base five levels when unresolvable.
+    const supported = resolveModelThinkingForRef(effectiveModelRef).levels.map((l) => l.id);
+    if (!supported.includes(thinkingLevel)) {
+      errors.push(`thinkingLevel must be one of: ${supported.join(", ")}`);
+    }
   }
 
   if (errors.length > 0) {
@@ -76,14 +89,6 @@ export async function handleSessionsSettings(
     return true;
   }
 
-  // The app omits (or empties) modelRef to mean "use the agent's default model". Resolve that
-  // default and write it as an *explicit* override, identical in shape to any other selection — so
-  // the agent runs the default exactly the way it runs an explicitly-picked model. Do NOT just
-  // clear the override here: the session entry is shared with the OpenClaw core, which stamps it
-  // with provenance fields (`modelOverrideSource`, `model`, `modelProvider`); deleting only our
-  // three fields leaves those dangling and the core mis-resolves to a fallback model.
-  const effectiveModelRef = modelRef || resolveAgentDefaults(sessionKey).model;
-
   const settings: FridaySessionSettingsUpdate = { reasoningLevel, thinkingLevel };
   if (effectiveModelRef) {
     const split = splitModelRef(effectiveModelRef);

package/src/http/handlers/sse.ts

@@ -67,7 +67,9 @@ export async function handleSseStream(req: IncomingMessage, res: ServerResponse)
   const lastEventId = parseLastEventId(req, url);
   if (lastEventId > 0) sseEmitter.replayBacklog(deviceId, lastEventId);
 
-  const config = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(getFridayNextRuntime().config));
+  const config = resolveFridayNextConfig(
+    getHostOpenClawConfigSnapshot(getFridayNextRuntime().config),
+  );
   const keepalive = setInterval(() => {
     if (conn.isClosed) {
       clearInterval(keepalive);