@vellumai/assistant 0.10.2 → 0.10.3-dev.202606252046.9075fd5

package/src/plugins/pipeline.ts

@@ -4,9 +4,10 @@
  * A "hook" is a named lifecycle event (`user-prompt-submit`, `post-tool-use`,
  * ...) that every registered plugin may handle. The runner walks each plugin's
  * hook for a given event in registration order, threading a context value
- * through the chain so hooks can observe and transform it. A hook either
- * mutates the context in place (returning `void`) or returns a partial
- * context whose fields are merged onto the threaded value.
+ * through the chain so hooks can observe and transform it. Each hook receives
+ * an isolated draft of the current context. A hook either mutates the draft in
+ * place (returning `void`) or returns a partial context whose fields are merged
+ * onto the draft. Failed hook drafts are discarded.
  *
  * `getHooksFor` is now async — it pulls user-land hooks from the mtime
  * cache (filesystem-as-truth) and default plugin hooks from the registry
@@ -16,34 +17,131 @@
  */
 
 import type { HookName } from "../plugin-api/constants.js";
+import { getLogger } from "../util/logger.js";
 import { getHooksFor } from "./registry.js";
+import type { HookFunction } from "./types.js";
 
 // ─── Hook runner ────────────────────────────────────────────────────────────
 
+const log = getLogger("plugin-pipeline");
+
+function isPluginLogger(value: unknown): value is {
+  info: unknown;
+  warn: unknown;
+  error: unknown;
+  debug: unknown;
+} {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    typeof (value as { info?: unknown }).info === "function" &&
+    typeof (value as { warn?: unknown }).warn === "function" &&
+    typeof (value as { error?: unknown }).error === "function" &&
+    typeof (value as { debug?: unknown }).debug === "function"
+  );
+}
+
+function isPlainObject(value: object): boolean {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function cloneHookValue<T>(value: T, seen = new WeakMap<object, unknown>()): T {
+  if (value === null || typeof value !== "object") return value;
+  if (value instanceof Error || isPluginLogger(value)) return value;
+
+  const existing = seen.get(value);
+  if (existing !== undefined) return existing as T;
+
+  if (Array.isArray(value)) {
+    const copy: unknown[] = [];
+    seen.set(value, copy);
+    for (const item of value) {
+      copy.push(cloneHookValue(item, seen));
+    }
+    return copy as T;
+  }
+
+  if (value instanceof Date) {
+    return new Date(value.getTime()) as T;
+  }
+
+  if (value instanceof Map) {
+    const copy = new Map();
+    seen.set(value, copy);
+    for (const [key, mapValue] of value) {
+      copy.set(cloneHookValue(key, seen), cloneHookValue(mapValue, seen));
+    }
+    return copy as T;
+  }
+
+  if (value instanceof Set) {
+    const copy = new Set();
+    seen.set(value, copy);
+    for (const item of value) {
+      copy.add(cloneHookValue(item, seen));
+    }
+    return copy as T;
+  }
+
+  if (!isPlainObject(value)) return value;
+
+  const copy: Record<PropertyKey, unknown> = {};
+  seen.set(value, copy);
+  for (const key of Reflect.ownKeys(value)) {
+    copy[key] = cloneHookValue(
+      (value as Record<PropertyKey, unknown>)[key],
+      seen,
+    );
+  }
+  return copy as T;
+}
+
 /**
  * Execute a hook chain: walk every registered plugin's hook for `name` in
  * registration order, threading `initialCtx` through each. Hooks may either
- * mutate the context in place (returning `void`) or return a partial context
- * whose fields are merged onto the threaded value — keys the hook returns
- * overwrite the running context, every other field is preserved. The final
- * context after the chain settles is returned.
+ * mutate their draft context in place (returning `void`) or return a partial
+ * context whose fields are merged onto the draft — keys the hook returns
+ * overwrite the running context, every other field is preserved. If a hook
+ * throws, its draft is discarded and the next hook receives the last
+ * successfully committed context. The final context after the chain settles is
+ * returned.
  *
  * @param name        The hook identifier — pick one from {@link HOOKS}.
  * @param initialCtx  Context the first hook receives.
  * @returns The final context after the chain settles. Same reference as
- *          `initialCtx` when no plugin registers `name`, and when every
- *          chained hook returns `void` (mutation-in-place style).
+ *          `initialCtx` when no plugin registers `name`.
  */
 export async function runHook<TCtx>(
   name: HookName,
   initialCtx: TCtx,
 ): Promise<TCtx> {
-  const hooks = await getHooksFor<TCtx>(name);
+  let hooks: HookFunction<TCtx>[];
+  try {
+    hooks = await getHooksFor<TCtx>(name);
+  } catch (err) {
+    log.error(
+      { err, hookName: name },
+      "plugin hook discovery failed — proceeding without hooks",
+    );
+    return initialCtx;
+  }
+
   let active = initialCtx;
   for (const hook of hooks) {
-    const result = await hook(active);
-    if (result !== undefined) {
-      active = { ...active, ...result };
+    const draft = cloneHookValue(active);
+    try {
+      const result = await hook(draft);
+      if (result !== undefined) {
+        active = { ...draft, ...result };
+      } else {
+        active = draft;
+      }
+    } catch (err) {
+      log.error(
+        { err, hookName: name },
+        "plugin hook failed — proceeding with current context",
+      );
     }
   }
   return active;

package/src/plugins/registry.ts

@@ -19,11 +19,12 @@
  * Design doc: `.private/plans/agent-plugin-system.md`.
  */
 
+import { isPluginDisabled } from "./disabled-state.js";
 import { getUserHooksFor } from "./mtime-cache.js";
 import {
+  type HookFunction,
   type Plugin,
   PluginExecutionError,
-  type PluginHookFn,
 } from "./types.js";
 
 // ─── Internal state ──────────────────────────────────────────────────────────
@@ -35,6 +36,25 @@ import {
  */
 const registeredPlugins = new Map<string, Plugin>();
 
+/**
+ * Hook registry — the per-surface registry for default plugin hooks. Each
+ * hook name maps to an ordered list of `{fn, pluginName}` entries, one per
+ * plugin that contributes that hook. The list order matches registration
+ * order (i.e. {@link getAllDefaultPlugins} array order), which fixes
+ * hook-chain ordering the same way the old `registeredPlugins` map did.
+ *
+ * Populated by {@link registerPlugin} alongside `registeredPlugins` and
+ * depleted by {@link unregisterPlugin}. {@link getHooksFor} reads from this
+ * map (not `registeredPlugins`) so it can filter disabled plugins at read
+ * time via {@link isPluginDisabled} — the key mechanism that makes
+ * `assistant plugins disable default-*` take effect immediately in a
+ * running assistant.
+ */
+const hookRegistry = new Map<
+  string,
+  Array<{ fn: HookFunction; pluginName: string }>
+>();
+
 /**
  * Latch that closes the per-boot registration window. Flipped to `true` by
  * {@link closeRegistration} once `loadUserPlugins()` has returned. After that,
@@ -126,6 +146,22 @@ export function registerPlugin(plugin: Plugin): void {
   }
 
   registeredPlugins.set(name, plugin);
+
+  // Register each hook into the per-surface hook registry. `getHooksFor`
+  // reads from this map (filtered by `isPluginDisabled`) rather than from
+  // `registeredPlugins`, so toggling the `.disabled` sentinel at runtime
+  // takes effect on the next turn without mutating the plugin registry.
+  if (plugin.hooks) {
+    for (const [hookName, fn] of Object.entries(plugin.hooks)) {
+      if (typeof fn !== "function") continue;
+      let list = hookRegistry.get(hookName);
+      if (!list) {
+        list = [];
+        hookRegistry.set(hookName, list);
+      }
+      list.push({ fn: fn as HookFunction, pluginName: name });
+    }
+  }
 }
 
 // ─── Queries ─────────────────────────────────────────────────────────────────
@@ -151,20 +187,22 @@ export function getRegisteredPlugins(): Plugin[] {
  * files. First-party default plugin hooks are read synchronously from the
  * registry and prepended.
  *
- * The `TCtx` generic mirrors {@link PluginHookFn}'s — callers parameterize
+ * The `TCtx` generic mirrors {@link HookFunction}'s — callers parameterize
  * over the concrete context type their hook receives. Hooks that mutate
  * the context in place return `void`; hooks that return a new context
  * replace the threaded value for the next hook in the chain.
  */
 export async function getHooksFor<TCtx = unknown>(
   name: string,
-): Promise<PluginHookFn<TCtx>[]> {
-  // First-party defaults from the registry (synchronous).
-  const defaultHooks: PluginHookFn<TCtx>[] = [];
-  for (const plugin of registeredPlugins.values()) {
-    const hook = plugin.hooks?.[name];
-    if (hook) {
-      defaultHooks.push(hook as PluginHookFn<TCtx>);
+): Promise<HookFunction<TCtx>[]> {
+  // First-party defaults from the hook registry, filtered by the `.disabled`
+  // sentinel at read time. This is what makes `assistant plugins disable
+  // default-*` take effect immediately in a running assistant: the hooks stay
+  // registered but are filtered out on the next turn.
+  const defaultHooks: HookFunction<TCtx>[] = [];
+  for (const entry of hookRegistry.get(name) ?? []) {
+    if (!isPluginDisabled(entry.pluginName)) {
+      defaultHooks.push(entry.fn as HookFunction<TCtx>);
     }
   }
 
@@ -199,14 +237,18 @@ export function closeRegistration(): void {
  */
 export function unregisterPlugin(name: string): void {
   registeredPlugins.delete(name);
-}
-
-export function getRegisteredPlugin(name: string): Plugin | undefined {
-  return registeredPlugins.get(name);
-}
 
-export function setRegisteredPlugin(plugin: Plugin): void {
-  registeredPlugins.set(plugin.manifest.name, plugin);
+  // Remove all hooks contributed by this plugin from the hook registry.
+  // Used by the bootstrap failure path (init threw) and the feature-flag
+  // skip path — both are boot-time decisions where the plugin's hooks should
+  // never participate in the turn lifecycle.
+  for (const [, list] of hookRegistry) {
+    for (let i = list.length - 1; i >= 0; i--) {
+      if (list[i]!.pluginName === name) {
+        list.splice(i, 1);
+      }
+    }
+  }
 }
 
 // ─── Test hooks ──────────────────────────────────────────────────────────────
@@ -228,6 +270,7 @@ export function resetPluginRegistryForTests(): void {
     );
   }
   registeredPlugins.clear();
+  hookRegistry.clear();
   // Re-open the registration window so subsequent tests can register plugins
   // again. Without this, the latch set by a prior `closeRegistration()` call
   // would leak across test cases and reject legitimate registrations.

package/src/plugins/surface-import.ts

@@ -0,0 +1,121 @@
+/**
+ * Shared low-level import machinery for user-surface files (plugin tools,
+ * plugin hooks, and standalone workspace hooks).
+ *
+ * Both the plugin/tool cache (`mtime-cache.ts`) and the hook cache
+ * (`../hooks/hook-loader.ts`) re-import surface files keyed by mtime. This
+ * module owns the pieces they share — mtime stat, the per-process import
+ * timeout, and a timeout-guarded, concurrency-deduplicated dynamic import —
+ * so neither surface duplicates the logic and the import-timeout knob is
+ * configured in exactly one place.
+ *
+ * Kept dependency-light (only the logger and `importDefault`) so it can sit
+ * below both caches without introducing an import cycle.
+ */
+
+import { statSync } from "node:fs";
+
+import { getLogger } from "../util/logger.js";
+import { importDefault } from "./external-plugin-loader.js";
+
+const log = getLogger("surface-import");
+
+/**
+ * Per-process upper bound on how long a single surface import may take.
+ * Set once at boot by `populateCacheAtBoot`; read by every re-import. A
+ * plugin/hook with a hanging top-level `await` is skipped rather than
+ * blocking the daemon.
+ */
+let importTimeoutMs = 10_000;
+
+/** Override the surface import timeout (called once at boot). */
+export function setSurfaceImportTimeout(ms: number): void {
+  importTimeoutMs = ms;
+}
+
+/** Current surface import timeout in milliseconds. */
+export function getSurfaceImportTimeout(): number {
+  return importTimeoutMs;
+}
+
+/**
+ * Get the mtimeMs of a file, or 0 if the file doesn't exist or can't be
+ * stat'd. Callers treat 0 as "absent" (cache-evict / skip).
+ */
+export function getMtime(filePath: string): number {
+  try {
+    return statSync(filePath).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * In-flight import promises, keyed by file path. Prevents duplicate
+ * `import()` calls when multiple readers request the same surface
+ * concurrently.
+ */
+const inflight = new Map<string, Promise<unknown>>();
+
+/**
+ * Import a module's default export with a timeout. If the import doesn't
+ * resolve within `timeoutMs`, logs a warning and returns `undefined` so a
+ * hanging module doesn't block daemon startup indefinitely. Defaults to the
+ * module-level {@link getSurfaceImportTimeout}.
+ */
+export async function importWithTimeout<T>(
+  filePath: string,
+  timeoutMs: number = importTimeoutMs,
+): Promise<T | undefined> {
+  let timeoutHandle: ReturnType<typeof setTimeout> | undefined;
+  try {
+    const timeoutSentinel = Symbol("import-timeout");
+    const importPromise = importWithDedup<T>(filePath);
+    const timeoutPromise = new Promise<typeof timeoutSentinel>((resolve) => {
+      timeoutHandle = setTimeout(() => resolve(timeoutSentinel), timeoutMs);
+    });
+    const result = await Promise.race([importPromise, timeoutPromise]);
+    if (result === timeoutSentinel) {
+      importPromise.catch(() => {
+        /* swallow — late rejection from abandoned import */
+      });
+      log.warn(
+        { filePath, timeoutMs },
+        `Import timed out after ${timeoutMs}ms — skipping surface`,
+      );
+      return undefined;
+    }
+    return result as T;
+  } finally {
+    if (timeoutHandle !== undefined) clearTimeout(timeoutHandle);
+  }
+}
+
+/**
+ * Import a module's default export, deduplicating concurrent imports for
+ * the same file path. This prevents two readers from triggering duplicate
+ * `import()` calls when they request the same surface simultaneously.
+ *
+ * Note: Bun caches `import()` by resolved path within a process and does not
+ * bust on query-string or hash changes, so the dedup is about avoiding
+ * redundant async work, not cache-busting. A content edit to an existing
+ * file is only picked up after a process restart (added and removed files
+ * are picked up live, since discovery is by directory listing).
+ */
+async function importWithDedup<T>(filePath: string): Promise<T> {
+  let promise = inflight.get(filePath);
+  if (promise === undefined) {
+    promise = importDefault<T>(filePath);
+    inflight.set(filePath, promise);
+  }
+  try {
+    return (await promise) as T;
+  } finally {
+    inflight.delete(filePath);
+  }
+}
+
+/** Clear in-flight import state. Test-only. */
+export function clearSurfaceImportInflight(): void {
+  inflight.clear();
+}

package/src/plugins/types.ts

@@ -19,7 +19,7 @@ import type {
 } from "../daemon/conversation-runtime-assembly.js";
 import type { TrustContext } from "../daemon/trust-context.js";
 import type { ConversationGraphMemory } from "../memory/graph/conversation-graph-memory.js";
-import type { PluginHookFn } from "../plugin-api/types.js";
+import type { HookFunction } from "../plugin-api/types.js";
 import type { Message } from "../providers/types.js";
 import type { SkillRoute } from "../runtime/skill-route-registry.js";
 import type { Tool } from "../tools/types.js";
@@ -47,8 +47,6 @@ export interface PluginManifest {
    * own version at load time.
    */
   version: string;
-  /** Credential keys the plugin needs resolved before `init()` runs. */
-  requiresCredential?: string[];
   /**
    * Assistant feature-flag keys that must all be enabled for this plugin to
    * activate. Checked by `bootstrapPlugins` via `isAssistantFeatureFlagEnabled`
@@ -69,9 +67,9 @@ export interface PluginManifest {
 // existing internal call sites keep working. Plugin authors import these from
 // `@vellumai/plugin-api`.
 export type {
-  PluginHookFn,
-  PluginInitContext,
-  PluginShutdownContext,
+  HookFunction,
+  InitContext,
+  ShutdownContext,
 } from "../plugin-api/types.js";
 
 // ─── Memory-graph result ─────────────────────────────────────────────────────
@@ -345,14 +343,14 @@ export type PluginRouteRegistration = SkillRoute;
  * unknown keys are forward-compat scaffolding.
  *
  * See `assistant/src/daemon/external-plugins-bootstrap.ts` for the
- * full lifecycle, and {@link PluginHookFn} for the per-entry signature.
+ * full lifecycle, and {@link HookFunction} for the per-entry signature.
  */
 // The map stores hooks for arbitrary keys with arbitrary context shapes.
 // `any` (rather than `unknown`) is required so concrete plugin signatures
-// like `(ctx: PluginInitContext) => Promise<void>` and `() => Promise<void>`
+// like `(ctx: InitContext) => Promise<void>` and `() => Promise<void>`
 // both assign in/out of slot entries under strict-function-types contravariance.
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type PluginHooks = Record<string, PluginHookFn<any>>;
+export type PluginHooks = Record<string, HookFunction<any>>;
 
 /**
  * A registered plugin. Every field besides `manifest` is optional — a plugin

package/src/prompts/persona-resolver.ts

@@ -1,11 +1,14 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, join } from "node:path";
 
+import type { GuardianDelivery } from "@vellumai/gateway-client";
+
+import { findContactByAddress } from "../contacts/contact-store.js";
 import {
-  findContactByAddress,
-  findGuardianForChannel,
-  listGuardianChannels,
-} from "../contacts/contact-store.js";
+  anyGuardian,
+  guardianForChannel,
+  peekCachedGuardianDelivery,
+} from "../contacts/guardian-delivery-reader.js";
 import type { ChannelCapabilities } from "../daemon/conversation-runtime-assembly.js";
 import type { TrustContext } from "../daemon/trust-context.js";
 import { getLogger } from "../util/logger.js";
@@ -87,8 +90,38 @@ function resolveGuardianUserFile(trustContext: TrustContext): string | null {
       return guardianContact.userFile ?? "guardian.md";
     }
   }
-  const guardian = findGuardianForChannel(trustContext.sourceChannel);
-  return guardian ? (guardian.contact.userFile ?? "guardian.md") : null;
+  const guardian = peekGuardianForChannel(trustContext.sourceChannel);
+  return guardian ? (guardianDeliveryUserFile(guardian) ?? "guardian.md") : null;
+}
+
+/**
+ * Resolve the local INFO `userFile` for a gateway guardian delivery. The
+ * gateway carries identity (channel + address) but not local INFO, so we join
+ * the local contact by the guardian's channel address. Returns `undefined` when
+ * no local contact matches.
+ */
+function guardianDeliveryUserFile(
+  guardian: GuardianDelivery,
+): string | undefined {
+  const contact = findContactByAddress(
+    guardian.channelType,
+    guardian.address,
+  );
+  return contact?.userFile ?? undefined;
+}
+
+/** Active guardian for a channel from the IO-free delivery cache. */
+function peekGuardianForChannel(
+  channelType: string,
+): GuardianDelivery | undefined {
+  const cached = peekCachedGuardianDelivery({ channelTypes: [channelType] });
+  return cached ? guardianForChannel(cached, channelType) : undefined;
+}
+
+/** First guardian across all channels from the IO-free delivery cache. */
+function peekAnyGuardian(): GuardianDelivery | undefined {
+  const cached = peekCachedGuardianDelivery();
+  return cached ? anyGuardian(cached) : undefined;
 }
 
 /**
@@ -102,12 +135,11 @@ function resolveUserFilename(
 
   try {
     if (trustContext === undefined) {
-      // Desktop / native (no gateway) — resolve via guardian contact,
-      // preferring the vellum-channel guardian when multiple exist.
-      const vellumGuardian = findGuardianForChannel("vellum");
-      const guardian = vellumGuardian ?? listGuardianChannels();
+      // Desktop / native — resolve via the gateway guardian delivery cache,
+      // preferring the vellum-channel guardian, then any guardian.
+      const guardian = peekGuardianForChannel("vellum") ?? peekAnyGuardian();
       if (guardian) {
-        filename = guardian.contact.userFile ?? "guardian.md";
+        filename = guardianDeliveryUserFile(guardian) ?? "guardian.md";
       }
     } else if (trustContext.requesterExternalUserId) {
       // Channel-routed request — look up contact by channel identity

package/src/providers/anthropic/client.ts

@@ -786,6 +786,11 @@ export class AnthropicProvider implements Provider {
     this.useNativeWebSearch = options.useNativeWebSearch ?? false;
   }
 
+  /** See {@link Provider.supportsNativeWebSearch}. */
+  get supportsNativeWebSearch(): boolean {
+    return this.useNativeWebSearch;
+  }
+
   async sendMessage(
     messages: Message[],
     options?: SendMessageOptions,

package/src/providers/call-site-routing.ts

@@ -34,6 +34,7 @@ import {
 } from "./connection-resolution.js";
 import { listConnections } from "./inference/connections.js";
 import type { ProvidersConfig } from "./registry.js";
+import { shouldUseNativeWebSearch } from "./registry.js";
 import type {
   Message,
   Provider,
@@ -43,6 +44,9 @@ import type {
 
 export class CallSiteRoutingProvider implements Provider {
   public readonly tokenEstimationProvider?: string;
+  // Forward native web-search capability so it survives the wrapper chain
+  // (callers like the advisor consult gate on it). Fixed at construction.
+  public readonly supportsNativeWebSearch?: boolean;
 
   // Per-call async context that tracks which provider is currently executing.
   // Using AsyncLocalStorage instead of a plain instance field means concurrent
@@ -94,6 +98,7 @@ export class CallSiteRoutingProvider implements Provider {
     ) => Promise<Provider | null>,
   ) {
     this.tokenEstimationProvider = defaultProvider.tokenEstimationProvider;
+    this.supportsNativeWebSearch = defaultProvider.supportsNativeWebSearch;
     if (defaultProvider.countInputTokens) {
       this.countInputTokens =
         defaultProvider.countInputTokens.bind(defaultProvider);
@@ -126,6 +131,46 @@ export class CallSiteRoutingProvider implements Provider {
       : doSend();
   }
 
+  /**
+   * Native web-search capability of the provider/model THIS call routes to.
+   *
+   * `selectProvider` picks the transport from the routed connection, but each
+   * leaf provider's static `supportsNativeWebSearch` was fixed to the DEFAULT
+   * (provider, model) at boot. Resolving the call-site here — same
+   * `resolveCallSiteConfig` inputs `selectProvider` uses — and recomputing
+   * `shouldUseNativeWebSearch(resolved.provider, resolved.model)` yields the
+   * capability of the routed target instead of the construction-time default.
+   *
+   * Falls back to the default provider's static flag when no `callSite` is set
+   * (the legacy short-circuit `selectProvider` also takes).
+   *
+   * Known limitation: this reports the *resolved* target's capability and does
+   * not replay `selectProvider`'s async soft-credential fallback. If the routed
+   * connection has a transient credential failure at send time, `selectProvider`
+   * falls back to the default provider while this probe still reports the routed
+   * target — so a non-native default + native routed target with a credential
+   * blip can attach `web_search` to the fallback non-native provider. The probe
+   * stays sync (the loop assembles tools synchronously) and the worst case is
+   * bounded: the advisor consult that hits it degrades benignly (the unhandled
+   * tool surfaces as a caught failure → "(advisor unavailable)"), not a crash.
+   */
+  supportsNativeWebSearchFor(options?: SendMessageOptions): boolean {
+    const callSite = options?.config?.callSite;
+    if (!callSite) {
+      return this.defaultProvider.supportsNativeWebSearch === true;
+    }
+    const resolved = resolveCallSiteConfig(callSite, getConfig().llm, {
+      overrideProfile: options?.config?.overrideProfile,
+      forceOverrideProfile: options?.config?.forceOverrideProfile,
+      selectionSeed: options?.config?.selectionSeed,
+    });
+    return shouldUseNativeWebSearch(
+      getConfig(),
+      resolved.provider,
+      resolved.model,
+    );
+  }
+
   /**
    * Pick the provider to route this call through.
    *

package/src/providers/model-catalog.ts

@@ -760,6 +760,22 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
         maxEffort: "max",
         pricing: { inputPer1mTokens: 1.74, outputPer1mTokens: 3.48 },
       },
+      {
+        id: "accounts/fireworks/models/deepseek-v4-flash",
+        displayName: "DeepSeek V4 Flash",
+        contextWindowTokens: 1040000,
+        maxOutputTokens: 131072,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: false,
+        supportsToolUse: true,
+        maxEffort: "max",
+        pricing: {
+          inputPer1mTokens: 0.14,
+          outputPer1mTokens: 0.28,
+          cacheReadPer1mTokens: 0.03,
+        },
+      },
     ],
     defaultModel: "accounts/fireworks/models/kimi-k2p5",
     apiKeyUrl: "https://fireworks.ai/account/api-keys",