@swarmclawai/swarmclaw 0.7.1 → 0.7.3

package/src/lib/server/session-tools/image-gen.ts

@@ -0,0 +1,380 @@
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import fs from 'fs'
+import path from 'path'
+import type { Plugin, PluginHooks } from '@/types'
+import { getPluginManager } from '../plugins'
+import { normalizeToolInputArgs } from './normalize-tool-args'
+import { UPLOAD_DIR } from '../storage'
+import type { ToolBuildContext } from './context'
+
+type ImageProvider = 'openai' | 'stability' | 'replicate' | 'fal' | 'together' | 'fireworks' | 'bfl' | 'custom'
+
+interface PluginConfig {
+  provider: ImageProvider
+  apiKey: string
+  model: string
+  defaultSize: string
+  customEndpoint: string
+}
+
+function getConfig(): PluginConfig {
+  const ps = getPluginManager().getPluginSettings('image_gen')
+  return {
+    provider: (ps.provider as ImageProvider) || 'openai',
+    apiKey: (ps.apiKey as string) || '',
+    model: (ps.model as string) || '',
+    defaultSize: (ps.defaultSize as string) || '1024x1024',
+    customEndpoint: (ps.customEndpoint as string) || '',
+  }
+}
+
+type GenResult = { b64?: string; url?: string; error?: string }
+
+// --- Provider Implementations ---
+
+async function generateOpenAI(prompt: string, size: string, quality: string, cfg: PluginConfig): Promise<GenResult> {
+  const model = cfg.model || 'gpt-image-1'
+  const res = await fetch('https://api.openai.com/v1/images/generations', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${cfg.apiKey}` },
+    body: JSON.stringify({ model, prompt, n: 1, size, quality, response_format: 'b64_json' }),
+    signal: AbortSignal.timeout(120_000),
+  })
+  if (!res.ok) return { error: `OpenAI ${res.status}: ${(await res.text().catch(() => '')).slice(0, 300)}` }
+  const data = await res.json()
+  return { b64: data?.data?.[0]?.b64_json }
+}
+
+async function generateStability(prompt: string, size: string, cfg: PluginConfig): Promise<GenResult> {
+  // Stability v2beta uses multipart/form-data and returns raw image bytes
+  const model = cfg.model || 'sd3'
+  const formData = new FormData()
+  formData.append('prompt', prompt)
+  formData.append('model', model)
+  formData.append('output_format', 'png')
+  // Map size to aspect ratio
+  const [w, h] = size.split('x').map(Number)
+  if (w && h) {
+    const ratio = w > h ? '16:9' : h > w ? '9:16' : '1:1'
+    formData.append('aspect_ratio', ratio)
+  }
+  const res = await fetch('https://api.stability.ai/v2beta/stable-image/generate/sd3', {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${cfg.apiKey}`, Accept: 'image/*' },
+    body: formData,
+    signal: AbortSignal.timeout(120_000),
+  })
+  if (!res.ok) return { error: `Stability ${res.status}: ${(await res.text().catch(() => '')).slice(0, 300)}` }
+  const buf = Buffer.from(await res.arrayBuffer())
+  return { b64: buf.toString('base64') }
+}
+
+async function generateReplicate(prompt: string, size: string, cfg: PluginConfig): Promise<GenResult> {
+  const model = cfg.model || 'black-forest-labs/flux-schnell'
+  const [w, h] = size.split('x').map(Number)
+  // Try sync mode first (Prefer: wait blocks up to 60s)
+  const createRes = await fetch('https://api.replicate.com/v1/predictions', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${cfg.apiKey}`, Prefer: 'wait' },
+    body: JSON.stringify({ model, input: { prompt, width: w || 1024, height: h || 1024 } }),
+    signal: AbortSignal.timeout(120_000),
+  })
+  if (!createRes.ok) return { error: `Replicate ${createRes.status}: ${(await createRes.text().catch(() => '')).slice(0, 300)}` }
+  let prediction = await createRes.json()
+
+  // If sync didn't complete, poll
+  if (prediction.status !== 'succeeded' && prediction.status !== 'failed' && prediction.urls?.get) {
+    const deadline = Date.now() + 120_000
+    while (prediction.status !== 'succeeded' && prediction.status !== 'failed' && Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, 2000))
+      const pollRes = await fetch(prediction.urls.get, {
+        headers: { Authorization: `Bearer ${cfg.apiKey}` },
+        signal: AbortSignal.timeout(10_000),
+      })
+      prediction = await pollRes.json()
+    }
+  }
+  if (prediction.status === 'failed') return { error: `Replicate failed: ${prediction.error || 'unknown'}` }
+  const output = Array.isArray(prediction.output) ? prediction.output[0] : prediction.output
+  if (typeof output === 'string') return { url: output }
+  return { error: 'No image in Replicate response.' }
+}
+
+async function generateFal(prompt: string, size: string, cfg: PluginConfig): Promise<GenResult> {
+  const model = cfg.model || 'fal-ai/flux/schnell'
+  const [w, h] = size.split('x').map(Number)
+  const res = await fetch(`https://fal.run/${model}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Authorization: `Key ${cfg.apiKey}` },
+    body: JSON.stringify({ prompt, image_size: { width: w || 1024, height: h || 1024 }, num_images: 1 }),
+    signal: AbortSignal.timeout(120_000),
+  })
+  if (!res.ok) return { error: `fal.ai ${res.status}: ${(await res.text().catch(() => '')).slice(0, 300)}` }
+  const data = await res.json()
+  const imageUrl = data?.images?.[0]?.url
+  if (imageUrl) return { url: imageUrl }
+  return { error: 'No image in fal.ai response.' }
+}
+
+async function generateTogether(prompt: string, size: string, cfg: PluginConfig): Promise<GenResult> {
+  const model = cfg.model || 'black-forest-labs/FLUX.1-schnell-Free'
+  const [w, h] = size.split('x').map(Number)
+  const res = await fetch('https://api.together.xyz/v1/images/generations', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${cfg.apiKey}` },
+    body: JSON.stringify({ model, prompt, width: w || 1024, height: h || 1024, n: 1, response_format: 'b64_json' }),
+    signal: AbortSignal.timeout(120_000),
+  })
+  if (!res.ok) return { error: `Together ${res.status}: ${(await res.text().catch(() => '')).slice(0, 300)}` }
+  const data = await res.json()
+  const b64 = data?.data?.[0]?.b64_json
+  if (b64) return { b64 }
+  const url = data?.data?.[0]?.url
+  if (url) return { url }
+  return { error: 'No image in Together response.' }
+}
+
+async function generateFireworks(prompt: string, _size: string, cfg: PluginConfig): Promise<GenResult> {
+  const model = cfg.model || 'flux-1-schnell-fp8'
+  const res = await fetch(`https://api.fireworks.ai/inference/v1/workflows/accounts/fireworks/models/${model}/text_to_image`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${cfg.apiKey}`, Accept: 'image/jpeg' },
+    body: JSON.stringify({ prompt }),
+    signal: AbortSignal.timeout(120_000),
+  })
+  if (!res.ok) return { error: `Fireworks ${res.status}: ${(await res.text().catch(() => '')).slice(0, 300)}` }
+  // Response may be JSON with base64 array or raw image
+  const ct = res.headers.get('content-type') || ''
+  if (ct.includes('application/json')) {
+    const data = await res.json()
+    const b64 = data?.base64?.[0] ?? data?.data?.[0]?.b64_json
+    if (b64) return { b64 }
+    return { error: 'No image in Fireworks JSON response.' }
+  }
+  // Raw image bytes
+  const buf = Buffer.from(await res.arrayBuffer())
+  return { b64: buf.toString('base64') }
+}
+
+async function generateBFL(prompt: string, size: string, cfg: PluginConfig): Promise<GenResult> {
+  const [w, h] = size.split('x').map(Number)
+  const model = cfg.model || 'flux-pro-1.1'
+  const createRes = await fetch(`https://api.bfl.ai/v1/${model}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', 'x-key': cfg.apiKey },
+    body: JSON.stringify({ prompt, width: w || 1024, height: h || 1024 }),
+    signal: AbortSignal.timeout(15_000),
+  })
+  if (!createRes.ok) return { error: `BFL ${createRes.status}: ${(await createRes.text().catch(() => '')).slice(0, 300)}` }
+  const task = await createRes.json()
+  const pollingUrl = task?.polling_url || (task?.id ? `https://api.bfl.ai/v1/get_result?id=${task.id}` : null)
+  if (!pollingUrl) return { error: 'No polling URL from BFL.' }
+
+  // Poll for result
+  const deadline = Date.now() + 120_000
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 2000))
+    const pollRes = await fetch(pollingUrl, {
+      headers: { 'x-key': cfg.apiKey },
+      signal: AbortSignal.timeout(10_000),
+    })
+    const result = await pollRes.json()
+    if (result.status === 'Ready' && result.result?.sample) return { url: result.result.sample }
+    if (result.status === 'Error') return { error: `BFL error: ${result.result || 'unknown'}` }
+  }
+  return { error: 'BFL generation timed out.' }
+}
+
+async function generateCustom(prompt: string, size: string, quality: string, cfg: PluginConfig): Promise<GenResult> {
+  if (!cfg.customEndpoint) return { error: 'Custom endpoint URL not configured.' }
+  // Assumes OpenAI-compatible image generation API
+  const [w, h] = size.split('x').map(Number)
+  const res = await fetch(cfg.customEndpoint, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${cfg.apiKey}` },
+    body: JSON.stringify({ model: cfg.model || 'default', prompt, n: 1, size, width: w || 1024, height: h || 1024, quality, response_format: 'b64_json' }),
+    signal: AbortSignal.timeout(120_000),
+  })
+  if (!res.ok) return { error: `Custom API ${res.status}: ${(await res.text().catch(() => '')).slice(0, 300)}` }
+  const data = await res.json()
+  const b64 = data?.data?.[0]?.b64_json ?? data?.images?.[0]?.b64_json ?? data?.b64_json ?? data?.artifacts?.[0]?.base64
+  if (b64) return { b64 }
+  const url = data?.data?.[0]?.url ?? data?.images?.[0]?.url ?? data?.url
+  if (url) return { url }
+  return { error: 'No image found in custom API response.' }
+}
+
+// --- Dispatcher ---
+
+const PROVIDERS: Record<ImageProvider, (prompt: string, size: string, quality: string, cfg: PluginConfig) => Promise<GenResult>> = {
+  openai: generateOpenAI,
+  stability: (p, s, _q, c) => generateStability(p, s, c),
+  replicate: (p, s, _q, c) => generateReplicate(p, s, c),
+  fal: (p, s, _q, c) => generateFal(p, s, c),
+  together: (p, s, _q, c) => generateTogether(p, s, c),
+  fireworks: (p, s, _q, c) => generateFireworks(p, s, c),
+  bfl: (p, s, _q, c) => generateBFL(p, s, c),
+  custom: generateCustom,
+}
+
+async function saveImageResult(result: GenResult, prompt: string, filename: string | undefined): Promise<string> {
+  if (result.error) return `Error: ${result.error}`
+
+  if (result.b64) {
+    const buf = Buffer.from(result.b64, 'base64')
+    const baseName = filename || `img-${Date.now()}.png`
+    const safeName = baseName.replace(/[^a-zA-Z0-9._-]/g, '_')
+    const dest = path.join(UPLOAD_DIR, safeName)
+    if (!fs.existsSync(UPLOAD_DIR)) fs.mkdirSync(UPLOAD_DIR, { recursive: true })
+    fs.writeFileSync(dest, buf)
+    return `Image generated (${buf.length} bytes).\n\n![${prompt.slice(0, 60)}](/api/uploads/${safeName})\n\n[Download](/api/uploads/${safeName})`
+  }
+
+  if (result.url) {
+    // Download remote URL to uploads
+    try {
+      const res = await fetch(result.url, { signal: AbortSignal.timeout(30_000) })
+      if (res.ok) {
+        const buf = Buffer.from(await res.arrayBuffer())
+        const baseName = filename || `img-${Date.now()}.png`
+        const safeName = baseName.replace(/[^a-zA-Z0-9._-]/g, '_')
+        const dest = path.join(UPLOAD_DIR, safeName)
+        if (!fs.existsSync(UPLOAD_DIR)) fs.mkdirSync(UPLOAD_DIR, { recursive: true })
+        fs.writeFileSync(dest, buf)
+        return `Image generated (${buf.length} bytes).\n\n![${prompt.slice(0, 60)}](/api/uploads/${safeName})\n\n[Download](/api/uploads/${safeName})`
+      }
+    } catch { /* fall through to URL-only response */ }
+    return `Image generated: ${result.url}`
+  }
+
+  return 'Error: No image returned.'
+}
+
+async function executeImageGen(args: Record<string, unknown>): Promise<string> {
+  const normalized = normalizeToolInputArgs(args)
+  const prompt = String(normalized.prompt || '').trim()
+  if (!prompt) return 'Error: prompt is required.'
+
+  const cfg = getConfig()
+  if (!cfg.apiKey) return 'Error: Image generation API key not configured. Ask the user to add one in Plugin Settings > Image Generation.'
+
+  const size = String(normalized.size || cfg.defaultSize)
+  const quality = String(normalized.quality || 'standard')
+  const filename = normalized.filename as string | undefined
+
+  const generate = PROVIDERS[cfg.provider]
+  if (!generate) return `Error: Unknown provider "${cfg.provider}".`
+
+  try {
+    const result = await generate(prompt, size, quality, cfg)
+    return saveImageResult(result, prompt, filename)
+  } catch (err: unknown) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
+
+const ImageGenPlugin: Plugin = {
+  name: 'Image Generation',
+  enabledByDefault: false,
+  description: 'Generate images from text prompts. Supports OpenAI, Stability AI, Replicate, fal.ai, Together AI, Fireworks AI, BFL (Flux), or any OpenAI-compatible API.',
+  hooks: {
+    getCapabilityDescription: () =>
+      'I can generate images from text descriptions using `generate_image`. Supports different sizes, quality levels, and providers.',
+  } as PluginHooks,
+  tools: [
+    {
+      name: 'generate_image',
+      description: 'Generate an image from a text prompt. The image is saved and a download link is returned. Use descriptive, detailed prompts for best results.',
+      parameters: {
+        type: 'object',
+        properties: {
+          prompt: { type: 'string', description: 'Detailed text description of the image to generate' },
+          size: { type: 'string', enum: ['1024x1024', '1536x1024', '1024x1536', '512x512', '768x768', '1280x720', '720x1280'], description: 'Image dimensions (default: 1024x1024)' },
+          quality: { type: 'string', enum: ['standard', 'hd', 'low', 'medium', 'high'], description: 'Quality level (default: standard). Primarily used by OpenAI.' },
+          filename: { type: 'string', description: 'Optional filename for the saved image (e.g. "hero-banner.png")' },
+        },
+        required: ['prompt'],
+      },
+      execute: async (args) => executeImageGen(args),
+    },
+  ],
+  ui: {
+    settingsFields: [
+      {
+        key: 'provider',
+        label: 'Provider',
+        type: 'select',
+        options: [
+          { value: 'openai', label: 'OpenAI (DALL-E / gpt-image)' },
+          { value: 'stability', label: 'Stability AI' },
+          { value: 'replicate', label: 'Replicate (Flux, SDXL, etc.)' },
+          { value: 'fal', label: 'fal.ai (Flux, SDXL, etc.)' },
+          { value: 'together', label: 'Together AI' },
+          { value: 'fireworks', label: 'Fireworks AI' },
+          { value: 'bfl', label: 'BFL / Black Forest Labs (Flux Pro)' },
+          { value: 'custom', label: 'Custom (OpenAI-compatible endpoint)' },
+        ],
+        defaultValue: 'openai',
+      },
+      {
+        key: 'apiKey',
+        label: 'API Key',
+        type: 'secret',
+        required: true,
+        placeholder: 'sk-... / r8_... / fal-...',
+        help: 'API key for the selected provider.',
+      },
+      {
+        key: 'model',
+        label: 'Model',
+        type: 'text',
+        placeholder: 'gpt-image-1 / black-forest-labs/flux-schnell / ...',
+        help: 'Model ID. Each provider has its own default if left blank.',
+      },
+      {
+        key: 'defaultSize',
+        label: 'Default Size',
+        type: 'select',
+        options: [
+          { value: '1024x1024', label: '1024x1024 (Square)' },
+          { value: '1536x1024', label: '1536x1024 (Landscape)' },
+          { value: '1024x1536', label: '1024x1536 (Portrait)' },
+          { value: '1280x720', label: '1280x720 (16:9)' },
+          { value: '512x512', label: '512x512 (Small)' },
+          { value: '768x768', label: '768x768 (Medium)' },
+        ],
+        defaultValue: '1024x1024',
+      },
+      {
+        key: 'customEndpoint',
+        label: 'Custom Endpoint URL',
+        type: 'text',
+        placeholder: 'https://your-api.example.com/v1/images/generations',
+        help: 'Only used when provider is "Custom". Should accept OpenAI-compatible image generation requests.',
+      },
+    ],
+  },
+}
+
+getPluginManager().registerBuiltin('image_gen', ImageGenPlugin)
+
+export function buildImageGenTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasPlugin('image_gen')) return []
+
+  return [
+    tool(
+      async (args) => executeImageGen(args),
+      {
+        name: 'generate_image',
+        description: ImageGenPlugin.tools![0].description,
+        schema: z.object({
+          prompt: z.string().describe('Detailed text description of the image to generate'),
+          size: z.enum(['1024x1024', '1536x1024', '1024x1536', '512x512', '768x768', '1280x720', '720x1280']).optional().describe('Image dimensions (default: 1024x1024)'),
+          quality: z.enum(['standard', 'hd', 'low', 'medium', 'high']).optional().describe('Quality level (default: standard)'),
+          filename: z.string().optional().describe('Optional filename for the saved image'),
+        }),
+      },
+    ),
+  ]
+}

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

@@ -5,7 +5,7 @@ import { loadSettings, loadSessions, saveSessions, loadMcpServers } from '../sto
 import { loadRuntimeSettings } from '../runtime-settings'
 import { log } from '../logger'
 import { resolveSessionToolPolicy } from '../tool-capability-policy'
-import { expandToolIds } from '../tool-aliases'
+import { expandPluginIds } from '../tool-aliases'
 import type { ToolContext, SessionToolsResult, ToolBuildContext } from './context'
 
 // Import all tool modules to trigger their builtin registration
@@ -33,6 +33,16 @@ import { buildDiscoveryTools } from './discovery'
 import { buildMonitorTools } from './monitor'
 import { buildSampleUITools } from './sample-ui'
 import { buildPluginCreatorTools } from './plugin-creator'
+import { buildImageGenTools } from './image-gen'
+import { buildEmailTools } from './email'
+import { buildCalendarTools } from './calendar'
+import { buildReplicateTools } from './replicate'
+import { buildMailboxTools } from './mailbox'
+import { buildHumanLoopTools } from './human-loop'
+import { buildDocumentTools } from './document'
+import { buildExtractTools } from './extract'
+import { buildTableTools } from './table'
+import { buildCrawlTools } from './crawl'
 import { normalizeToolInputArgs } from './normalize-tool-args'
 
 import { getPluginManager } from '../plugins'
@@ -41,34 +51,37 @@ import { jsonSchemaToZod } from '../mcp-client'
 export type { ToolContext, SessionToolsResult }
 export { sweepOrphanedBrowsers, cleanupSessionBrowser, getActiveBrowserCount, hasActiveBrowser }
 
-export async function buildSessionTools(cwd: string, enabledTools: string[], ctx?: ToolContext): Promise<SessionToolsResult> {
+export async function buildSessionTools(cwd: string, enabledPlugins: string[], ctx?: ToolContext): Promise<SessionToolsResult> {
   const tools: StructuredToolInterface[] = []
   const cleanupFns: (() => Promise<void>)[] = []
-  
+
   try {
     const runtime = loadRuntimeSettings()
     const commandTimeoutMs = runtime.shellCommandTimeoutMs
     const claudeTimeoutMs = runtime.claudeCodeTimeoutMs
     const cliProcessTimeoutMs = runtime.cliProcessTimeoutMs
     const appSettings = loadSettings()
-    const toolPolicy = resolveSessionToolPolicy(enabledTools, appSettings)
-    const expandedEnabledTools = expandToolIds(toolPolicy.enabledTools)
-    const expandedBlockedTools = expandToolIds(toolPolicy.blockedTools.map((entry) => entry.tool))
-    const blockedToolSet = new Set(expandedBlockedTools)
-    const filteredEnabledTools = expandedEnabledTools.filter((toolId) => !blockedToolSet.has(toolId))
-    const activeTools = filteredEnabledTools.includes('shell')
-      && !filteredEnabledTools.includes('process')
-      && !blockedToolSet.has('process')
-      ? [...filteredEnabledTools, 'process']
-      : filteredEnabledTools
-    const activeToolSet = new Set(activeTools)
-    const hasTool = (toolName: string) => activeToolSet.has(toolName)
+    const toolPolicy = resolveSessionToolPolicy(enabledPlugins, appSettings)
+    const expandedEnabled = expandPluginIds(toolPolicy.enabledPlugins)
+    const expandedBlocked = expandPluginIds(toolPolicy.blockedPlugins.map((entry) => entry.tool))
+    const blockedSet = new Set(expandedBlocked)
+    const filteredEnabled = expandedEnabled.filter((id) => !blockedSet.has(id))
+    const pluginManager = getPluginManager()
+    const activePlugins = (filteredEnabled.includes('shell')
+      && !filteredEnabled.includes('process')
+      && !blockedSet.has('process')
+      ? [...filteredEnabled, 'process']
+      : filteredEnabled).filter(t => pluginManager.isEnabled(t))
+    const activePluginSet = new Set(activePlugins)
+    const hasPlugin = (pluginName: string) => activePluginSet.has(pluginName)
+    /** @deprecated Use hasPlugin */
+    const hasTool = hasPlugin
 
-    if (toolPolicy.blockedTools.length > 0) {
-      log.info('session-tools', 'Capability policy blocked tool families', {
+    if (toolPolicy.blockedPlugins.length > 0) {
+      log.info('session-tools', 'Capability policy blocked plugin families', {
         sessionId: ctx?.sessionId || null,
         agentId: ctx?.agentId || null,
-        blockedTools: toolPolicy.blockedTools.map((entry) => `${entry.tool}:${entry.reason}`),
+        blockedPlugins: toolPolicy.blockedPlugins.map((entry) => `${entry.tool}:${entry.reason}`),
       })
     }
 
@@ -78,14 +91,14 @@ export async function buildSessionTools(cwd: string, enabledTools: string[], ctx
       return sessions[ctx.sessionId] || null
     }
 
-    const readStoredDelegateResumeId = (key: 'claudeCode' | 'codex' | 'opencode'): string | null => {
+    const readStoredDelegateResumeId = (key: 'claudeCode' | 'codex' | 'opencode' | 'gemini'): string | null => {
       const session = resolveCurrentSession()
       if (!session?.delegateResumeIds || typeof session.delegateResumeIds !== 'object') return null
       const raw = session.delegateResumeIds[key]
       return typeof raw === 'string' && raw.trim() ? raw.trim() : null
     }
 
-    const persistDelegateResumeId = (key: 'claudeCode' | 'codex' | 'opencode', resumeId: string | null | undefined): void => {
+    const persistDelegateResumeId = (key: 'claudeCode' | 'codex' | 'opencode' | 'gemini', resumeId: string | null | undefined): void => {
       const normalized = typeof resumeId === 'string' ? resumeId.trim() : ''
       if (!normalized || !ctx?.sessionId) return
       const sessions = loadSessions()
@@ -106,6 +119,7 @@ export async function buildSessionTools(cwd: string, enabledTools: string[], ctx
     const bctx: ToolBuildContext = {
       cwd,
       ctx,
+      hasPlugin,
       hasTool,
       cleanupFns,
       commandTimeoutMs,
@@ -114,41 +128,60 @@ export async function buildSessionTools(cwd: string, enabledTools: string[], ctx
       persistDelegateResumeId,
       readStoredDelegateResumeId,
       resolveCurrentSession,
-      activeTools,
+      activePlugins,
     }
 
     // 1. Build Native Bridge Tools (Legacy enablement)
-    tools.push(
-      ...buildShellTools(bctx),
-      ...buildFileTools(bctx),
-      ...buildEditFileTools(bctx),
-      ...buildDelegateTools(bctx),
-      ...buildWebTools(bctx),
-      ...buildMemoryTools(bctx),
-      ...buildPlatformTools(bctx),
-      ...buildSandboxTools(bctx),
-      ...buildChatroomTools(bctx),
-      ...buildSubagentTools(bctx),
-      ...buildCanvasTools(bctx),
-      ...buildHttpTools(bctx),
-      ...buildGitTools(bctx),
-      ...buildWalletTools(bctx),
-      ...buildOpenClawWorkspaceTools(bctx),
-      ...buildScheduleTools(bctx),
-      ...buildSessionInfoTools(bctx),
-      ...buildOpenClawNodeTools(bctx),
-      ...buildContextTools(bctx),
-      ...buildConnectorTools(bctx),
-      ...buildDiscoveryTools(bctx),
-      ...buildMonitorTools(bctx),
-      ...buildSampleUITools(bctx),
-      ...buildPluginCreatorTools(bctx),
-    )
+    const toolToPluginMap: Record<string, string> = {}
+
+    const nativeBuilders: Array<[string, (ctx: ToolBuildContext) => StructuredToolInterface[]]> = [
+      ['shell', buildShellTools],
+      ['files', buildFileTools],
+      ['edit_file', buildEditFileTools],
+      ['delegate', buildDelegateTools],
+      ['web', buildWebTools],
+      ['memory', buildMemoryTools],
+      ['manage_platform', buildPlatformTools],
+      ['sandbox', buildSandboxTools],
+      ['manage_chatrooms', buildChatroomTools],
+      ['spawn_subagent', buildSubagentTools],
+      ['canvas', buildCanvasTools],
+      ['http', buildHttpTools],
+      ['git', buildGitTools],
+      ['wallet', buildWalletTools],
+      ['openclaw_workspace', buildOpenClawWorkspaceTools],
+      ['schedule', buildScheduleTools],
+      ['manage_sessions', buildSessionInfoTools],
+      ['openclaw_nodes', buildOpenClawNodeTools],
+      ['context_mgmt', buildContextTools],
+      ['manage_connectors', buildConnectorTools],
+      ['discovery', buildDiscoveryTools],
+      ['monitor', buildMonitorTools],
+      ['sample_ui', buildSampleUITools],
+      ['plugin_creator', buildPluginCreatorTools],
+      ['image_gen', buildImageGenTools],
+      ['email', buildEmailTools],
+      ['calendar', buildCalendarTools],
+      ['replicate', buildReplicateTools],
+      ['mailbox', buildMailboxTools],
+      ['ask_human', buildHumanLoopTools],
+      ['document', buildDocumentTools],
+      ['extract', buildExtractTools],
+      ['table', buildTableTools],
+      ['crawl', buildCrawlTools],
+    ]
+
+    for (const [pluginId, builder] of nativeBuilders) {
+      const builtTools = builder(bctx)
+      for (const t of builtTools) {
+        toolToPluginMap[t.name] = pluginId
+      }
+      tools.push(...builtTools)
+    }
 
     // 2. Build Plugin Tools (Built-in + External)
     try {
-      const pluginManager = getPluginManager()
-      const pluginTools = pluginManager.getTools(activeTools)
+      const pluginTools = pluginManager.getTools(activePlugins)
       const existingNames = new Set(tools.map((t) => t.name))
       
       for (const entry of pluginTools) {
@@ -161,6 +194,7 @@ export async function buildSessionTools(cwd: string, enabledTools: string[], ctx
           continue
         }
         existingNames.add(pt.name)
+        toolToPluginMap[pt.name] = entry.pluginId
 
         tools.push(
           tool(
@@ -208,6 +242,7 @@ export async function buildSessionTools(cwd: string, enabledTools: string[], ctx
           const mcpLcTools = await mcpToolsToLangChain(conn.client, config.name)
           for (const t of mcpLcTools) {
             if (!disabledMcpToolNames.has(t.name)) {
+              toolToPluginMap[t.name] = `mcp:${serverId}`
               tools.push(t)
             }
           }
@@ -224,6 +259,7 @@ export async function buildSessionTools(cwd: string, enabledTools: string[], ctx
     }
 
     // 4. Always available: request_tool_access
+    toolToPluginMap['request_tool_access'] = '_system'
     tools.push(
       tool(
         async (args) => {
@@ -248,13 +284,57 @@ export async function buildSessionTools(cwd: string, enabledTools: string[], ctx
       ),
     )
 
+    const buildFallbackHookSession = (): Session => ({
+      id: ctx?.sessionId || 'plugin-hook-session',
+      name: 'Plugin Hook Session',
+      cwd,
+      user: 'system',
+      provider: 'openai',
+      model: 'unknown',
+      claudeSessionId: null,
+      messages: [],
+      createdAt: Date.now(),
+      lastActiveAt: Date.now(),
+      agentId: ctx?.agentId || null,
+      plugins: [...activePlugins],
+    })
+
+    const wrappedTools = tools.map((candidate) => {
+      const schema = (candidate as unknown as { schema?: z.ZodTypeAny }).schema || z.object({}).passthrough()
+      return tool(
+        async (args) => {
+          const normalizedArgs = normalizeToolInputArgs((args ?? {}) as Record<string, unknown>)
+          const nextArgs = await pluginManager.runBeforeToolExec(
+            { toolName: candidate.name, input: normalizedArgs },
+            { enabledIds: activePlugins },
+          )
+          const effectiveArgs = nextArgs ?? normalizedArgs
+          const result = await candidate.invoke(effectiveArgs)
+          const outputText = typeof result === 'string' ? result : JSON.stringify(result)
+          const hookSession = resolveCurrentSession() || buildFallbackHookSession()
+          await pluginManager.runHook(
+            'afterToolExec',
+            { session: hookSession, toolName: candidate.name, input: effectiveArgs, output: outputText },
+            { enabledIds: activePlugins },
+          )
+          return outputText
+        },
+        {
+          name: candidate.name,
+          description: candidate.description,
+          schema,
+        },
+      )
+    })
+
     return {
-      tools,
+      tools: wrappedTools,
       cleanup: async () => {
         for (const fn of cleanupFns) {
           try { await fn() } catch { /* ignore */ }
         }
       },
+      toolToPluginMap,
     }
   } catch (err: any) {
     console.error('[session-tools] buildSessionTools critical failure:', err.message)