@syengup/friday-channel-next 0.1.30 → 0.1.37

package/src/friday-session.ts

@@ -49,7 +49,7 @@ export function deviceIdFromSessionKey(sessionKey: string): string | null {
   const m1 = sessionKey.match(/^friday-next-(.+)$/i);
   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;
 }
 
 /**
@@ -66,7 +66,8 @@ const deviceIdToLatestHistorySessionKey = new Map<string, string>();
 let lastRegisteredFridayDeviceId: string | undefined;
 
 function normalizeFridaySessionKeyCase(sk: string): string {
-  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;
 }
@@ -157,7 +158,11 @@ function mergeRunMetadataIntoLifecycleEnd(
   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 (
@@ -260,7 +265,10 @@ function completeAgentEventForward(params: {
 /**
  * Resolve the real device UUID for Friday outbound (`sendText` / `sendMedia`).
  */
-export function resolveFridayDeviceIdForOutbound(to: string | undefined, rawCtx?: Record<string, unknown>): string {
+export function resolveFridayDeviceIdForOutbound(
+  to: string | undefined,
+  rawCtx?: Record<string, unknown>,
+): string {
   const trimmed = (to ?? "").trim();
   if (trimmed && trimmed.toLowerCase() !== "friday-next") {
     return trimmed;
@@ -279,6 +287,23 @@ export function resolveFridayDeviceIdForOutbound(to: string | undefined, rawCtx?
   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: unknown): string {
+  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).
  *
@@ -308,8 +333,7 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
   if (!deviceIdRaw) return;
 
   if (!sk) {
-    sk =
-      latestHistorySessionKeyForDeviceId(deviceIdRaw) ?? `friday-next-${deviceIdRaw}`;
+    sk = latestHistorySessionKeyForDeviceId(deviceIdRaw) ?? `friday-next-${deviceIdRaw}`;
   }
 
   openClawRunIdToDeviceId.set(evt.runId, deviceIdRaw.toUpperCase());
@@ -325,11 +349,9 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
 
   // Phase 1: spawning — tool.start with taskName in args
   if (isSpawnTool && evt.data.phase === "start") {
-    const toolCallId =
-      typeof evt.data.toolCallId === "string" ? evt.data.toolCallId : "";
+    const toolCallId = typeof evt.data.toolCallId === "string" ? evt.data.toolCallId : "";
     const args = evt.data.args as Record<string, unknown> | undefined;
-    const label =
-      typeof args?.taskName === "string" ? args.taskName : undefined;
+    const label = typeof args?.taskName === "string" ? args.taskName : undefined;
     if (toolCallId) {
       const intent = registerSpawnIntent({
         toolCallId,
@@ -362,15 +384,12 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
       | { childSessionKey?: string; runId?: string; taskName?: string }
       | undefined;
     if (details?.childSessionKey) {
-      const toolCallId =
-        typeof evt.data.toolCallId === "string" ? evt.data.toolCallId : "";
+      const toolCallId = typeof evt.data.toolCallId === "string" ? evt.data.toolCallId : "";
       const intent = toolCallId ? consumeSpawnIntent(toolCallId) : undefined;
       const label =
         details.taskName ||
         intent?.label ||
-        (typeof (evt.data as Record<string, unknown>).meta === "string"
-          ? ((evt.data as Record<string, unknown>).meta as string)
-          : undefined);
+        (typeof evt.data.meta === "string" ? evt.data.meta : undefined);
       const entry = ensureSubagentFromSpawnTool({
         childSessionKey: details.childSessionKey,
         bareRunId: details.runId,
@@ -404,10 +423,13 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
   // Only annotate events that originate from the subagent itself
   // (sessionKey matches childSessionKey). Main-agent delivery events
   // share the announce runId but have a different sessionKey.
-  const isSubagentOwnEvent =
-    subagentEntry && sk && subagentEntry.childSessionKey === sk;
+  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: Record<string, unknown> = { ...evt.data };
@@ -436,12 +458,14 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
 
   const lifecyclePhase =
     evt.stream === "lifecycle" && typeof evt.data.phase === "string" ? evt.data.phase : "";
-  const isTerminalLifecycle = evt.stream === "lifecycle" && (lifecyclePhase === "end" || lifecyclePhase === "error");
+  const isTerminalLifecycle =
+    evt.stream === "lifecycle" && (lifecyclePhase === "end" || lifecyclePhase === "error");
 
   // 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/src/history/normalize-message.test.ts

@@ -1,8 +1,5 @@
 import { describe, it, expect } from "vitest";
-import {
-  normalizeHistoryMessage,
-  normalizeHistoryMessages,
-} from "./normalize-message.js";
+import { normalizeHistoryMessage, normalizeHistoryMessages } from "./normalize-message.js";
 
 function meta(id?: string, seq = 1, extra: Record<string, unknown> = {}) {
   return { __openclaw: { ...(id ? { id } : {}), seq, recordTimestampMs: 1700000000000, ...extra } };
@@ -124,7 +121,7 @@ describe("normalizeHistoryMessage", () => {
     expect(out?.toolResult?.images).toBeUndefined();
   });
 
-  it("keeps image blocks on non-canvas toolResults", () => {
+  it("keeps image blocks on image-producing (image_generation) toolResults", () => {
     const out = normalizeHistoryMessage(
       {
         role: "toolResult",
@@ -138,11 +135,34 @@ describe("normalizeHistoryMessage", () => {
     expect(out?.toolResult?.images).toEqual([{ mimeType: "image/png", data: "REALIMG" }]);
   });
 
+  it("drops inline image blocks on read toolResults (agent visual input, not an attachment)", () => {
+    // The `read` tool returns the file it fed to the model as an inline base64
+    // image so the agent can "see" it. That is NOT a user-facing attachment —
+    // surfacing it spawned phantom corrupt image bubbles on history rebuild for
+    // turns where the agent only LOOKED at a file and sent nothing.
+    const out = normalizeHistoryMessage(
+      {
+        role: "toolResult",
+        toolCallId: "tc-read",
+        toolName: "read",
+        content: [
+          { type: "text", text: "Read image file [image/jpeg]" },
+          { type: "image", mimeType: "image/jpeg", data: "AGENTVISUALINPUT" },
+        ],
+        ...meta("entry-read", 7),
+      },
+      0,
+    );
+    expect(out?.toolResult?.images).toBeUndefined();
+    expect(out?.toolResult?.text).toBe("Read image file [image/jpeg]");
+  });
+
   it("strips MEDIA: lines from text into mediaPaths", () => {
     const out = normalizeHistoryMessage(
       {
         role: "assistant",
-        content: "Here is the serene landscape 🌅\nMEDIA:/Users/me/.openclaw/media/tool-image-generation/x.png",
+        content:
+          "Here is the serene landscape 🌅\nMEDIA:/Users/me/.openclaw/media/tool-image-generation/x.png",
         ...meta("a1", 1),
       },
       0,
@@ -158,13 +178,20 @@ describe("normalizeHistoryMessage", () => {
     );
     expect(out?.text).toBe("two files");
     expect(out?.mediaPaths).toEqual(["/a/x.png", "/a/y.mp4"]);
-    const plain = normalizeHistoryMessage({ role: "user", content: "no media here", ...meta("u", 1) }, 0);
+    const plain = normalizeHistoryMessage(
+      { role: "user", content: "no media here", ...meta("u", 1) },
+      0,
+    );
     expect(plain?.mediaPaths).toBeUndefined();
   });
 
   it("flags compaction records via __openclaw.kind", () => {
     const out = normalizeHistoryMessage(
-      { role: "system", content: [{ type: "text", text: "Compaction" }], ...meta("c1", 9, { kind: "compaction" }) },
+      {
+        role: "system",
+        content: [{ type: "text", text: "Compaction" }],
+        ...meta("c1", 9, { kind: "compaction" }),
+      },
       0,
     );
     expect(out?.kind).toBe("compaction");

package/src/history/normalize-message.ts

@@ -104,6 +104,17 @@ function splitMediaLines(text: string): { text: string; paths: string[] } {
   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. */
@@ -219,10 +230,7 @@ function normalizeRole(raw: unknown): FridayHistoryRole {
  * Normalize one raw transcript message. `index` is the position in the returned
  * batch, used only to synthesize a stable-ish id when upstream omits one.
  */
-export function normalizeHistoryMessage(
-  raw: unknown,
-  index: number,
-): FridayHistoryMessage | null {
+export function normalizeHistoryMessage(raw: unknown, index: number): FridayHistoryMessage | null {
   const record = asRecord(raw);
   if (!record) return null;
 
@@ -254,14 +262,18 @@ export function normalizeHistoryMessage(
   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: FridayHistoryToolResult = {
       ...(readString(record.toolCallId) ? { toolCallId: readString(record.toolCallId) } : {}),
       ...(toolName ? { toolName } : {}),

package/src/history/read-transcript.ts

@@ -40,10 +40,7 @@ function resolveEntry(store: Record<string, unknown>, sessionKey: string): unkno
   return undefined;
 }
 
-export function resolveTranscriptPath(
-  entry: unknown,
-  storePath: string,
-): string | undefined {
+export function resolveTranscriptPath(entry: unknown, storePath: string): string | undefined {
   const sessionFile = entryString(entry, "sessionFile");
   if (sessionFile) {
     return path.isAbsolute(sessionFile)

package/src/http/handlers/agent-config.test.ts

@@ -0,0 +1,212 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { EventEmitter } from "node:events";
+import { Readable } from "node:stream";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { handleAgentConfig } from "./agent-config.js";
+import { setMockRuntime } from "../../test-support/mock-runtime.js";
+import {
+  setFridayAgentForwardRuntime,
+  resetFridayAgentForwardRuntimeForTest,
+} from "../../agent-forward-runtime.js";
+import { setUpgradeRuntime, resetUpgradeRuntimeForTest } from "../../upgrade-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;
+  }
+}
+
+const AUTH = { authorization: "Bearer test-token" };
+
+function makeReq(headers: Record<string, string> = {}, method = "GET", body?: unknown): any {
+  const stream = Readable.from(body === undefined ? [] : [Buffer.from(JSON.stringify(body))]);
+  return Object.assign(stream, { method, url: "/friday-next/agents/main/config", headers });
+}
+
+/** Wire both runtimes around a single mutable `config`; mutateConfigFile edits it in place. */
+function setRuntimes(config: Record<string, unknown>, workspace?: string): void {
+  setFridayAgentForwardRuntime({
+    runtime: {
+      agent: {
+        session: { resolveStorePath: () => "", loadSessionStore: () => ({}) },
+        ...(workspace ? { resolveAgentWorkspaceDir: () => workspace } : {}),
+      },
+      config: { current: () => config },
+    },
+  } as any);
+  setUpgradeRuntime({
+    runtime: {
+      system: {},
+      config: {
+        current: () => config,
+        mutateConfigFile: async ({ mutate }: { mutate: (draft: unknown) => unknown | void }) => {
+          mutate(config);
+          return config;
+        },
+      },
+    },
+    source: "/dev/path",
+  } as any);
+}
+
+describe("handleAgentConfig", () => {
+  beforeEach(() => setMockRuntime());
+  afterEach(() => {
+    resetFridayAgentForwardRuntimeForTest();
+    resetUpgradeRuntimeForTest();
+  });
+
+  it("rejects unsupported methods with 405", async () => {
+    setRuntimes({});
+    const res = new MockRes();
+    await handleAgentConfig(makeReq(AUTH, "POST"), res as any, "main");
+    expect(res.statusCode).toBe(405);
+  });
+
+  it("rejects missing token with 401", async () => {
+    setRuntimes({});
+    const res = new MockRes();
+    await handleAgentConfig(makeReq({}, "GET"), res as any, "main");
+    expect(res.statusCode).toBe(401);
+  });
+
+  it("GET returns the configured agent's editable fields", async () => {
+    setRuntimes({
+      agents: {
+        list: [
+          {
+            id: "Research Bot",
+            model: { primary: "anthropic/claude", fallbacks: ["openai/gpt-4"] },
+            thinkingDefault: "high",
+            tools: { profile: "default", deny: ["bash"], allow: ["read", "edit"] },
+            skills: ["deep-research", "verify"],
+          },
+        ],
+      },
+    });
+    const res = new MockRes();
+    await handleAgentConfig(makeReq(AUTH), res as any, "research-bot");
+    expect(res.statusCode).toBe(200);
+    const body = JSON.parse(res.body);
+    expect(body.ok).toBe(true);
+    expect(body.exists).toBe(true);
+    expect(body.model).toEqual({ primary: "anthropic/claude", fallbacks: ["openai/gpt-4"] });
+    expect(body.thinkingDefault).toBe("high");
+    expect(body.tools).toEqual({ profile: "default", allow: ["read", "edit"], deny: ["bash"] });
+    expect(body.skills).toEqual(["deep-research", "verify"]);
+  });
+
+  it("GET reports exists:false and inherited (undefined) fields for an implicit agent", async () => {
+    setRuntimes({ agents: { defaults: {} } });
+    const res = new MockRes();
+    await handleAgentConfig(makeReq(AUTH), res as any, "main");
+    const body = JSON.parse(res.body);
+    expect(body.exists).toBe(false);
+    expect(body.model).toBeUndefined();
+    expect(body.skills).toBeUndefined();
+    expect(body.availableSkills).toEqual([]);
+  });
+
+  it("GET distinguishes [] (all skills disabled) from absent (inherit)", async () => {
+    setRuntimes({ agents: { list: [{ id: "main", skills: [] }] } });
+    const res = new MockRes();
+    await handleAgentConfig(makeReq(AUTH), res as any, "main");
+    expect(JSON.parse(res.body).skills).toEqual([]);
+  });
+
+  it("PUT sets the model on an existing entry", async () => {
+    const config: Record<string, unknown> = {
+      agents: { list: [{ id: "main", model: "old/model" }] },
+    };
+    setRuntimes(config);
+    const res = new MockRes();
+    await handleAgentConfig(makeReq(AUTH, "PUT", { model: "openai/gpt-5" }), res as any, "main");
+    expect(res.statusCode).toBe(200);
+    const entry = (config.agents as any).list[0];
+    expect(entry.model).toBe("openai/gpt-5");
+  });
+
+  it("PUT model:null deletes the field so it inherits defaults", async () => {
+    const config: Record<string, unknown> = {
+      agents: { list: [{ id: "main", model: "old/model" }] },
+    };
+    setRuntimes(config);
+    const res = new MockRes();
+    await handleAgentConfig(makeReq(AUTH, "PUT", { model: null }), res as any, "main");
+    expect(res.statusCode).toBe(200);
+    expect("model" in (config.agents as any).list[0]).toBe(false);
+  });
+
+  it("PUT skills:[] disables all; skills:null clears the field", async () => {
+    const config: Record<string, unknown> = { agents: { list: [{ id: "main", skills: ["a"] }] } };
+    setRuntimes(config);
+
+    let res = new MockRes();
+    await handleAgentConfig(makeReq(AUTH, "PUT", { skills: [] }), res as any, "main");
+    expect((config.agents as any).list[0].skills).toEqual([]);
+
+    res = new MockRes();
+    await handleAgentConfig(makeReq(AUTH, "PUT", { skills: null }), res as any, "main");
+    expect("skills" in (config.agents as any).list[0]).toBe(false);
+  });
+
+  it("PUT creates a bare list entry for an implicit agent, never marking it default", async () => {
+    const config: Record<string, unknown> = { agents: { defaults: {} } };
+    setRuntimes(config);
+    const res = new MockRes();
+    await handleAgentConfig(
+      makeReq(AUTH, "PUT", { tools: { profile: "restricted" } }),
+      res as any,
+      "main",
+    );
+    expect(res.statusCode).toBe(200);
+    const list = (config.agents as any).list;
+    expect(list).toHaveLength(1);
+    expect(list[0].id).toBe("main");
+    expect(list[0].tools).toEqual({ profile: "restricted" });
+    expect("default" in list[0]).toBe(false);
+  });
+
+  it("PUT rejects a body with no editable fields", async () => {
+    setRuntimes({ agents: { list: [{ id: "main" }] } });
+    const res = new MockRes();
+    await handleAgentConfig(makeReq(AUTH, "PUT", { unrelated: 1 }), res as any, "main");
+    expect(res.statusCode).toBe(400);
+  });
+
+  it("PUT rejects a non-array, non-null skills value", async () => {
+    setRuntimes({ agents: { list: [{ id: "main" }] } });
+    const res = new MockRes();
+    await handleAgentConfig(makeReq(AUTH, "PUT", { skills: "deep-research" }), res as any, "main");
+    expect(res.statusCode).toBe(400);
+  });
+
+  it("GET lists skills discovered in the workspace skills/ dir (SKILL.md dirs only)", async () => {
+    const workspace = fs.mkdtempSync(path.join(os.tmpdir(), "friday-skills-"));
+    for (const id of ["deep-research", "verify"]) {
+      fs.mkdirSync(path.join(workspace, "skills", id), { recursive: true });
+      fs.writeFileSync(path.join(workspace, "skills", id, "SKILL.md"), "# " + id);
+    }
+    // No SKILL.md → not a skill; must be ignored.
+    fs.mkdirSync(path.join(workspace, "skills", "not-a-skill"), { recursive: true });
+    try {
+      setRuntimes({ agents: { list: [{ id: "main" }] } }, workspace);
+      const res = new MockRes();
+      await handleAgentConfig(makeReq(AUTH), res as any, "main");
+      expect(JSON.parse(res.body).availableSkills.map((s: { id: string }) => s.id)).toEqual([
+        "deep-research",
+        "verify",
+      ]);
+    } finally {
+      fs.rmSync(workspace, { recursive: true, force: true });
+    }
+  });
+});