@lota-sdk/core 0.1.43 → 0.1.45

package/package.json

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

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

@@ -4,7 +4,6 @@ import { z } from 'zod'
 import { aiGatewayChatModel } from '../ai-gateway/ai-gateway'
 import { buildAiGatewayDirectCacheHeaders } from '../ai-gateway/cache-headers'
 import { agentDescriptions, agentDisplayNames, routerModelId } from '../config/agent-defaults'
-import { OPENROUTER_FAST_REASONING_MODEL_ID } from '../config/model-constants'
 
 // ---------------------------------------------------------------------------
 // Schemas
@@ -45,26 +44,48 @@ function extractJson(text: string): unknown {
   }
 }
 
+/** Extract usable text from agent result — reasoning-only models put output in reasoning tokens */
+function extractResultText(result: { text?: string; reasoning?: unknown }): string {
+  const text = typeof result.text === 'string' ? result.text : ''
+  if (text.trim()) return text
+  // Reasoning can be a string or an array of { type, text } objects
+  const reasoning = result.reasoning
+  if (typeof reasoning === 'string') return reasoning
+  if (Array.isArray(reasoning)) {
+    return reasoning
+      .map((r) => (typeof r === 'string' ? r : typeof r === 'object' && r && 'text' in r ? String(r.text) : ''))
+      .join('')
+  }
+  return ''
+}
+
 // ---------------------------------------------------------------------------
 // Prompts
 // ---------------------------------------------------------------------------
 
-const TRIAGE_SYSTEM_PROMPT = `You are a workstream message router. Decide which team member should respond to the user message.
+const TRIAGE_SYSTEM_PROMPT = `You are a workstream message router. Decide which team member should respond FIRST to the user message.
 
 Rules:
 - Pick the single best-fit agent from the members list based on domain expertise.
+- If the user explicitly addresses an agent by name or role (e.g. "CTO: ..." or "CMO: ..."), route to that agent.
 - If no specialist clearly matches (general chat, greetings, coordination), respond with agentId "".
 - Be decisive. Reply with ONLY a JSON object, no other text.
 
 Format: {"agentId":"<id>","routingContext":"<1-sentence instruction>"}`
 
-const CHECK_SYSTEM_PROMPT = `You decide if another team member should also respond after the previous agent.
+const CHECK_SYSTEM_PROMPT = `You decide if another team member should ALSO respond after the previous agent's response.
+
+You will receive:
+- The original user message
+- Which agents already responded
+- The last agent's actual response
+- The remaining available agents
 
 Rules:
-- Add another agent if the user's message has a clearly separate dimension not yet covered.
-- If the user explicitly addressed multiple agents (e.g. "CTO: ... CMO: ..."), each addressed agent MUST respond.
-- If the previous agent deferred to another specialist, that specialist SHOULD respond.
-- Do NOT add agents for agreement or acknowledgement only.
+- If the user explicitly addressed multiple agents (e.g. "CTO: ... CMO: ...") and one hasn't responded yet, they MUST respond. Return done:false.
+- If the last agent's response explicitly defers to or recommends another specialist, that specialist SHOULD respond. Return done:false.
+- If there is a clearly separate dimension of the user's question not yet covered by any responded agent, add the best-fit remaining agent.
+- Do NOT add agents just for agreement, acknowledgement, or minor additions.
 - Reply with ONLY a JSON object, no other text.
 
 Format: {"done":true} or {"done":false,"agentId":"<id>","routingContext":"<1-sentence>"}`
@@ -74,16 +95,12 @@ Format: {"done":true} or {"done":false,"agentId":"<id>","routingContext":"<1-sen
 // ---------------------------------------------------------------------------
 
 function createRouterAgent(systemPrompt: string) {
-  const modelId = routerModelId ?? OPENROUTER_FAST_REASONING_MODEL_ID
-  // Router needs plain JSON output, not reasoning tokens
-  const providerOptions = routerModelId
-    ? { openai: { provider: { order: ['groq'], allow_fallbacks: true } } }
-    : undefined
+  const modelId = routerModelId ?? 'openai/gpt-5.4-nano'
   return new ToolLoopAgent({
     id: 'workstream-router',
     model: aiGatewayChatModel(modelId),
     headers: buildAiGatewayDirectCacheHeaders('workstream-router'),
-    providerOptions,
+    providerOptions: { openai: { reasoningEffort: 'high' } },
     instructions: systemPrompt,
     maxOutputTokens: 256,
   })
@@ -114,12 +131,8 @@ export async function triageWorkstreamMessage(params: {
     return null
   }
 
-  const rawText = typeof result.text === 'string' ? result.text : ''
-  const reasoning = (result as { reasoning?: string }).reasoning ?? ''
-  console.log('[workstream-router] triage raw text:', rawText.slice(0, 300))
-  console.log('[workstream-router] triage reasoning:', reasoning.slice(0, 300))
-  // Use reasoning as fallback if text is empty (reasoning-only models like gpt-oss-120b)
-  const effectiveText = rawText || reasoning
+  const effectiveText = extractResultText(result as { text?: string; reasoning?: unknown })
+  console.log('[workstream-router] triage raw:', effectiveText.slice(0, 300))
   const json = extractJson(effectiveText)
   const parsed = TriageResultSchema.safeParse(json)
   if (!parsed.success) {
@@ -157,17 +170,35 @@ export async function checkForNextAgent(params: {
     `Remaining members:\n${membersDesc}`,
     `Already responded: ${respondedList}`,
     `User message: "${params.messageText}"`,
-    `Last response summary: "${params.lastResponseSummary}"`,
+    `Last agent response:\n"${params.lastResponseSummary}"`,
   ].join('\n\n')
 
   const agent = createRouterAgent(CHECK_SYSTEM_PROMPT)
-  const result = await agent.generate({ messages: [{ role: 'user', content: prompt }], timeout: { totalMs: 30_000 } })
+  let result: Awaited<ReturnType<typeof agent.generate>>
+  try {
+    result = await agent.generate({ messages: [{ role: 'user', content: prompt }], timeout: { totalMs: 30_000 } })
+  } catch (error) {
+    console.error('[workstream-router] check failed:', error instanceof Error ? error.message : error)
+    return { done: true }
+  }
 
-  const json = extractJson(typeof result.text === 'string' ? result.text : '')
+  const effectiveText = extractResultText(result as { text?: string; reasoning?: unknown })
+  console.log('[workstream-router] check raw:', effectiveText.slice(0, 300))
+  const json = extractJson(effectiveText)
   const parsed = CheckResultSchema.safeParse(json)
-  if (!parsed.success) return { done: true }
-  if (parsed.data.done) return { done: true }
-  if (!parsed.data.agentId || !remainingMembers.includes(parsed.data.agentId)) return { done: true }
+  if (!parsed.success) {
+    console.log('[workstream-router] check parse failed:', JSON.stringify(parsed.error.issues))
+    return { done: true }
+  }
+  if (parsed.data.done) {
+    console.log('[workstream-router] check: done, no more agents needed')
+    return { done: true }
+  }
+  if (!parsed.data.agentId || !remainingMembers.includes(parsed.data.agentId)) {
+    console.log('[workstream-router] check: invalid agentId:', parsed.data.agentId)
+    return { done: true }
+  }
 
+  console.log('[workstream-router] check: next agent:', parsed.data.agentId)
   return parsed.data
 }