@lota-sdk/core 0.1.17 → 0.1.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/core",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -32,7 +32,7 @@
     "@chat-adapter/slack": "^4.23.0",
     "@chat-adapter/state-ioredis": "^4.23.0",
     "@logtape/logtape": "^2.0.5",
-    "@lota-sdk/shared": "0.1.17",
+    "@lota-sdk/shared": "0.1.18",
     "@mendable/firecrawl-js": "^4.17.0",
     "@surrealdb/node": "^3.0.3",
     "ai": "^6.0.137",

package/src/{bifrost/bifrost.ts → ai-gateway/ai-gateway.ts}

@@ -3,26 +3,57 @@ import { createOpenAI } from '@ai-sdk/openai'
 import { wrapLanguageModel } from 'ai'
 import type { LanguageModelMiddleware } from 'ai'
 
-import { getRequiredEnv } from '../utils/env'
+import { getRuntimeConfig } from '../runtime/runtime-config'
 import { isRecord, readString } from '../utils/string'
 
-type BifrostLanguageModel = Parameters<typeof wrapLanguageModel>[0]['model']
-type BifrostExtraParams = Record<string, unknown>
-type BifrostChatResponse = { body?: unknown }
-type BifrostTransformParamsOptions = Parameters<NonNullable<LanguageModelMiddleware['transformParams']>>[0]
+type AiGatewayLanguageModel = Parameters<typeof wrapLanguageModel>[0]['model']
+type AiGatewayExtraParams = Record<string, unknown>
+type AiGatewayChatResponse = { body?: unknown }
+type AiGatewayTransformParamsOptions = Parameters<NonNullable<LanguageModelMiddleware['transformParams']>>[0]
 type WrapStreamOptions = Parameters<NonNullable<LanguageModelMiddleware['wrapStream']>>[0]
-type BifrostCallOptions = WrapStreamOptions['params']
-type BifrostGenerateResult = Awaited<ReturnType<WrapStreamOptions['doGenerate']>>
-type BifrostStreamResult = Awaited<ReturnType<WrapStreamOptions['doStream']>>
-type BifrostGeneratedContent = BifrostGenerateResult['content'][number]
-type BifrostStreamPart = BifrostStreamResult['stream'] extends ReadableStream<infer T> ? T : never
-
+type AiGatewayCallOptions = WrapStreamOptions['params']
+type AiGatewayGenerateResult = Awaited<ReturnType<WrapStreamOptions['doGenerate']>>
+type AiGatewayStreamResult = Awaited<ReturnType<WrapStreamOptions['doStream']>>
+type AiGatewayGeneratedContent = AiGatewayGenerateResult['content'][number]
+type AiGatewayStreamPart = AiGatewayStreamResult['stream'] extends ReadableStream<infer T> ? T : never
+type AiGatewayConfig = { apiKey: string; baseURL: string }
+
+const EXPECTED_GATEWAY_KEY_PREFIX = 'sk-bf-'
+const AI_GATEWAY_VIRTUAL_KEY_HEADER = 'x-bf-vk'
+const AI_GATEWAY_EXTRA_PARAMS_HEADER = 'x-bf-passthrough-extra-params'
+const DEFAULT_AI_GATEWAY_URL = 'https://ai-gateway.gobrainy.ai' as const
 const OPENROUTER_RESPONSE_HEALING_EXTRA_PARAMS = {
   plugins: [{ id: 'response-healing' }],
-} as const satisfies BifrostExtraParams
+} as const satisfies AiGatewayExtraParams
+
+function normalizeAiGatewayUrl(value: string): string {
+  const trimmed = value.trim()
+  if (!trimmed) {
+    throw new Error('[ai-gateway] AI gateway URL is required.')
+  }
+
+  const normalized = trimmed.replace(/\/+$/, '')
+  return normalized.endsWith('/v1') ? normalized : `${normalized}/v1`
+}
+
+function readDirectEnvAiGatewayConfig(): AiGatewayConfig {
+  const apiKey = (process.env.LOTA_KEY ?? process.env.VENTUROS_KEY ?? '').trim()
+  if (!apiKey) {
+    throw new Error(
+      '[ai-gateway] Missing AI gateway key. Set LOTA_KEY or VENTUROS_KEY, or configure createLotaRuntime({ aiGateway: { key } }).',
+    )
+  }
 
-function readRequiredGatewayEnv(name: 'AI_GATEWAY_KEY' | 'AI_GATEWAY_URL'): string {
-  return getRequiredEnv(name).trim()
+  return { apiKey, baseURL: normalizeAiGatewayUrl(process.env.AI_GATEWAY_URL?.trim() || DEFAULT_AI_GATEWAY_URL) }
+}
+
+function readAiGatewayConfig(): AiGatewayConfig {
+  try {
+    const { aiGateway } = getRuntimeConfig()
+    return { apiKey: aiGateway.key.trim(), baseURL: normalizeAiGatewayUrl(aiGateway.url) }
+  } catch {
+    return readDirectEnvAiGatewayConfig()
+  }
 }
 
 function readReasoningDetailsText(value: unknown): string | null {
@@ -41,7 +72,7 @@ function readReasoningDeltaText(value: unknown): string | null {
   return typeof value === 'string' && value.length > 0 ? value : null
 }
 
-function readBifrostChatReasoningText(message: Record<string, unknown>): string | null {
+function readAiGatewayChatReasoningText(message: Record<string, unknown>): string | null {
   return (
     readString(message.reasoning) ??
     readString(message.reasoning_content) ??
@@ -49,20 +80,20 @@ function readBifrostChatReasoningText(message: Record<string, unknown>): string
   )
 }
 
-export function extractBifrostChatReasoningText(responseBody: unknown): string | null {
+export function extractAiGatewayChatReasoningText(responseBody: unknown): string | null {
   if (!isRecord(responseBody) || !Array.isArray(responseBody.choices)) return null
 
   for (const choice of responseBody.choices) {
     if (!isRecord(choice) || !isRecord(choice.message)) continue
 
-    const reasoningText = readBifrostChatReasoningText(choice.message)
+    const reasoningText = readAiGatewayChatReasoningText(choice.message)
     if (reasoningText) return reasoningText
   }
 
   return null
 }
 
-export function extractBifrostChatReasoningDeltaText(rawChunk: unknown): string | null {
+export function extractAiGatewayChatReasoningDeltaText(rawChunk: unknown): string | null {
   if (!isRecord(rawChunk) || !Array.isArray(rawChunk.choices)) return null
 
   for (const choice of rawChunk.choices) {
@@ -78,9 +109,9 @@ export function extractBifrostChatReasoningDeltaText(rawChunk: unknown): string
   return null
 }
 
-type BifrostResponsesReasoningDelta = { id: string; delta: string; itemId: string }
+type AiGatewayResponsesReasoningDelta = { id: string; delta: string; itemId: string }
 
-export function extractBifrostResponsesReasoningDelta(rawChunk: unknown): BifrostResponsesReasoningDelta | null {
+export function extractAiGatewayResponsesReasoningDelta(rawChunk: unknown): AiGatewayResponsesReasoningDelta | null {
   if (!isRecord(rawChunk) || rawChunk.type !== 'response.reasoning_summary_text.delta') return null
   if ('summary_index' in rawChunk) return null
 
@@ -91,21 +122,21 @@ export function extractBifrostResponsesReasoningDelta(rawChunk: unknown): Bifros
   return { id: `${itemId}:0`, delta, itemId }
 }
 
-export function injectBifrostChatReasoningContent(
-  content: readonly BifrostGeneratedContent[],
-  response?: BifrostChatResponse,
-): BifrostGeneratedContent[] {
+export function injectAiGatewayChatReasoningContent(
+  content: readonly AiGatewayGeneratedContent[],
+  response?: AiGatewayChatResponse,
+): AiGatewayGeneratedContent[] {
   if (content.some((part) => part.type === 'reasoning')) {
     return [...content]
   }
 
-  const reasoningText = extractBifrostChatReasoningText(response?.body)
+  const reasoningText = extractAiGatewayChatReasoningText(response?.body)
   if (!reasoningText) return [...content]
 
   return [{ type: 'reasoning', text: reasoningText }, ...content]
 }
 
-function isReasoningEnabled(params: BifrostCallOptions): boolean {
+function isReasoningEnabled(params: AiGatewayCallOptions): boolean {
   if (!isRecord(params.providerOptions) || !isRecord(params.providerOptions.openai)) return false
 
   const openaiOptions = params.providerOptions.openai
@@ -114,34 +145,34 @@ function isReasoningEnabled(params: BifrostCallOptions): boolean {
   return typeof openaiOptions.reasoningEffort === 'string' && openaiOptions.reasoningEffort !== 'none'
 }
 
-function shouldCloseInjectedReasoning(chunk: BifrostStreamPart): boolean {
+function shouldCloseInjectedReasoning(chunk: AiGatewayStreamPart): boolean {
   return chunk.type !== 'stream-start' && chunk.type !== 'response-metadata' && chunk.type !== 'raw'
 }
 
-export function injectBifrostChatReasoningStream(
-  stream: ReadableStream<BifrostStreamPart>,
-): ReadableStream<BifrostStreamPart> {
-  const reasoningId = 'bifrost-reasoning-0'
+export function injectAiGatewayChatReasoningStream(
+  stream: ReadableStream<AiGatewayStreamPart>,
+): ReadableStream<AiGatewayStreamPart> {
+  const reasoningId = 'ai-gateway-reasoning-0'
   let reasoningOpen = false
   let reasoningClosed = false
 
   return stream.pipeThrough(
-    new TransformStream<BifrostStreamPart, BifrostStreamPart>({
+    new TransformStream<AiGatewayStreamPart, AiGatewayStreamPart>({
       transform(chunk, controller) {
         const closeReasoning = () => {
           if (!reasoningOpen || reasoningClosed) return
 
-          controller.enqueue({ type: 'reasoning-end', id: reasoningId } satisfies BifrostStreamPart)
+          controller.enqueue({ type: 'reasoning-end', id: reasoningId } satisfies AiGatewayStreamPart)
           reasoningClosed = true
         }
 
         if (chunk.type === 'raw') {
-          const reasoningDelta = reasoningClosed ? null : extractBifrostChatReasoningDeltaText(chunk.rawValue)
+          const reasoningDelta = reasoningClosed ? null : extractAiGatewayChatReasoningDeltaText(chunk.rawValue)
           controller.enqueue(chunk)
 
           if (reasoningDelta) {
             if (!reasoningOpen) {
-              controller.enqueue({ type: 'reasoning-start', id: reasoningId } satisfies BifrostStreamPart)
+              controller.enqueue({ type: 'reasoning-start', id: reasoningId } satisfies AiGatewayStreamPart)
               reasoningOpen = true
             }
 
@@ -149,7 +180,7 @@ export function injectBifrostChatReasoningStream(
               type: 'reasoning-delta',
               id: reasoningId,
               delta: reasoningDelta,
-            } satisfies BifrostStreamPart)
+            } satisfies AiGatewayStreamPart)
           }
           return
         }
@@ -162,23 +193,23 @@ export function injectBifrostChatReasoningStream(
       },
       flush(controller) {
         if (!reasoningOpen || reasoningClosed) return
-        controller.enqueue({ type: 'reasoning-end', id: reasoningId } satisfies BifrostStreamPart)
+        controller.enqueue({ type: 'reasoning-end', id: reasoningId } satisfies AiGatewayStreamPart)
       },
     }),
   )
 }
 
-export function injectBifrostResponsesReasoningStream(
-  stream: ReadableStream<BifrostStreamPart>,
-): ReadableStream<BifrostStreamPart> {
+export function injectAiGatewayResponsesReasoningStream(
+  stream: ReadableStream<AiGatewayStreamPart>,
+): ReadableStream<AiGatewayStreamPart> {
   return stream.pipeThrough(
-    new TransformStream<BifrostStreamPart, BifrostStreamPart>({
+    new TransformStream<AiGatewayStreamPart, AiGatewayStreamPart>({
       transform(chunk, controller) {
         controller.enqueue(chunk)
 
         if (chunk.type !== 'raw') return
 
-        const reasoningDelta = extractBifrostResponsesReasoningDelta(chunk.rawValue)
+        const reasoningDelta = extractAiGatewayResponsesReasoningDelta(chunk.rawValue)
         if (!reasoningDelta) return
 
         controller.enqueue({
@@ -186,16 +217,16 @@ export function injectBifrostResponsesReasoningStream(
           id: reasoningDelta.id,
           delta: reasoningDelta.delta,
           providerMetadata: { openai: { itemId: reasoningDelta.itemId } },
-        } satisfies BifrostStreamPart)
+        } satisfies AiGatewayStreamPart)
       },
     }),
   )
 }
 
-function addBifrostReasoningRawChunks(
-  params: BifrostCallOptions,
-  type: BifrostTransformParamsOptions['type'],
-): BifrostCallOptions {
+function addAiGatewayReasoningRawChunks(
+  params: AiGatewayCallOptions,
+  type: AiGatewayTransformParamsOptions['type'],
+): AiGatewayCallOptions {
   if (type !== 'stream' || !isReasoningEnabled(params) || params.includeRawChunks === true) {
     return params
   }
@@ -203,9 +234,9 @@ function addBifrostReasoningRawChunks(
   return { ...params, includeRawChunks: true }
 }
 
-export function injectBifrostExtraParamsRequestBody(
+export function injectAiGatewayExtraParamsRequestBody(
   body: BodyInit | null | undefined,
-  extraParams: BifrostExtraParams,
+  extraParams: AiGatewayExtraParams,
 ): BodyInit | null | undefined {
   if (typeof body !== 'string') return body
 
@@ -225,87 +256,90 @@ export function injectBifrostExtraParamsRequestBody(
   return JSON.stringify({ ...parsed, extra_params: mergedExtraParams })
 }
 
-function createBifrostFetchWithExtraParams(extraParams: BifrostExtraParams): typeof fetch {
+function createAiGatewayFetchWithExtraParams(extraParams: AiGatewayExtraParams): typeof fetch {
   const fetchWithExtraParams = (input: RequestInfo | URL, init?: RequestInit | BunFetchRequestInit) =>
-    globalThis.fetch(input, { ...init, body: injectBifrostExtraParamsRequestBody(init?.body, extraParams) })
+    globalThis.fetch(input, { ...init, body: injectAiGatewayExtraParamsRequestBody(init?.body, extraParams) })
 
   return Object.assign(fetchWithExtraParams, { preconnect: globalThis.fetch.preconnect.bind(globalThis.fetch) })
 }
 
-function createBifrostProvider(extraParams?: BifrostExtraParams) {
-  const apiKey = readRequiredGatewayEnv('AI_GATEWAY_KEY')
-  if (!apiKey.startsWith('sk-bf-')) {
-    throw new Error('[bifrost] AI_GATEWAY_KEY must use the Bifrost virtual-key format (sk-bf-*).')
+function createAiGatewayProvider(extraParams?: AiGatewayExtraParams) {
+  const { apiKey, baseURL } = readAiGatewayConfig()
+  if (!apiKey.startsWith(EXPECTED_GATEWAY_KEY_PREFIX)) {
+    throw new Error(`[ai-gateway] Gateway keys must use the ${EXPECTED_GATEWAY_KEY_PREFIX}* format.`)
   }
 
   return createOpenAI({
-    baseURL: readRequiredGatewayEnv('AI_GATEWAY_URL'),
+    baseURL,
     apiKey,
-    headers: { 'x-bf-vk': apiKey, ...(extraParams ? { 'x-bf-passthrough-extra-params': 'true' } : {}) },
-    ...(extraParams ? { fetch: createBifrostFetchWithExtraParams(extraParams) } : {}),
+    headers: {
+      [AI_GATEWAY_VIRTUAL_KEY_HEADER]: apiKey,
+      ...(extraParams ? { [AI_GATEWAY_EXTRA_PARAMS_HEADER]: 'true' } : {}),
+    },
+    ...(extraParams ? { fetch: createAiGatewayFetchWithExtraParams(extraParams) } : {}),
   })
 }
 
-function withBifrostDevTools<TModel extends BifrostLanguageModel>(model: TModel): TModel {
+function withAiGatewayDevTools<TModel extends AiGatewayLanguageModel>(model: TModel): TModel {
   return wrapLanguageModel({ model, middleware: devToolsMiddleware() }) as TModel
 }
 
 let provider: ReturnType<typeof createOpenAI> | null = null
 let openRouterResponseHealingProvider: ReturnType<typeof createOpenAI> | null = null
 
-export function getBifrostProvider() {
+export function getAiGatewayProvider() {
   if (provider) return provider
 
-  provider = createBifrostProvider()
+  provider = createAiGatewayProvider()
 
   return provider
 }
 
-export function getBifrostOpenRouterResponseHealingProvider() {
+export function getAiGatewayOpenRouterResponseHealingProvider() {
   if (openRouterResponseHealingProvider) return openRouterResponseHealingProvider
 
-  openRouterResponseHealingProvider = createBifrostProvider(OPENROUTER_RESPONSE_HEALING_EXTRA_PARAMS)
+  openRouterResponseHealingProvider = createAiGatewayProvider(OPENROUTER_RESPONSE_HEALING_EXTRA_PARAMS)
 
   return openRouterResponseHealingProvider
 }
 
-export function bifrostModel(modelId: string) {
-  return withBifrostDevTools(
+export function aiGatewayModel(modelId: string) {
+  return withAiGatewayDevTools(
     wrapLanguageModel({
-      model: getBifrostProvider()(modelId),
+      model: getAiGatewayProvider()(modelId),
       middleware: {
         specificationVersion: 'v3',
-        transformParams: async ({ params, type }) => addBifrostReasoningRawChunks(params, type),
+        transformParams: async ({ params, type }) => addAiGatewayReasoningRawChunks(params, type),
         wrapStream: async ({ doStream, params }) => {
           const result = await doStream()
           if (!isReasoningEnabled(params)) return result
 
-          return { ...result, stream: injectBifrostResponsesReasoningStream(result.stream) }
+          return { ...result, stream: injectAiGatewayResponsesReasoningStream(result.stream) }
         },
       },
     }),
   )
 }
 
-export function bifrostOpenRouterResponseHealingModel(modelId: string) {
-  return withBifrostDevTools(getBifrostOpenRouterResponseHealingProvider()(modelId))
+export function aiGatewayOpenRouterResponseHealingModel(modelId: string) {
+  return withAiGatewayDevTools(getAiGatewayOpenRouterResponseHealingProvider()(modelId))
 }
 
-export function bifrostChatModel(modelId: string) {
-  return withBifrostDevTools(
+export function aiGatewayChatModel(modelId: string) {
+  return withAiGatewayDevTools(
     wrapLanguageModel({
-      model: getBifrostProvider().chat(modelId),
+      model: getAiGatewayProvider().chat(modelId),
       middleware: {
         specificationVersion: 'v3',
-        transformParams: async ({ params, type }) => addBifrostReasoningRawChunks(params, type),
+        transformParams: async ({ params, type }) => addAiGatewayReasoningRawChunks(params, type),
         wrapGenerate: async ({ doGenerate }) => {
           const result = await doGenerate()
 
           return {
             ...result,
-            content: injectBifrostChatReasoningContent(
+            content: injectAiGatewayChatReasoningContent(
               result.content,
-              result.response as BifrostChatResponse | undefined,
+              result.response as AiGatewayChatResponse | undefined,
             ),
           }
         },
@@ -313,13 +347,15 @@ export function bifrostChatModel(modelId: string) {
           const result = await doStream()
           if (!isReasoningEnabled(params)) return result
 
-          return { ...result, stream: injectBifrostChatReasoningStream(result.stream) }
+          return { ...result, stream: injectAiGatewayChatReasoningStream(result.stream) }
         },
       },
     }),
   )
 }
 
-export function bifrostEmbeddingModel(modelId: string) {
-  return getBifrostProvider().embeddingModel(modelId)
+export function aiGatewayEmbeddingModel(modelId: string) {
+  return getAiGatewayProvider().embeddingModel(modelId)
 }
+
+export { DEFAULT_AI_GATEWAY_URL, normalizeAiGatewayUrl }

package/src/ai-gateway/cache-headers.ts

@@ -0,0 +1,8 @@
+const AI_GATEWAY_CACHE_KEY_HEADER = 'x-bf-cache-key'
+const AI_GATEWAY_CACHE_TTL_HEADER = 'x-bf-cache-ttl'
+
+export function buildAiGatewayCacheHeaders(cacheKey: string, ttl?: string): Record<string, string> {
+  const headers: Record<string, string> = { [AI_GATEWAY_CACHE_KEY_HEADER]: cacheKey }
+  if (ttl) headers[AI_GATEWAY_CACHE_TTL_HEADER] = ttl
+  return headers
+}

package/src/{bifrost → ai-gateway}/index.ts

@@ -1,2 +1,2 @@
-export * from './bifrost'
+export * from './ai-gateway'
 export * from './cache-headers'

package/src/config/model-constants.ts

@@ -1,5 +1,5 @@
 export {
-  BIFROST_REASONING_SUMMARY_LEVEL,
+  AI_GATEWAY_REASONING_SUMMARY_LEVEL,
   OPENAI_HIGH_REASONING_PROVIDER_OPTIONS,
   OPENAI_REASONING_MODEL_ID,
   OPENROUTER_DELEGATED_REASONING_MODEL_ID,

package/src/embeddings/provider.ts

@@ -1,7 +1,7 @@
 import { embed, embedMany } from 'ai'
 
+import { aiGatewayEmbeddingModel } from '../ai-gateway/ai-gateway'
 import { getEmbeddingCache } from '../ai/embedding-cache'
-import { bifrostEmbeddingModel } from '../bifrost/bifrost'
 import { getRuntimeConfig } from '../runtime/runtime-config'
 
 const SUPPORTED_EMBEDDING_PREFIXES = ['openai/', 'openrouter/'] as const
@@ -30,7 +30,7 @@ function resolveEmbeddingModel(modelId: string) {
     )
   }
 
-  return bifrostEmbeddingModel(normalized)
+  return aiGatewayEmbeddingModel(normalized)
 }
 
 function normalizeEmbedding(embedding: readonly number[]): number[] {

package/src/index.ts

@@ -1,6 +1,6 @@
 export * from './create-runtime'
 export * from './ai'
-export * from './bifrost'
+export * from './ai-gateway'
 export * from './config'
 export * from './db'
 export * from './document'

package/src/runtime/runtime-config.ts

@@ -220,8 +220,6 @@ export const LotaRuntimeConfigSchema = z.object({
   aiGateway: z.object({
     url: z.string().trim().min(1),
     key: z.string().trim().min(1),
-    admin: z.string().trim().min(1).optional(),
-    pass: z.string().trim().min(1).optional(),
     embeddingModel: z.string().trim().min(1).default('openai/text-embedding-3-small'),
   }),
   s3: z.object({
@@ -294,9 +292,7 @@ export const LOTA_RUNTIME_ENV_KEYS = Object.freeze([
   'SURREALDB_PASSWORD',
   'REDIS_URL',
   'AI_GATEWAY_URL',
-  'AI_GATEWAY_KEY',
-  'AI_GATEWAY_ADMIN',
-  'AI_GATEWAY_PASS',
+  'LOTA_KEY',
   'AI_EMBEDDING_MODEL',
   'S3_ENDPOINT',
   'S3_BUCKET',

package/src/system-agents/context-compaction.agent.ts

@@ -1,7 +1,7 @@
 import { ToolLoopAgent } from 'ai'
 
-import { bifrostOpenRouterResponseHealingModel } from '../bifrost/bifrost'
-import { buildBifrostCacheHeaders } from '../bifrost/cache-headers'
+import { aiGatewayOpenRouterResponseHealingModel } from '../ai-gateway/ai-gateway'
+import { buildAiGatewayCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
   OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
@@ -40,8 +40,8 @@ Return valid data for:
 export function createContextCompactionAgent(options: CreateHelperToolLoopAgentOptions) {
   return new ToolLoopAgent({
     id: 'context-compaction',
-    model: bifrostOpenRouterResponseHealingModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
-    headers: buildBifrostCacheHeaders('context-compaction'),
+    model: aiGatewayOpenRouterResponseHealingModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+    headers: buildAiGatewayCacheHeaders('context-compaction'),
     providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
     ...resolveHelperAgentOptions(options, { instructions: CONTEXT_COMPACTION_PROMPT }),
   })

package/src/system-agents/memory-reranker.agent.ts

@@ -1,7 +1,7 @@
 import { ToolLoopAgent } from 'ai'
 
-import { bifrostOpenRouterResponseHealingModel } from '../bifrost/bifrost'
-import { buildBifrostCacheHeaders } from '../bifrost/cache-headers'
+import { aiGatewayOpenRouterResponseHealingModel } from '../ai-gateway/ai-gateway'
+import { buildAiGatewayCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_LOW_REASONING_PROVIDER_OPTIONS,
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
@@ -32,8 +32,8 @@ Set every item.relevance as a string; use empty string when no reason is needed.
 export function createMemoryRerankerAgent(options: CreateHelperToolLoopAgentOptions) {
   return new ToolLoopAgent({
     id: 'memory-reranker',
-    model: bifrostOpenRouterResponseHealingModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
-    headers: buildBifrostCacheHeaders('memory-reranker'),
+    model: aiGatewayOpenRouterResponseHealingModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+    headers: buildAiGatewayCacheHeaders('memory-reranker'),
     providerOptions: OPENROUTER_LOW_REASONING_PROVIDER_OPTIONS,
     ...resolveHelperAgentOptions(options),
   })

package/src/system-agents/memory.agent.ts

@@ -1,7 +1,7 @@
 import { ToolLoopAgent } from 'ai'
 
-import { bifrostOpenRouterResponseHealingModel } from '../bifrost/bifrost'
-import { buildBifrostCacheHeaders } from '../bifrost/cache-headers'
+import { aiGatewayOpenRouterResponseHealingModel } from '../ai-gateway/ai-gateway'
+import { buildAiGatewayCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
   OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
@@ -52,8 +52,8 @@ Return only the schema fields with no extra formatting.
 export function createOrgMemoryAgent(options: CreateHelperToolLoopAgentOptions) {
   return new ToolLoopAgent({
     id: 'org-memory',
-    model: bifrostOpenRouterResponseHealingModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
-    headers: buildBifrostCacheHeaders('org-memory'),
+    model: aiGatewayOpenRouterResponseHealingModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+    headers: buildAiGatewayCacheHeaders('org-memory'),
     providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
     ...resolveHelperAgentOptions(options),
   })

package/src/system-agents/recent-activity-title-refiner.agent.ts

@@ -1,7 +1,7 @@
 import { ToolLoopAgent } from 'ai'
 
-import { bifrostModel } from '../bifrost/bifrost'
-import { buildBifrostCacheHeaders } from '../bifrost/cache-headers'
+import { aiGatewayModel } from '../ai-gateway/ai-gateway'
+import { buildAiGatewayCacheHeaders } from '../ai-gateway/cache-headers'
 import { getLeadAgentDisplayName } from '../config/agent-defaults'
 import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
@@ -79,8 +79,8 @@ Return only the title text. No quotes, labels, JSON, markdown, or explanation.
 export function createRecentActivityTitleRefinerAgent(options: CreateHelperToolLoopAgentOptions) {
   return new ToolLoopAgent({
     id: 'recent-activity-title-refiner',
-    model: bifrostModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
-    headers: buildBifrostCacheHeaders('recent-activity-title-refiner'),
+    model: aiGatewayModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+    headers: buildAiGatewayCacheHeaders('recent-activity-title-refiner'),
     providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
     ...resolveHelperAgentOptions(options, {
       instructions: buildRecentActivityTitleRefinerPrompt(),

package/src/system-agents/regular-chat-memory-digest.agent.ts

@@ -1,7 +1,7 @@
 import { ToolLoopAgent } from 'ai'
 
-import { bifrostOpenRouterResponseHealingModel } from '../bifrost/bifrost'
-import { buildBifrostCacheHeaders } from '../bifrost/cache-headers'
+import { aiGatewayOpenRouterResponseHealingModel } from '../ai-gateway/ai-gateway'
+import { buildAiGatewayCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
   OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
@@ -66,8 +66,8 @@ Return only schema fields.
 export function createRegularChatMemoryDigestAgent(options: CreateHelperToolLoopAgentOptions) {
   return new ToolLoopAgent({
     id: 'regular-chat-memory-digest',
-    model: bifrostOpenRouterResponseHealingModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
-    headers: buildBifrostCacheHeaders('regular-chat-memory-digest'),
+    model: aiGatewayOpenRouterResponseHealingModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+    headers: buildAiGatewayCacheHeaders('regular-chat-memory-digest'),
     providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
     ...resolveHelperAgentOptions(options, {
       instructions: regularChatMemoryDigestPrompt,

package/src/system-agents/skill-extractor.agent.ts

@@ -1,8 +1,8 @@
 import { ToolLoopAgent } from 'ai'
 import { z } from 'zod'
 
-import { bifrostOpenRouterResponseHealingModel } from '../bifrost/bifrost'
-import { buildBifrostCacheHeaders } from '../bifrost/cache-headers'
+import { aiGatewayOpenRouterResponseHealingModel } from '../ai-gateway/ai-gateway'
+import { buildAiGatewayCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
   OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
@@ -79,8 +79,8 @@ export type SkillCandidate = z.infer<typeof SkillCandidateSchema>
 export function createSkillExtractorAgent(options: CreateHelperToolLoopAgentOptions) {
   return new ToolLoopAgent({
     id: 'skill-extractor',
-    model: bifrostOpenRouterResponseHealingModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
-    headers: buildBifrostCacheHeaders('skill-extractor'),
+    model: aiGatewayOpenRouterResponseHealingModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+    headers: buildAiGatewayCacheHeaders('skill-extractor'),
     providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
     ...resolveHelperAgentOptions(options, {
       instructions: skillExtractorPrompt,

package/src/system-agents/skill-manager.agent.ts

@@ -1,8 +1,8 @@
 import { ToolLoopAgent } from 'ai'
 import { z } from 'zod'
 
-import { bifrostOpenRouterResponseHealingModel } from '../bifrost/bifrost'
-import { buildBifrostCacheHeaders } from '../bifrost/cache-headers'
+import { aiGatewayOpenRouterResponseHealingModel } from '../ai-gateway/ai-gateway'
+import { buildAiGatewayCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
   OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
@@ -69,8 +69,8 @@ export const SkillManagerOutputSchema = z.object({
 export function createSkillManagerAgent(options: CreateHelperToolLoopAgentOptions) {
   return new ToolLoopAgent({
     id: 'skill-manager',
-    model: bifrostOpenRouterResponseHealingModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
-    headers: buildBifrostCacheHeaders('skill-manager'),
+    model: aiGatewayOpenRouterResponseHealingModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+    headers: buildAiGatewayCacheHeaders('skill-manager'),
     providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
     ...resolveHelperAgentOptions(options, {
       instructions: skillManagerPrompt,

package/src/system-agents/title-generator.agent.ts

@@ -1,7 +1,7 @@
 import { ToolLoopAgent } from 'ai'
 
-import { bifrostModel } from '../bifrost/bifrost'
-import { buildBifrostCacheHeaders } from '../bifrost/cache-headers'
+import { aiGatewayModel } from '../ai-gateway/ai-gateway'
+import { buildAiGatewayCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_FAST_REASONING_MODEL_ID,
   OPENROUTER_MINIMAL_REASONING_PROVIDER_OPTIONS,
@@ -33,8 +33,8 @@ Return only the title text. No quotes, no labels, no explanation.
 export function createWorkstreamTitleGeneratorAgent(options: CreateHelperToolLoopAgentOptions) {
   return new ToolLoopAgent({
     id: 'workstream-title-generator',
-    model: bifrostModel(OPENROUTER_FAST_REASONING_MODEL_ID),
-    headers: buildBifrostCacheHeaders('workstream-title-generator'),
+    model: aiGatewayModel(OPENROUTER_FAST_REASONING_MODEL_ID),
+    headers: buildAiGatewayCacheHeaders('workstream-title-generator'),
     providerOptions: OPENROUTER_MINIMAL_REASONING_PROVIDER_OPTIONS,
     ...resolveHelperAgentOptions(options, {
       instructions: WORKSTREAM_TITLE_GENERATOR_PROMPT,

package/src/tools/research-topic.tool.ts

@@ -1,5 +1,5 @@
-import { bifrostChatModel } from '../bifrost/bifrost'
-import { buildBifrostCacheHeaders } from '../bifrost/cache-headers'
+import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
+import { buildAiGatewayCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_MEDIUM_REASONING_PROVIDER_OPTIONS,
   OPENROUTER_WEB_RESEARCH_MODEL_ID,
@@ -13,9 +13,9 @@ export const researchTopicTool = createDelegatedAgentTool({
   id: 'researchTopic',
   description:
     'Delegate a research task to a dedicated research agent that searches the web, fetches pages, and returns a synthesized markdown report. Call multiple instances in parallel for broad research across different topics.',
-  model: () => bifrostChatModel(OPENROUTER_WEB_RESEARCH_MODEL_ID),
+  model: () => aiGatewayChatModel(OPENROUTER_WEB_RESEARCH_MODEL_ID),
   providerOptions: OPENROUTER_MEDIUM_REASONING_PROVIDER_OPTIONS,
-  headers: buildBifrostCacheHeaders('researchTopic'),
+  headers: buildAiGatewayCacheHeaders('researchTopic'),
   instructions: RESEARCHER_PROMPT,
   tools: { searchWeb: searchWebTool.create(), fetchWebpage: fetchWebpageTool.create() },
 })

package/src/bifrost/cache-headers.ts

@@ -1,8 +0,0 @@
-const BIFROST_CACHE_KEY_HEADER = 'x-bf-cache-key'
-const BIFROST_CACHE_TTL_HEADER = 'x-bf-cache-ttl'
-
-export function buildBifrostCacheHeaders(cacheKey: string, ttl?: string): Record<string, string> {
-  const headers: Record<string, string> = { [BIFROST_CACHE_KEY_HEADER]: cacheKey }
-  if (ttl) headers[BIFROST_CACHE_TTL_HEADER] = ttl
-  return headers
-}