@swarmclawai/swarmclaw 1.2.1 → 1.2.3

package/src/lib/server/agents/agent-repository.ts

@@ -0,0 +1,90 @@
+import type { Agent } from '@/types'
+
+import {
+  deleteAgent as deleteStoredAgent,
+  loadAgent as loadStoredAgent,
+  loadAgents as loadStoredAgents,
+  loadTrashedAgents as loadStoredTrashedAgents,
+  patchAgent as patchStoredAgent,
+  saveAgents as saveStoredAgents,
+  upsertAgent as upsertStoredAgent,
+} from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+
+type AgentRepositoryOptions = { includeTrashed?: boolean }
+
+export const agentRepository = createRecordRepository<Agent, AgentRepositoryOptions>(
+  'agents',
+  {
+    get(id, options) {
+      return loadStoredAgent(id, options) as Agent | null
+    },
+    list(options) {
+      return loadStoredAgents(options) as Record<string, Agent>
+    },
+    upsert(id, value) {
+      upsertStoredAgent(id, value)
+    },
+    replace(data) {
+      saveStoredAgents(data)
+    },
+    patch(id, updater) {
+      return patchStoredAgent(id, updater as (current: Agent | null) => Agent | null) as Agent | null
+    },
+    delete(id) {
+      deleteStoredAgent(id)
+    },
+  },
+)
+
+export function getAgent(id: string, options?: AgentRepositoryOptions): Agent | null {
+  return agentRepository.get(id, options)
+}
+
+export function getAgents(ids: string[], options?: AgentRepositoryOptions): Record<string, Agent> {
+  return agentRepository.getMany(ids, options)
+}
+
+export function listAgents(options?: AgentRepositoryOptions): Record<string, Agent> {
+  return agentRepository.list(options)
+}
+
+export function saveAgent(id: string, agent: Agent | Record<string, unknown>): void {
+  agentRepository.upsert(id, agent as Agent)
+}
+
+export function saveAgentMany(entries: Array<[string, Agent | Record<string, unknown>]>): void {
+  agentRepository.upsertMany(entries as Array<[string, Agent]>)
+}
+
+export function replaceAgents(agents: Record<string, Agent | Record<string, unknown>>): void {
+  agentRepository.replace(agents as Record<string, Agent>)
+}
+
+export function patchAgent(id: string, updater: (current: Agent | null) => Agent | null): Agent | null {
+  return agentRepository.patch(id, updater)
+}
+
+export function deleteAgent(id: string): void {
+  agentRepository.delete(id)
+}
+
+export function loadAgents(options?: AgentRepositoryOptions): Record<string, Agent> {
+  return listAgents(options)
+}
+
+export function loadAgent(id: string, options?: AgentRepositoryOptions): Agent | null {
+  return getAgent(id, options)
+}
+
+export function saveAgents(agents: Record<string, Agent | Record<string, unknown>>): void {
+  replaceAgents(agents)
+}
+
+export function upsertAgent(id: string, agent: Agent | Record<string, unknown>): void {
+  saveAgent(id, agent)
+}
+
+export function loadTrashedAgents(): Record<string, Agent> {
+  return loadStoredTrashedAgents() as Record<string, Agent>
+}

package/src/lib/server/agents/delegation-job-repository.ts

@@ -0,0 +1,53 @@
+import type { DelegationJobRecord } from '@/types'
+
+import {
+  deleteDelegationJob as deleteStoredDelegationJob,
+  loadDelegationJobItem as loadStoredDelegationJob,
+  loadDelegationJobs as loadStoredDelegationJobs,
+  patchDelegationJob as patchStoredDelegationJob,
+  upsertDelegationJob as upsertStoredDelegationJob,
+} from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+
+export const delegationJobRepository = createRecordRepository<DelegationJobRecord>(
+  'delegation-jobs',
+  {
+    get(id) {
+      return loadStoredDelegationJob(id) as DelegationJobRecord | null
+    },
+    list() {
+      return loadStoredDelegationJobs() as Record<string, DelegationJobRecord>
+    },
+    upsert(id, value) {
+      upsertStoredDelegationJob(id, value as DelegationJobRecord)
+    },
+    patch(id, updater) {
+      return patchStoredDelegationJob(
+        id,
+        updater as (current: DelegationJobRecord | null) => DelegationJobRecord | null,
+      ) as DelegationJobRecord | null
+    },
+    delete(id) {
+      deleteStoredDelegationJob(id)
+    },
+  },
+)
+
+export const getDelegationJobRecord = (id: string) => delegationJobRepository.get(id)
+export const getDelegationJobRecords = (ids: string[]) => delegationJobRepository.getMany(ids)
+export const listDelegationJobRecords = () => delegationJobRepository.list()
+export const saveDelegationJobRecord = (id: string, value: DelegationJobRecord | Record<string, unknown>) =>
+  delegationJobRepository.upsert(id, value as DelegationJobRecord)
+export const saveDelegationJobRecords = (entries: Array<[string, DelegationJobRecord | Record<string, unknown>]>) =>
+  delegationJobRepository.upsertMany(entries as Array<[string, DelegationJobRecord]>)
+export const patchDelegationJobRecord = (
+  id: string,
+  updater: (current: DelegationJobRecord | null) => DelegationJobRecord | null,
+) => delegationJobRepository.patch(id, updater)
+export const deleteDelegationJobRecord = (id: string) => delegationJobRepository.delete(id)
+
+export const loadDelegationJobs = listDelegationJobRecords
+export const loadDelegationJob = getDelegationJobRecord
+export const upsertDelegationJob = saveDelegationJobRecord
+export const patchDelegationJob = patchDelegationJobRecord
+export const deleteDelegationJob = deleteDelegationJobRecord

package/src/lib/server/agents/delegation-jobs.ts

@@ -1,13 +1,20 @@
 import { genId } from '@/lib/id'
 import { hmrSingleton } from '@/lib/shared-utils'
 import type { DelegationJobArtifact, DelegationJobCheckpoint, DelegationJobRecord, DelegationJobStatus } from '@/types'
-import { loadDelegationJobs, loadDelegationJobItem, loadSession, logActivity, patchDelegationJob, upsertDelegationJob } from '@/lib/server/storage'
+import {
+  loadDelegationJob,
+  loadDelegationJobs,
+  patchDelegationJob,
+  upsertDelegationJob,
+} from '@/lib/server/agents/delegation-job-repository'
+import { logActivity } from '@/lib/server/activity/activity-log'
 import { logExecution } from '@/lib/server/execution-log'
 import { log } from '@/lib/server/logger'
 import { debug } from '@/lib/server/debug'
 import { createNotification } from '@/lib/server/create-notification'
 import { enqueueSystemEvent } from '@/lib/server/runtime/system-events'
 import { ensureDelegationMission, syncDelegationMissionFromJob } from '@/lib/server/missions/mission-service'
+import { loadSession } from '@/lib/server/sessions/session-repository'
 import { notify } from '@/lib/server/ws-hub'
 
 interface DelegationRuntimeHandle {
@@ -115,7 +122,7 @@ export function createDelegationJob(input: CreateDelegationJobInput): Delegation
 }
 
 export function getDelegationJob(id: string): DelegationJobRecord | null {
-  const current = loadDelegationJobItem(id)
+  const current = loadDelegationJob(id)
   if (!current || typeof current !== 'object') return null
   return current as DelegationJobRecord
 }
@@ -144,9 +151,9 @@ export function updateDelegationJob(
     }
   })
   if (!result) return null
-  const synced = syncDelegationMissionFromJob(id) || result
+  syncDelegationMissionFromJob(id)
   notifyDelegationJobsChanged()
-  return getDelegationJob(id) || synced
+  return getDelegationJob(id) || result
 }
 
 export function appendDelegationCheckpoint(

package/src/lib/server/agents/guardian-checkpoint-repository.ts

@@ -0,0 +1,35 @@
+import type { GuardianCheckpoint } from '@/types'
+
+import {
+  loadGuardianCheckpoints as loadStoredGuardianCheckpoints,
+  patchGuardianCheckpoint as patchStoredGuardianCheckpoint,
+  upsertGuardianCheckpoint as upsertStoredGuardianCheckpoint,
+} from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+
+export const guardianCheckpointRepository = createRecordRepository<GuardianCheckpoint>(
+  'guardian-checkpoints',
+  {
+    get(id) {
+      return loadStoredGuardianCheckpoints()[id] || null
+    },
+    list() {
+      return loadStoredGuardianCheckpoints()
+    },
+    upsert(id, value) {
+      upsertStoredGuardianCheckpoint(id, value as GuardianCheckpoint)
+    },
+    patch(id, updater) {
+      return patchStoredGuardianCheckpoint(id, updater)
+    },
+  },
+)
+
+export const loadGuardianCheckpoints = () => guardianCheckpointRepository.list()
+export const loadGuardianCheckpoint = (id: string) => guardianCheckpointRepository.get(id)
+export const upsertGuardianCheckpoint = (id: string, value: GuardianCheckpoint | Record<string, unknown>) =>
+  guardianCheckpointRepository.upsert(id, value as GuardianCheckpoint)
+export const patchGuardianCheckpoint = (
+  id: string,
+  updater: (current: GuardianCheckpoint | null) => GuardianCheckpoint | null,
+) => guardianCheckpointRepository.patch(id, updater)

package/src/lib/server/agents/guardian.ts

@@ -1,12 +1,12 @@
 import { execSync } from 'node:child_process'
 import path from 'node:path'
 import type { ApprovalRequest, GuardianCheckpoint } from '@/types'
+import { loadApprovals } from '@/lib/server/approvals/approval-repository'
 import {
-  loadApprovals,
   loadGuardianCheckpoints,
   patchGuardianCheckpoint,
   upsertGuardianCheckpoint,
-} from '@/lib/server/storage'
+} from '@/lib/server/agents/guardian-checkpoint-repository'
 import { requestApproval } from '@/lib/server/approvals'
 import { errorMessage } from '@/lib/shared-utils'
 import { genId } from '@/lib/id'

package/src/lib/server/agents/main-agent-loop.ts

@@ -1,10 +1,17 @@
 import { hmrSingleton } from '@/lib/shared-utils'
 import type { GoalContract, Message, MessageToolEvent, Session } from '@/types'
 import { mergeGoalContracts, parseGoalContractFromText, parseMainLoopPlan, parseMainLoopReview } from '@/lib/server/agents/autonomy-contract'
+import {
+  deletePersistedMainLoopState,
+  loadPersistedMainLoopState,
+  upsertPersistedMainLoopState,
+} from '@/lib/server/agents/main-loop-state-repository'
+import { loadAgents } from '@/lib/server/agents/agent-repository'
 import { assessAutonomyRun } from '@/lib/server/autonomy/supervisor-reflection'
 import { enqueueSystemEvent } from '@/lib/server/runtime/system-events'
-import { loadAgents, loadSessions, loadSettings, loadPersistedMainLoopState, upsertPersistedMainLoopState, deletePersistedMainLoopState } from '@/lib/server/storage'
 import { buildMissionHeartbeatPrompt as buildMissionHeartbeatPromptFromMission, getMissionForSession } from '@/lib/server/missions/mission-service'
+import { loadSettings } from '@/lib/server/settings/settings-repository'
+import { getSession, loadSessions } from '@/lib/server/sessions/session-repository'
 
 const LEGACY_META_LINE_RE = /\[(?:MAIN_LOOP_META|MAIN_LOOP_PLAN|MAIN_LOOP_REVIEW|AGENT_HEARTBEAT_META)\]\s*(\{[^\n]*\})?/i
 const HEARTBEAT_META_RE = /\[AGENT_HEARTBEAT_META\]\s*(\{[^\n]*\})/i
@@ -437,7 +444,7 @@ function hydrateStateFromSession(sessionId: string): MainLoopState | null {
 }
 
 function persistState(sessionId: string, state: MainLoopState): void {
-  upsertPersistedMainLoopState(sessionId, state as unknown)
+  upsertPersistedMainLoopState(sessionId, state as unknown as Record<string, unknown>)
 }
 
 function getOrCreateState(sessionId: string): MainLoopState | null {
@@ -738,7 +745,7 @@ export function isMainSession(session: unknown): boolean {
 export function buildMainLoopHeartbeatPrompt(session: unknown, fallbackPrompt: string): string {
   const candidate = asSession(session)
   if (!candidate?.id) return fallbackPrompt
-  const persistedSession = loadSessions()[String(candidate.id)] as Session | undefined
+  const persistedSession = getSession(String(candidate.id)) as Session | undefined
   const missionPrompt = buildMissionHeartbeatPromptFromMission(
     persistedSession || candidate as Session,
     fallbackPrompt,

package/src/lib/server/agents/main-loop-state-repository.ts

@@ -0,0 +1,38 @@
+import { perf } from '@/lib/server/runtime/perf'
+import {
+  deletePersistedMainLoopState as deleteStoredMainLoopState,
+  loadPersistedMainLoopState as loadStoredMainLoopState,
+  upsertPersistedMainLoopState as upsertStoredMainLoopState,
+} from '@/lib/server/storage'
+
+export type PersistedMainLoopState = Record<string, unknown>
+
+export function loadPersistedMainLoopState(sessionId: string): PersistedMainLoopState | null {
+  return perf.measureSync(
+    'repository',
+    'main-loop-state.get',
+    () => loadStoredMainLoopState(sessionId) as PersistedMainLoopState | null,
+    { sessionId },
+  )
+}
+
+export function upsertPersistedMainLoopState(
+  sessionId: string,
+  value: PersistedMainLoopState,
+): void {
+  perf.measureSync(
+    'repository',
+    'main-loop-state.upsert',
+    () => upsertStoredMainLoopState(sessionId, value),
+    { sessionId },
+  )
+}
+
+export function deletePersistedMainLoopState(sessionId: string): void {
+  perf.measureSync(
+    'repository',
+    'main-loop-state.delete',
+    () => deleteStoredMainLoopState(sessionId),
+    { sessionId },
+  )
+}

package/src/lib/server/agents/subagent-runtime.ts

@@ -8,7 +8,7 @@
 
 import { genId } from '@/lib/id'
 import { DEFAULT_DELEGATION_MAX_DEPTH } from '@/lib/runtime/runtime-loop'
-import { loadAgents, loadSessions, saveSessions } from '@/lib/server/storage'
+import { loadAgents } from '@/lib/server/agents/agent-repository'
 import { enqueueSessionRun, type EnqueueSessionRunResult } from '@/lib/server/runtime/session-run-manager'
 import { loadRuntimeSettings } from '@/lib/server/runtime/runtime-settings'
 import { applyResolvedRoute, resolvePrimaryAgentRoute } from '@/lib/server/agents/agent-runtime-config'
@@ -48,6 +48,7 @@ import { debug } from '@/lib/server/debug'
 import { logExecution } from '@/lib/server/execution-log'
 import { enqueueSystemEvent } from '@/lib/server/runtime/system-events'
 import { getEnabledCapabilityIds, splitCapabilityIds } from '@/lib/capability-selection'
+import { getSession, loadSessions, saveSession } from '@/lib/server/sessions/session-repository'
 
 // ---------------------------------------------------------------------------
 // Types
@@ -276,7 +277,7 @@ async function spawnSubagentImpl(
     browserProfileId,
   }
   sessions[sid] = applyResolvedRoute(nextSession, resolvePrimaryAgentRoute(agent))
-  saveSessions(sessions)
+  saveSession(sid, sessions[sid])
 
   log.info('subagent', 'Spawning', { agentId: agent.id, agentName: agent.name, depth: depth + 1, jobId: job.id, sessionId: sid })
   logExecution(sid, 'delegation_start', `Subagent spawning: ${agent.name}`, {
@@ -398,12 +399,13 @@ async function spawnSubagentImpl(
           `subagent:${job.id}`,
         )
       }
+      const completedSession = getSession(sid)
       await runCapabilityHook(
         'sessionEnd',
         {
           sessionId: sid,
-          session: loadSessions()[sid] || null,
-          messageCount: Array.isArray(loadSessions()[sid]?.messages) ? loadSessions()[sid].messages.length : 0,
+          session: completedSession,
+          messageCount: Array.isArray(completedSession?.messages) ? completedSession.messages.length : 0,
           durationMs: subagentResult.durationMs,
           reason: subagentResult.status,
         },
@@ -460,12 +462,13 @@ async function spawnSubagentImpl(
           `subagent:${job.id}`,
         )
       }
+      const failedSession = getSession(sid)
       await runCapabilityHook(
         'sessionEnd',
         {
           sessionId: sid,
-          session: loadSessions()[sid] || null,
-          messageCount: Array.isArray(loadSessions()[sid]?.messages) ? loadSessions()[sid].messages.length : 0,
+          session: failedSession,
+          messageCount: Array.isArray(failedSession?.messages) ? failedSession.messages.length : 0,
           durationMs: subagentResult.durationMs,
           reason: subagentResult.status,
         },

package/src/lib/server/agents/subagent-swarm.ts

@@ -13,22 +13,23 @@ import { genId } from '@/lib/id'
 import { errorMessage, hmrSingleton, sleep } from '@/lib/shared-utils'
 import { log } from '@/lib/server/logger'
 import { logExecution } from '@/lib/server/execution-log'
-import { logActivity } from '@/lib/server/storage'
+import { logActivity } from '@/lib/server/activity/activity-log'
 import { createNotification } from '@/lib/server/create-notification'
 import { notify } from '@/lib/server/ws-hub'
+import { loadAgents } from '@/lib/server/agents/agent-repository'
 import {
   spawnSubagent,
   type SubagentContext,
   type SubagentHandle,
   type SubagentResult,
 } from '@/lib/server/agents/subagent-runtime'
-import { loadAgents, loadSessions } from '@/lib/server/storage'
 import { getDelegationJob } from '@/lib/server/agents/delegation-jobs'
 import {
   getLineageNode,
   cancelLineageNode,
   type SubagentState,
 } from '@/lib/server/agents/subagent-lineage'
+import { loadSessions } from '@/lib/server/sessions/session-repository'
 import type { Agent } from '@/types'
 
 // ---------------------------------------------------------------------------

package/src/lib/server/agents/task-session.ts

@@ -1,9 +1,9 @@
 import { genId } from '@/lib/id'
-import { loadSessions, saveSessions } from '@/lib/server/storage'
 import { WORKSPACE_DIR } from '@/lib/server/data-dir'
 import type { Agent } from '@/types'
 import { getEnabledCapabilitySelection } from '@/lib/capability-selection'
 import { applyResolvedRoute, resolvePrimaryAgentRoute } from '@/lib/server/agents/agent-runtime-config'
+import { saveSession } from '@/lib/server/sessions/session-repository'
 
 export function createAgentTaskSession(
   agent: Agent,
@@ -15,7 +15,6 @@ export function createAgentTaskSession(
     preferredGatewayUseCase?: string | null
   } | null,
 ): string {
-  const sessions = loadSessions()
   const sessionId = genId()
   const preferredGatewayTags = Array.isArray(routePreferences?.preferredGatewayTags)
     ? routePreferences.preferredGatewayTags.filter((tag) => typeof tag === 'string' && tag.trim())
@@ -25,7 +24,7 @@ export function createAgentTaskSession(
     preferredGatewayUseCase: routePreferences?.preferredGatewayUseCase || null,
   })
 
-  sessions[sessionId] = applyResolvedRoute({
+  const session = applyResolvedRoute({
     id: sessionId,
     name: `[Task] ${agent.name}: ${task.slice(0, 40)}`,
     cwd: cwd || WORKSPACE_DIR,
@@ -57,6 +56,6 @@ export function createAgentTaskSession(
     heartbeatEnabled: false,
   }, resolvedRoute)
 
-  saveSessions(sessions)
+  saveSession(sessionId, session)
   return sessionId
 }

package/src/lib/server/approvals/approval-repository.ts

@@ -0,0 +1,30 @@
+import {
+  deleteApproval as deleteStoredApproval,
+  loadApprovals as loadStoredApprovals,
+  upsertApproval as upsertStoredApproval,
+} from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+import type { ApprovalRequest } from '@/types'
+
+export const approvalRepository = createRecordRepository<ApprovalRequest>(
+  'approvals',
+  {
+    get(id) {
+      return loadStoredApprovals()[id] || null
+    },
+    list() {
+      return loadStoredApprovals() as Record<string, ApprovalRequest>
+    },
+    upsert(id, value) {
+      upsertStoredApproval(id, value)
+    },
+    delete(id) {
+      deleteStoredApproval(id)
+    },
+  },
+)
+
+export const loadApprovals = () => approvalRepository.list()
+export const loadApproval = (id: string) => approvalRepository.get(id)
+export const upsertApproval = (id: string, value: ApprovalRequest | Record<string, unknown>) => approvalRepository.upsert(id, value as ApprovalRequest)
+export const deleteApproval = (id: string) => approvalRepository.delete(id)

package/src/lib/server/autonomy/supervisor-incident-repository.ts

@@ -0,0 +1,42 @@
+import type { SupervisorIncident } from '@/types'
+
+import {
+  loadSupervisorIncident as loadStoredSupervisorIncident,
+  loadSupervisorIncidents as loadStoredSupervisorIncidents,
+  saveSupervisorIncidents as saveStoredSupervisorIncidents,
+  upsertSupervisorIncident as upsertStoredSupervisorIncident,
+} from '@/lib/server/storage'
+import { createRecordRepository } from '@/lib/server/persistence/repository-utils'
+
+export const supervisorIncidentRepository = createRecordRepository<SupervisorIncident>(
+  'supervisor-incidents',
+  {
+    get(id) {
+      return loadStoredSupervisorIncident(id) as SupervisorIncident | null
+    },
+    list() {
+      return loadStoredSupervisorIncidents() as Record<string, SupervisorIncident>
+    },
+    upsert(id, value) {
+      upsertStoredSupervisorIncident(id, value as SupervisorIncident)
+    },
+    replace(data) {
+      saveStoredSupervisorIncidents(data as Record<string, SupervisorIncident>)
+    },
+  },
+)
+
+export const loadSupervisorIncidents = () => supervisorIncidentRepository.list()
+export const loadSupervisorIncident = (id: string) => supervisorIncidentRepository.get(id)
+export const saveSupervisorIncidents = (items: Record<string, SupervisorIncident | Record<string, unknown>>) => (
+  supervisorIncidentRepository.replace(items as Record<string, SupervisorIncident>)
+)
+export const upsertSupervisorIncident = (id: string, value: SupervisorIncident | Record<string, unknown>) => (
+  supervisorIncidentRepository.upsert(id, value as SupervisorIncident)
+)
+
+export function listAgentIncidents(agentId?: string): SupervisorIncident[] {
+  return Object.values(loadSupervisorIncidents())
+    .filter((incident) => !agentId || incident.agentId === agentId)
+    .sort((left, right) => right.createdAt - left.createdAt)
+}

package/src/lib/server/chat-execution/chat-execution-types.ts

@@ -0,0 +1,38 @@
+import type { MessageToolEvent, SSEEvent } from '@/types'
+
+export interface ExecuteChatTurnInput {
+  sessionId: string
+  message: string
+  missionId?: string | null
+  imagePath?: string
+  imageUrl?: string
+  attachedFiles?: string[]
+  internal?: boolean
+  source?: string
+  runId?: string
+  signal?: AbortSignal
+  onEvent?: (event: SSEEvent) => void
+  modelOverride?: string
+  heartbeatConfig?: {
+    ackMaxChars: number
+    showOk: boolean
+    showAlerts: boolean
+    target: string | null
+    lightContext?: boolean
+    deliveryMode?: 'default' | 'tool_only' | 'silent'
+  }
+  replyToId?: string
+}
+
+export interface ExecuteChatTurnResult {
+  runId?: string
+  sessionId: string
+  missionId?: string | null
+  text: string
+  persisted: boolean
+  toolEvents: MessageToolEvent[]
+  error?: string
+  inputTokens?: number
+  outputTokens?: number
+  estimatedCost?: number
+}

package/src/lib/server/chat-execution/chat-execution-utils.ts

@@ -2,7 +2,7 @@ import fs from 'fs'
 import path from 'path'
 import type { Message, MessageToolEvent } from '@/types'
 import { dedup } from '@/lib/shared-utils'
-import { getUsageSpendSince } from '@/lib/server/storage'
+import { getUsageSpendSince } from '@/lib/server/usage/usage-repository'
 import { extensionIdMatches } from '@/lib/server/tool-aliases'
 import { buildToolEventAssistantSummary } from '@/lib/chat/tool-event-summary'
 import { looksLikePositiveConnectorDeliveryText } from '@/lib/server/chat-execution/chat-execution-connector-delivery'