@lota-sdk/core 0.4.9 → 0.4.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lota-sdk/core",
-  "version": "0.4.9",
+  "version": "0.4.11",
   "type": "module",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -31,7 +31,7 @@
     "@ai-sdk/openai": "^3.0.53",
     "@chat-adapter/slack": "^4.26.0",
     "@chat-adapter/state-ioredis": "^4.26.0",
-    "@lota-sdk/shared": "0.4.9",
+    "@lota-sdk/shared": "0.4.11",
     "@mendable/firecrawl-js": "^4.18.3",
     "@surrealdb/node": "^3.0.3",
     "ai": "^6.0.167",

package/src/ai/embedding-cache.ts

@@ -107,7 +107,9 @@ export class EmbeddingCache {
   }
 }
 
-export class EmbeddingCacheTag extends Context.Service<EmbeddingCacheTag, EmbeddingCache>()('EmbeddingCache') {}
+export class EmbeddingCacheTag extends Context.Service<EmbeddingCacheTag, EmbeddingCache>()(
+  '@lota-sdk/core/EmbeddingCache',
+) {}
 
 export const EmbeddingCacheLive = Layer.effect(
   EmbeddingCacheTag,

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

@@ -6,7 +6,6 @@ import { Cause, Clock, Context, Duration, Effect, ExecutionPlan, Fiber, Layer, S
 
 import { DEFAULT_AI_GATEWAY_URL } from '../config/constants'
 import { AiGenerationError, ConfigurationError } from '../effect/errors'
-import { getLotaSdkRuntime } from '../effect/runtime'
 import { RuntimeConfigServiceTag } from '../effect/services'
 import { getDirectOpenRouterProvider, normalizeDirectOpenRouterModelId } from '../openrouter/direct-provider'
 import { isRecord, readString } from '../utils/string'
@@ -24,16 +23,18 @@ type AiGatewayGeneratedContent = AiGatewayGenerateResult['content'][number]
 type AiGatewayStreamPart = AiGatewayStreamResult['stream'] extends ReadableStream<infer T> ? T : never
 type AiGatewayProviderOptions = NonNullable<AiGatewayCallOptions['providerOptions']>
 type AiGatewayAttemptResult<A> = { source: string; result: A }
+// eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents
+type AiGatewayRunFork = <A, E>(effect: Effect.Effect<A, E, never>) => Fiber.Fiber<A, E | unknown>
 
 class AiGatewayGenerateAttempt extends Context.Service<
   AiGatewayGenerateAttempt,
   { readonly execute: Effect.Effect<AiGatewayAttemptResult<AiGatewayGenerateResult>, AiGenerationError> }
->()('AiGatewayGenerateAttempt') {}
+>()('@lota-sdk/core/internal/AiGatewayGenerateAttempt') {}
 
 class AiGatewayStreamAttempt extends Context.Service<
   AiGatewayStreamAttempt,
   { readonly execute: Effect.Effect<AiGatewayAttemptResult<AiGatewayStreamResult>, AiGenerationError> }
->()('AiGatewayStreamAttempt') {}
+>()('@lota-sdk/core/internal/AiGatewayStreamAttempt') {}
 
 const EXPECTED_GATEWAY_KEY_PREFIX = 'sk-bf-'
 const AI_GATEWAY_VIRTUAL_KEY_HEADER = 'x-bf-vk'
@@ -69,6 +70,10 @@ const RETRYABLE_NETWORK_ERROR_PATTERNS = [
   /timed out/i,
 ]
 
+function isAiGenerationError(error: unknown): error is AiGenerationError {
+  return isRecord(error) && error._tag === 'AiGenerationError'
+}
+
 function getNumericField(value: Record<string, unknown>, key: string): number | null {
   const field = value[key]
   if (typeof field === 'number' && Number.isFinite(field)) return field
@@ -156,7 +161,7 @@ function stringifyProviderField(value: unknown, maxLength: number): string | und
 }
 
 function classifyAiGatewayError(source: string, error: unknown): AiGenerationError {
-  if (error instanceof AiGenerationError) {
+  if (isAiGenerationError(error)) {
     return error
   }
 
@@ -267,12 +272,13 @@ function withAiGatewayResilience<A>(source: string, effect: Effect.Effect<A, AiG
 function withAiGatewayStreamIdleTimeout(
   stream: ReadableStream<AiGatewayStreamPart>,
   source: string,
+  runFork: AiGatewayRunFork,
   onFinalize?: () => void,
 ): ReadableStream<AiGatewayStreamPart> {
   let closed = false
   let reader: ReadableStreamDefaultReader<AiGatewayStreamPart> | null = null
-  let idleTimeoutFiber: ReturnType<typeof Effect.runFork> | null = null
-  let bodyPumpFiber: ReturnType<typeof Effect.runFork> | null = null
+  let idleTimeoutFiber: Fiber.Fiber<unknown, unknown> | null = null
+  let bodyPumpFiber: Fiber.Fiber<unknown, unknown> | null = null
   let finalized = false
 
   const finalize = () => {
@@ -281,9 +287,9 @@ function withAiGatewayStreamIdleTimeout(
     onFinalize?.()
   }
 
-  const interruptFiber = (fiber: ReturnType<typeof Effect.runFork> | null) => {
+  const interruptFiber = (fiber: Fiber.Fiber<unknown, unknown> | null) => {
     if (!fiber) return
-    void Effect.runFork(Fiber.interrupt(fiber))
+    void runFork(Fiber.interrupt(fiber))
   }
 
   const stopIdleTimeout = () => {
@@ -347,7 +353,7 @@ function withAiGatewayStreamIdleTimeout(
 
   const resetIdleTimeout = (controller: ReadableStreamDefaultController<AiGatewayStreamPart>) => {
     stopIdleTimeout()
-    idleTimeoutFiber = Effect.runFork(
+    idleTimeoutFiber = runFork(
       Effect.sleep(Duration.millis(AI_GATEWAY_STREAM_IDLE_TIMEOUT_MS)).pipe(
         Effect.flatMap(() =>
           Effect.gen(function* () {
@@ -413,7 +419,7 @@ function withAiGatewayStreamIdleTimeout(
     start(controller) {
       const streamReader = stream.getReader()
       reader = streamReader
-      bodyPumpFiber = Effect.runFork(pumpStreamEffect(streamReader, controller))
+      bodyPumpFiber = runFork(pumpStreamEffect(streamReader, controller))
     },
     cancel(reason) {
       closed = true
@@ -465,7 +471,7 @@ function normalizeAiGatewayUrl(value: string): string {
 export class AiGatewayTag extends Context.Service<
   AiGatewayTag,
   { readonly semaphore: Semaphore.Semaphore; readonly provider: ReturnType<typeof createOpenAI> }
->()('AiGateway') {}
+>()('@lota-sdk/core/AiGateway') {}
 
 export const AiGatewayLive = Layer.effect(
   AiGatewayTag,
@@ -487,27 +493,32 @@ export const AiGatewayLive = Layer.effect(
   }),
 )
 
-function resolveFromRuntime<I, T>(tag: Context.Key<I, T>): T {
-  return getLotaSdkRuntime().runSync(Effect.service(tag))
-}
-
-function getAiGateway(): AiGatewayTag['Service'] {
-  return resolveFromRuntime(AiGatewayTag)
-}
+type AiGatewayRuntimeConfig = Context.Service.Shape<typeof RuntimeConfigServiceTag>
 
-function withAiGatewayConcurrency<A>(effect: Effect.Effect<A, AiGenerationError>): Effect.Effect<A, AiGenerationError> {
-  return getAiGateway().semaphore.withPermit(effect)
+function withAiGatewayConcurrency<A>(
+  effect: Effect.Effect<A, AiGenerationError>,
+): Effect.Effect<A, AiGenerationError, AiGatewayTag> {
+  return Effect.gen(function* () {
+    const gateway = yield* AiGatewayTag
+    return yield* gateway.semaphore.withPermit(effect)
+  })
 }
 
 function withAiGatewayStreamConcurrency(
   effect: Effect.Effect<AiGatewayAttemptResult<AiGatewayStreamResult>, AiGenerationError>,
-): Effect.Effect<AiGatewayAttemptResult<AiGatewayStreamResult>, AiGenerationError> {
+  runFork: AiGatewayRunFork,
+): Effect.Effect<AiGatewayAttemptResult<AiGatewayStreamResult>, AiGenerationError, AiGatewayTag> {
   return Effect.uninterruptibleMask((restore) =>
     Effect.gen(function* () {
-      const { semaphore } = getAiGateway()
+      const { semaphore } = yield* AiGatewayTag
       const currentContext = yield* Effect.context<never>()
       yield* semaphore.take(1)
 
+      // NOTE: manual release intentional — permit outlives Effect scope for the
+      // stream lifetime. The stream consumer drains asynchronously after this
+      // Effect resolves; the permit is released by either the idle-timeout
+      // finalize callback or the error path below. The `released` guard makes
+      // the release idempotent across those paths.
       let released = false
       const release = () => {
         if (released) return
@@ -517,13 +528,14 @@ function withAiGatewayStreamConcurrency(
 
       const attempt = yield* restore(effect).pipe(
         Effect.catchTag('AiGenerationError', (error) => Effect.sync(release).pipe(Effect.andThen(Effect.fail(error)))),
+        Effect.onInterrupt(() => Effect.sync(release)),
       )
 
       return {
         ...attempt,
         result: {
           ...attempt.result,
-          stream: withAiGatewayStreamIdleTimeout(attempt.result.stream, attempt.source, release),
+          stream: withAiGatewayStreamIdleTimeout(attempt.result.stream, attempt.source, runFork, release),
         },
       }
     }),
@@ -610,18 +622,20 @@ function isOpenRouterModel(modelId: string): boolean {
   return modelId.trim().toLowerCase().startsWith('openrouter/')
 }
 
-function hasDirectOpenRouterFallback(modelId: string): boolean {
-  const config = resolveFromRuntime(RuntimeConfigServiceTag)
+function hasDirectOpenRouterFallback(config: AiGatewayRuntimeConfig, modelId: string): boolean {
   return isOpenRouterModel(modelId) && Boolean(config.aiGateway.openRouterApiKey?.trim())
 }
 
-function getDirectOpenRouterChatModel(modelId: string): AiGatewayLanguageModel {
-  const config = resolveFromRuntime(RuntimeConfigServiceTag)
+function getDirectOpenRouterChatModel(config: AiGatewayRuntimeConfig, modelId: string): AiGatewayLanguageModel {
   return getDirectOpenRouterProvider(config.aiGateway.openRouterApiKey).chat(normalizeDirectOpenRouterModelId(modelId))
 }
 
-function shouldFallbackToDirectOpenRouter(modelId: string, error: AiGenerationError): boolean {
-  return hasDirectOpenRouterFallback(modelId) && isRetryableAiGatewayError(error)
+function shouldFallbackToDirectOpenRouter(
+  config: AiGatewayRuntimeConfig,
+  modelId: string,
+  error: AiGenerationError,
+): boolean {
+  return hasDirectOpenRouterFallback(config, modelId) && isRetryableAiGatewayError(error)
 }
 
 function attemptAiGatewayGenerate(
@@ -653,22 +667,25 @@ function attemptAiGatewayStream(
 }
 
 function attemptDirectOpenRouterGenerate(
+  config: AiGatewayRuntimeConfig,
   modelId: string,
   params: AiGatewayCallOptions,
 ): Effect.Effect<AiGatewayAttemptResult<AiGatewayGenerateResult>, AiGenerationError> {
-  const model = getDirectOpenRouterChatModel(modelId)
+  const model = getDirectOpenRouterChatModel(config, modelId)
   return attemptAiGatewayGenerate('openrouter.generate', () => model.doGenerate(params))
 }
 
 function attemptDirectOpenRouterStream(
+  config: AiGatewayRuntimeConfig,
   modelId: string,
   params: AiGatewayCallOptions,
 ): Effect.Effect<AiGatewayAttemptResult<AiGatewayStreamResult>, AiGenerationError> {
-  const model = getDirectOpenRouterChatModel(modelId)
+  const model = getDirectOpenRouterChatModel(config, modelId)
   return attemptAiGatewayStream('openrouter.stream', () => model.doStream(params))
 }
 
 function executeGenerateAttemptPlan(
+  config: AiGatewayRuntimeConfig,
   modelId: string,
   params: AiGatewayCallOptions,
   doGenerate: () => PromiseLike<AiGatewayGenerateResult>,
@@ -681,7 +698,7 @@ function executeGenerateAttemptPlan(
     return yield* attempt.execute
   })
 
-  if (!hasDirectOpenRouterFallback(modelId)) {
+  if (!hasDirectOpenRouterFallback(config, modelId)) {
     return effect.pipe(
       Effect.provide(primary),
       Effect.withSpan('AiGateway.executeGeneratePlan'),
@@ -695,9 +712,9 @@ function executeGenerateAttemptPlan(
         { provide: primary },
         {
           provide: Layer.succeed(AiGatewayGenerateAttempt, {
-            execute: attemptDirectOpenRouterGenerate(modelId, params),
+            execute: attemptDirectOpenRouterGenerate(config, modelId, params),
           }),
-          while: (error: AiGenerationError) => shouldFallbackToDirectOpenRouter(modelId, error),
+          while: (error: AiGenerationError) => shouldFallbackToDirectOpenRouter(config, modelId, error),
         },
       ),
     ),
@@ -707,6 +724,7 @@ function executeGenerateAttemptPlan(
 }
 
 function executeStreamAttemptPlan(
+  config: AiGatewayRuntimeConfig,
   modelId: string,
   params: AiGatewayCallOptions,
   doStream: () => PromiseLike<AiGatewayStreamResult>,
@@ -719,7 +737,7 @@ function executeStreamAttemptPlan(
     return yield* attempt.execute
   })
 
-  if (!hasDirectOpenRouterFallback(modelId)) {
+  if (!hasDirectOpenRouterFallback(config, modelId)) {
     return effect.pipe(
       Effect.provide(primary),
       Effect.withSpan('AiGateway.executeStreamPlan'),
@@ -732,8 +750,10 @@ function executeStreamAttemptPlan(
       ExecutionPlan.make(
         { provide: primary },
         {
-          provide: Layer.succeed(AiGatewayStreamAttempt, { execute: attemptDirectOpenRouterStream(modelId, params) }),
-          while: (error: AiGenerationError) => shouldFallbackToDirectOpenRouter(modelId, error),
+          provide: Layer.succeed(AiGatewayStreamAttempt, {
+            execute: attemptDirectOpenRouterStream(config, modelId, params),
+          }),
+          while: (error: AiGenerationError) => shouldFallbackToDirectOpenRouter(config, modelId, error),
         },
       ),
     ),
@@ -821,7 +841,56 @@ function addAiGatewayReasoningRawChunks(
   return { ...params, includeRawChunks: true }
 }
 
-function createAiGatewayLanguageModelMiddleware(modelId: string): LanguageModelMiddleware {
+function resolveProviderModel(
+  provider: ReturnType<typeof createOpenAI>,
+  modelId: string,
+  providerId: string,
+): AiGatewayLanguageModel {
+  return providerId === OPENAI_CHAT_PROVIDER_ID ? provider.chat(modelId) : provider(modelId)
+}
+
+// Module-level Promise slot that `createLotaRuntime` populates during boot.
+// This is a legitimate per-process singleton (mirrors the worker bootstrap
+// pattern in `workers/bootstrap.ts`): the AI gateway middleware is dispatched
+// by AI SDK callers that live outside Effect context, so the middleware needs
+// a way to run gateway Effects without capturing a `ManagedRuntime` through
+// every `aiGatewayModel(modelId)` call site.
+//
+// Only `createLotaRuntime` writes to the slot; resetting on disconnect is a
+// Phase 3b concern — for now it stays alive for the process lifetime.
+let aiGatewayRuntimeReady: Promise<{
+  gateway: Context.Service.Shape<typeof AiGatewayTag>
+  runtimeConfig: Context.Service.Shape<typeof RuntimeConfigServiceTag>
+  runPromise: <A, E>(effect: Effect.Effect<A, E, never>) => Promise<A>
+  runFork: AiGatewayRunFork
+}> | null = null
+
+export function bindAiGatewayRuntime(params: {
+  gateway: Context.Service.Shape<typeof AiGatewayTag>
+  runtimeConfig: Context.Service.Shape<typeof RuntimeConfigServiceTag>
+  runPromise: <A, E>(effect: Effect.Effect<A, E, never>) => Promise<A>
+  runFork: AiGatewayRunFork
+}): void {
+  aiGatewayRuntimeReady = Promise.resolve(params)
+}
+
+export function clearAiGatewayRuntime(): void {
+  aiGatewayRuntimeReady = null
+}
+
+async function getAiGatewayRuntime(): Promise<{
+  gateway: Context.Service.Shape<typeof AiGatewayTag>
+  runtimeConfig: Context.Service.Shape<typeof RuntimeConfigServiceTag>
+  runPromise: <A, E>(effect: Effect.Effect<A, E, never>) => Promise<A>
+  runFork: AiGatewayRunFork
+}> {
+  if (!aiGatewayRuntimeReady) {
+    throw new Error('AI gateway runtime has not been initialized. Call createLotaRuntime() first.')
+  }
+  return aiGatewayRuntimeReady
+}
+
+function createAiGatewayLanguageModelMiddleware(modelId: string, providerId: string): LanguageModelMiddleware {
   return {
     specificationVersion: 'v3',
     transformParams: ({ params, type }) =>
@@ -830,10 +899,12 @@ function createAiGatewayLanguageModelMiddleware(modelId: string): LanguageModelM
           addAiGatewayReasoningRawChunks(normalizeAiGatewayChatProviderOptions(params, modelId), type),
         ),
       ),
-    wrapGenerate: ({ doGenerate, params }) =>
-      Effect.runPromise(
+    wrapGenerate: async ({ params }) => {
+      const { gateway, runtimeConfig, runPromise } = await getAiGatewayRuntime()
+      const model = resolveProviderModel(gateway.provider, modelId, providerId)
+      return runPromise(
         withAiGatewayConcurrency(
-          executeGenerateAttemptPlan(modelId, params, doGenerate).pipe(
+          executeGenerateAttemptPlan(runtimeConfig, modelId, params, () => model.doGenerate(params)).pipe(
             Effect.map(({ result }) => ({
               ...result,
               content: injectAiGatewayChatReasoningContent(
@@ -842,12 +913,15 @@ function createAiGatewayLanguageModelMiddleware(modelId: string): LanguageModelM
               ),
             })),
           ),
-        ),
-      ),
-    wrapStream: ({ doStream, params }) =>
-      Effect.runPromise(
+        ).pipe(Effect.provideService(AiGatewayTag, gateway)),
+      )
+    },
+    wrapStream: async ({ params }) => {
+      const { gateway, runtimeConfig, runPromise, runFork } = await getAiGatewayRuntime()
+      const model = resolveProviderModel(gateway.provider, modelId, providerId)
+      return runPromise(
         withAiGatewayStreamConcurrency(
-          executeStreamAttemptPlan(modelId, params, doStream).pipe(
+          executeStreamAttemptPlan(runtimeConfig, modelId, params, () => model.doStream(params)).pipe(
             Effect.map((attempt) => ({
               ...attempt,
               result: isReasoningEnabled(params)
@@ -855,8 +929,12 @@ function createAiGatewayLanguageModelMiddleware(modelId: string): LanguageModelM
                 : attempt.result,
             })),
           ),
-        ).pipe(Effect.map(({ result }) => result)),
-      ),
+          runFork,
+        )
+          .pipe(Effect.map(({ result }) => result))
+          .pipe(Effect.provideService(AiGatewayTag, gateway)),
+      )
+    },
   }
 }
 
@@ -893,36 +971,42 @@ function withAiGatewayDevTools<TModel extends AiGatewayLanguageModel>(model: TMo
   return wrapLanguageModel({ model, middleware: devToolsMiddleware() }) as TModel
 }
 
-function createLazyAiGatewayLanguageModel(params: {
-  modelId: string
-  providerId: string
-  resolve: () => AiGatewayLanguageModel
-}): AiGatewayLanguageModel {
+function createAiGatewayLanguageModelPlaceholder(modelId: string, providerId: string): AiGatewayLanguageModel {
+  const unreachable = (method: string) =>
+    Promise.reject(
+      new Error(
+        `[ai-gateway] AiGateway language model ${modelId}.${method} was invoked without the gateway middleware; ` +
+          'this call path should be fully handled by createAiGatewayLanguageModelMiddleware.',
+      ),
+    )
+
   return {
     specificationVersion: 'v3',
-    provider: params.providerId,
-    modelId: params.modelId,
+    provider: providerId,
+    modelId,
     supportedUrls: {},
-    doGenerate: (options) => params.resolve().doGenerate(options),
-    doStream: (options) => params.resolve().doStream(options),
+    doGenerate: () => unreachable('doGenerate'),
+    doStream: () => unreachable('doStream'),
   }
 }
 
-function createLazyAiGatewayEmbeddingModel(modelId: string): AiGatewayEmbeddingModel {
+function createAiGatewayEmbeddingModelPlaceholder(modelId: string): AiGatewayEmbeddingModel {
   return {
     specificationVersion: 'v3',
     provider: OPENAI_EMBEDDING_PROVIDER_ID,
     modelId,
     maxEmbeddingsPerCall: OPENAI_EMBEDDING_MAX_PER_CALL,
     supportsParallelCalls: true,
-    doEmbed: (options) => getAiGatewayProvider().embeddingModel(modelId).doEmbed(options),
+    doEmbed: () =>
+      Promise.reject(
+        new Error(
+          `[ai-gateway] AiGateway embedding model ${modelId}.doEmbed was invoked without the gateway middleware; ` +
+            'this call path should be fully handled by aiGatewayEmbeddingModel middleware.',
+        ),
+      ),
   }
 }
 
-export function getAiGatewayProvider() {
-  return getAiGateway().provider
-}
-
 export function aiGatewayModel(modelId: string) {
   if (isOpenRouterModel(modelId)) {
     return aiGatewayChatModel(modelId)
@@ -930,12 +1014,8 @@ export function aiGatewayModel(modelId: string) {
 
   return withAiGatewayDevTools(
     wrapLanguageModel({
-      model: createLazyAiGatewayLanguageModel({
-        modelId,
-        providerId: OPENAI_RESPONSES_PROVIDER_ID,
-        resolve: () => getAiGatewayProvider()(modelId),
-      }),
-      middleware: createAiGatewayLanguageModelMiddleware(modelId),
+      model: createAiGatewayLanguageModelPlaceholder(modelId, OPENAI_RESPONSES_PROVIDER_ID),
+      middleware: createAiGatewayLanguageModelMiddleware(modelId, OPENAI_RESPONSES_PROVIDER_ID),
     }),
   )
 }
@@ -947,30 +1027,32 @@ export function aiGatewayOpenRouterResponseHealingModel(modelId: string) {
 export function aiGatewayChatModel(modelId: string) {
   return withAiGatewayDevTools(
     wrapLanguageModel({
-      model: createLazyAiGatewayLanguageModel({
-        modelId,
-        providerId: OPENAI_CHAT_PROVIDER_ID,
-        resolve: () => getAiGatewayProvider().chat(modelId),
-      }),
-      middleware: createAiGatewayLanguageModelMiddleware(modelId),
+      model: createAiGatewayLanguageModelPlaceholder(modelId, OPENAI_CHAT_PROVIDER_ID),
+      middleware: createAiGatewayLanguageModelMiddleware(modelId, OPENAI_CHAT_PROVIDER_ID),
     }),
   )
 }
 
 export function aiGatewayEmbeddingModel(modelId: string) {
   return wrapEmbeddingModel({
-    model: createLazyAiGatewayEmbeddingModel(modelId),
+    model: createAiGatewayEmbeddingModelPlaceholder(modelId),
     middleware: {
       specificationVersion: 'v3',
-      wrapEmbed: ({ doEmbed }) =>
-        Effect.runPromise(
+      wrapEmbed: async ({ params }) => {
+        const { gateway, runPromise } = await getAiGatewayRuntime()
+        const embeddingModel = gateway.provider.embeddingModel(modelId)
+        return runPromise(
           withAiGatewayConcurrency(
             withAiGatewayResilience(
               'ai-gateway.embed',
-              Effect.tryPromise({ try: doEmbed, catch: (cause) => classifyAiGatewayError('ai-gateway.embed', cause) }),
-            ),
-          ).pipe(Effect.withSpan('AiGateway.embed'), Effect.annotateSpans({ modelId })),
-        ),
+              Effect.tryPromise({
+                try: () => embeddingModel.doEmbed(params),
+                catch: (cause) => classifyAiGatewayError('ai-gateway.embed', cause),
+              }),
+            ).pipe(Effect.withSpan('AiGateway.embed'), Effect.annotateSpans({ modelId })),
+          ).pipe(Effect.provideService(AiGatewayTag, gateway)),
+        )
+      },
     },
   })
 }

package/src/ai-gateway/index.ts

@@ -1,2 +1,17 @@
-export * from './ai-gateway'
+export {
+  AiGatewayLive,
+  AiGatewayTag,
+  DEFAULT_AI_GATEWAY_URL,
+  aiGatewayChatModel,
+  aiGatewayEmbeddingModel,
+  aiGatewayModel,
+  aiGatewayOpenRouterResponseHealingModel,
+  bindAiGatewayRuntime,
+  extractAiGatewayChatReasoningDeltaText,
+  extractAiGatewayChatReasoningText,
+  injectAiGatewayChatReasoningContent,
+  injectAiGatewayChatReasoningStream,
+  normalizeAiGatewayChatProviderOptions,
+  normalizeAiGatewayUrl,
+} from './ai-gateway'
 export * from './cache-headers'

package/src/config/agent-defaults.ts

@@ -1,9 +1,6 @@
 import type { ToolSet } from 'ai'
-import { Effect } from 'effect'
 
 import { ConfigurationError } from '../effect/errors'
-import { getCurrentRuntime } from '../effect/runtime-ref'
-import { AgentConfigServiceTag, AgentFactoryServiceTag } from '../effect/services'
 import type {
   AgentFactory,
   AgentRuntimeConfigParams,
@@ -131,111 +128,11 @@ export interface CoreThreadProfile {
   instructions: string
 }
 
-function resolveAgentConfigFromRuntime(): ResolvedAgentConfig {
-  return getCurrentRuntime().runSync(Effect.service(AgentConfigServiceTag))
+export function isAgentName(agentConfig: ResolvedAgentConfig, value: unknown): value is string {
+  return typeof value === 'string' && agentConfig.rosterSet.has(value)
 }
 
-function resolveAgentFactoryConfigFromRuntime(): ResolvedAgentFactoryConfig {
-  return getCurrentRuntime().runSync(Effect.service(AgentFactoryServiceTag))
-}
-
-export function getResolvedAgentConfig(): ResolvedAgentConfig {
-  return resolveAgentConfigFromRuntime()
-}
-
-export function getResolvedAgentFactoryConfig(): ResolvedAgentFactoryConfig {
-  return resolveAgentFactoryConfigFromRuntime()
-}
-
-export function isAgentName(value: unknown): value is string {
-  return typeof value === 'string' && resolveAgentConfigFromRuntime().rosterSet.has(value)
-}
-
-export function getAgentRoster(): readonly string[] {
-  return resolveAgentConfigFromRuntime().roster
-}
-
-export function getAgentDisplayNames(): Record<string, string> {
-  return resolveAgentConfigFromRuntime().displayNames
-}
-
-export function getAgentShortDisplayNames(): Record<string, string> {
-  return resolveAgentConfigFromRuntime().shortDisplayNames
-}
-
-export function getAgentDescriptions(): Record<string, string> {
-  return resolveAgentConfigFromRuntime().descriptions
-}
-
-export function getLeadAgentId(): string {
-  return resolveAgentConfigFromRuntime().leadAgentId
-}
-
-export function getLeadAgentDisplayName(): string {
-  const resolved = resolveAgentConfigFromRuntime()
-  return resolved.displayNames[resolved.leadAgentId] ?? resolved.leadAgentId
-}
-
-export function getRouterModelId(): string | undefined {
-  return resolveAgentConfigFromRuntime().routerModelId
-}
-
-export function getTeamConsultParticipants(): readonly string[] {
-  return resolveAgentConfigFromRuntime().teamConsultParticipants
-}
-
-export function getCoreThreadProfile(coreType: string): CoreThreadProfile {
-  return resolveAgentConfigFromRuntime().getCoreThreadProfile(coreType)
-}
-
-export function resolveAgentNameAlias(value: unknown): string | undefined {
+export function resolveAgentNameAlias(agentConfig: ResolvedAgentConfig, value: unknown): string | undefined {
   if (typeof value !== 'string') return undefined
-  return resolveAgentConfigFromRuntime().aliasMap.get(normalizeAgentLookupKey(value))
-}
-
-export function getCreateAgentRegistry(): AgentFactory {
-  return resolveAgentFactoryConfigFromRuntime().createAgent
-}
-
-export function buildAgentTools(...args: Parameters<AgentToolBuilder>): ReturnType<AgentToolBuilder> {
-  return resolveAgentFactoryConfigFromRuntime().buildAgentTools(...args)
-}
-
-export function getAgentRuntimeConfig(
-  ...args: Parameters<AgentRuntimeConfigProvider>
-): ReturnType<AgentRuntimeConfigProvider> {
-  return resolveAgentFactoryConfigFromRuntime().getAgentRuntimeConfig(...args)
-}
-
-export function getPluginRuntime(): Record<string, unknown> | undefined {
-  return resolveAgentFactoryConfigFromRuntime().pluginRuntime
-}
-
-const AGENT_MENTION_REGEX = /(^|[^\w])@([a-z][a-z0-9_-]*)\b/gi
-
-export interface AgentMentionMatch {
-  agent: string
-  mention: string
-  index: number
-  length: number
-}
-
-export function extractAgentMentions(
-  message: string,
-  agentConfig: ResolvedAgentConfig = resolveAgentConfigFromRuntime(),
-): AgentMentionMatch[] {
-  const matches: AgentMentionMatch[] = []
-  if (!message.trim()) return matches
-
-  const regex = new RegExp(AGENT_MENTION_REGEX)
-  for (const rawMatch of message.matchAll(regex)) {
-    const prefix = rawMatch[1]
-    const rawAgent = rawMatch[2].toLowerCase()
-    if (!agentConfig.rosterSet.has(rawAgent)) continue
-
-    const index = rawMatch.index + prefix.length
-    matches.push({ agent: rawAgent, mention: `@${rawAgent}`, index, length: rawAgent.length + 1 })
-  }
-
-  return matches
+  return agentConfig.aliasMap.get(normalizeAgentLookupKey(value))
 }

package/src/config/agent-types.ts

@@ -1,8 +1,8 @@
+import type { ChatMode, CreateRoutedAgentOptions } from '@lota-sdk/shared'
 import type { ToolLoopAgent, ToolSet } from 'ai'
 
 import type { RecordIdRef } from '../db/record-id'
 import type { AgentRuntimeConfig, AgentRuntimeRuleOptions } from '../runtime/agent-runtime-policy'
-import type { ChatMode, CreateRoutedAgentOptions } from '../runtime/agent-types'
 
 export interface AgentToolBuilderParams {
   agentId: string