@syengup/friday-channel-next 0.1.30 → 0.1.36

package/src/http/handlers/files.test.ts

@@ -0,0 +1,114 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  clearFileIndexForTest,
+  fridayFilesPublicUrl,
+  readAttachmentFileFromDisk,
+  rememberInboundMediaName,
+  resolveMediaAttachment,
+  setAttachmentsDirForTest,
+  storeFile,
+} from "./files.js";
+
+let tmpDir: string;
+
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "fn-files-"));
+  setAttachmentsDirForTest(tmpDir);
+  clearFileIndexForTest();
+});
+
+afterEach(() => {
+  setAttachmentsDirForTest(null);
+  clearFileIndexForTest();
+  fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("attachment original filename survives a gateway restart", () => {
+  it("stores under a uuid token but recovers the original filename from disk", () => {
+    const stored = storeFile(Buffer.from("%PDF-1.4 fake"), "Quarterly Report.pdf", "application/pdf");
+    expect(stored.urlToken).not.toBe("Quarterly Report.pdf");
+
+    const disk = readAttachmentFileFromDisk(stored.urlToken);
+    expect(disk).not.toBeNull();
+    // The display/download name is the original — not the on-disk uuid.
+    expect(disk!.filename).toBe("Quarterly Report.pdf");
+    expect(disk!.mimeType).toBe("application/pdf");
+    // The disk basename stays the uuid token so URLs keep pointing at the real file.
+    expect(disk!.diskName).toBe(stored.urlToken);
+  });
+
+  it("resolveMediaAttachment keeps the original name after the in-memory index is cleared", () => {
+    const stored = storeFile(Buffer.from("notes body"), "meeting-notes.txt", "text/plain");
+    const url = `/friday-next/files/${encodeURIComponent(stored.urlToken)}`;
+
+    // Simulate a gateway restart: the in-memory index is gone, only disk remains.
+    clearFileIndexForTest();
+
+    const resolved = resolveMediaAttachment(url);
+    expect(resolved).not.toBeNull();
+    expect(resolved!.fileName).toBe("meeting-notes.txt");
+    expect(resolved!.url).toBe(url);
+  });
+
+  it("fridayFilesPublicUrl still points at the on-disk token after a restart", () => {
+    const stored = storeFile(Buffer.from("x"), "doc.docx", "application/octet-stream");
+    clearFileIndexForTest();
+
+    const publicUrl = fridayFilesPublicUrl(`/friday-next/files/${encodeURIComponent(stored.urlToken)}`);
+    expect(publicUrl).toBe(`/friday-next/files/${encodeURIComponent(stored.urlToken)}`);
+  });
+
+  it("falls back to the on-disk basename for legacy files that have no sidecar", () => {
+    // A file stored before this fix: raw uuid token on disk, no .fnmeta sidecar.
+    const token = "11111111-2222-3333-4444-555555555555.pdf";
+    fs.writeFileSync(path.join(tmpDir, token), Buffer.from("legacy"));
+
+    const disk = readAttachmentFileFromDisk(token);
+    expect(disk).not.toBeNull();
+    expect(disk!.filename).toBe(token);
+    expect(disk!.diskName).toBe(token);
+  });
+
+  it("never serves the sidecar file itself", () => {
+    const stored = storeFile(Buffer.from("y"), "report.pdf", "application/pdf");
+    expect(readAttachmentFileFromDisk(`${stored.urlToken}.fnmeta`)).toBeNull();
+  });
+});
+
+describe("inbound user attachments (core media-store renames to a bare uuid)", () => {
+  it("recovers the original upload name from the remembered inbound sidecar on rebuild", () => {
+    // Core copies the upload to media/inbound/<uuid> with no extension and no name;
+    // the transcript records this path. We remembered the real name at send time.
+    const inboundUuid = "c950d280-55e5-4e06-aede-9f08653362a8";
+    const inboundPath = path.join(tmpDir, "..", "media", "inbound", inboundUuid);
+    fs.mkdirSync(path.dirname(inboundPath), { recursive: true });
+    fs.writeFileSync(inboundPath, Buffer.from("%PDF body"));
+
+    rememberInboundMediaName(inboundPath, "Project Brief.pdf", "application/pdf");
+
+    // History rebuild: resolveMediaAttachment is handed the raw inbound path.
+    const resolved = resolveMediaAttachment(inboundPath);
+    expect(resolved).not.toBeNull();
+    expect(resolved!.fileName).toBe("Project Brief.pdf");
+    // The copy carries the recovered extension so downloads open correctly.
+    expect(resolved!.url).toMatch(/\.pdf$/);
+
+    fs.rmSync(path.dirname(inboundPath), { recursive: true, force: true });
+  });
+
+  it("falls back to the bare uuid when nothing was remembered (pre-fix messages)", () => {
+    const inboundUuid = "99999999-0000-1111-2222-333333333333";
+    const inboundPath = path.join(tmpDir, "..", "media", "inbound", inboundUuid);
+    fs.mkdirSync(path.dirname(inboundPath), { recursive: true });
+    fs.writeFileSync(inboundPath, Buffer.from("legacy"));
+
+    const resolved = resolveMediaAttachment(inboundPath);
+    expect(resolved).not.toBeNull();
+    expect(resolved!.fileName).toBe(inboundUuid);
+
+    fs.rmSync(path.dirname(inboundPath), { recursive: true, force: true });
+  });
+});

package/src/http/handlers/files.ts

@@ -72,6 +72,70 @@ function resolveStoredFile(key: string): StoredFile | undefined {
   return fileIndex.get(key) ?? fileTokenIndex.get(key);
 }
 
+/** Clear the in-memory file index. Test-only: simulates a gateway restart. */
+export function clearFileIndexForTest(): void {
+  fileIndex.clear();
+  fileTokenIndex.clear();
+  externalFileSourceIndex.clear();
+}
+
+/**
+ * The on-disk basename is a `<uuid>.<ext>` token, and the original filename lives only in
+ * the process-local `fileIndex`. To keep the real name after a gateway restart (when the
+ * index is empty) we persist it in a sidecar JSON file next to each stored attachment.
+ */
+interface AttachmentMetaSidecar {
+  filename: string;
+  mimeType: string;
+}
+
+const META_SIDECAR_SUFFIX = ".fnmeta";
+
+function metaSidecarPath(urlToken: string): string {
+  return path.join(getAttachmentsDir(), `${urlToken}${META_SIDECAR_SUFFIX}`);
+}
+
+function writeAttachmentMetaSidecar(urlToken: string, filename: string, mimeType: string): void {
+  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: string, filename: string, mimeType: string): void {
+  const key = path.basename(inboundPath);
+  const name = filename.trim();
+  if (!key || !name) return;
+  writeAttachmentMetaSidecar(key, name, mimeType);
+}
+
+function readAttachmentMetaSidecar(urlToken: string): AttachmentMetaSidecar | null {
+  try {
+    const raw = fs.readFileSync(metaSidecarPath(urlToken), "utf8");
+    const parsed = JSON.parse(raw) as Partial<AttachmentMetaSidecar>;
+    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.
@@ -79,16 +143,26 @@ function resolveStoredFile(key: string): StoredFile | undefined {
 export 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 {
   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;
   }
@@ -117,14 +191,17 @@ export function normalizeAgentMediaPath(raw: string): string {
   return s;
 }
 
-function copyLocalFileToAttachments(sourcePath: string): StoredFile | null {
+function copyLocalFileToAttachments(sourcePath: string, originalFilename?: string): StoredFile | null {
   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 {
@@ -148,6 +225,7 @@ function copyLocalFileToAttachments(sourcePath: string): StoredFile | null {
       createdAt: Date.now(),
     };
     registerStoredFile(file);
+    writeAttachmentMetaSidecar(urlToken, filename, mimeType);
     return file;
   } catch (err) {
     logger.error(`copyLocalFileToAttachments failed for "${resolvedPath}": ${String(err)}`);
@@ -182,6 +260,7 @@ export function storeFile(buffer: Buffer, filename: string, mimeType: string): S
   };
 
   registerStoredFile(file);
+  writeAttachmentMetaSidecar(urlToken, safeFilename, mimeType);
   return file;
 }
 
@@ -218,7 +297,7 @@ export function fridayFilesPublicUrl(ref: string): string {
 
   const disk = readAttachmentFileFromDisk(lookupKey);
   if (disk) {
-    return `/friday-next/files/${encodeURIComponent(disk.filename)}`;
+    return `/friday-next/files/${encodeURIComponent(disk.diskName)}`;
   }
 
   const trimmed = ref.trim();
@@ -235,13 +314,13 @@ export function getExternalFileSourceByUrlToken(token: string): string | undefin
 /**
  * Read a file as a Buffer with its MIME type (by id or urlToken).
  */
-export function readFile(id: string): { buffer: Buffer | null; mimeType: string } {
+export function readFile(id: string): { buffer: Buffer | null; mimeType: string; filename?: string } {
   const file = resolveStoredFile(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 };
   }
 }
 
@@ -294,19 +373,24 @@ export function resolveMediaAttachment(localPath: string): ResolvedAttachment |
     return { fileName: fallback, url: localPath };
   }
 
-  const filename = path.basename(localPath);
-  if (!filename) return null;
+  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/src/http/handlers/messages.ts

@@ -43,6 +43,7 @@ import {
   fridayAttachmentLookupKey,
   fridayFilesPublicUrl,
   readFile,
+  rememberInboundMediaName,
   resolveMediaAttachment,
   resolveMediaUrl,
 } from "./files.js";
@@ -377,11 +378,15 @@ async function buildBodyForAgentWithAttachments(text: string, attachmentIds: str
 
   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}]`);
     }
   }

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 {
@@ -89,6 +94,13 @@ 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 };
 }
 

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/server.ts

@@ -16,6 +16,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";
@@ -88,6 +91,27 @@ async function handleFridayNextRoute(
     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/src/link-preview/ssrf-guard.test.ts

@@ -66,7 +66,7 @@ describe("assertPublicHttpUrl", () => {
     expect(() => assertPublicHttpUrl(new URL("http://127.0.0.1/"))).toThrow(BlockedUrlError);
     expect(() => assertPublicHttpUrl(new URL("http://10.0.0.5/"))).toThrow(BlockedUrlError);
     expect(() => assertPublicHttpUrl(new URL("http://[::1]/"))).toThrow(BlockedUrlError);
-    expect(() => assertPublicHttpUrl(new URL("http://[fc00::1]/"))).toThrow(BlockedUrlError);
+    expect(() => assertPublicHttpUrl(new URL("http://[fd00::1]/"))).toThrow(BlockedUrlError);
   });
 
   it("allows public IP literals", () => {
@@ -106,11 +106,16 @@ describe("isPrivateAddress", () => {
   });
 
   it("flags private/reserved IPv6 and mapped IPv4", () => {
-    for (const ip of ["::1", "::", "fc00::1", "fd12:3456::1", "fe80::1", "::ffff:10.0.0.1", "::ffff:127.0.0.1"]) {
+    for (const ip of ["::1", "::", "fd00::1", "fd12:3456::1", "fe80::1", "::ffff:10.0.0.1", "::ffff:127.0.0.1"]) {
       expect(isPrivateAddress(ip), ip).toBe(true);
     }
   });
 
+  it("passes fc00::/8 (fake-IP DNS v6 range used by clash/mihomo tun mode)", () => {
+    expect(isPrivateAddress("fc00::1e7")).toBe(false);
+    expect(isPrivateAddress("fc00::ffff:ffff")).toBe(false);
+  });
+
   it("passes public IPv6 and mapped public IPv4", () => {
     expect(isPrivateAddress("2606:2800:220:1:248:1893:25c8:1946")).toBe(false);
     expect(isPrivateAddress("::ffff:93.184.216.34")).toBe(false);

package/src/link-preview/ssrf-guard.ts

@@ -90,7 +90,11 @@ function isPrivateIPv6(ip: string): boolean {
   if (mapped) return isPrivateIPv4(mapped[1]);
   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/src/media-fetch.test.ts

@@ -59,7 +59,7 @@ describe("downloadRemoteMedia", () => {
         async () =>
           new Response(new Uint8Array([1, 2, 3]), {
             status: 200,
-            headers: { "content-type": "image/png", "content-length": String(64 * 1024 * 1024) },
+            headers: { "content-type": "image/png", "content-length": String(128 * 1024 * 1024) },
           }),
       ),
     );

package/src/media-fetch.ts

@@ -10,7 +10,10 @@ import { guessMimeType } from "./http/handlers/files.js";
  * 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: string): boolean {