@swarmclawai/swarmclaw 0.7.2 → 0.7.4

package/src/lib/server/session-tools/platform.ts

@@ -6,12 +6,150 @@ import type { Plugin, PluginHooks } from '@/types'
 import { getPluginManager } from '../plugins'
 import { normalizeToolInputArgs } from './normalize-tool-args'
 
+function parsePlatformData(value: unknown): Record<string, unknown> | null {
+  if (!value) return null
+  if (typeof value === 'object' && !Array.isArray(value)) {
+    return value as Record<string, unknown>
+  }
+  if (typeof value !== 'string') return null
+  const trimmed = value.trim()
+  if (!trimmed) return null
+  try {
+    const parsed = JSON.parse(trimmed)
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>
+    }
+  } catch {
+    // Preserve non-JSON data strings as-is in the caller.
+  }
+  return null
+}
+
+function firstPlatformResource(value: unknown): Record<string, unknown> | null {
+  if (!Array.isArray(value)) return null
+  const first = value.find((entry) => entry && typeof entry === 'object' && !Array.isArray(entry))
+  return first && typeof first === 'object' && !Array.isArray(first)
+    ? first as Record<string, unknown>
+    : null
+}
+
+function normalizePlatformResourceName(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined
+  const normalized = value.trim().toLowerCase()
+  if (!normalized) return undefined
+  const singularMap: Record<string, string> = {
+    agent: 'agents',
+    task: 'tasks',
+    backlog_task: 'tasks',
+    'backlog-task': 'tasks',
+    backlogtask: 'tasks',
+    task_backlog: 'tasks',
+    'task-backlog': 'tasks',
+    work_item: 'tasks',
+    'work-item': 'tasks',
+    schedule: 'schedules',
+    skill: 'skills',
+    document: 'documents',
+    secret: 'secrets',
+    connector: 'connectors',
+    session: 'sessions',
+  }
+  return singularMap[normalized] || normalized
+}
+
+function inferPlatformResourceFromAction(value: unknown): { resource?: string; action?: string } {
+  if (typeof value !== 'string') return {}
+  const normalized = value.trim().toLowerCase().replace(/-/g, '_')
+  if (!normalized) return {}
+  const match = normalized.match(/^(list|get|create|update|delete)_([a-z_]+)$/)
+  if (!match) return {}
+  const [, action, rawResource] = match
+  const resource = normalizePlatformResourceName(rawResource)
+  if (!resource) return {}
+  return { resource, action }
+}
+
+function extractPlatformFields(value: Record<string, unknown>): Record<string, unknown> {
+  const fields: Record<string, unknown> = {}
+  for (const [key, fieldValue] of Object.entries(value)) {
+    if (fieldValue === undefined || fieldValue === null) continue
+    if (['input', 'args', 'arguments', 'payload', 'resources', 'parameters', 'resource', 'type', 'action', 'id'].includes(key)) continue
+    fields[key] = fieldValue
+  }
+  return fields
+}
+
+export function normalizePlatformActionArgs(rawArgs: Record<string, unknown>): Record<string, unknown> {
+  const normalized = normalizeToolInputArgs(rawArgs)
+  const resourceEntry = firstPlatformResource(normalized.resources)
+  const { resource, action, id, data, ...rest } = normalized
+  const payload: Record<string, unknown> = {}
+  const resourceValue = resource ?? resourceEntry?.resource ?? resourceEntry?.type
+  const rawResourceName = typeof resourceValue === 'string'
+    ? String(resourceValue).trim()
+    : undefined
+
+  const rawAction = action ?? resourceEntry?.action
+  const inferredFromAction = resourceValue === undefined
+    ? inferPlatformResourceFromAction(rawAction)
+    : {}
+  const effectiveResource = normalizePlatformResourceName(resourceValue) ?? inferredFromAction.resource
+  const effectiveAction = inferredFromAction.action && resourceValue === undefined
+    ? inferredFromAction.action
+    : rawAction
+  const effectiveId = id ?? resourceEntry?.id
+
+  if (effectiveResource !== undefined) payload.resource = effectiveResource
+  if (effectiveAction !== undefined) payload.action = effectiveAction
+  if (effectiveId !== undefined) payload.id = effectiveId
+
+  const directFields = extractPlatformFields(rest)
+  const resourcePayloadCandidates = effectiveResource
+    ? uniqueStrings([
+        rawResourceName,
+        effectiveResource,
+        effectiveResource.replace(/s$/, ''),
+      ])
+    : []
+  const directResourcePayload = resourcePayloadCandidates
+    .map((candidate) => parsePlatformData(normalized[candidate]))
+    .find(Boolean)
+    || null
+  if (effectiveResource) {
+    for (const candidate of resourcePayloadCandidates) delete directFields[candidate]
+  }
+  const parameterFields = {
+    ...(parsePlatformData(resourceEntry?.parameters) || {}),
+    ...(parsePlatformData(resourceEntry?.params) || {}),
+    ...(parsePlatformData(normalized.parameters) || {}),
+    ...(directResourcePayload || {}),
+  }
+  const parsedData = parsePlatformData(data)
+  const mergedData = {
+    ...(parsedData || {}),
+    ...parameterFields,
+    ...directFields,
+  }
+
+  if (Object.keys(mergedData).length > 0) {
+    payload.data = JSON.stringify(mergedData)
+  } else if (typeof data === 'string' && data.trim()) {
+    payload.data = data
+  }
+
+  return payload
+}
+
+function uniqueStrings(values: Array<string | undefined>): string[] {
+  return [...new Set(values.filter((value): value is string => Boolean(value)))]
+}
+
 /**
  * Unified Platform Execution Logic
  */
 async function executePlatformAction(args: any, bctx: any) {
-  const normalized = normalizeToolInputArgs((args ?? {}) as Record<string, unknown>)
-  const { resource, action, id, data, ...rest } = normalized
+  const normalized = normalizePlatformActionArgs((args ?? {}) as Record<string, unknown>)
+  const { resource, action, id, data } = normalized
   
   // We reuse the existing CRUD tool logic but expose it via a single tool
   const crudTools = buildCrudTools({
@@ -36,7 +174,7 @@ async function executePlatformAction(args: any, bctx: any) {
   }
 
   // Forward to the specific CRUD tool implementation
-  return targetTool.invoke({ action, id, data, ...rest })
+  return targetTool.invoke({ action, id, data })
 }
 
 /**
@@ -52,7 +190,7 @@ const PlatformPlugin: Plugin = {
   tools: [
     {
       name: 'manage_platform',
-      description: 'Unified tool for managing all SwarmClaw resources.',
+      description: 'Unified fallback tool for managing SwarmClaw resources when a more specific `manage_*` tool is not available. For create/update, pass resource + action, then either put fields inside data, pass them as top-level fields, or use a single resources[0].parameters envelope.',
       parameters: {
         type: 'object',
         properties: {

package/src/lib/server/session-tools/plugin-creator.ts

@@ -27,6 +27,8 @@ async function executePluginCreatorAction(args: Record<string, unknown>, ctxOrBc
   const action = normalized.action as string | undefined
   const filename = (normalized.filename ?? normalized.fileName) as string | undefined
   const code = (normalized.code ?? normalized.content) as string | undefined
+  const packageJson = normalized.packageJson ?? normalized.package_json ?? normalized.manifest
+  const packageManager = typeof normalized.packageManager === 'string' ? normalized.packageManager : undefined
   const approved = normalized.approved as boolean | undefined
 
   try {
@@ -40,15 +42,23 @@ async function executePluginCreatorAction(args: Record<string, unknown>, ctxOrBc
 
       // REQUIRE USER APPROVAL
       if (approved !== true) {
-        const { requestApproval } = await import('../approvals')
-        requestApproval({
+        const { requestApprovalMaybeAutoApprove } = await import('../approvals')
+        const approval = await requestApprovalMaybeAutoApprove({
           category: 'plugin_scaffold',
           title: `Scaffold Plugin: ${filename}`,
           description: `Create new plugin file with ${code.length} chars of code.`,
-          data: { filename, code, createdByAgentId: pctx.agentId || null },
+          data: { filename, code, packageJson, packageManager, createdByAgentId: pctx.agentId || null },
           agentId: pctx.agentId,
           sessionId: pctx.sessionId,
         })
+        if (approval.status === 'approved') {
+          return JSON.stringify({
+            type: 'plugin_scaffold_request',
+            filename,
+            autoApproved: true,
+            message: `Plugin "${filename}" was auto-approved and scaffolded. It is now available in this chat.`,
+          })
+        }
         return JSON.stringify({
           type: 'plugin_scaffold_request',
           filename,
@@ -56,12 +66,13 @@ async function executePluginCreatorAction(args: Record<string, unknown>, ctxOrBc
         })
       }
 
-      const filePath = path.join(PLUGINS_DIR, filename)
-      fs.writeFileSync(filePath, code, 'utf8')
-
-      // Reload the plugin manager so the new plugin is discovered
       const manager = getPluginManager()
-      manager.reload()
+      await manager.savePluginSource(filename, code, {
+        packageJson,
+        packageManager,
+        installDependencies: packageJson !== undefined,
+      })
+      const filePath = path.join(PLUGINS_DIR, filename)
 
       // Auto-enable the plugin for the agent that created it
       if (pctx.agentId && pctx.sessionId) {
@@ -82,10 +93,53 @@ async function executePluginCreatorAction(args: Record<string, unknown>, ctxOrBc
       return `Plugin saved to ${filePath} and PluginManager reloaded. It is now enabled for this chat.`
     }
 
+    if (action === 'install_dependencies') {
+      if (!filename) return 'Error: filename is required for install_dependencies.'
+
+      if (approved !== true) {
+        const { requestApprovalMaybeAutoApprove } = await import('../approvals')
+        const approval = await requestApprovalMaybeAutoApprove({
+          category: 'plugin_install',
+          title: `Install Plugin Dependencies: ${filename}`,
+          description: `Install package dependencies for plugin ${filename}${packageManager ? ` using ${packageManager}` : ''}.`,
+          data: { filename, packageJson, packageManager, createdByAgentId: pctx.agentId || null },
+          agentId: pctx.agentId,
+          sessionId: pctx.sessionId,
+        })
+        if (approval.status === 'approved') {
+          return JSON.stringify({
+            type: 'plugin_install_request',
+            filename,
+            autoApproved: true,
+            message: `Dependencies for "${filename}" were auto-approved and are being installed.`,
+          })
+        }
+        return JSON.stringify({
+          type: 'plugin_install_request',
+          filename,
+          message: `I've requested approval to install dependencies for "${filename}". Once approved, the plugin manager will run the selected package manager automatically.`,
+        })
+      }
+
+      const manager = getPluginManager()
+      if (packageJson !== undefined) {
+        const source = manager.readPluginSource(filename)
+        await manager.savePluginSource(filename, source, {
+          packageJson,
+          packageManager,
+          installDependencies: false,
+        })
+      }
+      const result = await manager.installPluginDependencies(filename, {
+        packageManager: packageManager as import('@/types').PluginPackageManager | undefined,
+      })
+      return `Dependencies installed for ${filename} using ${result.packageManager || packageManager || 'npm'}.`
+    }
+
     if (action === 'get_spec') {
       return `
 SwarmClaw Plugin Specification:
-A plugin is a CommonJS module (.js) that must be DUAL-COMPATIBLE with both SwarmClaw and OpenClaw platforms.
+A plugin is a JavaScript module (.js or .mjs) that can be dual-compatible with both SwarmClaw and OpenClaw platforms.
 
 \`\`\`js
 module.exports = {
@@ -100,10 +154,11 @@ module.exports = {
   hooks: {
     beforeAgentStart: async ({ session, message }) => {},
     afterAgentComplete: async ({ session, response }) => {},
-    beforeToolExec: async ({ session, toolName, args }) => {},
-    afterToolExec: async ({ session, toolName, result }) => {},
+    beforeToolExec: async ({ toolName, input }) => input,
+    afterToolExec: async ({ session, toolName, input, output }) => {},
     transformInboundMessage: async ({ session, text }) => { return text; },
     transformOutboundMessage: async ({ session, text }) => { return text; },
+    afterChatTurn: async ({ session, message, response, source, internal }) => {},
   },
 
   tools: [
@@ -140,27 +195,31 @@ module.exports = {
 \`\`\`
 
 Key rules:
-- Export BOTH SwarmClaw hooks/tools AND a register(api) method for cross-platform compatibility
-- SwarmClaw checks for hooks/tools first; OpenClaw checks for register()
+- Export SwarmClaw hooks/tools. Add register(api) too if you want OpenClaw compatibility.
+- SwarmClaw checks hooks/tools first; OpenClaw checks register()
 - Tools must have name, description, parameters (JSON Schema), and execute function
 - Hooks are optional — only include the ones you need
+- If your plugin needs npm/pnpm/yarn/bun packages, include a packageJson object during scaffold or call install_dependencies later.
+- Dependency installs are run by the plugin manager inside a per-plugin workspace using the selected package manager with scripts disabled.
+- Plugin settings are declared through ui.settingsFields and stored per plugin ID
 - Keep plugins focused: one clear purpose per plugin
 `
     }
 
     if (action === 'read') {
       if (!filename) return 'Error: filename required.'
-      const filePath = path.join(PLUGINS_DIR, filename)
-      if (!fs.existsSync(filePath)) return `File not found: ${filename}`
-      return fs.readFileSync(filePath, 'utf8')
+      return getPluginManager().readPluginSource(filename)
     }
 
     if (action === 'edit') {
       if (!filename || !code) return 'Error: filename and code are required for edit.'
-      const filePath = path.join(PLUGINS_DIR, filename)
-      if (!fs.existsSync(filePath)) return `File not found: ${filename}. Use scaffold to create new plugins.`
-      fs.writeFileSync(filePath, code, 'utf8')
-      getPluginManager().reload()
+      const manager = getPluginManager()
+      try {
+        manager.readPluginSource(filename)
+      } catch {
+        return `File not found: ${filename}. Use scaffold to create new plugins.`
+      }
+      await manager.savePluginSource(filename, code)
       return `Updated ${filename} and reloaded plugin manager.`
     }
 
@@ -175,7 +234,7 @@ Key rules:
       return `File not found: ${filename}`
     }
 
-    return `Unknown action "${action}". Valid actions: get_spec, scaffold, read, edit, delete`
+    return `Unknown action "${action}". Valid actions: get_spec, scaffold, read, edit, delete, install_dependencies`
   } catch (err: unknown) {
     return `Error: ${err instanceof Error ? err.message : String(err)}`
   }
@@ -186,8 +245,15 @@ Key rules:
  */
 const PluginCreatorPlugin: Plugin = {
   name: 'Plugin Creator',
-  description: 'Design, write, and test custom SwarmClaw plugins dynamically.',
-  hooks: {} as PluginHooks,
+  description: 'Design focused SwarmClaw plugins for durable capabilities and recurring automations.',
+  hooks: {
+    getCapabilityDescription: () => 'I can scaffold focused plugins (`plugin_creator_tool`) when a capability should become durable instead of living in a one-off sandbox script.',
+    getOperatingGuidance: () => [
+      'For recurring or scheduled automations, prefer a focused plugin plus `manage_schedules` over repeated sandbox runs.',
+      'Put API keys in plugin settings or SwarmClaw secrets instead of hardcoding them in plugin source.',
+      'Call `get_spec` before scaffolding so the plugin follows the current contract.',
+    ],
+  } as PluginHooks,
   tools: [
     {
       name: 'plugin_creator_tool',
@@ -195,9 +261,11 @@ const PluginCreatorPlugin: Plugin = {
       parameters: {
         type: 'object',
         properties: {
-          action: { type: 'string', enum: ['get_spec', 'scaffold', 'read', 'edit', 'delete'], description: 'get_spec: learn format. scaffold: create (needs approval). read: view code. edit: update existing. delete: remove.' },
+          action: { type: 'string', enum: ['get_spec', 'scaffold', 'read', 'edit', 'delete', 'install_dependencies'], description: 'get_spec: learn format. scaffold: create (needs approval). read: view code. edit: update existing. delete: remove. install_dependencies: write/read package.json and install runtime deps.' },
           filename: { type: 'string', description: 'Plugin filename, e.g. my-plugin.js. Required for scaffold and delete.' },
           code: { type: 'string', description: 'The raw JavaScript code for the plugin. Required for scaffold.' },
+          packageJson: { type: 'object', description: 'Optional package.json object for dependency-aware plugins. Use with scaffold or install_dependencies.' },
+          packageManager: { type: 'string', enum: ['npm', 'pnpm', 'yarn', 'bun'], description: 'Optional package manager to use for dependency installs.' },
           approved: { type: 'boolean', description: 'Internal flag — do NOT set this. The approval system handles it automatically.' }
         },
         required: ['action']
@@ -228,9 +296,11 @@ export function buildPluginCreatorTools(bctx: ToolBuildContext): StructuredToolI
         name: 'plugin_creator_tool',
         description: PluginCreatorPlugin.tools![0].description,
         schema: z.object({
-          action: z.enum(['get_spec', 'scaffold', 'read', 'edit', 'delete']),
+          action: z.enum(['get_spec', 'scaffold', 'read', 'edit', 'delete', 'install_dependencies']),
           filename: z.string().optional(),
           code: z.string().optional(),
+          packageJson: z.record(z.string(), z.any()).optional(),
+          packageManager: z.enum(['npm', 'pnpm', 'yarn', 'bun']).optional(),
           approved: z.boolean().optional()
         })
       }

package/src/lib/server/session-tools/primitive-tools.test.ts

@@ -0,0 +1,257 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { after, before, describe, it } from 'node:test'
+import type { Session } from '@/types'
+
+const originalEnv = {
+  DATA_DIR: process.env.DATA_DIR,
+  WORKSPACE_DIR: process.env.WORKSPACE_DIR,
+  SWARMCLAW_BUILD_MODE: process.env.SWARMCLAW_BUILD_MODE,
+}
+
+let tempDir = ''
+let workspaceDir = ''
+let buildDocumentTools: typeof import('./document').buildDocumentTools
+let buildExtractTools: typeof import('./extract').buildExtractTools
+let buildTableTools: typeof import('./table').buildTableTools
+let buildMailboxTools: typeof import('./mailbox').buildMailboxTools
+let buildHumanLoopTools: typeof import('./human-loop').buildHumanLoopTools
+let buildCrawlTools: typeof import('./crawl').buildCrawlTools
+let sessionMailbox: typeof import('../session-mailbox')
+let watchJobs: typeof import('../watch-jobs')
+let storage: typeof import('../storage')
+
+function makeSession(overrides?: Partial<Session>): Session {
+  return {
+    id: 'session_1',
+    name: 'Test Session',
+    cwd: workspaceDir,
+    user: 'tester',
+    provider: 'ollama',
+    model: 'qwen3.5',
+    apiEndpoint: 'http://localhost:11434',
+    claudeSessionId: null,
+    messages: [],
+    createdAt: Date.now(),
+    lastActiveAt: Date.now(),
+    plugins: [],
+    ...overrides,
+  }
+}
+
+function makeBuildContext(overrides?: {
+  cwd?: string
+  session?: Session
+}) {
+  const session = overrides?.session || makeSession()
+  return {
+    cwd: overrides?.cwd || workspaceDir,
+    ctx: {
+      sessionId: session.id,
+      agentId: session.agentId || 'agent_1',
+    },
+    hasPlugin: () => true,
+    hasTool: () => true,
+    cleanupFns: [],
+    commandTimeoutMs: 5000,
+    claudeTimeoutMs: 5000,
+    cliProcessTimeoutMs: 5000,
+    persistDelegateResumeId: () => {},
+    readStoredDelegateResumeId: () => null,
+    resolveCurrentSession: () => session,
+    activePlugins: [],
+  }
+}
+
+before(async () => {
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-primitive-tools-'))
+  workspaceDir = path.join(tempDir, 'workspace')
+  fs.mkdirSync(workspaceDir, { recursive: true })
+  process.env.DATA_DIR = path.join(tempDir, 'data')
+  process.env.WORKSPACE_DIR = workspaceDir
+  process.env.SWARMCLAW_BUILD_MODE = '1'
+  fs.mkdirSync(process.env.DATA_DIR, { recursive: true })
+
+  ;({ buildDocumentTools } = await import('./document'))
+  ;({ buildExtractTools } = await import('./extract'))
+  ;({ buildTableTools } = await import('./table'))
+  ;({ buildMailboxTools } = await import('./mailbox'))
+  ;({ buildHumanLoopTools } = await import('./human-loop'))
+  ;({ buildCrawlTools } = await import('./crawl'))
+  sessionMailbox = await import('../session-mailbox')
+  watchJobs = await import('../watch-jobs')
+  storage = await import('../storage')
+})
+
+after(() => {
+  if (originalEnv.DATA_DIR === undefined) delete process.env.DATA_DIR
+  else process.env.DATA_DIR = originalEnv.DATA_DIR
+  if (originalEnv.WORKSPACE_DIR === undefined) delete process.env.WORKSPACE_DIR
+  else process.env.WORKSPACE_DIR = originalEnv.WORKSPACE_DIR
+  if (originalEnv.SWARMCLAW_BUILD_MODE === undefined) delete process.env.SWARMCLAW_BUILD_MODE
+  else process.env.SWARMCLAW_BUILD_MODE = originalEnv.SWARMCLAW_BUILD_MODE
+  fs.rmSync(tempDir, { recursive: true, force: true })
+})
+
+describe('primitive tools', () => {
+  it('document tool reads, stores, and searches extracted text', async () => {
+    const sourcePath = path.join(workspaceDir, 'note.txt')
+    fs.writeFileSync(sourcePath, 'Invoice 42 for ACME\nTotal: $120.50\n')
+
+    const [documentTool] = buildDocumentTools(makeBuildContext())
+    const read = JSON.parse(String(await documentTool.invoke({ action: 'read', filePath: 'note.txt' })))
+    assert.match(read.text, /Invoice 42/)
+
+    const stored = JSON.parse(String(await documentTool.invoke({ action: 'store', filePath: 'note.txt', title: 'Invoice Note' })))
+    const search = JSON.parse(String(await documentTool.invoke({ action: 'search', query: 'ACME' })))
+    const fetched = JSON.parse(String(await documentTool.invoke({ action: 'get', id: stored.id })))
+
+    assert.equal(search.matches[0].id, stored.id)
+    assert.equal(fetched.title, 'Invoice Note')
+  })
+
+  it('table tool transforms inline data and writes results', async () => {
+    const [tableTool] = buildTableTools(makeBuildContext())
+    const rows = [
+      { id: '1', name: 'Ada', score: 10 },
+      { id: '2', name: 'Grace', score: 25 },
+      { id: '2', name: 'Grace', score: 25 },
+    ]
+
+    const filtered = JSON.parse(String(await tableTool.invoke({
+      action: 'filter',
+      rows,
+      where: [{ column: 'score', op: 'gt', value: 15 }],
+    })))
+    assert.equal(filtered.rowCount, 2)
+
+    const deduped = JSON.parse(String(await tableTool.invoke({
+      action: 'dedupe',
+      rows,
+      on: ['id'],
+    })))
+    assert.equal(deduped.rowCount, 2)
+
+    const joined = JSON.parse(String(await tableTool.invoke({
+      action: 'join',
+      leftRows: [{ id: '1', team: 'red' }],
+      rightRows: [{ id: '1', email: 'ada@example.com' }],
+      on: 'id',
+    })))
+    assert.equal(joined.rows[0].email, 'ada@example.com')
+
+    const writeResult = JSON.parse(String(await tableTool.invoke({
+      action: 'write',
+      rows,
+      outputPath: 'exports/report.csv',
+    })))
+    assert.equal(fs.existsSync(writeResult.output.filePath), true)
+  })
+
+  it('human-loop tool creates durable mailbox and approval waits', async () => {
+    const [humanTool] = buildHumanLoopTools(makeBuildContext())
+    const sessions = storage.loadSessions()
+    sessions.session_1 = makeSession({ id: 'session_1', agentId: 'agent_1' })
+    storage.saveSessions(sessions)
+
+    const requestInput = JSON.parse(String(await humanTool.invoke({
+      action: 'request_input',
+      question: 'Ship it?',
+      correlationId: 'corr_123',
+    })))
+    assert.equal(requestInput.ok, true)
+
+    const replyWatch = JSON.parse(String(await humanTool.invoke({
+      action: 'wait_for_reply',
+      correlationId: 'corr_123',
+    })))
+    const replyEnvelope = sessionMailbox.sendMailboxEnvelope({
+      toSessionId: 'session_1',
+      type: 'human_reply',
+      payload: 'yes',
+      correlationId: 'corr_123',
+    })
+    watchJobs.triggerMailboxWatchJobs({ sessionId: 'session_1', envelope: replyEnvelope })
+    assert.equal(watchJobs.getWatchJob(replyWatch.id)?.status, 'triggered')
+
+    const approval = JSON.parse(String(await humanTool.invoke({
+      action: 'request_approval',
+      title: 'Need signoff',
+      question: 'Allow publish?',
+    })))
+    const approvalWatch = JSON.parse(String(await humanTool.invoke({
+      action: 'wait_for_approval',
+      approvalId: approval.id,
+    })))
+    watchJobs.triggerApprovalWatchJobs({ approvalId: approval.id, status: 'approved' })
+    assert.equal(watchJobs.getWatchJob(approvalWatch.id)?.status, 'triggered')
+  })
+
+  it('mailbox tool reports configuration status without requiring network', async () => {
+    const [mailboxTool] = buildMailboxTools(makeBuildContext())
+    const status = JSON.parse(String(await mailboxTool.invoke({ action: 'status' })))
+    assert.equal(status.configured, false)
+    assert.equal(status.folder, 'INBOX')
+  })
+
+  it('extract tool reports active model context', async () => {
+    const [extractTool] = buildExtractTools(makeBuildContext({
+      session: makeSession({
+        provider: 'ollama',
+        model: 'qwen3.5',
+        apiEndpoint: 'http://localhost:11434',
+      }),
+    }))
+    const status = JSON.parse(String(await extractTool.invoke({ action: 'status' })))
+    assert.equal(status.provider, 'ollama')
+    assert.equal(Array.isArray(status.supports), true)
+  })
+
+  it('crawl tool crawls and dedupes fetched pages without a live server', async () => {
+    const originalFetch = global.fetch
+    global.fetch = (async (input: RequestInfo | URL) => {
+      const url = typeof input === 'string' ? input : input.toString()
+      if (url.endsWith('/page-2')) {
+        return new Response('<html><head><title>Page Two</title></head><body><article><h1>Second</h1><p>Next content</p></article></body></html>', {
+          status: 200,
+          headers: { 'content-type': 'text/html' },
+        })
+      }
+      return new Response('<html><head><title>Root</title></head><body><article><h1>Home</h1><p>Welcome</p></article><a href="/page-2" rel="next">Next</a></body></html>', {
+        status: 200,
+        headers: { 'content-type': 'text/html' },
+      })
+    }) as typeof fetch
+
+    try {
+      const [crawlTool] = buildCrawlTools(makeBuildContext())
+      const baseUrl = 'https://example.test/'
+
+      const crawled = JSON.parse(String(await crawlTool.invoke({
+        action: 'crawl_site',
+        url: baseUrl,
+        limit: 2,
+      })))
+      assert.equal(crawled.count, 2)
+      assert.equal(crawled.pages[0].title, 'Root')
+
+      const extracted = JSON.parse(String(await crawlTool.invoke({
+        action: 'extract_sitemap',
+        url: baseUrl,
+        limit: 2,
+      })))
+      assert.equal(extracted.count, 2)
+      assert.equal(extracted.urls.includes('https://example.test/page-2'), true)
+
+      const deduped = JSON.parse(String(await crawlTool.invoke({
+        action: 'dedupe_pages',
+        pages: [crawled.pages[0], crawled.pages[0], crawled.pages[1]],
+      })))
+      assert.equal(deduped.count, 2)
+    } finally {
+      global.fetch = originalFetch
+    }
+  })
+})

package/src/lib/server/session-tools/replicate.ts

@@ -3,7 +3,6 @@ import { tool, type StructuredToolInterface } from '@langchain/core/tools'
 import type { Plugin, PluginHooks } from '@/types'
 import { getPluginManager } from '../plugins'
 import { normalizeToolInputArgs } from './normalize-tool-args'
-import { loadSettings } from '../storage'
 import type { ToolBuildContext } from './context'
 
 interface ReplicateConfig {
@@ -14,8 +13,7 @@ interface ReplicateConfig {
 }
 
 function getConfig(): ReplicateConfig {
-  const settings = loadSettings()
-  const ps = (settings.pluginSettings as Record<string, Record<string, unknown>> | undefined)?.replicate ?? {}
+  const ps = getPluginManager().getPluginSettings('replicate')
   return {
     apiToken: (ps.apiToken as string) || '',
     defaultModel: (ps.defaultModel as string) || '',