@syengup/friday-channel-next 0.1.30 → 0.1.37

package/src/thinking-levels.test.ts

@@ -0,0 +1,143 @@
+import { describe, it, expect, afterEach } from "vitest";
+import {
+  resolveModelThinking,
+  resolveModelThinkingForRef,
+  isThinkingLevelSupportedForRef,
+} from "./thinking-levels.js";
+import {
+  setFridayAgentForwardRuntime,
+  resetFridayAgentForwardRuntimeForTest,
+} from "./agent-forward-runtime.js";
+
+/** Inject a forward runtime whose `resolveThinkingPolicy` echoes the recorded calls + a fixed reply. */
+function setThinkingPolicy(
+  impl: (params: { provider?: string | null; model?: string | null }) => {
+    levels: Array<{ id: string; label: string }>;
+    defaultLevel?: string | null;
+  },
+): { calls: Array<{ provider?: string | null; model?: string | null }> } {
+  const calls: Array<{ provider?: string | null; model?: string | null }> = [];
+  setFridayAgentForwardRuntime({
+    runtime: {
+      agent: {
+        session: { resolveStorePath: () => "", loadSessionStore: () => ({}) },
+        resolveThinkingPolicy: (params: { provider?: string | null; model?: string | null }) => {
+          calls.push(params);
+          return impl(params);
+        },
+      },
+      config: { current: () => ({}) },
+    },
+  } as never);
+  return { calls };
+}
+
+describe("resolveModelThinking", () => {
+  afterEach(() => {
+    resetFridayAgentForwardRuntimeForTest();
+  });
+
+  it("returns the runtime-resolved levels + default for a model that supports xhigh", () => {
+    setThinkingPolicy(() => ({
+      levels: [
+        { id: "off", label: "off" },
+        { id: "minimal", label: "minimal" },
+        { id: "low", label: "low" },
+        { id: "medium", label: "medium" },
+        { id: "high", label: "high" },
+        { id: "xhigh", label: "xhigh" },
+      ],
+      defaultLevel: "high",
+    }));
+    const result = resolveModelThinking("openai", "gpt-5.4");
+    expect(result.levels.map((l) => l.id)).toEqual([
+      "off",
+      "minimal",
+      "low",
+      "medium",
+      "high",
+      "xhigh",
+    ]);
+    expect(result.default).toBe("high");
+  });
+
+  it("passes binary on/off labels through unchanged", () => {
+    setThinkingPolicy(() => ({
+      levels: [
+        { id: "off", label: "off" },
+        { id: "low", label: "on" },
+      ],
+    }));
+    const result = resolveModelThinking("moonshot", "kimi-k2");
+    expect(result.levels).toEqual([
+      { id: "off", label: "off" },
+      { id: "low", label: "on" },
+    ]);
+    expect(result.default).toBeUndefined();
+  });
+
+  it("falls back to the base five levels when no runtime is registered", () => {
+    const result = resolveModelThinking("anything", "model-x");
+    expect(result.levels.map((l) => l.id)).toEqual(["off", "minimal", "low", "medium", "high"]);
+    expect(result.default).toBeUndefined();
+  });
+
+  it("falls back to the base levels when resolveThinkingPolicy throws", () => {
+    setThinkingPolicy(() => {
+      throw new Error("boom");
+    });
+    const result = resolveModelThinking("openai", "gpt-5.4");
+    expect(result.levels.map((l) => l.id)).toEqual(["off", "minimal", "low", "medium", "high"]);
+  });
+
+  it("falls back to the base levels when the policy returns no levels", () => {
+    setThinkingPolicy(() => ({ levels: [] }));
+    const result = resolveModelThinking("openai", "gpt-5.4");
+    expect(result.levels.map((l) => l.id)).toEqual(["off", "minimal", "low", "medium", "high"]);
+  });
+});
+
+describe("resolveModelThinkingForRef", () => {
+  afterEach(() => {
+    resetFridayAgentForwardRuntimeForTest();
+  });
+
+  it("splits a provider/model ref and forwards both parts to the policy", () => {
+    const { calls } = setThinkingPolicy(() => ({ levels: [{ id: "off", label: "off" }] }));
+    resolveModelThinkingForRef("deepseek/deepseek-v4-pro");
+    expect(calls).toEqual([{ provider: "deepseek", model: "deepseek-v4-pro" }]);
+  });
+
+  it("treats a bare model id as having no provider", () => {
+    const { calls } = setThinkingPolicy(() => ({ levels: [{ id: "off", label: "off" }] }));
+    resolveModelThinkingForRef("just-a-model");
+    expect(calls).toEqual([{ provider: null, model: "just-a-model" }]);
+  });
+
+  it("returns the base set for an empty ref without calling the runtime", () => {
+    const { calls } = setThinkingPolicy(() => ({ levels: [{ id: "off", label: "off" }] }));
+    const result = resolveModelThinkingForRef("");
+    expect(calls).toEqual([]);
+    expect(result.levels.map((l) => l.id)).toEqual(["off", "minimal", "low", "medium", "high"]);
+  });
+});
+
+describe("isThinkingLevelSupportedForRef", () => {
+  afterEach(() => {
+    resetFridayAgentForwardRuntimeForTest();
+  });
+
+  it("accepts a level the model supports and rejects one it does not", () => {
+    setThinkingPolicy(() => ({
+      levels: [
+        { id: "off", label: "off" },
+        { id: "low", label: "low" },
+        { id: "medium", label: "medium" },
+        { id: "high", label: "high" },
+        { id: "max", label: "max" },
+      ],
+    }));
+    expect(isThinkingLevelSupportedForRef("deepseek/deepseek-v4", "max")).toBe(true);
+    expect(isThinkingLevelSupportedForRef("deepseek/deepseek-v4", "xhigh")).toBe(false);
+  });
+});

package/src/thinking-levels.ts

@@ -0,0 +1,70 @@
+import { getFridayAgentForwardRuntime } from "./agent-forward-runtime.js";
+import { splitModelRef } from "./session/session-manager.js";
+
+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;
+}
+
+/**
+ * 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: ThinkingLevelOption[] = [
+  { 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: string | undefined | null,
+  modelId: string | undefined | null,
+): ResolvedModelThinking {
+  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: string | undefined | null,
+): ResolvedModelThinking {
+  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: string | undefined | null,
+  level: string,
+): boolean {
+  return resolveModelThinkingForRef(modelRef).levels.some((l) => l.id === level);
+}

package/src/tool-catalog.ts

@@ -0,0 +1,261 @@
+/**
+ * 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";
+
+interface CoreCatalogTool {
+  id: string;
+  label: string;
+  description: string;
+  source: string;
+  defaultProfiles: string[];
+}
+interface CoreCatalogGroup {
+  id: string;
+  label: string;
+  source: string;
+  pluginId?: string;
+  tools: CoreCatalogTool[];
+}
+interface CoreCatalogResult {
+  agentId: string;
+  profiles: Array<{ id: string; label: string }>;
+  groups: CoreCatalogGroup[];
+}
+type BuildFn = (params: {
+  cfg: unknown;
+  agentId?: string;
+  includePlugins?: boolean;
+}) => CoreCatalogResult;
+
+let cachedBuildFn: BuildFn | null | undefined;
+
+async function loadBuildFn(): Promise<BuildFn | null> {
+  if (cachedBuildFn !== undefined) return cachedBuildFn;
+  cachedBuildFn = await locateBuildFn();
+  return cachedBuildFn;
+}
+
+/**
+ * Core's catalog builder enumerates plugin tools via an internal
+ * `ensureStandaloneRuntimePluginRegistryLoaded({ surface: "channel" })`, which
+ * `pinActivePluginChannelRegistry()`s a tool-scoped registry that does NOT carry the
+ * friday-next channel registration. Because friday-next is an external channel (not in
+ * core's static CHANNEL_IDS), that re-pin drops it from the deliverable-channel set for
+ * the WHOLE gateway until the next full reload/restart — so every agent `message` send
+ * then fails with `Unknown channel: friday-next`. We snapshot the channel registry before
+ * the build and pin it back after, neutralizing the side effect. Resilient-import the
+ * runtime chunk like the catalog builder (gateway singleton; state lives on globalThis).
+ */
+interface ChannelRegistryFns {
+  get: () => unknown;
+  pin: (registry: unknown) => void;
+}
+let cachedChannelRegistryFns: ChannelRegistryFns | null | undefined;
+
+async function loadChannelRegistryFns(): Promise<ChannelRegistryFns | null> {
+  if (cachedChannelRegistryFns !== undefined) return cachedChannelRegistryFns;
+  cachedChannelRegistryFns = await locateChannelRegistryFns();
+  return cachedChannelRegistryFns;
+}
+
+async function locateChannelRegistryFns(): Promise<ChannelRegistryFns | null> {
+  const root = resolveOpenClawRoot();
+  if (!root) return null;
+  const distDir = path.join(root, "dist");
+  let files: string[];
+  try {
+    files = fs.readdirSync(distDir).filter((f) => f.endsWith(".js"));
+  } catch {
+    return null;
+  }
+  for (const file of files) {
+    let content: string;
+    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))) as Record<string, unknown>;
+      const pin = mod.pinActivePluginChannelRegistry;
+      const get = mod.getActivePluginChannelRegistry;
+      if (typeof pin === "function" && typeof get === "function") {
+        return {
+          get: get as () => unknown,
+          pin: pin as (registry: unknown) => void,
+        };
+      }
+    } catch {
+      // unreadable/non-importable candidate → keep scanning
+    }
+  }
+  return null;
+}
+
+async function locateBuildFn(): Promise<BuildFn | null> {
+  const root = resolveOpenClawRoot();
+  if (!root) return null;
+  const distDir = path.join(root, "dist");
+  let files: string[];
+  try {
+    files = fs.readdirSync(distDir).filter((f) => f.endsWith(".js"));
+  } catch {
+    return null;
+  }
+  for (const file of files) {
+    let content: string;
+    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))) as Record<string, unknown>;
+      if (typeof mod.buildToolsCatalogResult === "function")
+        return mod.buildToolsCatalogResult as BuildFn;
+    } catch {
+      // unreadable/non-importable candidate → keep scanning
+    }
+  }
+  return null;
+}
+
+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[];
+}
+
+function readStringArray(value: unknown): string[] {
+  return Array.isArray(value) ? value.filter((v): v is string => typeof v === "string") : [];
+}
+
+/** Read an agent's `tools` config block from the host config. */
+function findAgentTools(cfg: unknown, agentId: string): AgentToolsConfigShape | undefined {
+  const list = (
+    (cfg as Record<string, unknown> | undefined)?.agents as Record<string, unknown> | undefined
+  )?.list as Array<Record<string, unknown>> | undefined;
+  if (!Array.isArray(list)) return undefined;
+  const entry = list.find((a) => a && typeof a === "object" && normalizeAgentId(a.id) === agentId);
+  return entry?.tools as AgentToolsConfigShape | undefined;
+}
+
+/**
+ * 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: unknown,
+  agentId: string,
+): Promise<AgentToolsCatalog | null> {
+  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: CoreCatalogResult;
+  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: AgentCatalogGroup[] = 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: boolean;
+      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(): void {
+  cachedBuildFn = undefined;
+}

package/src/upgrade-runtime.ts

@@ -28,7 +28,7 @@ export type UpgradeRuntime = {
   /** Mutate the config file; `afterWrite: { mode: "restart" }` triggers a safe gateway restart. */
   mutateConfigFile: (params: {
     afterWrite: ConfigAfterWrite;
-    mutate: (draft: unknown) => unknown | void;
+    mutate: (draft: unknown) => unknown;
   }) => Promise<unknown>;
   /**
    * Filesystem path of THIS loaded plugin (`api.source`). Used to infer the install
@@ -42,7 +42,9 @@ let upgradeRuntime: UpgradeRuntime | null = null;
 
 export function setUpgradeRuntime(api: OpenClawPluginApi): void {
   const runtime = api.runtime as unknown as {
-    system?: { runCommandWithTimeout?: (argv: string[], opts: unknown) => Promise<SpawnResultLike> };
+    system?: {
+      runCommandWithTimeout?: (argv: string[], opts: unknown) => Promise<SpawnResultLike>;
+    };
     config: {
       current: () => unknown;
       mutateConfigFile?: (params: unknown) => Promise<unknown>;

package/src/version.ts

@@ -11,7 +11,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(): string {
   // dist layout: <root>/dist/src/version.js → ../../package.json = <root>/package.json
@@ -22,7 +22,11 @@ function resolvePluginVersion(): string {
       const path = fileURLToPath(new URL(rel, import.meta.url));
       const raw = readFileSync(path, "utf8");
       const pkg = JSON.parse(raw) as { name?: string; version?: string };
-      if (pkg.name === "@syengup/friday-channel-next" && typeof pkg.version === "string" && pkg.version) {
+      if (
+        pkg.name === "@syengup/friday-channel-next" &&
+        typeof pkg.version === "string" &&
+        pkg.version
+      ) {
         return pkg.version;
       }
     } catch {

package/tsconfig.json

@@ -14,4 +14,4 @@
   },
   "include": ["index.ts", "src/**/*.ts", "src/**/*.d.ts"],
   "exclude": ["src/e2e/**", "src/**/*.test.ts", "src/test-support/**", "scripts/**"]
-}
+}