@syengup/friday-channel-next 0.1.30 → 0.1.36

package/dist/src/http/handlers/agent-files.js

@@ -0,0 +1,137 @@
+/**
+ * GET/PUT /friday-next/agents/{id}/files[/{name}]
+ *
+ * Reads and edits an agent's core workspace files — the same whitelist ControlUI
+ * exposes (AGENTS/IDENTITY/SOUL/TOOLS/MEMORY/USER/HEARTBEAT/BOOTSTRAP.md). These
+ * are plain workspace files, not config: written directly via Node fs into the
+ * dir resolved by `api.runtime.agent.resolveAgentWorkspaceDir` (the same call
+ * agents-list uses to read IDENTITY.md). No config mutation, no gateway restart —
+ * the agent re-reads them on its next run.
+ *
+ *  - GET  /agents/{id}/files          → status of every whitelist file
+ *  - GET  /agents/{id}/files/{name}   → one file's content
+ *  - PUT  /agents/{id}/files/{name}   → write one file (body: { content })
+ *
+ * Security: the file name MUST be in the whitelist (no path traversal), and the
+ * resolved path is re-checked to stay inside the workspace dir as defense in depth.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { getFridayAgentForwardRuntime } from "../../agent-forward-runtime.js";
+import { normalizeAgentId } from "../../agent-id.js";
+import { extractBearerToken } from "../middleware/auth.js";
+import { readJsonBody } from "../middleware/body.js";
+import { createFridayNextLogger } from "../../logging.js";
+/** Core workspace files an agent edits, mirroring ControlUI's `agents.files` whitelist. */
+export const CORE_AGENT_FILES = [
+    "AGENTS.md",
+    "IDENTITY.md",
+    "SOUL.md",
+    "TOOLS.md",
+    "MEMORY.md",
+    "USER.md",
+    "HEARTBEAT.md",
+    "BOOTSTRAP.md",
+];
+const CORE_FILE_SET = new Set(CORE_AGENT_FILES);
+/** Max core-file size on write (256 KiB) — these are prompts, not data dumps. */
+const MAX_FILE_BYTES = 256 * 1024;
+function json(res, status, body) {
+    res.statusCode = status;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify(body));
+    return true;
+}
+/** Resolve the agent's workspace dir, or undefined if the runtime can't. */
+function resolveWorkspace(agentId) {
+    const rt = getFridayAgentForwardRuntime();
+    if (!rt?.resolveAgentWorkspaceDir)
+        return undefined;
+    try {
+        const dir = rt.resolveAgentWorkspaceDir(rt.getConfig(), agentId);
+        return dir || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Whitelisted, traversal-safe absolute path for `name` inside `workspace`, or null. */
+function safeFilePath(workspace, name) {
+    if (!CORE_FILE_SET.has(name))
+        return null;
+    const resolved = path.resolve(workspace, name);
+    // Defense in depth: the resolved path must sit directly inside the workspace.
+    if (path.dirname(resolved) !== path.resolve(workspace))
+        return null;
+    return resolved;
+}
+export async function handleAgentFiles(req, res, rawAgentId, fileName) {
+    const method = req.method;
+    if (method !== "GET" && method !== "PUT") {
+        return json(res, 405, { error: "Method Not Allowed" });
+    }
+    if (!extractBearerToken(req)) {
+        return json(res, 401, { error: "Unauthorized: bearer token mismatch" });
+    }
+    const agentId = normalizeAgentId(rawAgentId);
+    const workspace = resolveWorkspace(agentId);
+    if (!workspace)
+        return json(res, 503, { error: "Agent workspace not resolvable" });
+    // GET /files — list whitelist status.
+    if (method === "GET" && !fileName) {
+        const files = CORE_AGENT_FILES.map((name) => {
+            try {
+                const stat = fs.statSync(path.join(workspace, name));
+                return { name, exists: true, bytes: stat.size };
+            }
+            catch {
+                return { name, exists: false, bytes: 0 };
+            }
+        });
+        return json(res, 200, { ok: true, id: agentId, files });
+    }
+    if (!fileName || !CORE_FILE_SET.has(fileName)) {
+        return json(res, 400, {
+            error: `Unknown core file; allowed: ${CORE_AGENT_FILES.join(", ")}`,
+        });
+    }
+    const filePath = safeFilePath(workspace, fileName);
+    if (!filePath)
+        return json(res, 400, { error: "Invalid file name" });
+    if (method === "GET") {
+        try {
+            const content = fs.readFileSync(filePath, "utf-8");
+            return json(res, 200, { ok: true, id: agentId, name: fileName, exists: true, content });
+        }
+        catch {
+            return json(res, 200, { ok: true, id: agentId, name: fileName, exists: false, content: "" });
+        }
+    }
+    // PUT — write content.
+    const body = await readJsonBody(req);
+    if (!body || typeof body.content !== "string") {
+        return json(res, 400, { error: "Missing required field: content (string)" });
+    }
+    const content = body.content;
+    if (Buffer.byteLength(content, "utf-8") > MAX_FILE_BYTES) {
+        return json(res, 413, { error: `content exceeds ${MAX_FILE_BYTES} bytes` });
+    }
+    const log = createFridayNextLogger("agent-files");
+    try {
+        fs.mkdirSync(workspace, { recursive: true });
+        fs.writeFileSync(filePath, content, "utf-8");
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        log.error(`write ${fileName} for "${agentId}" failed: ${msg}`);
+        return json(res, 500, { error: "Failed to write file", detail: msg });
+    }
+    log.info(`wrote ${fileName} for "${agentId}" (${Buffer.byteLength(content, "utf-8")} bytes)`);
+    return json(res, 200, {
+        ok: true,
+        id: agentId,
+        name: fileName,
+        exists: true,
+        bytes: Buffer.byteLength(content, "utf-8"),
+    });
+}

package/dist/src/http/handlers/agent-tools-catalog.d.ts

@@ -0,0 +1,10 @@
+/**
+ * GET /friday-next/agents/{id}/tools/catalog
+ *
+ * Returns the agent's full tool catalog (core + plugin tools, grouped by category,
+ * with descriptions, profiles, and per-tool effective `enabled`/`inProfile` state) for
+ * the app's toolbox editor — mirroring ControlUI. Edits are saved via the existing
+ * `PUT /agents/{id}/config` (tools.{profile,allow,alsoAllow,deny}).
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare function handleAgentToolsCatalog(req: IncomingMessage, res: ServerResponse, rawAgentId: string): Promise<boolean>;

package/dist/src/http/handlers/agent-tools-catalog.js

@@ -0,0 +1,33 @@
+/**
+ * GET /friday-next/agents/{id}/tools/catalog
+ *
+ * Returns the agent's full tool catalog (core + plugin tools, grouped by category,
+ * with descriptions, profiles, and per-tool effective `enabled`/`inProfile` state) for
+ * the app's toolbox editor — mirroring ControlUI. Edits are saved via the existing
+ * `PUT /agents/{id}/config` (tools.{profile,allow,alsoAllow,deny}).
+ */
+import { getFridayAgentForwardRuntime } from "../../agent-forward-runtime.js";
+import { normalizeAgentId } from "../../agent-id.js";
+import { buildAgentToolsCatalog } from "../../tool-catalog.js";
+import { extractBearerToken } from "../middleware/auth.js";
+function json(res, status, body) {
+    res.statusCode = status;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify(body));
+    return true;
+}
+export async function handleAgentToolsCatalog(req, res, rawAgentId) {
+    if (req.method !== "GET") {
+        return json(res, 405, { error: "Method Not Allowed" });
+    }
+    if (!extractBearerToken(req)) {
+        return json(res, 401, { error: "Unauthorized: bearer token mismatch" });
+    }
+    const agentId = normalizeAgentId(rawAgentId);
+    const cfg = getFridayAgentForwardRuntime()?.getConfig();
+    const catalog = await buildAgentToolsCatalog(cfg, agentId);
+    if (!catalog) {
+        return json(res, 503, { error: "Tool catalog unavailable" });
+    }
+    return json(res, 200, { ok: true, id: agentId, ...catalog });
+}

package/dist/src/http/handlers/agents-list.js

@@ -2,25 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { getFridayAgentForwardRuntime, } from "../../agent-forward-runtime.js";
 import { extractBearerToken } from "../middleware/auth.js";
-const DEFAULT_AGENT_ID = "main";
-/** Agent ids already in path/shell-safe form skip the slug rewrite below. */
-const SAFE_AGENT_ID = /^[a-z0-9][a-z0-9_-]*$/;
-/**
- * Mirror of OpenClaw's `normalizeAgentId` (src/routing/session-key.ts): trim,
- * lowercase, keep path/shell-safe. Empty → "main".
- */
-function normalizeAgentId(value) {
-    const trimmed = typeof value === "string" ? value.trim() : "";
-    if (!trimmed)
-        return DEFAULT_AGENT_ID;
-    const lowered = trimmed.toLowerCase();
-    if (SAFE_AGENT_ID.test(lowered))
-        return lowered;
-    return (lowered
-        .replace(/[^a-z0-9_-]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, 64) || DEFAULT_AGENT_ID);
-}
+import { DEFAULT_AGENT_ID, normalizeAgentId } from "../../agent-id.js";
 /** Extract a primary model ref from the `model` field (string or {primary,...}). */
 function resolvePrimaryModel(model) {
     if (typeof model === "string")

package/dist/src/http/handlers/cancel.js

@@ -1,4 +1,5 @@
-import { abortRun } from "../../agent/abort-run.js";
+import { abortRunForSessionKey } from "../../agent/abort-run.js";
+import { getRunRoute } from "../../run-metadata.js";
 import { sseEmitter } from "../../sse/emitter.js";
 import { readJsonBody } from "../middleware/body.js";
 import { extractBearerToken } from "../middleware/auth.js";
@@ -18,16 +19,21 @@ export async function handleCancel(req, res) {
     }
     const body = await readJsonBody(req);
     const runId = typeof body?.runId === "string" ? body.runId.trim() : "";
-    if (!runId) {
+    // sessionKey is the primary identifier (one active run per session); runId is a
+    // back-compat fallback for older apps — resolve it to a sessionKey via the run route.
+    const sessionKey = (typeof body?.sessionKey === "string" ? body.sessionKey.trim() : "") ||
+        (runId ? getRunRoute(runId)?.sessionKey?.trim() ?? "" : "");
+    if (!sessionKey && !runId) {
         res.statusCode = 400;
         res.setHeader("Content-Type", "application/json");
-        res.end(JSON.stringify({ error: "Missing runId" }));
+        res.end(JSON.stringify({ error: "Missing sessionKey or runId" }));
         return true;
     }
-    await abortRun(runId);
-    sseEmitter.untrackRun(runId);
+    const result = sessionKey ? await abortRunForSessionKey(sessionKey) : { aborted: false, drained: false };
+    if (runId)
+        sseEmitter.untrackRun(runId);
     res.statusCode = 200;
     res.setHeader("Content-Type", "application/json");
-    res.end(JSON.stringify({ ok: true, runId, cancelled: true }));
+    res.end(JSON.stringify({ ok: true, sessionKey, runId, cancelled: true, ...result }));
     return true;
 }

package/dist/src/http/handlers/files.d.ts

@@ -17,6 +17,18 @@ export interface StoredFile {
     path: string;
     createdAt: number;
 }
+/** Clear the in-memory file index. Test-only: simulates a gateway restart. */
+export declare function clearFileIndexForTest(): void;
+/**
+ * Remember the original upload filename for an inbound media file.
+ *
+ * When a user sends an attachment, core's media-store copies it to
+ * `~/.openclaw/media/inbound/<uuid>` — a bare uuid with no extension and no original
+ * name — and the transcript records THAT path. So on history rebuild the original name
+ * is unrecoverable. We stash it here (keyed by the inbound basename, reusing the sidecar
+ * scheme but inside our own attachments dir) at send time, while we still know it.
+ */
+export declare function rememberInboundMediaName(inboundPath: string, filename: string, mimeType: string): void;
 /**
  * Read a file from `attachments/` by URL path token (disk basename).
  * Used when the in-memory index was cleared after a gateway restart.
@@ -24,7 +36,10 @@ export interface StoredFile {
 export declare function readAttachmentFileFromDisk(fileToken: string): {
     buffer: Buffer;
     mimeType: string;
+    /** Original display/download filename (from sidecar; falls back to the on-disk basename). */
     filename: string;
+    /** On-disk basename / urlToken — use this to build `/friday-next/files/{token}` URLs. */
+    diskName: string;
 } | null;
 /**
  * Copy a local file into `attachments/` and register it (no full-buffer read for the copy path).
@@ -54,6 +69,7 @@ export declare function getExternalFileSourceByUrlToken(token: string): string |
 export declare function readFile(id: string): {
     buffer: Buffer | null;
     mimeType: string;
+    filename?: string;
 };
 /**
  * Copy a file from a local filesystem path into the Friday Next channel file store

package/dist/src/http/handlers/files.js

@@ -53,6 +53,57 @@ function registerStoredFile(file) {
 function resolveStoredFile(key) {
     return fileIndex.get(key) ?? fileTokenIndex.get(key);
 }
+/** Clear the in-memory file index. Test-only: simulates a gateway restart. */
+export function clearFileIndexForTest() {
+    fileIndex.clear();
+    fileTokenIndex.clear();
+    externalFileSourceIndex.clear();
+}
+const META_SIDECAR_SUFFIX = ".fnmeta";
+function metaSidecarPath(urlToken) {
+    return path.join(getAttachmentsDir(), `${urlToken}${META_SIDECAR_SUFFIX}`);
+}
+function writeAttachmentMetaSidecar(urlToken, filename, mimeType) {
+    try {
+        fs.writeFileSync(metaSidecarPath(urlToken), JSON.stringify({ filename, mimeType }));
+    }
+    catch (err) {
+        logger.warn(`writeAttachmentMetaSidecar failed for "${urlToken}": ${String(err)}`);
+    }
+}
+/**
+ * Remember the original upload filename for an inbound media file.
+ *
+ * When a user sends an attachment, core's media-store copies it to
+ * `~/.openclaw/media/inbound/<uuid>` — a bare uuid with no extension and no original
+ * name — and the transcript records THAT path. So on history rebuild the original name
+ * is unrecoverable. We stash it here (keyed by the inbound basename, reusing the sidecar
+ * scheme but inside our own attachments dir) at send time, while we still know it.
+ */
+export function rememberInboundMediaName(inboundPath, filename, mimeType) {
+    const key = path.basename(inboundPath);
+    const name = filename.trim();
+    if (!key || !name)
+        return;
+    writeAttachmentMetaSidecar(key, name, mimeType);
+}
+function readAttachmentMetaSidecar(urlToken) {
+    try {
+        const raw = fs.readFileSync(metaSidecarPath(urlToken), "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed.filename === "string" && parsed.filename) {
+            return {
+                filename: parsed.filename,
+                mimeType: typeof parsed.mimeType === "string" ? parsed.mimeType : "",
+            };
+        }
+    }
+    catch {
+        // Missing or malformed sidecar (e.g. attachment stored before this fix) — caller
+        // falls back to the on-disk basename.
+    }
+    return null;
+}
 /**
  * Read a file from `attachments/` by URL path token (disk basename).
  * Used when the in-memory index was cleared after a gateway restart.
@@ -61,13 +112,21 @@ export function readAttachmentFileFromDisk(fileToken) {
     const safe = path.basename(fileToken);
     if (!safe || safe === "." || safe === "..")
         return null;
+    if (safe.endsWith(META_SIDECAR_SUFFIX))
+        return null;
     const dir = getAttachmentsDir();
     const full = path.join(dir, safe);
     if (!fs.existsSync(full) || !fs.statSync(full).isFile())
         return null;
     try {
         const buffer = fs.readFileSync(full);
-        return { buffer, mimeType: guessMimeType(safe), filename: safe };
+        const meta = readAttachmentMetaSidecar(safe);
+        return {
+            buffer,
+            mimeType: meta?.mimeType || guessMimeType(safe),
+            filename: meta?.filename || safe,
+            diskName: safe,
+        };
     }
     catch {
         return null;
@@ -97,16 +156,19 @@ export function normalizeAgentMediaPath(raw) {
     }
     return s;
 }
-function copyLocalFileToAttachments(sourcePath) {
+function copyLocalFileToAttachments(sourcePath, originalFilename) {
     const resolvedPath = normalizeAgentMediaPath(sourcePath);
-    const filename = path.basename(resolvedPath);
+    const diskBasename = path.basename(resolvedPath);
+    // Prefer the caller-supplied original name (recovered from an inbound sidecar); fall
+    // back to the on-disk basename (which for core inbound media is a bare uuid).
+    const filename = originalFilename?.trim() || diskBasename;
     if (!filename)
         return null;
     try {
         if (!fs.existsSync(resolvedPath) || !fs.statSync(resolvedPath).isFile())
             return null;
         const id = crypto.randomUUID();
-        const ext = path.extname(filename);
+        const ext = path.extname(filename) || path.extname(diskBasename);
         const urlToken = ext ? `${id}${ext}` : id;
         const storedPath = path.join(getAttachmentsDir(), urlToken);
         try {
@@ -131,6 +193,7 @@ function copyLocalFileToAttachments(sourcePath) {
             createdAt: Date.now(),
         };
         registerStoredFile(file);
+        writeAttachmentMetaSidecar(urlToken, filename, mimeType);
         return file;
     }
     catch (err) {
@@ -163,6 +226,7 @@ export function storeFile(buffer, filename, mimeType) {
         createdAt: Date.now(),
     };
     registerStoredFile(file);
+    writeAttachmentMetaSidecar(urlToken, safeFilename, mimeType);
     return file;
 }
 /**
@@ -196,7 +260,7 @@ export function fridayFilesPublicUrl(ref) {
     }
     const disk = readAttachmentFileFromDisk(lookupKey);
     if (disk) {
-        return `/friday-next/files/${encodeURIComponent(disk.filename)}`;
+        return `/friday-next/files/${encodeURIComponent(disk.diskName)}`;
     }
     const trimmed = ref.trim();
     if (trimmed.startsWith("/friday-next/files/")) {
@@ -215,10 +279,10 @@ export function readFile(id) {
     if (!file)
         return { buffer: null, mimeType: "application/octet-stream" };
     try {
-        return { buffer: fs.readFileSync(file.path), mimeType: file.mimeType };
+        return { buffer: fs.readFileSync(file.path), mimeType: file.mimeType, filename: file.filename };
     }
     catch {
-        return { buffer: null, mimeType: file.mimeType };
+        return { buffer: null, mimeType: file.mimeType, filename: file.filename };
     }
 }
 /**
@@ -262,19 +326,23 @@ export function resolveMediaAttachment(localPath) {
         const fallback = path.basename(token);
         return { fileName: fallback, url: localPath };
     }
-    const filename = path.basename(localPath);
-    if (!filename)
+    const basename = path.basename(localPath);
+    if (!basename)
         return null;
-    const stored = copyLocalFileToAttachments(localPath);
+    // Core inbound media is stored as a bare uuid (no name/extension). Recover the original
+    // upload name we stashed at send time, keyed by that uuid basename.
+    const remembered = readAttachmentMetaSidecar(basename)?.filename;
+    const originalName = remembered || basename;
+    const stored = copyLocalFileToAttachments(localPath, originalName);
     if (!stored) {
         // Best-effort fallback: still return a Friday URL so app can receive attachment event.
         // Download handler will try reading external source path lazily by token.
         const id = crypto.randomUUID();
-        const ext = path.extname(filename);
+        const ext = path.extname(originalName);
         const token = ext ? `${id}${ext}` : id;
         externalFileSourceIndex.set(token, normalizeAgentMediaPath(localPath));
         return {
-            fileName: filename,
+            fileName: originalName,
             url: `/friday-next/files/${encodeURIComponent(token)}`,
         };
     }

package/dist/src/http/handlers/messages.js

@@ -19,7 +19,7 @@ import { extractBearerToken } from "../middleware/auth.js";
 import { readJsonBody } from "../middleware/body.js";
 import { registerFridaySessionDeviceMapping } from "../../friday-session.js";
 import { touchFridayInbound } from "../../friday-inbound-stats.js";
-import { fridayAttachmentLookupKey, fridayFilesPublicUrl, readFile, resolveMediaAttachment, resolveMediaUrl, } from "./files.js";
+import { fridayAttachmentLookupKey, fridayFilesPublicUrl, readFile, rememberInboundMediaName, resolveMediaAttachment, resolveMediaUrl, } from "./files.js";
 import { runFridayDispatch } from "../../agent/dispatch-bridge.js";
 import { saveInboundMediaBuffer } from "../../agent/media-bridge.js";
 import { contextTokensFromUsageRecord, getRunMetadata, getRunRoute, hasRunFinalDelivered, markRunFinalDelivered, registerRunRoute, setRunMetadata, } from "../../run-metadata.js";
@@ -277,11 +277,16 @@ async function buildBodyForAgentWithAttachments(text, attachmentIds) {
         return text.trim();
     const mediaRefs = [];
     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}]`);
         }
     }

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

@@ -1,4 +1,5 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
+import { type ThinkingLevelOption } from "../../thinking-levels.js";
 export interface FridayModelEntry {
     id: string;
     name?: string;
@@ -6,5 +7,9 @@ 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;
 }
 export declare function handleModelsList(req: IncomingMessage, res: ServerResponse): Promise<boolean>;

package/dist/src/http/handlers/models-list.js

@@ -1,5 +1,6 @@
 import { getFridayAgentForwardRuntime } from "../../agent-forward-runtime.js";
 import { splitModelRef } from "../../session/session-manager.js";
+import { resolveModelThinking } from "../../thinking-levels.js";
 import { extractBearerToken } from "../middleware/auth.js";
 function resolveConfiguredModels() {
     const rt = getFridayAgentForwardRuntime();
@@ -65,6 +66,13 @@ function resolveConfiguredModels() {
             maxTokens: meta?.maxTokens,
         });
     }
+    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) {

package/dist/src/http/handlers/sessions-settings.js

@@ -1,8 +1,8 @@
 import { setSessionSettings, getSessionSettings, splitModelRef, resolveAgentDefaults, } 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, res) {
     if (req.method !== "PUT" && req.method !== "GET") {
         res.statusCode = 405;
@@ -44,12 +44,24 @@ export async function handleSessionsSettings(req, res) {
     const reasoningLevel = typeof body?.reasoningLevel === "string" ? body.reasoningLevel : undefined;
     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 = [];
     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) {
         res.statusCode = 400;
@@ -57,13 +69,6 @@ export async function handleSessionsSettings(req, res) {
         res.end(JSON.stringify({ error: errors.join("; ") }));
         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 = { reasoningLevel, thinkingLevel };
     if (effectiveModelRef) {
         const split = splitModelRef(effectiveModelRef);

package/dist/src/http/server.js

@@ -14,6 +14,9 @@ import { handleNodesApprove } from "./handlers/nodes-approve.js";
 import { handleSessionsSettings } from "./handlers/sessions-settings.js";
 import { handleModelsList } from "./handlers/models-list.js";
 import { handleAgentsList } from "./handlers/agents-list.js";
+import { handleAgentConfig } from "./handlers/agent-config.js";
+import { handleAgentFiles } from "./handlers/agent-files.js";
+import { handleAgentToolsCatalog } from "./handlers/agent-tools-catalog.js";
 import { handleHistorySessions } from "./handlers/history-sessions.js";
 import { handleHistoryMessages } from "./handlers/history-messages.js";
 import { handleHistorySetTitle } from "./handlers/history-set-title.js";
@@ -71,6 +74,26 @@ async function handleFridayNextRoute(req, res) {
     if (req.method === "GET" && pathname === "/friday-next/agents") {
         return await handleAgentsList(req, res);
     }
+    // Routes: GET/PUT /friday-next/agents/{id}/config
+    //         GET     /friday-next/agents/{id}/files
+    //         GET/PUT /friday-next/agents/{id}/files/{name}
+    if (pathname.startsWith("/friday-next/agents/")) {
+        const segs = pathname
+            .slice("/friday-next/agents/".length)
+            .split("/")
+            .filter(Boolean)
+            .map((s) => decodeURIComponent(s));
+        const [id, sub, name] = segs;
+        if (id && sub === "config" && segs.length === 2) {
+            return await handleAgentConfig(req, res, id);
+        }
+        if (id && sub === "files" && (segs.length === 2 || segs.length === 3)) {
+            return await handleAgentFiles(req, res, id, name);
+        }
+        if (id && sub === "tools" && name === "catalog" && segs.length === 3) {
+            return await handleAgentToolsCatalog(req, res, id);
+        }
+    }
     if (req.method === "GET" && pathname === "/friday-next/status") {
         return await handleStatus(req, res);
     }

package/dist/src/link-preview/ssrf-guard.js

@@ -98,8 +98,12 @@ function isPrivateIPv6(ip) {
     if (lower === "::" || lower === "::1")
         return true; // unspecified / loopback
     const head = lower.split(":")[0];
-    if (head.startsWith("fc") || head.startsWith("fd"))
-        return true; // fc00::/7 ULA
+    // fc00::/8 (the reserved, never-assigned half of ULA fc00::/7) intentionally NOT blocked:
+    // RFC 4193 requires locally-assigned ULA to set the L bit, so real LAN services live in
+    // fd00::/8, while fake-IP DNS setups (mihomo/clash tun mode with IPv6, common on gateway
+    // hosts) resolve EVERY domain into fc00::/18. Same rationale as 198.18/15 on the IPv4 side.
+    if (head.startsWith("fd"))
+        return true; // fd00::/8 locally-assigned ULA
     if (/^fe[89ab]/.test(head))
         return true; // fe80::/10 link-local
     return false;

package/dist/src/media-fetch.js

@@ -8,7 +8,10 @@ import { guessMimeType } from "./http/handlers/files.js";
  * gateway's `/friday-next/files/` route — identical to the local-file path. This keeps the app's
  * download story uniform (always talks to the trusted gateway host with a bearer token).
  */
-const MAX_REMOTE_MEDIA_BYTES = 25 * 1024 * 1024; // 25MB
+// Aligns with openclaw's own remote-media ceiling (DEFAULT_FETCH_MEDIA_MAX_BYTES =
+// MAX_DOCUMENT_BYTES = 100MB). The real per-kind limit is enforced downstream by
+// saveMediaBuffer (via resolveMediaMaxBytes); this is just the download ceiling.
+const MAX_REMOTE_MEDIA_BYTES = 100 * 1024 * 1024; // 100MB
 const REMOTE_MEDIA_TIMEOUT_MS = 20_000;
 export function isHttpUrl(value) {
     return /^https?:\/\//i.test(value.trim());