@swarmclawai/swarmclaw 1.2.6 → 1.2.9

package/src/lib/server/chat-execution/stream-agent-chat.ts

@@ -78,7 +78,6 @@ import {
   buildToolAvailabilityLines,
   buildToolDisciplineLines,
   buildToolSection,
-  buildExternalWalletExecutionBlock,
   buildForcedExternalServiceSummary,
   shouldForceAttachmentFollowthrough,
   joinPromptSegments,
@@ -101,7 +100,6 @@ import { finalizeStreamResult } from '@/lib/server/chat-execution/post-stream-fi
 import {
   classifyMessage,
   isDeliverableTask as classifiedIsDeliverableTask,
-  hasTransactionalWalletIntent as classifiedHasTransactionalWalletIntent,
   isResearchSynthesis as classifiedIsResearchSynthesis,
   type MessageClassification,
 } from '@/lib/server/chat-execution/message-classifier'
@@ -125,7 +123,6 @@ export {
   buildToolAvailabilityLines,
   buildToolDisciplineLines,
   buildToolSection,
-  buildExternalWalletExecutionBlock,
   shouldForceAttachmentFollowthrough,
   buildForcedExternalServiceSummary,
 }
@@ -142,7 +139,6 @@ export {
 } from '@/lib/server/chat-execution/stream-continuation'
 
 export {
-  isWalletSimulationResult,
   resolveSuccessfulTerminalToolBoundary,
   shouldForceExternalServiceSummary,
 } from '@/lib/server/chat-execution/chat-streaming-utils'
@@ -190,6 +186,7 @@ interface StreamAgentChatOpts {
   fallbackCredentialIds?: string[]
   signal?: AbortSignal
   promptMode?: PromptMode
+  classification?: MessageClassification | null
   /** Run source (e.g. 'heartbeat', 'chat', 'scheduler') — used for heartbeat-specific tuning. */
   source?: string
 }
@@ -223,10 +220,23 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
 
 async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAgentChatResult> {
   const startTs = Date.now()
-  const { session, message, imagePath, imageUrl, attachedFiles, apiKey, systemPrompt, executionBrief, extraSystemContext, write, history, fallbackCredentialIds, signal } = opts
+  const {
+    session,
+    message,
+    imagePath,
+    imageUrl,
+    attachedFiles,
+    apiKey,
+    systemPrompt,
+    executionBrief,
+    extraSystemContext,
+    write,
+    history,
+    fallbackCredentialIds,
+    signal,
+    classification: providedClassification,
+  } = opts
   const isHeartbeat = isHeartbeatSource(opts.source)
-  const promptMode: PromptMode = opts.promptMode ?? resolvePromptMode(session)
-  const isMinimalPrompt = promptMode === 'minimal'
   const isConnectorSession = isDirectConnectorSession(session)
   const rawExtensions = getEnabledCapabilityIds(session)
   const hasShellCapability = rawExtensions.some((toolId) => ['shell', 'execute_command'].includes(String(toolId)))
@@ -241,6 +251,23 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
 
   const sessionAgent = session.agentId ? getAgent(session.agentId) : null
 
+  const classificationPromise = providedClassification !== undefined
+    ? Promise.resolve(providedClassification)
+    : classifyMessage({
+        sessionId: session.id,
+        agentId: session.agentId,
+        message,
+        history,
+      }).catch(() => null as MessageClassification | null)
+  const classification = await classificationPromise
+  const lightweightDirectChat = classification?.isLightweightDirectChat === true
+    && !isConnectorSession
+    && !isHeartbeat
+  const promptMode: PromptMode = opts.promptMode ?? resolvePromptMode(session, {
+    preferMinimalPrompt: lightweightDirectChat,
+  })
+  const isMinimalPrompt = promptMode === 'minimal'
+
   // Resolve agent's thinking level for provider-native params
   let agentThinkingLevel: 'minimal' | 'low' | 'medium' | 'high' | undefined
   if (session.thinkingLevel) {
@@ -248,6 +275,9 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   } else if (sessionAgent) {
     agentThinkingLevel = sessionAgent.thinkingLevel
   }
+  if (lightweightDirectChat) {
+    agentThinkingLevel = 'minimal'
+  }
 
   const llm = buildChatModel({
     provider: session.provider,
@@ -296,16 +326,6 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
     return Math.max(0, Math.min(3600, Math.trunc(parsed)))
   })()
 
-  // -------------------------------------------------------------------------
-  // Start message classification in the background (LLM-based, ~200-800ms)
-  // -------------------------------------------------------------------------
-  const classificationPromise = classifyMessage({
-    sessionId: session.id,
-    agentId: session.agentId,
-    message,
-    history,
-  }).catch(() => null as MessageClassification | null)
-
   // -------------------------------------------------------------------------
   // System prompt assembly (stays inline — many async calls + local state)
   // -------------------------------------------------------------------------
@@ -426,8 +446,6 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   const suggestionsBlock = buildSuggestionsSection(settings.suggestionsEnabled, isMinimalPrompt)
   if (suggestionsBlock) promptParts.push(suggestionsBlock)
 
-  // Await classification before building the agentic execution policy
-  const classification = await classificationPromise
   const delegationAdvisory = sessionAgent && agentDelegationEnabled
     ? resolveDelegationAdvisory({
         currentAgent: sessionAgent,
@@ -867,7 +885,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   const routingDecision = routeTaskIntent(message, sessionExtensions, null, classification)
   const explicitRequiredToolNames = getExplicitRequiredToolNames(message, sessionExtensions)
 
-  const boundedExternalExecutionTask = classifiedHasTransactionalWalletIntent(classification, message)
+  const boundedExternalExecutionTask = false
   const likelyResearchSynthesisTask = classifiedIsResearchSynthesis(classification, routingDecision.intent)
   const shouldEnforceEarlyRequiredToolKickoff = explicitRequiredToolNames.length > 0
     && classifiedIsDeliverableTask(classification, message)
@@ -1138,7 +1156,14 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
       }
 
       // Async LLM-based incomplete-action check: catches "I'll run the deployment:" with no tool calls
-      if (!shouldContinue && outcome && !state.hasToolCalls && state.fullText.trim().length > 0 && state.fullText.trim().length < 500) {
+      if (
+        !shouldContinue
+        && outcome
+        && !state.hasToolCalls
+        && classification?.isLightweightDirectChat !== true
+        && state.fullText.trim().length > 0
+        && state.fullText.trim().length < 500
+      ) {
         const completeness = await evaluateResponseCompleteness({
           sessionId: session.id,
           agentId: session.agentId,

package/src/lib/server/chat-execution/stream-continuation.test.ts

@@ -46,36 +46,6 @@ describe('stream-continuation', () => {
     })
   })
 
-  // ---- looksLikeExternalWalletTask ----
-  describe('looksLikeExternalWalletTask', () => {
-    it('matches wallet keywords', () => {
-      assert.equal(mod.looksLikeExternalWalletTask('swap 100 USDC on Arbitrum'), true)
-      assert.equal(mod.looksLikeExternalWalletTask('check my wallet balance'), true)
-      assert.equal(mod.looksLikeExternalWalletTask('trade ETH for SOL'), true)
-    })
-
-    it('returns false for empty/unrelated text', () => {
-      assert.equal(mod.looksLikeExternalWalletTask(''), false)
-      assert.equal(mod.looksLikeExternalWalletTask('write me a poem about cats'), false)
-    })
-  })
-
-  // ---- looksLikeBoundedExternalExecutionTask ----
-  describe('looksLikeBoundedExternalExecutionTask', () => {
-    it('requires wallet keywords + action verbs', () => {
-      assert.equal(mod.looksLikeBoundedExternalExecutionTask('swap 100 USDC on Arbitrum'), true)
-      assert.equal(mod.looksLikeBoundedExternalExecutionTask('buy ETH on the exchange'), true)
-    })
-
-    it('returns false without action verbs', () => {
-      assert.equal(mod.looksLikeBoundedExternalExecutionTask('check my wallet balance'), false)
-    })
-
-    it('returns false for non-wallet text', () => {
-      assert.equal(mod.looksLikeBoundedExternalExecutionTask('execute the test suite'), false)
-    })
-  })
-
   // ---- looksLikeOpenEndedDeliverableTask ----
   describe('looksLikeOpenEndedDeliverableTask', () => {
     it('matches deliverable patterns', () => {
@@ -112,24 +82,6 @@ describe('stream-continuation', () => {
     })
   })
 
-  // ---- hasStateChangingWalletEvidence ----
-  describe('hasStateChangingWalletEvidence', () => {
-    it('detects send_transaction action in wallet_tool', () => {
-      const events = [{ name: 'wallet_tool', input: '{"action":"send_transaction"}', output: '{}' }]
-      assert.equal(mod.hasStateChangingWalletEvidence(events), true)
-    })
-
-    it('returns false for non-wallet tools', () => {
-      const events = [{ name: 'web', input: 'search', output: 'results' }]
-      assert.equal(mod.hasStateChangingWalletEvidence(events), false)
-    })
-
-    it('returns false for read-only wallet actions', () => {
-      const events = [{ name: 'wallet_tool', input: '{"action":"balance"}', output: '{}' }]
-      assert.equal(mod.hasStateChangingWalletEvidence(events), false)
-    })
-  })
-
   // ---- countExternalExecutionResearchSteps ----
   describe('countExternalExecutionResearchSteps', () => {
     it('counts http/web/browser tools', () => {
@@ -141,12 +93,12 @@ describe('stream-continuation', () => {
       assert.equal(mod.countExternalExecutionResearchSteps(events), 2)
     })
 
-    it('counts read-only wallet actions', () => {
+    it('does not count non-research tools', () => {
       const events = [
-        { name: 'wallet_tool', input: '{"action":"balance"}', output: '{}' },
-        { name: 'wallet_tool', input: '{"action":"send_transaction"}', output: '{}' },
+        { name: 'shell', input: 'ls', output: 'files' },
+        { name: 'files', input: 'read', output: 'content' },
       ]
-      assert.equal(mod.countExternalExecutionResearchSteps(events), 1)
+      assert.equal(mod.countExternalExecutionResearchSteps(events), 0)
     })
   })
 

package/src/lib/server/chat-execution/stream-continuation.ts

@@ -194,25 +194,9 @@ function getRequestedArtifactStatus(params: {
 // Tool evidence analysis
 // ---------------------------------------------------------------------------
 
-export function hasStateChangingWalletEvidence(toolEvents: MessageToolEvent[]): boolean {
-  return toolEvents.some((event) => {
-    const input = `${event.input || ''}\n${event.output || ''}`
-    return event.name === 'wallet_tool' && (
-      /"action":"send_transaction"/.test(input)
-      || /"action":"send"/.test(input)
-      || /"action":"sign_transaction"/.test(input)
-      || /"type":"extension_wallet_action_request"/.test(input)
-      || /"type":"extension_wallet_transfer_request"/.test(input)
-      || /"status":"broadcast"/.test(input)
-    )
-  })
-}
-
 export function countExternalExecutionResearchSteps(toolEvents: MessageToolEvent[]): number {
   return toolEvents.filter((event) => {
-    if (['http_request', 'web', 'web_search', 'web_fetch', 'browser'].includes(event.name)) return true
-    if (event.name !== 'wallet_tool') return false
-    return /"action":"(balance|address|transactions|call_contract|encode_contract_call)"/.test(event.input || '')
+    return ['http_request', 'web', 'web_search', 'web_fetch', 'browser'].includes(event.name)
   }).length
 }
 
@@ -238,49 +222,24 @@ export function countDistinctExternalResearchHosts(toolEvents: MessageToolEvent[
 // Continuation decision helpers
 // ---------------------------------------------------------------------------
 
-export function shouldForceExternalExecutionFollowthrough(params: {
+export function shouldForceExternalExecutionFollowthrough(_params: {
   userMessage: string
   finalResponse: string
   hasToolCalls: boolean
   toolEvents: MessageToolEvent[]
   classification?: MessageClassification | null
 }): boolean {
-  const isTransactional = params.classification?.walletIntent === 'transactional'
-  if (!isTransactional) return false
-  if (!params.hasToolCalls || params.toolEvents.length < 4) return false
-  if (hasStateChangingWalletEvidence(params.toolEvents)) return false
-  const distinctHosts = countDistinctExternalResearchHosts(params.toolEvents)
-  const trimmed = params.finalResponse.trim()
-  if (!trimmed) return countExternalExecutionResearchSteps(params.toolEvents) >= 4 || distinctHosts >= 3
-  if (/\b(last reversible step|exact blocker|safest next action|blocked|cannot|can't|missing capability|no-key route unavailable)\b/i.test(trimmed)) {
-    return false
-  }
-  if (countExternalExecutionResearchSteps(params.toolEvents) < 4 && distinctHosts < 3) return false
-  return /(let me|i'll|i will|trying|research|query|check|look|promising|now let me|good -|good,)/i.test(trimmed) || trimmed.length < 500
+  return false
 }
 
-export function shouldForceExternalExecutionKickoffFollowthrough(params: {
+export function shouldForceExternalExecutionKickoffFollowthrough(_params: {
   userMessage: string
   finalResponse: string
   hasToolCalls: boolean
   toolEvents: MessageToolEvent[]
   classification?: MessageClassification | null
 }): boolean {
-  const isTransactional = params.classification?.walletIntent === 'transactional'
-  if (!isTransactional) return false
-  if (params.hasToolCalls || params.toolEvents.length > 0) return false
-
-  const trimmed = params.finalResponse.trim()
-  if (!trimmed) return true
-  if (/^(?:HEARTBEAT_OK|NO_MESSAGE)\b/i.test(trimmed)) return false
-  if (/\?\s*$/.test(trimmed)) return false
-  if (/\b(last reversible step|exact blocker|blocked|cannot|can't|missing capability|need approval|requires approval|approval boundary|requires human|ask_human|credential|authentication|login|2fa|mfa|captcha)\b/i.test(trimmed)) {
-    return false
-  }
-  if (/\b(done|completed|finished|sent|broadcast|minted|purchased|bought|swapped|claimed)\b/i.test(trimmed)) {
-    return false
-  }
-  return looksLikeIncompleteDeliverableResponse(trimmed) || trimmed.length < 220
+  return false
 }
 
 export function shouldForceDeliverableFollowthrough(params: {
@@ -454,8 +413,7 @@ function buildExternalExecutionFollowthroughPrompt(params: {
     'You are in a bounded external execution task and have already done enough research.',
     'Do not restart broad discovery. Do not ask the user for another prompt.',
     'Do not spend this continuation on more venue shopping. Use the already confirmed route unless one last fetch is strictly required to prepare execution.',
-    'If several venue or aggregator APIs already failed, stop searching for more venues. Either use a direct onchain read path with the available wallet tools, or state the blocker.',
-    'A prose approval request does not count as completion. If the next step is a sign/send/approve action, call the real wallet tool action so the runtime can create the approval request.',
+    'If several venue or aggregator APIs already failed, stop searching for more venues and state the blocker.',
     'Do not mutate already confirmed token addresses, router addresses, spender addresses, or network identifiers unless newer tool evidence proves the earlier value was wrong.',
     'Within this continuation, do exactly one of the following:',
     '1. Take the next concrete execution step now using the existing tools and stop at the first approval boundary for a state-changing action.',

package/src/lib/server/chatrooms/chatroom-routing.test.ts

@@ -16,6 +16,8 @@ const agents: Record<string, Agent> = {
     model: 'gpt-test',
     systemPrompt: '',
     capabilities: ['deploy', 'infrastructure'],
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
   },
   design: {
     id: 'design',
@@ -25,6 +27,8 @@ const agents: Record<string, Agent> = {
     model: 'gpt-test',
     systemPrompt: '',
     capabilities: ['design', 'ui'],
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
   },
 }
 

package/src/lib/server/chatrooms/session-mailbox.ts

@@ -1,7 +1,6 @@
 import { genId } from '@/lib/id'
 import type { MailboxEnvelope } from '@/types'
 import { loadSession, patchSession } from '@/lib/server/sessions/session-repository'
-import { requestMissionTicksForHumanReply } from '@/lib/server/missions/mission-service'
 
 interface MailboxOptions {
   limit?: number
@@ -167,15 +166,6 @@ export function sendMailboxEnvelope(input: {
       lastActiveAt: now,
     }
   })
-  if (envelope.type === 'human_reply') {
-    requestMissionTicksForHumanReply({
-      sessionId: input.toSessionId,
-      correlationId: envelope.correlationId || null,
-      envelopeId: envelope.id,
-      payload: envelope.payload,
-      fromSessionId: envelope.fromSessionId || null,
-    })
-  }
   import('@/lib/server/runtime/watch-jobs')
     .then(({ triggerMailboxWatchJobs }) => {
       triggerMailboxWatchJobs({ sessionId: input.toSessionId, envelope })

package/src/lib/server/chats/chat-session-service.ts

@@ -7,7 +7,6 @@ import { buildAgentDisabledMessage, isAgentDisabled } from '@/lib/server/agents/
 import { loadAgent } from '@/lib/server/agents/agent-repository'
 import { clearMainLoopStateForSession } from '@/lib/server/agents/main-agent-loop'
 import { applyResolvedRoute, resolvePrimaryAgentRoute } from '@/lib/server/agents/agent-runtime-config'
-import { enrichSessionWithMissionSummary } from '@/lib/server/missions/mission-service'
 import { cleanupSessionProcesses } from '@/lib/server/runtime/process-manager'
 import { stopActiveSessionProcess } from '@/lib/server/runtime/runtime-state'
 import {
@@ -60,7 +59,7 @@ export function listChatsForApi(): Record<string, ReturnType<typeof buildSession
     sessions[id].currentRunId = run.runningRunId || null
   }
   return Object.fromEntries(
-    Object.entries(sessions).map(([id, session]) => [id, buildSessionListSummary(enrichSessionWithMissionSummary(session))]),
+    Object.entries(sessions).map(([id, session]) => [id, buildSessionListSummary(session)]),
   )
 }
 
@@ -72,7 +71,7 @@ export function getChatSessionForApi(sessionId: string): Session | null {
   session.active = !!run.runningRunId
   session.queuedCount = queue.queueLength
   session.currentRunId = run.runningRunId || null
-  return enrichSessionWithMissionSummary(session)
+  return session
 }
 
 export function createChatSession(input: Record<string, unknown>): ServiceResult<Session> {
@@ -285,7 +284,7 @@ export function updateChatSession(sessionId: string, updates: Record<string, unk
 
   saveSession(sessionId, original)
   notify('sessions')
-  return enrichSessionWithMissionSummary(original)
+  return original
 }
 
 export function deleteChatSession(sessionId: string): boolean {
@@ -320,7 +319,6 @@ export function queueChatMessage(sessionId: string, body: Record<string, unknown
   }
   const queued = enqueueSessionRun({
     sessionId,
-    missionId: session.missionId || null,
     message,
     imagePath,
     imageUrl,

package/src/lib/server/connectors/connector-inbound.ts

@@ -1095,7 +1095,6 @@ If media sending fails, report the exact error and retry with a corrected path/t
 
     const queued = enqueueSessionRun({
       sessionId: session.id,
-      missionId: session.missionId || null,
       message: modelInputText,
       imagePath: firstImagePath,
       imageUrl: firstImageUrl,

package/src/lib/server/connectors/connector-lifecycle.ts

@@ -19,6 +19,7 @@ import {
   setReconnectState,
 } from './reconnect-state'
 import { connectorRuntimeState, runningConnectors } from './runtime-state'
+import { ensureSwarmdockConnectorCredential } from './swarmdock-secret'
 
 const TAG = 'connector-lifecycle'
 
@@ -70,6 +71,7 @@ export async function getPlatform(platform: string) {
     case 'googlechat': return (await import('./googlechat')).default
     case 'matrix':    return (await import('./matrix')).default
     case 'email':     return (await import('./email')).default
+    case 'swarmdock': return (await import('./swarmdock')).default
   }
 
   // 2. Check Extension-provided connectors
@@ -134,8 +136,9 @@ async function _startConnectorImpl(connectorId: string): Promise<void> {
   }
 
   const connectors = loadConnectors()
-  const connector = connectors[connectorId] as Connector | undefined
-  if (!connector) throw new Error('Connector not found')
+  const storedConnector = connectors[connectorId] as Connector | undefined
+  if (!storedConnector) throw new Error('Connector not found')
+  let connector: Connector = storedConnector
 
   // Starting a connector expresses durable intent: keep it enabled across
   // transient failures so daemon recovery and server restarts can retry it.
@@ -148,6 +151,16 @@ async function _startConnectorImpl(connectorId: string): Promise<void> {
   }
 
   try {
+    let swarmdockFallbackPrivateKey: string | null = null
+    if (connector.platform === 'swarmdock') {
+      const prepared = ensureSwarmdockConnectorCredential(connector, {
+        allowMigrationFailureFallback: true,
+      })
+      connector = prepared.connector
+      connectors[connectorId] = connector
+      swarmdockFallbackPrivateKey = prepared.fallbackPrivateKey
+    }
+
     // Resolve bot token from credential
     let botToken = ''
     if (connector.credentialId) {
@@ -164,8 +177,11 @@ async function _startConnectorImpl(connectorId: string): Promise<void> {
     if (!botToken && connector.platform === 'bluebubbles' && connector.config.password) {
       botToken = connector.config.password
     }
+    if (!botToken && swarmdockFallbackPrivateKey) {
+      botToken = swarmdockFallbackPrivateKey
+    }
 
-    if (!botToken && connector.platform !== 'whatsapp' && connector.platform !== 'openclaw' && connector.platform !== 'signal' && connector.platform !== 'email') {
+    if (!botToken && connector.platform !== 'whatsapp' && connector.platform !== 'openclaw' && connector.platform !== 'signal' && connector.platform !== 'email' && connector.platform !== 'swarmdock') {
       throw new Error('No bot token configured')
     }
 

package/src/lib/server/connectors/connector-service.ts

@@ -43,6 +43,11 @@ import type {
 } from '@/types'
 import type { ServiceResult } from '@/lib/server/service-result'
 import type { DaemonConnectorRuntimeState } from '@/lib/server/daemon/types'
+import {
+  ensureSwarmdockConnectorCredential,
+  prepareSwarmdockConnectorInput,
+  redactConnectorSecrets,
+} from './swarmdock-secret'
 
 function cloneConnector<T extends Connector>(connector: T): T {
   return {
@@ -124,35 +129,52 @@ function requireSenderId(body: Record<string, unknown>): string {
 export async function listConnectorsWithRuntime(): Promise<Record<string, Connector>> {
   await ensureDaemonProcessRunning('api/connectors:get')
   const connectors = Object.fromEntries(
-    Object.entries(loadConnectors()).map(([id, connector]) => [id, cloneConnector(connector)]),
+    Object.entries(loadConnectors()).map(([id, connector]) => {
+      const prepared = ensureSwarmdockConnectorCredential(connector, {
+        allowMigrationFailureFallback: true,
+      })
+      return [id, cloneConnector(prepared.connector)]
+    }),
   ) as Record<string, Connector>
   const runtimeByConnector = await listDaemonConnectorRuntime()
   for (const connector of Object.values(connectors)) {
     applyRuntimeFields(connector, runtimeByConnector[connector.id] || null)
   }
-  return connectors
+  return Object.fromEntries(
+    Object.entries(connectors).map(([id, connector]) => [id, redactConnectorSecrets(connector)]),
+  )
 }
 
 export async function getConnectorWithRuntime(id: string): Promise<Connector | null> {
   await ensureDaemonProcessRunning('api/connectors/[id]:get')
   const connector = loadConnector(id)
   if (!connector) return null
-  const current = cloneConnector(connector)
-  return applyRuntimeFields(current, await getDaemonConnectorRuntime(id))
+  const prepared = ensureSwarmdockConnectorCredential(connector, {
+    allowMigrationFailureFallback: true,
+  })
+  const current = cloneConnector(prepared.connector)
+  return redactConnectorSecrets(applyRuntimeFields(current, await getDaemonConnectorRuntime(id)))
 }
 
 export function createConnector(body: Record<string, unknown>): Connector {
   const id = genId()
+  const rawConfig = body.config && typeof body.config === 'object' && !Array.isArray(body.config)
+    ? body.config as Record<string, string>
+    : {}
+  const prepared = prepareSwarmdockConnectorInput({
+    platform: body.platform as Connector['platform'],
+    name: (body.name as string) || `${String(body.platform || '')} Connector`,
+    credentialId: (body.credentialId as string | null | undefined) || null,
+    config: rawConfig,
+  })
   const connector: Connector = {
     id,
     name: (body.name as string) || `${String(body.platform || '')} Connector`,
     platform: body.platform as Connector['platform'],
     agentId: (body.agentId as string | null | undefined) || null,
     chatroomId: (body.chatroomId as string | null | undefined) || null,
-    credentialId: (body.credentialId as string | null | undefined) || null,
-    config: body.config && typeof body.config === 'object' && !Array.isArray(body.config)
-      ? body.config as Record<string, string>
-      : {},
+    credentialId: prepared.credentialId,
+    config: prepared.config,
     isEnabled: false,
     status: 'stopped',
     lastError: null,
@@ -210,6 +232,14 @@ export async function updateConnectorFromRoute(id: string, body: Record<string,
   if (body.credentialId !== undefined) next.credentialId = typeof body.credentialId === 'string' || body.credentialId === null ? body.credentialId : next.credentialId
   if (body.config !== undefined) next.config = body.config && typeof body.config === 'object' && !Array.isArray(body.config) ? body.config as Record<string, string> : next.config
   if (body.isEnabled !== undefined) next.isEnabled = typeof body.isEnabled === 'boolean' ? body.isEnabled : next.isEnabled
+  const prepared = prepareSwarmdockConnectorInput({
+    platform: next.platform,
+    name: next.name,
+    credentialId: next.credentialId || null,
+    config: next.config,
+  })
+  next.credentialId = prepared.credentialId
+  next.config = prepared.config
   persistConnector(next)
 
   try {
@@ -235,7 +265,7 @@ export async function updateConnectorFromRoute(id: string, body: Record<string,
   }
 
   notify('connectors')
-  return serviceOk(await getConnectorWithRuntime(id) || next)
+  return serviceOk(await getConnectorWithRuntime(id) || redactConnectorSecrets(next))
 }
 
 export async function deleteConnectorFromRoute(id: string): Promise<ServiceResult<{ ok: true }>> {

package/src/lib/server/connectors/discord.ts

@@ -217,8 +217,8 @@ const discord: PlatformConnector = {
             return String(sent.id || '')
           },
         })
-      } catch (err: any) {
-        log.error(TAG, 'Error handling message:', err.message)
+      } catch (err: unknown) {
+        log.error(TAG, 'Error handling message:', errorMessage(err))
         try {
           await message.reply('Sorry, I encountered an error processing your message.')
         } catch { /* ignore */ }

package/src/lib/server/connectors/matrix.ts

@@ -4,6 +4,7 @@ import path from 'path'
 import { DATA_DIR } from '../data-dir'
 import type { PlatformConnector, ConnectorInstance, InboundMessage } from './types'
 import { resolveConnectorIngressReply } from './ingress-delivery'
+import { errorMessage } from '@/lib/shared-utils'
 
 const TAG = 'matrix'
 
@@ -54,8 +55,8 @@ const matrix: PlatformConnector = {
         const reply = await resolveConnectorIngressReply(onMessage, inbound)
         if (!reply) return
         await client.sendText(roomId, reply.visibleText)
-      } catch (err: any) {
-        log.error(TAG, 'Error handling message:', err.message)
+      } catch (err: unknown) {
+        log.error(TAG, 'Error handling message:', errorMessage(err))
         try {
           await client.sendText(roomId, 'Sorry, I encountered an error processing your message.')
         } catch { /* ignore */ }

package/src/lib/server/connectors/signal.ts

@@ -4,6 +4,7 @@ import type { ChildProcess } from 'child_process'
 import type { Connector } from '@/types'
 import type { PlatformConnector, ConnectorInstance, InboundMessage, ConnectorIngressResult } from './types'
 import { resolveConnectorIngressReply } from './ingress-delivery'
+import { errorMessage } from '@/lib/shared-utils'
 
 const TAG = 'signal'
 
@@ -107,8 +108,8 @@ const signal: PlatformConnector = {
               `${cliPath} -u ${phoneNumber} send -m ${JSON.stringify(text)} ${channelId}`,
               { timeout: 15_000 },
             )
-          } catch (err: any) {
-            throw new Error(`Signal send failed: ${err.message}`)
+          } catch (err: unknown) {
+            throw new Error(`Signal send failed: ${errorMessage(err)}`)
           }
         }
       },
@@ -179,8 +180,8 @@ export async function handleSignalEvent(
         { timeout: 15_000 },
       )
     }
-  } catch (err: any) {
-    log.error(TAG, 'Error handling message:', err.message)
+  } catch (err: unknown) {
+    log.error(TAG, 'Error handling message:', errorMessage(err))
   }
 }