@swarmclawai/swarmclaw 1.2.1 → 1.2.3

package/src/lib/server/chat-execution/chat-turn-stream-execution.ts

@@ -0,0 +1,296 @@
+import { CONTEXT_OVERFLOW_RE } from '@/lib/providers/error-classification'
+import type { ProviderType } from '@/types'
+import { getEnabledCapabilityIds } from '@/lib/capability-selection'
+import { isLocalOpenClawEndpoint } from '@/lib/openclaw/openclaw-endpoint'
+import { streamAgentChat } from '@/lib/server/chat-execution/stream-agent-chat'
+import { applyContextClearBoundary } from '@/lib/server/chat-execution/chat-execution-utils'
+import { estimateCost } from '@/lib/server/cost'
+import { log } from '@/lib/server/logger'
+import { runCapabilityHook } from '@/lib/server/native-capabilities'
+import { markProviderFailure } from '@/lib/server/provider-health'
+import {
+  getCachedLlmResponse,
+  resolveLlmResponseCacheConfig,
+  setCachedLlmResponse,
+  type LlmResponseCacheKeyInput,
+} from '@/lib/server/llm-response-cache'
+import {
+  activeSessionProcesses,
+  clearActiveSessionProcess,
+  registerActiveSessionProcess,
+} from '@/lib/server/runtime/runtime-state'
+import { perf } from '@/lib/server/runtime/perf'
+import { getSessionMessages } from '@/lib/server/sessions/session-repository'
+import { notify } from '@/lib/server/ws-hub'
+import { errorMessage as toErrorMessage } from '@/lib/shared-utils'
+
+import type { ExecuteChatTurnInput } from './chat-execution-types'
+import type { PartialAssistantPersistence } from '@/lib/server/chat-execution/chat-turn-partial-persistence'
+import type { PreparedExecutableChatTurn } from '@/lib/server/chat-execution/chat-turn-preparation'
+import type { ToolRoutingResult } from '@/lib/server/chat-execution/chat-turn-tool-routing'
+
+const TAG = 'chat-execution'
+
+export interface ExecutedPreparedChatTurn {
+  fullResponse: string
+  errorMessage?: string
+  toolRoutingResult: ToolRoutingResult | null
+  responseCacheHit: boolean
+  durationMs: number
+  directUsage: {
+    inputTokens: number
+    outputTokens: number
+    received: boolean
+  }
+}
+
+export async function executePreparedChatTurn(params: {
+  input: ExecuteChatTurnInput
+  prepared: PreparedExecutableChatTurn
+  partialPersistence: PartialAssistantPersistence
+  preflightToolRoutingResult?: ToolRoutingResult | null
+}): Promise<ExecutedPreparedChatTurn> {
+  const { input, prepared, partialPersistence, preflightToolRoutingResult = null } = params
+  const {
+    sessionId,
+    imageUrl,
+    attachedFiles,
+    internal = false,
+    runId,
+    source = 'chat',
+    signal,
+  } = input
+  const {
+    sessionForRun,
+    appSettings,
+    lifecycleRunId,
+    extensionsForRun,
+    effectiveMessage,
+    providerType,
+    provider,
+    apiKey,
+    hasExtensions,
+    systemPrompt,
+    resolvedImagePath,
+    heartbeatLightContext,
+    isAutoRunNoHistory,
+    missionContextBlock,
+  } = prepared
+
+  const emit = partialPersistence.emit
+  const parseAndEmit = partialPersistence.parseAndEmit
+  let fullResponse = ''
+  let errorMessage: string | undefined
+
+  const directUsage = { inputTokens: 0, outputTokens: 0, received: false }
+  const responseCacheConfig = resolveLlmResponseCacheConfig(appSettings)
+  let responseCacheHit = false
+  let responseCacheInput: LlmResponseCacheKeyInput | null = null
+  let durationMs = 0
+  const startTs = Date.now()
+  const endLlmPerf = perf.start('chat-execution', 'llm-round-trip', {
+    sessionId,
+    provider: providerType,
+    hasExtensions,
+    extensionCount: getEnabledCapabilityIds(sessionForRun).length,
+  })
+
+  if (preflightToolRoutingResult) {
+    fullResponse = preflightToolRoutingResult.fullResponse
+    errorMessage = preflightToolRoutingResult.errorMessage
+    if (fullResponse) emit({ t: 'd', text: fullResponse })
+    partialPersistence.stop()
+    endLlmPerf({ durationMs: 0, cacheHit: false })
+    return {
+      fullResponse,
+      errorMessage,
+      toolRoutingResult: preflightToolRoutingResult,
+      responseCacheHit,
+      durationMs,
+      directUsage,
+    }
+  }
+
+  const abortController = new AbortController()
+  const abortFromOutside = () => abortController.abort()
+  if (signal) {
+    if (signal.aborted) abortController.abort()
+    else signal.addEventListener('abort', abortFromOutside)
+  }
+
+  registerActiveSessionProcess(sessionId, {
+    runId: runId || null,
+    source,
+    kill: () => abortController.abort(),
+  })
+
+  try {
+    const heartbeatHistory = isAutoRunNoHistory
+      ? (heartbeatLightContext ? [] : getSessionMessages(sessionId).slice(-6))
+      : undefined
+
+    const useLocalOpenClawNativeRuntime = providerType === 'openclaw' && isLocalOpenClawEndpoint(sessionForRun.apiEndpoint)
+    log.info(
+      TAG,
+      `provider=${providerType}, hasExtensions=${hasExtensions}, localOpenClawNative=${useLocalOpenClawNativeRuntime}, imagePath=${resolvedImagePath || 'none'}, attachedFiles=${attachedFiles?.length || 0}, extensions=${getEnabledCapabilityIds(sessionForRun).length}`,
+    )
+
+    if (hasExtensions) {
+      const result = await streamAgentChat({
+        session: sessionForRun,
+        message: effectiveMessage,
+        imagePath: resolvedImagePath,
+        imageUrl,
+        attachedFiles,
+        apiKey,
+        systemPrompt,
+        extraSystemContext: missionContextBlock ? [missionContextBlock] : undefined,
+        write: (raw) => parseAndEmit(raw),
+        history: heartbeatHistory ?? applyContextClearBoundary(getSessionMessages(sessionId)),
+        signal: abortController.signal,
+        source,
+      })
+      fullResponse = result.finalResponse || result.fullText
+    } else {
+      let directHistorySnapshot = isAutoRunNoHistory
+        ? (heartbeatLightContext ? [] : getSessionMessages(sessionId).slice(-6))
+        : applyContextClearBoundary(getSessionMessages(sessionId))
+      responseCacheInput = {
+        provider: providerType,
+        model: sessionForRun.model,
+        apiEndpoint: sessionForRun.apiEndpoint || '',
+        systemPrompt,
+        message: effectiveMessage,
+        imagePath: input.imagePath,
+        imageUrl,
+        attachedFiles,
+        history: directHistorySnapshot,
+      }
+      const canUseResponseCache = !internal && responseCacheConfig.enabled
+      const cached = canUseResponseCache
+        ? getCachedLlmResponse(responseCacheInput, responseCacheConfig)
+        : null
+      if (cached) {
+        responseCacheHit = true
+        fullResponse = cached.text
+        emit({
+          t: 'md',
+          text: JSON.stringify({
+            cache: {
+              hit: true,
+              ageMs: cached.ageMs,
+              provider: cached.provider,
+              model: cached.model,
+            },
+          }),
+        })
+        emit({ t: 'd', text: cached.text })
+      } else {
+        await runCapabilityHook(
+          'llmInput',
+          {
+            session: sessionForRun,
+            runId: lifecycleRunId,
+            provider: providerType as ProviderType,
+            model: sessionForRun.model,
+            systemPrompt,
+            prompt: effectiveMessage,
+            historyMessages: directHistorySnapshot,
+            imagesCount: resolvedImagePath ? 1 : 0,
+          },
+          { enabledIds: extensionsForRun },
+        )
+        const doStreamChat = () => provider.handler.streamChat({
+          session: sessionForRun,
+          message: effectiveMessage,
+          imagePath: resolvedImagePath,
+          apiKey,
+          systemPrompt,
+          write: (raw: string) => parseAndEmit(raw),
+          active: activeSessionProcesses,
+          loadHistory: (sid: string) => {
+            if (sid === sessionId) return directHistorySnapshot
+            return isAutoRunNoHistory
+              ? getSessionMessages(sid).slice(-6)
+              : applyContextClearBoundary(getSessionMessages(sid))
+          },
+          onUsage: (usage) => {
+            directUsage.inputTokens = usage.inputTokens
+            directUsage.outputTokens = usage.outputTokens
+            directUsage.received = true
+          },
+          signal: abortController.signal,
+        })
+        try {
+          fullResponse = await doStreamChat()
+        } catch (streamErr: unknown) {
+          const streamErrMsg = toErrorMessage(streamErr)
+          const streamStatus = (streamErr as Record<string, unknown>)?.status
+          if (typeof streamStatus === 'number' && streamStatus === 400 && CONTEXT_OVERFLOW_RE.test(streamErrMsg)) {
+            log.warn('chat-run', 'Context overflow in direct path, reducing history and retrying', {
+              sessionId,
+              error: streamErrMsg,
+              historyLen: directHistorySnapshot.length,
+            })
+            directHistorySnapshot = directHistorySnapshot.slice(-10)
+            fullResponse = await doStreamChat()
+          } else {
+            throw streamErr
+          }
+        }
+        await runCapabilityHook(
+          'llmOutput',
+          {
+            session: sessionForRun,
+            runId: lifecycleRunId,
+            provider: providerType as ProviderType,
+            model: sessionForRun.model,
+            assistantTexts: fullResponse ? [fullResponse] : [],
+            response: fullResponse,
+            usage: directUsage.received
+              ? {
+                  input: directUsage.inputTokens,
+                  output: directUsage.outputTokens,
+                  total: directUsage.inputTokens + directUsage.outputTokens,
+                  estimatedCost: estimateCost(sessionForRun.model, directUsage.inputTokens, directUsage.outputTokens),
+                }
+              : undefined,
+          },
+          { enabledIds: extensionsForRun },
+        )
+        if (canUseResponseCache && responseCacheInput && fullResponse) {
+          setCachedLlmResponse(responseCacheInput, fullResponse, responseCacheConfig)
+        }
+      }
+    }
+    durationMs = Date.now() - startTs
+    endLlmPerf({ durationMs, cacheHit: responseCacheHit })
+  } catch (err: unknown) {
+    endLlmPerf({ error: true })
+    errorMessage = toErrorMessage(err)
+    const failureText = errorMessage || 'Run failed.'
+    markProviderFailure(providerType, failureText, sessionForRun.credentialId)
+    emit({ t: 'err', text: failureText })
+    log.error('chat-run', `Run failed for session ${sessionId}`, {
+      runId,
+      source,
+      internal,
+      error: failureText,
+      stack: err instanceof Error ? err.stack?.split('\n').slice(0, 6).join('\n') : undefined,
+    })
+  } finally {
+    partialPersistence.stop()
+    clearActiveSessionProcess(sessionId)
+    notify('sessions')
+    if (signal) signal.removeEventListener('abort', abortFromOutside)
+  }
+
+  return {
+    fullResponse,
+    errorMessage,
+    toolRoutingResult: null,
+    responseCacheHit,
+    durationMs,
+    directUsage,
+  }
+}

package/src/lib/server/chat-execution/chat-turn-tool-routing.ts

@@ -12,7 +12,7 @@
 import path from 'node:path'
 import type { StructuredToolInterface } from '@langchain/core/tools'
 import type { AppSettings, MessageToolEvent, SSEEvent } from '@/types'
-import { loadAgents } from '@/lib/server/storage'
+import { getAgent } from '@/lib/server/agents/agent-repository'
 import { buildSessionTools } from '@/lib/server/session-tools'
 import { resolveConcreteToolPolicyBlock, type ExtensionPolicyDecision } from '@/lib/server/tool-capability-policy'
 import { resolveActiveProjectContext } from '@/lib/server/project-context'
@@ -350,7 +350,7 @@ export function resolveRequestedToolPreflightResponse(params: {
   const requestedToolNames = requestedToolNamesFromMessage(params.message)
   if (requestedToolNames.length === 0) return null
 
-  const agent = params.session?.agentId ? loadAgents()[params.session.agentId] : null
+  const agent = params.session?.agentId ? getAgent(params.session.agentId) : null
   const blockedResponses: string[] = []
   const unavailableResponses: string[] = []
   for (const toolName of requestedToolNames) {
@@ -361,8 +361,8 @@ export function resolveRequestedToolPreflightResponse(params: {
     }
     if (
       (toolName === 'delegate' || toolName.startsWith('delegate_to_'))
-      && agent
-      && agent.delegationEnabled !== true
+      && params.session?.agentId
+      && agent?.delegationEnabled !== true
     ) {
       unavailableResponses.push(buildToolUnavailableResponse(toolName, 'delegation is not enabled for this agent right now'))
       continue
@@ -407,7 +407,7 @@ async function invokeSessionTool(
     return { invoked: false, responseOverride: null }
   }
 
-  const agent = ctx.session.agentId ? loadAgents()[ctx.session.agentId] : null
+  const agent = ctx.session.agentId ? getAgent(ctx.session.agentId) : null
   const agentRecord = agent as Record<string, unknown> | null
   const activeProjectContext = resolveActiveProjectContext(ctx.session as unknown as { agentId?: string | null; cwd?: string | null; projectId?: string | null })
   const { tools, cleanup } = await buildSessionTools(ctx.session.cwd, ctx.enabledExtensions, {

package/src/lib/server/chat-execution/message-classifier.test.ts

@@ -0,0 +1,329 @@
+import assert from 'node:assert/strict'
+import { describe, it, before, after } from 'node:test'
+
+const originalEnv = {
+  SWARMCLAW_BUILD_MODE: process.env.SWARMCLAW_BUILD_MODE,
+}
+
+let mod: typeof import('@/lib/server/chat-execution/message-classifier')
+
+before(async () => {
+  process.env.SWARMCLAW_BUILD_MODE = '1'
+  mod = await import('@/lib/server/chat-execution/message-classifier')
+})
+
+after(() => {
+  if (originalEnv.SWARMCLAW_BUILD_MODE === undefined) delete process.env.SWARMCLAW_BUILD_MODE
+  else process.env.SWARMCLAW_BUILD_MODE = originalEnv.SWARMCLAW_BUILD_MODE
+})
+
+// ---------------------------------------------------------------------------
+// parseClassificationResponse
+// ---------------------------------------------------------------------------
+
+describe('parseClassificationResponse', () => {
+  const validJson = JSON.stringify({
+    isDeliverableTask: true,
+    isBroadGoal: false,
+    walletIntent: 'none',
+    hasHumanSignals: false,
+    hasSignificantEvent: false,
+    isResearchSynthesis: false,
+    explicitToolRequests: [],
+    confidence: 0.9,
+  })
+
+  it('parses valid JSON with all schema fields', () => {
+    const result = mod.parseClassificationResponse(validJson)
+    assert.ok(result)
+    assert.equal(result!.isDeliverableTask, true)
+    assert.equal(result!.isBroadGoal, false)
+    assert.equal(result!.walletIntent, 'none')
+    assert.equal(result!.confidence, 0.9)
+    assert.deepEqual(result!.explicitToolRequests, [])
+  })
+
+  it('returns null for malformed JSON', () => {
+    assert.equal(mod.parseClassificationResponse('not json at all'), null)
+    assert.equal(mod.parseClassificationResponse('{broken'), null)
+  })
+
+  it('returns null for JSON missing required keys', () => {
+    const partial = JSON.stringify({ isDeliverableTask: true })
+    assert.equal(mod.parseClassificationResponse(partial), null)
+  })
+
+  it('tolerates extra keys in JSON', () => {
+    const withExtra = JSON.stringify({
+      isDeliverableTask: true,
+      isBroadGoal: false,
+      walletIntent: 'none',
+      hasHumanSignals: false,
+      hasSignificantEvent: false,
+      isResearchSynthesis: false,
+      explicitToolRequests: ['shell'],
+      confidence: 0.85,
+      extraKey: 'should be ignored',
+    })
+    const result = mod.parseClassificationResponse(withExtra)
+    assert.ok(result)
+    assert.equal(result!.isDeliverableTask, true)
+  })
+
+  it('extracts embedded JSON from prose text', () => {
+    const prose = `Here is my classification:\n${validJson}\nEnd of classification.`
+    const result = mod.parseClassificationResponse(prose)
+    assert.ok(result)
+    assert.equal(result!.isDeliverableTask, true)
+  })
+
+  it('returns null for empty text', () => {
+    assert.equal(mod.parseClassificationResponse(''), null)
+    assert.equal(mod.parseClassificationResponse('   '), null)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// isDeliverableTask
+// ---------------------------------------------------------------------------
+
+describe('isDeliverableTask', () => {
+  it('uses classification value when provided', () => {
+    const cls = makeClassification({ isDeliverableTask: true })
+    assert.equal(mod.isDeliverableTask(cls, 'anything'), true)
+
+    const cls2 = makeClassification({ isDeliverableTask: false })
+    assert.equal(mod.isDeliverableTask(cls2, 'build me a landing page'), false)
+  })
+
+  it('falls back to regex when classification is null', () => {
+    // A message that looks like a deliverable task
+    const result = mod.isDeliverableTask(null, 'Create a detailed marketing report with competitor analysis and market sizing. Include charts and recommendations for Q3 strategy across all regions.')
+    assert.equal(typeof result, 'boolean')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// isBroadGoal
+// ---------------------------------------------------------------------------
+
+describe('isBroadGoal', () => {
+  it('uses classification value when provided', () => {
+    assert.equal(mod.isBroadGoal(makeClassification({ isBroadGoal: true }), ''), true)
+    assert.equal(mod.isBroadGoal(makeClassification({ isBroadGoal: false }), ''), false)
+  })
+
+  it('falls back to regex when classification is null', () => {
+    const result = mod.isBroadGoal(null, 'I want to build a complete e-commerce platform with user authentication, product catalog, shopping cart, and payment processing')
+    assert.equal(typeof result, 'boolean')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// hasWalletIntent
+// ---------------------------------------------------------------------------
+
+describe('hasWalletIntent', () => {
+  it('walletIntent none returns false', () => {
+    assert.equal(mod.hasWalletIntent(makeClassification({ walletIntent: 'none' }), ''), false)
+  })
+
+  it('walletIntent read_only returns true', () => {
+    assert.equal(mod.hasWalletIntent(makeClassification({ walletIntent: 'read_only' }), ''), true)
+  })
+
+  it('walletIntent transactional returns true', () => {
+    assert.equal(mod.hasWalletIntent(makeClassification({ walletIntent: 'transactional' }), ''), true)
+  })
+
+  it('falls back to regex when classification is null', () => {
+    const result = mod.hasWalletIntent(null, 'check my wallet balance')
+    assert.equal(typeof result, 'boolean')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// hasTransactionalWalletIntent
+// ---------------------------------------------------------------------------
+
+describe('hasTransactionalWalletIntent', () => {
+  it('only transactional returns true', () => {
+    assert.equal(mod.hasTransactionalWalletIntent(makeClassification({ walletIntent: 'transactional' }), ''), true)
+    assert.equal(mod.hasTransactionalWalletIntent(makeClassification({ walletIntent: 'read_only' }), ''), false)
+    assert.equal(mod.hasTransactionalWalletIntent(makeClassification({ walletIntent: 'none' }), ''), false)
+  })
+
+  it('falls back to regex when classification is null', () => {
+    const result = mod.hasTransactionalWalletIntent(null, 'swap 1 ETH for USDC')
+    assert.equal(typeof result, 'boolean')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// hasHumanSignals
+// ---------------------------------------------------------------------------
+
+describe('hasHumanSignals', () => {
+  it('uses classification value when provided', () => {
+    assert.equal(mod.hasHumanSignals(makeClassification({ hasHumanSignals: true }), ''), true)
+    assert.equal(mod.hasHumanSignals(makeClassification({ hasHumanSignals: false }), ''), false)
+  })
+
+  it('regex detects personal text', () => {
+    assert.equal(mod.hasHumanSignals(null, 'my birthday is next week'), true)
+  })
+
+  it('regex returns false for task-only text', () => {
+    assert.equal(mod.hasHumanSignals(null, 'deploy the app'), false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// hasSignificantEvent
+// ---------------------------------------------------------------------------
+
+describe('hasSignificantEvent', () => {
+  it('uses classification value when provided', () => {
+    assert.equal(mod.hasSignificantEvent(makeClassification({ hasSignificantEvent: true }), ''), true)
+    assert.equal(mod.hasSignificantEvent(makeClassification({ hasSignificantEvent: false }), ''), false)
+  })
+
+  it('regex detects significant events', () => {
+    assert.equal(mod.hasSignificantEvent(null, 'I just got promoted at work'), true)
+    assert.equal(mod.hasSignificantEvent(null, 'my graduation ceremony is on Friday'), true)
+  })
+
+  it('regex returns false for non-event text', () => {
+    assert.equal(mod.hasSignificantEvent(null, 'fix the login bug'), false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// isResearchSynthesis
+// ---------------------------------------------------------------------------
+
+describe('isResearchSynthesis', () => {
+  it('uses classification value when provided', () => {
+    assert.equal(mod.isResearchSynthesis(makeClassification({ isResearchSynthesis: true }), null), true)
+    assert.equal(mod.isResearchSynthesis(makeClassification({ isResearchSynthesis: false }), null), false)
+  })
+
+  it('falls back to routingIntent when classification is null', () => {
+    assert.equal(mod.isResearchSynthesis(null, 'research'), true)
+    assert.equal(mod.isResearchSynthesis(null, 'browsing'), true)
+    assert.equal(mod.isResearchSynthesis(null, 'coding'), false)
+    assert.equal(mod.isResearchSynthesis(null, null), false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// classifyMessage — with generateText override
+// ---------------------------------------------------------------------------
+
+describe('classifyMessage', () => {
+  it('returns valid classification from mock generateText', async () => {
+    const mockResponse = JSON.stringify({
+      isDeliverableTask: true,
+      isBroadGoal: false,
+      walletIntent: 'none',
+      hasHumanSignals: false,
+      hasSignificantEvent: false,
+      isResearchSynthesis: false,
+      explicitToolRequests: ['shell'],
+      confidence: 0.95,
+    })
+
+    const result = await mod.classifyMessage(
+      { sessionId: 'test-session', message: 'Build me a dashboard' },
+      { generateText: async () => mockResponse },
+    )
+
+    assert.ok(result)
+    assert.equal(result!.isDeliverableTask, true)
+    assert.equal(result!.walletIntent, 'none')
+    assert.deepEqual(result!.explicitToolRequests, ['shell'])
+  })
+
+  it('returns null for empty message', async () => {
+    const result = await mod.classifyMessage(
+      { sessionId: 'test-session', message: '' },
+      { generateText: async () => '{}' },
+    )
+    assert.equal(result, null)
+  })
+
+  it('returns null for whitespace-only message', async () => {
+    const result = await mod.classifyMessage(
+      { sessionId: 'test-session', message: '   ' },
+      { generateText: async () => '{}' },
+    )
+    assert.equal(result, null)
+  })
+
+  it('returns null when generateText times out', async () => {
+    const result = await mod.classifyMessage(
+      { sessionId: 'test-session', message: 'A message that will timeout for classification purposes' },
+      {
+        generateText: () => new Promise((resolve) => {
+          // Never resolves within 2s timeout
+          setTimeout(() => resolve('{}'), 10_000)
+        }),
+      },
+    )
+    assert.equal(result, null)
+  })
+
+  it('caches results for the same message', async () => {
+    let callCount = 0
+    const mockResponse = JSON.stringify({
+      isDeliverableTask: false,
+      isBroadGoal: false,
+      walletIntent: 'none',
+      hasHumanSignals: false,
+      hasSignificantEvent: false,
+      isResearchSynthesis: false,
+      explicitToolRequests: [],
+      confidence: 0.8,
+    })
+
+    const generateText = async () => {
+      callCount++
+      return mockResponse
+    }
+
+    // Use a unique message to avoid cache from other tests
+    const uniqueMsg = `cache-test-${Date.now()}-${Math.random()}`
+
+    const first = await mod.classifyMessage(
+      { sessionId: 'test-session', message: uniqueMsg },
+      { generateText },
+    )
+    const second = await mod.classifyMessage(
+      { sessionId: 'test-session', message: uniqueMsg },
+      { generateText },
+    )
+
+    assert.ok(first)
+    assert.ok(second)
+    assert.deepEqual(first, second)
+    assert.equal(callCount, 1, 'generateText should only be called once due to cache')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Helper
+// ---------------------------------------------------------------------------
+
+function makeClassification(overrides: Partial<import('@/lib/server/chat-execution/message-classifier').MessageClassification>): import('@/lib/server/chat-execution/message-classifier').MessageClassification {
+  return {
+    isDeliverableTask: false,
+    isBroadGoal: false,
+    walletIntent: 'none',
+    hasHumanSignals: false,
+    hasSignificantEvent: false,
+    isResearchSynthesis: false,
+    explicitToolRequests: [],
+    confidence: 0.9,
+    ...overrides,
+  }
+}

package/src/lib/server/chat-execution/post-stream-finalization.ts

@@ -13,7 +13,7 @@ const TAG = 'post-stream'
 import { extractSuggestions } from '@/lib/server/suggestions'
 import type { StructuredToolInterface } from '@langchain/core/tools'
 import { estimateCost, buildExtensionDefinitionCosts } from '@/lib/server/cost'
-import { appendUsage } from '@/lib/server/storage'
+import { appendUsage } from '@/lib/server/usage/usage-repository'
 import { runCapabilityHook } from '@/lib/server/native-capabilities'
 import {
   shouldForceExternalServiceSummary,