@vellumai/assistant 0.9.1-staging.1 → 0.10.0-staging.2

package/src/plugins/defaults/memory-v3-shadow/orchestrate.ts

@@ -18,9 +18,10 @@
  *      Each lane only ever ADDS candidates, so the pool is recall-safe by
  *      construction.
  *   2. Build the candidate pool in CACHE ORDER: the stable prefix —
- *      `[...core (file order), ...hot (score order), ...fresh (recency
- *      order)]`, all computed at lane init — followed by the finder
- *      candidates (needle → dense → edge surfacing order). The stable prefix
+ *      `[...core (file order), ...hot (score order), ...fresh (recency order),
+ *      ...always-candidate (skills pinned every turn)]`, all computed at lane
+ *      init — followed by the finder candidates (needle → dense → edge
+ *      surfacing order). The stable prefix
  *      is identical across consecutive turns while the lanes are unchanged
  *      (lane invalidation at consolidation is the recompute cadence), so the
  *      selector input's leading segment rides the provider KV cache (the
@@ -82,6 +83,10 @@ export interface OrchestrateDeps {
   /** The modification-recency fresh set in recency order (computed at lane
    *  init with core and hot excluded). Follows hot in the stable prefix. */
   freshSlugs: Slug[];
+  /** Skills pinned into the candidate pool every turn regardless of retrieval
+   *  (existence-filtered and core/hot/fresh-excluded at lane init). Follow fresh
+   *  in the stable prefix so the selector always sees them. */
+  alwaysCandidateSlugs?: Slug[];
   /** Pre-rendered FULL cards for the stable-prefix slugs, keyed by slug.
    *  Rendered ONCE at lane init so the selector's stable prefix is
    *  byte-identical across turns (the cache contract). Every core/hot/fresh
@@ -172,14 +177,19 @@ export async function orchestrate(
   const { sections } = deps.sectionIndex;
 
   // The stable prefix: core (file order), hot (score order), fresh (recency
-  // order). Hot is computed with core excluded at lane init, fresh with both
-  // excluded; the filters here are a cheap defensive dedup so a misbehaving
-  // lane can never double-list a slug.
+  // order), then always-candidate skills. Hot is computed with core excluded at
+  // lane init, fresh with both excluded, always-candidate with all three
+  // excluded; the filters here are a cheap defensive dedup so a misbehaving lane
+  // can never double-list a slug.
   const core = deps.coreSlugs;
   const hot = deps.hotSlugs.filter((slug) => !core.includes(slug));
   const coreHot = new Set<Slug>([...core, ...hot]);
   const fresh = deps.freshSlugs.filter((slug) => !coreHot.has(slug));
-  const stablePrefix = new Set<Slug>([...coreHot, ...fresh]);
+  const coreHotFresh = new Set<Slug>([...coreHot, ...fresh]);
+  const always = (deps.alwaysCandidateSlugs ?? []).filter(
+    (slug) => !coreHotFresh.has(slug),
+  );
+  const stablePrefix = new Set<Slug>([...coreHotFresh, ...always]);
 
   // Step 1: needle (sync BM25) and dense (async embed + Qdrant) lanes run in
   // parallel. Both return distinct articles each tagged with their best-scoring
@@ -342,19 +352,21 @@ export async function orchestrate(
   // its own snippet line so its CURRENT relevance stays visible; `selectPool`
   // dedupes selections by slug. Finder candidates with no match text fall
   // back to the page's lead-section snippet.
-  const stable: StableCandidate[] = [...core, ...hot, ...fresh].map((slug) => {
-    const card = deps.prefixCards.get(slug);
-    if (card === undefined) {
-      // Lane init renders a card for every core/hot slug; a hole here means
-      // the lanes and the card map are out of sync. Throw rather than render
-      // a degraded card — the caller (observeTurn) logs and skips the turn,
-      // which is better than silently breaking the byte-stable prefix.
-      throw new Error(
-        `memory-v3: no pre-rendered card for stable-prefix slug "${slug}"`,
-      );
-    }
-    return { slug, card };
-  });
+  const stable: StableCandidate[] = [...core, ...hot, ...fresh, ...always].map(
+    (slug) => {
+      const card = deps.prefixCards.get(slug);
+      if (card === undefined) {
+        // Lane init renders a card for every core/hot slug; a hole here means
+        // the lanes and the card map are out of sync. Throw rather than render
+        // a degraded card — the caller (observeTurn) logs and skips the turn,
+        // which is better than silently breaking the byte-stable prefix.
+        throw new Error(
+          `memory-v3: no pre-rendered card for stable-prefix slug "${slug}"`,
+        );
+      }
+      return { slug, card };
+    },
+  );
   const finderTail: PoolCandidate[] = finder.map((c) => ({
     slug: c.slug,
     lane: c.lane,

package/src/plugins/defaults/memory-v3-shadow/selection-log-store.ts

@@ -19,6 +19,7 @@
 import type { MemoryV3SelectionLog } from "../../../api/responses/memory-v3-selection-log.js";
 import { isAssistantFeatureFlagEnabled } from "../../../config/assistant-feature-flags.js";
 import { getConfig } from "../../../config/loader.js";
+import { isMemoryV3Live } from "../../../config/memory-v3-gate.js";
 import { getDb, getSqliteFrom } from "../../../memory/db-connection.js";
 import { readPage } from "../../../memory/v2/page-store.js";
 import { getWorkspaceDir } from "../../../util/platform.js";
@@ -35,7 +36,6 @@ import {
 } from "./types.js";
 
 const MEMORY_V3_SHADOW = "memory-v3-shadow" as const;
-const MEMORY_V3_LIVE = "memory-v3-live" as const;
 
 interface SelectionRow {
   turn: number;
@@ -74,6 +74,52 @@ function rowsForMessageIds(messageIds: string[]): SelectionRow[] {
     .all(...messageIds) as SelectionRow[];
 }
 
+const MAX_FORK_HOPS = 64;
+
+/**
+ * Read the `forkSourceMessageId` back-pointer that `cloneForkMessageMetadata`
+ * stamps onto every message a fork copies, for the given message ids.
+ */
+function forkSourceIdsOf(messageIds: string[]): string[] {
+  if (messageIds.length === 0) return [];
+  const placeholders = messageIds.map(() => "?").join(", ");
+  const rows = getSqliteFrom(getDb())
+    .query(
+      /*sql*/ `
+      SELECT json_extract(metadata, '$.forkSourceMessageId') AS src
+      FROM messages
+      WHERE id IN (${placeholders})
+    `,
+    )
+    .all(...messageIds) as Array<{ src: string | null }>;
+  return rows
+    .map((r) => r.src)
+    .filter((src): src is string => typeof src === "string" && src.length > 0);
+}
+
+/**
+ * A fork copies the parent's messages under fresh ids but does not copy their
+ * `memory_v3_selections` rows, so an inherited turn has no rows under its own
+ * message ids. Each copied message preserves a `forkSourceMessageId` pointer to
+ * the message it was cloned from; walk that chain (a fork of a fork chains it
+ * again) to the nearest ancestor generation that logged selections and return
+ * those rows. Returns `[]` when no ancestor has v3 rows (or the ids aren't fork
+ * copies).
+ */
+function rowsViaForkSource(messageIds: string[]): SelectionRow[] {
+  let frontier = messageIds;
+  const visited = new Set(messageIds);
+  for (let hop = 0; hop < MAX_FORK_HOPS; hop++) {
+    const sources = forkSourceIdsOf(frontier).filter((id) => !visited.has(id));
+    if (sources.length === 0) return [];
+    for (const id of sources) visited.add(id);
+    const rows = rowsForMessageIds(sources);
+    if (rows.length > 0) return rows;
+    frontier = sources;
+  }
+  return [];
+}
+
 /**
  * Resolve each selection's persisted matched section `(slug, ordinal)` to the
  * concrete `Section` in the CURRENT page, so the injected block renders the
@@ -133,7 +179,7 @@ async function buildSelectionLog(
 
   return {
     turn: rows[0]!.turn,
-    live: isAssistantFeatureFlagEnabled(MEMORY_V3_LIVE, config),
+    live: isMemoryV3Live(config),
     shadow: isAssistantFeatureFlagEnabled(MEMORY_V3_SHADOW, config),
     selections,
     injectedText,
@@ -150,13 +196,20 @@ async function buildSelectionLog(
  * conversation with no v3 data). Message ids are globally unique, so no
  * conversation scope is needed.
  *
+ * For turns inherited from a fork, the copied messages carry fresh ids with no
+ * selection rows of their own, so the lookup falls back to the parent's rows by
+ * following each message's `forkSourceMessageId` back-pointer.
+ *
  * Selection rows are stored in selection order, so rendering them in row order
  * reproduces the block v3 would inject.
  */
 export async function getMemoryV3SelectionForInspectorByMessageIds(
   messageIds: string[],
 ): Promise<MemoryV3SelectionLog | null> {
-  return buildSelectionLog(rowsForMessageIds(messageIds));
+  const rows = rowsForMessageIds(messageIds);
+  return buildSelectionLog(
+    rows.length > 0 ? rows : rowsViaForkSource(messageIds),
+  );
 }
 
 /**

package/src/plugins/defaults/memory-v3-shadow/shadow-plugin.ts

@@ -34,6 +34,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { isAssistantFeatureFlagEnabled } from "../../../config/assistant-feature-flags.js";
 import { getConfig } from "../../../config/loader.js";
 import type { AssistantConfig } from "../../../config/schema.js";
+import { loadSkillCatalog } from "../../../config/skills.js";
 import { getMessages } from "../../../memory/conversation-crud.js";
 import { getDb, getSqliteFrom } from "../../../memory/db-connection.js";
 import { stringifyMessageContent } from "../../../memory/message-content.js";
@@ -68,7 +69,6 @@ import {
 } from "./types.js";
 
 export const MEMORY_V3_SHADOW = "memory-v3-shadow" as const;
-export const MEMORY_V3_LIVE = "memory-v3-live" as const;
 
 const log = getLogger("memory-v3-shadow");
 
@@ -107,6 +107,9 @@ export interface ShadowLanes {
   /** Modification-recency fresh set in recency order: core and hot excluded,
    *  filtered to pages in the section index. */
   freshSlugs: string[];
+  /** Skills pinned into the stable prefix every turn (`always-candidate: true`
+   *  in SKILL.md), existence-filtered and core/hot/fresh-excluded. */
+  alwaysCandidateSlugs: string[];
   /** Learned-edge graph: co-selection NPMI associations over the selection
    *  log, rebuilt with the lanes (the consolidation cadence). */
   learnedGraph: EdgeGraph;
@@ -216,6 +219,18 @@ async function initLanes(config: AssistantConfig): Promise<ShadowLanes> {
     excludeSlugs: new Set([...coreSlugs, ...hotSlugs]),
   }).filter((slug) => sectionIndex.byArticle.has(slug));
 
+  // Always-candidate skills are pinned into the stable prefix every turn so the
+  // selector can choose a cross-cutting capability (e.g. workflows) even when no
+  // retrieval lane surfaces it — its relevance is a judgment the model makes,
+  // not something embedding similarity finds. Filtered to skills present in the
+  // section index and excluded from core/hot/fresh so the prefix never
+  // double-lists a slug.
+  const prefixSet = new Set([...coreSlugs, ...hotSlugs, ...freshSlugs]);
+  const alwaysCandidateSlugs = loadSkillCatalog()
+    .filter((summary) => summary.alwaysCandidate === true)
+    .map((summary) => `skills/${summary.id}`)
+    .filter((slug) => sectionIndex.byArticle.has(slug) && !prefixSet.has(slug));
+
   // Pre-render the stable-prefix cards ONCE per lane build: the selector's
   // stable prefix must be byte-identical across turns to ride the provider KV
   // cache, so the cards are frozen here (lane invalidation at consolidation is
@@ -228,7 +243,10 @@ async function initLanes(config: AssistantConfig): Promise<ShadowLanes> {
   const modifiedAtBySlug = new Map(
     pageIndex.entries.map((entry) => [entry.slug, entry.modifiedAt]),
   );
-  const laneAnnotation = (slug: Slug, lane: "core" | "hot" | "fresh") => {
+  const laneAnnotation = (
+    slug: Slug,
+    lane: "core" | "hot" | "fresh" | "always",
+  ) => {
     if (lane !== "fresh") return `[lane: ${lane}]`;
     const modifiedAt = modifiedAtBySlug.get(slug);
     if (
@@ -249,6 +267,7 @@ async function initLanes(config: AssistantConfig): Promise<ShadowLanes> {
     ["core", coreSlugs],
     ["hot", hotSlugs],
     ["fresh", freshSlugs],
+    ["always", alwaysCandidateSlugs],
   ] as const) {
     for (const slug of slugs) {
       const raw = await capabilityOrDiskBody(
@@ -303,6 +322,7 @@ async function initLanes(config: AssistantConfig): Promise<ShadowLanes> {
     coreSlugs,
     hotSlugs,
     freshSlugs,
+    alwaysCandidateSlugs,
     prefixCards,
   };
 }
@@ -545,6 +565,7 @@ export async function observeTurn(
       coreSlugs: lanes.coreSlugs,
       hotSlugs: lanes.hotSlugs,
       freshSlugs: lanes.freshSlugs,
+      alwaysCandidateSlugs: lanes.alwaysCandidateSlugs,
       prefixCards: lanes.prefixCards,
       needleK: v3.needleK,
       denseK: v3.denseK,

package/src/plugins/defaults/task-progress-nudge/hooks/post-tool-use.ts

@@ -48,6 +48,7 @@
 import type { PluginHookFn, PostToolUseContext } from "@vellumai/plugin-api";
 
 import type { ContentBlock, Message } from "../../../../providers/types.js";
+import { isWeakOpenModel } from "../../../../providers/weak-open-model.js";
 
 /**
  * Canonical nudge notice. Module-level constant so tests and wrapping plugins
@@ -66,17 +67,6 @@ export const TASK_PROGRESS_NUDGE_TEXT =
  */
 export const TASK_PROGRESS_NUDGE_ROUND_THRESHOLD = 3;
 
-/**
- * Weaker open models that disregard the static progress-card instruction and
- * so get the mid-turn nudge: Kimi, DeepSeek, and MiniMax. Family-level matching
- * spans provider naming conventions (OpenRouter `moonshotai/kimi-k2.6`,
- * `deepseek/deepseek-chat`, `minimax/minimax-m3`; Fireworks
- * `accounts/fireworks/models/minimax-m3`, `kimi-k2p6`). Extend as other models
- * show the same gap. Capable models (Claude, GPT) follow the prompt and are
- * intentionally excluded.
- */
-const WEAK_MODEL_PATTERN = /kimi|deepseek|minimax/i;
-
 /**
  * Round count at the last nudge, per conversation. A non-zero entry means the
  * turn has already been nudged; it resets when the round count drops below the
@@ -145,7 +135,7 @@ function scanTurn(messages: ReadonlyArray<Message>): {
 }
 
 const postToolUse: PluginHookFn<PostToolUseContext> = async (ctx) => {
-  if (!WEAK_MODEL_PATTERN.test(ctx.model)) return;
+  if (!isWeakOpenModel(ctx.model)) return;
 
   const { rounds, taskProgressShown } = scanTurn(ctx.messages);
 

package/src/plugins/defaults/title-generate/hooks/stop.ts

@@ -1,16 +1,16 @@
 /**
- * Default `stop` hook: triggers the second-pass conversation-title
- * regeneration once a conversation has accumulated enough context.
+ * Default `stop` hook: triggers conversation-title retry/regeneration once a
+ * conversation has accumulated useful context.
  *
  * The first title is generated from the opening prompt alone (see
  * `./user-prompt-submit.ts`). After a few exchanges the conversation's real
  * topic is usually clearer, so a single second pass re-titles using the most
- * recent messages. This hook is the trigger — it fires the regeneration when
- * the conversation reaches its third user turn — and delegates the title
- * itself to the service (`memory/conversation-title-service.ts`), which
- * re-checks that the title is still auto-generated, resolves the title
- * provider, persists, and broadcasts the `conversation_title_updated` /
- * `sync_changed` events.
+ * recent messages. This hook is the trigger — it retries placeholder titles
+ * after successful turns and fires the second-pass regeneration when the
+ * conversation reaches its third user turn. The service
+ * (`memory/conversation-title-service.ts`) re-checks that the title is still
+ * auto-generated, resolves the title provider, persists, and broadcasts the
+ * `conversation_title_updated` / `sync_changed` events.
  *
  * Turn count is read from history rather than an external counter: the number
  * of genuine user prompts — user-role messages that aren't purely tool results
@@ -22,7 +22,11 @@ import type { PluginHookFn, StopContext } from "@vellumai/plugin-api";
 
 import { getConfig } from "../../../../config/loader.js";
 import { getConversation } from "../../../../memory/conversation-crud.js";
-import { queueRegenerateConversationTitle } from "../../../../memory/conversation-title-service.js";
+import {
+  AUTO_TITLE_DETERMINISTIC,
+  isReplaceableTitle,
+  queueRegenerateConversationTitle,
+} from "../../../../memory/conversation-title-service.js";
 import type { Message } from "../../../../providers/types.js";
 
 /**
@@ -50,37 +54,68 @@ function countUserTurns(messages: ReadonlyArray<Message>): number {
   return turns;
 }
 
+function shouldRetryFallbackTitle(conversation: {
+  title: string | null;
+  isAutoTitle: number;
+}): boolean {
+  if (!conversation.isAutoTitle) return false;
+  return (
+    isReplaceableTitle(conversation.title) ||
+    conversation.isAutoTitle === AUTO_TITLE_DETERMINISTIC
+  );
+}
+
 const stop: PluginHookFn<StopContext> = async (ctx) => {
   // Re-title only at a genuine successful turn end (the model returned a reply
   // with no tool calls). Any other terminal — a provider rejection, abort, or
   // an output-limit cutoff — produced no new topic to re-title from.
   if (ctx.exitReason !== "no_tool_calls") return;
 
-  if (getConfig().conversations.skipAutoRetitling) return;
-
-  if (countUserTurns(ctx.messages) !== SECOND_PASS_USER_TURN) return;
+  const userTurns = countUserTurns(ctx.messages);
+  if (userTurns === 0) return;
 
   // System conversations (background/scheduled) keep their deterministic
   // bootstrap title — multi-prompt background jobs can reach three user-role
   // turns with no human present, and a refined LLM title isn't worth the
   // tokens there. The lookup fails open: on a read error the hook behaves as
   // before (queues regeneration; the service re-checks isAutoTitle).
+  let retryFallbackTitle = false;
   try {
     const conversation = getConversation(ctx.conversationId);
     if (conversation && conversation.conversationType !== "standard") return;
+    retryFallbackTitle = conversation
+      ? shouldRetryFallbackTitle(conversation)
+      : false;
   } catch {
     // Fall through to queueing.
   }
 
-  const { conversationId } = ctx;
-  // Deferred to a later macrotask so the just-completed turn's persistence
-  // settles first. The service regenerates from the most recent stored
-  // messages, so it must run after the reply is persisted to reflect it. The
-  // service is itself fire-and-forget and re-checks replaceability, owning
-  // provider resolution, persistence, and the resulting broadcast.
-  setTimeout(() => {
-    queueRegenerateConversationTitle({ conversationId });
-  }, 0);
+  if (
+    userTurns === SECOND_PASS_USER_TURN &&
+    !getConfig().conversations.skipAutoRetitling
+  ) {
+    const { conversationId } = ctx;
+    // Deferred to a later macrotask so the just-completed turn's persistence
+    // settles first. The service regenerates from the most recent stored
+    // messages, so it must run after the reply is persisted to reflect it. The
+    // service is itself fire-and-forget and re-checks replaceability, owning
+    // provider resolution, persistence, and the resulting broadcast.
+    setTimeout(() => {
+      queueRegenerateConversationTitle({ conversationId });
+    }, 0);
+    return;
+  }
+
+  if (retryFallbackTitle) {
+    const { conversationId } = ctx;
+    setTimeout(() => {
+      queueRegenerateConversationTitle({
+        conversationId,
+        onlyIfReplaceable: true,
+      });
+    }, 0);
+    return;
+  }
 };
 
 export default stop;

package/src/prompts/persona-resolver.ts

@@ -96,13 +96,23 @@ function resolveUserFilename(
         filename = contactWithChannels.userFile ?? null;
       } else if (trustContext.trustClass === "guardian") {
         // Managed desktop: the JWT principal ID used as requesterExternalUserId
-        // may differ from the contact channel's external_user_id (they are
-        // separate identity concepts). Fall back to the channel-type guardian.
+        // may differ from the contact channel's address (they are separate
+        // identity concepts). Fall back to the channel-type guardian.
         const guardian = findGuardianForChannel(trustContext.sourceChannel);
         if (guardian) {
           filename = guardian.contact.userFile ?? "guardian.md";
         }
       }
+    } else if (trustContext.trustClass === "guardian") {
+      // Guardian-trust turn carrying no requester identity — background and
+      // scheduled turns (heartbeat, scheduled pulses) run under the guardian
+      // trust class but have no per-actor address to look up. Resolve the
+      // channel's guardian user file so they load the same persona as a
+      // foreground guardian turn instead of falling back to users/default.md.
+      const guardian = findGuardianForChannel(trustContext.sourceChannel);
+      if (guardian) {
+        filename = guardian.contact.userFile ?? "guardian.md";
+      }
     }
   } catch (err) {
     // Contacts table may be absent — happens during early bootstrap

package/src/prompts/templates/system-sections.ts

@@ -259,6 +259,13 @@ Meet your user where they are. If they are nontechnical, prefer "Gmail needs rec
 Err toward brevity; expand only when the user follows up or their style calls for more.
 
 These are default guidelines. Always prioritize communication preferences that you've established through your relationship with your human.
+`,
+  },
+  {
+    id: "01-delegate-subagents",
+    body: `## Delegate independent work
+
+When part of a task can run on its own — a research sweep, a multi-file investigation, a build-and-test loop — hand it off instead of grinding through it inline: load the \`subagent\` skill, then \`subagent_spawn\` early and in parallel. Make delegating that kind of work your default, not a last resort; an unnecessary subagent is cheaper than serialized work, and a long inline dig floods your own context.
 `,
   },
   {
@@ -267,8 +274,6 @@ These are default guidelines. Always prioritize communication preferences that y
 Batch independent tool calls into the same response. An extra LLM round trip costs orders of magnitude more than a few wasted tool calls — err on the side of parallelizing when calls are independent. Reading multiple files, \`glob\`/\`grep\`, \`ls\`, \`git status\`/\`diff\`/\`log\`, type-checks, and tests should be batched.
 
 Before emitting a single tool call, ask whether your next turn would be another tool call that doesn't consume this one's output — if so, they belong together. Serialized tool calls without a real data dependency are a bug.
-
-For non-trivial independent workstreams — research, coding, multi-step investigations — delegate to subagents (load the \`subagent\` skill) and spawn them early and in parallel; an unnecessary subagent is cheaper than serialized work.
 </use_parallel_tool_calls>
 `,
   },

package/src/providers/__tests__/provider-env-vars.test.ts

@@ -35,6 +35,7 @@ describe("getLlmProviderEnvVar", () => {
     expect(getLlmProviderEnvVar("brave")).toBeUndefined();
     expect(getLlmProviderEnvVar("perplexity")).toBeUndefined();
     expect(getLlmProviderEnvVar("tavily")).toBeUndefined();
+    expect(getLlmProviderEnvVar("firecrawl")).toBeUndefined();
   });
 
   test("returns undefined for unknown provider", () => {
@@ -55,6 +56,10 @@ describe("getSearchProviderEnvVar", () => {
     expect(getSearchProviderEnvVar("tavily")).toBe("TAVILY_API_KEY");
   });
 
+  test("returns FIRECRAWL_API_KEY for firecrawl", () => {
+    expect(getSearchProviderEnvVar("firecrawl")).toBe("FIRECRAWL_API_KEY");
+  });
+
   test("returns undefined for LLM providers (out of scope)", () => {
     expect(getSearchProviderEnvVar("anthropic")).toBeUndefined();
     expect(getSearchProviderEnvVar("openai")).toBeUndefined();
@@ -75,6 +80,7 @@ describe("getAnyProviderEnvVar", () => {
     expect(getAnyProviderEnvVar("brave")).toBe("BRAVE_API_KEY");
     expect(getAnyProviderEnvVar("perplexity")).toBe("PERPLEXITY_API_KEY");
     expect(getAnyProviderEnvVar("tavily")).toBe("TAVILY_API_KEY");
+    expect(getAnyProviderEnvVar("firecrawl")).toBe("FIRECRAWL_API_KEY");
   });
 
   test("returns undefined for ollama (keyless LLM provider)", () => {

package/src/providers/__tests__/provider-secret-catalog.test.ts

@@ -44,5 +44,6 @@ describe("API_KEY_PROVIDERS", () => {
     expect(API_KEY_PROVIDERS).toContain("brave");
     expect(API_KEY_PROVIDERS).toContain("perplexity");
     expect(API_KEY_PROVIDERS).toContain("tavily");
+    expect(API_KEY_PROVIDERS).toContain("firecrawl");
   });
 });