@swarmclawai/swarmclaw 0.7.2 → 0.7.3

package/src/lib/server/storage.ts

@@ -156,8 +156,13 @@ const COLLECTIONS = [
   'souls',
   'benchmarks',
   'approvals',
+  'browser_sessions',
+  'watch_jobs',
+  'delegation_jobs',
 ] as const
 
+export type StorageCollection = (typeof COLLECTIONS)[number]
+
 for (const table of COLLECTIONS) {
   db.exec(`CREATE TABLE IF NOT EXISTS ${table} (id TEXT PRIMARY KEY, data TEXT NOT NULL)`)
 }
@@ -185,12 +190,34 @@ function getCollectionRawCache(table: string): LRUMap<string, string> {
   return loaded
 }
 
+function normalizeStoredRecord(table: string, value: any): any {
+  if (table !== 'sessions') return value
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return value
+
+  const session = value as Record<string, any>
+  if (session.sessionType !== 'human') session.sessionType = 'human'
+  const isLegacyShortcut = (
+    (typeof session.id === 'string' && session.id.startsWith('agent-thread-'))
+    || (typeof session.name === 'string' && session.name.startsWith('agent-thread:'))
+  )
+  if (
+    isLegacyShortcut
+    && typeof session.agentId === 'string'
+    && session.agentId.trim()
+    && (!session.shortcutForAgentId || session.shortcutForAgentId !== session.agentId)
+  ) {
+    session.shortcutForAgentId = session.agentId
+  }
+  if ('mainLoopState' in session) delete session.mainLoopState
+  return session
+}
+
 function loadCollection(table: string): Record<string, any> {
   const raw = getCollectionRawCache(table)
   const result: Record<string, any> = {}
   for (const [id, data] of raw.entries()) {
     try {
-      result[id] = JSON.parse(data)
+      result[id] = normalizeStoredRecord(table, JSON.parse(data))
     } catch {
       // Ignore malformed records instead of crashing list endpoints.
     }
@@ -205,7 +232,8 @@ function saveCollection(table: string, data: Record<string, any>) {
   const toDelete: string[] = []
 
   for (const [id, val] of Object.entries(data)) {
-    const serialized = JSON.stringify(val)
+    const normalized = normalizeStoredRecord(table, val)
+    const serialized = JSON.stringify(normalized)
     if (typeof serialized !== 'string') continue
     next.set(id, serialized)
     if (current.get(id) !== serialized) {
@@ -251,7 +279,7 @@ function deleteCollectionItem(table: string, id: string) {
  * concurrent processes are modifying different items.
  */
 function upsertCollectionItem(table: string, id: string, value: any) {
-  const serialized = JSON.stringify(value)
+  const serialized = JSON.stringify(normalizeStoredRecord(table, value))
   db.prepare(`INSERT OR REPLACE INTO ${table} (id, data) VALUES (?, ?)`).run(id, serialized)
   // Update the in-memory cache
   const cached = collectionCache.get(table)
@@ -260,6 +288,51 @@ function upsertCollectionItem(table: string, id: string, value: any) {
   }
 }
 
+function loadCollectionItem(table: string, id: string): any | null {
+  const row = db.prepare(`SELECT data FROM ${table} WHERE id = ?`).get(id) as { data: string } | undefined
+  if (!row) return null
+  try {
+    return normalizeStoredRecord(table, JSON.parse(row.data))
+  } catch {
+    return null
+  }
+}
+
+function upsertCollectionItems(table: string, entries: Array<[string, any]>): void {
+  if (!entries.length) return
+  const prepared = entries
+    .map(([id, value]) => [id, JSON.stringify(normalizeStoredRecord(table, value))] as const)
+    .filter(([, serialized]) => typeof serialized === 'string')
+  if (!prepared.length) return
+
+  const transaction = db.transaction(() => {
+    const upsert = db.prepare(`INSERT OR REPLACE INTO ${table} (id, data) VALUES (?, ?)`)
+    for (const [id, serialized] of prepared) {
+      upsert.run(id, serialized)
+    }
+  })
+  transaction()
+
+  const cached = collectionCache.get(table)
+  if (cached) {
+    for (const [id, serialized] of prepared) {
+      cached.set(id, serialized)
+    }
+  }
+}
+
+export function loadStoredItem(table: StorageCollection, id: string): any | null {
+  return loadCollectionItem(table, id)
+}
+
+export function upsertStoredItem(table: StorageCollection, id: string, value: any): void {
+  upsertCollectionItem(table, id, value)
+}
+
+export function upsertStoredItems(table: StorageCollection, entries: Array<[string, any]>): void {
+  upsertCollectionItems(table, entries)
+}
+
 function loadSingleton(table: string, fallback: any): any {
   const row = db.prepare(`SELECT data FROM ${table} WHERE id = 1`).get() as { data: string } | undefined
   return row ? JSON.parse(row.data) : fallback
@@ -392,7 +465,7 @@ if (!IS_BUILD_BOOTSTRAP) {
 
 ## Platform
 
-- **Agents** — Create specialized AI agents (Agents tab → "+") with a provider, model, system prompt, and tools. "Generate with AI" scaffolds agents from a description. Toggle "Orchestrator" to let an agent delegate work to others.
+- **Agents** — Create specialized AI agents (Agents tab → "+") with a provider, model, system prompt, and tools. "Generate with AI" scaffolds agents from a description. Enable cross-agent delegation when an agent should assign work to others.
 - **Providers** — Configure LLM backends in Settings → Providers: Claude Code CLI, OpenAI Codex CLI, OpenCode CLI, Anthropic, OpenAI, Google Gemini, DeepSeek, Groq, Together AI, Mistral AI, xAI (Grok), Fireworks AI, Ollama, OpenClaw, or custom OpenAI-compatible endpoints.
 - **Tasks** — The Task Board tracks work items. Assign agents and they'll execute autonomously.
 - **Schedules** — Cron-based recurring jobs that run agents or tasks automatically.
@@ -419,7 +492,7 @@ Use your platform management tools proactively:
 You have opinions about good agent design. You suggest creative approaches, warn about common pitfalls, and get excited when someone gets something cool working. You're not a manual — you're a collaborator.
 
 Be concise but not curt. Warmth doesn't require verbosity. When someone asks "how do I...?", give them the direct steps. Offer to do things rather than just explaining — if someone wants an agent created, create it. Use your tools when actions speak louder than words. If you don't know something, say so honestly.`,
-      isOrchestrator: false,
+      isOrchestrator: true,
       plugins: defaultStarterTools,
       heartbeatEnabled: true,
       platformAssignScope: 'all',
@@ -440,6 +513,15 @@ Be concise but not curt. Warmth doesn't require verbosity. When someone asks "ho
           existing.plugins = mergedPlugins
           delete existing.tools
           existing.updatedAt = Date.now()
+        }
+        if (existing.platformAssignScope === 'all' || existing.platformAssignScope === 'self') {
+          const derivedIsOrchestrator = existing.platformAssignScope === 'all'
+          if (existing.isOrchestrator !== derivedIsOrchestrator) {
+            existing.isOrchestrator = derivedIsOrchestrator
+            existing.updatedAt = Date.now()
+          }
+        }
+        if (JSON.stringify(JSON.parse(row.data)) !== JSON.stringify(existing)) {
           db.prepare('UPDATE agents SET data = ? WHERE id = ?').run(JSON.stringify(existing), 'default')
         }
       } catch {
@@ -685,12 +767,106 @@ export function saveQueue(q: string[]) {
 }
 
 // --- Settings ---
+const APP_SETTINGS_SECRET_FIELDS = [
+  'elevenLabsApiKey',
+  'tavilyApiKey',
+  'braveApiKey',
+] as const
+
+const ENCRYPTED_APP_SETTINGS_KEY = '__encryptedAppSettings'
+
+type PersistedSettingsRecord = Record<string, any> & {
+  [ENCRYPTED_APP_SETTINGS_KEY]?: Record<string, string>
+}
+
+function cloneRecord<T extends Record<string, any>>(value: T): T {
+  return JSON.parse(JSON.stringify(value || {})) as T
+}
+
+function isPlainRecord(value: unknown): value is Record<string, any> {
+  return !!value && typeof value === 'object' && !Array.isArray(value)
+}
+
+function getEncryptedAppSettings(settings: PersistedSettingsRecord): Record<string, string> {
+  return isPlainRecord(settings[ENCRYPTED_APP_SETTINGS_KEY])
+    ? { ...(settings[ENCRYPTED_APP_SETTINGS_KEY] as Record<string, string>) }
+    : {}
+}
+
+function isClearedSecretValue(value: unknown): boolean {
+  return value === null || (typeof value === 'string' && value.trim() === '')
+}
+
+function isProvidedSecretValue(value: unknown): value is string {
+  return typeof value === 'string' && value.trim().length > 0
+}
+
+function buildPersistedSettings(input: Record<string, any>, existing?: PersistedSettingsRecord): PersistedSettingsRecord {
+  const next = cloneRecord(input) as PersistedSettingsRecord
+  const encrypted = {
+    ...(existing ? getEncryptedAppSettings(existing) : {}),
+    ...getEncryptedAppSettings(next),
+  }
+
+  delete next[ENCRYPTED_APP_SETTINGS_KEY]
+
+  for (const field of APP_SETTINGS_SECRET_FIELDS) {
+    const raw = next[field]
+    if (isClearedSecretValue(raw)) {
+      delete encrypted[field]
+      delete next[field]
+      continue
+    }
+    if (isProvidedSecretValue(raw)) {
+      encrypted[field] = encryptKey(raw)
+      delete next[field]
+    }
+  }
+
+  if (Object.keys(encrypted).length > 0) next[ENCRYPTED_APP_SETTINGS_KEY] = encrypted
+  return next
+}
+
+function resolveSettingsSecrets(settings: PersistedSettingsRecord): Record<string, any> {
+  const resolved = cloneRecord(settings)
+  delete resolved[ENCRYPTED_APP_SETTINGS_KEY]
+
+  const encrypted = getEncryptedAppSettings(settings)
+  for (const field of APP_SETTINGS_SECRET_FIELDS) {
+    if (isProvidedSecretValue(resolved[field])) continue
+    const value = encrypted[field]
+    if (typeof value !== 'string' || !value) continue
+    try {
+      resolved[field] = decryptKey(value)
+    } catch {
+      // Ignore malformed encrypted settings instead of breaking all settings reads.
+    }
+  }
+
+  return resolved
+}
+
 export function loadSettings(): Record<string, any> {
-  return loadSingleton('settings', {})
+  const persisted = loadSingleton('settings', {}) as PersistedSettingsRecord
+  const normalized = buildPersistedSettings(persisted, persisted)
+  if (JSON.stringify(persisted) !== JSON.stringify(normalized)) {
+    saveSingleton('settings', normalized)
+  }
+  return resolveSettingsSecrets(normalized)
 }
 
 export function saveSettings(s: Record<string, any>) {
-  saveSingleton('settings', s)
+  const existing = loadSingleton('settings', {}) as PersistedSettingsRecord
+  saveSingleton('settings', buildPersistedSettings(s, existing))
+}
+
+export function loadPublicSettings(): Record<string, any> {
+  const settings = cloneRecord(loadSettings())
+  for (const field of APP_SETTINGS_SECRET_FIELDS) {
+    settings[`${field}Configured`] = isProvidedSecretValue(settings[field])
+    settings[field] = null
+  }
+  return settings
 }
 
 // --- Secrets (service keys for orchestrators) ---
@@ -1026,6 +1202,49 @@ export function loadApprovals(): Record<string, unknown> {
   return loadCollection('approvals')
 }
 
+// --- Browser Sessions ---
+export function loadBrowserSessions(): Record<string, unknown> {
+  return loadCollection('browser_sessions')
+}
+
+export function upsertBrowserSession(id: string, data: unknown) {
+  upsertCollectionItem('browser_sessions', id, data)
+}
+
+export function deleteBrowserSession(id: string) {
+  deleteCollectionItem('browser_sessions', id)
+}
+
+// --- Watch Jobs ---
+export function loadWatchJobs(): Record<string, unknown> {
+  return loadCollection('watch_jobs')
+}
+
+export function upsertWatchJob(id: string, data: unknown) {
+  upsertCollectionItem('watch_jobs', id, data)
+}
+
+export function upsertWatchJobs(entries: Array<[string, unknown]>) {
+  upsertCollectionItems('watch_jobs', entries)
+}
+
+export function deleteWatchJob(id: string) {
+  deleteCollectionItem('watch_jobs', id)
+}
+
+// --- Delegation Jobs ---
+export function loadDelegationJobs(): Record<string, unknown> {
+  return loadCollection('delegation_jobs')
+}
+
+export function upsertDelegationJob(id: string, data: unknown) {
+  upsertCollectionItem('delegation_jobs', id, data)
+}
+
+export function deleteDelegationJob(id: string) {
+  deleteCollectionItem('delegation_jobs', id)
+}
+
 export function upsertApproval(id: string, approval: unknown) {
   upsertCollectionItem('approvals', id, approval)
 }

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

@@ -13,6 +13,7 @@ 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'
 
 /** Extract a breadcrumb title from notable tool completions (task/schedule/agent creation). */
 interface StreamAgentChatOpts {
@@ -59,7 +60,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,7 +72,6 @@ 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 })
@@ -102,13 +102,15 @@ 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.',
+    '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.',
+    '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 (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)
 
   return parts.filter(Boolean).join('\n')
 }
@@ -136,7 +138,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
   }
@@ -192,6 +196,8 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
       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 +296,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 +304,6 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
       heartbeatIntervalSec,
       platformAssignScope: agentPlatformAssignScope,
       userMessage: message,
-      hasExistingPlan,
     }),
   )
 
@@ -480,14 +482,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()
@@ -512,6 +513,9 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
     const maxIterations = MAX_AUTO_CONTINUES + MAX_TRANSIENT_RETRIES
     for (let iteration = 0; iteration <= maxIterations; iteration++) {
       let shouldContinue: 'recursion' | 'transient' | false = false
+      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 +524,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 +551,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 +591,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 +604,16 @@ 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'
             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 +624,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 +633,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 +675,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 +685,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,6 +719,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
           throw innerErr
         }
       } finally {
+        clearIdleWatchdog()
         abortController.signal.removeEventListener('abort', onParentAbort)
       }
 
@@ -775,7 +800,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, [])
+  })
+})