@vellumai/assistant 0.3.0

package/src/daemon/session-skill-tools.ts

@@ -0,0 +1,356 @@
+/**
+ * Session-time projection of active skill tools.
+ *
+ * On each agent turn the conversation history (and any pre-activated IDs from
+ * config or slash commands) determine which skills are "active".  This module
+ * computes the union, loads tool manifests, registers new skill tools, tears
+ * down tools for skills that are no longer active, and returns the projected
+ * tool definitions so the agent loop can include them in the next request.
+ */
+
+import type { Message, ToolDefinition } from '../providers/types.js';
+import type { SkillSummary, SkillToolManifest } from '../config/skills.js';
+import type { ActiveSkillEntry } from '../skills/active-skill-tools.js';
+import { loadSkillCatalog } from '../config/skills.js';
+import { deriveActiveSkills } from '../skills/active-skill-tools.js';
+
+import { parseToolManifestFile } from '../skills/tool-manifest.js';
+import { computeSkillVersionHash } from '../skills/version-hash.js';
+import { createSkillToolsFromManifest } from '../tools/skills/skill-tool-factory.js';
+import {
+  getTool,
+  registerSkillTools,
+  unregisterSkillTools,
+} from '../tools/registry.js';
+import { getLogger } from '../util/logger.js';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+
+const log = getLogger('session-skill-tools');
+
+// ---------------------------------------------------------------------------
+// Public types
+// ---------------------------------------------------------------------------
+
+export interface SkillToolProjection {
+  /** Tool definitions to append to the agent's tool list for this turn. */
+  toolDefinitions: ToolDefinition[];
+  /** Tool names that belong to currently active skills. */
+  allowedToolNames: Set<string>;
+}
+
+/**
+ * Session-scoped cache for skill projection. Avoids re-scanning the entire
+ * conversation history and re-reading the filesystem on every agent turn.
+ *
+ * Each session should own its own cache instance to prevent cross-session
+ * state bleed.
+ */
+export interface SkillProjectionCache {
+  /** Cached deriveActiveSkills result. */
+  derived?: {
+    /** Number of messages in history when this cache was last computed. */
+    messageCount: number;
+    /** Reference to the first message when cache was computed. Compaction
+     *  replaces the first message with a new summary object, so a reference
+     *  mismatch signals that history was rewritten even if the count matches. */
+    firstMessage: Message | undefined;
+    /** IDs already seen — used for deduplication during incremental scans. */
+    seenIds: Set<string>;
+    /** The accumulated active skill entries. */
+    entries: ActiveSkillEntry[];
+  };
+  /** Cached skill catalog. Invalidated when the session is marked stale
+   *  (e.g. skill directories changed on disk while a run is in progress). */
+  catalog?: SkillSummary[];
+}
+
+export interface ProjectSkillToolsOptions {
+  /** Skill IDs that should be treated as active regardless of history markers. */
+  preactivatedSkillIds?: string[];
+  /**
+   * Session-scoped tracking map of previously active skill IDs to their
+   * version hashes. Each session should own its own map to prevent
+   * cross-session state bleed when the daemon serves multiple concurrent
+   * sessions. When a skill's hash changes between turns, its tools are
+   * unregistered and re-registered with the updated definitions.
+   */
+  previouslyActiveSkillIds?: Map<string, string>;
+  /**
+   * Session-scoped projection cache. When provided, projectSkillTools will
+   * avoid redundant deriveActiveSkills scans and loadSkillCatalog filesystem
+   * reads across agent turns.
+   */
+  cache?: SkillProjectionCache;
+}
+
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Load and parse a skill's TOOLS.json manifest, returning null on any failure.
+ */
+function loadManifestForSkill(skill: SkillSummary): SkillToolManifest | null {
+  const manifestPath = join(skill.directoryPath, 'TOOLS.json');
+  if (!existsSync(manifestPath)) {
+    log.debug({ skillId: skill.id, manifestPath }, 'No TOOLS.json found for skill');
+    return null;
+  }
+
+  try {
+    return parseToolManifestFile(manifestPath);
+  } catch (err) {
+    log.warn({ err, skillId: skill.id, manifestPath }, 'Failed to parse TOOLS.json for skill');
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Cache helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Return active skill entries, using the projection cache when available.
+ *
+ * History is append-only within a session (messages are only added, never
+ * mutated in place). If history.length hasn't changed since the last scan,
+ * the cached result is returned immediately. If new messages were appended,
+ * only the delta is scanned and merged. If history shrank (e.g. compression
+ * replaced earlier messages), the cache is invalidated and a full rescan
+ * is performed.
+ */
+function getCachedActiveSkills(
+  history: Message[],
+  cache?: SkillProjectionCache,
+): ActiveSkillEntry[] {
+  if (!cache) return deriveActiveSkills(history);
+
+  const cached = cache.derived;
+
+  // Fast path: history unchanged since last scan. Both the count and the
+  // first message reference must match — compaction can rewrite history
+  // without changing the total count.
+  if (cached && cached.messageCount === history.length && cached.firstMessage === history[0]) {
+    return cached.entries;
+  }
+
+  // History grew (and first message is unchanged) — scan only the new messages.
+  if (cached && cached.messageCount < history.length && cached.firstMessage === history[0]) {
+    const delta = history.slice(cached.messageCount);
+    const newEntries = deriveActiveSkills(delta);
+
+    // Merge: add any entries not already seen.
+    let changed = false;
+    for (const entry of newEntries) {
+      if (!cached.seenIds.has(entry.id)) {
+        cached.seenIds.add(entry.id);
+        cached.entries.push(entry);
+        changed = true;
+      }
+    }
+
+    cached.messageCount = history.length;
+    if (changed) {
+      log.debug(
+        { newEntries: newEntries.length, total: cached.entries.length },
+        'Incremental skill derivation found new entries',
+      );
+    }
+    return cached.entries;
+  }
+
+  // History shrank, compaction rewrote it, or no cache yet — full rescan.
+  const entries = deriveActiveSkills(history);
+  const seenIds = new Set(entries.map((e) => e.id));
+  cache.derived = { messageCount: history.length, firstMessage: history[0], seenIds, entries };
+  return entries;
+}
+
+/**
+ * Return the skill catalog, caching it across agent turns.
+ *
+ * The cache is invalidated when the session is marked stale (e.g. skill
+ * directories changed on disk while the session is still processing).
+ */
+function getCachedCatalog(cache?: SkillProjectionCache): SkillSummary[] {
+  if (!cache) return loadSkillCatalog();
+
+  if (!cache.catalog) {
+    cache.catalog = loadSkillCatalog();
+  }
+  return cache.catalog;
+}
+
+// ---------------------------------------------------------------------------
+// Main export
+// ---------------------------------------------------------------------------
+
+/**
+ * Compute the set of active skill tools for the current session turn.
+ *
+ * 1. Derives active skill IDs from conversation history markers.
+ * 2. Merges with any preactivated IDs (union).
+ * 3. For each newly-active skill, loads its TOOLS.json and registers tools.
+ * 4. For each previously-active skill that is no longer active, unregisters.
+ * 5. Returns projected tool definitions and the set of allowed tool names.
+ */
+export function projectSkillTools(
+  history: Message[],
+  options?: ProjectSkillToolsOptions,
+): SkillToolProjection {
+  const contextEntries = getCachedActiveSkills(history, options?.cache);
+  const preactivated = options?.preactivatedSkillIds ?? [];
+  const prevActive = options?.previouslyActiveSkillIds ?? new Map<string, string>();
+
+  // Index marker versions by skill ID so we can use them during registration.
+  // When a marker carries a version, it records the hash that was active at
+  // load time — useful for detecting drift without re-hashing the directory.
+  const markerVersionById = new Map<string, string>();
+  for (const entry of contextEntries) {
+    if (entry.version) {
+      markerVersionById.set(entry.id, entry.version);
+    }
+  }
+
+  // Union of context-derived and preactivated IDs
+  const contextIds = contextEntries.map((e) => e.id);
+  const activeIds = new Set<string>([...contextIds, ...preactivated]);
+
+  // Determine which skills were removed since last projection
+  const removedIds = new Set<string>();
+  for (const id of prevActive.keys()) {
+    if (!activeIds.has(id)) {
+      removedIds.add(id);
+    }
+  }
+
+  // Unregister tools for skills that are no longer active
+  for (const id of removedIds) {
+    log.info({ skillId: id }, 'Unregistering tools for deactivated skill');
+    unregisterSkillTools(id);
+  }
+
+  // Early exit if nothing is active
+  if (activeIds.size === 0) {
+    prevActive.clear();
+    return { toolDefinitions: [], allowedToolNames: new Set() };
+  }
+
+  // Load the catalog (cached for session lifetime) and index by ID
+  const catalog = getCachedCatalog(options?.cache);
+  const catalogById = new Map<string, SkillSummary>();
+  for (const skill of catalog) {
+    catalogById.set(skill.id, skill);
+  }
+
+  const allToolDefinitions: ToolDefinition[] = [];
+  const allToolNames = new Set<string>();
+  const successfulEntries = new Map<string, string>();
+  // Track skills already unregistered in the version-change branch so the
+  // transiently-failed cleanup loop doesn't double-decrement their refcount.
+  const alreadyUnregistered = new Set<string>();
+
+  for (const skillId of activeIds) {
+    const skill = catalogById.get(skillId);
+    if (!skill) {
+      log.warn({ skillId }, 'Active skill ID not found in catalog');
+      continue;
+    }
+
+    const manifest = loadManifestForSkill(skill);
+    if (!manifest) {
+      continue;
+    }
+
+    // Compute the current version hash for this skill directory
+    let currentHash: string;
+    try {
+      currentHash = computeSkillVersionHash(skill.directoryPath);
+    } catch (err) {
+      log.warn({ err, skillId }, 'Failed to compute skill version hash, treating as changed');
+      currentHash = `unknown-${Date.now()}`;
+    }
+
+    // Create runtime Tool objects
+    const tools = createSkillToolsFromManifest(
+      manifest.tools,
+      skillId,
+      skill.directoryPath,
+      currentHash,
+      skill.bundled,
+    );
+
+    if (tools.length > 0) {
+      const prevHash = prevActive.get(skillId);
+      if (prevHash === undefined) {
+        // Newly active skill — register for the first time
+        registerSkillTools(tools);
+      } else if (prevHash !== currentHash) {
+        // Hash changed — unregister stale tools, then re-register with new definitions
+        log.info({ skillId, prevHash, currentHash }, 'Skill version changed, re-registering tools');
+        unregisterSkillTools(skillId);
+        alreadyUnregistered.add(skillId);
+        try {
+          registerSkillTools(tools);
+        } catch (err) {
+          log.error({ err, skillId }, 'Failed to re-register skill tools after version change');
+          // Don't add to successfulEntries — will be cleaned up as transiently-failed
+          continue;
+        }
+      } else {
+        // Hash unchanged — check if the bundled status drifted (e.g. a
+        // managed skill override was added/removed with identical content).
+        // Re-register so the ownerSkillBundled flag stays accurate.
+        const existing = getTool(tools[0].name);
+        if (existing && existing.ownerSkillBundled !== (skill.bundled ?? undefined)) {
+          log.info({ skillId, bundled: skill.bundled }, 'Skill bundled status changed, re-registering tools');
+          unregisterSkillTools(skillId);
+          registerSkillTools(tools);
+        }
+      }
+
+      successfulEntries.set(skillId, currentHash);
+      for (const tool of tools) {
+        allToolDefinitions.push(tool.getDefinition());
+        allToolNames.add(tool.name);
+      }
+    }
+  }
+
+  // Unregister skills that were previously active but failed processing this
+  // turn (catalog miss, manifest failure, empty tools). Without this, the
+  // skill would be re-registered when it recovers next turn, inflating the
+  // refcount since the prior registration was never decremented.
+  for (const id of prevActive.keys()) {
+    if (activeIds.has(id) && !successfulEntries.has(id) && !alreadyUnregistered.has(id)) {
+      log.info({ skillId: id }, 'Unregistering tools for transiently-failed skill');
+      unregisterSkillTools(id);
+    }
+  }
+
+  // Update the session-scoped tracking map in-place — only include skills
+  // that were successfully processed so failed skills can be retried next turn.
+  prevActive.clear();
+  for (const [id, hash] of successfulEntries) {
+    prevActive.set(id, hash);
+  }
+
+  return {
+    toolDefinitions: allToolDefinitions,
+    allowedToolNames: allToolNames,
+  };
+}
+
+/**
+ * Reset the projection state and unregister all skill tools tracked in the
+ * given map. Used for session teardown and tests.
+ */
+export function resetSkillToolProjection(trackedIds?: Map<string, string>): void {
+  if (trackedIds) {
+    for (const id of trackedIds.keys()) {
+      unregisterSkillTools(id);
+    }
+    trackedIds.clear();
+  }
+}

package/src/daemon/session-slash.ts

@@ -0,0 +1,305 @@
+import { readFileSync, existsSync } from 'node:fs';
+import { getConfig, loadRawConfig, saveRawConfig } from '../config/loader.js';
+import { initializeProviders } from '../providers/registry.js';
+import { loadSkillCatalog } from '../config/skills.js';
+import { resolveSkillStates } from '../config/skill-state.js';
+import {
+  buildInvocableSlashCatalog,
+  resolveSlashSkillCommand,
+  rewriteKnownSlashCommandPrompt,
+} from '../skills/slash-commands.js';
+import { getWorkspacePromptPath } from '../util/platform.js';
+
+export type SlashResolution =
+  | { kind: 'passthrough'; content: string }
+  | { kind: 'rewritten'; content: string; skillId: string }
+  | { kind: 'unknown'; message: string };
+
+// ── /model command ───────────────────────────────────────────────────
+
+const AVAILABLE_MODELS = [
+  'claude-opus-4-6',
+  'claude-opus-4-6-fast',
+  'claude-sonnet-4-6',
+  'claude-haiku-4-5-20251001',
+] as const;
+
+const MODEL_DISPLAY_NAMES: Record<string, string> = {
+  'claude-opus-4-6': 'Claude Opus 4.6',
+  'claude-opus-4-6-fast': 'Claude Opus 4.6 Fast',
+  'claude-sonnet-4-6': 'Claude Sonnet 4.6',
+  'claude-haiku-4-5-20251001': 'Claude Haiku 4.5',
+};
+
+const PROVIDER_MODEL_SHORTCUTS: Record<string, { provider: string; model: string; displayName: string }> = {
+  // Anthropic
+  'opus': { provider: 'anthropic', model: 'claude-opus-4-6', displayName: 'Claude Opus 4.6' },
+  'opus-fast': { provider: 'anthropic', model: 'claude-opus-4-6-fast', displayName: 'Claude Opus 4.6 Fast' },
+  'sonnet': { provider: 'anthropic', model: 'claude-sonnet-4-6', displayName: 'Claude Sonnet 4.6' },
+  'haiku': { provider: 'anthropic', model: 'claude-haiku-4-5-20251001', displayName: 'Claude Haiku 4.5' },
+
+  // OpenAI
+  'gpt4': { provider: 'openai', model: 'gpt-4', displayName: 'GPT-4' },
+  'gpt4o': { provider: 'openai', model: 'gpt-4o', displayName: 'GPT-4o' },
+  'gpt5': { provider: 'openai', model: 'gpt-5.2', displayName: 'GPT-5.2' },
+
+  // Gemini
+  'gemini': { provider: 'gemini', model: 'gemini-3-flash', displayName: 'Gemini 3 Flash' },
+
+  // Ollama
+  'ollama': { provider: 'ollama', model: 'llama3.2', displayName: 'Llama 3.2' },
+
+  // Fireworks
+  'fireworks': { provider: 'fireworks', model: 'accounts/fireworks/models/kimi-k2p5', displayName: 'Kimi K2.5' },
+
+  // OpenRouter
+  'openrouter': { provider: 'openrouter', model: 'x-ai/grok-4', displayName: 'Grok 4 (OpenRouter)' },
+};
+
+/** Reverse lookup: model ID → provider, derived from PROVIDER_MODEL_SHORTCUTS. */
+export const MODEL_TO_PROVIDER: Record<string, string> = Object.fromEntries(
+  Object.values(PROVIDER_MODEL_SHORTCUTS).map(({ model, provider }) => [model, provider]),
+);
+
+/** Read the assistant's name from IDENTITY.md for personalized responses. */
+function getAssistantName(): string | null {
+  try {
+    const path = getWorkspacePromptPath('IDENTITY.md');
+    if (!existsSync(path)) return null;
+    const content = readFileSync(path, 'utf-8');
+    const match = content.match(/\*\*Name:\*\*\s*(.+)/);
+    return match?.[1]?.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+/** Partial-match a user input like "opus", "sonnet", "haiku" to a full model ID. */
+function matchModel(input: string): string | undefined {
+  const lower = input.toLowerCase().trim();
+  // Exact match first
+  const exact = AVAILABLE_MODELS.find((m) => m === lower);
+  if (exact) return exact;
+  // Partial match (e.g. "opus" → "claude-opus-4-6")
+  return AVAILABLE_MODELS.find((m) => m.includes(lower));
+}
+
+function resolveProviderModelCommand(content: string): SlashResolution | null {
+  const trimmed = content.trim();
+  if (!trimmed.startsWith('/')) return null;
+
+  // Extract the command (e.g., "/gpt4" → "gpt4")
+  const match = trimmed.match(/^\/([a-z0-9-]+)(\s|$)/i);
+  if (!match) return null;
+
+  const command = match[1].toLowerCase();
+  const shortcut = PROVIDER_MODEL_SHORTCUTS[command];
+  if (!shortcut) return null;
+
+  const { provider, model, displayName } = shortcut;
+  const config = getConfig();
+  const name = getAssistantName();
+
+  // Check if API key exists for this provider (Ollama doesn't require an API key)
+  if (provider !== 'ollama' && !config.apiKeys[provider]) {
+    return {
+      kind: 'unknown',
+      message: `Cannot switch to ${displayName}. No API key configured for ${provider}.\n\nSet it with: \`config set apiKeys.${provider} <your-key>\``,
+    };
+  }
+
+  // Check if already using this provider+model
+  if (config.provider === provider && config.model === model) {
+    const alreadyMsg = name
+      ? `${name} is already running on **${displayName}**.`
+      : `Already using **${displayName}**.`;
+    return {
+      kind: 'unknown',
+      message: alreadyMsg,
+    };
+  }
+
+  // Update config with both provider and model
+  const raw = loadRawConfig();
+  raw.provider = provider;
+  raw.model = model;
+  saveRawConfig(raw);
+
+  // Re-initialize providers with new config
+  const newConfig = getConfig();
+  initializeProviders(newConfig);
+
+  const switchedMsg = name
+    ? `Switched ${name} to **${displayName}**. New conversations will use this model.`
+    : `Switched to **${displayName}**. New conversations will use this model.`;
+
+  return {
+    kind: 'unknown',
+    message: switchedMsg,
+  };
+}
+
+function resolveModelList(): SlashResolution {
+  const config = getConfig();
+  const lines = ['Available models:\n'];
+
+  for (const [cmd, { provider, model, displayName }] of Object.entries(PROVIDER_MODEL_SHORTCUTS)) {
+    const hasKey = provider === 'ollama' || !!config.apiKeys[provider];
+    const isCurrent = config.provider === provider && config.model === model;
+    const status = hasKey ? '✓' : '✗';
+    const current = isCurrent ? ' **[current]**' : '';
+    lines.push(`- **${displayName}** (/${cmd}) ${status}${current}`);
+  }
+
+  lines.push('\n✓ = API key configured, ✗ = not configured');
+  lines.push('\nTip: Configure a provider with `config set apiKeys.<provider> <key>`');
+
+  return {
+    kind: 'unknown',
+    message: lines.join('\n'),
+  };
+}
+
+function resolveModelCommand(content: string): SlashResolution | null {
+  const trimmed = content.trim();
+  // Match /models → route to list
+  if (trimmed === '/models') {
+    return resolveModelList();
+  }
+
+  if (!trimmed.startsWith('/model')) return null;
+  // Ensure it's exactly "/model" or "/model " (not "/modelsomething")
+  if (trimmed.length > 6 && trimmed[6] !== ' ') return null;
+
+  const args = trimmed.slice(6).trim();
+  const name = getAssistantName();
+
+  if (!args) {
+    // Show current model
+    const config = getConfig();
+    const displayName = MODEL_DISPLAY_NAMES[config.model] ?? config.model;
+    const prefix = name ? `${name} is running on` : `Currently using`;
+    return {
+      kind: 'unknown',
+      message: `${prefix} **${displayName}** (\`${config.model}\`).`,
+    };
+  }
+
+  // Handle /model list
+  if (args === 'list') {
+    return resolveModelList();
+  }
+
+  // Try to match the model name
+  const matched = matchModel(args);
+  if (!matched) {
+    const available = AVAILABLE_MODELS.map(
+      (m) => `- **${MODEL_DISPLAY_NAMES[m]}** (\`${m}\`)`,
+    ).join('\n');
+    return {
+      kind: 'unknown',
+      message: `Hmm, "${args}" doesn't match any available model. Here's what you can pick from:\n${available}`,
+    };
+  }
+
+  // Check if already using this model
+  const currentConfig = getConfig();
+  if (currentConfig.model === matched) {
+    const displayName = MODEL_DISPLAY_NAMES[matched] ?? matched;
+    const alreadyMsg = name
+      ? `${name} is already running on **${displayName}**.`
+      : `Already on **${displayName}**.`;
+    return {
+      kind: 'unknown',
+      message: alreadyMsg,
+    };
+  }
+
+  // Validate that Anthropic provider is available
+  if (!currentConfig.apiKeys.anthropic) {
+    const displayName = MODEL_DISPLAY_NAMES[matched] ?? matched;
+    return {
+      kind: 'unknown',
+      message: `Cannot switch to ${displayName}. No API key configured for Anthropic.\n\nSet it with: \`config set apiKeys.anthropic <your-key>\``,
+    };
+  }
+
+  // Change model: save config and re-initialize providers
+  const raw = loadRawConfig();
+  raw.provider = 'anthropic'; // Ensure provider is set for Anthropic models
+  raw.model = matched;
+  saveRawConfig(raw);
+  const config = getConfig();
+  initializeProviders(config);
+
+  const displayName = MODEL_DISPLAY_NAMES[matched] ?? matched;
+  const switchedMsg = name
+    ? `Switched ${name} to **${displayName}**. New conversations will use this model.`
+    : `Switched to **${displayName}**. New conversations will use this model.`;
+  return {
+    kind: 'unknown',
+    message: switchedMsg,
+  };
+}
+
+/**
+ * Resolve slash commands against the current skill catalog.
+ * Returns `unknown` with a deterministic message, or the (possibly rewritten) content.
+ */
+export function resolveSlash(content: string): SlashResolution {
+  // Check provider shortcuts first (/gpt4, /opus, etc.)
+  const providerResult = resolveProviderModelCommand(content);
+  if (providerResult) return providerResult;
+
+  // Handle /model command
+  const modelResult = resolveModelCommand(content);
+  if (modelResult) return modelResult;
+
+  // Handle /commands command
+  if (content.trim() === '/commands') {
+    return {
+      kind: 'unknown',
+      message: '/commands — List all available commands\n/model — Show or switch the current model\n/models — List all available models',
+    };
+  }
+
+  const config = getConfig();
+  const catalog = loadSkillCatalog();
+  const resolved = resolveSkillStates(catalog, config);
+  const invocable = buildInvocableSlashCatalog(catalog, resolved);
+  const resolution = resolveSlashSkillCommand(content, invocable);
+
+  if (resolution.kind === 'known') {
+    const skill = invocable.get(resolution.skillId.toLowerCase());
+    return {
+      kind: 'rewritten',
+      content: rewriteKnownSlashCommandPrompt({
+        rawInput: content,
+        skillId: resolution.skillId,
+        skillName: skill?.name ?? resolution.skillId,
+        trailingArgs: resolution.trailingArgs,
+      }),
+      skillId: resolution.skillId,
+    };
+  }
+
+  if (resolution.kind === 'unknown') {
+    return { kind: 'unknown', message: resolution.message };
+  }
+
+  return { kind: 'passthrough', content };
+}
+
+// ── Provider Ordering Error Detection ────────────────────────────────
+
+const ORDERING_ERROR_PATTERNS = [
+  /tool_result.*not immediately after.*tool_use/i,
+  /tool_use.*must have.*tool_result/i,
+  /tool_use_id.*without.*tool_result/i,
+  /tool_result.*tool_use_id.*not found/i,
+  /messages.*invalid.*order/i,
+];
+
+export function isProviderOrderingError(message: string): boolean {
+  return ORDERING_ERROR_PATTERNS.some((pattern) => pattern.test(message));
+}