@krtclcdy/tersio 2.25.3 → 2.25.5

package/extensions/shared/brand-marks.ts

@@ -0,0 +1,163 @@
+// Brand mark catalog: names, not bytes. One list serves both consumers — the dashboard draws from
+// it at runtime, and the CLI export inlines the same URLs so a single-file dashboard keeps its
+// logos with the network off. Simple Icons files are CC0-1.0; the marks stay their owners'
+// property and the dashboard uses them nominatively, to name the service that served a request.
+// A vendor with no Simple Icons entry keeps its owner-hosted mark, one with no hosted mark is
+// drawn inline (`dashboard/app/src/lib/marks/inline.ts`), and bumping `SIMPLE_ICONS` once moves
+// every Simple Icons entry with it.
+const SIMPLE_ICONS = "https://cdn.jsdelivr.net/npm/simple-icons@16/icons";
+
+/** Slug to mark URL. Only slugs named here resolve to a mark; the rest get a monogram. */
+export const REMOTE_MARKS: Readonly<Record<string, string>> = {
+  // Simple Icons, CC0-1.0.
+  anthropic: `${SIMPLE_ICONS}/anthropic.svg`,
+  google: `${SIMPLE_ICONS}/google.svg`,
+  meta: `${SIMPLE_ICONS}/meta.svg`,
+  deepseek: `${SIMPLE_ICONS}/deepseek.svg`,
+  qwen: `${SIMPLE_ICONS}/qwen.svg`,
+  x: `${SIMPLE_ICONS}/x.svg`,
+  mistralai: `${SIMPLE_ICONS}/mistralai.svg`,
+  minimax: `${SIMPLE_ICONS}/minimax.svg`,
+  zdotai: `${SIMPLE_ICONS}/zdotai.svg`,
+  xiaomi: `${SIMPLE_ICONS}/xiaomi.svg`,
+  kimi: `${SIMPLE_ICONS}/kimi.svg`,
+  moonshotai: `${SIMPLE_ICONS}/moonshotai.svg`,
+  nvidia: `${SIMPLE_ICONS}/nvidia.svg`,
+  amd: `${SIMPLE_ICONS}/amd.svg`,
+  ollama: `${SIMPLE_ICONS}/ollama.svg`,
+  cline: `${SIMPLE_ICONS}/cline.svg`,
+  githubcopilot: `${SIMPLE_ICONS}/githubcopilot.svg`,
+  openrouter: `${SIMPLE_ICONS}/openrouter.svg`,
+  github: `${SIMPLE_ICONS}/github.svg`,
+  instagram: `${SIMPLE_ICONS}/instagram.svg`,
+  reddit: `${SIMPLE_ICONS}/reddit.svg`,
+  // Owner-hosted, nominative use.
+  groq: "https://groq.com/favicon.svg",
+  poolside: "https://poolside.ai/favicon/favicon.svg",
+  cerebras:
+    "https://cdn.sanity.io/images/e4qjo92p/production/e7a55ae5ab7e2c4fdfd4e66a51f628d1f2f44207-967x967.png?w=256&h=256&fit=max",
+  inclusionai: "https://cdn-avatars.huggingface.co/v1/production/uploads/662e1f9da266499277937d33/fyKuazRifqiaIO34xrhhm.jpeg",
+  // Owner avatars: the vendor or gateway posts no standalone icon, so its account picture stands in.
+  stepfun: "https://cdn-avatars.huggingface.co/v1/production/uploads/644f7e6233ac8f46fa0b9e26/CmF2ocXhkr2UtHXgmwq7-.png",
+  // typesafe.ai serves one full-bleed tile: a dark square with pink art inside it.
+  typesafe: "https://framerusercontent.com/images/aNFzSFxM4fjICmnibw7npfZjcQ.png",
+  // A gateway's own brand, which names the service that served the request. Never another vendor's logo.
+  opencode: "https://opencode.ai/favicon.svg",
+  commandcode: "https://commandcode.ai/favicon.ico",
+  kilo: "https://kilo.ai/favicon.ico",
+  magpie: "https://usemagpie.ai/favicon.png",
+  gmicloud: "https://gmicloud.ai/favicon.ico",
+  charmhyper: "https://github.com/charmbracelet.png?size=80",
+};
+
+/**
+ * Tile fill, not text. A mark whose tile carries its brand color reads as the brand, and a mark
+ * whose logo already fills its own box never shows the fill. Values come from the brand (the
+ * service's own page or its own asset), never from a guess; a slug absent here keeps the plain
+ * panel and the theme ink.
+ */
+export const MARK_BG: Readonly<Record<string, string>> = {
+  // Simple Icons marks: the vendor's brand color, taken from its own brand page.
+  anthropic: "#d97757",
+  meta: "#0082fb",
+  google: "#4285f4",
+  deepseek: "#4d6bfe",
+  qwen: "#6950ef",
+  mistralai: "#ff7000",
+  minimax: "#e11d48",
+  // Kimi's own favicon carries this blue, not the Moonshot violet.
+  kimi: "#1782fe",
+  xiaomi: "#ff6900",
+  nvidia: "#76b900",
+  amd: "#ed1c24",
+  x: "#000000",
+  ollama: "#000000",
+  zdotai: "#2d2d2d",
+  github: "#181717",
+  githubcopilot: "#181717",
+  cline: "#9f58fa",
+  openrouter: "#03080a",
+  instagram: "#e4405f",
+  reddit: "#ff4500",
+  linkedin: "#0a66c2",
+  // Owner-hosted marks: the tile matches the asset's own square, and a slug whose artwork already
+  // carries its own color takes a white tile so the art reads.
+  groq: "#f43e01",
+  poolside: "#4137ff",
+  cerebras: "#ffffff",
+  typesafe: "#171717",
+  charmhyper: "#ffffff",
+  stepfun: "#ffffff",
+  kilo: "#f7f576",
+  opencode: "#131010",
+  // The mark's own artwork is white, so the tile is white and the glyph is black.
+  openai: "#ffffff",
+  commandcode: "#ffffff",
+  gmicloud: "#ffffff",
+  magpie: "#0b0b0c",
+};
+
+/**
+ * Glyph scale per slug, applied to the glyph box the tile clips. Simple Icons art fills its 24 box
+ * by very different amounts, so the measured ink box decides the scale: a logo that runs to its
+ * box edge shrinks and one with an invisible margin grows. One is the default.
+ */
+export const MARK_SCALE: Readonly<Record<string, number>> = {
+  kimi: 0.72,
+  zdotai: 0.72,
+  openrouter: 0.9,
+  magpie: 1.15,
+};
+
+/** WCAG relative luminance of a `#rrggbb` string. */
+export function luminance(hex: string): number {
+  const n = parseInt(hex.slice(1), 16);
+  const ch = [(n >> 16) & 255, (n >> 8) & 255, n & 255].map((v) => {
+    const s = v / 255;
+    return s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+  });
+  return 0.2126 * ch[0] + 0.7152 * ch[1] + 0.0722 * ch[2];
+}
+
+/**
+ * The glyph color that stays legible on a tile fill. The cut sits at 0.35, which keeps white ink
+ * on a brand color: Meta blue, DeepSeek blue, Xiaomi orange, Mistral orange, and Kimi blue all
+ * carry a white logo, which is how their own brand sheets print them. Only a light neutral takes
+ * black: Kilo yellow, StepFun teal, and Lightbend orange.
+ */
+export function contrastInk(hex: string): string {
+  return luminance(hex) > 0.35 ? "#000000" : "#ffffff";
+}
+
+/**
+ * Marks that carry their own color or their own background. Everything else is opaque black, so
+ * it draws as an alpha mask filled with the chosen ink instead of an image. A slug whose asset is
+ * a filled tile must draw as an image, or the mask paints one flat block and the logo vanishes.
+ */
+export const COLORED_MARKS: ReadonlySet<string> = new Set([
+  "cerebras",
+  "inclusionai",
+  "typesafe",
+  "opencode",
+  "commandcode",
+  "kilo",
+  "magpie",
+  "charmhyper",
+  "stepfun",
+  // The ICO and the two inline PNGs are dark tiles with light art drawn inside them. The Groq
+  // favicon is one flat orange, so it draws as a mask instead: a masked glyph on a Groq-orange
+  // tile is a logo, and the same art as an image on the same orange tile is a blank tile.
+  "gmicloud",
+  "stealth",
+  "cognition",
+]);
+
+/** The URL a mark comes from, or null when the name has no hosted mark. */
+export function markUrl(slug: string): string | null {
+  return REMOTE_MARKS[slug] ?? null;
+}
+
+/** True when the mark carries its own color and must draw as an image. */
+export function isColoredMark(slug: string): boolean {
+  return COLORED_MARKS.has(slug);
+}

package/extensions/shared/host.ts

@@ -36,7 +36,7 @@ interface HostAdapter {
   label(pi: HostHandle, text: string): void;
   on<E>(pi: ExtensionApi, event: string, handler: (event: E, ctx: ExtensionCtx) => unknown): void;
   select(ui: UiApi | undefined, title: string, options: SelectOption[], dialogOptions?: Record<string, unknown>): Promise<string | undefined>;
-  inject(event: SystemPromptEvent, text: string, staleMarker?: string): PromptInjection | undefined;
+  inject(event: SystemPromptEvent, block: PromptBlock): PromptInjection | undefined;
   stringArray(pi: ExtensionApi, name: string, spec: StringArraySpec): ToolParams;
 }
 
@@ -53,15 +53,21 @@ const piAdapter: HostAdapter = {
     if (picked === undefined) return undefined;
     return options[shown.indexOf(picked)]?.label ?? picked;
   },
-  inject(event, text, staleMarker) {
-    const marker = staleMarker?.replace(/^[^\w]+/, '').trim();
+  inject(event, block) {
+    const marker = block.staleMarker?.replace(/^[^\w]+/, '').trim();
     const dropStale = (parts: string[]): string[] => (marker ? parts.filter((part) => !part.includes(marker)) : parts);
     const options = event.systemPromptOptions;
+    // A named section is replaced in place; returning systemPrompt replaces the whole prompt.
+    const sections = options?.sections;
+    if (block.sectionTag && sections && typeof sections === 'object') {
+      sections[block.sectionTag] = block.text;
+      return undefined;
+    }
     if (options && typeof options.appendSystemPrompt === 'string') {
-      options.appendSystemPrompt = dropStale([options.appendSystemPrompt]).concat(text).filter(Boolean).join('\n\n');
+      options.appendSystemPrompt = dropStale([options.appendSystemPrompt]).concat(block.text).filter(Boolean).join('\n\n');
       return undefined;
     }
-    return { systemPrompt: `${dropStale(asPromptArray(event.systemPrompt)).join('\n\n')}\n\n${text}` };
+    return { systemPrompt: `${dropStale(asPromptArray(event.systemPrompt)).join('\n\n')}\n\n${block.text}` };
   },
   stringArray(_pi, name, spec) {
     const array: Record<string, unknown> = { type: 'array', items: { type: 'string' } };
@@ -78,10 +84,10 @@ const ompAdapter: HostAdapter = {
     if (!ui?.select) return undefined;
     return ui.select(title, options, dialogOptions);
   },
-  inject(event, text, staleMarker) {
-    const marker = staleMarker?.replace(/^[^\w]+/, '').trim();
+  inject(event, block) {
+    const marker = block.staleMarker?.replace(/^[^\w]+/, '').trim();
     const dropStale = (parts: string[]): string[] => (marker ? parts.filter((part) => !part.includes(marker)) : parts);
-    return { systemPrompt: [...dropStale(asPromptArray(event.systemPrompt)), text] };
+    return { systemPrompt: [...dropStale(asPromptArray(event.systemPrompt)), block.text] };
   },
   stringArray(pi, name, spec) {
     const { z } = pi.zod as { z: ZodFactory['z'] };
@@ -98,10 +104,10 @@ const opencodeAdapter: HostAdapter = {
     if (!ui?.select) return undefined;
     return ui.select(title, options, dialogOptions);
   },
-  inject(event, text, staleMarker) {
-    const marker = staleMarker?.replace(/^[^\w]+/, '').trim();
+  inject(event, block) {
+    const marker = block.staleMarker?.replace(/^[^\w]+/, '').trim();
     const dropStale = (parts: string[]): string[] => (marker ? parts.filter((part) => !part.includes(marker)) : parts);
-    return { systemPrompt: [...dropStale(asPromptArray(event.systemPrompt)), text] };
+    return { systemPrompt: [...dropStale(asPromptArray(event.systemPrompt)), block.text] };
   },
   stringArray(_pi, name, spec) {
     const array: Record<string, unknown> = { type: 'array', items: { type: 'string' } };
@@ -141,8 +147,15 @@ export async function hostSelect(
   return adapterFor(pi).select(ui, title, options, dialogOptions);
 }
 
-export function injectPromptText(pi: HostHandle, event: SystemPromptEvent, text: string, staleMarker?: string): PromptInjection | undefined {
-  return adapterFor(pi).inject(event, text, staleMarker);
+/** One prompt block: its text, the section tag that owns it, and prior text to drop. */
+export interface PromptBlock {
+  text: string;
+  sectionTag?: string;
+  staleMarker?: string;
+}
+
+export function injectPromptText(pi: HostHandle, event: SystemPromptEvent, block: PromptBlock): PromptInjection | undefined {
+  return adapterFor(pi).inject(event, block);
 }
 
 export function stringArrayToolParams(pi: ExtensionApi, name: string, spec: StringArraySpec = {}): ToolParams {

package/extensions/shared/plugin-settings.ts

@@ -2,7 +2,7 @@
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import path from 'node:path';
-import { homeDir, tersioHome } from '../lib/utils.ts';
+import { homeDir, tersioHome } from './utils.ts';
 
 export const PLUGIN_NAME = '@krtclcdy/tersio';
 

package/extensions/shared/pricing.ts

@@ -1,7 +1,7 @@
 // extensions/shared/pricing.ts — dynamic model pricing from LiteLLM. Exact id → provider-prefix strip → default, reported with known:false when unpriced.
 import fs from 'node:fs';
 import path from 'node:path';
-import { tersioDataPath } from '../lib/utils.ts';
+import { tersioDataPath } from './utils.ts';
 
 export interface ModelPrice {
   input: number;
@@ -13,6 +13,27 @@ export interface ModelPrice {
 // Sonnet-class default for unpriced models; always paired with known:false.
 export const DEFAULT_PRICE: ModelPrice = { input: 2, output: 10, cacheRead: 0.2, cacheWrite: 2.5 };
 
+/**
+ * How a price was found, strongest first. `tail` and `default` are estimates.
+ *
+ * - `measured`: the host reported it. The only tier that can be zero without being a guess.
+ * - `override`: the operator's `prices.local.json`, exact for the gateway it names.
+ * - `exact`: the feed holds the id verbatim, or case-folded. `alias`: via `MODEL_ALIASES`.
+ * - `tail`: the feed holds the bare name under some provider, which need not be the one billed.
+ * - `default`: no match. `DEFAULT_PRICE`, an estimate by definition.
+ */
+export type PriceTier = 'measured' | 'override' | 'exact' | 'alias' | 'tail' | 'default';
+
+/** Tiers firm enough to call a price. `tail` and `default` are estimates, so they are not. */
+export const PRICE_TIERS_FIRM: readonly PriceTier[] = ['measured', 'override', 'exact', 'alias'];
+
+export interface PriceHit {
+  price: ModelPrice;
+  known: boolean;
+  live: boolean;
+  tier: PriceTier;
+}
+
 const LITELLM_URL = 'https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json';
 // Readers use the file even when stale, and only one refresh runs per process; `tersio update` still forces a fresh fetch.
 const CACHE_TTL_MS = 7 * 24 * 3600 * 1000;
@@ -24,6 +45,49 @@ export function pricesCachePath(): string {
   return tersioDataPath('prices.json', 'tersio-prices.json');
 }
 
+/**
+ * The operator's own prices, merged over the feed and keyed exactly as the transcript spells a
+ * model. A `*` prefix matches any gateway suffix. This is where a model the feed keys under a
+ * different provider gets a real price.
+ */
+export function pricesOverridePath(): string {
+  const override = process.env.TERSIO_PRICES_OVERRIDE_FILE;
+  if (override) return override;
+  return tersioDataPath('prices.local.json', 'tersio-prices.local.json');
+}
+
+/** The override file's mtime, or 0 when absent. Callers key their memo on it. */
+function overrideStamp(): number {
+  try {
+    return fs.statSync(pricesOverridePath()).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+let overrideCache: { stamp: number; exact: Map<string, ModelPrice>; tails: Array<[string, ModelPrice]> } | null = null;
+
+/** Reads the override file, keeping a `*`-prefixed entry as a suffix matcher. */
+function loadOverrides(stamp = overrideStamp()): { exact: Map<string, ModelPrice>; tails: Array<[string, ModelPrice]> } | null {
+  if (stamp === 0) return null;
+  const file = pricesOverridePath();
+  if (overrideCache && overrideCache.stamp === stamp) return overrideCache;
+  const exact = new Map<string, ModelPrice>();
+  const tails: Array<[string, ModelPrice]> = [];
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8')) as Record<string, unknown>;
+    for (const [id, row] of Object.entries(parsed ?? {})) {
+      const price = asPrice(row);
+      if (!price) continue;
+      // A `*` prefix matches any gateway prefix, so one entry covers every spelling of a model.
+      if (id.startsWith('*')) tails.push([id.slice(1).toLowerCase(), price]);
+      else exact.set(id, price);
+    }
+  } catch { /* an unreadable override is empty, not fatal */ }
+  overrideCache = { stamp, exact, tails };
+  return overrideCache;
+}
+
 export function pricesUrl(): string {
   return process.env.TERSIO_PRICES_URL || LITELLM_URL;
 }
@@ -109,30 +173,29 @@ export function canonicalPriceId(model: string): string {
   return MODEL_ALIASES.find((a) => a.id === key || a.feed === key || key.endsWith(`/${a.id}`) || key.endsWith(`/${a.feed}`))?.id ?? key;
 }
 
-export function priceFor(model: string, live?: LivePrices | null): { price: ModelPrice; known: boolean; live: boolean } {
+export function priceFor(model: string, live?: LivePrices | null): PriceHit {
   const table = live === undefined ? loadLivePrices() : live;
   if (live === undefined) {
-    const memo = priceMemo(table);
+    // An operator who edits the override file expects the new price at once, not after a refresh.
+    const stamp = overrideStamp();
+    if (memoTable !== table || memoStamp !== stamp) {
+      memoTable = table;
+      memoStamp = stamp;
+      memo = new Map();
+    }
     const hit = memo.get(model);
     if (hit) return hit;
-    const resolved = resolvePrice(model, table);
+    const resolved = resolvePrice(model, table, stamp);
     memo.set(model, resolved);
     return resolved;
   }
-  return resolvePrice(model, table);
+  return resolvePrice(model, table, overrideStamp());
 }
 
 // Recent rows repeat a handful of models; the memo turns thousands of lookups into one per model. Cleared whenever the table identity changes.
 let memoTable: LivePrices | null | undefined;
-let memo = new Map<string, { price: ModelPrice; known: boolean; live: boolean }>();
-
-function priceMemo(table: LivePrices | null): Map<string, { price: ModelPrice; known: boolean; live: boolean }> {
-  if (memoTable !== table) {
-    memoTable = table;
-    memo = new Map();
-  }
-  return memo;
-}
+let memoStamp = 0;
+let memo = new Map<string, PriceHit>();
 
 // Validated once per table instead of once per lookup.
 let compiledTable: LivePrices | null = null;
@@ -150,26 +213,42 @@ function priceEntries(table: LivePrices): Array<[string, ModelPrice]> {
   return entries;
 }
 
-function resolvePrice(model: string, table: LivePrices | null): { price: ModelPrice; known: boolean; live: boolean } {
-  // An alias goes through the same exact-then-suffix chain as any other id, so it still resolves when the feed keys it under a provider prefix.
-  const id = MODEL_ALIASES.find((a) => a.id === model.toLowerCase())?.feed ?? model;
+function resolvePrice(model: string, table: LivePrices | null, stamp = overrideStamp()): PriceHit {
+  // The operator's file wins outright: it is the only source that can name what a gateway charges.
+  const overrides = loadOverrides(stamp);
+  if (overrides) {
+    const own = overrides.exact.get(model) ?? overrides.exact.get(model.toLowerCase());
+    if (own) return { price: own, known: true, live: false, tier: 'override' };
+    const low = model.toLowerCase();
+    for (const [suffix, price] of overrides.tails) {
+      if (low === suffix || low.endsWith(`/${suffix}`)) {
+        return { price, known: true, live: false, tier: 'override' };
+      }
+    }
+  }
+
+  // An alias goes through the same chain as any other id, so it still resolves when the feed keys
+  // it under a provider prefix.
+  const alias = MODEL_ALIASES.find((a) => a.id === model.toLowerCase());
+  const id = alias?.feed ?? model;
   if (table) {
     const entries = priceEntries(table);
+    // 1. The id verbatim, then case-folded. Nothing is being guessed here.
+    const hit = entries.find(([k]) => k === id) ?? entries.find(([k]) => k === id.toLowerCase());
+    if (hit) return { price: hit[1], known: true, live: true, tier: alias ? 'alias' : 'exact' };
+
     const lower = id.toLowerCase();
-    const hit = entries.find(([k]) => k === id) ?? entries.find(([k]) => k === lower);
-    if (hit) return { price: hit[1], known: true, live: true };
-    // Provider-prefixed ids ("azure/gpt-4o", "dashscope/qwen-max"): match the
-    // first cached key that ends with the full id, then with the bare tail
-    // segment, so "codex/openai/gpt-6-luna" still finds "gpt-6-luna".
-    const name = lower;
-    const tail = name.split('/').pop() ?? name;
-    const key = entries.find(([k]) => {
+    const tail = lower.split('/').pop() ?? lower;
+    // The bare model name under any provider, which need not be the provider that billed the row.
+    // Reported as tier `tail`, so a caller keeps it out of a firm total; `prices.local.json` fixes
+    // a specific case.
+    const bare = entries.find(([k]) => {
       const lk = k.toLowerCase();
-      return lk === name || lk.endsWith(`/${name}`) || lk === tail || lk.endsWith(`/${tail}`);
+      return lk === tail || lk.endsWith(`/${tail}`);
     });
-    if (key) return { price: key[1], known: true, live: true };
+    if (bare) return { price: bare[1], known: true, live: true, tier: 'tail' };
   }
-  return { price: DEFAULT_PRICE, known: false, live: false };
+  return { price: DEFAULT_PRICE, known: false, live: false, tier: 'default' };
 }
 // Fetch LiteLLM pricing and write the cache. False on any failure — callers fall back silently.
 export async function refreshPrices(): Promise<boolean> {

package/extensions/shared/session-state.ts

@@ -95,7 +95,9 @@ export function normalizeInputCommand(value: unknown): string {
 }
 
 export function asPromptArray(systemPrompt: string | string[]): string[] {
-  return Array.isArray(systemPrompt) ? systemPrompt : [systemPrompt];
+  const parts = Array.isArray(systemPrompt) ? systemPrompt : [systemPrompt];
+  // OMP can hand back a hole in the array; a non-string breaks every marker check.
+  return parts.filter((part): part is string => typeof part === 'string');
 }
 
 export function systemPromptIncludes(systemPrompt: string | string[], marker: string): boolean {

package/extensions/shared/types.ts

@@ -36,6 +36,7 @@ export interface UiApi {
 export interface ExtensionCtx {
   hasUI?: boolean;
   cwd?: string;
+  signal?: AbortSignal;
   sessionManager?: {
     getBranch?: () => SessionEntry[];
     getEntries?: () => SessionEntry[];
@@ -46,13 +47,20 @@ export interface ExtensionCtx {
 
 export interface SystemPromptEvent {
   systemPrompt: string | string[];
-  // pi only: the mutable prompt sections. OMP does not provide it.
-  systemPromptOptions?: { appendSystemPrompt?: string };
+  // pi only: the mutable prompt sections and append slot. OMP does not provide them.
+  systemPromptOptions?: { appendSystemPrompt?: string; sections?: Record<string, string> };
 }
 
 /** What a `before_agent_start` handler hands back. OMP takes an array, pi a string. */
 export type PromptInjection = { systemPrompt: string[] } | { systemPrompt: string };
 
+/** A finished tool call, before its result reaches the model. pi and OMP provide it. */
+export interface ToolResultEvent {
+  toolName?: string;
+  content?: Array<{ type?: string; text?: string }>;
+  isError?: boolean;
+}
+
 /** A tool `parameters` object. OMP wants zod, pi wants JSON Schema. */
 export type ToolParams = Record<string, unknown>;