@strav/brain 1.0.0-alpha.9 → 1.0.1

package/src/brain_config.ts

@@ -16,6 +16,7 @@
  * that want every long request to cache flip this to `true`.
  */
 
+import type { MCPServer } from './mcp_server.ts'
 import type { ModelTier } from './types.ts'
 
 /** Anthropic-specific driver config. */
@@ -33,7 +34,216 @@ export interface AnthropicProviderConfig {
   betas?: readonly string[]
 }
 
-export type ProviderConfig = AnthropicProviderConfig // | OpenAIProviderConfig | … (later slices)
+/**
+ * OpenAI Responses API driver config — backed by the `openai`
+ * SDK's `client.responses.create` endpoint. Use when you need
+ * OpenAI's server-side tools (web search, code interpreter) or
+ * the Responses API's reasoning surfaces. The chat completions
+ * provider (`driver: 'openai'`) covers everything else.
+ */
+export interface OpenAIResponsesProviderConfig {
+  driver: 'openai-responses'
+  /** API key. Required. Most apps source from `env('OPENAI_API_KEY')`. */
+  apiKey: string
+  /** Optional override of the SDK's base URL. */
+  baseUrl?: string
+  /** Optional organization id. */
+  organization?: string
+  /** Default model. Defaults to `gpt-5`. */
+  defaultModel?: string
+  /** Default `max_output_tokens`. Defaults to 4096. */
+  defaultMaxTokens?: number
+  /** Default embedding model (inherited from chat completions endpoint). Defaults to `text-embedding-3-small`. */
+  defaultEmbedModel?: string
+  /** Default audio-transcription model. Defaults to `whisper-1`. */
+  defaultTranscribeModel?: string
+}
+
+/** OpenAI-specific driver config. */
+export interface OpenAIProviderConfig {
+  driver: 'openai'
+  /** API key. Required. Most apps source from `env('OPENAI_API_KEY')`. */
+  apiKey: string
+  /** Optional override of the SDK's base URL — useful for proxies, Azure OpenAI, or test doubles. */
+  baseUrl?: string
+  /** Optional organization id. */
+  organization?: string
+  /** Default model when neither `options.model` nor `options.tier` is passed. Defaults to `gpt-5`. */
+  defaultModel?: string
+  /** Default `max_tokens` for `chat()` calls that don't specify one. */
+  defaultMaxTokens?: number
+  /** Default embedding model for `brain.embed(...)`. Defaults to `text-embedding-3-small`. */
+  defaultEmbedModel?: string
+  /** Default audio-transcription model for `brain.transcribe(...)`. Defaults to `whisper-1`. */
+  defaultTranscribeModel?: string
+}
+
+/** Google (Gemini) driver config — backed by `@google/genai`. */
+export interface GeminiProviderConfig {
+  driver: 'google'
+  /** API key. Required. Most apps source from `env('GOOGLE_API_KEY')` or `env('GEMINI_API_KEY')`. */
+  apiKey: string
+  /** Optional override of the SDK's base URL — useful for proxies or test doubles. */
+  baseUrl?: string
+  /** Default model when neither `options.model` nor `options.tier` is passed. Defaults to `gemini-2.5-flash`. */
+  defaultModel?: string
+  /** Default `max_tokens` for `chat()` calls that don't specify one. */
+  defaultMaxTokens?: number
+  /** Optional API version pin (`v1` / `v1beta`). */
+  apiVersion?: string
+  /** Default embedding model for `brain.embed(...)`. Defaults to `text-embedding-004`. */
+  defaultEmbedModel?: string
+}
+
+/** DeepSeek driver config — backed by the `openai` SDK pointed at DeepSeek's OpenAI-compatible endpoint. */
+export interface DeepSeekProviderConfig {
+  driver: 'deepseek'
+  /** API key. Required. Most apps source from `env('DEEPSEEK_API_KEY')`. */
+  apiKey: string
+  /** Optional override of the SDK's base URL. Defaults to `https://api.deepseek.com/v1`. */
+  baseUrl?: string
+  /** Default model when neither `options.model` nor `options.tier` is passed. Defaults to `deepseek-chat`. */
+  defaultModel?: string
+  /** Default `max_tokens` for `chat()` calls that don't specify one. */
+  defaultMaxTokens?: number
+}
+
+/**
+ * Ollama driver config — backed by the `openai` SDK pointed at a
+ * local Ollama server's OpenAI-compatible `/v1` endpoint. The same
+ * shape works against any OpenAI-compatible local server (LM Studio,
+ * llama.cpp's server, vLLM, …) by overriding `baseUrl`.
+ */
+export interface OllamaProviderConfig {
+  driver: 'ollama'
+  /**
+   * Required — model must be already pulled on the Ollama server
+   * (`ollama pull <model>`). No universal default exists because
+   * apps install whichever models they need. Common picks for
+   * tool-calling: `llama3.2`, `llama3.1`, `qwen2.5`, `mistral`.
+   */
+  defaultModel: string
+  /** Optional override of the SDK's base URL. Defaults to `http://localhost:11434/v1`. */
+  baseUrl?: string
+  /**
+   * Optional API key. Ollama doesn't require one — the SDK demands
+   * a non-empty string, so a placeholder is fine and the default
+   * (`'ollama'`) works. Override only when running behind a proxy
+   * that adds its own auth layer.
+   */
+  apiKey?: string
+  /** Default `max_tokens` for `chat()` calls that don't specify one. */
+  defaultMaxTokens?: number
+  /**
+   * Default embedding model for `brain.embed(...)`. No universal
+   * default — apps pull an embedding-tuned model (e.g.
+   * `nomic-embed-text`, `mxbai-embed-large`) and reference it here.
+   * Calls that omit `options.model` without this set throw.
+   */
+  defaultEmbedModel?: string
+  /**
+   * Default audio-transcription model for `brain.transcribe(...)`.
+   * No universal default — Ollama versions vary on whether they
+   * expose a Whisper-style endpoint, and apps pull whatever
+   * model their build supports (e.g. `whisper`). Calls that omit
+   * `options.model` without this set throw.
+   */
+  defaultTranscribeModel?: string
+}
+
+/**
+ * Qwen (Alibaba DashScope) driver config — backed by the `openai`
+ * SDK pointed at DashScope's OpenAI-compatible `/compatible-mode/v1`
+ * endpoint.
+ *
+ * DashScope publishes regional endpoints (Singapore, Beijing, Hong Kong,
+ * US-Virginia). The default is the Singapore endpoint
+ * (`dashscope-intl`) to fit Strav's SEA-first positioning; apps in
+ * other regions override via `baseUrl`.
+ */
+export interface QwenProviderConfig {
+  driver: 'qwen'
+  /** API key. Required. Most apps source from `env('DASHSCOPE_API_KEY')` or `env('QWEN_API_KEY')`. */
+  apiKey: string
+  /**
+   * Optional base URL override. Defaults to the Singapore endpoint
+   * `https://dashscope-intl.aliyuncs.com/compatible-mode/v1`. Other
+   * documented options:
+   *   - `https://dashscope.aliyuncs.com/compatible-mode/v1` (Beijing)
+   *   - `https://dashscope-us.aliyuncs.com/compatible-mode/v1` (US/Virginia)
+   *   - `https://cn-hongkong.dashscope.aliyuncs.com/compatible-mode/v1` (Hong Kong)
+   */
+  baseUrl?: string
+  /** Default model. Defaults to `qwen-plus` (mid-tier; `qwen-turbo` is cheaper, `qwen-max` is heaviest). */
+  defaultModel?: string
+  /** Default `max_tokens` for `chat()` calls that don't specify one. */
+  defaultMaxTokens?: number
+}
+
+/**
+ * MiniMax driver config — backed by the `openai` SDK pointed at
+ * MiniMax's OpenAI-compatible endpoint at `https://api.minimax.io/v1`.
+ */
+export interface MiniMaxProviderConfig {
+  driver: 'minimax'
+  /** API key. Required. Most apps source from `env('MINIMAX_API_KEY')`. */
+  apiKey: string
+  /** Optional base URL override. Defaults to `https://api.minimax.io/v1`. */
+  baseUrl?: string
+  /** Default model. Defaults to `MiniMax-M2`. */
+  defaultModel?: string
+  /** Default `max_tokens` for `chat()` calls that don't specify one. */
+  defaultMaxTokens?: number
+}
+
+/**
+ * OpenRouter driver config — backed by the `openai` SDK pointed at
+ * `https://openrouter.ai/api/v1`. OpenRouter multiplexes 300+ models
+ * behind one OpenAI-compatible endpoint; **the surface a given call
+ * supports depends on the chosen model**. Pin an explicit model slug
+ * (e.g. `anthropic/claude-sonnet-4`, `meta-llama/llama-3.3-70b`) per
+ * call; consult `https://openrouter.ai/api/v1/models` for the
+ * `supported_parameters` per model. Calls to `embed` / `transcribe`
+ * are not exposed; structured output uses the OpenAI-compat
+ * tool-forcing pattern and depends on the model supporting
+ * function-calling.
+ */
+export interface OpenRouterProviderConfig {
+  driver: 'openrouter'
+  /** API key. Required. Most apps source from `env('OPENROUTER_API_KEY')`. */
+  apiKey: string
+  /** Optional base URL override. Defaults to `https://openrouter.ai/api/v1`. */
+  baseUrl?: string
+  /**
+   * Default model. No default — OpenRouter has no canonical pick;
+   * apps must choose a slug (e.g. `anthropic/claude-sonnet-4`).
+   */
+  defaultModel?: string
+  /** Default `max_tokens` for `chat()` calls that don't specify one. */
+  defaultMaxTokens?: number
+  /**
+   * Optional app URL — forwarded as the `HTTP-Referer` header.
+   * OpenRouter uses it to attribute traffic on their leaderboard
+   * and rankings page.
+   */
+  appUrl?: string
+  /**
+   * Optional app title — forwarded as the `X-Title` header. Paired
+   * with `appUrl` for OpenRouter's leaderboard.
+   */
+  appTitle?: string
+}
+
+export type ProviderConfig =
+  | AnthropicProviderConfig
+  | OpenAIProviderConfig
+  | OpenAIResponsesProviderConfig
+  | GeminiProviderConfig
+  | DeepSeekProviderConfig
+  | OllamaProviderConfig
+  | QwenProviderConfig
+  | MiniMaxProviderConfig
+  | OpenRouterProviderConfig
 
 /** Cache-shape defaults applied when `ChatOptions.cache` is omitted. */
 export interface BrainCacheConfig {
@@ -55,6 +265,13 @@ export interface BrainConfigShape {
   tiers?: Partial<Record<ModelTier, string>>
   /** Prompt-cache defaults. */
   cache?: BrainCacheConfig
+  /**
+   * Default MCP servers — declared on every `runWithTools` call
+   * unless the per-call options provide their own list. Apps that
+   * need different MCP server sets per route override at the call
+   * site or via `Agent.mcpServers`.
+   */
+  mcpServers?: readonly MCPServer[]
 }
 
 /**

package/src/brain_driver.ts

@@ -0,0 +1,247 @@
+/**
+ * `BrainDriver` — the contract every brain backend implements.
+ *
+ * Each concrete driver (`AnthropicBrainDriver`, `OpenAIBrainDriver`,
+ * `GeminiBrainDriver`, `DeepSeekBrainDriver`, …) wraps the vendor's
+ * SDK and translates the framework shapes (`Message`, `ChatOptions`)
+ * into the vendor's native request, then translates the response back
+ * into `ChatResult` / `StreamEvent`.
+ *
+ * Drivers are values, not classes the app instantiates by name — apps
+ * use them via the `BrainManager` facade. The interface is exported so
+ * apps that need to plug in a custom backend (e.g. a local Ollama
+ * variant, or a private gateway) can do so without subclassing.
+ */
+
+import type { AgentGenerateResult } from './agent_generate_result.ts'
+import type { AgentResult } from './agent_result.ts'
+import type { AgentStreamEvent } from './agent_stream_event.ts'
+import type { MCPServer } from './mcp_server.ts'
+import type { OutputSchema } from './output_schema.ts'
+import type { SuspendedRun } from './suspended_run.ts'
+import type { Tool } from './tool.ts'
+import type { ToolExecutionError } from './tool_execution_error.ts'
+import type {
+  AudioSource,
+  ChatOptions,
+  ChatResult,
+  EmbedOptions,
+  EmbedResult,
+  GenerateResult,
+  Message,
+  StreamEvent,
+  ToolUseBlock,
+  TranscribeOptions,
+  TranscribeResult,
+} from './types.ts'
+
+export interface RunWithToolsOptions extends ChatOptions {
+  /** Safety ceiling on tool-use round-trips. Default `10`. */
+  maxIterations?: number
+  /** Free-form context bag passed to every tool's `execute(input, ctx)`. */
+  context?: Record<string, unknown>
+  /**
+   * MCP servers Anthropic should connect to on this call. Merges
+   * with `config.brain.mcpServers` (per-call wins). Empty array or
+   * undefined → no MCP servers. Anthropic's backend handles tool
+   * discovery + invocation; the framework only surfaces the
+   * resulting `mcp_tool_use` / `mcp_tool_result` blocks.
+   */
+  mcpServers?: readonly MCPServer[]
+  /**
+   * Tool-error recovery hook. Called when a tool's `execute` throws
+   * — OR when the model called a tool that isn't registered. Two
+   * outcomes:
+   *
+   *   - Return a string → the loop continues. The string lands as
+   *     `tool_result.content` with `isError: true`, the model sees
+   *     the error and can adapt (try a different approach, ask the
+   *     user, give up). Recommended for production agents that
+   *     should survive transient failures.
+   *
+   *   - Return `undefined` (the default when this option is unset)
+   *     → the framework throws `ToolExecutionError` and the loop
+   *     aborts. Same behavior as before this option existed.
+   *
+   * The hook may inspect `error.cause` to filter — e.g., feed back
+   * transient HTTP errors but rethrow programmer errors:
+   *
+   * ```ts
+   * onToolError: (err) =>
+   *   err.cause instanceof TransientError ? err.cause.message : undefined
+   * ```
+   */
+  onToolError?(error: ToolExecutionError): string | undefined
+  /**
+   * Human-in-the-loop gate. Called before each tool execution; when
+   * it returns `true`, the loop suspends and `runWithTools` returns
+   * a `SuspendedRun` carrying the pending tool calls + a JSON-
+   * serializable snapshot of the loop state. Apps obtain results
+   * out-of-band (human approval, queued worker, external system,
+   * ...) and call `brain.resumeTools(state, results, tools, options)`
+   * to continue.
+   *
+   * Mid-batch invariant: if a tool call inside a multi-call batch
+   * triggers suspension, the framework also captures all unexecuted
+   * siblings from the same assistant turn — the provider's
+   * `tool_use` / `tool_result` pairing must stay balanced on resume.
+   *
+   * V1 scope: only honored on non-streaming `runWithTools`. Pass it
+   * to `streamWithTools`, `runWithToolsAndSchema`, or
+   * `streamWithToolsAndSchema` and the framework throws `BrainError`
+   * — those entrypoints don't yet model the pause/resume protocol.
+   */
+  shouldSuspend?(
+    call: ToolUseBlock,
+    context?: Record<string, unknown>,
+  ): boolean | Promise<boolean>
+}
+
+/**
+ * Same as `RunWithToolsOptions` but with `shouldSuspend` required.
+ * Used to narrow the return type of `runWithTools` overloads — when
+ * apps opt in to the human-in-the-loop gate, the result widens to
+ * `AgentResult | SuspendedRun`; otherwise it's just `AgentResult`.
+ */
+export type RunWithToolsOptionsWithSuspend = RunWithToolsOptions & {
+  shouldSuspend: NonNullable<RunWithToolsOptions['shouldSuspend']>
+}
+
+export interface BrainDriver {
+  /** Identifier — matches the `config.brain.providers` key. */
+  readonly name: string
+
+  /**
+   * Generate a single reply. Awaits the full response; for
+   * token-by-token rendering use `stream()`.
+   */
+  chat(messages: readonly Message[], options?: ChatOptions): Promise<ChatResult>
+
+  /**
+   * Stream the reply as it's generated. The async iterable yields
+   * `text` events for each delta and a final `stop` event with usage
+   * + stop-reason. Apps that want the full collected message at the
+   * end pass the same `messages` to `chat()` instead; this surface is
+   * for UI streaming, not for "make one call and get the message".
+   */
+  stream(messages: readonly Message[], options?: ChatOptions): AsyncIterable<StreamEvent>
+
+  /**
+   * Count input tokens for a given message set + options. Used by
+   * apps that need to budget context before sending. Optional — not
+   * every provider exposes a cheap token-count endpoint, so the
+   * implementation may approximate.
+   */
+  countTokens?(messages: readonly Message[], options?: ChatOptions): Promise<number>
+
+  /**
+   * Agentic loop. Sends the `messages` + `tools` to the model;
+   * detects tool-use blocks in the response; runs the matching
+   * tool's `execute`; appends the result and re-asks. Loops until
+   * the model returns `stop_reason: 'end_turn'` (or its
+   * provider-specific equivalent) or `maxIterations` is hit.
+   *
+   * Optional on the interface so providers that don't (yet) support
+   * tool use can omit it; `BrainManager.runTools` throws a
+   * `BrainError` when the configured provider lacks the method.
+   */
+  runWithTools?(
+    messages: readonly Message[],
+    tools: readonly Tool[],
+    options?: RunWithToolsOptions,
+  ): Promise<AgentResult | SuspendedRun>
+
+  /**
+   * Structured output. Sends `messages` to the model with a
+   * JSON-Schema constraint and returns the parsed object. Apps that
+   * supplied `schema.parse` get a runtime-validated value; otherwise
+   * the value is `T` by type assertion (the provider does its own
+   * upstream schema enforcement, but the framework doesn't validate).
+   *
+   * Optional on the interface so providers that lack a structured-
+   * output endpoint can omit it; `BrainManager.generate` throws a
+   * `BrainError` when the configured provider doesn't expose this.
+   */
+  generate?<T>(
+    messages: readonly Message[],
+    schema: OutputSchema<T>,
+    options?: ChatOptions,
+  ): Promise<GenerateResult<T>>
+
+  /**
+   * Tool-loop + structured output combined. Runs the agentic loop
+   * with the same tool-handling as `runWithTools`, but pins a
+   * JSON-Schema constraint on every turn — so when the model
+   * finally answers without calling a tool, its text is JSON
+   * matching the schema. Returns the parsed value alongside the
+   * loop bookkeeping.
+   *
+   * Optional on the interface; `BrainManager.generateWithTools`
+   * throws `BrainError` when the configured provider lacks it.
+   */
+  runWithToolsAndSchema?<T>(
+    messages: readonly Message[],
+    tools: readonly Tool[],
+    schema: OutputSchema<T>,
+    options?: RunWithToolsOptions,
+  ): Promise<AgentGenerateResult<T>>
+
+  /**
+   * Streaming variant of `runWithToolsAndSchema`. Same agentic loop,
+   * same schema constraint on every turn — yielded as
+   * `AgentStreamEvent<T>`s. The terminal `stop` event carries the
+   * parsed `value` + raw `text` alongside the loop bookkeeping.
+   *
+   * Optional; `BrainManager.streamGenerateWithTools` throws
+   * `BrainError` when the chosen provider doesn't implement it.
+   */
+  streamWithToolsAndSchema?<T>(
+    messages: readonly Message[],
+    tools: readonly Tool[],
+    schema: OutputSchema<T>,
+    options?: RunWithToolsOptions,
+  ): AsyncIterable<AgentStreamEvent<T>>
+
+  /**
+   * Streaming variant of `runWithTools`. Yields `AgentStreamEvent`s
+   * as the loop progresses — text deltas during model turns,
+   * `tool_use` / `tool_result` boundaries around tool execution,
+   * `iteration_start` / `iteration_end` per round, a terminal
+   * `stop` with the full trace + usage.
+   *
+   * Optional — providers without a streaming tool-loop implementation
+   * can omit it; `BrainManager.streamTools` throws `BrainError` in
+   * that case.
+   */
+  streamWithTools?(
+    messages: readonly Message[],
+    tools: readonly Tool[],
+    options?: RunWithToolsOptions,
+  ): AsyncIterable<AgentStreamEvent>
+
+  /**
+   * Embeddings — turn one or more text inputs into vectors for
+   * similarity search / RAG / clustering. Optional because not
+   * every provider exposes an embeddings endpoint (V1: Anthropic
+   * and DeepSeek don't; OpenAI, Gemini, Ollama do).
+   */
+  embed?(
+    texts: readonly string[],
+    options?: EmbedOptions,
+  ): Promise<EmbedResult>
+
+  /**
+   * Audio transcription — convert an audio clip to text.
+   * Complements `AudioBlock` (which sends audio + text together
+   * to a multimodal chat model) by exposing the dedicated
+   * transcription endpoint where the provider has one. V1:
+   * OpenAI (Whisper / gpt-4o-transcribe), Ollama (inherits via
+   * OpenAI-compat), Gemini (chat-wrap fallback — internally
+   * sends an AudioBlock with a "transcribe verbatim" prompt).
+   * Anthropic + DeepSeek throw — no transcription API.
+   */
+  transcribe?(
+    audio: AudioSource,
+    options?: TranscribeOptions,
+  ): Promise<TranscribeResult>
+}

package/src/brain_error.ts

@@ -1,16 +1,32 @@
 /**
- * `BrainError` — typed wrapper for failures originating in the brain
- * stack. Provider-native errors (e.g. `Anthropic.RateLimitError`) are
- * preserved on `.cause` so apps can `instanceof`-check them when they
- * need provider-specific recovery; the wrapping just gives the
- * framework a consistent `StravError` to render through the standard
+ * `BrainError` hierarchy — typed wrappers for failures originating
+ * in the brain stack.
+ *
+ * Provider-native errors (e.g. `Anthropic.RateLimitError`) are
+ * preserved on `.cause` so apps can `instanceof`-check them when
+ * they need vendor-specific recovery; the framework wrapping gives
+ * a consistent `StravError` to render through the standard
  * exception handler.
  *
- * Subclassing surface deferred — V1 has one error type. When a real
- * use case appears for distinguishing "model refused" vs "rate
- * limited" at the framework level (rather than `instanceof
- * Anthropic.RateLimitError` at the call site), a typed hierarchy
- * lands.
+ * Subclasses ship in v1 for the boot / lookup / usage paths.
+ * Vendor-side runtime errors use `BrainProviderError` as the
+ * generic wrapper. Granular vendor classes (rate-limit, content
+ * filter, etc.) land when apps actually need to branch on them at
+ * the framework level — until then, `instanceof Anthropic.RateLimitError`
+ * on `.cause` is the call-site pattern.
+ *
+ *   - `BrainConfigError` — boot-time misconfiguration (missing
+ *     provider in `config.brain.providers`, default key absent).
+ *
+ *   - `UnknownProviderError` — `brain.provider(name)` for a name
+ *     that wasn't registered.
+ *
+ *   - `BrainUsageError` — pre-condition violations from the
+ *     framework's own API contract (e.g. `AgentRunner.run` called
+ *     before `input()`).
+ *
+ *   - `BrainProviderError` — wraps a vendor exception. `cause` is
+ *     preserved; default status 502.
  */
 
 import { StravError } from '@strav/kernel'
@@ -27,3 +43,63 @@ export class BrainError extends StravError {
     )
   }
 }
+
+export class BrainConfigError extends BrainError {
+  constructor(
+    message: string,
+    options: { context?: Record<string, unknown> } = {},
+  ) {
+    super(message, options)
+    // Reassign code/status via the underlying StravError props (the
+    // base constructor froze them with `brain.error`); we read them
+    // back through getters so subclass-specific overrides surface in
+    // logs.
+    Object.defineProperty(this, 'code', { value: 'brain.config' })
+    Object.defineProperty(this, 'status', { value: 500 })
+  }
+}
+
+export class UnknownProviderError extends BrainError {
+  constructor(name: string, available: readonly string[]) {
+    super(
+      `Brain provider "${name}" is not registered. Available: ${available.join(', ') || '<none>'}.`,
+      { context: { requested: name, available } },
+    )
+    Object.defineProperty(this, 'code', { value: 'brain.unknown_provider' })
+    Object.defineProperty(this, 'status', { value: 400 })
+  }
+}
+
+export class BrainUsageError extends BrainError {
+  constructor(
+    message: string,
+    options: { context?: Record<string, unknown> } = {},
+  ) {
+    super(message, options)
+    Object.defineProperty(this, 'code', { value: 'brain.usage' })
+    Object.defineProperty(this, 'status', { value: 500 })
+  }
+}
+
+export class BrainProviderError extends BrainError {
+  constructor(
+    message: string,
+    options: {
+      provider: string
+      operation: string
+      context?: Record<string, unknown>
+      cause?: unknown
+    },
+  ) {
+    super(message, {
+      context: {
+        provider: options.provider,
+        operation: options.operation,
+        ...(options.context ?? {}),
+      },
+      ...(options.cause !== undefined ? { cause: options.cause } : {}),
+    })
+    Object.defineProperty(this, 'code', { value: 'brain.provider_error' })
+    Object.defineProperty(this, 'status', { value: 502 })
+  }
+}