@lota-sdk/core 0.4.8 → 0.4.9

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

@@ -1,6 +1,8 @@
 import { S3Client } from 'bun'
+import { Context, Schema, Effect, Layer } from 'effect'
 
-import { getRuntimeConfig } from '../runtime/runtime-config'
+import { RuntimeConfigServiceTag } from '../effect/services'
+import type { ResolvedLotaRuntimeConfig } from '../runtime/runtime-config'
 import { toSafeSegment } from './attachment-utils'
 
 function toSafePathSegment(value: string): string {
@@ -23,43 +25,73 @@ function buildGeneratedDocumentStorageKey(params: {
   return `${safeOrganizationId}/generated/${safeNamespace}/${safeRelativePath}`
 }
 
-class GeneratedDocumentStorageService {
-  private _client: InstanceType<typeof S3Client> | undefined
+class GeneratedDocumentStorageError extends Schema.TaggedErrorClass<GeneratedDocumentStorageError>()(
+  'GeneratedDocumentStorageError',
+  { message: Schema.String, cause: Schema.Defect },
+) {}
 
-  private get client(): InstanceType<typeof S3Client> {
-    if (!this._client) {
-      const config = getRuntimeConfig()
-      this._client = new S3Client({
-        accessKeyId: config.s3.accessKeyId,
-        secretAccessKey: config.s3.secretAccessKey,
-        bucket: config.s3.bucket,
-        endpoint: config.s3.endpoint,
-        region: config.s3.region,
-      })
-    }
-    return this._client
-  }
+export function makeGeneratedDocumentStorageService(config: ResolvedLotaRuntimeConfig) {
+  const client = new S3Client({
+    accessKeyId: config.s3.accessKeyId,
+    secretAccessKey: config.s3.secretAccessKey,
+    bucket: config.s3.bucket,
+    endpoint: config.s3.endpoint,
+    region: config.s3.region,
+  })
 
-  async writeTextArtifact(params: {
-    organizationId: string
-    namespace: string
-    relativePath: string
-    content: string
-    mediaType: string
-  }): Promise<{ storageKey: string; sizeBytes: number }> {
-    const storageKey = buildGeneratedDocumentStorageKey(params)
-    const sizeBytes = Buffer.byteLength(params.content, 'utf8')
-    await this.client.file(storageKey).write(params.content, { type: params.mediaType })
-    return { storageKey, sizeBytes }
-  }
+  return {
+    writeTextArtifact(params: {
+      organizationId: string
+      namespace: string
+      relativePath: string
+      content: string
+      mediaType: string
+    }) {
+      const storageKey = buildGeneratedDocumentStorageKey(params)
+      const sizeBytes = Buffer.byteLength(params.content, 'utf8')
+      return Effect.tryPromise({
+        try: () => client.file(storageKey).write(params.content, { type: params.mediaType }),
+        catch: (cause) =>
+          new GeneratedDocumentStorageError({
+            message: `Failed to write generated document artifact ${storageKey}.`,
+            cause,
+          }),
+      }).pipe(Effect.as({ storageKey, sizeBytes }))
+    },
 
-  async readTextArtifact(storageKey: string): Promise<string> {
-    return await this.client.file(storageKey).text()
-  }
+    readTextArtifact(storageKey: string) {
+      return Effect.tryPromise({
+        try: () => client.file(storageKey).text(),
+        catch: (cause) =>
+          new GeneratedDocumentStorageError({
+            message: `Failed to read generated document artifact ${storageKey}.`,
+            cause,
+          }),
+      })
+    },
 
-  async deleteTextArtifact(storageKey: string): Promise<void> {
-    await this.client.file(storageKey).delete()
+    deleteTextArtifact(storageKey: string) {
+      return Effect.tryPromise({
+        try: () => client.file(storageKey).delete(),
+        catch: (cause) =>
+          new GeneratedDocumentStorageError({
+            message: `Failed to delete generated document artifact ${storageKey}.`,
+            cause,
+          }),
+      }).pipe(Effect.asVoid)
+    },
   }
 }
 
-export const generatedDocumentStorageService = new GeneratedDocumentStorageService()
+export class GeneratedDocumentStorageServiceTag extends Context.Service<
+  GeneratedDocumentStorageServiceTag,
+  ReturnType<typeof makeGeneratedDocumentStorageService>
+>()('GeneratedDocumentStorageService') {}
+
+export const GeneratedDocumentStorageServiceLive = Layer.effect(
+  GeneratedDocumentStorageServiceTag,
+  Effect.gen(function* () {
+    const config = yield* RuntimeConfigServiceTag
+    return makeGeneratedDocumentStorageService(config)
+  }),
+)

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

@@ -1,3 +1,5 @@
+import { ValidationError } from '../effect/errors'
+
 const SUBSTANTIVE_CHAR_PATTERN = /[\p{L}\p{N}]/u
 const WORD_LIKE_PATTERN = /[\p{L}\p{N}][\p{L}\p{N}/._'-]*/gu
 
@@ -20,7 +22,7 @@ function isSubstantiveAgentResult(value: string): boolean {
 export function assertSubstantiveAgentResult(value: string, label = 'Agent result'): string {
   const normalized = normalizeAgentResultText(value)
   if (!isSubstantiveAgentResult(normalized)) {
-    throw new Error(`${label} must contain substantive text.`)
+    throw new ValidationError({ message: `${label} must contain substantive text.` })
   }
 
   return normalized

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

@@ -1,6 +1,6 @@
 import { ToolLoopAgent } from 'ai'
 
-import { aiGatewayOpenRouterResponseHealingModel } from '../ai-gateway/ai-gateway'
+import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
@@ -34,7 +34,7 @@ The caller enforces a structured output schema with exactly one field:
 export function createContextCompactionAgent(options: CreateHelperToolLoopAgentOptions) {
   return new ToolLoopAgent({
     id: 'context-compaction',
-    model: aiGatewayOpenRouterResponseHealingModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+    model: aiGatewayChatModel(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

@@ -1,10 +1,12 @@
-import { ToolLoopAgent, stepCountIs, tool } from 'ai'
+import { generateText, ToolLoopAgent, stepCountIs, tool } from 'ai'
 import type { ModelMessage, LanguageModel, ToolLoopAgentSettings, ToolSet } from 'ai'
+import { Schema, Effect } from 'effect'
 import { z } from 'zod'
 
 import type { ToolDefinition } from '../ai/definitions'
 import { aiLogger } from '../config/logger'
-import { formatUtcPromptDate } from '../utils/date-time'
+import { formatUtcPromptDate, nowDate } from '../utils/date-time'
+import { getErrorMessage } from '../utils/errors'
 import { isRecord } from '../utils/string'
 import { assertSubstantiveAgentResult } from './agent-result'
 
@@ -28,11 +30,26 @@ interface DelegatedAgentDefinitionWithContext<TContext> extends Omit<DelegatedAg
   createTools: (context: TContext) => ToolSet
 }
 
+class DelegatedAgentError extends Schema.TaggedErrorClass<DelegatedAgentError>()('DelegatedAgentError', {
+  stage: Schema.Literals(['generate', 'validate', 'follow-up-generate', 'follow-up-validate']),
+  label: Schema.String,
+  message: Schema.String,
+  cause: Schema.Defect,
+}) {}
+
+function toDelegatedAgentError(
+  stage: DelegatedAgentError['stage'],
+  label: string,
+  cause: unknown,
+): DelegatedAgentError {
+  return new DelegatedAgentError({ stage, label, message: getErrorMessage(cause), cause })
+}
+
 function resolveAgentModel(model: AgentModel): LanguageModel {
   return typeof model === 'function' ? model() : model
 }
 
-function buildCurrentDateContext(now = new Date()): string {
+function buildCurrentDateContext(now = nowDate()): string {
   return [`Today is ${formatUtcPromptDate(now)}.`, 'Use this exact date for any recency reasoning.'].join(' ')
 }
 
@@ -134,49 +151,71 @@ function extractToolResultText(messages: ModelMessage[]): string {
   return chunks.join('\n\n---\n\n')
 }
 
-async function generateSubstantiveDelegatedAgentResult(params: {
+export function generateSubstantiveDelegatedAgentResultEffect(params: {
   label: string
   task: string
   abortSignal?: AbortSignal
   createAgent: () => ToolLoopAgent<never, ToolSet>
-}): Promise<string> {
-  const agent = params.createAgent()
-  const result = await agent.generate({ prompt: params.task, abortSignal: params.abortSignal })
-
-  try {
-    return assertSubstantiveAgentResult(result.text, params.label)
-  } catch (firstError) {
-    aiLogger.warn`Delegated agent returned non-substantive result, attempting follow-up synthesis (label=${params.label}, textLength=${result.text.length})`
-
-    if (params.abortSignal?.aborted) {
-      throw firstError
-    }
+  synthesize: (prompt: string, abortSignal?: AbortSignal) => PromiseLike<{ text: string }>
+}): Effect.Effect<string, DelegatedAgentError> {
+  return Effect.gen(function* () {
+    const agent = params.createAgent()
+    const result = yield* Effect.tryPromise({
+      try: () => agent.generate({ prompt: params.task, abortSignal: params.abortSignal }),
+      catch: (error) => toDelegatedAgentError('generate', params.label, error),
+    })
+
+    return yield* Effect.try({
+      try: () => assertSubstantiveAgentResult(result.text, params.label),
+      catch: (error) => toDelegatedAgentError('validate', params.label, error),
+    }).pipe(
+      Effect.catch((firstError) =>
+        Effect.gen(function* () {
+          yield* Effect.sync(() => {
+            aiLogger.warn`Delegated agent returned non-substantive result, attempting follow-up synthesis (label=${params.label}, textLength=${result.text.length})`
+          })
+
+          if (params.abortSignal?.aborted) {
+            return yield* firstError
+          }
 
-    // Try a follow-up: feed the agent's tool results back as context and ask for synthesis
-    const toolContext = extractToolResultText('messages' in result ? ((result.messages ?? []) as ModelMessage[]) : [])
-    if (toolContext.length > 100) {
-      const followUpPrompt = [
-        params.task,
-        '',
-        'Here is the research data you already gathered:',
-        '',
-        toolContext.slice(0, 8000),
-        '',
-        NON_SUBSTANTIVE_AGENT_RESULT_RETRY_PROMPT,
-      ].join('\n')
-
-      const followUp = await params.createAgent().generate({ prompt: followUpPrompt, abortSignal: params.abortSignal })
-
-      try {
-        return assertSubstantiveAgentResult(followUp.text, params.label)
-      } catch (secondError) {
-        aiLogger.error`Delegated agent follow-up also non-substantive (label=${params.label}, textLength=${followUp.text.length}, textPreview=${followUp.text.slice(0, 200)})`
-        throw secondError
-      }
-    }
+          // Try a follow-up: feed the agent's tool results back as context and ask for synthesis
+          const toolContext = extractToolResultText(
+            'messages' in result ? ((result.messages ?? []) as ModelMessage[]) : [],
+          )
+          if (toolContext.length <= 100) {
+            return yield* firstError
+          }
 
-    throw firstError
-  }
+          const followUpPrompt = [
+            params.task,
+            '',
+            'Here is the research data you already gathered:',
+            '',
+            toolContext.slice(0, 8000),
+            '',
+            NON_SUBSTANTIVE_AGENT_RESULT_RETRY_PROMPT,
+          ].join('\n')
+
+          const followUp = yield* Effect.tryPromise({
+            try: () => params.synthesize(followUpPrompt, params.abortSignal),
+            catch: (error) => toDelegatedAgentError('follow-up-generate', params.label, error),
+          })
+
+          return yield* Effect.try({
+            try: () => assertSubstantiveAgentResult(followUp.text, params.label),
+            catch: (error) => toDelegatedAgentError('follow-up-validate', params.label, error),
+          }).pipe(
+            Effect.catch((secondError) =>
+              Effect.sync(() => {
+                aiLogger.error`Delegated agent follow-up also non-substantive (label=${params.label}, textLength=${followUp.text.length}, textPreview=${followUp.text.slice(0, 200)})`
+              }).pipe(Effect.andThen(Effect.fail(secondError))),
+            ),
+          )
+        }),
+      ),
+    )
+  })
 }
 
 export function createDelegatedAgentTool(definition: DelegatedAgentDefinition): ToolDefinition<void> {
@@ -189,32 +228,47 @@ export function createDelegatedAgentTool(definition: DelegatedAgentDefinition):
       tool({
         description: definition.description,
         inputSchema: z.object({ task: z.string().min(1) }),
-        execute: async ({ task }: { task: string }, { abortSignal }) => {
-          const agentTools = definition.tools
-          const createAgent = () =>
-            new ToolLoopAgent({
-              id: definition.id,
-              model: resolveAgentModel(definition.model),
-              ...(definition.providerOptions ? { providerOptions: definition.providerOptions } : {}),
-              ...(definition.headers ? { headers: definition.headers } : {}),
-              instructions: buildDelegatedAgentInstructions(definition.instructions, agentTools),
-              tools: agentTools,
-              maxOutputTokens: definition.maxOutputTokens ?? DEFAULT_DELEGATED_AGENT_MAX_OUTPUT_TOKENS,
-              ...(typeof temperature === 'number' ? { temperature } : {}),
-              stopWhen: [stepCountIs(maxSteps)],
-              prepareStep: async ({ messages }) => ({ messages: retainCriticalAgentMessages(messages) }),
-            })
-
-          return {
-            task,
-            result: await generateSubstantiveDelegatedAgentResult({
-              label: `${definition.id} result`,
-              task,
-              abortSignal,
-              createAgent,
+        execute: ({ task }: { task: string }, { abortSignal }) =>
+          Effect.runPromise(
+            Effect.gen(function* () {
+              const agentTools = definition.tools
+              const createAgent = () =>
+                new ToolLoopAgent({
+                  id: definition.id,
+                  model: resolveAgentModel(definition.model),
+                  ...(definition.providerOptions ? { providerOptions: definition.providerOptions } : {}),
+                  ...(definition.headers ? { headers: definition.headers } : {}),
+                  instructions: buildDelegatedAgentInstructions(definition.instructions, agentTools),
+                  tools: agentTools,
+                  maxOutputTokens: definition.maxOutputTokens ?? DEFAULT_DELEGATED_AGENT_MAX_OUTPUT_TOKENS,
+                  ...(typeof temperature === 'number' ? { temperature } : {}),
+                  stopWhen: [stepCountIs(maxSteps)],
+                  prepareStep: ({ messages }) => ({ messages: retainCriticalAgentMessages(messages) }),
+                })
+              const synthesize = (prompt: string, abortSignal?: AbortSignal) =>
+                generateText({
+                  model: resolveAgentModel(definition.model),
+                  ...(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.`,
+                  prompt,
+                  abortSignal,
+                  maxOutputTokens: definition.maxOutputTokens ?? DEFAULT_DELEGATED_AGENT_MAX_OUTPUT_TOKENS,
+                  ...(typeof temperature === 'number' ? { temperature } : {}),
+                })
+
+              return {
+                task,
+                result: yield* generateSubstantiveDelegatedAgentResultEffect({
+                  label: `${definition.id} result`,
+                  task,
+                  abortSignal,
+                  createAgent,
+                  synthesize,
+                }),
+              }
             }),
-          }
-        },
+          ),
       }),
   } as const satisfies ToolDefinition<void>
 }
@@ -231,32 +285,47 @@ export function createDelegatedAgentToolWithContext<TContext>(
       tool({
         description: definition.description,
         inputSchema: z.object({ task: z.string().min(1) }),
-        execute: async ({ task }: { task: string }, { abortSignal }) => {
-          const agentTools = definition.createTools(context)
-          const createAgent = () =>
-            new ToolLoopAgent({
-              id: definition.id,
-              model: resolveAgentModel(definition.model),
-              ...(definition.providerOptions ? { providerOptions: definition.providerOptions } : {}),
-              ...(definition.headers ? { headers: definition.headers } : {}),
-              instructions: buildDelegatedAgentInstructions(definition.instructions, agentTools),
-              tools: agentTools,
-              maxOutputTokens: definition.maxOutputTokens ?? DEFAULT_DELEGATED_AGENT_MAX_OUTPUT_TOKENS,
-              ...(typeof temperature === 'number' ? { temperature } : {}),
-              stopWhen: [stepCountIs(maxSteps)],
-              prepareStep: async ({ messages }) => ({ messages: retainCriticalAgentMessages(messages) }),
-            })
-
-          return {
-            task,
-            result: await generateSubstantiveDelegatedAgentResult({
-              label: `${definition.id} result`,
-              task,
-              abortSignal,
-              createAgent,
+        execute: ({ task }: { task: string }, { abortSignal }) =>
+          Effect.runPromise(
+            Effect.gen(function* () {
+              const agentTools = definition.createTools(context)
+              const createAgent = () =>
+                new ToolLoopAgent({
+                  id: definition.id,
+                  model: resolveAgentModel(definition.model),
+                  ...(definition.providerOptions ? { providerOptions: definition.providerOptions } : {}),
+                  ...(definition.headers ? { headers: definition.headers } : {}),
+                  instructions: buildDelegatedAgentInstructions(definition.instructions, agentTools),
+                  tools: agentTools,
+                  maxOutputTokens: definition.maxOutputTokens ?? DEFAULT_DELEGATED_AGENT_MAX_OUTPUT_TOKENS,
+                  ...(typeof temperature === 'number' ? { temperature } : {}),
+                  stopWhen: [stepCountIs(maxSteps)],
+                  prepareStep: ({ messages }) => ({ messages: retainCriticalAgentMessages(messages) }),
+                })
+              const synthesize = (prompt: string, abortSignal?: AbortSignal) =>
+                generateText({
+                  model: resolveAgentModel(definition.model),
+                  ...(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.`,
+                  prompt,
+                  abortSignal,
+                  maxOutputTokens: definition.maxOutputTokens ?? DEFAULT_DELEGATED_AGENT_MAX_OUTPUT_TOKENS,
+                  ...(typeof temperature === 'number' ? { temperature } : {}),
+                })
+
+              return {
+                task,
+                result: yield* generateSubstantiveDelegatedAgentResultEffect({
+                  label: `${definition.id} result`,
+                  task,
+                  abortSignal,
+                  createAgent,
+                  synthesize,
+                }),
+              }
             }),
-          }
-        },
+          ),
       }),
   } as const satisfies ToolDefinition<TContext>
 }

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

@@ -1,6 +1,6 @@
 import { ToolLoopAgent } from 'ai'
 
-import { aiGatewayOpenRouterResponseHealingModel } from '../ai-gateway/ai-gateway'
+import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_LOW_REASONING_PROVIDER_OPTIONS,
@@ -32,7 +32,7 @@ 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: aiGatewayOpenRouterResponseHealingModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+    model: aiGatewayChatModel(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,6 +1,6 @@
 import { ToolLoopAgent } from 'ai'
 
-import { aiGatewayOpenRouterResponseHealingModel } from '../ai-gateway/ai-gateway'
+import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
@@ -52,7 +52,7 @@ Return only the schema fields with no extra formatting.
 export function createOrgMemoryAgent(options: CreateHelperToolLoopAgentOptions) {
   return new ToolLoopAgent({
     id: 'org-memory',
-    model: aiGatewayOpenRouterResponseHealingModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+    model: aiGatewayChatModel(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,6 +1,6 @@
 import { ToolLoopAgent } from 'ai'
 
-import { aiGatewayModel } from '../ai-gateway/ai-gateway'
+import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
 import { getLeadAgentDisplayName } from '../config/agent-defaults'
 import {
@@ -79,7 +79,7 @@ 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: aiGatewayModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+    model: aiGatewayChatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
     headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
     providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
     ...resolveHelperAgentOptions(options, {

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

@@ -1,6 +1,6 @@
 import { ToolLoopAgent } from 'ai'
 
-import { aiGatewayOpenRouterResponseHealingModel } from '../ai-gateway/ai-gateway'
+import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
@@ -27,7 +27,7 @@ Synthesize an updated workspace profile summary and durable memory facts from co
 export function createRegularChatMemoryDigestAgent(options: CreateHelperToolLoopAgentOptions) {
   return new ToolLoopAgent({
     id: 'regular-chat-memory-digest',
-    model: aiGatewayOpenRouterResponseHealingModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+    model: aiGatewayChatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
     headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
     providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
     ...resolveHelperAgentOptions(options, {

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

@@ -1,7 +1,7 @@
 import { ToolLoopAgent } from 'ai'
 import { z } from 'zod'
 
-import { aiGatewayOpenRouterResponseHealingModel } from '../ai-gateway/ai-gateway'
+import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
@@ -45,7 +45,7 @@ export type SkillCandidate = z.infer<typeof SkillCandidateSchema>
 export function createSkillExtractorAgent(options: CreateHelperToolLoopAgentOptions) {
   return new ToolLoopAgent({
     id: 'skill-extractor',
-    model: aiGatewayOpenRouterResponseHealingModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+    model: aiGatewayChatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
     headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
     providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
     ...resolveHelperAgentOptions(options, {

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

@@ -1,7 +1,7 @@
 import { ToolLoopAgent } from 'ai'
 import { z } from 'zod'
 
-import { aiGatewayOpenRouterResponseHealingModel } from '../ai-gateway/ai-gateway'
+import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
 import {
   OPENROUTER_STRUCTURED_HELPER_MODEL_ID,
@@ -69,7 +69,7 @@ export const SkillManagerOutputSchema = z.object({
 export function createSkillManagerAgent(options: CreateHelperToolLoopAgentOptions) {
   return new ToolLoopAgent({
     id: 'skill-manager',
-    model: aiGatewayOpenRouterResponseHealingModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
+    model: aiGatewayChatModel(OPENROUTER_STRUCTURED_HELPER_MODEL_ID),
     headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
     providerOptions: OPENROUTER_HIGH_REASONING_PROVIDER_OPTIONS,
     ...resolveHelperAgentOptions(options, {