@syengup/friday-channel-next 0.1.30 → 0.1.37

package/README.md

@@ -10,15 +10,19 @@
 - **Disk-backed SSE replay** per `deviceId` (JSONL + `Last-Event-ID` / `lastEventId`) for offline gaps and restarts
 - File upload/download (`POST /friday-next/files`, `GET /friday-next/files/:id`)
 - Cancel (`POST /friday-next/cancel`) and status with `activeRuns` (`GET /friday-next/status`)
+- **Agent config editing** (mirrors ControlUI, no core changes): model / core `.md` files / tool permissions / skills, per agent — via `agents.list[]` (`mutateConfigFile`) + workspace fs
+- History sync, link-preview cards, and in-app plugin self-upgrade
 
 ## Endpoints
 
 - `GET /friday-next/events?deviceId=...`
 - `POST /friday-next/messages`
-- `POST /friday-next/files`
-- `GET /friday-next/files/:id`
-- `POST /friday-next/cancel`
-- `GET /friday-next/status`
+- `POST /friday-next/files` · `GET /friday-next/files/:id`
+- `POST /friday-next/cancel` · `GET /friday-next/status` · `GET /friday-next/health`
+- `GET /friday-next/models` · `GET /friday-next/agents` · `GET|PUT /friday-next/sessions/settings`
+- `GET|PUT /friday-next/agents/{id}/config` · `GET|PUT /friday-next/agents/{id}/files[/{name}]` · `GET /friday-next/agents/{id}/tools/catalog`
+- `GET /friday-next/history/sessions` · `GET /friday-next/history/messages` · `GET /friday-next/link-preview`
+- `GET /friday-next/plugin/info` · `POST /friday-next/plugin/upgrade`
 
 See **`API.md`** (English) and **`API.zh-CN.md`** (Chinese) for payloads, event shapes, offline queue paths, and breaking changes.
 

package/dist/index.js

@@ -33,7 +33,7 @@ function deviceIdFromToolContext(ctx) {
     }
     const sk = typeof ctx.sessionKey === "string" && ctx.sessionKey.trim()
         ? ctx.sessionKey.trim()
-        : (ctx.runId ? getOpenClawAgentRunContext(ctx.runId)?.sessionKey?.trim() : undefined) ?? "";
+        : ((ctx.runId ? getOpenClawAgentRunContext(ctx.runId)?.sessionKey?.trim() : undefined) ?? "");
     if (sk) {
         const d = resolveFridayDeviceIdForSessionKey(sk);
         if (d)

package/dist/src/agent/abort-run.d.ts

@@ -1 +1,12 @@
-export declare function abortRun(runId: string): Promise<void>;
+export type AbortRunResult = {
+    aborted: boolean;
+    drained: boolean;
+};
+/**
+ * Abort the active run for a channel `sessionKey`.
+ *
+ * A session has at most one active run at a time, and the SDK keys active runs by
+ * their internal `sessionId` (not the channel runId). So resolve sessionKey → sessionId
+ * first, then abort-and-drain so the caller learns whether the run actually settled.
+ */
+export declare function abortRunForSessionKey(sessionKey: string): Promise<AbortRunResult>;

package/dist/src/agent/abort-run.js

@@ -1,11 +1,26 @@
-export async function abortRun(runId) {
-    if (process.env.VITEST !== "true") {
-        try {
-            const { abortAgentHarnessRun } = await import("openclaw/plugin-sdk/agent-harness");
-            abortAgentHarnessRun(runId);
-        }
-        catch {
-            // optional at runtime
-        }
+/**
+ * Abort the active run for a channel `sessionKey`.
+ *
+ * A session has at most one active run at a time, and the SDK keys active runs by
+ * their internal `sessionId` (not the channel runId). So resolve sessionKey → sessionId
+ * first, then abort-and-drain so the caller learns whether the run actually settled.
+ */
+export async function abortRunForSessionKey(sessionKey) {
+    if (process.env.VITEST === "true")
+        return { aborted: false, drained: false };
+    const key = sessionKey.trim();
+    if (!key)
+        return { aborted: false, drained: false };
+    try {
+        const { resolveActiveEmbeddedRunSessionId, abortAndDrainAgentHarnessRun } = await import("openclaw/plugin-sdk/agent-harness");
+        const sessionId = resolveActiveEmbeddedRunSessionId(key);
+        if (!sessionId)
+            return { aborted: false, drained: false };
+        const result = await abortAndDrainAgentHarnessRun({ sessionId, sessionKey: key });
+        return { aborted: result.aborted, drained: result.drained };
+    }
+    catch {
+        // optional at runtime
+        return { aborted: false, drained: false };
     }
 }

package/dist/src/agent/dispatch-bridge.d.ts

@@ -1,4 +1,4 @@
-type DispatchFn = (args: unknown) => Promise<unknown> | unknown;
+type DispatchFn = (args: unknown) => unknown;
 export declare function runFridayDispatch(args: Parameters<DispatchFn>[0]): ReturnType<DispatchFn>;
 export declare function __setMockFridayDispatchForTests(fn: DispatchFn): void;
 export declare function __resetMockFridayDispatchForTests(): void;

package/dist/src/agent/media-bridge.d.ts

@@ -1,4 +1,11 @@
-export declare function saveInboundMediaBuffer(buffer: Buffer, mimeType: string): Promise<{
+/**
+ * openclaw's own per-kind byte cap for a mime type (image 6MB / audio·video 16MB /
+ * document 100MB). Unknown mimes fall back to the most permissive ("document") cap.
+ * Returns undefined if the media runtime isn't importable (tests / stripped runtime),
+ * letting `saveMediaBuffer` apply its built-in default.
+ */
+export declare function resolveMediaMaxBytes(mimeType: string): Promise<number | undefined>;
+export declare function saveInboundMediaBuffer(buffer: Buffer, mimeType: string, originalFilename?: string): Promise<{
     id: string;
     path: string;
 }>;

package/dist/src/agent/media-bridge.js

@@ -2,10 +2,31 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import crypto from "node:crypto";
-export async function saveInboundMediaBuffer(buffer, mimeType) {
+/**
+ * openclaw's own per-kind byte cap for a mime type (image 6MB / audio·video 16MB /
+ * document 100MB). Unknown mimes fall back to the most permissive ("document") cap.
+ * Returns undefined if the media runtime isn't importable (tests / stripped runtime),
+ * letting `saveMediaBuffer` apply its built-in default.
+ */
+export async function resolveMediaMaxBytes(mimeType) {
+    try {
+        const { maxBytesForKind, mediaKindFromMime } = await import("openclaw/plugin-sdk/media-runtime");
+        return maxBytesForKind(mediaKindFromMime(mimeType) ?? "document");
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function saveInboundMediaBuffer(buffer, mimeType, originalFilename) {
     try {
         const sdk = await import("openclaw/plugin-sdk/media-store");
-        const saved = await sdk.saveMediaBuffer(buffer, mimeType, "inbound");
+        // Accept whatever openclaw itself supports for this media kind instead of
+        // saveMediaBuffer's conservative 5MB default.
+        const maxBytes = await resolveMediaMaxBytes(mimeType);
+        // Pass the original filename (5th arg) so core's media-store preserves the
+        // name+extension instead of saving a bare uuid. Otherwise the agent receives
+        // `[media attached: file://.../inbound/<uuid>]` with no file-format signal.
+        const saved = await sdk.saveMediaBuffer(buffer, mimeType, "inbound", maxBytes, originalFilename);
         if (saved?.id && saved?.path)
             return { id: saved.id, path: saved.path };
     }

package/dist/src/agent/node-pairing-bridge.d.ts

@@ -1,9 +1,12 @@
-export declare function loadNodePairingModule(): Promise<{
-    listNodePairing: Function;
-    approveNodePairing: Function;
-}>;
+type ListNodePairingFn = () => Promise<any>;
+type ApproveNodePairingFn = (requestId: string, options: {
+    callerScopes?: unknown;
+}) => Promise<any>;
+type NodePairingModule = {
+    listNodePairing: ListNodePairingFn;
+    approveNodePairing: ApproveNodePairingFn;
+};
+export declare function loadNodePairingModule(): Promise<NodePairingModule>;
 /** Vitest-only: inject mock pairing functions. */
-export declare function __setMockNodePairingForTests(mock: {
-    listNodePairing: Function;
-    approveNodePairing: Function;
-}): void;
+export declare function __setMockNodePairingForTests(mock: NodePairingModule): void;
+export {};

package/dist/src/agent/node-pairing-bridge.js

@@ -16,7 +16,9 @@ function resolveOpenClawDistFromPath() {
             readdirSync(dist);
             return dist;
         }
-        catch { }
+        catch {
+            // Not a real dist dir — keep walking PATH.
+        }
     }
     return null;
 }
@@ -45,7 +47,9 @@ function resolveOpenClawDist() {
             readdirSync(root);
             return root;
         }
-        catch { }
+        catch {
+            // Candidate dir doesn't exist — try the next one.
+        }
     }
     throw new Error("OpenClaw dist directory not found. Set OPENCLAW_DIST env var.");
 }

package/dist/src/agent/subagent-registry.js

@@ -8,9 +8,6 @@ export function registerSessionKeyForRun(sessionKey, runId) {
         return;
     sessionKeyToRunId.set(sessionKey, runId);
 }
-function resolveRunIdForSessionKey(sessionKey) {
-    return sessionKeyToRunId.get(sessionKey);
-}
 /**
  * Parse OpenClaw announce compound runId:
  *   announce:v<version>:<sessionKey>:<bareRunId>

package/dist/src/agent-forward-runtime.d.ts

@@ -16,6 +16,21 @@ export type FridayAgentForwardRuntime = {
     }) => Promise<Record<string, unknown> | null>;
     /** Resolves an agent's workspace dir — used to read IDENTITY.md for the name fallback. */
     resolveAgentWorkspaceDir?: (cfg: unknown, agentId: string) => string;
+    /**
+     * Resolves the thinking-level options + default for a provider/model pair, driven by the running
+     * gateway's provider plugins + model catalog (so the option set varies per model). Optional: older
+     * gateways don't expose it, in which case callers fall back to the base five levels.
+     */
+    resolveThinkingPolicy?: (params: {
+        provider?: string | null;
+        model?: string | null;
+    }) => {
+        levels: Array<{
+            id: string;
+            label: string;
+        }>;
+        defaultLevel?: string | null;
+    };
     getConfig: () => unknown;
 };
 /** Called from `registerFull` so terminal lifecycle forwards can read `sessions.json` after persist. */

package/dist/src/agent-forward-runtime.js

@@ -8,6 +8,8 @@ export function setFridayAgentForwardRuntime(api) {
             .updateSessionStoreEntry,
         resolveAgentWorkspaceDir: api.runtime.agent
             .resolveAgentWorkspaceDir,
+        resolveThinkingPolicy: api.runtime.agent
+            .resolveThinkingPolicy,
         getConfig: () => api.runtime.config.current(),
     };
 }

package/dist/src/agent-id.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Agent id normalization shared across handlers.
+ *
+ * Mirror of OpenClaw's `normalizeAgentId` (src/routing/session-key.ts): trim,
+ * lowercase, keep path/shell-safe. Empty → "main".
+ */
+export declare const DEFAULT_AGENT_ID = "main";
+export declare function normalizeAgentId(value: unknown): string;

package/dist/src/agent-id.js

@@ -0,0 +1,21 @@
+/**
+ * Agent id normalization shared across handlers.
+ *
+ * Mirror of OpenClaw's `normalizeAgentId` (src/routing/session-key.ts): trim,
+ * lowercase, keep path/shell-safe. Empty → "main".
+ */
+export 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_-]*$/;
+export 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);
+}

package/dist/src/channel-actions.js

@@ -24,6 +24,23 @@ function pickString(params, keys) {
     }
     return "";
 }
+function pickStringArray(params, key) {
+    const v = params[key];
+    if (!Array.isArray(v))
+        return [];
+    const out = [];
+    const seen = new Set();
+    for (const entry of v) {
+        if (typeof entry !== "string")
+            continue;
+        const trimmed = entry.trim();
+        if (!trimmed || seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        out.push(trimmed);
+    }
+    return out;
+}
 async function readMediaFile(mediaPath, ctx) {
     if (isHttpUrl(mediaPath)) {
         return downloadRemoteMedia(mediaPath);
@@ -35,7 +52,9 @@ async function readMediaFile(mediaPath, ctx) {
                 return { buffer, mimeType: guessMimeType(mediaPath) };
             }
         }
-        catch { /* fall through */ }
+        catch {
+            /* fall through */
+        }
     }
     try {
         const buffer = fs.readFileSync(mediaPath);
@@ -78,23 +97,37 @@ async function handleSend(ctx) {
             },
         }, to, true);
     }
-    // Resolve media from an inline base64 buffer or a path/url reference. (`attachments[]` arrays are
-    // normalized by the OpenClaw core and arrive via outbound.sendMedia, so they're not handled here.)
-    let media = null;
-    let originalMediaUrl = "";
-    if (inlineBase64) {
-        media = decodeBase64Media(inlineBase64, mediaMimeHint || (filename ? guessMimeType(filename) : ""));
-        originalMediaUrl = filename || "inline-buffer";
+    // Resolve the media to send. A `message` tool call with a structured `attachments[]` array is
+    // flattened by the OpenClaw core into `params.mediaUrls` (with `media` set to the first entry for
+    // back-compat), so prefer the full list; fall back to a single inline base64 buffer or a
+    // path/url reference for the single-attachment / direct-link / buffer cases.
+    const mediaSources = [];
+    const mediaUrls = pickStringArray(ctx.params, "mediaUrls");
+    if (mediaUrls.length > 0) {
+        for (const ref of mediaUrls) {
+            const loaded = await readMediaFile(ref, ctx);
+            if (loaded)
+                mediaSources.push({ ...loaded, originalMediaUrl: ref });
+        }
+    }
+    else if (inlineBase64) {
+        const loaded = decodeBase64Media(inlineBase64, mediaMimeHint || (filename ? guessMimeType(filename) : ""));
+        if (loaded)
+            mediaSources.push({ ...loaded, originalMediaUrl: filename || "inline-buffer" });
     }
     else if (mediaPath) {
-        media = await readMediaFile(mediaPath, ctx);
-        originalMediaUrl = mediaPath;
+        const loaded = await readMediaFile(mediaPath, ctx);
+        if (loaded)
+            mediaSources.push({ ...loaded, originalMediaUrl: mediaPath });
     }
-    // Send media via SSE outbound
-    if (media) {
+    // Send each media via its own SSE outbound event. They all share this send's `runId` so the app
+    // groups them into a single assistant message (first → attachment, rest → extra attachments).
+    if (mediaSources.length > 0) {
         const { saveMediaBuffer } = await import("openclaw/plugin-sdk/media-store");
-        const saved = await saveMediaBuffer(media.buffer, media.mimeType, "inbound");
-        if (saved.id) {
+        for (const source of mediaSources) {
+            const saved = await saveMediaBuffer(source.buffer, source.mimeType, "inbound");
+            if (!saved.id)
+                continue;
             const publicUrl = `/friday-next/files/${encodeURIComponent(saved.id)}`;
             sseEmitter.broadcast({
                 type: "outbound",
@@ -107,7 +140,7 @@ async function handleSend(ctx) {
                     audioAsVoice: false,
                     caption: caption || text,
                     mediaUrl: publicUrl,
-                    ctx: { to, text: caption || text, originalMediaUrl },
+                    ctx: { to, text: caption || text, originalMediaUrl: source.originalMediaUrl },
                 },
             }, to, true);
         }

package/dist/src/channel.js

@@ -8,12 +8,14 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { createChatChannelPlugin } from "openclaw/plugin-sdk/core";
+import { waitUntilAbort } from "openclaw/plugin-sdk/channel-lifecycle";
 import { createFridayNextLogger } from "./logging.js";
 import { saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
 import { sseEmitter } from "./sse/emitter.js";
 import { describeMessageActions, handleMessageAction } from "./channel-actions.js";
 import { guessMimeType, resolveMediaAttachment } from "./http/handlers/files.js";
 import { downloadRemoteMedia, isHttpUrl } from "./media-fetch.js";
+import { resolveMediaMaxBytes } from "./agent/media-bridge.js";
 import { resolveFridayDeviceIdForOutbound, resolveHistorySessionKeyForFridayDevice, } from "./friday-session.js";
 import { getRunRoute } from "./run-metadata.js";
 import { getLastFridayInboundAt } from "./friday-inbound-stats.js";
@@ -83,6 +85,21 @@ const fridayLifecycle = {
         // No-op
     },
 };
+/**
+ * friday-next is a passive HTTP+SSE channel: its routes live on the shared gateway server and
+ * SSE clients connect on demand, so there is no per-account socket or polling loop to maintain.
+ * But the core health-monitor reads the account's lifecycle `running` flag — which the framework
+ * flips to `false` the moment `startAccount` resolves/rejects. Without a long-lived startAccount
+ * the account is permanently seen as "stopped" and restarted every health poll (~5 min). A stopped
+ * account drops out of the deliverable-channel registry, so an agent `message` send landing in that
+ * window fails with `Unknown channel: friday-next`. Hold the account lifecycle open until abort
+ * (reload/shutdown) so the channel stays `running:true` and continuously deliverable.
+ */
+const fridayGateway = {
+    startAccount: async (ctx) => {
+        await waitUntilAbort(ctx.abortSignal);
+    },
+};
 const fridayStatus = {
     buildAccountSnapshot: async (params) => {
         const { account, runtime } = params;
@@ -117,6 +134,7 @@ export const fridayNextChannelPlugin = createChatChannelPlugin({
         },
         config: fridayConfigAdapter,
         lifecycle: fridayLifecycle,
+        gateway: fridayGateway,
         status: fridayStatus,
         bindings: {
             compileConfiguredBinding: () => null,
@@ -165,7 +183,6 @@ export const fridayNextChannelPlugin = createChatChannelPlugin({
             const runId = runIdFromCtx ?? sseEmitter.getLastRunIdForDevice(deviceId) ?? undefined;
             const sessionKey = resolveOutboundSessionKey(deviceId, runId, rawCtx);
             const conn = sseEmitter.getConnection(deviceId);
-            const ts = new Date().toISOString();
             logger.info(`[SEND_TEXT] to=${deviceId} runId=${runId ?? "(none)"} sessionKey=${sessionKey ?? "(none)"} textLen=${text.length} online=${!!conn}`);
             if (conn) {
                 sseEmitter.broadcast({
@@ -240,13 +257,15 @@ export const fridayNextChannelPlugin = createChatChannelPlugin({
             }
             if (buffer) {
                 const mimeType = downloadedMimeType ?? guessMimeType(mediaUrl);
-                const saved = await saveMediaBuffer(buffer, mimeType, "inbound");
+                // Match what openclaw itself supports for this media kind rather than
+                // saveMediaBuffer's 5MB default.
+                const maxBytes = await resolveMediaMaxBytes(mimeType);
+                const saved = await saveMediaBuffer(buffer, mimeType, "inbound", maxBytes);
                 if (saved.id) {
                     const fileUrl = `/friday-next/files/${encodeURIComponent(saved.id)}`;
                     const resolved = resolveMediaAttachment(fileUrl);
                     const publicUrl = resolved ? resolved.url : fileUrl;
                     const conn = sseEmitter.getConnection(deviceId);
-                    const ts = new Date().toISOString();
                     logger.info(`[SEND_MEDIA] to=${deviceId} runId=${runId ?? "(none)"} sessionKey=${sessionKey ?? "(none)"} audioAsVoice=${audioAsVoice} url=${publicUrl} online=${!!conn}`);
                     if (conn) {
                         sseEmitter.broadcast({

package/dist/src/collect-message-media-paths.js

@@ -63,7 +63,16 @@ export function collectMediaPathsFromToolResult(raw, acc) {
         const filePath = o.filePath;
         if (typeof filePath === "string")
             add(filePath);
-        for (const k of ["details", "result", "content", "text", "body", "message", "arguments", "args"]) {
+        for (const k of [
+            "details",
+            "result",
+            "content",
+            "text",
+            "body",
+            "message",
+            "arguments",
+            "args",
+        ]) {
             if (o[k] !== undefined)
                 visit(o[k]);
         }

package/dist/src/friday-session.js

@@ -37,7 +37,7 @@ export function deviceIdFromSessionKey(sessionKey) {
     if (m1)
         return m1[1] ?? null;
     const m2 = sessionKey.match(/^agent:main:friday-next-(.+)$/i);
-    return m2 ? m2[1] ?? null : null;
+    return m2 ? (m2[1] ?? null) : null;
 }
 /**
  * When the app uses a plain `sessionKey` (e.g. `main` → `agent:main:main` in the gateway),
@@ -52,7 +52,8 @@ const deviceIdToLatestHistorySessionKey = new Map();
 /** Last device that called POST /friday-next/messages (same gateway process). Used for cron/outbound when `to` is placeholder and the app is offline (no SSE). */
 let lastRegisteredFridayDeviceId;
 function normalizeFridaySessionKeyCase(sk) {
-    return /^friday-next-|^agent:main:friday-next-/i.test(sk) || /^agent:main:friday-next:direct:/i.test(sk)
+    return /^friday-next-|^agent:main:friday-next-/i.test(sk) ||
+        /^agent:main:friday-next:direct:/i.test(sk)
         ? sk.toLowerCase()
         : sk;
 }
@@ -126,7 +127,9 @@ function mergeRunMetadataIntoLifecycleEnd(runId, base) {
     if (typeof meta.modelName === "string" && meta.modelName.trim()) {
         extra.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) {
         extra.totalTokens = Math.floor(meta.totalTokens);
     }
     if (typeof meta.contextTokensUsed === "number" &&
@@ -242,6 +245,26 @@ export function resolveFridayDeviceIdForOutbound(to, rawCtx) {
         return lastRegisteredFridayDeviceId;
     return trimmed || "friday-next";
 }
+/**
+ * Stringify a subagent error payload for the wire. `evt.data.error` comes from an
+ * in-process SDK callback, so it can be a real Error, a plain object, or a value
+ * that JSON.stringify would throw on (circular/BigInt) — keep this total and
+ * never-throwing, since it runs on the error path that emits `subagent ended`.
+ */
+function stringifySubagentError(raw) {
+    if (raw == null)
+        return "unknown";
+    if (typeof raw === "string")
+        return raw;
+    if (raw instanceof Error)
+        return raw.message || raw.name || "error";
+    try {
+        return JSON.stringify(raw) ?? "unknown";
+    }
+    catch {
+        return "unstringifiable error";
+    }
+}
 /**
  * Forward global OpenClaw agent events to the Friday SSE connection (transparent).
  *
@@ -272,8 +295,7 @@ export function forwardAgentEventRaw(evt) {
     if (!deviceIdRaw)
         return;
     if (!sk) {
-        sk =
-            latestHistorySessionKeyForDeviceId(deviceIdRaw) ?? `friday-next-${deviceIdRaw}`;
+        sk = latestHistorySessionKeyForDeviceId(deviceIdRaw) ?? `friday-next-${deviceIdRaw}`;
     }
     openClawRunIdToDeviceId.set(evt.runId, deviceIdRaw.toUpperCase());
     // Register sessionKey → runId so we can resolve parentRunId
@@ -317,9 +339,7 @@ export function forwardAgentEventRaw(evt) {
             const intent = toolCallId ? consumeSpawnIntent(toolCallId) : undefined;
             const label = details.taskName ||
                 intent?.label ||
-                (typeof evt.data.meta === "string"
-                    ? evt.data.meta
-                    : undefined);
+                (typeof evt.data.meta === "string" ? evt.data.meta : undefined);
             const entry = ensureSubagentFromSpawnTool({
                 childSessionKey: details.childSessionKey,
                 bareRunId: details.runId,
@@ -351,7 +371,11 @@ export function forwardAgentEventRaw(evt) {
     // share the announce runId but have a different sessionKey.
     const isSubagentOwnEvent = subagentEntry && sk && subagentEntry.childSessionKey === sk;
     const subagentMeta = isSubagentOwnEvent
-        ? { label: subagentEntry.label, parentRunId: subagentEntry.parentRunId, depth: subagentEntry.depth }
+        ? {
+            label: subagentEntry.label,
+            parentRunId: subagentEntry.parentRunId,
+            depth: subagentEntry.depth,
+        }
         : undefined;
     let outgoingData = { ...evt.data };
     if (evt.stream === "thinking") {
@@ -381,7 +405,7 @@ export function forwardAgentEventRaw(evt) {
     // Emit subagent ended SSE when a subagent run terminates
     if (isTerminalLifecycle && isSubagentOwnEvent && subagentEntry.status !== "ended") {
         const outcome = lifecyclePhase === "error" ? "error" : "ok";
-        const errorStr = lifecyclePhase === "error" ? String(evt.data.error ?? "unknown") : undefined;
+        const errorStr = lifecyclePhase === "error" ? stringifySubagentError(evt.data.error) : undefined;
         const ended = registerSubagentEnded({ runId: evt.runId, outcome, error: errorStr });
         if (ended) {
             sseEmitter.broadcast({

package/dist/src/history/normalize-message.js

@@ -46,6 +46,16 @@ function splitMediaLines(text) {
         .trim();
     return { text: cleaned, paths };
 }
+/**
+ * Tools whose `toolResult` carries a user-facing PRODUCED image, which stays a
+ * chat attachment. Every OTHER tool's inline image block is the agent's visual
+ * INPUT — a file the `read` tool fed to the model, a `canvas` snapshot, a
+ * browser screenshot — and must NOT surface as an attachment on history rebuild
+ * (it spawns phantom, often-corrupt bubbles for turns where the agent never
+ * sent a file). Keep this a whitelist so any new image-CONSUMING tool is safe by
+ * default; add new image-PRODUCING tools here explicitly.
+ */
+const IMAGE_PRODUCING_TOOLS = new Set(["image_generation"]);
 const MEDIA_MARKER_RE = /\[media attached:\s*([^\]]+)\]/gi;
 /** Pull `[media attached: <url>]` markers out of free text into image refs. */
 function extractMediaMarkers(text) {
@@ -181,14 +191,18 @@ export function normalizeHistoryMessage(raw, index) {
     if (role === "toolResult") {
         const split = splitMediaLines(parsed.text);
         const toolName = readString(record.toolName);
-        // Canvas snapshots come back as base64 image blocks on the `canvas` tool result so the *agent*
-        // can "see" the rendered page — they must never surface as chat attachments on history rebuild.
-        // The streaming deliver path already drops the temp-file form (see isCanvasSnapshotMediaPath in
-        // http/handlers/messages.ts); this is the transcript-rebuild counterpart. The canvas tool has no
-        // other image-returning action, so all images on a canvas result are snapshots.
-        const isCanvasResult = toolName === "canvas";
-        const images = isCanvasResult ? [] : parsed.images;
-        const mediaPaths = isCanvasResult ? [] : split.paths;
+        // Inline image blocks on a toolResult are almost always the agent's visual
+        // INPUT — a file the `read` tool fed to the model, a `canvas` snapshot (so the
+        // agent can "see" the rendered page), a browser screenshot — NOT a user-facing
+        // attachment. Surfacing them spawns phantom, often-corrupt attachment bubbles on
+        // history rebuild for turns where the agent never sent a file. Only tools that
+        // PRODUCE a user-facing image keep their blocks. (This was a `canvas`-only
+        // blacklist, which still leaked `read`/screenshot images.) The streaming deliver
+        // path drops the canvas temp-file form separately (isCanvasSnapshotMediaPath in
+        // http/handlers/messages.ts); this is the transcript-rebuild counterpart.
+        const keepInlineImages = toolName ? IMAGE_PRODUCING_TOOLS.has(toolName) : false;
+        const images = keepInlineImages ? parsed.images : [];
+        const mediaPaths = toolName === "canvas" ? [] : split.paths;
         const toolResult = {
             ...(readString(record.toolCallId) ? { toolCallId: readString(record.toolCallId) } : {}),
             ...(toolName ? { toolName } : {}),

package/dist/src/http/handlers/agent-config.d.ts

@@ -0,0 +1,27 @@
+/**
+ * GET/PUT /friday-next/agents/{id}/config
+ *
+ * Reads and edits a single agent's runtime configuration — the same fields
+ * OpenClaw's ControlUI manages, but written through the plugin's own config
+ * channel (`api.runtime.config.mutateConfigFile`, proven by plugin-upgrade) so
+ * NO OpenClaw core changes are needed. All edits land in `agents.list[]` of the
+ * host config file (`~/.clawrc`), exactly where ControlUI's `config.set` writes.
+ *
+ * Editable fields:
+ *  - model           → agents.list[i].model        (string | {primary,fallbacks})
+ *  - thinkingDefault → agents.list[i].thinkingDefault
+ *  - tools           → agents.list[i].tools        ({profile,allow,alsoAllow,deny})
+ *  - skills          → agents.list[i].skills       (string[]; [] disables all, absent inherits defaults)
+ *
+ * Clearing an override MUST delete the field (not leave a stale value) so the
+ * core's config merge falls back to `agents.defaults` — same hazard documented
+ * for the default-model bug. PUT therefore treats an explicit `null` as "clear".
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+export interface AgentToolsConfig {
+    profile?: string;
+    allow?: string[];
+    alsoAllow?: string[];
+    deny?: string[];
+}
+export declare function handleAgentConfig(req: IncomingMessage, res: ServerResponse, rawAgentId: string): Promise<boolean>;