@syengup/friday-channel-next 0.1.30 → 0.1.37

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

@@ -1,7 +1,19 @@
 import { existsSync, readdirSync, realpathSync } from "node:fs";
 import { delimiter, dirname, join } from "node:path";
 
-let cache: { listNodePairing: Function; approveNodePairing: Function } | null = null;
+// Results come from the untyped OpenClaw dist module, so the resolved shapes are
+// `any` at this host boundary — callers read dynamic fields (.pending, .status, …).
+type ListNodePairingFn = () => Promise<any>;
+type ApproveNodePairingFn = (
+  requestId: string,
+  options: { callerScopes?: unknown },
+) => Promise<any>;
+type NodePairingModule = {
+  listNodePairing: ListNodePairingFn;
+  approveNodePairing: ApproveNodePairingFn;
+};
+
+let cache: NodePairingModule | null = null;
 
 function resolveOpenClawDistFromPath(): string | null {
   // Walk PATH looking for the openclaw binary, then resolve its real
@@ -16,7 +28,9 @@ function resolveOpenClawDistFromPath(): string | null {
       const dist = join(dirname(real), "dist");
       readdirSync(dist);
       return dist;
-    } catch {}
+    } catch {
+      // Not a real dist dir — keep walking PATH.
+    }
   }
   return null;
 }
@@ -43,15 +57,17 @@ function resolveOpenClawDist(): string {
   ].filter((v): v is string => typeof v === "string" && v.length > 0);
 
   for (const root of candidates) {
-    try { readdirSync(root); return root; } catch {}
+    try {
+      readdirSync(root);
+      return root;
+    } catch {
+      // Candidate dir doesn't exist — try the next one.
+    }
   }
   throw new Error("OpenClaw dist directory not found. Set OPENCLAW_DIST env var.");
 }
 
-export async function loadNodePairingModule(): Promise<{
-  listNodePairing: Function;
-  approveNodePairing: Function;
-}> {
+export async function loadNodePairingModule(): Promise<NodePairingModule> {
   if (cache) return cache;
   const dist = resolveOpenClawDist();
   const file = readdirSync(dist).find(
@@ -63,12 +79,13 @@ export async function loadNodePairingModule(): Promise<{
   // bundled module uses `export { listNodePairing as r, … }`.  Resolve the
   // correct functions by Function.name, which preserves the original name.
   const mod = await import(join(dist, file));
-  let listNodePairing: Function | undefined;
-  let approveNodePairing: Function | undefined;
+  let listNodePairing: ListNodePairingFn | undefined;
+  let approveNodePairing: ApproveNodePairingFn | undefined;
   for (const value of Object.values(mod)) {
     if (typeof value === "function") {
-      if (value.name === "listNodePairing") listNodePairing = value;
-      else if (value.name === "approveNodePairing") approveNodePairing = value;
+      if (value.name === "listNodePairing") listNodePairing = value as ListNodePairingFn;
+      else if (value.name === "approveNodePairing")
+        approveNodePairing = value as ApproveNodePairingFn;
     }
   }
   if (!listNodePairing || !approveNodePairing) {
@@ -79,9 +96,6 @@ export async function loadNodePairingModule(): Promise<{
 }
 
 /** Vitest-only: inject mock pairing functions. */
-export function __setMockNodePairingForTests(mock: {
-  listNodePairing: Function;
-  approveNodePairing: Function;
-}): void {
+export function __setMockNodePairingForTests(mock: NodePairingModule): void {
   cache = mock;
 }

package/src/agent/run-usage-accumulator.ts

@@ -39,8 +39,10 @@ export function accumulateRunUsage(
   const entry = ensure(runId);
   if (typeof usage.input === "number" && usage.input > 0) entry.input += usage.input;
   if (typeof usage.output === "number" && usage.output > 0) entry.output += usage.output;
-  if (typeof usage.cacheRead === "number" && usage.cacheRead > 0) entry.cacheRead += usage.cacheRead;
-  if (typeof usage.cacheWrite === "number" && usage.cacheWrite > 0) entry.cacheWrite += usage.cacheWrite;
+  if (typeof usage.cacheRead === "number" && usage.cacheRead > 0)
+    entry.cacheRead += usage.cacheRead;
+  if (typeof usage.cacheWrite === "number" && usage.cacheWrite > 0)
+    entry.cacheWrite += usage.cacheWrite;
   if (typeof usage.total === "number" && usage.total > 0) entry.total += usage.total;
   if (model && model.trim()) entry.model = model.trim();
   if (provider && provider.trim()) entry.provider = provider.trim();

package/src/agent/subagent-registry.ts

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

package/src/agent-forward-runtime.ts

@@ -16,6 +16,15 @@ 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;
 };
 
@@ -30,6 +39,8 @@ export function setFridayAgentForwardRuntime(api: OpenClawPluginApi): void {
       .updateSessionStoreEntry as FridayAgentForwardRuntime["updateSessionStoreEntry"],
     resolveAgentWorkspaceDir: (api.runtime.agent as Record<string, unknown>)
       .resolveAgentWorkspaceDir as FridayAgentForwardRuntime["resolveAgentWorkspaceDir"],
+    resolveThinkingPolicy: (api.runtime.agent as Record<string, unknown>)
+      .resolveThinkingPolicy as FridayAgentForwardRuntime["resolveThinkingPolicy"],
     getConfig: () => api.runtime.config.current(),
   };
 }

package/src/agent-id.ts

@@ -0,0 +1,24 @@
+/**
+ * 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: unknown): string {
+  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/src/agent-run-context-bridge.ts

@@ -26,7 +26,9 @@ function getAgentEventState(): AgentEventStateLike | undefined {
   return { runContextById };
 }
 
-export function getOpenClawAgentRunContext(runId: string): OpenClawAgentRunContextBridge | undefined {
+export function getOpenClawAgentRunContext(
+  runId: string,
+): OpenClawAgentRunContextBridge | undefined {
   if (!runId) return undefined;
   return getAgentEventState()?.runContextById.get(runId);
 }

package/src/channel-actions.test.ts

@@ -6,7 +6,11 @@ import { handleMessageAction } from "./channel-actions.js";
 import { sseEmitter } from "./sse/emitter.js";
 import { setOfflineQueueBaseDirForTest } from "./sse/offline-queue.js";
 import { registerRunRoute } from "./run-metadata.js";
-import { createTempHistoryDir, removeTempHistoryDir, setMockRuntime } from "./test-support/mock-runtime.js";
+import {
+  createTempHistoryDir,
+  removeTempHistoryDir,
+  setMockRuntime,
+} from "./test-support/mock-runtime.js";
 
 /**
  * The `message` tool's `action=send` is handled here (NOT via outbound.sendText/sendMedia).
@@ -107,8 +111,8 @@ describe("channel-actions handleSend sessionKey routing", () => {
     // 8-byte PNG magic header so saveMediaBuffer's magic-byte detection recognizes an image.
     const pngBytes = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x01]);
     const directLink = "https://picsum.photos/600/400";
-    const fetchMock = vi.fn(async () =>
-      new Response(pngBytes, { status: 200, headers: { "content-type": "image/png" } }),
+    const fetchMock = vi.fn(
+      async () => new Response(pngBytes, { status: 200, headers: { "content-type": "image/png" } }),
     );
     vi.stubGlobal("fetch", fetchMock);
 
@@ -163,6 +167,53 @@ describe("channel-actions handleSend sessionKey routing", () => {
     expect(media?.data.sessionKey).toBe(appSession);
   });
 
+  it("send with a multi-file mediaUrls[] emits one op:media per file (same runId)", async () => {
+    // The agent's `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).
+    // handleSend must emit one outbound op:media per file, not just the first.
+    const deviceId = "DEV-ACT-MULTI";
+    const runId = "run-act-multi";
+    const appSession = "agent:operator:friday:direct:dev-act-multi:1780561609";
+    registerRunRoute({ runId, deviceId, sessionKey: appSession });
+    sseEmitter.trackDeviceForRun(deviceId, runId);
+    const res = connect(deviceId);
+
+    const files = ["A.swift", "B.swift", "C.swift"].map((name) => {
+      const p = path.join(historyDir, name);
+      fs.writeFileSync(p, `// ${name}`);
+      return p;
+    });
+
+    const result = await handleMessageAction({
+      action: "send",
+      params: {
+        to: deviceId,
+        message: "三个文件发给你",
+        media: files[0], // core sets `media` to the first entry
+        mediaUrls: files, // ...and the full list here
+      },
+      sessionKey: "agent:operator:main",
+    });
+
+    expect((result as { ok?: boolean }).ok).toBe(true);
+    const mediaFrames = parseOutboundFrames(res).filter(
+      (f) => f.type === "outbound" && f.data.op === "media",
+    );
+    expect(mediaFrames).toHaveLength(3);
+    // All media events share the send's runId so the app groups them into one assistant message.
+    const runIds = new Set(mediaFrames.map((f) => f.data.runId));
+    expect(runIds.size).toBe(1);
+    // Original filenames preserved (one per file, no duplicates, no drops).
+    const names = mediaFrames
+      .map((f) => (f.data.ctx as { originalMediaUrl?: string })?.originalMediaUrl)
+      .map((p) => (p ? path.basename(p) : ""));
+    expect(new Set(names)).toEqual(new Set(["A.swift", "B.swift", "C.swift"]));
+    for (const f of mediaFrames) {
+      expect(String(f.data.mediaUrl)).toMatch(/^\/friday-next\/files\//);
+      expect(f.data.sessionKey).toBe(appSession);
+    }
+  });
+
   it("falls back to ctx.sessionKey when the device has no active run-route", async () => {
     const deviceId = "DEV-ACT-2";
     const res = connect(deviceId);
@@ -173,7 +224,9 @@ describe("channel-actions handleSend sessionKey routing", () => {
       sessionKey: "agent:operator:friday:direct:fallback-session",
     });
 
-    const text = parseOutboundFrames(res).find((f) => f.type === "outbound" && f.data.op === "text");
+    const text = parseOutboundFrames(res).find(
+      (f) => f.type === "outbound" && f.data.op === "text",
+    );
     expect(text?.data.sessionKey).toBe("agent:operator:friday:direct:fallback-session");
   });
 });

package/src/channel-actions.ts

@@ -36,6 +36,21 @@ function pickString(params: Record<string, unknown>, keys: string[]): string {
   return "";
 }
 
+function pickStringArray(params: Record<string, unknown>, key: string): string[] {
+  const v = params[key];
+  if (!Array.isArray(v)) return [];
+  const out: string[] = [];
+  const seen = new Set<string>();
+  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: string,
   ctx: MessageActionCtx,
@@ -49,7 +64,9 @@ async function readMediaFile(
       if (buffer?.length) {
         return { buffer, mimeType: guessMimeType(mediaPath) };
       }
-    } catch { /* fall through */ }
+    } catch {
+      /* fall through */
+    }
   }
   try {
     const buffer = fs.readFileSync(mediaPath);
@@ -101,26 +118,35 @@ async function handleSend(ctx: MessageActionCtx): Promise<unknown> {
     );
   }
 
-  // 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: { buffer: Buffer; mimeType: string } | null = null;
-  let originalMediaUrl = "";
-  if (inlineBase64) {
-    media = decodeBase64Media(
+  // 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: { buffer: Buffer; mimeType: string; originalMediaUrl: string }[] = [];
+  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) : ""),
     );
-    originalMediaUrl = filename || "inline-buffer";
+    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(
         {
@@ -134,7 +160,7 @@ async function handleSend(ctx: MessageActionCtx): Promise<unknown> {
             audioAsVoice: false,
             caption: caption || text,
             mediaUrl: publicUrl,
-            ctx: { to, text: caption || text, originalMediaUrl },
+            ctx: { to, text: caption || text, originalMediaUrl: source.originalMediaUrl },
           },
         },
         to,

package/src/channel.lifecycle.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import { fridayNextChannelPlugin } from "./channel.js";
+
+/**
+ * friday-next is a passive HTTP+SSE channel whose routes live on the shared gateway server.
+ * It still MUST keep its account lifecycle pending (running:true) so the core health-monitor
+ * does not poll it as "stopped" and restart it every few minutes. 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`. See gateway.startAccount keep-alive in channel.ts.
+ */
+describe("friday-next channel gateway lifecycle", () => {
+  it("exposes a startAccount keep-alive that stays pending until abort", async () => {
+    const gateway = (fridayNextChannelPlugin as { gateway?: { startAccount?: unknown } }).gateway;
+    expect(gateway?.startAccount).toBeTypeOf("function");
+
+    const startAccount = gateway!.startAccount as (ctx: {
+      accountId: string;
+      abortSignal: AbortSignal;
+    }) => Promise<unknown>;
+
+    const controller = new AbortController();
+    const started = startAccount({ accountId: "default", abortSignal: controller.signal });
+
+    // Must stay pending while the account is alive (so the core keeps running:true).
+    let settled = false;
+    void started.then(
+      () => {
+        settled = true;
+      },
+      () => {
+        settled = true;
+      },
+    );
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    expect(settled).toBe(false);
+
+    // Aborting (reload / shutdown) resolves it cleanly.
+    controller.abort();
+    await expect(started).resolves.toBeUndefined();
+  });
+});

package/src/channel.outbound.test.ts

@@ -6,7 +6,11 @@ import { fridayNextChannelPlugin } from "./channel.js";
 import { sseEmitter } from "./sse/emitter.js";
 import { setOfflineQueueBaseDirForTest } from "./sse/offline-queue.js";
 import { registerRunRoute } from "./run-metadata.js";
-import { createTempHistoryDir, removeTempHistoryDir, setMockRuntime } from "./test-support/mock-runtime.js";
+import {
+  createTempHistoryDir,
+  removeTempHistoryDir,
+  setMockRuntime,
+} from "./test-support/mock-runtime.js";
 
 /**
  * Outbound (message-tool send) must route to the session that started the run.
@@ -95,11 +99,19 @@ describe("friday-next channel outbound sessionKey routing", () => {
   it("run-route wins over ctx sessionKey (ctx carries the agent's base/main session, not the active app session)", async () => {
     const deviceId = "DEV-TEXT-2";
     const runId = "run-text-2";
-    registerRunRoute({ runId, deviceId, sessionKey: "agent:operator:friday-next:direct:route-session" });
+    registerRunRoute({
+      runId,
+      deviceId,
+      sessionKey: "agent:operator:friday-next:direct:route-session",
+    });
     sseEmitter.trackDeviceForRun(deviceId, runId);
     const res = connect(deviceId);
 
-    await outbound.sendText({ to: deviceId, text: "hi", requesterSessionKey: "agent:operator:main" });
+    await outbound.sendText({
+      to: deviceId,
+      text: "hi",
+      requesterSessionKey: "agent:operator:main",
+    });
 
     const evt = parseOutboundFrames(res).find((f) => f.type === "outbound" && f.data.op === "text");
     expect(evt?.data.sessionKey).toBe("agent:operator:friday-next:direct:route-session");
@@ -129,7 +141,9 @@ describe("friday-next channel outbound sessionKey routing", () => {
 
     await outbound.sendMedia({ to: deviceId, text: "caption", mediaUrl: mediaFile });
 
-    const evt = parseOutboundFrames(res).find((f) => f.type === "outbound" && f.data.op === "media");
+    const evt = parseOutboundFrames(res).find(
+      (f) => f.type === "outbound" && f.data.op === "media",
+    );
     expect(evt).toBeDefined();
     expect(evt?.data.sessionKey).toBe(sessionKey);
     expect(evt?.data.deviceId).toBe(deviceId);