@syengup/friday-channel-next 0.1.13 → 0.1.15

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

@@ -0,0 +1,100 @@
+/**
+ * GET /friday-next/history/messages?sessionKey=&agentId=&limit=
+ *
+ * Returns a session's transcript history as a flat, normalized message stream.
+ * The Friday app groups these into rounds itself (by role transitions) and uses
+ * each message's stable `id` (the upstream transcript entry id) as its sync key.
+ *
+ * Reads via the gateway `sessions.get` method (exposed to plugins as
+ * `runtime.subagent.getSessionMessages`), which already resolves the active
+ * branch and compaction, then normalizes each raw message into a stable DTO.
+ */
+import { getFridayNextRuntime } from "../../runtime.js";
+import { extractBearerToken } from "../middleware/auth.js";
+import { normalizeHistoryMessages } from "../../history/normalize-message.js";
+import { readSessionTranscriptRawMessages, resolveSessionId } from "../../history/read-transcript.js";
+import { resolveMediaAttachment } from "./files.js";
+const DEFAULT_LIMIT = 200;
+const MAX_LIMIT = 1000;
+function resolveSubagentApi() {
+    try {
+        const runtime = getFridayNextRuntime();
+        return runtime.subagent;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function handleHistoryMessages(req, res) {
+    if (req.method !== "GET") {
+        res.statusCode = 405;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Method Not Allowed" }));
+        return true;
+    }
+    const token = extractBearerToken(req);
+    if (!token) {
+        res.statusCode = 401;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Unauthorized: bearer token mismatch" }));
+        return true;
+    }
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const sessionKey = url.searchParams.get("sessionKey")?.trim();
+    if (!sessionKey) {
+        res.statusCode = 400;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Missing required query param: sessionKey" }));
+        return true;
+    }
+    const agentId = url.searchParams.get("agentId")?.trim() || undefined;
+    const limitParam = Number(url.searchParams.get("limit"));
+    const limit = Number.isFinite(limitParam) && limitParam > 0
+        ? Math.min(Math.floor(limitParam), MAX_LIMIT)
+        : DEFAULT_LIMIT;
+    // Primary path: read the transcript file directly (works from an HTTP route).
+    let rawMessages = readSessionTranscriptRawMessages(sessionKey, limit);
+    // Fallback: the request-scoped gateway method (only works in some contexts).
+    if (rawMessages.length === 0) {
+        const sessionApi = resolveSubagentApi();
+        if (sessionApi?.getSessionMessages) {
+            try {
+                const response = await sessionApi.getSessionMessages({ sessionKey, limit });
+                rawMessages = Array.isArray(response?.messages) ? response.messages : [];
+            }
+            catch {
+                // Best-effort: an unreadable/unknown session yields an empty history
+                // rather than an error, so the app degrades gracefully.
+                rawMessages = [];
+            }
+        }
+    }
+    const messages = normalizeHistoryMessages(rawMessages);
+    // Resolve `MEDIA:<server-path>` references into downloadable attachment URLs
+    // (copies the file into the plugin's attachments/ dir — the same mechanism the
+    // live deliver path uses), then drop the raw paths from the wire.
+    for (const message of messages) {
+        if (!message.mediaPaths?.length)
+            continue;
+        const resolved = message.mediaPaths
+            .map((p) => resolveMediaAttachment(p))
+            .filter((r) => Boolean(r))
+            .map((r) => ({ url: r.url, filename: r.fileName }));
+        if (resolved.length) {
+            message.images = [...(message.images ?? []), ...resolved];
+        }
+        delete message.mediaPaths;
+    }
+    const sessionId = resolveSessionId(sessionKey);
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({
+        ok: true,
+        sessionKey,
+        ...(agentId ? { agentId } : {}),
+        ...(sessionId ? { sessionId } : {}),
+        totalMessages: messages.length,
+        messages,
+    }));
+    return true;
+}

package/dist/src/http/handlers/history-sessions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * GET /friday-next/history/sessions
+ *
+ * Lists every session across every configured agent (lightweight metadata only).
+ * The Friday app uses this to surface sessions created on other platforms /
+ * channels in its sidebar before lazily fetching each session's history.
+ *
+ * Session message bodies are intentionally NOT read here — that is the job of the
+ * per-session history endpoint. We only read each agent's `sessions.json` via the
+ * forward runtime (`loadSessionStore`), matching the read path already used for
+ * terminal lifecycle forwards.
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+export interface FridayHistorySessionSummary {
+    /** Canonical app session key, e.g. "agent:main:main". */
+    sessionKey: string;
+    agentId: string;
+    sessionId?: string;
+    updatedAt?: number;
+    model?: string;
+    title?: string;
+}
+export declare function handleHistorySessions(req: IncomingMessage, res: ServerResponse): Promise<boolean>;

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

@@ -0,0 +1,163 @@
+/**
+ * GET /friday-next/history/sessions
+ *
+ * Lists every session across every configured agent (lightweight metadata only).
+ * The Friday app uses this to surface sessions created on other platforms /
+ * channels in its sidebar before lazily fetching each session's history.
+ *
+ * Session message bodies are intentionally NOT read here — that is the job of the
+ * per-session history endpoint. We only read each agent's `sessions.json` via the
+ * forward runtime (`loadSessionStore`), matching the read path already used for
+ * terminal lifecycle forwards.
+ */
+import fs from "node:fs";
+import { getFridayAgentForwardRuntime } from "../../agent-forward-runtime.js";
+import { extractBearerToken } from "../middleware/auth.js";
+import { resolveTranscriptPath } from "../../history/read-transcript.js";
+const DEFAULT_AGENT_ID = "main";
+const SAFE_AGENT_ID = /^[a-z0-9][a-z0-9_-]*$/;
+/** Mirror of OpenClaw's `normalizeAgentId` (also used in agents-list.ts). */
+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);
+}
+function readString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function readNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+/** Configured agent ids (deduped). Falls back to the implicit "main" agent. */
+function resolveConfiguredAgentIds(config) {
+    const agents = config?.agents;
+    const list = agents?.list;
+    if (!Array.isArray(list) || list.length === 0)
+        return [DEFAULT_AGENT_ID];
+    const ids = new Set();
+    for (const agent of list) {
+        if (agent && typeof agent === "object")
+            ids.add(normalizeAgentId(agent.id));
+    }
+    if (ids.size === 0)
+        ids.add(DEFAULT_AGENT_ID);
+    return [...ids];
+}
+/** Build the canonical app session key from an agent + a raw sessions.json key. */
+function toCanonicalSessionKey(agentId, storeKey) {
+    const key = storeKey.trim();
+    if (key.toLowerCase().startsWith("agent:"))
+        return key;
+    return `agent:${agentId}:${key}`;
+}
+/** Session-id portion (everything after `agent:<id>:`). */
+function sessionRest(canonicalKey) {
+    const m = canonicalKey.match(/^agent:[^:]+:(.+)$/);
+    return (m?.[1] ?? canonicalKey).toLowerCase();
+}
+/**
+ * Internal/system sessions that aren't user-facing conversations — mirrors what
+ * OpenClaw's own `sessions.list` filters (cron/global/unknown/phantom) plus
+ * heartbeat / subagent / memory-dreaming runs.
+ */
+function isInternalSessionKey(canonicalKey, storeKey) {
+    const k = storeKey.toLowerCase();
+    if (k === "global" || k === "unknown")
+        return true;
+    const rest = sessionRest(canonicalKey);
+    return (rest === "sessions" || // phantom agent-store entry
+        rest.startsWith("subagent:") ||
+        rest.startsWith("cron:") ||
+        rest.startsWith("dreaming-narrative") ||
+        rest === "heartbeat" ||
+        rest.endsWith(":heartbeat"));
+}
+/** A session counts as archived/empty when its transcript file is gone or empty. */
+function hasLiveTranscript(entry, storePath) {
+    const filePath = resolveTranscriptPath(entry, storePath);
+    if (!filePath)
+        return false;
+    try {
+        return fs.statSync(filePath).size > 0;
+    }
+    catch {
+        return false; // archived (moved to .deleted/.bak) or never written
+    }
+}
+function readAgentSessions(agentId) {
+    const rt = getFridayAgentForwardRuntime();
+    if (!rt)
+        return [];
+    let storePath;
+    let store;
+    try {
+        storePath = rt.resolveStorePath(undefined, { agentId });
+        store = rt.loadSessionStore(storePath) ?? {};
+    }
+    catch {
+        return [];
+    }
+    const summaries = [];
+    for (const [storeKey, rawEntry] of Object.entries(store)) {
+        if (!rawEntry || typeof rawEntry !== "object")
+            continue;
+        const entry = rawEntry;
+        const canonicalKey = toCanonicalSessionKey(agentId, storeKey);
+        // Drop internal/system sessions and subagent links.
+        if (isInternalSessionKey(canonicalKey, storeKey))
+            continue;
+        if (entry.spawnedBy || entry.subagentRole || entry.parentSessionKey)
+            continue;
+        // Drop archived/empty sessions (transcript moved away or never written).
+        if (!hasLiveTranscript(entry, storePath))
+            continue;
+        summaries.push({
+            sessionKey: canonicalKey,
+            agentId,
+            ...(readString(entry.sessionId) ? { sessionId: readString(entry.sessionId) } : {}),
+            ...(readNumber(entry.updatedAt) !== undefined ? { updatedAt: readNumber(entry.updatedAt) } : {}),
+            ...(readString(entry.model) ?? readString(entry.modelOverride)
+                ? { model: readString(entry.model) ?? readString(entry.modelOverride) }
+                : {}),
+            // Server-side session display name (matches OpenClaw's resolution order).
+            ...(readString(entry.displayName) ?? readString(entry.label)
+                ? { title: readString(entry.displayName) ?? readString(entry.label) }
+                : {}),
+        });
+    }
+    return summaries;
+}
+export async function handleHistorySessions(req, res) {
+    if (req.method !== "GET") {
+        res.statusCode = 405;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Method Not Allowed" }));
+        return true;
+    }
+    const token = extractBearerToken(req);
+    if (!token) {
+        res.statusCode = 401;
+        res.setHeader("Content-Type", "application/json");
+        res.end(JSON.stringify({ error: "Unauthorized: bearer token mismatch" }));
+        return true;
+    }
+    const rt = getFridayAgentForwardRuntime();
+    const config = rt?.getConfig();
+    const agentIds = resolveConfiguredAgentIds(config);
+    const sessions = [];
+    for (const agentId of agentIds) {
+        sessions.push(...readAgentSessions(agentId));
+    }
+    sessions.sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify({ ok: true, sessions }));
+    return true;
+}

package/dist/src/http/handlers/history-set-title.d.ts

@@ -0,0 +1,10 @@
+/**
+ * PUT /friday-next/sessions/title  body: { sessionKey, title }
+ *
+ * Syncs the app-set session name to the server session's `displayName` (the
+ * field OpenClaw resolves first for a session's display title, ahead of `label`).
+ * Writes via `updateSessionStoreEntry` (cache-owning, not request-scoped), so the
+ * change is also visible to webui and other clients.
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+export declare function handleHistorySetTitle(req: IncomingMessage, res: ServerResponse): Promise<boolean>;

package/dist/src/http/handlers/history-set-title.js

@@ -0,0 +1,77 @@
+/**
+ * PUT /friday-next/sessions/title  body: { sessionKey, title }
+ *
+ * Syncs the app-set session name to the server session's `displayName` (the
+ * field OpenClaw resolves first for a session's display title, ahead of `label`).
+ * Writes via `updateSessionStoreEntry` (cache-owning, not request-scoped), so the
+ * change is also visible to webui and other clients.
+ */
+import { getFridayAgentForwardRuntime } from "../../agent-forward-runtime.js";
+import { extractBearerToken } from "../middleware/auth.js";
+import { readJsonBody } from "../middleware/body.js";
+import { agentIdFromSessionKey, toSessionStoreKey } from "../../session/session-manager.js";
+function json(res, status, body) {
+    res.statusCode = status;
+    res.setHeader("Content-Type", "application/json");
+    res.end(JSON.stringify(body));
+    return true;
+}
+/** Real store key matching `sessionKey`, tolerating deviceId case differences. */
+function resolveStoreKey(store, sessionKey) {
+    if (store[sessionKey])
+        return sessionKey;
+    const canonical = toSessionStoreKey(sessionKey);
+    if (store[canonical])
+        return canonical;
+    const target = canonical.toLowerCase();
+    for (const k of Object.keys(store)) {
+        if (k.toLowerCase() === target)
+            return k;
+    }
+    return undefined;
+}
+export async function handleHistorySetTitle(req, res) {
+    if (req.method !== "PUT" && req.method !== "POST") {
+        return json(res, 405, { error: "Method Not Allowed" });
+    }
+    if (!extractBearerToken(req)) {
+        return json(res, 401, { error: "Unauthorized: bearer token mismatch" });
+    }
+    const body = (await readJsonBody(req));
+    const sessionKey = typeof body?.sessionKey === "string" ? body.sessionKey.trim() : "";
+    const title = typeof body?.title === "string" ? body.title.trim() : "";
+    if (!sessionKey) {
+        return json(res, 400, { error: "Missing required field: sessionKey" });
+    }
+    const rt = getFridayAgentForwardRuntime();
+    if (!rt?.updateSessionStoreEntry) {
+        return json(res, 503, { error: "Session store write not available" });
+    }
+    const agentId = agentIdFromSessionKey(sessionKey);
+    let storePath;
+    let store;
+    try {
+        storePath = rt.resolveStorePath(undefined, { agentId });
+        store = rt.loadSessionStore(storePath) ?? {};
+    }
+    catch {
+        return json(res, 500, { error: "Failed to load session store" });
+    }
+    const storeKey = resolveStoreKey(store, sessionKey);
+    if (!storeKey) {
+        return json(res, 404, { error: `Session not found: ${sessionKey}` });
+    }
+    try {
+        const updated = await rt.updateSessionStoreEntry({
+            storePath,
+            sessionKey: storeKey,
+            // Empty title clears the override so the server can derive its own again.
+            update: () => ({ displayName: title || undefined }),
+        });
+        const sessionId = updated && typeof updated.sessionId === "string" ? updated.sessionId : undefined;
+        return json(res, 200, { ok: true, sessionKey, ...(sessionId ? { sessionId } : {}), title });
+    }
+    catch {
+        return json(res, 500, { error: "Failed to update session title" });
+    }
+}

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

@@ -13,8 +13,7 @@ import crypto from "node:crypto";
 import { resolveFridayNextConfig } from "../../config.js";
 import { getHostOpenClawConfigSnapshot } from "../../host-config.js";
 import { getFridayNextRuntime } from "../../runtime.js";
-import { getFridayAgentForwardRuntime } from "../../agent-forward-runtime.js";
-import { agentIdFromSessionKey, setSessionSettings, splitModelRef, toSessionStoreKey, } from "../../session/session-manager.js";
+import { resolveAgentDefaults, setSessionSettings, splitModelRef, toSessionStoreKey, } from "../../session/session-manager.js";
 import { sseEmitter } from "../../sse/emitter.js";
 import { extractBearerToken } from "../middleware/auth.js";
 import { readJsonBody } from "../middleware/body.js";
@@ -314,41 +313,9 @@ export async function handleMessages(req, res) {
     res.end(JSON.stringify({ accepted: true, deviceId: normalizedDeviceId, runId }));
     log("MESSAGE_RECEIVED", normalizedDeviceId, runId, `textLen=${trimmedText.length} attachments=${attachments.length} sessionKey=${baseSessionKey}`);
     const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(runtime.config));
-    // Resolve defaults from the OpenClaw agent config so settings are never left empty.
-    // The target agent comes from the app-supplied sessionKey (`agent:<id>:<rest>`); prefer that
-    // agent's own configured model/thinking over the global defaults so non-main agents are not
-    // silently forced onto the global default model.
-    const targetAgentId = agentIdFromSessionKey(baseSessionKey);
-    let defaultModel;
-    let defaultThinking;
-    try {
-        const forwardRt = getFridayAgentForwardRuntime();
-        if (forwardRt) {
-            const ocCfg = (forwardRt.getConfig() ?? {});
-            const agents = ocCfg.agents;
-            const agentEntry = agents?.list?.find((a) => agentIdFromSessionKey(`agent:${String(a?.id ?? "")}:x`) === targetAgentId);
-            const agentModel = agentEntry?.model;
-            const perAgentModel = typeof agentModel === "string"
-                ? agentModel
-                : typeof agentModel?.primary === "string"
-                    ? agentModel.primary
-                    : undefined;
-            const perAgentThinking = typeof agentEntry?.thinkingDefault === "string"
-                ? agentEntry.thinkingDefault
-                : undefined;
-            const agentDefaults = agents?.defaults;
-            const model = agentDefaults?.model;
-            const globalModel = typeof model?.primary === "string" ? model.primary : undefined;
-            const globalThinking = typeof agentDefaults?.thinkingDefault === "string"
-                ? agentDefaults.thinkingDefault
-                : undefined;
-            defaultModel = perAgentModel ?? globalModel;
-            defaultThinking = perAgentThinking ?? globalThinking;
-        }
-    }
-    catch {
-        // Config not available (tests) — leave defaults undefined.
-    }
+    // Resolve defaults from the OpenClaw agent config so settings are never left empty. Prefers the
+    // target agent's own model/thinking over the global defaults (see resolveAgentDefaults).
+    const { model: defaultModel, thinking: defaultThinking } = resolveAgentDefaults(baseSessionKey);
     const modelRef = payload.modelRef ?? defaultModel;
     const reasoningLevel = payload.reasoningLevel ?? "stream";
     const thinkingLevel = payload.thinkingLevel ?? defaultThinking;
@@ -356,7 +323,8 @@ export async function handleMessages(req, res) {
     if (modelRef) {
         settings.modelRef = modelRef;
         const split = splitModelRef(modelRef);
-        settings.providerOverride = split.provider;
+        // `?? null` clears a stale provider when the resolved ref is bare (no `provider/` prefix).
+        settings.providerOverride = split.provider ?? null;
         settings.modelOverride = split.modelId;
     }
     if (reasoningLevel)

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

@@ -1,4 +1,4 @@
-import { setSessionSettings, getSessionSettings, splitModelRef, } from "../../session/session-manager.js";
+import { setSessionSettings, getSessionSettings, splitModelRef, resolveAgentDefaults, } from "../../session/session-manager.js";
 import { readJsonBody } from "../middleware/body.js";
 import { extractBearerToken } from "../middleware/auth.js";
 const VALID_REASONING = new Set(["on", "off", "stream"]);
@@ -43,7 +43,7 @@ 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 : undefined;
+    const modelRef = typeof body?.modelRef === "string" ? body.modelRef.trim() : undefined;
     const errors = [];
     if (reasoningLevel !== undefined && !VALID_REASONING.has(reasoningLevel)) {
         errors.push(`reasoningLevel must be one of: ${[...VALID_REASONING].join(", ")}`);
@@ -57,11 +57,26 @@ export async function handleSessionsSettings(req, res) {
         res.end(JSON.stringify({ error: errors.join("; ") }));
         return true;
     }
-    const settings = { reasoningLevel, thinkingLevel, modelRef };
-    if (modelRef) {
-        const split = splitModelRef(modelRef);
-        settings["providerOverride"] = split.provider;
-        settings["modelOverride"] = split.modelId;
+    // 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);
+        settings.modelRef = effectiveModelRef;
+        // `?? null` clears a stale provider when the ref is bare (no `provider/` prefix).
+        settings.providerOverride = split.provider ?? null;
+        settings.modelOverride = split.modelId;
+    }
+    else {
+        // No configured default to resolve (e.g. config unavailable) — clear rather than pin a stale model.
+        settings.modelRef = null;
+        settings.providerOverride = null;
+        settings.modelOverride = null;
     }
     const result = setSessionSettings(sessionKey, settings);
     res.statusCode = 200;

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 { handleHistorySessions } from "./handlers/history-sessions.js";
+import { handleHistoryMessages } from "./handlers/history-messages.js";
+import { handleHistorySetTitle } from "./handlers/history-set-title.js";
 import { handleStatus } from "./handlers/status.js";
 import { handleHealth } from "./handlers/health.js";
 import { applyCorsHeaders } from "./middleware/cors.js";
@@ -68,6 +71,18 @@ async function handleFridayNextRoute(req, res) {
     if (req.method === "GET" && pathname === "/friday-next/status") {
         return await handleStatus(req, res);
     }
+    // Route: GET /friday-next/history/sessions (list all sessions across agents)
+    if (req.method === "GET" && pathname === "/friday-next/history/sessions") {
+        return await handleHistorySessions(req, res);
+    }
+    // Route: GET /friday-next/history/messages?sessionKey=&agentId=&limit=
+    if (req.method === "GET" && pathname === "/friday-next/history/messages") {
+        return await handleHistoryMessages(req, res);
+    }
+    // Route: PUT /friday-next/sessions/title (sync app session name → server displayName)
+    if ((req.method === "PUT" || req.method === "POST") && pathname === "/friday-next/sessions/title") {
+        return await handleHistorySetTitle(req, res);
+    }
     // Route: GET /friday-next/health?deviceId=...&nodeDeviceId=...&selfHeal=true
     if (req.method === "GET" && pathname === "/friday-next/health") {
         return await handleHealth(req, res);

package/dist/src/session/session-manager.d.ts

@@ -17,5 +17,34 @@ export interface FridaySessionSettings {
     providerOverride?: string;
     modelOverride?: string;
 }
-export declare function setSessionSettings(sessionKey: string, settings: FridaySessionSettings, historyDir?: string): FridaySessionSettings;
+/**
+ * Update shape for {@link setSessionSettings}. A field set to a string writes that value, a field
+ * left `undefined` is untouched, and a field set to `null` **clears** the stored value. The `null`
+ * case is what lets the app reset a model override back to the agent default — without it the merge
+ * could only ever add/replace overrides, never remove them (the cause of "selecting the default
+ * model doesn't take effect": a prior `provider/model` override survived and was read back).
+ */
+export type FridaySessionSettingsUpdate = {
+    reasoningLevel?: string | null;
+    thinkingLevel?: string | null;
+    modelRef?: string | null;
+    providerOverride?: string | null;
+    modelOverride?: string | null;
+};
+export declare function setSessionSettings(sessionKey: string, settings: FridaySessionSettingsUpdate, historyDir?: string): FridaySessionSettings;
 export declare function getSessionSettings(sessionKey: string, historyDir?: string): FridaySessionSettings;
+/**
+ * Resolve the configured default model + thinking level for the agent that owns `sessionKey`,
+ * reading the live OpenClaw config. Prefers the target agent's own `model`/`thinkingDefault` over
+ * the global `agents.defaults`, so non-main agents aren't silently forced onto the global default.
+ *
+ * Used to write the default model as an **explicit** override when the app selects it (the app
+ * sends no modelRef for the default). Writing it explicitly — rather than clearing the stored
+ * override — keeps the shared session entry consistent with the core's provenance fields
+ * (`modelOverrideSource`, `model`, `modelProvider`); a bare clear leaves those dangling and the
+ * agent mis-resolves to a fallback model.
+ */
+export declare function resolveAgentDefaults(sessionKey: string): {
+    model?: string;
+    thinking?: string;
+};

package/dist/src/session/session-manager.js

@@ -1,6 +1,7 @@
 import { join } from "node:path";
 import os from "node:os";
 import { readFileSync, writeFileSync } from "node:fs";
+import { getFridayAgentForwardRuntime } from "../agent-forward-runtime.js";
 const FRIDAY_AGENT_ID = "main";
 const SESSION_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
 /** Path/shell-safe agent id (mirrors OpenClaw's `normalizeAgentId`). Anything else falls back to `main`. */
@@ -122,7 +123,17 @@ export function setSessionSettings(sessionKey, settings, historyDir) {
         let updated = false;
         for (const key of fieldKeys) {
             const value = settings[key];
-            if (value !== undefined && data[fileKey][key] !== value) {
+            if (value === undefined)
+                continue; // leave the stored value untouched
+            if (value === null) {
+                // Explicit clear — remove the override so the agent falls back to its default.
+                if (key in data[fileKey]) {
+                    delete data[fileKey][key];
+                    updated = true;
+                }
+                continue;
+            }
+            if (data[fileKey][key] !== value) {
                 data[fileKey][key] = value;
                 updated = true;
             }
@@ -163,3 +174,41 @@ export function getSessionSettings(sessionKey, historyDir) {
         return {};
     }
 }
+/**
+ * Resolve the configured default model + thinking level for the agent that owns `sessionKey`,
+ * reading the live OpenClaw config. Prefers the target agent's own `model`/`thinkingDefault` over
+ * the global `agents.defaults`, so non-main agents aren't silently forced onto the global default.
+ *
+ * Used to write the default model as an **explicit** override when the app selects it (the app
+ * sends no modelRef for the default). Writing it explicitly — rather than clearing the stored
+ * override — keeps the shared session entry consistent with the core's provenance fields
+ * (`modelOverrideSource`, `model`, `modelProvider`); a bare clear leaves those dangling and the
+ * agent mis-resolves to a fallback model.
+ */
+export function resolveAgentDefaults(sessionKey) {
+    try {
+        const forwardRt = getFridayAgentForwardRuntime();
+        if (!forwardRt)
+            return {};
+        const ocCfg = (forwardRt.getConfig() ?? {});
+        const agents = ocCfg.agents;
+        const targetAgentId = agentIdFromSessionKey(sessionKey);
+        const agentEntry = agents?.list?.find((a) => agentIdFromSessionKey(`agent:${String(a?.id ?? "")}:x`) === targetAgentId);
+        const agentModel = agentEntry?.model;
+        const perAgentModel = typeof agentModel === "string"
+            ? agentModel
+            : typeof agentModel?.primary === "string"
+                ? agentModel.primary
+                : undefined;
+        const perAgentThinking = typeof agentEntry?.thinkingDefault === "string" ? agentEntry.thinkingDefault : undefined;
+        const agentDefaults = agents?.defaults;
+        const model = agentDefaults?.model;
+        const globalModel = typeof model?.primary === "string" ? model.primary : undefined;
+        const globalThinking = typeof agentDefaults?.thinkingDefault === "string" ? agentDefaults.thinkingDefault : undefined;
+        return { model: perAgentModel ?? globalModel, thinking: perAgentThinking ?? globalThinking };
+    }
+    catch {
+        // Config not available (e.g. unit tests) — caller decides the fallback.
+        return {};
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syengup/friday-channel-next",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "OpenClaw Friday Next Apple channel plugin",
   "license": "MIT",
   "type": "module",
@@ -14,7 +14,7 @@
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "prepublishOnly": "pnpm build",
+    "prepublishOnly": "pnpm build && rm -rf dist/attachments",
     "test": "npm run test:unit && npm run test:e2e",
     "test:unit": "vitest run",
     "test:e2e": "vitest run --config vitest.e2e.config.ts",