@swarmclawai/swarmclaw 1.5.53 → 1.5.55

package/src/lib/server/chat-execution/chat-turn-preparation.test.ts

@@ -0,0 +1,253 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+import type { Agent, Session } from '@/types'
+import type { ResolvedAgentRoute } from '@/lib/server/agents/agent-runtime-config'
+import { applyAgentSyncToSession } from './chat-turn-preparation'
+
+const SESSION_ID = 'sess_test_1'
+const AGENT_ID = 'agent_test_1'
+
+function makeAgent(overrides: Partial<Agent> = {}): Agent {
+  return {
+    id: AGENT_ID,
+    name: 'Test Agent',
+    description: '',
+    systemPrompt: '',
+    provider: 'openai',
+    model: 'gpt-4o',
+    credentialId: 'cred_openai',
+    apiEndpoint: null,
+    ...overrides,
+  } as Agent
+}
+
+function makeSession(overrides: Partial<Session> = {}): Session {
+  return {
+    id: SESSION_ID,
+    name: 'Chat',
+    cwd: '/tmp',
+    user: 'test',
+    provider: 'openai',
+    model: 'gpt-4o',
+    claudeSessionId: null,
+    messages: [],
+    createdAt: 0,
+    lastActiveAt: 0,
+    agentId: AGENT_ID,
+    ...overrides,
+  } as Session
+}
+
+function makeRoute(overrides: Partial<ResolvedAgentRoute> = {}): ResolvedAgentRoute {
+  return {
+    id: 'route_1',
+    label: 'primary',
+    provider: 'openai',
+    model: 'gpt-4o',
+    credentialId: 'cred_openai',
+    fallbackCredentialIds: [],
+    apiEndpoint: null,
+    gatewayProfileId: null,
+    priority: 1,
+    source: 'agent',
+    ...overrides,
+  }
+}
+
+describe('applyAgentSyncToSession — user-selected provider/model preservation', () => {
+  it('session with matching provider/model inherits credentials from route (baseline)', () => {
+    const session = makeSession({ provider: 'openai', model: 'gpt-4o', credentialId: null })
+    const agent = makeAgent()
+    const route = makeRoute({ credentialId: 'cred_openai' })
+
+    const { session: updated, changed } = applyAgentSyncToSession(session, agent, route, SESSION_ID)
+
+    assert.equal(changed, true)
+    assert.equal(updated.provider, 'openai', 'provider unchanged')
+    assert.equal(updated.model, 'gpt-4o', 'model unchanged')
+    assert.equal(updated.credentialId, 'cred_openai', 'credential synced from route')
+  })
+
+  it('user-switched provider is preserved even when agent/route disagree', () => {
+    const session = makeSession({
+      provider: 'anthropic',
+      model: 'claude-opus-4-7',
+      credentialId: 'cred_anthropic',
+      apiEndpoint: 'https://api.anthropic.com',
+    })
+    const agent = makeAgent({ provider: 'openai', model: 'gpt-4o' })
+    const route = makeRoute({ provider: 'openai', model: 'gpt-4o', credentialId: 'cred_openai' })
+
+    const { session: updated } = applyAgentSyncToSession(session, agent, route, SESSION_ID)
+
+    assert.equal(updated.provider, 'anthropic', 'user-switched provider preserved')
+    assert.equal(updated.model, 'claude-opus-4-7', 'user-switched model preserved')
+  })
+
+  it('user-switched provider keeps its credentials (does not rewrite from route)', () => {
+    const session = makeSession({
+      provider: 'anthropic',
+      model: 'claude-opus-4-7',
+      credentialId: 'cred_anthropic',
+      fallbackCredentialIds: ['cred_anthropic_backup'],
+      apiEndpoint: 'https://api.anthropic.com/v1',
+    })
+    const agent = makeAgent({ provider: 'openai', credentialId: 'cred_openai' })
+    const route = makeRoute({
+      provider: 'openai',
+      credentialId: 'cred_openai',
+      fallbackCredentialIds: ['cred_openai_backup'],
+      apiEndpoint: 'https://api.openai.com/v1',
+    })
+
+    const { session: updated } = applyAgentSyncToSession(session, agent, route, SESSION_ID)
+
+    assert.equal(updated.credentialId, 'cred_anthropic', 'credentialId not rewritten')
+    assert.deepEqual(
+      updated.fallbackCredentialIds,
+      ['cred_anthropic_backup'],
+      'fallbackCredentialIds not rewritten',
+    )
+    assert.equal(
+      updated.apiEndpoint,
+      'https://api.anthropic.com/v1',
+      'apiEndpoint not rewritten',
+    )
+  })
+
+  it('user-switched model (same provider) keeps its credentials and model', () => {
+    const session = makeSession({
+      provider: 'openai',
+      model: 'gpt-4o-mini',
+      credentialId: 'cred_openai_user',
+    })
+    const agent = makeAgent({ provider: 'openai', model: 'gpt-4o', credentialId: 'cred_openai' })
+    const route = makeRoute({
+      provider: 'openai',
+      model: 'gpt-4o',
+      credentialId: 'cred_openai',
+    })
+
+    const { session: updated } = applyAgentSyncToSession(session, agent, route, SESSION_ID)
+
+    assert.equal(updated.model, 'gpt-4o-mini', 'user-switched model preserved')
+    assert.equal(
+      updated.credentialId,
+      'cred_openai',
+      'same-provider credential does sync from route',
+    )
+  })
+
+  it('empty session.provider inherits from agent', () => {
+    const session = makeSession({
+      provider: '' as Session['provider'],
+      model: '',
+      credentialId: null,
+    })
+    const agent = makeAgent({ provider: 'openai', model: 'gpt-4o' })
+
+    const { session: updated, changed } = applyAgentSyncToSession(session, agent, null, SESSION_ID)
+
+    assert.equal(changed, true)
+    assert.equal(updated.provider, 'openai', 'provider initialized from agent')
+    assert.equal(updated.model, 'gpt-4o', 'model initialized from agent')
+  })
+
+  it('gatewayProfileId syncs from route regardless of provider switch', () => {
+    const session = makeSession({
+      provider: 'anthropic',
+      model: 'claude-opus-4-7',
+      gatewayProfileId: null,
+    })
+    const agent = makeAgent({ provider: 'openai' })
+    const route = makeRoute({ provider: 'openai', gatewayProfileId: 'gw_profile_1' })
+
+    const { session: updated } = applyAgentSyncToSession(session, agent, route, SESSION_ID)
+
+    assert.equal(
+      updated.gatewayProfileId,
+      'gw_profile_1',
+      'gatewayProfileId syncs from route even across provider switch',
+    )
+  })
+
+  it('no route: session inherits credentialId and apiEndpoint from agent when unset', () => {
+    const session = makeSession({
+      provider: 'openai',
+      model: 'gpt-4o',
+      credentialId: undefined,
+      apiEndpoint: undefined,
+    })
+    const agent = makeAgent({
+      provider: 'openai',
+      credentialId: 'cred_agent',
+      apiEndpoint: 'https://custom.openai.example/v1',
+    })
+
+    const { session: updated } = applyAgentSyncToSession(session, agent, null, SESSION_ID)
+
+    assert.equal(updated.credentialId, 'cred_agent', 'credentialId filled from agent')
+    assert.equal(
+      updated.apiEndpoint,
+      'https://custom.openai.example/v1',
+      'apiEndpoint filled from agent',
+    )
+  })
+
+  it('tool/extension selection syncs from agent when session has no parent', () => {
+    const session = makeSession({
+      parentSessionId: null,
+      tools: ['old_tool'],
+      extensions: ['old_ext'],
+    })
+    const agent = makeAgent({
+      tools: ['new_tool_a', 'new_tool_b'],
+      extensions: ['new_ext'],
+    })
+
+    const { session: updated, changed } = applyAgentSyncToSession(session, agent, null, SESSION_ID)
+
+    assert.equal(changed, true)
+    assert.deepEqual(updated.tools, ['new_tool_a', 'new_tool_b'])
+    assert.deepEqual(updated.extensions, ['new_ext'])
+  })
+
+  it('tool/extension selection does NOT sync on child (delegated) sessions', () => {
+    const session = makeSession({
+      parentSessionId: 'parent_session',
+      tools: ['child_tool'],
+      extensions: ['child_ext'],
+    })
+    const agent = makeAgent({
+      tools: ['agent_tool'],
+      extensions: ['agent_ext'],
+    })
+
+    const { session: updated } = applyAgentSyncToSession(session, agent, null, SESSION_ID)
+
+    assert.deepEqual(updated.tools, ['child_tool'], 'child session tools preserved')
+    assert.deepEqual(updated.extensions, ['child_ext'], 'child session extensions preserved')
+  })
+
+  it('idempotent: repeated sync with same inputs yields changed=false', () => {
+    const session = makeSession({
+      provider: 'openai',
+      model: 'gpt-4o',
+      credentialId: 'cred_openai',
+      fallbackCredentialIds: [],
+      apiEndpoint: null,
+      gatewayProfileId: null,
+      tools: [],
+      extensions: [],
+      parentSessionId: null,
+      memoryScopeMode: null,
+    })
+    const agent = makeAgent({ tools: [], extensions: [] })
+    const route = makeRoute()
+
+    applyAgentSyncToSession(session, agent, route, SESSION_ID)
+    const { changed } = applyAgentSyncToSession(session, agent, route, SESSION_ID)
+
+    assert.equal(changed, false, 'second sync makes no changes')
+  })
+})

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

@@ -3,7 +3,7 @@ import os from 'os'
 
 import { log } from '@/lib/server/logger'
 import { getProvider } from '@/lib/providers'
-import type { ExecutionBrief, Message, Session } from '@/types'
+import type { Agent, ExecutionBrief, Message, Session } from '@/types'
 import {
   decryptKey,
   loadCredentials,
@@ -29,6 +29,7 @@ import {
 import {
   applyResolvedRoute,
   resolvePrimaryAgentRoute,
+  type ResolvedAgentRoute,
 } from '@/lib/server/agents/agent-runtime-config'
 import {
   runCapabilityBeforeMessageWrite,
@@ -190,17 +191,13 @@ function joinSystemPromptBlocks(...blocks: Array<string | null | undefined>): st
   return joined || undefined
 }
 
-function syncSessionFromAgent(sessionId: string): void {
-  const session = getSession(sessionId)
-  if (!session?.agentId) return
-  const agent = getAgent(session.agentId)
-  if (!agent) return
-
+export function applyAgentSyncToSession(
+  session: Session,
+  agent: Agent,
+  route: ResolvedAgentRoute | null,
+  sessionId: string,
+): { session: Session; changed: boolean } {
   let changed = false
-  const route = resolvePrimaryAgentRoute(agent, undefined, {
-    preferredGatewayTags: session.routePreferredGatewayTags || [],
-    preferredGatewayUseCase: session.routePreferredGatewayUseCase || null,
-  })
   if (!session.provider && agent.provider) { session.provider = agent.provider; changed = true }
   if ((session.model === undefined || session.model === null || session.model === '') && agent.model !== undefined) {
     session.model = agent.model
@@ -208,19 +205,24 @@ function syncSessionFromAgent(sessionId: string): void {
   }
   if (route) {
     const resolved = applyResolvedRoute({ ...session }, route)
-    if (session.provider !== resolved.provider) { session.provider = resolved.provider; changed = true }
-    if (session.model !== resolved.model) { session.model = resolved.model; changed = true }
-    if ((session.credentialId || null) !== (resolved.credentialId || null)) {
-      session.credentialId = resolved.credentialId ?? null
-      changed = true
-    }
-    if (JSON.stringify(session.fallbackCredentialIds || []) !== JSON.stringify(resolved.fallbackCredentialIds || [])) {
-      session.fallbackCredentialIds = [...(resolved.fallbackCredentialIds || [])]
-      changed = true
-    }
-    if ((session.apiEndpoint || null) !== (resolved.apiEndpoint || null)) {
-      session.apiEndpoint = resolved.apiEndpoint ?? null
-      changed = true
+    // Do NOT sync provider/model from the route here — the user may have manually
+    // switched the session model, and we must preserve that choice.
+    // Provider/model are initialized from the route at session-creation time only.
+    // Only sync credentials/endpoint when the session's provider still matches the
+    // route's provider — if the user switched providers, leave their credential alone.
+    if (session.provider === resolved.provider) {
+      if ((session.credentialId || null) !== (resolved.credentialId || null)) {
+        session.credentialId = resolved.credentialId ?? null
+        changed = true
+      }
+      if (JSON.stringify(session.fallbackCredentialIds || []) !== JSON.stringify(resolved.fallbackCredentialIds || [])) {
+        session.fallbackCredentialIds = [...(resolved.fallbackCredentialIds || [])]
+        changed = true
+      }
+      if ((session.apiEndpoint || null) !== (resolved.apiEndpoint || null)) {
+        session.apiEndpoint = resolved.apiEndpoint ?? null
+        changed = true
+      }
     }
     if ((session.gatewayProfileId || null) !== (resolved.gatewayProfileId || null)) {
       session.gatewayProfileId = resolved.gatewayProfileId ?? null
@@ -297,9 +299,21 @@ function syncSessionFromAgent(sessionId: string): void {
       changed = true
     }
   }
+  return { session, changed }
+}
 
+export function syncSessionFromAgent(sessionId: string): void {
+  const session = getSession(sessionId)
+  if (!session?.agentId) return
+  const agent = getAgent(session.agentId)
+  if (!agent) return
+  const route = resolvePrimaryAgentRoute(agent, undefined, {
+    preferredGatewayTags: session.routePreferredGatewayTags || [],
+    preferredGatewayUseCase: session.routePreferredGatewayUseCase || null,
+  })
+  const { session: updated, changed } = applyAgentSyncToSession(session, agent, route, sessionId)
   if (changed) {
-    saveSession(sessionId, session)
+    saveSession(sessionId, updated)
   }
 }
 
@@ -624,9 +638,15 @@ export async function prepareChatTurn(input: ExecuteChatTurnInput): Promise<Prep
       preferredGatewayTags: session.routePreferredGatewayTags || [],
       preferredGatewayUseCase: session.routePreferredGatewayUseCase || null,
     })
-    if (preferredRoute) {
+    if (preferredRoute && sessionForRun.provider === preferredRoute.provider) {
+      // Apply route for credentials/endpoint/gateway, but preserve the user's
+      // manually-selected model — only sync infra, not the model choice.
+      const savedModel = sessionForRun.model
       sessionForRun = applyResolvedRoute({ ...sessionForRun }, preferredRoute)
+      sessionForRun = { ...sessionForRun, model: savedModel }
     }
+    // If the user has manually switched to a different provider, skip the route
+    // entirely — the session already has the correct provider/model/credential.
   }
   let effectiveMessage = message
 

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

@@ -218,13 +218,17 @@ export interface ClassifyMessageInput {
   history?: Message[]
 }
 
-// Timeout sized for Ollama Cloud with a fully-configured agent: observed
-// classifier calls in the 4-6 s range during live testing, plus the expanded
-// 4-flag semantic schema requires a slightly larger JSON output. 10 s
-// accommodates the tail without blocking chat turns for long on a total
-// failure. Result is cached per-message so the latency tax only applies to
-// first-seen messages.
-const CLASSIFIER_TIMEOUT_MS = 10_000
+// Timeout sized for Ollama Cloud with a fully-configured agent. Observed
+// classifier calls in the 4-6s range during live testing, with cloud
+// providers (Ollama Cloud, OpenRouter) routinely tipping over the 10s
+// boundary on a cold cache. SC_CLASSIFIER_TIMEOUT_MS overrides for users
+// running consistently slow providers; default raised to 20s so the cloud
+// path actually completes.
+const DEFAULT_CLASSIFIER_TIMEOUT_MS = 20_000
+const CLASSIFIER_TIMEOUT_MS = (() => {
+  const raw = Number(process.env.SC_CLASSIFIER_TIMEOUT_MS)
+  return Number.isFinite(raw) && raw > 0 ? Math.trunc(raw) : DEFAULT_CLASSIFIER_TIMEOUT_MS
+})()
 
 /**
  * Classify a user message using a single LLM call.

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

@@ -0,0 +1,85 @@
+import assert from 'node:assert/strict'
+import { describe, it } from 'node:test'
+
+import { stripLeakedClassificationJson } from './post-stream-finalization'
+
+// A fully-valid MessageClassification serialized by the model. Mirrors the
+// real output we observed during a live delegation turn.
+const VALID_LEAK = JSON.stringify({
+  taskIntent: 'research',
+  isDeliverableTask: false,
+  isBroadGoal: false,
+  isLightweightDirectChat: true,
+  hasHumanSignals: false,
+  hasSignificantEvent: false,
+  isResearchSynthesis: false,
+  workType: 'general',
+  explicitToolRequests: [],
+  confidence: 0.95,
+})
+
+describe('stripLeakedClassificationJson', () => {
+  it('strips a leaked classification JSON that starts with taskIntent', () => {
+    const input = `${VALID_LEAK}Task created and delegated.`
+    const { cleaned, stripped } = stripLeakedClassificationJson(input)
+    assert.equal(stripped, true)
+    assert.equal(cleaned, 'Task created and delegated.')
+  })
+
+  it('strips when the leak appears mid-response', () => {
+    const input = `Here you go: ${VALID_LEAK} continuing.`
+    const { cleaned, stripped } = stripLeakedClassificationJson(input)
+    assert.equal(stripped, true)
+    assert.equal(cleaned.includes('taskIntent'), false)
+  })
+
+  it('leaves normal assistant text untouched', () => {
+    const input = 'Your favorite color is blue.'
+    const { cleaned, stripped } = stripLeakedClassificationJson(input)
+    assert.equal(stripped, false)
+    assert.equal(cleaned, input)
+  })
+
+  it('leaves a partial or unrelated JSON object alone', () => {
+    // A bare object with one classifier-adjacent key but not the full shape
+    // must NOT be stripped — the zod schema rejects it.
+    const input = 'Prefix text. {"workType": "coding"} suffix.'
+    const { cleaned, stripped } = stripLeakedClassificationJson(input)
+    assert.equal(stripped, false)
+    assert.equal(cleaned, input)
+  })
+
+  it('ignores malformed JSON that looks like a classifier leak', () => {
+    const input = 'Malformed {"taskIntent": "research", "isDeliverableTask": [oops suffix.'
+    const { cleaned, stripped } = stripLeakedClassificationJson(input)
+    assert.equal(stripped, false)
+    assert.equal(cleaned, input)
+  })
+
+  it('does not confuse braces inside strings', () => {
+    const input = `Before {"label": "{not json}", ${VALID_LEAK.slice(1)} after`
+    const { cleaned, stripped } = stripLeakedClassificationJson(input)
+    assert.equal(stripped, true)
+    assert.equal(cleaned.includes('taskIntent'), false)
+  })
+
+  it('rejects a classifier-like object with an invalid enum value', () => {
+    // taskIntent must be one of the TaskIntent enum values. Garbage value is
+    // rejected by safeParse so no stripping happens.
+    const invalid = JSON.stringify({
+      taskIntent: 'totally-made-up-intent',
+      isDeliverableTask: false,
+      isBroadGoal: false,
+      hasHumanSignals: false,
+      hasSignificantEvent: false,
+      isResearchSynthesis: false,
+      workType: 'general',
+      explicitToolRequests: [],
+      confidence: 0.5,
+    })
+    const input = `${invalid} not a real leak`
+    const { cleaned, stripped } = stripLeakedClassificationJson(input)
+    assert.equal(stripped, false)
+    assert.equal(cleaned, input)
+  })
+})

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

@@ -18,32 +18,57 @@ import { runCapabilityHook } from '@/lib/server/native-capabilities'
 import {
   shouldForceExternalServiceSummary,
 } from '@/lib/server/chat-execution/chat-streaming-utils'
-import type { MessageClassification } from '@/lib/server/chat-execution/message-classifier'
+import {
+  MessageClassificationSchema,
+  type MessageClassification,
+} from '@/lib/server/chat-execution/message-classifier'
 import {
   resolveFinalStreamResponseText,
 } from '@/lib/server/chat-execution/stream-continuation'
 import { buildForcedExternalServiceSummary } from '@/lib/server/chat-execution/prompt-builder'
 
 // ---------------------------------------------------------------------------
-// Classification JSON leak detection — strips `{ "isDeliverableTask": ... }`
-// objects that some models echo verbatim into their response text.
+// Classification JSON leak detection — strips MessageClassification objects
+// that some models echo verbatim into their response text. Candidate JSON
+// substrings are found by brace-matching, then validated against the actual
+// MessageClassificationSchema — the single source of truth for what a
+// classifier object looks like.
 // ---------------------------------------------------------------------------
 
-const CLASSIFICATION_LEAK_RE = /\{\s*"isDeliverableTask"\s*:/
-
-function stripLeakedClassificationJson(text: string): { cleaned: string; stripped: boolean } {
-  const match = CLASSIFICATION_LEAK_RE.exec(text)
-  if (!match || match.index === undefined) return { cleaned: text, stripped: false }
-  const startIdx = match.index
+/** Returns the index just past the balanced `}` for the `{` at `start`, or -1. */
+function findBalancedObjectEnd(text: string, start: number): number {
   let depth = 0
-  let end = -1
-  for (let i = startIdx; i < text.length; i++) {
-    if (text[i] === '{') depth++
-    else if (text[i] === '}') { depth--; if (depth === 0) { end = i + 1; break } }
+  let inString = false
+  let escape = false
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i]
+    if (escape) { escape = false; continue }
+    if (inString) {
+      if (ch === '\\') escape = true
+      else if (ch === '"') inString = false
+      continue
+    }
+    if (ch === '"') inString = true
+    else if (ch === '{') depth += 1
+    else if (ch === '}') {
+      depth -= 1
+      if (depth === 0) return i + 1
+    }
+  }
+  return -1
+}
+
+export function stripLeakedClassificationJson(text: string): { cleaned: string; stripped: boolean } {
+  for (let i = text.indexOf('{'); i !== -1; i = text.indexOf('{', i + 1)) {
+    const end = findBalancedObjectEnd(text, i)
+    if (end === -1) break
+    let parsed: unknown
+    try { parsed = JSON.parse(text.slice(i, end)) } catch { continue }
+    if (!MessageClassificationSchema.safeParse(parsed).success) continue
+    log.warn(TAG, 'Stripped leaked classification JSON from model output')
+    return { cleaned: (text.slice(0, i) + text.slice(end)).trimStart(), stripped: true }
   }
-  if (end === -1) return { cleaned: text, stripped: false }
-  log.warn(TAG, 'Stripped leaked classification JSON from model output')
-  return { cleaned: (text.slice(0, startIdx) + text.slice(end)).trimStart(), stripped: true }
+  return { cleaned: text, stripped: false }
 }
 
 // StreamAgentChatResult is defined inline to avoid circular dependency with stream-agent-chat.ts

package/src/lib/server/chat-execution/response-completeness.test.ts

@@ -78,7 +78,8 @@ describe('response-completeness', () => {
           toolCallCount: 0,
         },
         {
-          generateText: () => new Promise((resolve) => setTimeout(() => resolve('{"isIncomplete": true, "confidence": 0.9}'), 5000)),
+          timeoutMs: 50,
+          generateText: () => new Promise((resolve) => setTimeout(() => resolve('{"isIncomplete": true, "confidence": 0.9}'), 500)),
         },
       )
       assert.equal(result, null)

package/src/lib/server/chat-execution/response-completeness.ts

@@ -153,7 +153,11 @@ export interface EvaluateCompletenessInput {
   toolCallCount: number
 }
 
-const COMPLETENESS_TIMEOUT_MS = 2_000
+const DEFAULT_COMPLETENESS_TIMEOUT_MS = 8_000
+const COMPLETENESS_TIMEOUT_MS = (() => {
+  const raw = Number(process.env.SC_COMPLETENESS_TIMEOUT_MS)
+  return Number.isFinite(raw) && raw > 0 ? Math.trunc(raw) : DEFAULT_COMPLETENESS_TIMEOUT_MS
+})()
 
 /**
  * Evaluate whether an agent response is incomplete — i.e. the agent described
@@ -164,7 +168,7 @@ const COMPLETENESS_TIMEOUT_MS = 2_000
  */
 export async function evaluateResponseCompleteness(
   input: EvaluateCompletenessInput,
-  options?: { generateText?: (prompt: string) => Promise<string> },
+  options?: { generateText?: (prompt: string) => Promise<string>; timeoutMs?: number },
 ): Promise<ResponseCompleteness | null> {
   const response = input.response.trim()
   if (!response) return null
@@ -175,6 +179,10 @@ export async function evaluateResponseCompleteness(
 
   const prompt = buildCompletenessPrompt(input.message, response, input.toolCallCount)
 
+  const timeoutMs = typeof options?.timeoutMs === 'number' && options.timeoutMs > 0
+    ? options.timeoutMs
+    : COMPLETENESS_TIMEOUT_MS
+
   const startMs = Date.now()
   try {
     const responseText = await Promise.race([
@@ -189,7 +197,7 @@ export async function evaluateResponseCompleteness(
             return extractModelText(result.content)
           })(),
       new Promise<never>((_, reject) =>
-        setTimeout(() => reject(new Error('completeness-timeout')), COMPLETENESS_TIMEOUT_MS),
+        setTimeout(() => reject(new Error('completeness-timeout')), timeoutMs),
       ),
     ])
 

package/src/lib/server/chatrooms/chatroom-agent-signals.test.ts

@@ -0,0 +1,54 @@
+import assert from 'node:assert/strict'
+import { test } from 'node:test'
+import { stripAgentReactionTokens } from '@/lib/server/chatrooms/chatroom-agent-signals'
+
+test('stripAgentReactionTokens removes single REACTION marker glued to text', () => {
+  const input = '11 plus 7 equals 18.\n[REACTION]{"emoji": "✅", "to": "c93bb040"}'
+  const out = stripAgentReactionTokens(input)
+  assert.equal(out, '11 plus 7 equals 18.')
+})
+
+test('stripAgentReactionTokens removes multiple REACTION markers', () => {
+  const input = 'Sure thing.[REACTION]{"emoji":"👍","to":"a1"} Got it.[REACTION]{"emoji":"🎉","to":"b2"}'
+  const out = stripAgentReactionTokens(input)
+  assert.ok(!out.includes('[REACTION]'))
+  assert.ok(out.includes('Sure thing.'))
+  assert.ok(out.includes('Got it.'))
+})
+
+test('stripAgentReactionTokens preserves text without markers', () => {
+  const input = 'Just a normal message with no markers.'
+  const out = stripAgentReactionTokens(input)
+  assert.equal(out, input)
+})
+
+test('stripAgentReactionTokens handles empty string', () => {
+  assert.equal(stripAgentReactionTokens(''), '')
+})
+
+test('stripAgentReactionTokens collapses excess whitespace from removed lines', () => {
+  const input = 'Line 1\n\n\n[REACTION]{"emoji":"✅","to":"x"}\n\n\nLine 2'
+  const out = stripAgentReactionTokens(input)
+  assert.ok(!out.includes('[REACTION]'))
+  assert.ok(out.includes('Line 1'))
+  assert.ok(out.includes('Line 2'))
+  assert.ok(!out.match(/\n{3,}/), 'no triple newlines')
+})
+
+test('stripAgentReactionTokens leaves [REACTION] intact when JSON is invalid (incomplete payload)', () => {
+  const input = 'Sure.[REACTION]{"emoji":"👍"} Done.'
+  const out = stripAgentReactionTokens(input)
+  assert.ok(out.includes('[REACTION]'), 'invalid reaction (missing "to") preserved verbatim')
+})
+
+test('stripAgentReactionTokens leaves [REACTION] intact when followed by non-JSON', () => {
+  const input = 'Notes: [REACTION] is a label, not a marker.'
+  const out = stripAgentReactionTokens(input)
+  assert.equal(out, input)
+})
+
+test('stripAgentReactionTokens handles nested JSON without truncation', () => {
+  const input = 'Tags applied.[REACTION]{"emoji":"🏷️","to":"abc","meta":{"reason":"label"}}'
+  const out = stripAgentReactionTokens(input)
+  assert.equal(out, 'Tags applied.')
+})