@syengup/friday-channel-next 0.1.30 → 0.1.37

package/src/skills-discovery.test.ts

@@ -0,0 +1,152 @@
+import { describe, it, expect, afterEach } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import {
+  discoverAvailableSkills,
+  enabledExtensionNames,
+  resetOpenClawRootCacheForTest,
+} from "./skills-discovery.js";
+import {
+  setFridayAgentForwardRuntime,
+  resetFridayAgentForwardRuntimeForTest,
+} from "./agent-forward-runtime.js";
+
+/** Create `<parent>/<id>/SKILL.md` for each id. */
+function makeSkills(parent: string, ids: string[]): void {
+  for (const id of ids) {
+    fs.mkdirSync(path.join(parent, id), { recursive: true });
+    fs.writeFileSync(path.join(parent, id, "SKILL.md"), "# " + id);
+  }
+}
+
+describe("discoverAvailableSkills", () => {
+  let root: string;
+
+  function wire(configRoot: string, cfg: unknown): void {
+    setFridayAgentForwardRuntime({
+      runtime: {
+        agent: {
+          session: { resolveStorePath: () => "", loadSessionStore: () => ({}) },
+          // main → <configRoot>/workspace ; others → <configRoot>/workspace/agents/<id>
+          resolveAgentWorkspaceDir: (_c: unknown, id: string) =>
+            id === "main"
+              ? path.join(configRoot, "workspace")
+              : path.join(configRoot, "workspace", "agents", id),
+        },
+        config: { current: () => cfg },
+      },
+    } as never);
+  }
+
+  afterEach(() => {
+    resetFridayAgentForwardRuntimeForTest();
+    resetOpenClawRootCacheForTest();
+    if (root) fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it("scans only the target agent's own workspace (not the default agent's), plus managed + extra dirs, deduped and sorted", () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), "friday-disc-"));
+    const configRoot = path.join(root, "configdir");
+    const extraDir = path.join(root, "extra");
+
+    // Default agent "main" workspace — its skills must NOT leak into other agents' catalogs.
+    makeSkills(path.join(configRoot, "workspace", "skills"), ["alpha"]);
+    // operator's own workspace — opencli also lives in the managed dir below, to prove
+    // workspace > installed precedence in dedup.
+    makeSkills(path.join(configRoot, "workspace", "agents", "operator", "skills"), [
+      "beta",
+      "opencli",
+    ]);
+    // managed dir: <configDir>/skills (sibling of the default workspace)
+    makeSkills(path.join(configRoot, "skills"), ["managed-one", "opencli"]);
+    // config extraDirs
+    makeSkills(extraDir, ["gamma"]);
+
+    const cfg = {
+      agents: { list: [{ id: "main", default: true }, { id: "operator" }] },
+      skills: { load: { extraDirs: [extraDir] } },
+    };
+    wire(configRoot, cfg);
+
+    const result = discoverAvailableSkills(cfg, "operator");
+    // "alpha" is main-only → absent for operator (regression guard for the main-leak bug).
+    expect(result.map((s) => s.id)).toEqual(["beta", "gamma", "managed-one", "opencli"]);
+    const bySource = Object.fromEntries(result.map((s) => [s.id, s.source]));
+    expect(bySource).toEqual({
+      beta: "workspace",
+      opencli: "workspace", // workspace wins over the managed-dir duplicate
+      "managed-one": "installed",
+      gamma: "extra",
+    });
+  });
+
+  it("ignores directories without SKILL.md", () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), "friday-disc-"));
+    const configRoot = path.join(root, "configdir");
+    const skillsDir = path.join(configRoot, "workspace", "skills");
+    makeSkills(skillsDir, ["real"]);
+    fs.mkdirSync(path.join(skillsDir, "empty-dir"), { recursive: true }); // no SKILL.md
+
+    const cfg = { agents: { list: [{ id: "main", default: true }] } };
+    wire(configRoot, cfg);
+
+    expect(discoverAvailableSkills(cfg, "main").map((s) => s.id)).toEqual(["real"]);
+  });
+
+  it("uses the SKILL.md frontmatter name over the dir name, and finds nested skills", () => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), "friday-disc-"));
+    const configRoot = path.join(root, "configdir");
+    const skillsDir = path.join(configRoot, "workspace", "skills");
+
+    // dir name != declared name
+    fs.mkdirSync(path.join(skillsDir, "self-improving-agent"), { recursive: true });
+    fs.writeFileSync(
+      path.join(skillsDir, "self-improving-agent", "SKILL.md"),
+      '---\nname: self-improvement\ndescription: "x"\n---\n# body',
+    );
+    // nested skill (redskill-style): SKILL.md two levels under the skills dir
+    const nested = path.join(skillsDir, "luckincoffee-mycoffeeskill", "my-coffee-skill");
+    fs.mkdirSync(nested, { recursive: true });
+    fs.writeFileSync(path.join(nested, "SKILL.md"), "---\nname: my-coffee\n---\n# body");
+
+    const cfg = { agents: { list: [{ id: "main", default: true }] } };
+    wire(configRoot, cfg);
+
+    const result = discoverAvailableSkills(cfg, "main");
+    expect(result.map((s) => s.id)).toEqual(["my-coffee", "self-improvement"]);
+    expect(result.find((s) => s.id === "self-improvement")?.description).toBe("x");
+  });
+
+  it("returns [] without throwing when nothing is resolvable", () => {
+    resetFridayAgentForwardRuntimeForTest();
+    expect(discoverAvailableSkills({}, "main")).toEqual([]);
+  });
+});
+
+describe("enabledExtensionNames", () => {
+  it("unions plugins.allow with entries[name].enabled === true", () => {
+    const cfg = {
+      plugins: {
+        allow: ["browser", "canvas"],
+        entries: {
+          browser: { enabled: true },
+          telegram: { enabled: true },
+          tavily: { enabled: false },
+          "open-prose": {},
+        },
+      },
+    };
+    const names = enabledExtensionNames(cfg);
+    expect(names.has("browser")).toBe(true);
+    expect(names.has("canvas")).toBe(true);
+    expect(names.has("telegram")).toBe(true); // from entries.enabled
+    expect(names.has("tavily")).toBe(false); // enabled:false
+    expect(names.has("open-prose")).toBe(false); // no enabled flag
+  });
+
+  it("returns an empty set when plugins config is absent", () => {
+    expect(enabledExtensionNames({}).size).toBe(0);
+    expect(enabledExtensionNames(undefined).size).toBe(0);
+  });
+});

package/src/skills-discovery.ts

@@ -0,0 +1,264 @@
+/**
+ * Discover the full catalog of skills an agent can load — the selectable set the
+ * app's skill-management UI offers, matching what OpenClaw's ControlUI shows.
+ *
+ * OpenClaw resolves an agent's loadable skills from several directories. None of
+ * the core's skill-discovery functions are reachable through a stable plugin-sdk
+ * specifier (they live only in hash-named chunks), so instead of deep-importing
+ * brittle core code we scan the same DIRECTORIES core scans — a far more stable
+ * coupling (directory conventions change far less often than bundled chunk names),
+ * and every access is guarded so a missing/renamed source just yields fewer skills
+ * rather than an error. A skill is a sub-directory containing `SKILL.md` (the same
+ * marker core's `loadSkillsFromDir` uses).
+ *
+ * Each discovered skill is tagged with a `source` category for the UI:
+ *  - workspace : the TARGET agent's own workspace `skills/` only — mirroring ControlUI,
+ *                which scans the single workspace resolved for that agent and never folds
+ *                in another agent's workspace (main is just another agent, not a shared pool)
+ *  - installed : managed skills dir (`<configDir>/skills`, sibling of the workspace)
+ *  - built-in  : bundled core skills (`<openclaw>/skills`)
+ *  - extra     : skills from ENABLED extensions (`<openclaw>/dist/extensions/<ext>/skills`,
+ *                gated by `plugins.allow`/`entries.enabled` like ControlUI) + config
+ *                `skills.load.extraDirs` — mirrors ControlUI's "EXTRA" bucket
+ *                (core tags extension skills `source: "extension"`).
+ *
+ * Dedup is by skill id, first source wins (workspace > installed > extra > built-in).
+ *
+ * A skill's id is the `name:` field in its `SKILL.md` frontmatter (falling back to
+ * the containing dir name) — NOT the dir name itself, which often differs (e.g. the
+ * `self-improving-agent/` dir declares `name: self-improvement`). The `description:`
+ * frontmatter field is surfaced too. Discovery is RECURSIVE (mirroring core's
+ * `loadSkills`): some skills nest the `SKILL.md` a few levels deep (e.g. redskill
+ * installs at `<pkg>/<sub>/<skill>/SKILL.md`).
+ *
+ * NOT included (out of scope for a name catalog): ClawHub remote-only skills and
+ * per-skill eligibility/`disabled` flags. The enabled set is the agent's own
+ * `skills[]` config, already returned separately by the config view.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { getFridayAgentForwardRuntime } from "./agent-forward-runtime.js";
+import { DEFAULT_AGENT_ID, normalizeAgentId } from "./agent-id.js";
+
+/** Depth limit for the recursive walk under each source dir (skills nest a few levels). */
+const MAX_SKILL_WALK_DEPTH = 6;
+const IGNORED_WALK_DIRS = new Set(["node_modules", ".git"]);
+
+export type SkillSource = "workspace" | "built-in" | "installed" | "extra";
+
+export interface DiscoveredSkill {
+  id: string;
+  description?: string;
+  source: SkillSource;
+}
+
+/** Extract `name`/`description` from a SKILL.md YAML frontmatter block. */
+function parseSkillFrontmatter(content: string): { name?: string; description?: string } {
+  const lines = content.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---") return {};
+  let name: string | undefined;
+  let description: string | undefined;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trim() === "---") break;
+    const m = /^(name|description)\s*:\s*(.+?)\s*$/.exec(lines[i]);
+    if (!m) continue;
+    let v = m[2].trim();
+    if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) {
+      v = v.slice(1, -1);
+    }
+    v = v.trim();
+    if (!v) continue;
+    if (m[1] === "name" && name === undefined) name = v;
+    else if (m[1] === "description" && description === undefined) description = v;
+  }
+  return { name, description };
+}
+
+/**
+ * Collect skills reachable under `root`, tagging each with `source`. A directory
+ * containing `SKILL.md` IS a skill (id = frontmatter `name`, else dir name) and is
+ * not descended into further; other directories are recursed up to a bounded depth.
+ * First occurrence of an id wins (call higher-priority sources first). Best-effort.
+ */
+function collectSkills(
+  root: string,
+  source: SkillSource,
+  out: Map<string, DiscoveredSkill>,
+  depth = 0,
+): void {
+  if (depth > MAX_SKILL_WALK_DEPTH) return;
+  let entries: fs.Dirent[];
+  try {
+    entries = fs.readdirSync(root, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  if (entries.some((e) => e.isFile() && e.name === "SKILL.md")) {
+    let fm: { name?: string; description?: string } = {};
+    try {
+      fm = parseSkillFrontmatter(fs.readFileSync(path.join(root, "SKILL.md"), "utf-8"));
+    } catch {
+      // unreadable frontmatter → fall back to dir name, no description
+    }
+    const id = fm.name ?? path.basename(root);
+    if (!out.has(id)) out.set(id, { id, description: fm.description, source });
+    return; // a skill is a leaf — don't treat its internals as nested skills
+  }
+  for (const e of entries) {
+    if (e.isDirectory() && !e.name.startsWith(".") && !IGNORED_WALK_DIRS.has(e.name)) {
+      collectSkills(path.join(root, e.name), source, out, depth + 1);
+    }
+  }
+}
+
+let cachedOpenClawRoot: string | null | undefined;
+
+/** Locate the installed `openclaw` package root (cached). Shared with tool-catalog discovery. */
+export function resolveOpenClawRoot(): string | null {
+  if (cachedOpenClawRoot !== undefined) return cachedOpenClawRoot;
+  cachedOpenClawRoot = computeOpenClawRoot();
+  return cachedOpenClawRoot;
+}
+
+function computeOpenClawRoot(): string | null {
+  const starts: string[] = [];
+  // Primary: resolve a subpath this plugin already imports (works inside the gateway
+  // where `openclaw/*` is resolvable). Standalone (e.g. unit tests) this throws → skipped.
+  try {
+    starts.push(createRequire(import.meta.url).resolve("openclaw/plugin-sdk/plugin-entry"));
+  } catch {
+    // not resolvable outside the gateway runtime
+  }
+  // Fallback: the gateway process entry (`<openclaw>/dist/index.js`) — the plugin runs in it.
+  if (typeof process.argv[1] === "string") starts.push(process.argv[1]);
+
+  for (const start of starts) {
+    let dir = path.dirname(start);
+    for (let i = 0; i < 10 && dir !== path.dirname(dir); i++) {
+      try {
+        const pkgPath = path.join(dir, "package.json");
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8")) as { name?: string };
+        if (pkg?.name === "openclaw") return dir;
+      } catch {
+        // keep walking up
+      }
+      dir = path.dirname(dir);
+    }
+  }
+  return null;
+}
+
+/**
+ * The set of bundled extensions enabled for this install — `plugins.allow` plus any
+ * `plugins.entries[name].enabled === true`. ControlUI only surfaces skills from
+ * enabled extensions, so we gate on the same set (extension dir name == plugin id).
+ */
+export function enabledExtensionNames(cfg: unknown): Set<string> {
+  const plugins = (cfg as Record<string, unknown> | undefined)?.plugins as
+    | Record<string, unknown>
+    | undefined;
+  const names = new Set<string>();
+  const allow = plugins?.allow;
+  if (Array.isArray(allow)) for (const n of allow) if (typeof n === "string") names.add(n);
+  const entries = plugins?.entries as Record<string, unknown> | undefined;
+  if (entries && typeof entries === "object") {
+    for (const [name, val] of Object.entries(entries)) {
+      if (val && typeof val === "object" && (val as Record<string, unknown>).enabled === true)
+        names.add(name);
+    }
+  }
+  return names;
+}
+
+/**
+ * Bundled skill source dirs inside the openclaw install, tagged like ControlUI:
+ * core `<openclaw>/skills` → "built-in"; per-extension `dist/extensions/<ext>/skills`
+ * → "extra" (core tags these `source: "extension"`). Extension skills are included
+ * only when the extension is enabled, matching ControlUI's EXTRA bucket.
+ */
+function bundledSkillSources(
+  enabledExtensions: Set<string>,
+): Array<{ dir: string; source: SkillSource }> {
+  const root = resolveOpenClawRoot();
+  if (!root) return [];
+  const out: Array<{ dir: string; source: SkillSource }> = [
+    { dir: path.join(root, "skills"), source: "built-in" },
+  ];
+  try {
+    const extRoot = path.join(root, "dist", "extensions");
+    for (const ext of fs.readdirSync(extRoot, { withFileTypes: true })) {
+      if (ext.isDirectory() && enabledExtensions.has(ext.name)) {
+        out.push({ dir: path.join(extRoot, ext.name, "skills"), source: "extra" });
+      }
+    }
+  } catch {
+    // no extensions dir on this build
+  }
+  return out;
+}
+
+function resolveDefaultAgentId(cfg: Record<string, unknown> | undefined): string {
+  const list = (cfg?.agents as Record<string, unknown> | undefined)?.list as
+    | Array<Record<string, unknown>>
+    | undefined;
+  if (Array.isArray(list) && list.length > 0) {
+    const def = list.find((a) => a?.default === true) ?? list[0];
+    if (def?.id) return normalizeAgentId(def.id);
+  }
+  return DEFAULT_AGENT_ID;
+}
+
+/**
+ * Full set of skills `agentId` can load, sorted by id, each tagged with its source
+ * category. Aggregates the TARGET agent's own workspace, the managed dir, config extra
+ * dirs, and bundled core/extension skills. Every source is optional and failure-tolerant.
+ */
+export function discoverAvailableSkills(cfg: unknown, agentId: string): DiscoveredSkill[] {
+  const c = cfg as Record<string, unknown> | undefined;
+  const resolveWs = getFridayAgentForwardRuntime()?.resolveAgentWorkspaceDir;
+  const sources: Array<{ dir: string; source: SkillSource }> = [];
+
+  if (resolveWs) {
+    // Workspace skills come ONLY from the target agent's own workspace — matching ControlUI's
+    // `resolveSkillsAgentWorkspace`→`buildWorkspaceSkillStatus(workspaceDir)`, which scans the
+    // single resolved workspace. Folding in the default agent's workspace (the old behavior)
+    // leaked main's skills into every other agent's catalog.
+    try {
+      const ws = resolveWs(cfg, agentId);
+      if (ws) sources.push({ dir: path.join(ws, "skills"), source: "workspace" });
+    } catch {
+      // skip unresolvable workspace
+    }
+    // Managed skills dir: `<configDir>/skills`. It is agent-independent; anchor it off the
+    // DEFAULT agent's workspace parent (the default workspace lives directly under configDir,
+    // whereas non-default workspaces may be nested under it).
+    try {
+      const defaultWs = resolveWs(cfg, resolveDefaultAgentId(c));
+      if (defaultWs)
+        sources.push({ dir: path.join(path.dirname(defaultWs), "skills"), source: "installed" });
+    } catch {
+      // skip unresolvable managed dir
+    }
+  }
+
+  const extraDirs = (
+    (c?.skills as Record<string, unknown> | undefined)?.load as Record<string, unknown> | undefined
+  )?.extraDirs;
+  if (Array.isArray(extraDirs)) {
+    for (const d of extraDirs)
+      if (typeof d === "string" && d.trim()) sources.push({ dir: d.trim(), source: "extra" });
+  }
+
+  sources.push(...bundledSkillSources(enabledExtensionNames(c)));
+
+  const out = new Map<string, DiscoveredSkill>();
+  for (const { dir, source } of sources) collectSkills(dir, source, out, 0);
+  return [...out.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+
+/** Test-only: reset the cached openclaw root. */
+export function resetOpenClawRootCacheForTest(): void {
+  cachedOpenClawRoot = undefined;
+}

package/src/sse/emitter.test.ts

@@ -78,7 +78,7 @@ describe("sseEmitter", () => {
     const body = c.writes.join("");
     expect(body).toContain("id: 2");
     expect(body).toContain("id: 3");
-    expect(body).not.toContain("text\":\"a\"");
+    expect(body).not.toContain('text":"a"');
 
     sseEmitter.removeConnection("device-replay");
   });

package/src/sse/emitter.ts

@@ -4,7 +4,14 @@ import { fridaySseOfflineQueue } from "./offline-queue.js";
 
 const logger = createFridayNextLogger("sse", "info");
 
-export type SseEventType = "connected" | "agent" | "deliver" | "tool-hook" | "outbound" | "ping" | "subagent";
+export type SseEventType =
+  | "connected"
+  | "agent"
+  | "deliver"
+  | "tool-hook"
+  | "outbound"
+  | "ping"
+  | "subagent";
 
 export interface SseEvent {
   type: SseEventType;
@@ -36,8 +43,7 @@ export class SseConnection {
 
   send(entry: BacklogEntry | SseEvent, flushNow?: boolean): void {
     if (this.closed) return;
-    const normalized =
-      "id" in entry && "event" in entry ? entry : { id: Date.now(), event: entry as SseEvent };
+    const normalized = "id" in entry && "event" in entry ? entry : { id: Date.now(), event: entry };
     const payload = JSON.stringify(normalized.event.data);
     this.pending.push(
       `id: ${normalized.id}\nevent: ${normalized.event.type}\ndata: ${payload}\n\n`,

package/src/sse/offline-queue.ts

@@ -21,7 +21,9 @@ export function setOfflineQueueBaseDirForTest(dir: string | null): void {
 export function resolveFridayNextEventsQueueDir(): string {
   if (testQueueBaseDir) return testQueueBaseDir;
   try {
-    const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(getFridayNextRuntime().config));
+    const cfg = resolveFridayNextConfig(
+      getHostOpenClawConfigSnapshot(getFridayNextRuntime().config),
+    );
     return path.join(path.dirname(cfg.historyDir), "events-queue");
   } catch {
     return path.join(os.homedir(), ".openclaw", "friday-next", "events-queue");
@@ -71,7 +73,13 @@ export class FridaySseOfflineQueue {
     return this.scanMaxId(deviceId.trim().toUpperCase());
   }
 
-  append(deviceId: string, id: number, event: string, data: Record<string, unknown>, backlogLimit: number): void {
+  append(
+    deviceId: string,
+    id: number,
+    event: string,
+    data: Record<string, unknown>,
+    backlogLimit: number,
+  ): void {
     if (event === "connected") return;
     this.ensureDir();
     const file = this.devicePath(deviceId);
@@ -119,7 +127,12 @@ export class FridaySseOfflineQueue {
       if (!line.trim()) continue;
       try {
         const o = JSON.parse(line) as PersistedSseEntry;
-        if (typeof o.id === "number" && typeof o.event === "string" && o.data && typeof o.data === "object") {
+        if (
+          typeof o.id === "number" &&
+          typeof o.event === "string" &&
+          o.data &&
+          typeof o.data === "object"
+        ) {
           all.push(o);
         }
       } catch {
@@ -128,11 +141,7 @@ export class FridaySseOfflineQueue {
     }
     if (all.length <= keep) return;
     const slice = all.slice(-keep);
-    fs.writeFileSync(
-      file,
-      slice.map((e) => JSON.stringify(e) + "\n").join(""),
-      "utf8",
-    );
+    fs.writeFileSync(file, slice.map((e) => JSON.stringify(e) + "\n").join(""), "utf8");
   }
 }
 

package/src/test-support/app-simulator.ts

@@ -68,7 +68,9 @@ class MockRes extends Writable {
 }
 
 function createRouteHarness() {
-  let routeHandler: ((req: Readable & { method?: string; url?: string }, res: Writable) => Promise<boolean>) | null = null;
+  let routeHandler:
+    | ((req: Readable & { method?: string; url?: string }, res: Writable) => Promise<boolean>)
+    | null = null;
   const fakeApi = {
     logger: { info: () => {}, warn: () => {}, error: () => {}, debug: () => {} },
     registerHttpRoute(route: { handler: (req: never, res: never) => Promise<boolean> }) {
@@ -193,7 +195,14 @@ export function createAppSimulator(opts?: { deviceId?: string; token?: string })
       });
       return { status: res.statusCode, body: jsonBody(res) };
     },
-    async uploadFiles(parts: Array<{ name: string; filename: string; contentType: string; content: string | Buffer }>) {
+    async uploadFiles(
+      parts: Array<{
+        name: string;
+        filename: string;
+        contentType: string;
+        content: string | Buffer;
+      }>,
+    ) {
       const boundary = "----friday-next-e2e-boundary";
       const chunks: Buffer[] = [];
       for (const part of parts) {
@@ -235,7 +244,12 @@ export function createAppSimulator(opts?: { deviceId?: string; token?: string })
       const res = await request({ method: "OPTIONS", path, headers: { origin } });
       return { status: res.statusCode, headers: res.headers };
     },
-    async rawRequest(arg: { method: string; path: string; headers?: Headers; body?: string | Buffer }) {
+    async rawRequest(arg: {
+      method: string;
+      path: string;
+      headers?: Headers;
+      body?: string | Buffer;
+    }) {
       const res = await request(arg);
       return { status: res.statusCode, body: res.body.toString("utf-8"), headers: res.headers };
     },

package/src/test-support/mock-dispatch.ts

@@ -1,7 +1,12 @@
-import { __setMockFridayDispatchForTests, __resetMockFridayDispatchForTests } from "../agent/dispatch-bridge.js";
+import {
+  __setMockFridayDispatchForTests,
+  __resetMockFridayDispatchForTests,
+} from "../agent/dispatch-bridge.js";
 import { forwardAgentEventRaw } from "../friday-session.js";
 
-type DispatchArg = Parameters<typeof __setMockFridayDispatchForTests>[0] extends (arg: infer A) => unknown
+type DispatchArg = Parameters<typeof __setMockFridayDispatchForTests>[0] extends (
+  arg: infer A,
+) => unknown
   ? A
   : never;
 
@@ -133,12 +138,20 @@ export class MockDispatchScript {
 
   block(text: string, mediaUrls: string[] = [], audioAsVoice = false): this {
     this.steps.push(async (_args, callbacks) => {
-      await callbacks.deliver?.({ text, mediaUrls, audioAsVoice } as never, { kind: "block" } as never);
+      await callbacks.deliver?.(
+        { text, mediaUrls, audioAsVoice } as never,
+        { kind: "block" } as never,
+      );
     });
     return this;
   }
 
-  deliverFinal(payload: { text: string; mediaUrls?: string[]; audioAsVoice?: boolean; isError?: boolean }): this {
+  deliverFinal(payload: {
+    text: string;
+    mediaUrls?: string[];
+    audioAsVoice?: boolean;
+    isError?: boolean;
+  }): this {
     this.steps.push(async (_args, callbacks) => {
       await callbacks.deliver?.(payload as never, { kind: "final" } as never);
     });