@strav/brain 1.0.0-alpha.9 → 1.0.1

package/src/persistence/schemas/brain_message_schema.ts

@@ -0,0 +1,61 @@
+/**
+ * `brainMessageSchema` — one row per assistant or user turn within
+ * a thread. Append-only; rows are inserted in `turn_index` order
+ * and never updated (compaction blocks live as a regular assistant
+ * row whose `content` includes a `CompactionBlock`).
+ *
+ * Why per-turn rather than a JSONB blob on `brain_thread`:
+ *
+ *   - **Pagination.** UIs render the latest N turns; queries select
+ *     by `(thread_id, turn_index)` instead of parsing a JSON array.
+ *   - **Per-turn metadata.** `model` / `usage` / `stop_reason` /
+ *     `response_id` are indexed and queryable for cost analytics,
+ *     audit, and routing (e.g., "which threads used gpt-5?").
+ *   - **Append cost.** Each `send()` is a single INSERT, not a
+ *     rewrite of the entire array.
+ *
+ * Columns:
+ *
+ *   - `id`           ULID primary key.
+ *   - `thread_id`    FK → `brain_thread`. `onDelete: cascade` —
+ *                    deleting a thread drops its history.
+ *   - `turn_index`   0-based ordinal. Unique with `thread_id` (app
+ *                    migration adds the index).
+ *   - `role`         `user` or `assistant`. The framework's
+ *                    `Message.role` union; tool_result blocks land
+ *                    on user turns per the assistant ↔ user
+ *                    handshake, so `role` reflects that.
+ *   - `content`      JSONB — `string | ContentBlock[]`. Carries
+ *                    every typed block: text, image, document,
+ *                    audio, tool_use, tool_result, mcp_*, compaction.
+ *   - `model`        Model identifier used for assistant turns
+ *                    (NULL for user turns).
+ *   - `usage`        JSONB — `ChatUsage` for assistant turns.
+ *   - `stop_reason`  Provider terminal reason (`end_turn`, etc.).
+ *   - `response_id`  OpenAI Responses API id when surfaced. Indexed
+ *                    via partial index in the recommended migration.
+ *   - `created_at`   Timestamp.
+ *
+ * Archetype.Event — append-only semantics; no `updated_at`.
+ */
+
+import { Archetype, defineSchema } from '@strav/database'
+import { brainThreadSchema } from './brain_thread_schema.ts'
+
+export const brainMessageSchema = defineSchema(
+  'brain_message',
+  Archetype.Event,
+  (t) => {
+    t.id()
+    t.foreign('thread_id').to(brainThreadSchema).onDelete('cascade').notNull()
+    t.integer('turn_index').notNull()
+    t.enum('role', ['user', 'assistant']).notNull()
+    t.json('content').notNull()
+    t.string('model').max(128).nullable()
+    t.json('usage').nullable()
+    t.string('stop_reason').max(64).nullable()
+    t.string('response_id').max(128).nullable()
+    t.timestamp('created_at').notNull()
+  },
+  { tenanted: true },
+)

package/src/persistence/schemas/brain_suspended_run_schema.ts

@@ -0,0 +1,58 @@
+/**
+ * `brainSuspendedRunSchema` — a paused agentic loop awaiting
+ * human-in-the-loop tool approval.
+ *
+ * Two real use cases drive the shape:
+ *
+ *   1. **Linked to a thread** — the suspending run was part of a
+ *      conversational thread; the app wants the suspended state to
+ *      reference its thread so the UI can show "thread X is paused
+ *      waiting on Y." `thread_id` is the FK, nullable so detached
+ *      runs are fine.
+ *   2. **Standalone** — the run came from a one-shot `runTools(...)`
+ *      call (cron job, queued worker, ...). No thread context;
+ *      `thread_id` stays NULL.
+ *
+ * Columns:
+ *
+ *   - `id`                  ULID primary key. The id apps reference
+ *                           when resuming.
+ *   - `thread_id`           FK → `brain_thread`, NULLABLE,
+ *                           `onDelete: set null` — if the thread
+ *                           gets deleted, the suspended run keeps
+ *                           its data so the human approver can
+ *                           still inspect it.
+ *   - `user_id`             App-defined approver / owner.
+ *   - `pending_tool_calls`  JSONB — `ToolUseBlock[]` the model
+ *                           wants executed. Multi-call batches are
+ *                           captured together (mid-batch invariant).
+ *   - `state`               JSONB — `SuspendedState` snapshot. The
+ *                           framework's `brain.resumeTools(state,
+ *                           ...)` takes this as its first arg.
+ *   - `status`              `pending | resumed | cancelled`. Apps
+ *                           bulk-list pending runs and walk through
+ *                           an approval queue.
+ *   - `timestamps`          `created_at` for "how long pending?"
+ *                           sorts, `updated_at` for transition
+ *                           tracking.
+ *
+ * Tenanted: standard `tenant_id` + RLS.
+ */
+
+import { Archetype, defineSchema } from '@strav/database'
+import { brainThreadSchema } from './brain_thread_schema.ts'
+
+export const brainSuspendedRunSchema = defineSchema(
+  'brain_suspended_run',
+  Archetype.Entity,
+  (t) => {
+    t.id()
+    t.foreign('thread_id').to(brainThreadSchema).onDelete('set null').nullable()
+    t.string('user_id').max(64).nullable()
+    t.json('pending_tool_calls').notNull()
+    t.json('state').notNull()
+    t.enum('status', ['pending', 'resumed', 'cancelled']).notNull().default('pending')
+    t.timestamps()
+  },
+  { tenanted: true },
+)

package/src/persistence/schemas/brain_thread_schema.ts

@@ -0,0 +1,50 @@
+/**
+ * `brainThreadSchema` — one row per conversation.
+ *
+ * Carries the per-thread defaults that `Thread` already serializes
+ * (`system`, `options`, `lastResponseId`) plus a few framework-side
+ * fields apps want to filter / sort on:
+ *
+ *   - `id`            ULID primary key. Hand the same value back to
+ *                     `BrainStore.loadThread(id)` to rehydrate.
+ *   - `user_id`       App-defined owner. Stored as `text` (no FK) —
+ *                     user table shape varies per app. Indexed in
+ *                     the recommended migration so "list threads
+ *                     for user X" stays fast.
+ *   - `title`         Human label. Apps set it from the first user
+ *                     turn or via an explicit "rename" UI.
+ *   - `system`        Thread-owned system prompt. Mirrors
+ *                     `ThreadState.system`. JSONB so the structured
+ *                     form (text + cache flag) round-trips.
+ *   - `options`       Thread defaults applied to every `send()`.
+ *                     Mirrors `ThreadState.options`.
+ *   - `last_response_id`  OpenAI Responses API stateful pointer.
+ *                     Mirrors `ThreadState.lastResponseId`. NULL for
+ *                     non-Responses providers.
+ *   - `timestamps`    `created_at` + `updated_at` for sort / audit.
+ *
+ * Tenanted: `tenant_id` FK + RLS policies auto-injected by
+ * `@strav/database`. Apps wrap calls in `tenants.withTenant(...)`
+ * and the database enforces isolation — no app-level filter needed.
+ *
+ * The per-turn message history lives in `brain_message`, joined by
+ * `thread_id`. This keeps every send to an O(1) INSERT and makes
+ * pagination / per-turn analytics cheap.
+ */
+
+import { Archetype, defineSchema } from '@strav/database'
+
+export const brainThreadSchema = defineSchema(
+  'brain_thread',
+  Archetype.Entity,
+  (t) => {
+    t.id()
+    t.string('user_id').max(64).nullable()
+    t.string('title').max(255).nullable()
+    t.json('system').nullable()
+    t.json('options').nullable()
+    t.string('last_response_id').max(128).nullable()
+    t.timestamps()
+  },
+  { tenanted: true },
+)

package/src/persistence/schemas/index.ts

@@ -0,0 +1,3 @@
+export { brainMessageSchema } from './brain_message_schema.ts'
+export { brainSuspendedRunSchema } from './brain_suspended_run_schema.ts'
+export { brainThreadSchema } from './brain_thread_schema.ts'

package/src/suspended_run.ts

@@ -0,0 +1,153 @@
+/**
+ * `SuspendedRun` — what `runWithTools` (and `runner.run()`) returns
+ * when the agentic loop pauses because `shouldSuspend(call)` returned
+ * `true` for a tool the model wants to call.
+ *
+ * Use case: human-in-the-loop gating. The integrator inspects
+ * `pendingToolCalls`, obtains results out-of-band (human approval,
+ * external worker, queued job, ...), and calls
+ * `brain.resumeTools(state, results, ...)` or
+ * `runner.resume(state, results)` to continue the conversation.
+ *
+ * State model:
+ *   - `state.messages` contains every message exchanged up to and
+ *     including the assistant turn that requested the pending tool
+ *     calls. Resume picks up by appending tool_result blocks for
+ *     each pending call and re-entering the loop — no special
+ *     provider-level resume hook is needed.
+ *   - `state` is plain JSON — apps persist it across process
+ *     boundaries (e.g., one row per pending agent run in Postgres).
+ *
+ * Mid-batch invariant: when a tool call in a multi-call batch
+ * triggers suspension, ALL remaining calls in that same batch are
+ * captured together in `pendingToolCalls`. Apps MUST supply results
+ * for every entry on resume; otherwise the provider's
+ * tool_use / tool_result pairing becomes unbalanced and the next
+ * model call rejects.
+ */
+
+import { BrainError } from './brain_error.ts'
+import type {
+  ChatUsage,
+  ContentBlock,
+  Message,
+  ToolResultBlock,
+  ToolUseBlock,
+} from './types.ts'
+
+export interface SuspendedRun {
+  status: 'suspended'
+  /**
+   * The model's pending tool calls — the one that triggered the
+   * suspension, plus any unexecuted siblings from the same
+   * assistant turn. Match by `id` when supplying results.
+   */
+  pendingToolCalls: ToolUseBlock[]
+  /** JSON-serializable snapshot of the loop state at the suspension point. */
+  state: SuspendedState
+}
+
+export interface SuspendedState {
+  /** Full message history up to and including the suspending assistant turn. */
+  messages: Message[]
+  /** Iteration count at the suspension point — preserved across resume. */
+  iterations: number
+  /** Aggregated token usage across the iterations completed so far. */
+  usage: ChatUsage
+  /**
+   * Provider response id captured at the suspension point. When the
+   * provider supports stateful conversations (OpenAI Responses API),
+   * resume threads this back through `previousResponseId` so the
+   * model picks up exactly where it paused.
+   */
+  responseId?: string
+}
+
+/**
+ * Result of one pending tool call, supplied to `resumeTools`. The
+ * shape mirrors `ToolResultBlock` minus the `type` discriminator —
+ * the framework builds the block at resume time.
+ *
+ * To signal a failure (so the model adapts rather than crashing the
+ * loop), pass a string describing the error as `content` and set
+ * `isError: true`.
+ */
+export interface ToolResultInput {
+  toolUseId: string
+  content: string
+  isError?: boolean
+}
+
+/**
+ * Type guard. Convenient at call sites that need to discriminate
+ * between a completed `AgentResult` and a `SuspendedRun`.
+ *
+ * ```ts
+ * const out = await brain.runTools(prompt, tools, { shouldSuspend })
+ * if (isSuspended(out)) {
+ *   await persistForLater(out.pendingToolCalls, out.state)
+ *   return
+ * }
+ * render(out.text)
+ * ```
+ */
+export function isSuspended(value: unknown): value is SuspendedRun {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    (value as { status?: unknown }).status === 'suspended'
+  )
+}
+
+/**
+ * Append a `tool_result` user-role message to `state.messages` that
+ * carries one block per supplied result. Validates that the pending
+ * tool_use ids referenced in the latest assistant turn are all
+ * covered — missing results throw `BrainError` so the next provider
+ * call doesn't fail with an opaque "tool_use without tool_result"
+ * upstream error.
+ *
+ * Exported for `BrainManager.resumeTools` / `AgentRunner.resume`;
+ * tests can use it directly to verify resume mechanics without
+ * round-tripping through a provider.
+ */
+export function appendResumeResults(
+  state: SuspendedState,
+  results: readonly ToolResultInput[],
+): Message[] {
+  const pending = collectPendingIds(state.messages)
+  for (const id of pending) {
+    if (!results.some((r) => r.toolUseId === id)) {
+      throw new BrainError(
+        `resumeTools: missing result for pending tool call id "${id}". Every pending tool_use in the suspending assistant turn must be answered on resume.`,
+        { context: { pendingIds: [...pending], suppliedIds: results.map((r) => r.toolUseId) } },
+      )
+    }
+  }
+  const resultBlocks: ContentBlock[] = results.map((r) => {
+    const block: ToolResultBlock = {
+      type: 'tool_result',
+      toolUseId: r.toolUseId,
+      content: r.content,
+      ...(r.isError ? { isError: true } : {}),
+    }
+    return block
+  })
+  return [...state.messages, { role: 'user', content: resultBlocks }]
+}
+
+/**
+ * Look at the latest assistant turn in `messages` and pull every
+ * tool_use block's id. Used to validate resume coverage.
+ */
+function collectPendingIds(messages: readonly Message[]): string[] {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i]!
+    if (m.role !== 'assistant') continue
+    if (typeof m.content === 'string') return []
+    return m.content
+      .filter((b): b is ToolUseBlock => b.type === 'tool_use')
+      .map((b) => b.id)
+  }
+  return []
+}

package/src/thread.ts

@@ -35,6 +35,14 @@ export interface ThreadState {
   messages: Message[]
   system?: SystemPrompt
   options?: ChatOptions
+  /**
+   * Last provider response id captured by `send(...)` — restored on
+   * `fromJSON` so subsequent sends thread it via
+   * `ChatOptions.previousResponseId` automatically. Only ever set
+   * when the underlying provider surfaces `responseId` (OpenAI
+   * Responses API today).
+   */
+  lastResponseId?: string
 }
 
 export class Thread {
@@ -42,6 +50,13 @@ export class Thread {
   readonly messages: Message[] = []
   readonly system?: SystemPrompt
   readonly options?: ChatOptions
+  /**
+   * Last response id returned by the provider on this thread. Used to
+   * thread stateful-conversation hints (OpenAI Responses API) into
+   * the next `send(...)` so apps don't have to manage it manually.
+   * `undefined` for providers that don't surface a response id.
+   */
+  lastResponseId?: string
   private readonly brain: BrainManager
 
   constructor(brain: BrainManager, opts: ThreadOptions = {}) {
@@ -54,6 +69,11 @@ export class Thread {
    * Append a user turn, call the model, append the assistant reply,
    * and return the reply text. Per-call options override the
    * thread's defaults; `system` always comes from the thread.
+   *
+   * When the underlying provider supports stateful conversations
+   * (OpenAI Responses API), `previousResponseId` is auto-threaded
+   * from the prior turn — apps don't need to manage it. Per-call
+   * `options.previousResponseId` wins if supplied explicitly.
    */
   async send(text: string, options: ChatOptions = {}): Promise<string> {
     this.messages.push({ role: 'user', content: text })
@@ -65,8 +85,25 @@ export class Thread {
       // mid-thread by changing the system prompt every turn.
       ...(this.system !== undefined ? { system: this.system } : {}),
     }
+    if (
+      merged.previousResponseId === undefined &&
+      this.lastResponseId !== undefined
+    ) {
+      merged.previousResponseId = this.lastResponseId
+    }
     const result = await this.brain.chat(this.messages, merged)
-    this.messages.push({ role: 'assistant', content: result.text })
+    // Preserve structured assistant content when present (compaction
+    // blocks today; reasoning blocks later). Round-tripping these
+    // back to the provider on subsequent sends is what makes
+    // server-side compaction actually save tokens — once a turn
+    // carries a `compaction` block, the older raw turns drop out
+    // and the model only re-reads the summary.
+    if (result.content !== undefined && result.content.length > 0) {
+      this.messages.push({ role: 'assistant', content: result.content })
+    } else {
+      this.messages.push({ role: 'assistant', content: result.text })
+    }
+    if (result.responseId !== undefined) this.lastResponseId = result.responseId
     return result.text
   }
 
@@ -80,6 +117,7 @@ export class Thread {
     const state: ThreadState = { messages: [...this.messages] }
     if (this.system !== undefined) state.system = this.system
     if (this.options !== undefined) state.options = this.options
+    if (this.lastResponseId !== undefined) state.lastResponseId = this.lastResponseId
     return state
   }
 
@@ -94,6 +132,7 @@ export class Thread {
     if (state.options !== undefined) options.options = state.options
     const thread = new Thread(brain, options)
     for (const m of state.messages) thread.messages.push(m)
+    if (state.lastResponseId !== undefined) thread.lastResponseId = state.lastResponseId
     return thread
   }
 }

package/src/tool.ts

@@ -23,6 +23,13 @@ export interface ToolContext {
   readonly callId: string
   /** Per-run free-form context bag passed by the caller. Optional. */
   readonly context: Readonly<Record<string, unknown>>
+  /**
+   * Cancellation signal forwarded from the run's `options.signal`.
+   * Tools that wrap network calls (HTTP fetches, MCP servers, child
+   * processes) should pass this through so cancellation actually
+   * unwinds in-flight work.
+   */
+  readonly signal?: AbortSignal
 }
 
 export interface Tool<TInput = unknown, TOutput = unknown> {

package/src/tool_runner.ts

@@ -0,0 +1,81 @@
+/**
+ * `runToolWithRecovery` — shared helper used by every provider's
+ * agentic loop to execute one tool call.
+ *
+ * Encapsulates two error paths and the optional `onToolError`
+ * recovery callback:
+ *
+ *   1. **Tool not registered** — the model called a name that
+ *      isn't in `toolMap`. Without recovery, throw
+ *      `ToolExecutionError`. With recovery, the callback's return
+ *      string becomes the `tool_result.content` (with `isError:
+ *      true`) and the loop continues — the model sees "unknown
+ *      tool" and adapts.
+ *
+ *   2. **`execute()` throws** — the tool's body raised. Same
+ *      pattern: either rethrow as `ToolExecutionError` or feed
+ *      back as an error result.
+ *
+ * The returned shape is the framework-agnostic `{ content, isError }`
+ * pair each provider then wraps into its own `tool_result` block
+ * shape (Anthropic `tool_result` with `is_error`; OpenAI tool-role
+ * message content; Gemini `functionResponse` with `{ error }`).
+ */
+
+import type { RunWithToolsOptions } from './brain_driver.ts'
+import type { Tool, ToolContext } from './tool.ts'
+import { ToolExecutionError } from './tool_execution_error.ts'
+
+export interface ToolRunResult {
+  content: string
+  isError: boolean
+}
+
+export async function runToolWithRecovery(
+  tool: Tool | undefined,
+  toolName: string,
+  callId: string,
+  input: unknown,
+  options: RunWithToolsOptions,
+): Promise<ToolRunResult> {
+  if (!tool) {
+    return recoverOrThrow(
+      new ToolExecutionError(
+        toolName,
+        callId,
+        new Error(`Tool "${toolName}" is not registered.`),
+      ),
+      options,
+    )
+  }
+
+  const ctx: ToolContext = {
+    callId,
+    context: options.context ?? {},
+    ...(options.signal !== undefined ? { signal: options.signal } : {}),
+  }
+  let output: unknown
+  try {
+    output = await tool.execute(input, ctx)
+  } catch (cause) {
+    return recoverOrThrow(new ToolExecutionError(toolName, callId, cause), options)
+  }
+  return {
+    content: typeof output === 'string' ? output : JSON.stringify(output),
+    isError: false,
+  }
+}
+
+/**
+ * Resolve a `ToolExecutionError` through the `onToolError` callback
+ * (when set) or rethrow. Used by providers for failures that happen
+ * outside `tool.execute` — e.g., OpenAI's JSON-parse-arguments path.
+ */
+export function recoverOrThrow(
+  error: ToolExecutionError,
+  options: RunWithToolsOptions,
+): ToolRunResult {
+  const recovered = options.onToolError?.(error)
+  if (typeof recovered !== 'string') throw error
+  return { content: recovered, isError: true }
+}

package/src/translate/index.ts

@@ -0,0 +1,19 @@
+// Public API of `@strav/brain/translate`.
+//
+// LLM-backed translation primitive on top of `BrainManager`. Sonnet-
+// uniform by default (tier='balanced'), with parallel fan-out across
+// target languages, JSON-schema constrained output, prompt caching on
+// the system prompt, and a process-local LRU for repeat strings.
+
+export { TranslateCache, cacheKey } from './translate_cache.ts'
+export {
+  type TranslateConfig,
+  TranslatorProvider,
+} from './translate_provider.ts'
+export {
+  type BatchTranslateOptions,
+  DEFAULT_SYSTEM_PROMPT,
+  type TranslateOptions,
+  Translator,
+  type TranslatorOptions,
+} from './translator.ts'

package/src/translate/translate_cache.ts

@@ -0,0 +1,78 @@
+/**
+ * `TranslateCache` — tiny LRU keyed on `(model, from, to, text)`. Keeps
+ * repeated translations of the same phrase from hitting the model
+ * twice during a single fan-out (or during a batch where the same
+ * field value recurs across drafts).
+ *
+ * Intentionally in-memory + process-local. Apps that want persistent
+ * caching (e.g. across job retries / restarts) wrap their own
+ * Repository around `Translator` and call into it themselves; this
+ * cache exists to make the hot path cheap, not to be a system of
+ * record.
+ *
+ * Eviction is FIFO via Map insertion order — re-inserting on hit
+ * (`delete`+`set`) bumps the entry to the end so cold entries fall
+ * off first. `capacity: 0` disables the cache entirely.
+ */
+
+export class TranslateCache {
+  private readonly store = new Map<string, string>()
+
+  constructor(readonly capacity: number) {}
+
+  get(key: string): string | undefined {
+    if (this.capacity === 0) return undefined
+    const hit = this.store.get(key)
+    if (hit === undefined) return undefined
+    // Bump recency.
+    this.store.delete(key)
+    this.store.set(key, hit)
+    return hit
+  }
+
+  set(key: string, value: string): void {
+    if (this.capacity === 0) return
+    if (this.store.has(key)) this.store.delete(key)
+    this.store.set(key, value)
+    if (this.store.size > this.capacity) {
+      // Evict the oldest entry (the first key in insertion order).
+      const oldest = this.store.keys().next().value
+      if (oldest !== undefined) this.store.delete(oldest)
+    }
+  }
+
+  clear(): void {
+    this.store.clear()
+  }
+
+  get size(): number {
+    return this.store.size
+  }
+}
+
+/**
+ * Stable cache key for a single (text → language) translation.
+ * Inputs are joined with a separator that can't appear in BCP-47
+ * codes; the text is hashed (FNV-1a 32-bit) to keep keys bounded.
+ *
+ * Collision risk on FNV-1a 32-bit is non-zero but acceptable for a
+ * best-effort cache: the cost of a collision is one extra LLM call
+ * the next time the loser's text hashes to the same key.
+ */
+export function cacheKey(input: {
+  model: string
+  from: string | undefined
+  to: string
+  text: string
+}): string {
+  return `${input.model}|${input.from ?? 'auto'}|${input.to}|${fnv1a32(input.text)}`
+}
+
+function fnv1a32(text: string): string {
+  let hash = 0x811c9dc5
+  for (let i = 0; i < text.length; i++) {
+    hash ^= text.charCodeAt(i)
+    hash = (hash + ((hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24))) >>> 0
+  }
+  return hash.toString(16).padStart(8, '0')
+}

package/src/translate/translate_provider.ts

@@ -0,0 +1,46 @@
+/**
+ * `TranslatorProvider` — `ServiceProvider` that binds a default
+ * `Translator` singleton resolved against the registered
+ * `BrainManager`.
+ *
+ * Reads `config.brain.translate` (optional) for defaults — provider,
+ * tier, model, cacheSize. Apps that need multiple translators with
+ * different defaults (e.g. one for headlines, one for body) skip the
+ * provider and construct `new Translator({ brain, ... })` directly.
+ */
+
+import { type Application, ConfigRepository, ServiceProvider } from '@strav/kernel'
+import { BrainManager } from '../brain_manager.ts'
+import type { ModelTier } from '../types.ts'
+import { Translator } from './translator.ts'
+
+export interface TranslateConfig {
+  provider?: string
+  tier?: ModelTier
+  model?: string
+  systemPrompt?: string
+  cacheSize?: number
+  cache?: boolean
+}
+
+export class TranslatorProvider extends ServiceProvider {
+  override readonly name = 'brain.translate'
+  override readonly dependencies = ['brain']
+
+  override register(app: Application): void {
+    app.singleton(Translator, (c) => {
+      const brain = c.resolve(BrainManager)
+      const cfg =
+        (c.resolve(ConfigRepository).get('brain.translate') as TranslateConfig | undefined) ?? {}
+      return new Translator({
+        brain,
+        ...(cfg.provider !== undefined ? { provider: cfg.provider } : {}),
+        ...(cfg.tier !== undefined ? { tier: cfg.tier } : {}),
+        ...(cfg.model !== undefined ? { model: cfg.model } : {}),
+        ...(cfg.systemPrompt !== undefined ? { systemPrompt: cfg.systemPrompt } : {}),
+        ...(cfg.cacheSize !== undefined ? { cacheSize: cfg.cacheSize } : {}),
+        ...(cfg.cache !== undefined ? { cache: cfg.cache } : {}),
+      })
+    })
+  }
+}