@lota-sdk/core 0.4.12 → 0.4.14

package/src/services/user.service.ts

@@ -6,7 +6,7 @@ import { ensureRecordId, recordIdToString } from '../db/record-id'
 import type { RecordIdInput } from '../db/record-id'
 import type { SurrealDBService } from '../db/service'
 import { TABLES } from '../db/tables'
-import { NotFoundError } from '../effect/errors'
+import { ERROR_TAGS, NotFoundError } from '../effect/errors'
 import { DatabaseServiceTag } from '../effect/services'
 import { toIsoDateTimeString } from '../utils/date-time'
 
@@ -28,7 +28,7 @@ function userNotFoundError(userId: RecordIdInput): NotFoundError {
   })
 }
 
-class UserServiceError extends Schema.TaggedErrorClass<UserServiceError>()('UserServiceError', {
+class UserServiceError extends Schema.TaggedErrorClass<UserServiceError>()(ERROR_TAGS.UserServiceError, {
   operation: Schema.String,
   cause: Schema.Defect,
 }) {}
@@ -38,59 +38,56 @@ function toUserServiceError(operation: string, cause: unknown): UserServiceError
 }
 
 export function makeUserService(db: SurrealDBService) {
-  function upsertUserEffect(params: { id: RecordIdInput; name: string; email: string }) {
+  const upsertUser = Effect.fn('UserService.upsertUser')(function* (params: {
+    id: RecordIdInput
+    name: string
+    email: string
+  }) {
     const userRef = ensureRecordId(params.id, TABLES.USER)
-    return db.upsert(TABLES.USER, userRef, { name: params.name, email: params.email }, sdkUserRecordSchema).pipe(
-      Effect.mapError((cause) => toUserServiceError('upsertUser', cause)),
-      Effect.map(toPublic),
-    )
-  }
+    const record = yield* db
+      .upsert(TABLES.USER, userRef, { name: params.name, email: params.email }, sdkUserRecordSchema)
+      .pipe(Effect.mapError((cause) => toUserServiceError('upsertUser', cause)))
+    return toPublic(record)
+  })
 
-  function getUserEffect(userId: RecordIdInput) {
-    return db.findOne(TABLES.USER, { id: ensureRecordId(userId, TABLES.USER) }, sdkUserRecordSchema).pipe(
-      Effect.mapError((cause) => toUserServiceError('getUser', cause)),
-      Effect.flatMap((record) => (record ? Effect.succeed(record) : Effect.fail(userNotFoundError(userId)))),
-      Effect.map(toPublic),
-    )
-  }
+  const getUser = Effect.fn('UserService.getUser')(function* (userId: RecordIdInput) {
+    const record = yield* db
+      .findOne(TABLES.USER, { id: ensureRecordId(userId, TABLES.USER) }, sdkUserRecordSchema)
+      .pipe(Effect.mapError((cause) => toUserServiceError('getUser', cause)))
+    if (!record) return yield* userNotFoundError(userId)
+    return toPublic(record)
+  })
 
-  function listUsersEffect() {
-    return db.findMany(TABLES.USER, {}, sdkUserRecordSchema, { orderBy: 'createdAt', orderDir: 'ASC' }).pipe(
-      Effect.mapError((cause) => toUserServiceError('listUsers', cause)),
-      Effect.map((records) => records.map(toPublic)),
-    )
-  }
+  const listUsers = Effect.fn('UserService.listUsers')(function* () {
+    const records = yield* db
+      .findMany(TABLES.USER, {}, sdkUserRecordSchema, { orderBy: 'createdAt', orderDir: 'ASC' })
+      .pipe(Effect.mapError((cause) => toUserServiceError('listUsers', cause)))
+    return records.map(toPublic)
+  })
 
-  function updateUserEffect(userId: RecordIdInput, params: { name?: string; email?: string }) {
-    return db.update(TABLES.USER, ensureRecordId(userId, TABLES.USER), params, sdkUserRecordSchema).pipe(
-      Effect.mapError((cause) => toUserServiceError('updateUser', cause)),
-      Effect.flatMap((updated) => (updated ? Effect.succeed(updated) : Effect.fail(userNotFoundError(userId)))),
-      Effect.map(toPublic),
-    )
-  }
+  const updateUser = Effect.fn('UserService.updateUser')(function* (
+    userId: RecordIdInput,
+    params: { name?: string; email?: string },
+  ) {
+    const updated = yield* db
+      .update(TABLES.USER, ensureRecordId(userId, TABLES.USER), params, sdkUserRecordSchema)
+      .pipe(Effect.mapError((cause) => toUserServiceError('updateUser', cause)))
+    if (!updated) return yield* userNotFoundError(userId)
+    return toPublic(updated)
+  })
 
-  function deleteUserEffect(userId: RecordIdInput) {
+  const deleteUser = Effect.fn('UserService.deleteUser')(function* (userId: RecordIdInput) {
     const userRef = ensureRecordId(userId, TABLES.USER)
-    return Effect.gen(function* () {
-      yield* db
-        .deleteWhere(TABLES.ORGANIZATION_MEMBER, { in: userRef })
-        .pipe(Effect.mapError((cause) => toUserServiceError('deleteUser.deleteMemberships', cause)))
-      const deleted = yield* db
-        .deleteById(TABLES.USER, userRef)
-        .pipe(Effect.mapError((cause) => toUserServiceError('deleteUser.deleteUser', cause)))
-      if (!deleted) {
-        return yield* userNotFoundError(userId)
-      }
-    })
-  }
+    yield* db
+      .deleteWhere(TABLES.ORGANIZATION_MEMBER, { in: userRef })
+      .pipe(Effect.mapError((cause) => toUserServiceError('deleteUser.deleteMemberships', cause)))
+    const deleted = yield* db
+      .deleteById(TABLES.USER, userRef)
+      .pipe(Effect.mapError((cause) => toUserServiceError('deleteUser.deleteUser', cause)))
+    if (!deleted) return yield* userNotFoundError(userId)
+  })
 
-  return {
-    upsertUser: upsertUserEffect,
-    getUser: getUserEffect,
-    listUsers: listUsersEffect,
-    updateUser: updateUserEffect,
-    deleteUser: deleteUserEffect,
-  }
+  return { upsertUser, getUser, listUsers, updateUser, deleteUser }
 }
 
 export class UserServiceTag extends Context.Service<UserServiceTag, ReturnType<typeof makeUserService>>()(

package/src/storage/attachment-parser.ts

@@ -3,9 +3,11 @@ import { Schema, Effect } from 'effect'
 import mammoth from 'mammoth'
 import { PDFParse } from 'pdf-parse'
 
+import { ERROR_TAGS } from '../effect/errors'
+
 const READ_FILE_PARTS_CHARS_PER_PAGE = 3500
 
-class AttachmentParserError extends Schema.TaggedErrorClass<AttachmentParserError>()('AttachmentParserError', {
+class AttachmentParserError extends Schema.TaggedErrorClass<AttachmentParserError>()(ERROR_TAGS.AttachmentParserError, {
   message: Schema.String,
   cause: Schema.Defect,
 }) {}
@@ -67,7 +69,9 @@ export function extractPdfPages(file: File): Promise<string[]> {
       }).pipe(
         Effect.ensuring(
           tryAttachmentPromise('Failed to destroy PDF parser.', () => parser.destroy()).pipe(
-            Effect.orDie,
+            Effect.catchTag(ERROR_TAGS.AttachmentParserError, (error) =>
+              Effect.logWarning(`Attachment parser cleanup failed: ${error.message}`),
+            ),
             Effect.asVoid,
           ),
         ),

package/src/storage/attachment-storage.service.ts

@@ -3,7 +3,7 @@ import { S3Client } from 'bun'
 import { Context, Schema, Effect, Layer } from 'effect'
 
 import { serverLogger } from '../config/logger'
-import { BadRequestError, ForbiddenError } from '../effect/errors'
+import { ERROR_TAGS, BadRequestError, ForbiddenError } from '../effect/errors'
 import { RuntimeConfigServiceTag } from '../effect/services'
 import type { ResolvedLotaRuntimeConfig } from '../runtime/runtime-config'
 import { getErrorMessage } from '../utils/errors'
@@ -36,11 +36,10 @@ export type UploadedThreadAttachment = {
 
 type AttachmentContextCandidate = { storageKey: string; name: string; contentType: string; sizeBytes: number | null }
 
-class AttachmentStorageError extends Schema.TaggedErrorClass<AttachmentStorageError>()('AttachmentStorageError', {
-  operation: Schema.String,
-  message: Schema.String,
-  cause: Schema.Defect,
-}) {}
+class AttachmentStorageError extends Schema.TaggedErrorClass<AttachmentStorageError>()(
+  ERROR_TAGS.AttachmentStorageError,
+  { operation: Schema.String, message: Schema.String, cause: Schema.Defect },
+) {}
 
 function toAttachmentStorageError(operation: string, cause: unknown): AttachmentStorageError {
   return new AttachmentStorageError({ operation, message: getErrorMessage(cause), cause })

package/src/storage/generated-document-storage.service.ts

@@ -26,7 +26,7 @@ function buildGeneratedDocumentStorageKey(params: {
 }
 
 class GeneratedDocumentStorageError extends Schema.TaggedErrorClass<GeneratedDocumentStorageError>()(
-  'GeneratedDocumentStorageError',
+  '@lota-sdk/core/GeneratedDocumentStorageError',
   { message: Schema.String, cause: Schema.Defect },
 ) {}
 

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

@@ -1,7 +1,7 @@
 import type { CreateHelperToolLoopAgentOptions } from '@lota-sdk/shared'
 import { ToolLoopAgent } from 'ai'
 
-import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
+import type { AiGatewayModels } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
@@ -31,12 +31,13 @@ The caller enforces a structured output schema with exactly one field:
 </output-format>
 </agent-instructions>`
 
-export function createContextCompactionAgent(options: CreateHelperToolLoopAgentOptions) {
-  return new ToolLoopAgent({
-    id: 'context-compaction',
-    model: aiGatewayChatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
-    headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
-    providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
-    ...resolveHelperAgentOptions(options, { instructions: CONTEXT_COMPACTION_PROMPT }),
-  })
+export function makeContextCompactionAgentFactory(models: AiGatewayModels) {
+  return (options: CreateHelperToolLoopAgentOptions) =>
+    new ToolLoopAgent({
+      id: 'context-compaction',
+      model: models.chatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+      headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
+      providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
+      ...resolveHelperAgentOptions(options, { instructions: CONTEXT_COMPACTION_PROMPT }),
+    })
 }

package/src/system-agents/delegated-agent-factory.ts

@@ -5,6 +5,7 @@ import { z } from 'zod'
 
 import type { ToolDefinition } from '../ai/definitions'
 import { aiLogger } from '../config/logger'
+import { ERROR_TAGS } from '../effect/errors'
 import { formatUtcPromptDate, nowDate } from '../utils/date-time'
 import { getErrorMessage } from '../utils/errors'
 import { isRecord } from '../utils/string'
@@ -12,6 +13,7 @@ import { assertSubstantiveAgentResult } from './agent-result'
 
 type AgentProviderOptions = ToolLoopAgentSettings['providerOptions']
 type AgentModel = LanguageModel | (() => LanguageModel)
+type AgentModelWithContext<TContext> = LanguageModel | ((context: TContext) => LanguageModel)
 
 interface DelegatedAgentDefinition {
   id: string
@@ -24,13 +26,26 @@ interface DelegatedAgentDefinition {
   maxSteps?: number
   maxOutputTokens?: number
   temperature?: number
+  runPromise: <A, E>(effect: Effect.Effect<A, E, never>, options?: { signal?: AbortSignal }) => Promise<A>
 }
 
-interface DelegatedAgentDefinitionWithContext<TContext> extends Omit<DelegatedAgentDefinition, 'tools'> {
+type DelegatedAgentRunPromise = <A, E>(
+  effect: Effect.Effect<A, E, never>,
+  options?: { signal?: AbortSignal },
+) => Promise<A>
+
+interface DelegatedAgentDefinitionWithContext<TContext> extends Omit<
+  DelegatedAgentDefinition,
+  'tools' | 'model' | 'runPromise'
+> {
+  model: AgentModelWithContext<TContext>
   createTools: (context: TContext) => ToolSet
+  /** Pull runPromise off the caller's context so each tool invocation carries
+   * its own runtime binding rather than closing over a boot-time one. */
+  getRunPromise: (context: TContext) => DelegatedAgentRunPromise
 }
 
-class DelegatedAgentError extends Schema.TaggedErrorClass<DelegatedAgentError>()('DelegatedAgentError', {
+class DelegatedAgentError extends Schema.TaggedErrorClass<DelegatedAgentError>()(ERROR_TAGS.DelegatedAgentError, {
   stage: Schema.Literals(['generate', 'validate', 'follow-up-generate', 'follow-up-validate']),
   label: Schema.String,
   message: Schema.String,
@@ -49,6 +64,13 @@ function resolveAgentModel(model: AgentModel): LanguageModel {
   return typeof model === 'function' ? model() : model
 }
 
+function resolveAgentModelWithContext<TContext>(
+  model: AgentModelWithContext<TContext>,
+  context: TContext,
+): LanguageModel {
+  return typeof model === 'function' ? (model as (ctx: TContext) => LanguageModel)(context) : model
+}
+
 function buildCurrentDateContext(now = nowDate()): string {
   return [`Today is ${formatUtcPromptDate(now)}.`, 'Use this exact date for any recency reasoning.'].join(' ')
 }
@@ -229,7 +251,7 @@ export function createDelegatedAgentTool(definition: DelegatedAgentDefinition):
         description: definition.description,
         inputSchema: z.object({ task: z.string().min(1) }),
         execute: ({ task }: { task: string }, { abortSignal }) =>
-          Effect.runPromise(
+          definition.runPromise(
             Effect.gen(function* () {
               const agentTools = definition.tools
               const createAgent = () =>
@@ -268,6 +290,7 @@ export function createDelegatedAgentTool(definition: DelegatedAgentDefinition):
                 }),
               }
             }),
+            abortSignal ? { signal: abortSignal } : undefined,
           ),
       }),
   } as const satisfies ToolDefinition<void>
@@ -286,13 +309,13 @@ export function createDelegatedAgentToolWithContext<TContext>(
         description: definition.description,
         inputSchema: z.object({ task: z.string().min(1) }),
         execute: ({ task }: { task: string }, { abortSignal }) =>
-          Effect.runPromise(
+          definition.getRunPromise(context)(
             Effect.gen(function* () {
               const agentTools = definition.createTools(context)
               const createAgent = () =>
                 new ToolLoopAgent({
                   id: definition.id,
-                  model: resolveAgentModel(definition.model),
+                  model: resolveAgentModelWithContext(definition.model, context),
                   ...(definition.providerOptions ? { providerOptions: definition.providerOptions } : {}),
                   ...(definition.headers ? { headers: definition.headers } : {}),
                   instructions: buildDelegatedAgentInstructions(definition.instructions, agentTools),
@@ -304,7 +327,7 @@ export function createDelegatedAgentToolWithContext<TContext>(
                 })
               const synthesize = (prompt: string, abortSignal?: AbortSignal) =>
                 generateText({
-                  model: resolveAgentModel(definition.model),
+                  model: resolveAgentModelWithContext(definition.model, context),
                   ...(definition.providerOptions ? { providerOptions: definition.providerOptions } : {}),
                   ...(definition.headers ? { headers: definition.headers } : {}),
                   system: `${definition.instructions.trim()}\n\nReturn a complete final markdown answer using only the provided research data. Do not call tools.`,
@@ -325,6 +348,7 @@ export function createDelegatedAgentToolWithContext<TContext>(
                 }),
               }
             }),
+            abortSignal ? { signal: abortSignal } : undefined,
           ),
       }),
   } as const satisfies ToolDefinition<TContext>

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

@@ -1,7 +1,7 @@
 import type { CreateHelperToolLoopAgentOptions } from '@lota-sdk/shared'
 import { ToolLoopAgent } from 'ai'
 
-import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
+import type { AiGatewayModels } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_LOW_REASONING_PROVIDER_OPTIONS,
@@ -29,12 +29,13 @@ Set every item.relevance as a string; use empty string when no reason is needed.
 </output>
 </agent-instructions>`
 
-export function createMemoryRerankerAgent(options: CreateHelperToolLoopAgentOptions) {
-  return new ToolLoopAgent({
-    id: 'memory-reranker',
-    model: aiGatewayChatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
-    headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
-    providerOptions: OPENROUTER_LOW_REASONING_PROVIDER_OPTIONS,
-    ...resolveHelperAgentOptions(options),
-  })
+export function makeMemoryRerankerAgentFactory(models: AiGatewayModels) {
+  return (options: CreateHelperToolLoopAgentOptions) =>
+    new ToolLoopAgent({
+      id: 'memory-reranker',
+      model: models.chatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+      headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
+      providerOptions: OPENROUTER_LOW_REASONING_PROVIDER_OPTIONS,
+      ...resolveHelperAgentOptions(options),
+    })
 }

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

@@ -1,7 +1,7 @@
 import type { CreateHelperToolLoopAgentOptions } from '@lota-sdk/shared'
 import { ToolLoopAgent } from 'ai'
 
-import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
+import type { AiGatewayModels } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
@@ -49,12 +49,13 @@ Return only the schema fields with no extra formatting.
 </format>
 </agent-instructions>`
 
-export function createOrgMemoryAgent(options: CreateHelperToolLoopAgentOptions) {
-  return new ToolLoopAgent({
-    id: 'org-memory',
-    model: aiGatewayChatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
-    headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
-    providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
-    ...resolveHelperAgentOptions(options),
-  })
+export function makeOrgMemoryAgentFactory(models: AiGatewayModels) {
+  return (options: CreateHelperToolLoopAgentOptions) =>
+    new ToolLoopAgent({
+      id: 'org-memory',
+      model: models.chatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+      headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
+      providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
+      ...resolveHelperAgentOptions(options),
+    })
 }

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

@@ -1,7 +1,7 @@
 import type { CreateHelperToolLoopAgentOptions } from '@lota-sdk/shared'
 import { ToolLoopAgent } from 'ai'
 
-import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
+import type { AiGatewayModels } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
 import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import {
@@ -76,18 +76,16 @@ Return only the title text. No quotes, labels, JSON, markdown, or explanation.
 </output>
 </agent-instructions>`
 
-export function createRecentActivityTitleRefinerAgent(
-  agentConfig: ResolvedAgentConfig,
-  options: CreateHelperToolLoopAgentOptions,
-) {
-  return new ToolLoopAgent({
-    id: 'recent-activity-title-refiner',
-    model: aiGatewayChatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
-    headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
-    providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
-    ...resolveHelperAgentOptions(options, {
-      instructions: buildRecentActivityTitleRefinerPrompt(agentConfig),
-      maxOutputTokens: RECENT_ACTIVITY_TITLE_MAX_TOKENS,
-    }),
-  })
+export function makeRecentActivityTitleRefinerAgentFactory(models: AiGatewayModels, agentConfig: ResolvedAgentConfig) {
+  return (options: CreateHelperToolLoopAgentOptions) =>
+    new ToolLoopAgent({
+      id: 'recent-activity-title-refiner',
+      model: models.chatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+      headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
+      providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
+      ...resolveHelperAgentOptions(options, {
+        instructions: buildRecentActivityTitleRefinerPrompt(agentConfig),
+        maxOutputTokens: RECENT_ACTIVITY_TITLE_MAX_TOKENS,
+      }),
+    })
 }

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

@@ -1,7 +1,7 @@
 import type { CreateHelperToolLoopAgentOptions } from '@lota-sdk/shared'
 import { ToolLoopAgent } from 'ai'
 
-import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
+import type { AiGatewayModels } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
@@ -24,15 +24,16 @@ Synthesize an updated workspace profile summary and durable memory facts from co
 </rules>
 </agent-instructions>`
 
-export function createRegularChatMemoryDigestAgent(options: CreateHelperToolLoopAgentOptions) {
-  return new ToolLoopAgent({
-    id: 'regular-chat-memory-digest',
-    model: aiGatewayChatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
-    headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
-    providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
-    ...resolveHelperAgentOptions(options, {
-      instructions: regularChatMemoryDigestPrompt,
-      maxOutputTokens: REGULAR_CHAT_MEMORY_DIGEST_MAX_TOKENS,
-    }),
-  })
+export function makeRegularChatMemoryDigestAgentFactory(models: AiGatewayModels) {
+  return (options: CreateHelperToolLoopAgentOptions) =>
+    new ToolLoopAgent({
+      id: 'regular-chat-memory-digest',
+      model: models.chatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+      headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
+      providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
+      ...resolveHelperAgentOptions(options, {
+        instructions: regularChatMemoryDigestPrompt,
+        maxOutputTokens: REGULAR_CHAT_MEMORY_DIGEST_MAX_TOKENS,
+      }),
+    })
 }

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

@@ -2,7 +2,7 @@ import type { CreateHelperToolLoopAgentOptions } from '@lota-sdk/shared'
 import { ToolLoopAgent } from 'ai'
 import { z } from 'zod'
 
-import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
+import type { AiGatewayModels } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
@@ -42,15 +42,16 @@ export const SkillExtractionOutputSchema = z.object({ candidates: z.array(SkillC
 
 export type SkillCandidate = z.infer<typeof SkillCandidateSchema>
 
-export function createSkillExtractorAgent(options: CreateHelperToolLoopAgentOptions) {
-  return new ToolLoopAgent({
-    id: 'skill-extractor',
-    model: aiGatewayChatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
-    headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
-    providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
-    ...resolveHelperAgentOptions(options, {
-      instructions: skillExtractorPrompt,
-      maxOutputTokens: SKILL_EXTRACTOR_MAX_TOKENS,
-    }),
-  })
+export function makeSkillExtractorAgentFactory(models: AiGatewayModels) {
+  return (options: CreateHelperToolLoopAgentOptions) =>
+    new ToolLoopAgent({
+      id: 'skill-extractor',
+      model: models.chatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+      headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
+      providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
+      ...resolveHelperAgentOptions(options, {
+        instructions: skillExtractorPrompt,
+        maxOutputTokens: SKILL_EXTRACTOR_MAX_TOKENS,
+      }),
+    })
 }

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

@@ -2,7 +2,7 @@ import type { CreateHelperToolLoopAgentOptions } from '@lota-sdk/shared'
 import { ToolLoopAgent } from 'ai'
 import { z } from 'zod'
 
-import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
+import type { AiGatewayModels } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
@@ -66,15 +66,16 @@ export const SkillManagerOutputSchema = z.object({
   mergedSkill: MergedSkillSchema.optional(),
 })
 
-export function createSkillManagerAgent(options: CreateHelperToolLoopAgentOptions) {
-  return new ToolLoopAgent({
-    id: 'skill-manager',
-    model: aiGatewayChatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
-    headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
-    providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
-    ...resolveHelperAgentOptions(options, {
-      instructions: skillManagerPrompt,
-      maxOutputTokens: SKILL_MANAGER_MAX_TOKENS,
-    }),
-  })
+export function makeSkillManagerAgentFactory(models: AiGatewayModels) {
+  return (options: CreateHelperToolLoopAgentOptions) =>
+    new ToolLoopAgent({
+      id: 'skill-manager',
+      model: models.chatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+      headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
+      providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
+      ...resolveHelperAgentOptions(options, {
+        instructions: skillManagerPrompt,
+        maxOutputTokens: SKILL_MANAGER_MAX_TOKENS,
+      }),
+    })
 }

package/src/system-agents/thread-router.agent.ts

@@ -2,12 +2,12 @@ import { generateObject } from 'ai'
 import { Effect } from 'effect'
 import { z } from 'zod'
 
-import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
+import type { AiGatewayModels } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
 import type { ResolvedAgentConfig } from '../config/agent-defaults'
 import { chatLogger } from '../config/logger'
 import type { ValidationError } from '../effect/errors'
-import { AiGenerationError } from '../effect/errors'
+import { ERROR_TAGS, AiGenerationError } from '../effect/errors'
 import { zodParse } from '../effect/zod'
 
 const TriageResultSchema = z.object({ agentId: z.string(), routingContext: z.string() })
@@ -170,6 +170,7 @@ function toRouterGenerationError(label: 'triage' | 'check', error: unknown): AiG
 
 function generateRouterObjectEffect<TSchema extends z.ZodTypeAny>(params: {
   agentConfig: ResolvedAgentConfig
+  aiGatewayModels: AiGatewayModels
   schema: TSchema
   system: string
   prompt: string
@@ -180,7 +181,7 @@ function generateRouterObjectEffect<TSchema extends z.ZodTypeAny>(params: {
   return Effect.tryPromise({
     try: () =>
       generateObject({
-        model: aiGatewayChatModel(modelId),
+        model: params.aiGatewayModels.chatModel(modelId),
         headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
         providerOptions: { openai: { reasoningEffort: 'low' } },
         schema: params.schema,
@@ -201,12 +202,12 @@ function generateRouterObjectEffect<TSchema extends z.ZodTypeAny>(params: {
     ),
     Effect.flatMap(({ object }) => zodParse(params.schema, object)),
     Effect.catchTags({
-      AiGenerationError: (error: AiGenerationError) =>
+      [ERROR_TAGS.AiGenerationError]: (error: AiGenerationError) =>
         Effect.sync(() => {
           chatLogger.error`[thread-router] ${params.label} failed: ${error.message}`
           return null
         }),
-      ValidationError: (error: ValidationError) =>
+      [ERROR_TAGS.ValidationError]: (error: ValidationError) =>
         Effect.sync(() => {
           chatLogger.error`[thread-router] ${params.label} failed: ${error.message}`
           return null
@@ -217,6 +218,7 @@ function generateRouterObjectEffect<TSchema extends z.ZodTypeAny>(params: {
 
 export function triageThreadMessage(params: {
   agentConfig: ResolvedAgentConfig
+  aiGatewayModels: AiGatewayModels
   threadTitle: string
   members: readonly string[]
   messageText: string
@@ -254,6 +256,7 @@ export function triageThreadMessage(params: {
 
       const parsed = yield* generateRouterObjectEffect({
         agentConfig: params.agentConfig,
+        aiGatewayModels: params.aiGatewayModels,
         schema: TriageResultSchema,
         system: TRIAGE_SYSTEM_PROMPT,
         prompt,
@@ -280,6 +283,7 @@ export function triageThreadMessage(params: {
 
 export function checkForNextAgent(params: {
   agentConfig: ResolvedAgentConfig
+  aiGatewayModels: AiGatewayModels
   threadTitle: string
   members: readonly string[]
   messageText: string
@@ -323,6 +327,7 @@ export function checkForNextAgent(params: {
 
       const parsed = yield* generateRouterObjectEffect({
         agentConfig: params.agentConfig,
+        aiGatewayModels: params.aiGatewayModels,
         schema: CheckResultObjectSchema,
         system: CHECK_SYSTEM_PROMPT,
         prompt,