@lota-sdk/core 0.4.7 → 0.4.9

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

@@ -1,11 +1,19 @@
 import { generateObject } from 'ai'
+import { Effect } from 'effect'
 import { z } from 'zod'
 
 import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
-import { agentDescriptions, agentDisplayNames, agentShortDisplayNames, routerModelId } from '../config/agent-defaults'
+import {
+  getAgentDescriptions,
+  getAgentDisplayNames,
+  getAgentShortDisplayNames,
+  getRouterModelId,
+} from '../config/agent-defaults'
 import { chatLogger } from '../config/logger'
-import { withTimeout } from '../utils/async'
+import type { ValidationError } from '../effect/errors'
+import { AiGenerationError } from '../effect/errors'
+import { zodParse } from '../effect/zod'
 
 const TriageResultSchema = z.object({ agentId: z.string(), routingContext: z.string() })
 
@@ -42,7 +50,7 @@ function readDisplayName(agentId: string, options?: RouterDisplayOptions): strin
     return override
   }
 
-  return agentDisplayNames[agentId] ?? agentId
+  return getAgentDisplayNames()[agentId] ?? agentId
 }
 
 function readShortDisplayName(agentId: string, options?: RouterDisplayOptions): string {
@@ -51,10 +59,11 @@ function readShortDisplayName(agentId: string, options?: RouterDisplayOptions):
     return override
   }
 
-  return agentShortDisplayNames[agentId] ?? readDisplayName(agentId, options)
+  return getAgentShortDisplayNames()[agentId] ?? readDisplayName(agentId, options)
 }
 
 function buildMembersDescription(members: readonly string[], options?: RouterDisplayOptions): string {
+  const agentDescriptions = getAgentDescriptions()
   return members
     .map((id) => {
       const display = readDisplayName(id, options)
@@ -83,12 +92,15 @@ function extractExplicitAgentTargets(
 
   const memberSet = new Set(members)
   const aliases = new Map<string, string>()
+  const defaultDisplayNames = options?.displayNamesById === undefined ? getAgentDisplayNames() : undefined
+  const defaultShortDisplayNames =
+    options?.shortDisplayNamesById === undefined ? getAgentShortDisplayNames() : undefined
 
   for (const member of members) {
     for (const rawAlias of [
       member,
-      agentDisplayNames[member],
-      agentShortDisplayNames[member],
+      defaultDisplayNames?.[member],
+      defaultShortDisplayNames?.[member],
       readDisplayName(member, options),
       readShortDisplayName(member, options),
       ...(readStringArrayOverride(options?.routingAliasesByAgentId, member) ?? []),
@@ -153,16 +165,23 @@ Rules:
 
 const THREAD_ROUTER_TIMEOUT_MS = 30_000
 
-async function generateRouterObject<TSchema extends z.ZodTypeAny>(params: {
+function toRouterGenerationError(label: 'triage' | 'check', error: unknown): AiGenerationError {
+  return new AiGenerationError({
+    source: `thread-router:${label}`,
+    message: error instanceof Error ? error.message : String(error),
+  })
+}
+
+function generateRouterObjectEffect<TSchema extends z.ZodTypeAny>(params: {
   schema: TSchema
   system: string
   prompt: string
   label: 'triage' | 'check'
-}): Promise<z.infer<TSchema> | null> {
-  const modelId = routerModelId ?? 'openai/gpt-5.4-nano'
+}): Effect.Effect<z.infer<TSchema> | null, never> {
+  const modelId = getRouterModelId() ?? 'openrouter/openai/gpt-5.4-nano'
 
-  try {
-    const { object } = await withTimeout(
+  return Effect.tryPromise({
+    try: () =>
       generateObject({
         model: aiGatewayChatModel(modelId),
         headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
@@ -172,17 +191,34 @@ async function generateRouterObject<TSchema extends z.ZodTypeAny>(params: {
         prompt: params.prompt,
         maxOutputTokens: 256,
       }),
-      THREAD_ROUTER_TIMEOUT_MS,
-      `thread-router ${params.label}`,
-    )
-    return params.schema.parse(object)
-  } catch (error) {
-    chatLogger.error`[thread-router] ${params.label} failed: ${error instanceof Error ? error.message : String(error)}`
-    return null
-  }
+    catch: (error) => toRouterGenerationError(params.label, error),
+  }).pipe(
+    Effect.timeout(THREAD_ROUTER_TIMEOUT_MS),
+    Effect.catchTag('TimeoutError', () =>
+      Effect.fail(
+        new AiGenerationError({
+          source: `thread-router:${params.label}`,
+          message: `Timed out after ${THREAD_ROUTER_TIMEOUT_MS}ms`,
+        }),
+      ),
+    ),
+    Effect.flatMap(({ object }) => zodParse(params.schema, object)),
+    Effect.catchTags({
+      AiGenerationError: (error: AiGenerationError) =>
+        Effect.sync(() => {
+          chatLogger.error`[thread-router] ${params.label} failed: ${error.message}`
+          return null
+        }),
+      ValidationError: (error: ValidationError) =>
+        Effect.sync(() => {
+          chatLogger.error`[thread-router] ${params.label} failed: ${error.message}`
+          return null
+        }),
+    }),
+  )
 }
 
-export async function triageThreadMessage(params: {
+export function triageThreadMessage(params: {
   threadTitle: string
   members: readonly string[]
   messageText: string
@@ -191,54 +227,58 @@ export async function triageThreadMessage(params: {
   shortDisplayNamesById?: Partial<Record<string, string>>
   routingAliasesByAgentId?: Partial<Record<string, string[]>>
 }): Promise<RouterTriageResult | null> {
-  const displayOptions: RouterDisplayOptions = {
-    displayNamesById: params.displayNamesById,
-    shortDisplayNamesById: params.shortDisplayNamesById,
-    routingAliasesByAgentId: params.routingAliasesByAgentId,
-  }
-  const explicitTargets = extractExplicitAgentTargets(params.messageText, params.members, displayOptions)
-  const firstExplicitTarget = explicitTargets[0]
-  if (firstExplicitTarget) {
-    return {
-      agentId: firstExplicitTarget,
-      routingContext: buildExplicitAgentRoutingContext(firstExplicitTarget, displayOptions),
-    }
-  }
-
-  const membersDesc = buildMembersDescription(params.members, displayOptions)
-  const prompt = [
-    `Thread: "${params.threadTitle}"`,
-    `Members:\n${membersDesc}`,
-    params.recentContext ? `Recent context:\n${params.recentContext}` : '',
-    `User message: "${params.messageText}"`,
-  ]
-    .filter(Boolean)
-    .join('\n\n')
-
-  const parsed = await generateRouterObject({
-    schema: TriageResultSchema,
-    system: TRIAGE_SYSTEM_PROMPT,
-    prompt,
-    label: 'triage',
-  })
-
-  if (!parsed) {
-    return null
-  }
-  if (!parsed.agentId) {
-    chatLogger.debug`[thread-router] triage returned empty agentId`
-    return null
-  }
-  if (!params.members.includes(parsed.agentId)) {
-    chatLogger.warn`[thread-router] triage returned unknown agent: ${parsed.agentId}`
-    return null
-  }
-
-  chatLogger.debug`[thread-router] triage routed to ${parsed.agentId}`
-  return parsed
+  return Effect.runPromise(
+    Effect.gen(function* () {
+      const displayOptions: RouterDisplayOptions = {
+        displayNamesById: params.displayNamesById,
+        shortDisplayNamesById: params.shortDisplayNamesById,
+        routingAliasesByAgentId: params.routingAliasesByAgentId,
+      }
+      const explicitTargets = extractExplicitAgentTargets(params.messageText, params.members, displayOptions)
+      const firstExplicitTarget = explicitTargets[0]
+      if (firstExplicitTarget) {
+        return {
+          agentId: firstExplicitTarget,
+          routingContext: buildExplicitAgentRoutingContext(firstExplicitTarget, displayOptions),
+        }
+      }
+
+      const membersDesc = buildMembersDescription(params.members, displayOptions)
+      const prompt = [
+        `Thread: "${params.threadTitle}"`,
+        `Members:\n${membersDesc}`,
+        params.recentContext ? `Recent context:\n${params.recentContext}` : '',
+        `User message: "${params.messageText}"`,
+      ]
+        .filter(Boolean)
+        .join('\n\n')
+
+      const parsed = yield* generateRouterObjectEffect({
+        schema: TriageResultSchema,
+        system: TRIAGE_SYSTEM_PROMPT,
+        prompt,
+        label: 'triage',
+      })
+
+      if (!parsed) {
+        return null
+      }
+      if (!parsed.agentId) {
+        chatLogger.debug`[thread-router] triage returned empty agentId`
+        return null
+      }
+      if (!params.members.includes(parsed.agentId)) {
+        chatLogger.warn`[thread-router] triage returned unknown agent: ${parsed.agentId}`
+        return null
+      }
+
+      chatLogger.debug`[thread-router] triage routed to ${parsed.agentId}`
+      return parsed
+    }),
+  )
 }
 
-export async function checkForNextAgent(params: {
+export function checkForNextAgent(params: {
   threadTitle: string
   members: readonly string[]
   messageText: string
@@ -248,51 +288,55 @@ export async function checkForNextAgent(params: {
   shortDisplayNamesById?: Partial<Record<string, string>>
   routingAliasesByAgentId?: Partial<Record<string, string[]>>
 }): Promise<RouterCheckResult> {
-  const displayOptions: RouterDisplayOptions = {
-    displayNamesById: params.displayNamesById,
-    shortDisplayNamesById: params.shortDisplayNamesById,
-    routingAliasesByAgentId: params.routingAliasesByAgentId,
-  }
-  const explicitTargets = extractExplicitAgentTargets(params.messageText, params.members, displayOptions)
-  const nextExplicitTarget = explicitTargets.find((agentId) => !params.respondedAgents.includes(agentId))
-  if (nextExplicitTarget) {
-    return {
-      done: false,
-      agentId: nextExplicitTarget,
-      routingContext: buildExplicitAgentRoutingContext(nextExplicitTarget, displayOptions),
-    }
-  }
-
-  const remainingMembers = params.members.filter((id) => !params.respondedAgents.includes(id))
-  if (remainingMembers.length === 0) return { done: true }
-
-  const membersDesc = buildMembersDescription(remainingMembers, displayOptions)
-  const respondedList = params.respondedAgents.map((id) => readDisplayName(id, displayOptions)).join(', ')
-
-  const prompt = [
-    `Thread: "${params.threadTitle}"`,
-    `Remaining members:\n${membersDesc}`,
-    `Already responded: ${respondedList}`,
-    `User message: "${params.messageText}"`,
-    `Last agent response:\n"${params.lastResponseSummary}"`,
-  ].join('\n\n')
-
-  const parsed = await generateRouterObject({
-    schema: CheckResultObjectSchema,
-    system: CHECK_SYSTEM_PROMPT,
-    prompt,
-    label: 'check',
-  })
-
-  if (!parsed || parsed.done) {
-    chatLogger.debug`[thread-router] check finished without another agent`
-    return { done: true }
-  }
-  if (!parsed.agentId || !remainingMembers.includes(parsed.agentId)) {
-    chatLogger.warn`[thread-router] check returned invalid agent: ${parsed.agentId ?? 'missing'}`
-    return { done: true }
-  }
-
-  chatLogger.debug`[thread-router] check selected ${parsed.agentId}`
-  return { done: false, agentId: parsed.agentId, routingContext: parsed.routingContext ?? null }
+  return Effect.runPromise(
+    Effect.gen(function* () {
+      const displayOptions: RouterDisplayOptions = {
+        displayNamesById: params.displayNamesById,
+        shortDisplayNamesById: params.shortDisplayNamesById,
+        routingAliasesByAgentId: params.routingAliasesByAgentId,
+      }
+      const explicitTargets = extractExplicitAgentTargets(params.messageText, params.members, displayOptions)
+      const nextExplicitTarget = explicitTargets.find((agentId) => !params.respondedAgents.includes(agentId))
+      if (nextExplicitTarget) {
+        return {
+          done: false,
+          agentId: nextExplicitTarget,
+          routingContext: buildExplicitAgentRoutingContext(nextExplicitTarget, displayOptions),
+        }
+      }
+
+      const remainingMembers = params.members.filter((id) => !params.respondedAgents.includes(id))
+      if (remainingMembers.length === 0) return { done: true }
+
+      const membersDesc = buildMembersDescription(remainingMembers, displayOptions)
+      const respondedList = params.respondedAgents.map((id) => readDisplayName(id, displayOptions)).join(', ')
+
+      const prompt = [
+        `Thread: "${params.threadTitle}"`,
+        `Remaining members:\n${membersDesc}`,
+        `Already responded: ${respondedList}`,
+        `User message: "${params.messageText}"`,
+        `Last agent response:\n"${params.lastResponseSummary}"`,
+      ].join('\n\n')
+
+      const parsed = yield* generateRouterObjectEffect({
+        schema: CheckResultObjectSchema,
+        system: CHECK_SYSTEM_PROMPT,
+        prompt,
+        label: 'check',
+      })
+
+      if (!parsed || parsed.done) {
+        chatLogger.debug`[thread-router] check finished without another agent`
+        return { done: true }
+      }
+      if (!parsed.agentId || !remainingMembers.includes(parsed.agentId)) {
+        chatLogger.warn`[thread-router] check returned invalid agent: ${parsed.agentId ?? 'missing'}`
+        return { done: true }
+      }
+
+      chatLogger.debug`[thread-router] check selected ${parsed.agentId}`
+      return { done: false, agentId: parsed.agentId, routingContext: parsed.routingContext ?? null }
+    }),
+  )
 }

package/src/system-agents/title-generator.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 {
   OPENROUTER_FAST_REASONING_MODEL_ID,
@@ -33,7 +33,7 @@ Return only the title text. No quotes, no labels, no explanation.
 export function createThreadTitleGeneratorAgent(options: CreateHelperToolLoopAgentOptions) {
   return new ToolLoopAgent({
     id: 'thread-title-generator',
-    model: aiGatewayModel(OPENROUTER_FAST_REASONING_MODEL_ID),
+    model: aiGatewayChatModel(OPENROUTER_FAST_REASONING_MODEL_ID),
     headers: buildAiGatewayDirectCacheHeaders('lota-sdk'),
     providerOptions: OPENROUTER_MINIMAL_REASONING_PROVIDER_OPTIONS,
     ...resolveHelperAgentOptions(options, {