@strav/brain 1.0.0-alpha.40 → 1.0.0-alpha.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strav/brain",
-  "version": "1.0.0-alpha.40",
+  "version": "1.0.0-alpha.42",
   "description": "Strav AI module — unified Provider interface, BrainManager, threads, prompt caching, tools / agents / MCP. Anthropic + OpenAI providers; Gemini / DeepSeek follow.",
   "type": "module",
   "main": "./src/index.ts",
@@ -26,8 +26,8 @@
     "@anthropic-ai/sdk": "^0.100.0",
     "@google/genai": "^2.7.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@strav/database": "1.0.0-alpha.40",
-    "@strav/kernel": "1.0.0-alpha.40",
+    "@strav/database": "1.0.0-alpha.42",
+    "@strav/kernel": "1.0.0-alpha.42",
     "openai": "^6.0.0"
   },
   "peerDependencies": {

package/src/brain_config.ts

@@ -151,6 +151,89 @@ export interface OllamaProviderConfig {
   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
@@ -158,6 +241,9 @@ export type ProviderConfig =
   | GeminiProviderConfig
   | DeepSeekProviderConfig
   | OllamaProviderConfig
+  | QwenProviderConfig
+  | MiniMaxProviderConfig
+  | OpenRouterProviderConfig
 
 /** Cache-shape defaults applied when `ChatOptions.cache` is omitted. */
 export interface BrainCacheConfig {

package/src/brain_provider.ts

@@ -25,15 +25,18 @@
  */
 
 import { type Application, ConfigError, ConfigRepository, ServiceProvider } from '@strav/kernel'
-import { BrainManager } from './brain_manager.ts'
 import type { BrainConfigShape, ProviderConfig } from './brain_config.ts'
+import type { BrainDriver } from './brain_driver.ts'
+import { BrainManager } from './brain_manager.ts'
 import { AnthropicBrainDriver } from './drivers/anthropic/anthropic_brain_driver.ts'
 import { DeepSeekBrainDriver } from './drivers/deepseek/deepseek_brain_driver.ts'
 import { GeminiBrainDriver } from './drivers/gemini/gemini_brain_driver.ts'
+import { MiniMaxBrainDriver } from './drivers/minimax/minimax_brain_driver.ts'
 import { OllamaBrainDriver } from './drivers/ollama/ollama_brain_driver.ts'
 import { OpenAIBrainDriver } from './drivers/openai/openai_brain_driver.ts'
 import { OpenAIResponsesBrainDriver } from './drivers/openai_responses/openai_responses_brain_driver.ts'
-import type { BrainDriver } from './brain_driver.ts'
+import { OpenRouterBrainDriver } from './drivers/openrouter/openrouter_brain_driver.ts'
+import { QwenBrainDriver } from './drivers/qwen/qwen_brain_driver.ts'
 
 export class BrainProvider extends ServiceProvider {
   override readonly name = 'brain'
@@ -133,10 +136,31 @@ function buildBrainDriver(name: string, config: ProviderConfig): BrainDriver {
         )
       }
       return new OllamaBrainDriver(name, config)
+    case 'qwen':
+      if (!config.apiKey) {
+        throw new ConfigError(
+          `BrainProvider: qwen provider "${name}" is missing apiKey. Source from env('DASHSCOPE_API_KEY') or env('QWEN_API_KEY').`,
+        )
+      }
+      return new QwenBrainDriver(name, config)
+    case 'minimax':
+      if (!config.apiKey) {
+        throw new ConfigError(
+          `BrainProvider: minimax provider "${name}" is missing apiKey. Source from env('MINIMAX_API_KEY').`,
+        )
+      }
+      return new MiniMaxBrainDriver(name, config)
+    case 'openrouter':
+      if (!config.apiKey) {
+        throw new ConfigError(
+          `BrainProvider: openrouter provider "${name}" is missing apiKey. Source from env('OPENROUTER_API_KEY').`,
+        )
+      }
+      return new OpenRouterBrainDriver(name, config)
     default: {
       const exhaustiveCheck: never = config
       throw new ConfigError(
-        `BrainProvider: unknown driver for provider "${name}". Known drivers: anthropic, openai, openai-responses, google, deepseek, ollama.`,
+        `BrainProvider: unknown driver for provider "${name}". Known drivers: anthropic, openai, openai-responses, google, deepseek, ollama, qwen, minimax, openrouter.`,
       )
       // (unreachable — kept for the exhaustive check to fire when a new driver lands)
       // biome-ignore lint/correctness/noUnreachable: kept for the exhaustive-check above

package/src/drivers/minimax/index.ts

@@ -0,0 +1 @@
+export { MiniMaxBrainDriver } from './minimax_brain_driver.ts'

package/src/drivers/minimax/minimax_brain_driver.ts

@@ -0,0 +1,84 @@
+/**
+ * `MiniMaxBrainDriver` — `OpenAICompatBrainDriver` pointed at
+ * MiniMax's OpenAI-compatible endpoint at `https://api.minimax.io/v1`.
+ *
+ * MiniMax (M2, abab line) speaks the OpenAI Chat Completions wire
+ * format and supports function-calling, so the OpenAI-compat base
+ * already covers chat / stream / generate (via `json_object`) /
+ * runWithToolsAndSchema (via tool-forcing).
+ *
+ * MiniMax has a `reasoning_split=true` flag that surfaces the
+ * assistant's reasoning trace on a separate `reasoning_details`
+ * field. Not wired in V1 — `effort` / `thinking` are stripped by
+ * the OpenAI-compat `buildParams` override and apps reach for
+ * reasoning surfaces via the Anthropic / Gemini / OpenAI Responses
+ * drivers.
+ *
+ * `embed` / `transcribe` are not exposed via the compatibility
+ * endpoint; the inherited stubs are replaced with explicit
+ * `BrainError`s so apps see a clear message instead of a wire 404.
+ */
+
+import type OpenAI from 'openai'
+import type { MiniMaxProviderConfig } from '../../brain_config.ts'
+import { BrainError } from '../../brain_error.ts'
+import type { ResolveMcpToolsOptions } from '../../mcp/resolve_mcp_tools.ts'
+import type {
+  AudioSource,
+  EmbedOptions,
+  EmbedResult,
+  TranscribeOptions,
+  TranscribeResult,
+} from '../../types.ts'
+import { OpenAICompatBrainDriver } from '../openai_compat/openai_compat_brain_driver.ts'
+
+const DEFAULT_MINIMAX_MODEL = 'MiniMax-M2'
+const DEFAULT_MINIMAX_BASE_URL = 'https://api.minimax.io/v1'
+
+export interface MiniMaxProviderOptions {
+  client?: OpenAI
+  /**
+   * Internal seam — tests inject a stub MCP client factory so MCP
+   * tool resolution doesn't dial the network. Real apps leave it
+   * unset; the provider uses the default `MCPClient`.
+   */
+  mcpClientFactory?: ResolveMcpToolsOptions['clientFactory']
+}
+
+export class MiniMaxBrainDriver extends OpenAICompatBrainDriver {
+  constructor(name: string, config: MiniMaxProviderConfig, options: MiniMaxProviderOptions = {}) {
+    super(
+      name,
+      {
+        driver: 'openai',
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl ?? DEFAULT_MINIMAX_BASE_URL,
+        defaultModel: config.defaultModel ?? DEFAULT_MINIMAX_MODEL,
+        ...(config.defaultMaxTokens !== undefined
+          ? { defaultMaxTokens: config.defaultMaxTokens }
+          : {}),
+      },
+      options,
+    )
+  }
+
+  override async embed(
+    _texts: readonly string[],
+    _options?: EmbedOptions,
+  ): Promise<EmbedResult<OpenAI.CreateEmbeddingResponse>> {
+    throw new BrainError(
+      `MiniMaxBrainDriver.embed: MiniMax's OpenAI-compatibility endpoint does not expose embeddings. Route embed calls to a provider with native support — OpenAI / Gemini / Ollama.`,
+      { context: { provider: this.name } },
+    )
+  }
+
+  override async transcribe(
+    _audio: AudioSource,
+    _options?: TranscribeOptions,
+  ): Promise<TranscribeResult<OpenAI.Audio.TranscriptionCreateResponse>> {
+    throw new BrainError(
+      "MiniMaxBrainDriver.transcribe: MiniMax's OpenAI-compatibility endpoint does not expose audio transcription. Route transcribe calls to a provider with native support — OpenAI / Ollama / Gemini.",
+      { context: { provider: this.name } },
+    )
+  }
+}

package/src/drivers/openrouter/index.ts

@@ -0,0 +1 @@
+export { OpenRouterBrainDriver } from './openrouter_brain_driver.ts'

package/src/drivers/openrouter/openrouter_brain_driver.ts

@@ -0,0 +1,137 @@
+/**
+ * `OpenRouterBrainDriver` — `OpenAICompatBrainDriver` pointed at
+ * OpenRouter's OpenAI-compatible endpoint at
+ * `https://openrouter.ai/api/v1`.
+ *
+ * OpenRouter multiplexes 300+ hosted models (Anthropic, OpenAI,
+ * Google, Meta, Mistral, DeepSeek, Qwen, ...) behind one
+ * Chat-Completions-shaped API. The driver does NOT try to predict
+ * which model supports what — capabilities vary per slug. The
+ * supported approach is:
+ *
+ *   - Pin an explicit model slug per call (e.g.
+ *     `anthropic/claude-sonnet-4`, `meta-llama/llama-3.3-70b`).
+ *   - If the chosen model doesn't support a primitive (tools,
+ *     JSON mode, schema-forcing), the upstream OpenRouter error
+ *     bubbles up as a `BrainError` from the inherited helpers.
+ *   - Consult `https://openrouter.ai/api/v1/models` and filter on
+ *     the `supported_parameters` field to pick a model that
+ *     handles the feature you need.
+ *
+ * Two OpenRouter-specific niceties:
+ *
+ *   - Optional `appUrl` (→ `HTTP-Referer`) and `appTitle`
+ *     (→ `X-Title`) forwarded as default headers on every request.
+ *     OpenRouter uses these to attribute traffic on their public
+ *     leaderboard / rankings.
+ *
+ *   - No `defaultModel` default — OpenRouter has no canonical pick.
+ *     Apps must set one, or pass `options.model` per call. The
+ *     inherited OpenAI default `gpt-5` would silently route through
+ *     OpenAI's slug namespace and surprise users.
+ *
+ * Inherits all OpenAI-compat overrides: `buildParams` strips
+ * `reasoning_effort` (re-add it in a subclass / per-call `extraBody`
+ * for models that take it), `generate` uses `json_object`-mode +
+ * schema-in-system-prompt, `runWithToolsAndSchema` /
+ * `streamWithToolsAndSchema` use the tool-forcing pattern.
+ *
+ * `embed` / `transcribe` are not exposed via OpenRouter — replaced
+ * with explicit `BrainError`s.
+ */
+
+import OpenAI from 'openai'
+import type { OpenRouterProviderConfig } from '../../brain_config.ts'
+import { BrainError } from '../../brain_error.ts'
+import type { ResolveMcpToolsOptions } from '../../mcp/resolve_mcp_tools.ts'
+import type {
+  AudioSource,
+  EmbedOptions,
+  EmbedResult,
+  TranscribeOptions,
+  TranscribeResult,
+} from '../../types.ts'
+import { OpenAICompatBrainDriver } from '../openai_compat/openai_compat_brain_driver.ts'
+
+const DEFAULT_OPENROUTER_BASE_URL = 'https://openrouter.ai/api/v1'
+/**
+ * Fallback when neither `config.defaultModel` nor a per-call
+ * `options.model` is supplied. Picked as a broad-purpose,
+ * tool-capable, well-priced default; apps that want something else
+ * just pass `defaultModel`.
+ */
+const DEFAULT_OPENROUTER_MODEL = 'openai/gpt-4o-mini'
+
+export interface OpenRouterProviderOptions {
+  client?: OpenAI
+  /**
+   * Internal seam — tests inject a stub MCP client factory so MCP
+   * tool resolution doesn't dial the network. Real apps leave it
+   * unset; the provider uses the default `MCPClient`.
+   */
+  mcpClientFactory?: ResolveMcpToolsOptions['clientFactory']
+}
+
+export class OpenRouterBrainDriver extends OpenAICompatBrainDriver {
+  constructor(
+    name: string,
+    config: OpenRouterProviderConfig,
+    options: OpenRouterProviderOptions = {},
+  ) {
+    const baseURL = config.baseUrl ?? DEFAULT_OPENROUTER_BASE_URL
+    const defaultHeaders = buildOpenRouterHeaders(config)
+    // Construct the OpenAI client locally so we can carry OpenRouter's
+    // attribution headers (HTTP-Referer / X-Title). The base
+    // OpenAIBrainDriver only exposes apiKey / baseUrl / organization,
+    // so we hand a fully-built client through `options.client`.
+    const client =
+      options.client ??
+      new OpenAI({
+        apiKey: config.apiKey,
+        baseURL,
+        ...(defaultHeaders ? { defaultHeaders } : {}),
+      })
+    super(
+      name,
+      {
+        driver: 'openai',
+        apiKey: config.apiKey,
+        baseUrl: baseURL,
+        defaultModel: config.defaultModel ?? DEFAULT_OPENROUTER_MODEL,
+        ...(config.defaultMaxTokens !== undefined
+          ? { defaultMaxTokens: config.defaultMaxTokens }
+          : {}),
+      },
+      { ...options, client },
+    )
+  }
+
+  override async embed(
+    _texts: readonly string[],
+    _options?: EmbedOptions,
+  ): Promise<EmbedResult<OpenAI.CreateEmbeddingResponse>> {
+    throw new BrainError(
+      `OpenRouterBrainDriver.embed: OpenRouter's API does not expose embeddings. Route embed calls to a provider with native support — OpenAI / Gemini / Ollama.`,
+      { context: { provider: this.name } },
+    )
+  }
+
+  override async transcribe(
+    _audio: AudioSource,
+    _options?: TranscribeOptions,
+  ): Promise<TranscribeResult<OpenAI.Audio.TranscriptionCreateResponse>> {
+    throw new BrainError(
+      "OpenRouterBrainDriver.transcribe: OpenRouter's API does not expose audio transcription. Route transcribe calls to a provider with native support — OpenAI / Ollama / Gemini.",
+      { context: { provider: this.name } },
+    )
+  }
+}
+
+function buildOpenRouterHeaders(
+  config: OpenRouterProviderConfig,
+): Record<string, string> | undefined {
+  const headers: Record<string, string> = {}
+  if (config.appUrl !== undefined) headers['HTTP-Referer'] = config.appUrl
+  if (config.appTitle !== undefined) headers['X-Title'] = config.appTitle
+  return Object.keys(headers).length > 0 ? headers : undefined
+}

package/src/drivers/qwen/index.ts

@@ -0,0 +1 @@
+export { QwenBrainDriver } from './qwen_brain_driver.ts'

package/src/drivers/qwen/qwen_brain_driver.ts

@@ -0,0 +1,103 @@
+/**
+ * `QwenBrainDriver` — `OpenAICompatBrainDriver` pointed at Alibaba
+ * DashScope's OpenAI-compatible `/compatible-mode/v1` endpoint.
+ *
+ * Why ship Qwen: deep coverage of Chinese + SEA languages, with the
+ * `qwen-plus` / `qwen-max` line punching at the frontier on those
+ * locales. Fits Strav's SEA-first positioning.
+ *
+ * Inherits the OpenAI-compat overrides (strip `reasoning_effort`,
+ * `json_object`-mode generate with schema-in-system-prompt,
+ * tool-forcing pattern for combined tools + schema) from the base
+ * class. Only adds:
+ *
+ *   - Constructor with DashScope defaults — base URL
+ *     `https://dashscope-intl.aliyuncs.com/compatible-mode/v1` (the
+ *     Singapore endpoint), default model `qwen-plus`.
+ *
+ *   - `mapUsage` override — Qwen reports prompt-cache hits on
+ *     OpenAI's standard `prompt_tokens_details.cached_tokens`
+ *     field; the inherited mapping is already correct. Kept the
+ *     hook here for vendor-specific extension fields if they
+ *     surface later.
+ *
+ * `embed` / `transcribe` are not implemented for V1 — DashScope
+ * exposes both via separate endpoints, but the framework's seam
+ * is per-driver and we'd rather route those calls to a provider
+ * with first-class support. Override the inherited stubs to throw
+ * with a clear message instead of letting the SDK 404.
+ */
+
+import type OpenAI from 'openai'
+import type { QwenProviderConfig } from '../../brain_config.ts'
+import { BrainError } from '../../brain_error.ts'
+import type { ResolveMcpToolsOptions } from '../../mcp/resolve_mcp_tools.ts'
+import type {
+  AudioSource,
+  EmbedOptions,
+  EmbedResult,
+  TranscribeOptions,
+  TranscribeResult,
+} from '../../types.ts'
+import { OpenAICompatBrainDriver } from '../openai_compat/openai_compat_brain_driver.ts'
+
+const DEFAULT_QWEN_MODEL = 'qwen-plus'
+const DEFAULT_QWEN_BASE_URL = 'https://dashscope-intl.aliyuncs.com/compatible-mode/v1'
+
+export interface QwenProviderOptions {
+  client?: OpenAI
+  /**
+   * Internal seam — tests inject a stub MCP client factory so MCP
+   * tool resolution doesn't dial the network. Real apps leave it
+   * unset; the provider uses the default `MCPClient`.
+   */
+  mcpClientFactory?: ResolveMcpToolsOptions['clientFactory']
+}
+
+export class QwenBrainDriver extends OpenAICompatBrainDriver {
+  constructor(name: string, config: QwenProviderConfig, options: QwenProviderOptions = {}) {
+    super(
+      name,
+      {
+        driver: 'openai',
+        apiKey: config.apiKey,
+        baseUrl: config.baseUrl ?? DEFAULT_QWEN_BASE_URL,
+        defaultModel: config.defaultModel ?? DEFAULT_QWEN_MODEL,
+        ...(config.defaultMaxTokens !== undefined
+          ? { defaultMaxTokens: config.defaultMaxTokens }
+          : {}),
+      },
+      options,
+    )
+  }
+
+  /**
+   * DashScope's compatibility endpoint does not expose embeddings
+   * via `/compatible-mode/v1/embeddings`. Override the inherited
+   * `embed` to throw clearly rather than 404 at the wire.
+   */
+  override async embed(
+    _texts: readonly string[],
+    _options?: EmbedOptions,
+  ): Promise<EmbedResult<OpenAI.CreateEmbeddingResponse>> {
+    throw new BrainError(
+      `QwenBrainDriver.embed: Qwen's OpenAI-compatibility endpoint does not expose embeddings. Route embed calls to a provider with native support — OpenAI / Gemini / Ollama.`,
+      { context: { provider: this.name } },
+    )
+  }
+
+  /**
+   * DashScope's compatibility endpoint does not expose audio
+   * transcription. Override the inherited `transcribe` to throw
+   * clearly.
+   */
+  override async transcribe(
+    _audio: AudioSource,
+    _options?: TranscribeOptions,
+  ): Promise<TranscribeResult<OpenAI.Audio.TranscriptionCreateResponse>> {
+    throw new BrainError(
+      "QwenBrainDriver.transcribe: Qwen's OpenAI-compatibility endpoint does not expose audio transcription. Route transcribe calls to a provider with native support — OpenAI / Ollama / Gemini.",
+      { context: { provider: this.name } },
+    )
+  }
+}

package/src/index.ts

@@ -2,7 +2,8 @@
 //
 // Shipped:
 //   - `BrainDriver` contract + concrete drivers — Anthropic, OpenAI
-//     (Chat + Responses), Gemini, DeepSeek, Ollama, openai-compat.
+//     (Chat + Responses), Gemini, DeepSeek, Ollama, Qwen, MiniMax,
+//     OpenRouter, openai-compat.
 //   - `BrainManager` + `Thread` (persisted history, compaction) + the
 //     `BrainProvider` service wiring + prompt-cache plumbing.
 //   - Tools — `defineTool`, `Agent` base + `AgentRunner`,
@@ -17,8 +18,8 @@ export { Agent } from './agent.ts'
 export type { AgentGenerateResult } from './agent_generate_result.ts'
 export type { AgentResult } from './agent_result.ts'
 export {
-  AgentRunner,
   type AgentRunMaybeSuspended,
+  AgentRunner,
   type AgentRunResult,
 } from './agent_runner.ts'
 export type { AgentStreamEvent } from './agent_stream_event.ts'
@@ -26,15 +27,23 @@ export {
   type AnthropicProviderConfig,
   type BrainCacheConfig,
   type BrainConfigShape,
-  type DeepSeekProviderConfig,
   DEFAULT_MODEL,
   DEFAULT_TIERS,
+  type DeepSeekProviderConfig,
   type GeminiProviderConfig,
+  type MiniMaxProviderConfig,
   type OllamaProviderConfig,
   type OpenAIProviderConfig,
   type OpenAIResponsesProviderConfig,
+  type OpenRouterProviderConfig,
   type ProviderConfig,
+  type QwenProviderConfig,
 } from './brain_config.ts'
+export type {
+  BrainDriver,
+  RunWithToolsOptions,
+  RunWithToolsOptionsWithSuspend,
+} from './brain_driver.ts'
 export {
   BrainConfigError,
   BrainError,
@@ -48,22 +57,20 @@ export {
   type BrainManagerOptions,
 } from './brain_manager.ts'
 export { BrainProvider } from './brain_provider.ts'
-export { defineTool, type DefineToolSpec } from './define_tool.ts'
-export { MCPClientPool, type MCPClientFactory } from './mcp/pool.ts'
-export type { MCPServer, MCPServerToolConfig } from './mcp_server.ts'
-export type { OutputSchema } from './output_schema.ts'
+export { type DefineToolSpec, defineTool } from './define_tool.ts'
 export { AnthropicBrainDriver } from './drivers/anthropic/anthropic_brain_driver.ts'
 export { DeepSeekBrainDriver } from './drivers/deepseek/deepseek_brain_driver.ts'
 export { GeminiBrainDriver } from './drivers/gemini/gemini_brain_driver.ts'
+export { MiniMaxBrainDriver } from './drivers/minimax/minimax_brain_driver.ts'
 export { OllamaBrainDriver } from './drivers/ollama/ollama_brain_driver.ts'
-export { OpenAICompatBrainDriver } from './drivers/openai_compat/openai_compat_brain_driver.ts'
 export { OpenAIBrainDriver } from './drivers/openai/openai_brain_driver.ts'
+export { OpenAICompatBrainDriver } from './drivers/openai_compat/openai_compat_brain_driver.ts'
 export { OpenAIResponsesBrainDriver } from './drivers/openai_responses/openai_responses_brain_driver.ts'
-export type {
-  BrainDriver,
-  RunWithToolsOptions,
-  RunWithToolsOptionsWithSuspend,
-} from './brain_driver.ts'
+export { OpenRouterBrainDriver } from './drivers/openrouter/openrouter_brain_driver.ts'
+export { QwenBrainDriver } from './drivers/qwen/qwen_brain_driver.ts'
+export { type MCPClientFactory, MCPClientPool } from './mcp/pool.ts'
+export type { MCPServer, MCPServerToolConfig } from './mcp_server.ts'
+export type { OutputSchema } from './output_schema.ts'
 export {
   appendResumeResults,
   isSuspended,
@@ -75,14 +82,14 @@ export { Thread, type ThreadOptions, type ThreadState } from './thread.ts'
 export type { Tool, ToolContext } from './tool.ts'
 export { ToolExecutionError } from './tool_execution_error.ts'
 export type {
+  AudioBlock,
+  AudioSource,
   ChatOptions,
   ChatResult,
   ChatUsage,
   CompactConfig,
   CompactionBlock,
   ContentBlock,
-  AudioBlock,
-  AudioSource,
   DocumentBlock,
   EmbedOptions,
   EmbedResult,