@syengup/friday-channel-next 0.1.30 → 0.1.36

package/dist/src/skills-discovery.d.ts

@@ -0,0 +1,58 @@
+/**
+ * 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 agent's own + the shared default-agent workspace `skills/`
+ *  - 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.
+ */
+export type SkillSource = "workspace" | "built-in" | "installed" | "extra";
+export interface DiscoveredSkill {
+    id: string;
+    description?: string;
+    source: SkillSource;
+}
+/** Locate the installed `openclaw` package root (cached). Shared with tool-catalog discovery. */
+export declare function resolveOpenClawRoot(): string | 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 declare function enabledExtensionNames(cfg: unknown): Set<string>;
+/**
+ * Full set of skills `agentId` can load, sorted by id, each tagged with its source
+ * category. Aggregates the agent's workspace, the shared root workspace, the managed
+ * dir, config extra dirs, and bundled core/extension skills. Every source is optional
+ * and failure-tolerant.
+ */
+export declare function discoverAvailableSkills(cfg: unknown, agentId: string): DiscoveredSkill[];
+/** Test-only: reset the cached openclaw root. */
+export declare function resetOpenClawRootCacheForTest(): void;

package/dist/src/skills-discovery.js

@@ -0,0 +1,247 @@
+/**
+ * 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 agent's own + the shared default-agent workspace `skills/`
+ *  - 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"]);
+/** Extract `name`/`description` from a SKILL.md YAML frontmatter block. */
+function parseSkillFrontmatter(content) {
+    const lines = content.split(/\r?\n/);
+    if (lines[0]?.trim() !== "---")
+        return {};
+    let name;
+    let description;
+    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, source, out, depth = 0) {
+    if (depth > MAX_SKILL_WALK_DEPTH)
+        return;
+    let entries;
+    try {
+        entries = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    if (entries.some((e) => e.isFile() && e.name === "SKILL.md")) {
+        let fm = {};
+        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;
+/** Locate the installed `openclaw` package root (cached). Shared with tool-catalog discovery. */
+export function resolveOpenClawRoot() {
+    if (cachedOpenClawRoot !== undefined)
+        return cachedOpenClawRoot;
+    cachedOpenClawRoot = computeOpenClawRoot();
+    return cachedOpenClawRoot;
+}
+function computeOpenClawRoot() {
+    const starts = [];
+    // 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"));
+                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) {
+    const plugins = cfg?.plugins;
+    const names = new Set();
+    const allow = plugins?.allow;
+    if (Array.isArray(allow))
+        for (const n of allow)
+            if (typeof n === "string")
+                names.add(n);
+    const entries = plugins?.entries;
+    if (entries && typeof entries === "object") {
+        for (const [name, val] of Object.entries(entries)) {
+            if (val && typeof val === "object" && val.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) {
+    const root = resolveOpenClawRoot();
+    if (!root)
+        return [];
+    const out = [
+        { 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) {
+    const list = cfg?.agents?.list;
+    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 agent's workspace, the shared root workspace, the managed
+ * dir, config extra dirs, and bundled core/extension skills. Every source is optional
+ * and failure-tolerant.
+ */
+export function discoverAvailableSkills(cfg, agentId) {
+    const c = cfg;
+    const resolveWs = getFridayAgentForwardRuntime()?.resolveAgentWorkspaceDir;
+    const sources = [];
+    if (resolveWs) {
+        const defaultId = resolveDefaultAgentId(c);
+        const ids = agentId === defaultId ? [agentId] : [agentId, defaultId];
+        let defaultWs;
+        for (const id of ids) {
+            try {
+                const ws = resolveWs(cfg, id);
+                if (ws) {
+                    sources.push({ dir: path.join(ws, "skills"), source: "workspace" });
+                    if (id === defaultId)
+                        defaultWs = ws;
+                }
+            }
+            catch {
+                // skip unresolvable workspace
+            }
+        }
+        // Managed skills dir: `<configDir>/skills`, the workspace's parent sibling.
+        if (defaultWs)
+            sources.push({ dir: path.join(path.dirname(defaultWs), "skills"), source: "installed" });
+    }
+    const extraDirs = c?.skills?.load?.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();
+    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() {
+    cachedOpenClawRoot = undefined;
+}

package/dist/src/thinking-levels.d.ts

@@ -0,0 +1,21 @@
+export interface ThinkingLevelOption {
+    id: string;
+    label: string;
+}
+export interface ResolvedModelThinking {
+    /** Ordered (off → highest) levels the model supports. */
+    levels: ThinkingLevelOption[];
+    /** Provider/model default level, when the gateway reports one. */
+    default?: string;
+}
+/**
+ * Resolves the thinking-level option set for `provider`/`modelId` from the running gateway's
+ * provider plugins + model catalog. The set varies per model (e.g. GPT-5.4 adds `xhigh`, Gemini adds
+ * `adaptive`, DeepSeek V4 adds `xhigh`/`max`, binary providers collapse to `off`/`on`). Falls back to
+ * the base five levels when the runtime API is unavailable.
+ */
+export declare function resolveModelThinking(provider: string | undefined | null, modelId: string | undefined | null): ResolvedModelThinking;
+/** Resolves thinking levels for a full `provider/model` ref (or bare model id). */
+export declare function resolveModelThinkingForRef(modelRef: string | undefined | null): ResolvedModelThinking;
+/** Whether `level` is a supported thinking level for the given `provider/model` ref. */
+export declare function isThinkingLevelSupportedForRef(modelRef: string | undefined | null, level: string): boolean;

package/dist/src/thinking-levels.js

@@ -0,0 +1,48 @@
+import { getFridayAgentForwardRuntime } from "./agent-forward-runtime.js";
+import { splitModelRef } from "./session/session-manager.js";
+/**
+ * Base five levels used when the running gateway is too old to expose `resolveThinkingPolicy`, or
+ * when resolution fails. Mirrors core `BASE_THINKING_LEVELS` (label === id for the base set).
+ */
+const BASE_THINKING_LEVELS = [
+    { id: "off", label: "off" },
+    { id: "minimal", label: "minimal" },
+    { id: "low", label: "low" },
+    { id: "medium", label: "medium" },
+    { id: "high", label: "high" },
+];
+/**
+ * Resolves the thinking-level option set for `provider`/`modelId` from the running gateway's
+ * provider plugins + model catalog. The set varies per model (e.g. GPT-5.4 adds `xhigh`, Gemini adds
+ * `adaptive`, DeepSeek V4 adds `xhigh`/`max`, binary providers collapse to `off`/`on`). Falls back to
+ * the base five levels when the runtime API is unavailable.
+ */
+export function resolveModelThinking(provider, modelId) {
+    const resolve = getFridayAgentForwardRuntime()?.resolveThinkingPolicy;
+    if (resolve) {
+        try {
+            const policy = resolve({ provider: provider ?? null, model: modelId ?? null });
+            if (policy?.levels?.length) {
+                return {
+                    levels: policy.levels.map((l) => ({ id: l.id, label: l.label })),
+                    default: policy.defaultLevel ?? undefined,
+                };
+            }
+        }
+        catch {
+            // Fall through to the base levels below.
+        }
+    }
+    return { levels: BASE_THINKING_LEVELS };
+}
+/** Resolves thinking levels for a full `provider/model` ref (or bare model id). */
+export function resolveModelThinkingForRef(modelRef) {
+    if (!modelRef)
+        return { levels: BASE_THINKING_LEVELS };
+    const split = splitModelRef(modelRef);
+    return resolveModelThinking(split.provider, split.modelId);
+}
+/** Whether `level` is a supported thinking level for the given `provider/model` ref. */
+export function isThinkingLevelSupportedForRef(modelRef, level) {
+    return resolveModelThinkingForRef(modelRef).levels.some((l) => l.id === level);
+}

package/dist/src/tool-catalog.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Build an agent's tool-permission catalog for the app's toolbox editor — the same
+ * tools/categories/descriptions/profiles ControlUI shows.
+ *
+ * The catalog (core + plugin tools, grouped, with descriptions and per-tool
+ * `defaultProfiles`) is produced by core's `buildToolsCatalogResult({cfg, agentId})`.
+ * That builder lives only in a hash-named dist chunk (no stable plugin-sdk export) and
+ * the catalog is CODE, not scannable data — so unlike skill discovery we can't avoid
+ * importing it. We locate the chunk RESILIENTLY (scan `<openclaw>/dist/*.js` for the one
+ * defining `buildToolsCatalogResult`, then dynamic-import it — Node returns the gateway's
+ * already-loaded module instance, so no side effects), cache it, and degrade gracefully
+ * (null) if the layout changes. Per-tool `enabled`/`inProfile` are then resolved here from
+ * the agent's `tools` config so the app can render simple toggles.
+ */
+export interface AgentToolsConfigShape {
+    profile?: string;
+    allow?: string[];
+    alsoAllow?: string[];
+    deny?: string[];
+}
+export interface AgentCatalogTool {
+    id: string;
+    label: string;
+    description: string;
+    source: string;
+    /** Effective state under the agent's current tools config. */
+    enabled: boolean;
+    /** Whether the active profile grants this tool (drives the app's allow/deny delta). */
+    inProfile: boolean;
+}
+export interface AgentCatalogGroup {
+    id: string;
+    label: string;
+    source: string;
+    pluginId?: string;
+    tools: AgentCatalogTool[];
+}
+export interface AgentToolsCatalog {
+    /** The agent's configured profile (null when unset). */
+    profile: string | null;
+    profiles: Array<{
+        id: string;
+        label: string;
+    }>;
+    groups: AgentCatalogGroup[];
+}
+/**
+ * The agent's full tool catalog with per-tool effective state, or null if the core
+ * catalog builder can't be located.
+ */
+export declare function buildAgentToolsCatalog(cfg: unknown, agentId: string): Promise<AgentToolsCatalog | null>;
+/** Test-only: reset the cached catalog builder. */
+export declare function resetToolCatalogCacheForTest(): void;

package/dist/src/tool-catalog.js

@@ -0,0 +1,192 @@
+/**
+ * Build an agent's tool-permission catalog for the app's toolbox editor — the same
+ * tools/categories/descriptions/profiles ControlUI shows.
+ *
+ * The catalog (core + plugin tools, grouped, with descriptions and per-tool
+ * `defaultProfiles`) is produced by core's `buildToolsCatalogResult({cfg, agentId})`.
+ * That builder lives only in a hash-named dist chunk (no stable plugin-sdk export) and
+ * the catalog is CODE, not scannable data — so unlike skill discovery we can't avoid
+ * importing it. We locate the chunk RESILIENTLY (scan `<openclaw>/dist/*.js` for the one
+ * defining `buildToolsCatalogResult`, then dynamic-import it — Node returns the gateway's
+ * already-loaded module instance, so no side effects), cache it, and degrade gracefully
+ * (null) if the layout changes. Per-tool `enabled`/`inProfile` are then resolved here from
+ * the agent's `tools` config so the app can render simple toggles.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { resolveOpenClawRoot } from "./skills-discovery.js";
+import { normalizeAgentId } from "./agent-id.js";
+let cachedBuildFn;
+async function loadBuildFn() {
+    if (cachedBuildFn !== undefined)
+        return cachedBuildFn;
+    cachedBuildFn = await locateBuildFn();
+    return cachedBuildFn;
+}
+let cachedChannelRegistryFns;
+async function loadChannelRegistryFns() {
+    if (cachedChannelRegistryFns !== undefined)
+        return cachedChannelRegistryFns;
+    cachedChannelRegistryFns = await locateChannelRegistryFns();
+    return cachedChannelRegistryFns;
+}
+async function locateChannelRegistryFns() {
+    const root = resolveOpenClawRoot();
+    if (!root)
+        return null;
+    const distDir = path.join(root, "dist");
+    let files;
+    try {
+        files = fs.readdirSync(distDir).filter((f) => f.endsWith(".js"));
+    }
+    catch {
+        return null;
+    }
+    for (const file of files) {
+        let content;
+        try {
+            content = fs.readFileSync(path.join(distDir, file), "utf8");
+        }
+        catch {
+            continue;
+        }
+        // Only the chunk that re-exports both helpers by their real names is usable.
+        if (!content.includes("pinActivePluginChannelRegistry"))
+            continue;
+        try {
+            const mod = (await import(path.join(distDir, file)));
+            const pin = mod.pinActivePluginChannelRegistry;
+            const get = mod.getActivePluginChannelRegistry;
+            if (typeof pin === "function" && typeof get === "function") {
+                return {
+                    get: get,
+                    pin: pin,
+                };
+            }
+        }
+        catch {
+            // unreadable/non-importable candidate → keep scanning
+        }
+    }
+    return null;
+}
+async function locateBuildFn() {
+    const root = resolveOpenClawRoot();
+    if (!root)
+        return null;
+    const distDir = path.join(root, "dist");
+    let files;
+    try {
+        files = fs.readdirSync(distDir).filter((f) => f.endsWith(".js"));
+    }
+    catch {
+        return null;
+    }
+    for (const file of files) {
+        let content;
+        try {
+            content = fs.readFileSync(path.join(distDir, file), "utf8");
+        }
+        catch {
+            continue;
+        }
+        if (!content.includes("function buildToolsCatalogResult"))
+            continue;
+        try {
+            const mod = (await import(path.join(distDir, file)));
+            if (typeof mod.buildToolsCatalogResult === "function")
+                return mod.buildToolsCatalogResult;
+        }
+        catch {
+            // unreadable/non-importable candidate → keep scanning
+        }
+    }
+    return null;
+}
+function readStringArray(value) {
+    return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+}
+/** Read an agent's `tools` config block from the host config. */
+function findAgentTools(cfg, agentId) {
+    const list = cfg?.agents
+        ?.list;
+    if (!Array.isArray(list))
+        return undefined;
+    const entry = list.find((a) => a && typeof a === "object" && normalizeAgentId(a.id) === agentId);
+    return entry?.tools;
+}
+/**
+ * The agent's full tool catalog with per-tool effective state, or null if the core
+ * catalog builder can't be located.
+ */
+export async function buildAgentToolsCatalog(cfg, agentId) {
+    const build = await loadBuildFn();
+    if (!build)
+        return null;
+    // Snapshot the channel registry so we can undo the build's `surface:"channel"` re-pin
+    // (which would otherwise drop friday-next from the gateway's deliverable channels).
+    const channelFns = await loadChannelRegistryFns();
+    const channelRegistryBefore = (() => {
+        try {
+            return channelFns?.get() ?? null;
+        }
+        catch {
+            return null;
+        }
+    })();
+    let core;
+    try {
+        core = build({ cfg, agentId, includePlugins: true });
+    }
+    catch {
+        return null;
+    }
+    finally {
+        // Pin the original channel registry back. Idempotent when the build didn't clobber it
+        // (core returns early when the surface already points at this registry).
+        if (channelFns && channelRegistryBefore) {
+            try {
+                channelFns.pin(channelRegistryBefore);
+            }
+            catch {
+                // best effort — never fail the catalog request over the restore
+            }
+        }
+    }
+    const tools = findAgentTools(cfg, agentId);
+    const profile = (typeof tools?.profile === "string" && tools.profile.trim()) ? tools.profile.trim() : null;
+    const allow = new Set(readStringArray(tools?.allow));
+    const alsoAllow = new Set(readStringArray(tools?.alsoAllow));
+    const deny = new Set(readStringArray(tools?.deny));
+    // No profile + no explicit allow == core's "allow all (except deny)".
+    const allowAll = profile === "full" || allow.has("*") || (!profile && allow.size === 0);
+    const groups = core.groups.map((g) => ({
+        id: g.id,
+        label: g.label,
+        source: g.source,
+        pluginId: g.pluginId,
+        tools: g.tools.map((t) => {
+            const inProfile = allowAll ? true : profile ? t.defaultProfiles.includes(profile) : false;
+            let enabled;
+            if (deny.has(t.id))
+                enabled = false;
+            else if (allowAll)
+                enabled = true;
+            else
+                enabled = inProfile || allow.has(t.id) || alsoAllow.has(t.id);
+            return {
+                id: t.id,
+                label: t.label,
+                description: t.description,
+                source: t.source,
+                enabled,
+                inProfile,
+            };
+        }),
+    }));
+    return { profile, profiles: core.profiles, groups };
+}
+/** Test-only: reset the cached catalog builder. */
+export function resetToolCatalogCacheForTest() {
+    cachedBuildFn = undefined;
+}

package/dist/src/version.js

@@ -10,7 +10,7 @@
 import { readFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 /** Keep in sync with package.json "version" as a last-resort fallback. */
-const FALLBACK_VERSION = "0.1.30";
+const FALLBACK_VERSION = "0.1.36";
 function resolvePluginVersion() {
     // dist layout: <root>/dist/src/version.js → ../../package.json = <root>/package.json
     // source layout (vitest/jiti): <root>/src/version.ts → ../package.json = <root>/package.json

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syengup/friday-channel-next",
-  "version": "0.1.30",
+  "version": "0.1.36",
   "description": "OpenClaw Friday Next Apple channel plugin",
   "license": "MIT",
   "type": "module",

package/src/agent/abort-run.ts

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