@swarmclawai/swarmclaw 0.7.1 → 0.7.3

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

@@ -0,0 +1,366 @@
+import { z } from 'zod'
+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 type { ToolBuildContext } from './context'
+
+type CalendarProvider = 'google' | 'outlook'
+
+interface CalendarConfig {
+  provider: CalendarProvider
+  accessToken: string
+  calendarId: string
+  refreshToken: string
+  clientId: string
+  clientSecret: string
+}
+
+function getConfig(): CalendarConfig {
+  const ps = getPluginManager().getPluginSettings('calendar')
+  return {
+    provider: (ps.provider as CalendarProvider) || 'google',
+    accessToken: (ps.accessToken as string) || '',
+    calendarId: (ps.calendarId as string) || 'primary',
+    refreshToken: (ps.refreshToken as string) || '',
+    clientId: (ps.clientId as string) || '',
+    clientSecret: (ps.clientSecret as string) || '',
+  }
+}
+
+/** Try to refresh the Google OAuth access token using the refresh token. */
+async function refreshGoogleToken(cfg: CalendarConfig): Promise<string | null> {
+  if (!cfg.refreshToken || !cfg.clientId || !cfg.clientSecret) return null
+  try {
+    const res = await fetch('https://oauth2.googleapis.com/token', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: new URLSearchParams({
+        grant_type: 'refresh_token',
+        refresh_token: cfg.refreshToken,
+        client_id: cfg.clientId,
+        client_secret: cfg.clientSecret,
+      }),
+      signal: AbortSignal.timeout(10_000),
+    })
+    if (!res.ok) return null
+    const data = await res.json()
+    const newToken = data?.access_token as string | undefined
+    if (newToken) {
+      getPluginManager().setPluginSettings('calendar', { ...cfg, accessToken: newToken })
+    }
+    return newToken || null
+  } catch {
+    return null
+  }
+}
+
+async function googleRequest(method: string, urlPath: string, cfg: CalendarConfig, body?: unknown): Promise<{ ok: boolean; data?: unknown; error?: string }> {
+  let token = cfg.accessToken
+  const baseUrl = 'https://www.googleapis.com/calendar/v3'
+
+  const doFetch = async (t: string) => {
+    const init: RequestInit = {
+      method,
+      headers: { Authorization: `Bearer ${t}`, 'Content-Type': 'application/json' },
+      signal: AbortSignal.timeout(15_000),
+    }
+    if (body && method !== 'GET' && method !== 'DELETE') init.body = JSON.stringify(body)
+    return fetch(`${baseUrl}${urlPath}`, init)
+  }
+
+  let res = await doFetch(token)
+  if (res.status === 401) {
+    const refreshed = await refreshGoogleToken(cfg)
+    if (refreshed) {
+      token = refreshed
+      res = await doFetch(token)
+    }
+  }
+
+  if (!res.ok) {
+    const errText = await res.text().catch(() => '')
+    return { ok: false, error: `Google Calendar ${res.status}: ${errText.slice(0, 300)}` }
+  }
+  if (method === 'DELETE') return { ok: true }
+  const data = await res.json()
+  return { ok: true, data }
+}
+
+async function outlookRequest(method: string, urlPath: string, cfg: CalendarConfig, body?: unknown): Promise<{ ok: boolean; data?: unknown; error?: string }> {
+  const baseUrl = 'https://graph.microsoft.com/v1.0/me'
+  const init: RequestInit = {
+    method,
+    headers: { Authorization: `Bearer ${cfg.accessToken}`, 'Content-Type': 'application/json' },
+    signal: AbortSignal.timeout(15_000),
+  }
+  if (body && method !== 'GET' && method !== 'DELETE') init.body = JSON.stringify(body)
+  const res = await fetch(`${baseUrl}${urlPath}`, init)
+  if (!res.ok) {
+    const errText = await res.text().catch(() => '')
+    return { ok: false, error: `Outlook ${res.status}: ${errText.slice(0, 300)}` }
+  }
+  if (method === 'DELETE') return { ok: true }
+  const data = await res.json()
+  return { ok: true, data }
+}
+
+function formatEvent(e: Record<string, unknown>): Record<string, unknown> {
+  return {
+    id: e.id,
+    summary: e.summary ?? e.subject,
+    start: (e.start as Record<string, unknown>)?.dateTime ?? (e.start as Record<string, unknown>)?.date ?? e.start,
+    end: (e.end as Record<string, unknown>)?.dateTime ?? (e.end as Record<string, unknown>)?.date ?? e.end,
+    location: e.location ?? (e.location as unknown as Record<string, unknown>)?.displayName,
+    description: typeof e.description === 'string' ? e.description.slice(0, 200) : (e.body as Record<string, unknown>)?.content?.toString().slice(0, 200),
+    status: e.status ?? e.showAs,
+    htmlLink: e.htmlLink ?? e.webLink,
+  }
+}
+
+async function executeCalendar(args: Record<string, unknown>): Promise<string> {
+  const normalized = normalizeToolInputArgs(args)
+  const action = String(normalized.action || 'list')
+  const cfg = getConfig()
+
+  if (!cfg.accessToken) {
+    return 'Error: Calendar not configured. Ask the user to add their access token in Plugin Settings > Calendar.'
+  }
+
+  try {
+    switch (action) {
+      case 'list': {
+        const timeMin = String(normalized.timeMin || new Date().toISOString())
+        const timeMax = normalized.timeMax as string | undefined
+        const maxResults = Math.min(Number(normalized.maxResults) || 20, 50)
+
+        if (cfg.provider === 'outlook') {
+          const params = new URLSearchParams({
+            $top: String(maxResults),
+            $orderby: 'start/dateTime',
+            $filter: `start/dateTime ge '${timeMin}'${timeMax ? ` and end/dateTime le '${timeMax}'` : ''}`,
+          })
+          const r = await outlookRequest('GET', `/calendar/events?${params}`, cfg)
+          if (!r.ok) return `Error: ${r.error}`
+          const events = ((r.data as Record<string, unknown>)?.value as Record<string, unknown>[]) ?? []
+          return JSON.stringify(events.map(formatEvent))
+        }
+
+        const params = new URLSearchParams({
+          timeMin,
+          maxResults: String(maxResults),
+          singleEvents: 'true',
+          orderBy: 'startTime',
+        })
+        if (timeMax) params.set('timeMax', timeMax)
+        const r = await googleRequest('GET', `/calendars/${encodeURIComponent(cfg.calendarId)}/events?${params}`, cfg)
+        if (!r.ok) return `Error: ${r.error}`
+        const events = ((r.data as Record<string, unknown>)?.items as Record<string, unknown>[]) ?? []
+        return JSON.stringify(events.map(formatEvent))
+      }
+
+      case 'create': {
+        const summary = String(normalized.summary || normalized.title || '').trim()
+        if (!summary) return 'Error: "summary" (event title) is required.'
+        const start = String(normalized.start || '').trim()
+        const end = String(normalized.end || '').trim()
+        if (!start) return 'Error: "start" (ISO datetime) is required.'
+
+        const description = (normalized.description as string) || ''
+        const location = (normalized.location as string) || ''
+
+        if (cfg.provider === 'outlook') {
+          const body = {
+            subject: summary,
+            body: { contentType: 'text', content: description },
+            start: { dateTime: start, timeZone: 'UTC' },
+            end: { dateTime: end || new Date(new Date(start).getTime() + 3600_000).toISOString(), timeZone: 'UTC' },
+            location: { displayName: location },
+          }
+          const r = await outlookRequest('POST', '/calendar/events', cfg, body)
+          if (!r.ok) return `Error: ${r.error}`
+          return `Event created: ${JSON.stringify(formatEvent(r.data as Record<string, unknown>))}`
+        }
+
+        const body = {
+          summary,
+          description,
+          location,
+          start: { dateTime: start, timeZone: 'UTC' },
+          end: { dateTime: end || new Date(new Date(start).getTime() + 3600_000).toISOString(), timeZone: 'UTC' },
+        }
+        const r = await googleRequest('POST', `/calendars/${encodeURIComponent(cfg.calendarId)}/events`, cfg, body)
+        if (!r.ok) return `Error: ${r.error}`
+        return `Event created: ${JSON.stringify(formatEvent(r.data as Record<string, unknown>))}`
+      }
+
+      case 'update': {
+        const eventId = String(normalized.eventId || normalized.id || '').trim()
+        if (!eventId) return 'Error: "eventId" is required.'
+        const updates: Record<string, unknown> = {}
+        if (normalized.summary) updates.summary = String(normalized.summary)
+        if (normalized.description) updates.description = String(normalized.description)
+        if (normalized.location) updates.location = String(normalized.location)
+        if (normalized.start) updates.start = { dateTime: String(normalized.start), timeZone: 'UTC' }
+        if (normalized.end) updates.end = { dateTime: String(normalized.end), timeZone: 'UTC' }
+
+        if (cfg.provider === 'outlook') {
+          const outlookUpdates: Record<string, unknown> = {}
+          if (normalized.summary) outlookUpdates.subject = String(normalized.summary)
+          if (normalized.description) outlookUpdates.body = { contentType: 'text', content: String(normalized.description) }
+          if (normalized.location) outlookUpdates.location = { displayName: String(normalized.location) }
+          if (normalized.start) outlookUpdates.start = { dateTime: String(normalized.start), timeZone: 'UTC' }
+          if (normalized.end) outlookUpdates.end = { dateTime: String(normalized.end), timeZone: 'UTC' }
+          const r = await outlookRequest('PATCH', `/calendar/events/${eventId}`, cfg, outlookUpdates)
+          if (!r.ok) return `Error: ${r.error}`
+          return `Event updated: ${JSON.stringify(formatEvent(r.data as Record<string, unknown>))}`
+        }
+
+        const r = await googleRequest('PATCH', `/calendars/${encodeURIComponent(cfg.calendarId)}/events/${eventId}`, cfg, updates)
+        if (!r.ok) return `Error: ${r.error}`
+        return `Event updated: ${JSON.stringify(formatEvent(r.data as Record<string, unknown>))}`
+      }
+
+      case 'delete': {
+        const eventId = String(normalized.eventId || normalized.id || '').trim()
+        if (!eventId) return 'Error: "eventId" is required.'
+
+        if (cfg.provider === 'outlook') {
+          const r = await outlookRequest('DELETE', `/calendar/events/${eventId}`, cfg)
+          if (!r.ok) return `Error: ${r.error}`
+          return `Event ${eventId} deleted.`
+        }
+
+        const r = await googleRequest('DELETE', `/calendars/${encodeURIComponent(cfg.calendarId)}/events/${eventId}`, cfg)
+        if (!r.ok) return `Error: ${r.error}`
+        return `Event ${eventId} deleted.`
+      }
+
+      case 'status': {
+        return JSON.stringify({
+          configured: true,
+          provider: cfg.provider,
+          calendarId: cfg.calendarId,
+          hasRefreshToken: !!cfg.refreshToken,
+        })
+      }
+
+      default:
+        return `Error: Unknown action "${action}". Use: list, create, update, delete, status.`
+    }
+  } catch (err: unknown) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
+
+const CalendarPlugin: Plugin = {
+  name: 'Calendar',
+  enabledByDefault: false,
+  description: 'Manage Google Calendar or Outlook calendar events — list, create, update, delete.',
+  hooks: {
+    getCapabilityDescription: () =>
+      'I can manage calendar events using `calendar`: list upcoming events, create new ones, update or delete existing events. Supports Google Calendar and Outlook.',
+  } as PluginHooks,
+  tools: [
+    {
+      name: 'calendar',
+      description: 'Manage calendar events. Actions: list (upcoming events), create (new event), update (modify event), delete (remove event), status (check config).',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: { type: 'string', enum: ['list', 'create', 'update', 'delete', 'status'], description: 'Action to perform' },
+          summary: { type: 'string', description: 'Event title (for create/update)' },
+          description: { type: 'string', description: 'Event description (for create/update)' },
+          location: { type: 'string', description: 'Event location (for create/update)' },
+          start: { type: 'string', description: 'Start datetime in ISO 8601 format (for create/update)' },
+          end: { type: 'string', description: 'End datetime in ISO 8601 format (for create/update). Defaults to 1 hour after start.' },
+          eventId: { type: 'string', description: 'Event ID (for update/delete)' },
+          timeMin: { type: 'string', description: 'List events starting from this ISO datetime (default: now)' },
+          timeMax: { type: 'string', description: 'List events up to this ISO datetime' },
+          maxResults: { type: 'number', description: 'Max events to return (default: 20, max: 50)' },
+        },
+        required: ['action'],
+      },
+      execute: async (args) => executeCalendar(args),
+    },
+  ],
+  ui: {
+    settingsFields: [
+      {
+        key: 'provider',
+        label: 'Calendar Provider',
+        type: 'select',
+        options: [
+          { value: 'google', label: 'Google Calendar' },
+          { value: 'outlook', label: 'Microsoft Outlook' },
+        ],
+        defaultValue: 'google',
+      },
+      {
+        key: 'accessToken',
+        label: 'Access Token',
+        type: 'secret',
+        required: true,
+        placeholder: 'ya29.a0...',
+        help: 'OAuth2 access token for the calendar API. For Google: generate via OAuth2 playground or a service account.',
+      },
+      {
+        key: 'refreshToken',
+        label: 'Refresh Token (Google)',
+        type: 'secret',
+        placeholder: '1//0e...',
+        help: 'Google OAuth2 refresh token. When set, the plugin auto-refreshes expired access tokens.',
+      },
+      {
+        key: 'clientId',
+        label: 'Client ID (Google)',
+        type: 'text',
+        placeholder: '123456789.apps.googleusercontent.com',
+        help: 'Google OAuth2 client ID. Required for token refresh.',
+      },
+      {
+        key: 'clientSecret',
+        label: 'Client Secret (Google)',
+        type: 'secret',
+        placeholder: 'GOCSPX-...',
+        help: 'Google OAuth2 client secret. Required for token refresh.',
+      },
+      {
+        key: 'calendarId',
+        label: 'Calendar ID',
+        type: 'text',
+        defaultValue: 'primary',
+        placeholder: 'primary',
+        help: 'Google Calendar ID (default: "primary"). For Outlook, this is ignored.',
+      },
+    ],
+  },
+}
+
+getPluginManager().registerBuiltin('calendar', CalendarPlugin)
+
+export function buildCalendarTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasPlugin('calendar')) return []
+
+  return [
+    tool(
+      async (args) => executeCalendar(args),
+      {
+        name: 'calendar',
+        description: CalendarPlugin.tools![0].description,
+        schema: z.object({
+          action: z.enum(['list', 'create', 'update', 'delete', 'status']).describe('Action to perform'),
+          summary: z.string().optional().describe('Event title'),
+          description: z.string().optional().describe('Event description'),
+          location: z.string().optional().describe('Event location'),
+          start: z.string().optional().describe('Start datetime (ISO 8601)'),
+          end: z.string().optional().describe('End datetime (ISO 8601)'),
+          eventId: z.string().optional().describe('Event ID (for update/delete)'),
+          timeMin: z.string().optional().describe('List events from this datetime'),
+          timeMax: z.string().optional().describe('List events until this datetime'),
+          maxResults: z.number().optional().describe('Max results (default 20, max 50)'),
+        }),
+      },
+    ),
+  ]
+}

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

@@ -88,7 +88,7 @@ getPluginManager().registerBuiltin('canvas', CanvasPlugin)
  * Legacy Bridge
  */
 export function buildCanvasTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('canvas')) return []
+  if (!bctx.hasPlugin('canvas')) return []
   return [
     tool(
       async (args) => executeCanvasAction(args, { sessionId: bctx.ctx?.sessionId || undefined }),

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

@@ -107,7 +107,9 @@ async function executeChatroomAction(args: Record<string, unknown>, context: { a
 const ChatroomPlugin: Plugin = {
   name: 'Core Chatrooms',
   description: 'Manage SwarmClaw routing rules and multi-agent chatrooms.',
-  hooks: {} as PluginHooks,
+  hooks: {
+    getCapabilityDescription: () => 'I can create and participate in chatrooms (`manage_chatrooms`) for multi-agent collaboration with @mention-based discussions.',
+  } as PluginHooks,
   tools: [
     {
       name: 'manage_chatrooms',
@@ -134,7 +136,7 @@ getPluginManager().registerBuiltin('chatroom', ChatroomPlugin)
  * Legacy Bridge
  */
 export function buildChatroomTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('manage_chatrooms')) return []
+  if (!bctx.hasPlugin('manage_chatrooms')) return []
   return [
     tool(
       async (args) => executeChatroomAction(args, { agentId: bctx.ctx?.agentId }),

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

@@ -60,8 +60,6 @@ function isAutonomousSystemTurn(userText: string): boolean {
   if (!userText) return false
   const text = userText.toUpperCase()
   return text.includes('AGENT_HEARTBEAT_WAKE')
-    || text.includes('SWARM_MAIN_MISSION_TICK')
-    || text.includes('SWARM_MAIN_AUTO_FOLLOWUP')
     || text.includes('SWARM_HEARTBEAT_CHECK')
 }
 
@@ -247,6 +245,9 @@ interface ConnectorActionInput {
   platform?: string
   to?: string
   message?: string
+  messageId?: string
+  targetMessage?: 'last_inbound' | 'last_outbound'
+  emoji?: string
   voiceText?: string
   voiceId?: string
   imageUrl?: string
@@ -255,9 +256,12 @@ interface ConnectorActionInput {
   mimeType?: string
   fileName?: string
   caption?: string
+  replyToMessageId?: string
+  threadId?: string
   delaySec?: number
   followUpMessage?: string
   followUpDelaySec?: number
+  dedupeKey?: string
   approved?: boolean
   ptt?: boolean
 }
@@ -284,13 +288,25 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
     mimeType,
     fileName,
     caption,
+    messageId,
+    targetMessage,
+    emoji,
+    replyToMessageId,
+    threadId,
+    dedupeKey,
     approved,
     ptt,
   } = normalized as ConnectorActionInput
 
   try {
     const actionName = String(action)
-    const { listRunningConnectors, sendConnectorMessage, getConnectorRecentChannelId } = await import('../connectors/manager')
+    const {
+      listRunningConnectors,
+      sendConnectorMessage,
+      getConnectorRecentChannelId,
+      scheduleConnectorFollowUp,
+      performConnectorMessageAction,
+    } = await import('../connectors/manager')
     const running = listRunningConnectors(platform || undefined)
 
     if (actionName === 'list_running' || actionName === 'list_targets') {
@@ -342,6 +358,9 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
       return { selected, connector }
     }
 
+    const currentSession = bctx.resolveCurrentSession?.()
+    const sessionId = bctx.ctx?.sessionId || currentSession?.id || undefined
+
     if (actionName === 'send' || actionName === 'send_voice_note' || actionName === 'schedule_followup') {
       const settings = loadSettings()
       if (settings.safetyRequireApprovalForOutbound === true && approved !== true) {
@@ -363,9 +382,7 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
       let channelId = target.channelId
       if (connector.platform === 'whatsapp') channelId = normalizeWhatsAppTarget(channelId)
 
-      const currentSession = bctx.resolveCurrentSession?.()
       const latestUserTurn = parseLatestUserTurn(currentSession)
-      const sessionId = bctx.ctx?.sessionId || currentSession?.id || 'unknown-session'
       const turnKey = buildConnectorActionKey([sessionId, latestUserTurn.time || 'no-user-turn'])
       const multiOutboundAllowed = userExplicitlyWantsMultipleOutbound(latestUserTurn.text)
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -392,6 +409,9 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
         const sent = await sendConnectorMessage({
           connectorId: selected.id, channelId, text: '', mediaPath: voicePath, mimeType: 'audio/mpeg',
           fileName: fileName?.trim() || 'voicenote.mp3', caption: caption?.trim() || undefined, ptt: ptt ?? true,
+          sessionId,
+          replyToMessageId: replyToMessageId?.trim() || undefined,
+          threadId: threadId?.trim() || undefined,
         })
         const result = JSON.stringify({ status: 'voice_sent', connectorId: sent.connectorId, platform: sent.platform, to: sent.channelId, voiceFile: voicePath })
         connectorTurnSendBudget.set(turnKey, { count: (existingBudget?.count || 0) + 1, at: now, lastResult: result })
@@ -405,11 +425,54 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
         return 'Error: message or media required.'
       }
 
+      if (actionName === 'schedule_followup') {
+        const followupText = (normalized.followUpMessage as string | undefined)?.trim() || message?.trim() || ''
+        if (!followupText && !media.mediaPath && !media.imageUrl && !media.fileUrl) {
+          return 'Error: follow-up message or media required.'
+        }
+        const followupDelay = (() => {
+          const direct = Number(normalized.followUpDelaySec)
+          if (Number.isFinite(direct) && direct >= 0) return direct
+          const fallback = Number(normalized.delaySec)
+          if (Number.isFinite(fallback) && fallback >= 0) return fallback
+          return 300
+        })()
+        const scheduled = scheduleConnectorFollowUp({
+          connectorId: selected.id,
+          channelId,
+          text: followupText,
+          sessionId,
+          delaySec: followupDelay,
+          dedupeKey: dedupeKey?.trim() || undefined,
+          imageUrl: media.imageUrl,
+          fileUrl: media.fileUrl,
+          mediaPath: media.mediaPath,
+          mimeType: mimeType?.trim() || undefined,
+          fileName: fileName?.trim() || undefined,
+          caption: caption?.trim() || undefined,
+          replyToMessageId: replyToMessageId?.trim() || undefined,
+          threadId: threadId?.trim() || undefined,
+          ptt: ptt ?? undefined,
+        })
+        return JSON.stringify({
+          status: 'scheduled',
+          connectorId: selected.id,
+          platform: selected.platform,
+          to: channelId,
+          followUpId: scheduled.followUpId,
+          sendAt: scheduled.sendAt,
+        })
+      }
+
       const sent = await sendConnectorMessage({
         connectorId: selected.id, channelId, text: message?.trim() || '',
+        sessionId,
         imageUrl: media.imageUrl, fileUrl: media.fileUrl, mediaPath: media.mediaPath,
         mimeType: mimeType?.trim() || undefined, fileName: fileName?.trim() || undefined,
-        caption: caption?.trim() || undefined, ptt: ptt ?? undefined,
+        caption: caption?.trim() || undefined,
+        replyToMessageId: replyToMessageId?.trim() || undefined,
+        threadId: threadId?.trim() || undefined,
+        ptt: ptt ?? undefined,
       })
 
       const result = JSON.stringify({ status: 'sent', connectorId: sent.connectorId, platform: sent.platform, to: sent.channelId, messageId: sent.messageId || null })
@@ -417,6 +480,35 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
       return result
     }
 
+    if (actionName === 'react' || actionName === 'edit' || actionName === 'delete' || actionName === 'pin') {
+      const resolved = resolveSelectedConnector()
+      if ('error' in resolved) return resolved.error
+      const { selected } = resolved
+      const target = pickChannelTarget({
+        connector: resolved.connector,
+        to,
+        recentChannelId: getConnectorRecentChannelId(selected.id),
+      })
+      if (target.error) return target.error
+      const result = await performConnectorMessageAction({
+        connectorId: selected.id,
+        channelId: selected.platform === 'whatsapp' ? normalizeWhatsAppTarget(target.channelId) : target.channelId,
+        action: actionName,
+        messageId: messageId?.trim() || undefined,
+        emoji: emoji?.trim() || undefined,
+        text: message?.trim() || undefined,
+        sessionId,
+        targetMessage,
+      })
+      return JSON.stringify({
+        status: actionName,
+        connectorId: result.connectorId,
+        platform: result.platform,
+        to: result.channelId,
+        messageId: result.messageId || null,
+      })
+    }
+
     return 'Unknown action.'
   } catch (err: unknown) {
     return `Error: ${err instanceof Error ? err.message : String(err)}`
@@ -429,7 +521,10 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
 const ConnectorPlugin: Plugin = {
   name: 'Core Connectors',
   description: 'Manage and send messages through chat platform connectors (WhatsApp, Telegram, Slack, etc.).',
-  hooks: {} as PluginHooks,
+  hooks: {
+    getCapabilityDescription: () => 'I can manage messaging channels (`manage_connectors`) — WhatsApp, Telegram, Slack, Discord — and send proactive messages via `connector_message_tool`.',
+    getOperatingGuidance: () => 'Connectors: proactive outreach for significant events only. Keep messages concise, no duplicates.',
+  } as PluginHooks,
   tools: [
     {
       name: 'connector_message_tool',
@@ -437,11 +532,20 @@ const ConnectorPlugin: Plugin = {
       parameters: {
         type: 'object',
         properties: {
-          action: { type: 'string', enum: ['list_running', 'start', 'stop', 'send', 'send_voice_note'] },
+          action: { type: 'string', enum: ['list_running', 'start', 'stop', 'send', 'send_voice_note', 'schedule_followup', 'react', 'edit', 'delete', 'pin'] },
           connectorId: { type: 'string' },
           platform: { type: 'string' },
           to: { type: 'string' },
-          message: { type: 'string' }
+          message: { type: 'string' },
+          messageId: { type: 'string' },
+          targetMessage: { type: 'string', enum: ['last_inbound', 'last_outbound'] },
+          emoji: { type: 'string' },
+          replyToMessageId: { type: 'string' },
+          threadId: { type: 'string' },
+          delaySec: { type: 'number' },
+          followUpMessage: { type: 'string' },
+          followUpDelaySec: { type: 'number' },
+          dedupeKey: { type: 'string' },
         },
         required: ['action']
       },
@@ -456,7 +560,7 @@ getPluginManager().registerBuiltin('connectors', ConnectorPlugin)
  * Legacy Bridge
  */
 export function buildConnectorTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('manage_connectors')) return []
+  if (!bctx.hasPlugin('manage_connectors')) return []
   return [
     tool(
       async (args) => executeConnectorAction(args as ConnectorActionInput, bctx),

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

@@ -14,25 +14,41 @@ export interface ToolContext {
 export interface SessionToolsResult {
   tools: StructuredToolInterface[]
   cleanup: () => Promise<void>
+  /** Maps tool name → plugin ID for attribution in usage tracking */
+  toolToPluginMap: Record<string, string>
 }
 
 export interface ToolBuildContext {
   cwd: string
   ctx: ToolContext | undefined
+  hasPlugin: (name: string) => boolean
+  /** @deprecated Use hasPlugin */
   hasTool: (name: string) => boolean
   cleanupFns: (() => Promise<void>)[]
   commandTimeoutMs: number
   claudeTimeoutMs: number
   cliProcessTimeoutMs: number
-  persistDelegateResumeId: (key: 'claudeCode' | 'codex' | 'opencode', id: string | null | undefined) => void
-  readStoredDelegateResumeId: (key: 'claudeCode' | 'codex' | 'opencode') => string | null
+  persistDelegateResumeId: (key: 'claudeCode' | 'codex' | 'opencode' | 'gemini', id: string | null | undefined) => void
+  readStoredDelegateResumeId: (key: 'claudeCode' | 'codex' | 'opencode' | 'gemini') => string | null
   resolveCurrentSession: () => any | null
-  activeTools: string[]
+  activePlugins: string[]
+}
+
+function normalizeWorkspaceAlias(cwd: string, filePath: string): string {
+  const trimmed = filePath.trim()
+  if (!trimmed) return trimmed
+  if (trimmed === '/workspace' || trimmed === 'workspace') return cwd
+  if (trimmed.startsWith('/workspace/')) return trimmed.slice('/workspace/'.length)
+  if (trimmed.startsWith('workspace/')) return trimmed.slice('workspace/'.length)
+  return trimmed
 }
 
 export function safePath(cwd: string, filePath: string): string {
-  const resolved = require('path').resolve(cwd, filePath)
-  if (!resolved.startsWith(require('path').resolve(cwd))) {
+  const path = require('path')
+  const normalized = normalizeWorkspaceAlias(cwd, filePath)
+  const resolvedRoot = path.resolve(cwd)
+  const resolved = path.resolve(resolvedRoot, normalized)
+  if (!resolved.startsWith(resolvedRoot)) {
     throw new Error('Path traversal not allowed')
   }
   return resolved