@swarmclawai/swarmclaw 0.7.2 → 0.7.4

package/src/lib/server/stream-agent-chat.ts

@@ -1,6 +1,7 @@
 import fs from 'fs'
 import { createReactAgent } from '@langchain/langgraph/prebuilt'
 import { HumanMessage, AIMessage } from '@langchain/core/messages'
+import { DEFAULT_HEARTBEAT_INTERVAL_SEC } from '@/lib/heartbeat-defaults'
 import { buildSessionTools } from './session-tools'
 import { buildChatModel } from './build-llm'
 import { loadSettings, loadAgents, loadSkills, appendUsage } from './storage'
@@ -13,6 +14,8 @@ import { buildCurrentDateTimePromptContext } from './prompt-runtime-context'
 import { expandPluginIds } from './tool-aliases'
 import type { Session, Message, UsageRecord, PluginInvocationRecord } from '@/types'
 import { extractSuggestions } from './suggestions'
+import { buildIdentityContinuityContext } from './identity-continuity'
+import { enqueueSystemEvent } from './system-events'
 
 /** Extract a breadcrumb title from notable tool completions (task/schedule/agent creation). */
 interface StreamAgentChatOpts {
@@ -42,6 +45,85 @@ function buildPluginCapabilityLines(enabledPlugins: string[], opts?: { platformA
   return lines
 }
 
+export function buildToolDisciplineLines(enabledPlugins: string[]): string[] {
+  const uniqueTools = Array.from(new Set(enabledPlugins.filter(Boolean))).sort()
+  if (uniqueTools.length === 0) return []
+
+  const lines = [
+    `Enabled tools in this session: ${uniqueTools.map((toolId) => `\`${toolId}\``).join(', ')}.`,
+    'Only call tools from this enabled list or tools explicitly returned by the runtime.',
+  ]
+
+  const directPlatformTools = uniqueTools.filter((toolId) => toolId.startsWith('manage_') && toolId !== 'manage_platform')
+  if (directPlatformTools.length > 0 && !uniqueTools.includes('manage_platform')) {
+    lines.push(`Use direct platform tools exactly as named (${directPlatformTools.map((toolId) => `\`${toolId}\``).join(', ')}). Do not substitute \`manage_platform\` unless it is explicitly enabled.`)
+  }
+
+  if (uniqueTools.includes('files')) {
+    lines.push('For `files`, include an explicit action whenever possible. Common patterns: `{"action":"list","dirPath":"."}`, `{"action":"read","filePath":"path/to/file.md"}`, and `{"action":"write","files":[{"path":"path/to/file.md","content":"..."}]}`.')
+  }
+
+  if (uniqueTools.includes('shell')) {
+    lines.push('For `shell`, use `{"action":"execute","command":"..."}` for commands and `{"action":"status","processId":"..."}` or `{"action":"log","processId":"..."}` for long-lived processes.')
+  }
+
+  if (uniqueTools.includes('web')) {
+    lines.push('For `web`, use `{"action":"search","query":"..."}` to research and `{"action":"fetch","url":"https://..."}` to read a specific page.')
+  }
+
+  if (uniqueTools.includes('browser')) {
+    lines.push('For `browser`, when the task includes a literal URL, pass that exact URL string to `{"action":"navigate","url":"..."}`. Do not invent placeholder URLs like `[Your URL]`, `Example_URL`, or `MockMailPage_URL`.')
+    lines.push('For `browser` form work, prefer `{"action":"fill_form","fields":[{"element":"#email","value":"user@example.com"},{"element":"#password","value":"..."}]}`. A shorthand `form` object keyed by input id/name also works for simple forms.')
+  }
+
+  if (uniqueTools.includes('http_request')) {
+    lines.push('For `http_request`, send exact literal URLs from the task or from prior tool results. Keep JSON request bodies as raw JSON strings.')
+  }
+
+  if (uniqueTools.includes('email')) {
+    lines.push('For `email`, send mail with `{"action":"send","to":"user@example.com","subject":"...","body":"..."}`. If delivery depends on SMTP setup, check `{"action":"status"}` before claiming success.')
+  }
+
+  if (uniqueTools.includes('ask_human')) {
+    lines.push('For `ask_human`, when a workflow needs a code, approval, or out-of-band value from a person, do not guess or keep re-submitting blank forms. Use `{"action":"request_input","question":"..."}` and, for durable pauses, `{"action":"wait_for_reply","correlationId":"..."}`.')
+  }
+
+  return lines
+}
+
+export function looksLikeOpenEndedDeliverableTask(text: string): boolean {
+  const normalized = text.toLowerCase()
+  if (!normalized.trim()) return false
+  if (/```|package\.json|tsconfig|tsx?\b|jsx?\b|pytest|vitest|npm run|src\/|components\/|api\//.test(normalized)) return false
+  if (/\b(revise|revision|iterate|iteration|draft|deliverable|deliverables|offer|brief|copy|proposal|landing|outreach|plan|strategy|report|memo|document|docs?)\b/.test(normalized)) return true
+  return isBroadGoal(text) && /(\.md\b|\.txt\b|copy|brief|proposal|plan|report|draft|document)/.test(normalized)
+}
+
+function getExplicitRequiredToolNames(userMessage: string, enabledPlugins: string[]): string[] {
+  const normalized = userMessage.toLowerCase()
+  const required: string[] = []
+
+  if (enabledPlugins.includes('ask_human')
+    && (/\bask_human\b/.test(normalized) || /ask the human/.test(normalized) || /request_input/.test(normalized))) {
+    required.push('ask_human')
+  }
+
+  if (enabledPlugins.includes('email')
+    && (/\bemail\b/.test(normalized) || /send a welcome email/.test(normalized) || /send an email/.test(normalized))) {
+    required.push('email')
+  }
+
+  return required
+}
+
+const OPEN_ENDED_REVISION_BLOCK = [
+  '## Revision Loop',
+  'For open-ended deliverable work, do a real two-pass loop before declaring success: create the draft artifacts, critique them against the objective, then modify at least one artifact based on that critique.',
+  'A critique by itself does not count as iteration. Iteration requires an actual changed artifact.',
+  'When resuming in an existing workspace, inspect the current files first, then update them. Do not assume you lost access to the workspace without an explicit tool attempt.',
+  'If `files` is available, use it with explicit actions and paths to inspect and revise the artifacts.',
+].join('\n')
+
 /** Detect whether a user message is a broad, high-level goal that benefits from decomposition. */
 function isBroadGoal(text: string): boolean {
   if (text.length < 50) return false
@@ -59,7 +141,7 @@ const GOAL_DECOMPOSITION_BLOCK = [
   'When you receive a broad, open-ended goal:',
   '1. Break it into 3-7 concrete, sequentially-executable subtasks before taking action.',
   '2. If manage_tasks is available, create a task for each subtask to track progress.',
-  '3. Output your plan in a [MAIN_LOOP_PLAN] JSON line: {"steps":["step1","step2",...],"current_step":"step1"}',
+  '3. Present the plan as a short checklist or numbered list in plain language.',
   '4. Execute the first subtask immediately — do not stop after planning.',
   '5. After each subtask, update progress and move to the next.',
 ].join('\n')
@@ -71,10 +153,10 @@ function buildAgenticExecutionPolicy(opts: {
   heartbeatIntervalSec: number
   platformAssignScope?: 'self' | 'all'
   userMessage?: string
-  hasExistingPlan?: boolean
 }) {
   const hasTooling = opts.enabledPlugins.length > 0
   const pluginLines = buildPluginCapabilityLines(opts.enabledPlugins, { platformAssignScope: opts.platformAssignScope })
+  const toolDisciplineLines = buildToolDisciplineLines(opts.enabledPlugins)
 
   const parts: string[] = []
 
@@ -85,7 +167,8 @@ function buildAgenticExecutionPolicy(opts: {
       ? 'I take initiative — plan briefly, execute tools, evaluate, iterate until done. Never stop at advice when action is implied.'
       : 'No tools enabled. Be explicit about what tool access is needed.',
     'Follow through on stated intentions with tool calls. Never claim results without tool evidence.',
-    'If a tool is named explicitly, invoke it. Short progress updates between steps.',
+    'If a task explicitly names an enabled tool, use that tool before declaring success. A prose request is not a substitute for `ask_human`, and browser work is not a substitute for `email` delivery.',
+    'When `ask_human` is enabled, collect required human input through the tool instead of asking for it only in plain assistant text.',
     opts.loopMode === 'ongoing'
       ? 'Loop: ONGOING — keep iterating until done, blocked, or limits reached.'
       : 'Loop: BOUNDED — execute multiple steps but finish within recursion budget.',
@@ -102,13 +185,22 @@ function buildAgenticExecutionPolicy(opts: {
     'Always reply to: questions, tasks, emotional sharing, or when you have something useful to add.',
     'Execute by default — only ask for confirmation on high-risk/irreversible actions. Do not end every response with a question.',
     'Never repeat completed side effects. Verify state first.',
+    'If a tool returns an error or validation failure, do not claim the task succeeded. Retry with corrected arguments or explain the blocker plainly.',
+    'Prefer the most specific tool you already have. Example: use `manage_schedules` for schedules and `manage_tasks` for tasks; treat `manage_platform` as a fallback umbrella only when a specific `manage_*` tool is unavailable.',
+    'For recurring, cron, interval, or follow-up automation requests, use `manage_schedules` directly when it is available.',
+    'Delegation is optional, not a stopping condition. If one delegate backend is unavailable or unauthenticated, try another delegate backend or continue with your other tools.',
+    'If a required tool is missing, request access by name with `manage_capabilities` action `request_access` (for example `shell` or `manage_schedules`).',
+    'Only mention files, screenshots, URLs, or download links that were actually returned by tools. Copy returned links exactly; do not rewrite them or prepend extra prefixes like "sandbox:".',
     `Heartbeat: if message is "${opts.heartbeatPrompt}", reply "HEARTBEAT_OK" unless you have a progress update.`,
     opts.heartbeatIntervalSec > 0 ? `Heartbeat cadence: ~${opts.heartbeatIntervalSec}s.` : '',
-    'For SWARM_MAIN_MISSION_TICK / SWARM_MAIN_AUTO_FOLLOWUP messages, follow the response contract and include [MAIN_LOOP_META] JSON.',
   )
 
+  if (toolDisciplineLines.length) parts.push('## Tool Discipline', ...toolDisciplineLines)
   if (pluginLines.length) parts.push('What I can do:\n' + pluginLines.join('\n'))
-  if (opts.userMessage && !opts.hasExistingPlan && isBroadGoal(opts.userMessage)) parts.push(GOAL_DECOMPOSITION_BLOCK)
+  if (opts.userMessage && isBroadGoal(opts.userMessage)) parts.push(GOAL_DECOMPOSITION_BLOCK)
+  if (opts.userMessage && looksLikeOpenEndedDeliverableTask(opts.userMessage) && opts.enabledPlugins.some((toolId) => toolId === 'files' || toolId === 'edit_file')) {
+    parts.push(OPEN_ENDED_REVISION_BLOCK)
+  }
 
   return parts.filter(Boolean).join('\n')
 }
@@ -136,7 +228,9 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
 
   // Resolve agent's thinking level for provider-native params
   let agentThinkingLevel: 'minimal' | 'low' | 'medium' | 'high' | undefined
-  if (session.agentId) {
+  if (session.thinkingLevel) {
+    agentThinkingLevel = session.thinkingLevel
+  } else if (session.agentId) {
     const agentsForThinking = loadAgents()
     agentThinkingLevel = agentsForThinking[session.agentId]?.thinkingLevel
   }
@@ -162,7 +256,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
       : typeof raw === 'string'
         ? Number.parseInt(raw, 10)
         : Number.NaN
-    if (!Number.isFinite(parsed)) return 120
+    if (!Number.isFinite(parsed)) return DEFAULT_HEARTBEAT_INTERVAL_SEC
     return Math.max(0, Math.min(3600, Math.trunc(parsed)))
   })()
 
@@ -180,18 +274,22 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
   let agentPlatformAssignScope: 'self' | 'all' = 'self'
   let agentMcpServerIds: string[] | undefined
   let agentMcpDisabledTools: string[] | undefined
+  let agentHeartbeatEnabled = false
   if (session.agentId) {
     const agents = loadAgents()
     const agent = agents[session.agentId]
     agentPlatformAssignScope = agent?.platformAssignScope || 'self'
     agentMcpServerIds = agent?.mcpServerIds
     agentMcpDisabledTools = agent?.mcpDisabledTools
+    agentHeartbeatEnabled = agent?.heartbeatEnabled === true
     if (!hasProvidedSystemPrompt) {
       // Identity block — make sure the agent knows who it is
       const identityLines = [`## My Identity`, `My name is ${agent?.name || 'Agent'}.`]
       if (agent?.description) identityLines.push(agent.description)
       identityLines.push('I should always refer to myself by this name. I am not "Assistant" — I have my own name and identity.')
       stateModifierParts.push(identityLines.join(' '))
+      const continuityBlock = buildIdentityContinuityContext(session, agent)
+      if (continuityBlock) stateModifierParts.push(continuityBlock)
       if (agent?.soul) stateModifierParts.push(agent.soul)
       if (agent?.systemPrompt) stateModifierParts.push(agent.systemPrompt)
       if (agent?.skillIds?.length) {
@@ -290,9 +388,6 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
     )
   }
 
-  // Check for existing plan in mainLoopState to skip decomposition injection
-  const hasExistingPlan = Array.isArray(session.mainLoopState?.planSteps) && session.mainLoopState.planSteps.length > 0
-
   stateModifierParts.push(
     buildAgenticExecutionPolicy({
       enabledPlugins: sessionPlugins,
@@ -301,7 +396,6 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
       heartbeatIntervalSec,
       platformAssignScope: agentPlatformAssignScope,
       userMessage: message,
-      hasExistingPlan,
     }),
   )
 
@@ -480,14 +574,13 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
   let needsTextSeparator = false
   let totalInputTokens = 0
   let totalOutputTokens = 0
-  let lastToolInput: unknown = null
   let accumulatedThinking = ''
   const pluginInvocations: PluginInvocationRecord[] = []
   let currentToolInputTokens = 0
 
   // Plugin hooks: beforeAgentStart
   const pluginMgr = getPluginManager()
-  await pluginMgr.runHook('beforeAgentStart', { session, message })
+  await pluginMgr.runHook('beforeAgentStart', { session, message }, { enabledIds: sessionPlugins })
 
   const abortController = new AbortController()
   const abortFromSignal = () => abortController.abort()
@@ -505,13 +598,21 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
 
   const MAX_AUTO_CONTINUES = 3
   const MAX_TRANSIENT_RETRIES = 2
+  const MAX_REQUIRED_TOOL_CONTINUES = 2
   let autoContinueCount = 0
   let transientRetryCount = 0
+  let requiredToolContinueCount = 0
+  const explicitRequiredToolNames = getExplicitRequiredToolNames(message, sessionPlugins)
+  const usedToolNames = new Set<string>()
 
   try {
-    const maxIterations = MAX_AUTO_CONTINUES + MAX_TRANSIENT_RETRIES
+    const maxIterations = MAX_AUTO_CONTINUES + MAX_TRANSIENT_RETRIES + MAX_REQUIRED_TOOL_CONTINUES
     for (let iteration = 0; iteration <= maxIterations; iteration++) {
-      let shouldContinue: 'recursion' | 'transient' | false = false
+      let shouldContinue: 'recursion' | 'transient' | 'required_tool' | false = false
+      let requiredToolReminderNames: string[] = []
+      let waitingForToolResult = false
+      let idleTimedOut = false
+      let idleTimer: ReturnType<typeof setTimeout> | null = null
 
       // Fresh per-iteration controller so an internal LangGraph abort doesn't poison subsequent iterations.
       // Linked to the parent so client disconnect / timeout still propagates.
@@ -520,7 +621,24 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
       if (abortController.signal.aborted) iterationController.abort()
       else abortController.signal.addEventListener('abort', onParentAbort)
 
+      const clearIdleWatchdog = () => {
+        if (idleTimer) {
+          clearTimeout(idleTimer)
+          idleTimer = null
+        }
+      }
+
+      const armIdleWatchdog = () => {
+        clearIdleWatchdog()
+        if (waitingForToolResult || iterationController.signal.aborted) return
+        idleTimer = setTimeout(() => {
+          idleTimedOut = true
+          iterationController.abort()
+        }, 90_000)
+      }
+
       try {
+        armIdleWatchdog()
         const eventStream = agent.streamEvents(
           { messages: langchainMessages },
           { version: 'v2', recursionLimit, signal: iterationController.signal },
@@ -530,6 +648,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
           const kind = event.event
 
           if (kind === 'on_chat_model_stream') {
+            armIdleWatchdog()
             const chunk = event.data?.chunk
             if (chunk?.content) {
               // content can be string or array of content blocks
@@ -569,6 +688,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
               }
             }
           } else if (kind === 'on_llm_end') {
+            armIdleWatchdog()
             // Track token usage from LLM responses — check all known LangChain event shapes
             const output = event.data?.output
             const usage = output?.llmOutput?.tokenUsage
@@ -581,17 +701,17 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
               totalOutputTokens += usage.completionTokens || usage.output_tokens || usage.completion_tokens || 0
             }
           } else if (kind === 'on_tool_start') {
+            clearIdleWatchdog()
+            waitingForToolResult = true
             hasToolCalls = true
             needsTextSeparator = true
             lastSegment = ''
             const toolName = event.name || 'unknown'
+            usedToolNames.add(toolName)
             const input = event.data?.input
-            lastToolInput = input
             // Estimate input tokens for plugin invocation tracking
             const inputStr = typeof input === 'string' ? input : JSON.stringify(input)
             currentToolInputTokens = Math.ceil((inputStr?.length || 0) / 4)
-            // Plugin hooks: beforeToolExec
-            await pluginMgr.runHook('beforeToolExec', { toolName, input })
             logExecution(session.id, 'tool_call', `${toolName} invoked`, {
               agentId: session.agentId,
               detail: { toolName, input: inputStr?.slice(0, 4000) },
@@ -602,6 +722,8 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
               toolInput: inputStr,
             })}\n\n`)
           } else if (kind === 'on_tool_end') {
+            waitingForToolResult = false
+            armIdleWatchdog()
             const toolName = event.name || 'unknown'
             const output = event.data?.output
             const outputStr = typeof output === 'string'
@@ -609,9 +731,6 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
               : output?.content
                 ? String(output.content)
                 : JSON.stringify(output)
-            // Plugin hooks: afterToolExec
-            await pluginMgr.runHook('afterToolExec', { session, toolName, input: lastToolInput as Record<string, unknown> | null, output: outputStr })
-            lastToolInput = null
             logExecution(session.id, 'tool_result', `${toolName} returned`, {
               agentId: session.agentId,
               detail: { toolName, output: outputStr?.slice(0, 4000), error: /^(Error:|error:)/i.test((outputStr || '').trim()) || undefined },
@@ -654,7 +773,9 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
         }
       } catch (innerErr: unknown) {
         const errName = innerErr instanceof Error ? innerErr.constructor.name : ''
-        const errMsg = innerErr instanceof Error ? innerErr.message : String(innerErr)
+        const errMsg = idleTimedOut
+          ? 'Model stream stalled without emitting text or tool results for 90 seconds.'
+          : innerErr instanceof Error ? innerErr.message : String(innerErr)
         const errStack = innerErr instanceof Error ? innerErr.stack?.slice(0, 500) : undefined
 
         // Classify the error:
@@ -662,9 +783,10 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
         // 2. Transient abort/timeout — LLM API failure, not from client disconnect
         const isRecursionError = errName === 'GraphRecursionError'
           || /recursion limit|maximum recursion/i.test(errMsg)
-        const isTransientAbort = !isRecursionError
+        const isTransientAbort = (!isRecursionError && idleTimedOut)
+          || (!isRecursionError
           && /abort|timed?\s*out|ECONNRESET|ECONNREFUSED|socket hang up|network/i.test(errMsg)
-          && !abortController.signal.aborted
+          && !abortController.signal.aborted)
 
         // Log diagnostic details for every error so we can trace root causes
         console.error(`[stream-agent-chat] Error in streamEvents iteration=${iteration}`, {
@@ -695,9 +817,26 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
           throw innerErr
         }
       } finally {
+        clearIdleWatchdog()
         abortController.signal.removeEventListener('abort', onParentAbort)
       }
 
+      if (!shouldContinue && explicitRequiredToolNames.length > 0 && requiredToolContinueCount < MAX_REQUIRED_TOOL_CONTINUES) {
+        requiredToolReminderNames = explicitRequiredToolNames.filter((toolName) => !usedToolNames.has(toolName))
+        if (requiredToolReminderNames.length > 0) {
+          shouldContinue = 'required_tool'
+          requiredToolContinueCount++
+          write(`data: ${JSON.stringify({
+            t: 'status',
+            text: JSON.stringify({
+              requiredToolsPending: requiredToolReminderNames,
+              reminderCount: requiredToolContinueCount,
+              maxReminders: MAX_REQUIRED_TOOL_CONTINUES,
+            }),
+          })}\n\n`)
+        }
+      }
+
       if (!shouldContinue) break
 
       if (shouldContinue === 'recursion') {
@@ -707,6 +846,14 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
         }
         langchainMessages.push(new HumanMessage({ content: 'Continue where you left off. Complete the remaining steps of the objective.' }))
         lastSegment = ''
+      } else if (shouldContinue === 'required_tool') {
+        if (fullText.trim()) {
+          langchainMessages.push(new AIMessage({ content: fullText }))
+        }
+        langchainMessages.push(new HumanMessage({
+          content: `You have not yet completed the required explicit tool step(s): ${requiredToolReminderNames.join(', ')}. Use those enabled tools now before declaring success. Do not replace ask_human with a plain-text request, and do not replace email delivery with browser work or prose.`,
+        }))
+        lastSegment = ''
       } else if (shouldContinue === 'transient') {
         // Short delay before retrying transient errors (API timeout, rate limit, etc.)
         await new Promise((r) => setTimeout(r, 2000 * transientRetryCount))
@@ -716,6 +863,19 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
     const errMsg = timedOut
       ? 'Ongoing loop stopped after reaching the configured runtime limit.'
       : err instanceof Error ? err.message : String(err)
+    const heartbeatEligible = runtime.loopMode === 'ongoing' || session.heartbeatEnabled === true || agentHeartbeatEnabled
+    const budgetLimited = timedOut || /recursion limit|maximum recursion/i.test(errMsg)
+    if (heartbeatEligible && budgetLimited) {
+      enqueueSystemEvent(
+        session.id,
+        '[Loop Budget Reached] The previous autonomous run stopped after hitting its loop budget. On the next heartbeat, resume carefully from the current state, verify completed work before repeating it, and focus only on the remaining objective.',
+        'loop_budget_reached',
+      )
+      logExecution(session.id, 'decision', 'Queued a deferred resume cue for the next heartbeat after loop budget exhaustion.', {
+        agentId: session.agentId,
+        detail: { timedOut, heartbeatEligible },
+      })
+    }
     logExecution(session.id, 'error', errMsg, { agentId: session.agentId, detail: { timedOut } })
     write(`data: ${JSON.stringify({ t: 'err', text: errMsg })}\n\n`)
   } finally {
@@ -775,7 +935,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
   }
 
   // Plugin hooks: afterAgentComplete
-  await pluginMgr.runHook('afterAgentComplete', { session, response: fullText })
+  await pluginMgr.runHook('afterAgentComplete', { session, response: fullText }, { enabledIds: sessionPlugins })
 
   // OpenClaw auto-sync: push memory if enabled
   try {

package/src/lib/server/structured-extract.test.ts

@@ -0,0 +1,72 @@
+import assert from 'node:assert/strict'
+import { afterEach, describe, it } from 'node:test'
+import { PROVIDERS } from '../providers'
+import { runStructuredExtraction } from './structured-extract'
+
+const originalOllamaHandler = PROVIDERS.ollama.handler.streamChat
+
+afterEach(() => {
+  PROVIDERS.ollama.handler.streamChat = originalOllamaHandler
+})
+
+describe('runStructuredExtraction', () => {
+  it('parses fenced JSON output from the current provider', async () => {
+    PROVIDERS.ollama.handler.streamChat = async () => '```json\n{"name":"Ada","score":10}\n```'
+
+    const result = await runStructuredExtraction({
+      session: {
+        id: 'session-1',
+        provider: 'ollama',
+        model: 'qwen3.5',
+        credentialId: null,
+        fallbackCredentialIds: [],
+        apiEndpoint: 'http://localhost:11434',
+      },
+      text: 'Ada scored 10.',
+      schema: {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+          score: { type: 'number' },
+        },
+        required: ['name', 'score'],
+      },
+      instruction: 'Extract the person and score.',
+    })
+
+    assert.deepEqual(result.object, { name: 'Ada', score: 10 })
+    assert.deepEqual(result.validationErrors, [])
+  })
+
+  it('repairs invalid JSON with a second pass', async () => {
+    let callCount = 0
+    PROVIDERS.ollama.handler.streamChat = async () => {
+      callCount += 1
+      return callCount === 1 ? 'name: Ada' : '{"name":"Ada"}'
+    }
+
+    const result = await runStructuredExtraction({
+      session: {
+        id: 'session-2',
+        provider: 'ollama',
+        model: 'qwen3.5',
+        credentialId: null,
+        fallbackCredentialIds: [],
+        apiEndpoint: 'http://localhost:11434',
+      },
+      text: 'Ada',
+      schema: {
+        type: 'object',
+        properties: {
+          name: { type: 'string' },
+        },
+        required: ['name'],
+      },
+      instruction: 'Extract the name.',
+    })
+
+    assert.equal(callCount, 2)
+    assert.deepEqual(result.object, { name: 'Ada' })
+    assert.deepEqual(result.validationErrors, [])
+  })
+})