@swarmclawai/swarmclaw 0.7.8 → 0.8.0

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

@@ -21,7 +21,7 @@ import {
   decryptKey,
 } from '../storage'
 import { resolveScheduleName } from '@/lib/schedule-name'
-import { findDuplicateSchedule, type ScheduleLike } from '@/lib/schedule-dedupe'
+import { findDuplicateSchedule, findEquivalentSchedules, type ScheduleLike } from '@/lib/schedule-dedupe'
 import { computeTaskFingerprint, findDuplicateTask } from '@/lib/task-dedupe'
 import {
   hasManagedAgentAssignmentInput,
@@ -118,6 +118,95 @@ function deriveTaskTitle(input: { title?: unknown; description?: unknown }): str
   return compact.slice(0, 120)
 }
 
+const VALID_CONNECTOR_PLATFORMS = new Set([
+  'discord',
+  'telegram',
+  'slack',
+  'whatsapp',
+  'openclaw',
+  'bluebubbles',
+  'signal',
+  'teams',
+  'googlechat',
+  'matrix',
+  'email',
+  'webchat',
+  'mockmail',
+])
+
+const VALID_CONNECTOR_STATUSES = new Set(['stopped', 'running', 'error'])
+
+function normalizeConnectorConfig(raw: unknown): Record<string, string> {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return {}
+  const normalized: Record<string, string> = {}
+  for (const [key, value] of Object.entries(raw as Record<string, unknown>)) {
+    const normalizedKey = typeof key === 'string' ? key.trim() : ''
+    if (!normalizedKey) continue
+    if (typeof value === 'string') {
+      normalized[normalizedKey] = value
+      continue
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+      normalized[normalizedKey] = String(value)
+    }
+  }
+  return normalized
+}
+
+function sanitizeConnectorCrudPayload(
+  raw: Record<string, unknown>,
+  options: { forUpdate?: boolean } = {},
+): Record<string, unknown> {
+  const { forUpdate = false } = options
+  const out: Record<string, unknown> = {}
+  const setString = (key: 'name' | 'platform' | 'status') => {
+    if (!Object.prototype.hasOwnProperty.call(raw, key)) return
+    const value = typeof raw[key] === 'string' ? raw[key].trim() : ''
+    if (!value) return
+    if (key === 'platform' && !VALID_CONNECTOR_PLATFORMS.has(value)) return
+    if (key === 'status' && !VALID_CONNECTOR_STATUSES.has(value)) return
+    out[key] = value
+  }
+  const setNullableId = (key: 'agentId' | 'chatroomId' | 'credentialId') => {
+    if (!Object.prototype.hasOwnProperty.call(raw, key)) return
+    const value = typeof raw[key] === 'string' ? raw[key].trim() : ''
+    out[key] = value || null
+  }
+
+  setString('name')
+  setString('platform')
+  setString('status')
+  setNullableId('agentId')
+  setNullableId('chatroomId')
+  setNullableId('credentialId')
+
+  if (Object.prototype.hasOwnProperty.call(raw, 'config')) {
+    out.config = normalizeConnectorConfig(raw.config)
+  }
+
+  if (Object.prototype.hasOwnProperty.call(raw, 'isEnabled')) {
+    out.isEnabled = raw.isEnabled === true
+  } else if (Object.prototype.hasOwnProperty.call(raw, 'enabled')) {
+    out.isEnabled = raw.enabled === true
+  }
+
+  if (!forUpdate) {
+    const platform = typeof out.platform === 'string' ? out.platform : 'discord'
+    return {
+      name: typeof out.name === 'string' && out.name ? out.name : 'Unnamed Connector',
+      platform,
+      agentId: Object.prototype.hasOwnProperty.call(out, 'agentId') ? out.agentId : null,
+      chatroomId: Object.prototype.hasOwnProperty.call(out, 'chatroomId') ? out.chatroomId : null,
+      credentialId: Object.prototype.hasOwnProperty.call(out, 'credentialId') ? out.credentialId : null,
+      config: Object.prototype.hasOwnProperty.call(out, 'config') ? out.config : {},
+      isEnabled: Object.prototype.hasOwnProperty.call(out, 'isEnabled') ? out.isEnabled : false,
+      ...(typeof out.status === 'string' ? { status: out.status } : {}),
+    }
+  }
+
+  return out
+}
+
 const TASK_STATUS_VALUES = new Set([
   'backlog',
   'queued',
@@ -157,6 +246,95 @@ function pickFirstTaskId(value: unknown): string | null {
   return ids[0] || null
 }
 
+function buildScheduleCreatorScope(schedule: Record<string, unknown> | null | undefined): {
+  agentId?: string | null
+  sessionId?: string | null
+} | null {
+  if (!schedule || typeof schedule !== 'object') return null
+  const agentId = typeof schedule.createdByAgentId === 'string' && schedule.createdByAgentId.trim()
+    ? schedule.createdByAgentId.trim()
+    : null
+  const sessionId = typeof schedule.createdInSessionId === 'string' && schedule.createdInSessionId.trim()
+    ? schedule.createdInSessionId.trim()
+    : null
+  if (!agentId && !sessionId) return null
+  return { agentId, sessionId }
+}
+
+function deriveScheduleFollowupTarget(sessionId: string | null | undefined): {
+  followupConnectorId?: string | null
+  followupChannelId?: string | null
+  followupThreadId?: string | null
+  followupSenderId?: string | null
+  followupSenderName?: string | null
+} {
+  const normalizedSessionId = typeof sessionId === 'string' ? sessionId.trim() : ''
+  if (!normalizedSessionId) return {}
+
+  const session = loadSessions()[normalizedSessionId] as {
+    connectorContext?: Record<string, unknown>
+    messages?: Array<Record<string, unknown>>
+  } | undefined
+  if (!session) return {}
+
+  const pickSourceFields = (source: Record<string, unknown> | null | undefined) => {
+    const connectorId = typeof source?.connectorId === 'string' ? source.connectorId.trim() : ''
+    const channelId = typeof source?.channelId === 'string' ? source.channelId.trim() : ''
+    if (!connectorId || !channelId) return {}
+    const threadId = typeof source?.threadId === 'string' ? source.threadId.trim() : ''
+    const senderId = typeof source?.senderId === 'string' ? source.senderId.trim() : ''
+    const senderName = typeof source?.senderName === 'string' ? source.senderName.trim() : ''
+    return {
+      followupConnectorId: connectorId,
+      followupChannelId: channelId,
+      followupThreadId: threadId || null,
+      followupSenderId: senderId || null,
+      followupSenderName: senderName || null,
+    }
+  }
+
+  const contextTarget = pickSourceFields(session.connectorContext || undefined)
+  if (contextTarget.followupConnectorId && contextTarget.followupChannelId) return contextTarget
+
+  const messages = Array.isArray(session.messages) ? session.messages : []
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const message = messages[i]
+    if ((typeof message?.role === 'string' ? message.role : '') !== 'user') continue
+    if (message?.historyExcluded === true) continue
+    const messageTarget = pickSourceFields(message?.source as Record<string, unknown> | undefined)
+    if (messageTarget.followupConnectorId && messageTarget.followupChannelId) return messageTarget
+  }
+
+  return {}
+}
+
+function findRelatedScheduleIds(
+  schedules: Record<string, ScheduleLike>,
+  schedule: Record<string, unknown> | null | undefined,
+  opts: { ignoreId?: string | null } = {},
+): string[] {
+  if (!schedule || typeof schedule !== 'object') return []
+  const scope = buildScheduleCreatorScope(schedule)
+  if (!scope?.sessionId) return []
+  const matches = findEquivalentSchedules(schedules, {
+    id: typeof schedule.id === 'string' ? schedule.id : null,
+    agentId: typeof schedule.agentId === 'string' ? schedule.agentId : null,
+    taskPrompt: typeof schedule.taskPrompt === 'string' ? schedule.taskPrompt : null,
+    scheduleType: typeof schedule.scheduleType === 'string' ? schedule.scheduleType : null,
+    cron: typeof schedule.cron === 'string' ? schedule.cron : null,
+    intervalMs: typeof schedule.intervalMs === 'number' ? schedule.intervalMs : null,
+    runAt: typeof schedule.runAt === 'number' ? schedule.runAt : null,
+    createdByAgentId: scope.agentId,
+    createdInSessionId: scope.sessionId,
+  }, {
+    ignoreId: opts.ignoreId || (typeof schedule.id === 'string' ? schedule.id : null),
+    creatorScope: scope,
+  })
+  return Array.from(new Set(matches
+    .map((entry) => (typeof entry.id === 'string' ? entry.id : ''))
+    .filter(Boolean)))
+}
+
 function applyTaskContinuationDefaults(
   parsed: Record<string, unknown>,
   tasks: Record<string, BoardTask>,
@@ -285,11 +463,7 @@ const RESOURCE_DEFAULTS: Record<string, (parsed: any) => any> = {
     ...p,
   }),
   manage_connectors: (p) => ({
-    name: p.name || 'Unnamed Connector',
-    platform: p.platform || 'discord',
-    agentId: p.agentId || null,
-    enabled: p.enabled ?? false,
-    ...p,
+    ...sanitizeConnectorCrudPayload(p as Record<string, unknown>),
   }),
   manage_webhooks: (p) => ({
     name: p.name || 'Unnamed Webhook',
@@ -391,9 +565,9 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
       description += `\n\nAgents may self-edit their own soul. To update your soul, use action="update", id="${ctx?.agentId || 'your-agent-id'}", and include data with the "soul" field. Set "platformAssignScope":"all" to let an agent delegate work across the fleet; use "self" for solo execution.`
     } else if (toolKey === 'manage_schedules') {
       if (assignScope === 'self') {
-        description += `\n\nOmit "agentId" to assign a schedule to yourself ("${ctx?.agentId || 'unknown'}"), or set it explicitly to yourself. You can only assign schedules to yourself. Schedule types: interval (set intervalMs), cron (set cron), once (set runAt). Provide either taskPrompt, command, or action+path. Before create, call list/get to avoid duplicate schedules. If an equivalent active/paused schedule already exists, create returns that existing schedule (deduplicated=true).`
+        description += `\n\nOmit "agentId" to assign a schedule to yourself ("${ctx?.agentId || 'unknown'}"), or set it explicitly to yourself. You can only assign schedules to yourself. Schedule types: interval (set intervalMs), cron (set cron), once (set runAt). Provide either taskPrompt, command, or action+path. Before create, call list/get to avoid duplicate schedules. Reuse or update an existing schedule you already created in this chat instead of making a near-duplicate. If an equivalent active/paused schedule already exists, create returns that existing schedule (deduplicated=true). For one-off reminders, prefer "once"; agent-created one-off schedules are cleaned up automatically after they finish. When the user says stop/pause/cancel a reminder, pause or delete every matching schedule you created in this chat, not just one row.`
       } else {
-        description += `\n\nOmit "agentId" to assign a schedule to yourself ("${ctx?.agentId || 'unknown'}"), or set "agentId" to another agent when needed. Schedule types: interval (set intervalMs), cron (set cron), once (set runAt). Provide either taskPrompt, command, or action+path. Before create, call list/get to avoid duplicate schedules. If an equivalent active/paused schedule already exists, create returns that existing schedule (deduplicated=true).` + agentSummary
+        description += `\n\nOmit "agentId" to assign a schedule to yourself ("${ctx?.agentId || 'unknown'}"), or set "agentId" to another agent when needed. Schedule types: interval (set intervalMs), cron (set cron), once (set runAt). Provide either taskPrompt, command, or action+path. Before create, call list/get to avoid duplicate schedules. Reuse or update an existing schedule you already created in this chat instead of making a near-duplicate. If an equivalent active/paused schedule already exists, create returns that existing schedule (deduplicated=true). For one-off reminders, prefer "once"; agent-created one-off schedules are cleaned up automatically after they finish. When the user says stop/pause/cancel a reminder, pause or delete every matching schedule you created in this chat, not just one row.` + agentSummary
       }
       if (ctx?.projectId) {
         description += `\n\nCurrent project context: "${ctx.projectName || ctx.projectId}" (projectId "${ctx.projectId}"). Omit "projectId" to use this active project by default.`
@@ -593,11 +767,15 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                 }
               }
               const newId = genId()
+              const scheduleFollowupTarget = toolKey === 'manage_schedules'
+                ? deriveScheduleFollowupTarget(ctx?.sessionId || null)
+                : {}
               const entry = {
                 id: newId,
                 ...parsed,
                 createdByAgentId: ctx?.agentId || null,
                 createdInSessionId: ctx?.sessionId || null,
+                ...scheduleFollowupTarget,
                 createdAt: now,
                 updatedAt: now,
               }
@@ -665,8 +843,12 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
               if (!effectiveId) return 'Error: "id" is required for update action.'
               const all = res.load()
               if (!all[effectiveId]) return `Not found: ${res.label} "${effectiveId}"`
+              const previousEntry = all[effectiveId]
+              let affectedScheduleIds: string[] | null = null
               const parsed = toolKey === 'manage_projects'
                 ? normalizeProjectPatchInput(buildCrudPayload(normalized, action, data))
+                : toolKey === 'manage_connectors'
+                  ? sanitizeConnectorCrudPayload(buildCrudPayload(normalized, action, data), { forUpdate: true })
                 : buildCrudPayload(normalized, action, data)
               const parsedRecord = parsed as Record<string, unknown>
               if (toolKey === 'manage_tasks') {
@@ -734,6 +916,21 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                   ...normalizedSchedule.value,
                   updatedAt: Date.now(),
                 }
+                const nextStatus = typeof all[effectiveId].status === 'string' ? all[effectiveId].status.trim().toLowerCase() : ''
+                if (nextStatus === 'paused' || nextStatus === 'completed' || nextStatus === 'failed') {
+                  const relatedIds = findRelatedScheduleIds(all as Record<string, ScheduleLike>, previousEntry, {
+                    ignoreId: effectiveId,
+                  })
+                  for (const relatedId of relatedIds) {
+                    if (!all[relatedId]) continue
+                    all[relatedId] = {
+                      ...all[relatedId],
+                      status: nextStatus,
+                      updatedAt: Date.now(),
+                    }
+                  }
+                  affectedScheduleIds = [effectiveId, ...relatedIds]
+                }
               }
               if (toolKey === 'manage_secrets') {
                 if (!canAccessSecret(all[effectiveId])) return 'Error: you do not have access to this secret.'
@@ -807,6 +1004,12 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
               if (toolKey === 'manage_projects') {
                 return JSON.stringify(buildProjectSnapshot(all[effectiveId]))
               }
+              if (toolKey === 'manage_schedules' && affectedScheduleIds?.length) {
+                return JSON.stringify({
+                  ...all[effectiveId],
+                  affectedScheduleIds,
+                })
+              }
               return JSON.stringify(all[effectiveId])
             }
             if (action === 'delete') {
@@ -817,7 +1020,12 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
               if (toolKey === 'manage_secrets' && !canAccessSecret(all[effectiveId])) {
                 return 'Error: you do not have access to this secret.'
               }
-              delete all[effectiveId]
+              const deletedIds = toolKey === 'manage_schedules'
+                ? [effectiveId, ...findRelatedScheduleIds(all as Record<string, ScheduleLike>, all[effectiveId], { ignoreId: effectiveId })]
+                : [effectiveId]
+              for (const deleteId of deletedIds) {
+                delete all[deleteId]
+              }
               res.save(all)
               if (toolKey === 'manage_projects') {
                 const clearProjectId = (load: () => Record<string, Record<string, unknown>>, save: (d: Record<string, Record<string, unknown>>) => void) => {
@@ -837,7 +1045,10 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                 clearProjectId(loadSkills, saveSkills)
                 clearProjectId(loadSecrets, saveSecrets)
               }
-              return JSON.stringify({ deleted: effectiveId })
+              return JSON.stringify({
+                deleted: effectiveId,
+                deletedIds,
+              })
             }
             return `Unknown action "${action}". Valid: list, get, create, update, delete`
           } catch (err: any) {

package/src/lib/server/session-tools/delegate-fallback.test.ts

@@ -206,6 +206,109 @@ describe('delegate fallback', () => {
     assert.match(String(output.response || ''), /codex fallback ok/i)
   })
 
+  it('uses nested data.task payloads from recent tool-call wrappers', () => {
+    const output = runWithFakeDelegates(`
+      const mod = await import('./src/lib/server/session-tools/delegate.ts')
+      const { buildDelegateTools } = mod.default || mod['module.exports'] || mod
+
+      const tools = buildDelegateTools({
+        cwd: process.cwd(),
+        ctx: { sessionId: 'session-test', agentId: 'agent-test', platformAssignScope: 'self' },
+        hasPlugin: (name) => name === 'delegate',
+        hasTool: (name) => name === 'delegate',
+        cleanupFns: [],
+        commandTimeoutMs: 5000,
+        claudeTimeoutMs: 5000,
+        cliProcessTimeoutMs: 5000,
+        persistDelegateResumeId: () => {},
+        readStoredDelegateResumeId: () => null,
+        resolveCurrentSession: () => null,
+        activePlugins: ['delegate'],
+      })
+
+      const delegateTool = tools.find((tool) => tool.name === 'delegate')
+      const raw = await delegateTool.invoke({
+        input: JSON.stringify({
+          data: {
+            task: 'Create a simple to-do list application.',
+          },
+        }),
+      })
+      console.log(raw)
+    `)
+
+    assert.equal(output.backend, 'codex')
+    assert.equal(output.status, 'completed')
+    assert.match(String(output.response || ''), /codex fallback ok/i)
+  })
+
+  it('falls back to reason text when malformed delegate wrappers omit task', () => {
+    const output = runWithFakeDelegates(`
+      const mod = await import('./src/lib/server/session-tools/delegate.ts')
+      const { buildDelegateTools } = mod.default || mod['module.exports'] || mod
+
+      const tools = buildDelegateTools({
+        cwd: process.cwd(),
+        ctx: { sessionId: 'session-test', agentId: 'agent-test', platformAssignScope: 'self' },
+        hasPlugin: (name) => name === 'delegate',
+        hasTool: (name) => name === 'delegate',
+        cleanupFns: [],
+        commandTimeoutMs: 5000,
+        claudeTimeoutMs: 5000,
+        cliProcessTimeoutMs: 5000,
+        persistDelegateResumeId: () => {},
+        readStoredDelegateResumeId: () => null,
+        resolveCurrentSession: () => null,
+        activePlugins: ['delegate'],
+      })
+
+      const delegateTool = tools.find((tool) => tool.name === 'delegate')
+      const raw = await delegateTool.invoke({
+        input: JSON.stringify({
+          parameters: {
+            tool_id: 'delegate',
+            reason: 'Building a simple front-end to-do list app is well-suited for a delegated agent.',
+            subagent_tool_id: 'agent_coder',
+            subagent_name: 'Coder',
+          },
+        }),
+      })
+      console.log(raw)
+    `)
+
+    assert.equal(output.backend, 'codex')
+    assert.equal(output.status, 'completed')
+    assert.match(String(output.response || ''), /codex fallback ok/i)
+  })
+
+  it('accepts legacy id fields for lifecycle delegate actions', () => {
+    const output = runWithFakeDelegates(`
+      const mod = await import('./src/lib/server/session-tools/delegate.ts')
+      const { buildDelegateTools } = mod.default || mod['module.exports'] || mod
+
+      const tools = buildDelegateTools({
+        cwd: process.cwd(),
+        ctx: { sessionId: 'session-test', agentId: 'agent-test', platformAssignScope: 'self' },
+        hasPlugin: (name) => name === 'delegate',
+        hasTool: (name) => name === 'delegate',
+        cleanupFns: [],
+        commandTimeoutMs: 5000,
+        claudeTimeoutMs: 5000,
+        cliProcessTimeoutMs: 5000,
+        persistDelegateResumeId: () => {},
+        readStoredDelegateResumeId: () => null,
+        resolveCurrentSession: () => null,
+        activePlugins: ['delegate'],
+      })
+
+      const delegateTool = tools.find((tool) => tool.name === 'delegate')
+      const raw = await delegateTool.invoke({ action: 'status', id: 'job-123' })
+      console.log(JSON.stringify({ raw }))
+    `)
+
+    assert.match(String(output.raw || ''), /delegation job "job-123" not found/i)
+  })
+
   it('ranks authenticated delegate backends ahead of unauthenticated ones', () => {
     const output = runWithFakeDelegates(`
       const mod = await import('./src/lib/server/provider-health.ts')

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

@@ -147,6 +147,41 @@ function coerceDelegateBackend(value: unknown): DelegateBackend | null {
   return null
 }
 
+function asDelegateRecord(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null
+}
+
+function pickNonEmptyDelegateString(...values: unknown[]): string | null {
+  for (const value of values) {
+    if (typeof value !== 'string') continue
+    const trimmed = value.trim()
+    if (!trimmed) continue
+    if ((trimmed.startsWith('{') && trimmed.endsWith('}')) || (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
+      continue
+    }
+    return trimmed
+  }
+  return null
+}
+
+function pickDelegateTaskText(record: Record<string, unknown> | null): string | null {
+  if (!record) return null
+  return pickNonEmptyDelegateString(
+    record.task,
+    record.prompt,
+    record.request,
+    record.instructions,
+    record.instruction,
+    record.description,
+    record.input,
+    record.reason,
+    record.goal,
+    record.objective,
+  )
+}
+
 function buildDelegateTaskFromPayload(normalized: Record<string, unknown>): string | null {
   const action = String(normalized.action || '').trim().toLowerCase()
   const target = [
@@ -200,20 +235,41 @@ function buildDelegateTaskFromPayload(normalized: Record<string, unknown>): stri
 
 function normalizeDelegateArgs(rawArgs: Record<string, unknown>): Record<string, unknown> {
   const normalized = normalizeToolInputArgs(rawArgs)
+  const nestedData = asDelegateRecord(normalized.data)
+  const delegatePayload = {
+    ...(nestedData || {}),
+    ...normalized,
+  }
   const backend = coerceDelegateBackend(
-    normalized.backend
-    ?? normalized.tool_name
-    ?? normalized.toolName
-    ?? normalized.delegate
-    ?? normalized.provider,
+    delegatePayload.backend
+    ?? delegatePayload.tool_name
+    ?? delegatePayload.toolName
+    ?? delegatePayload.tool
+    ?? delegatePayload.delegate
+    ?? delegatePayload.provider
+    ?? delegatePayload.subagent_tool_id
+    ?? delegatePayload.subagent_name,
   )
   if (backend && !normalized.backend) normalized.backend = backend
-  if (typeof normalized.task !== 'string' && typeof normalized.prompt === 'string') normalized.task = normalized.prompt
-  const action = String(normalized.action || '').trim().toLowerCase()
+  if (typeof normalized.task !== 'string' || !normalized.task.trim()) {
+    const directTask = pickDelegateTaskText(delegatePayload) || pickDelegateTaskText(nestedData)
+    if (directTask) normalized.task = directTask
+  }
+  const lifecycleJobId = pickNonEmptyDelegateString(
+    normalized.jobId,
+    normalized.id,
+    nestedData?.jobId,
+    nestedData?.id,
+  )
+  if (lifecycleJobId && (!normalized.jobId || typeof normalized.jobId !== 'string')) {
+    normalized.jobId = lifecycleJobId
+  }
+  const action = String(normalized.action ?? nestedData?.action ?? '').trim().toLowerCase()
   const isLifecycleAction = ['status', 'list', 'wait', 'cancel'].includes(action)
+  if (action) normalized.action = action
   if (!isLifecycleAction) {
     if (typeof normalized.task !== 'string' || !normalized.task.trim()) {
-      const synthesized = buildDelegateTaskFromPayload(normalized)
+      const synthesized = buildDelegateTaskFromPayload(delegatePayload)
       if (synthesized) normalized.task = synthesized
     }
     normalized.action = 'start'

package/src/lib/server/session-tools/discovery-approvals.test.ts

@@ -167,4 +167,146 @@ describe('discovery approval flows', () => {
     assert.equal(output.toolNames.includes('manage_schedules'), true)
     assert.equal(output.toolNames.includes('manage_platform'), false)
   })
+
+  it('session-granted builtins disabled by default still appear in the next turn tool list', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const toolsMod = await import('./src/lib/server/session-tools/index.ts')
+      const storage = storageMod.default || storageMod
+      const toolsApi = toolsMod.default || toolsMod
+
+      const now = Date.now()
+      storage.saveSessions({
+        session_email: {
+          id: 'session_email',
+          name: 'Email Tool Test',
+          cwd: process.env.WORKSPACE_DIR,
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          claudeSessionId: null,
+          messages: [],
+          createdAt: now,
+          lastActiveAt: now,
+          sessionType: 'human',
+          agentId: 'default',
+          plugins: ['email'],
+        },
+      })
+
+      const built = await toolsApi.buildSessionTools(process.env.WORKSPACE_DIR, ['email'], {
+        sessionId: 'session_email',
+        agentId: 'default',
+        platformAssignScope: 'self',
+      })
+      console.log(JSON.stringify({
+        toolNames: built.tools.map((entry) => entry.name).sort(),
+      }))
+    `)
+
+    assert.equal(output.toolNames.includes('email'), true)
+  })
+
+  it('discover reports session-granted builtin tools as available now', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const toolsMod = await import('./src/lib/server/session-tools/index.ts')
+      const storage = storageMod.default || storageMod
+      const toolsApi = toolsMod.default || toolsMod
+
+      const now = Date.now()
+      storage.saveSessions({
+        session_discover_email: {
+          id: 'session_discover_email',
+          name: 'Discovery Email Test',
+          cwd: process.env.WORKSPACE_DIR,
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          claudeSessionId: null,
+          messages: [],
+          createdAt: now,
+          lastActiveAt: now,
+          sessionType: 'human',
+          agentId: 'default',
+          plugins: ['email'],
+        },
+      })
+
+      const built = await toolsApi.buildSessionTools(process.env.WORKSPACE_DIR, ['email'], {
+        sessionId: 'session_discover_email',
+        agentId: 'default',
+        platformAssignScope: 'self',
+      })
+      const tool = built.tools.find((entry) => entry.name === 'manage_capabilities')
+      const raw = await tool.invoke({ action: 'discover', reason: 'Check runtime tool availability.' })
+      const plugins = JSON.parse(raw)
+      const email = plugins.find((entry) => entry.id === 'email')
+      console.log(JSON.stringify({
+        email,
+      }))
+    `)
+
+    assert.equal(output.email.granted, true)
+    assert.equal(output.email.availableNow, true)
+  })
+
+  it('hydrates agent-approved tools into stale connector sessions on the next turn', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const toolsMod = await import('./src/lib/server/session-tools/index.ts')
+      const approvalsMod = await import('./src/lib/server/approvals.ts')
+      const storage = storageMod.default || storageMod
+      const toolsApi = toolsMod.default || toolsMod
+      const approvals = approvalsMod.default || approvalsMod
+
+      const now = Date.now()
+      storage.saveSettings({ approvalsEnabled: true })
+      storage.saveSessions({
+        connector_session: {
+          id: 'connector_session',
+          name: 'Connector Session',
+          cwd: process.env.WORKSPACE_DIR,
+          user: 'connector',
+          provider: 'openai',
+          model: 'gpt-test',
+          claudeSessionId: null,
+          messages: [],
+          createdAt: now,
+          lastActiveAt: now,
+          sessionType: 'human',
+          agentId: 'agent_1',
+          plugins: ['browser'],
+        },
+      })
+
+      const approval = approvals.requestApproval({
+        category: 'tool_access',
+        title: 'Enable connector tool',
+        description: 'Grant connector messaging',
+        data: { toolId: 'connector_message_tool', pluginId: 'connector_message_tool' },
+        agentId: 'agent_1',
+        sessionId: null,
+      })
+      await approvals.submitDecision(approval.id, true)
+
+      const built = await toolsApi.buildSessionTools(process.env.WORKSPACE_DIR, ['browser'], {
+        sessionId: 'connector_session',
+        agentId: 'agent_1',
+        platformAssignScope: 'self',
+      })
+      try {
+        const session = storage.loadSessions().connector_session
+        console.log(JSON.stringify({
+          toolNames: built.tools.map((entry) => entry.name).sort(),
+          plugins: session.plugins || [],
+        }))
+      } finally {
+        await built.cleanup()
+      }
+    `)
+
+    assert.equal(output.toolNames.includes('connector_message_tool'), true)
+    assert.equal(output.plugins.includes('connector_message_tool'), true)
+  })
 })