@syengup/friday-channel-next 0.1.30 → 0.1.36

package/src/openclaw.d.ts

@@ -1,5 +1,16 @@
 declare module "openclaw/plugin-sdk/agent-harness" {
-  export const abortAgentHarnessRun: (runId: string) => void;
+  /** Abort the active embedded run keyed by its internal `sessionId` (NOT the channel runId). */
+  export const abortAgentHarnessRun: (sessionId: string) => boolean;
+  /** Abort the active embedded run and wait for it to actually settle. */
+  export const abortAndDrainAgentHarnessRun: (params: {
+    sessionId: string;
+    sessionKey?: string;
+    settleMs?: number;
+    forceClear?: boolean;
+    reason?: string;
+  }) => Promise<{ aborted: boolean; drained: boolean; forceCleared: boolean }>;
+  /** Map a channel sessionKey → the active embedded run's internal sessionId. */
+  export const resolveActiveEmbeddedRunSessionId: (sessionKey: string) => string | undefined;
   export const runAgentHarness: (...args: any[]) => any;
 }
 
@@ -43,6 +54,19 @@ declare module "openclaw/plugin-sdk/media-store" {
   export const saveMediaBuffer: (...args: any[]) => any;
 }
 
+declare module "openclaw/plugin-sdk/channel-lifecycle" {
+  export const waitUntilAbort: (
+    signal?: AbortSignal,
+    onAbort?: () => void | Promise<void>,
+  ) => Promise<void>;
+}
+
+declare module "openclaw/plugin-sdk/media-runtime" {
+  export type MediaKind = "image" | "audio" | "video" | "document";
+  export const mediaKindFromMime: (mime?: string | null) => MediaKind | undefined;
+  export const maxBytesForKind: (kind: MediaKind) => number;
+}
+
 declare module "openclaw/plugin-sdk/plugin-entry" {
   export type OpenClawPluginApi = any;
 }

package/src/skills-discovery.test.ts

@@ -0,0 +1,148 @@
+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("aggregates agent + shared root + 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");
+
+    // Shared root pool (default agent "main" workspace)
+    makeSkills(path.join(configRoot, "workspace", "skills"), ["alpha", "opencli"]);
+    // operator's own workspace — includes a duplicate (opencli) to prove dedup
+    makeSkills(path.join(configRoot, "workspace", "agents", "operator", "skills"), ["beta", "opencli"]);
+    // managed dir: <configDir>/skills (sibling of workspace)
+    makeSkills(path.join(configRoot, "skills"), ["managed-one"]);
+    // 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");
+    expect(result.map((s) => s.id)).toEqual(["alpha", "beta", "gamma", "managed-one", "opencli"]);
+    const bySource = Object.fromEntries(result.map((s) => [s.id, s.source]));
+    expect(bySource).toEqual({
+      alpha: "workspace",
+      beta: "workspace",
+      opencli: "workspace",
+      "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,248 @@
+/**
+ * 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"]);
+
+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 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: 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) {
+    const defaultId = resolveDefaultAgentId(c);
+    const ids = agentId === defaultId ? [agentId] : [agentId, defaultId];
+    let defaultWs: string | undefined;
+    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 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/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,68 @@
+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);
+}