@swarmclawai/swarmclaw 0.9.4 → 0.9.6

package/src/lib/server/tool-loop-detection.ts

@@ -120,6 +120,24 @@ export class ToolLoopTracker {
       ?? null
   }
 
+  /**
+   * Preview whether the next tool call should be warned or blocked before it executes.
+   * Pre-call checks only use detectors that do not depend on tool output.
+   */
+  preview(name: string, input: unknown): LoopDetectionResult | null {
+    const current: ToolCallRecord = {
+      name,
+      inputHash: hashToolInput(input),
+      outputHash: '',
+      outputPreview: '',
+      timestamp: Date.now(),
+    }
+    return this.checkCircuitBreakerPreview(current)
+      ?? this.checkToolFrequencyPreview(current)
+      ?? this.checkGenericRepeatPreview(current)
+      ?? null
+  }
+
   /** Get the full call history (for diagnostics). */
   getHistory(): ReadonlyArray<ToolCallRecord> {
     return this.history
@@ -156,6 +174,28 @@ export class ToolLoopTracker {
     return null
   }
 
+  private checkToolFrequencyPreview(current: ToolCallRecord): LoopDetectionResult | null {
+    let count = 1
+    for (const r of this.history) {
+      if (r.name === current.name) count++
+    }
+    if (count >= this.thresholds.toolFrequencyCritical) {
+      return {
+        severity: 'critical',
+        detector: 'tool_frequency',
+        message: `Tool "${current.name}" would be called ${count} times this turn. Excessive repetition — wrap up with available results.`,
+      }
+    }
+    if (count >= this.thresholds.toolFrequencyWarn) {
+      return {
+        severity: 'warning',
+        detector: 'tool_frequency',
+        message: `Tool "${current.name}" is nearing overuse (${count} calls this turn). Consider whether another call is needed.`,
+      }
+    }
+    return null
+  }
+
   private checkCircuitBreaker(current: ToolCallRecord): LoopDetectionResult | null {
     const key = `${current.name}:${current.inputHash}`
     let count = 0
@@ -172,6 +212,22 @@ export class ToolLoopTracker {
     return null
   }
 
+  private checkCircuitBreakerPreview(current: ToolCallRecord): LoopDetectionResult | null {
+    const key = `${current.name}:${current.inputHash}`
+    let count = 1
+    for (const r of this.history) {
+      if (`${r.name}:${r.inputHash}` === key) count++
+    }
+    if (count >= this.thresholds.circuitBreaker) {
+      return {
+        severity: 'critical',
+        detector: 'circuit_breaker',
+        message: `Circuit breaker: "${current.name}" would be called ${count} times with identical input. Halting before another runaway call.`,
+      }
+    }
+    return null
+  }
+
   private checkGenericRepeat(current: ToolCallRecord): LoopDetectionResult | null {
     const key = `${current.name}:${current.inputHash}`
     let count = 0
@@ -195,6 +251,29 @@ export class ToolLoopTracker {
     return null
   }
 
+  private checkGenericRepeatPreview(current: ToolCallRecord): LoopDetectionResult | null {
+    const key = `${current.name}:${current.inputHash}`
+    let count = 1
+    for (const r of this.history) {
+      if (`${r.name}:${r.inputHash}` === key) count++
+    }
+    if (count >= this.thresholds.repeatCritical) {
+      return {
+        severity: 'critical',
+        detector: 'generic_repeat',
+        message: `Tool "${current.name}" would repeat the same input ${count} times. Blocking before it becomes a stuck loop.`,
+      }
+    }
+    if (count >= this.thresholds.repeatWarn) {
+      return {
+        severity: 'warning',
+        detector: 'generic_repeat',
+        message: `Tool "${current.name}" is about to repeat the same input ${count} times. Consider a different approach.`,
+      }
+    }
+    return null
+  }
+
   private checkPollingStall(current: ToolCallRecord): LoopDetectionResult | null {
     // Look for recent sequential calls to the same tool with identical output
     const recent = this.history.slice(-this.thresholds.pollCritical)

package/src/lib/server/wallet/wallet-service.test.ts

@@ -3,7 +3,11 @@ import { describe, it } from 'node:test'
 
 import type { AgentWallet, WalletTransaction } from '@/types'
 
-import { validateWalletSendLimits } from '@/lib/server/wallet/wallet-service'
+import {
+  validateWalletSendLimits,
+  walletApprovalsGloballyEnabled,
+  walletRequiresApproval,
+} from '@/lib/server/wallet/wallet-service'
 
 function buildWallet(overrides: Partial<AgentWallet> = {}): AgentWallet {
   return {
@@ -55,3 +59,23 @@ describe('validateWalletSendLimits', () => {
     assert.match(error || '', /Daily limit exceeded/)
   })
 })
+
+describe('wallet approval helpers', () => {
+  it('treats missing app setting as globally enabled', () => {
+    assert.equal(walletApprovalsGloballyEnabled(undefined), true)
+    assert.equal(walletApprovalsGloballyEnabled({}), true)
+  })
+
+  it('lets the global setting disable approval even for approval-required wallets', () => {
+    const wallet = buildWallet({ requireApproval: true })
+
+    assert.equal(walletRequiresApproval(wallet, { walletApprovalsEnabled: true }), true)
+    assert.equal(walletRequiresApproval(wallet, { walletApprovalsEnabled: false }), false)
+  })
+
+  it('still respects the per-wallet toggle when global approvals remain enabled', () => {
+    const wallet = buildWallet({ requireApproval: false })
+
+    assert.equal(walletRequiresApproval(wallet, { walletApprovalsEnabled: true }), false)
+  })
+})

package/src/lib/server/wallet/wallet-service.ts

@@ -91,6 +91,19 @@ export function getWalletByAgentId(agentId: string, chain?: WalletChain | null):
   return wallets.find((wallet) => wallet.id === activeWalletId) ?? wallets[0] ?? null
 }
 
+export function walletApprovalsGloballyEnabled(
+  settings?: { walletApprovalsEnabled?: boolean | null } | null,
+): boolean {
+  return settings?.walletApprovalsEnabled !== false
+}
+
+export function walletRequiresApproval(
+  wallet: Pick<AgentWallet, 'requireApproval'>,
+  settings?: { walletApprovalsEnabled?: boolean | null } | null,
+): boolean {
+  return walletApprovalsGloballyEnabled(settings) && wallet.requireApproval !== false
+}
+
 export function createAgentWallet(input: {
   agentId: string
   chain?: WalletChain | string | null

package/src/types/index.ts

@@ -354,12 +354,144 @@ export interface UsageRecord {
 
 // --- Plugin System ---
 
+export interface PluginPromptBuildResult {
+  systemPrompt?: string
+  prependContext?: string
+  prependSystemContext?: string
+  appendSystemContext?: string
+}
+
+export interface PluginModelResolveResult {
+  providerOverride?: ProviderType
+  modelOverride?: string
+  apiEndpointOverride?: string | null
+}
+
+export interface PluginToolCallResult {
+  input?: Record<string, unknown> | null
+  params?: Record<string, unknown>
+  block?: boolean
+  blockReason?: string
+  warning?: string
+}
+
+export interface PluginMessagePersistResult {
+  message?: Message
+}
+
+export interface PluginBeforeMessageWriteResult extends PluginMessagePersistResult {
+  block?: boolean
+}
+
+export interface PluginSubagentSpawningResult {
+  status: 'ok' | 'error'
+  error?: string
+}
+
 export interface PluginHooks {
   beforeAgentStart?: (ctx: { session: Session; message: string }) => Promise<void> | void
   afterAgentComplete?: (ctx: { session: Session; response: string }) => Promise<void> | void
+  beforeModelResolve?: (ctx: {
+    session: Session
+    prompt: string
+    message: string
+    provider: ProviderType
+    model: string
+    apiEndpoint?: string | null
+  }) => Promise<PluginModelResolveResult | void> | PluginModelResolveResult | void
   beforeToolExec?: (ctx: { toolName: string; input: Record<string, unknown> | null }) => Promise<Record<string, unknown> | void> | Record<string, unknown> | void
+  beforePromptBuild?: (ctx: {
+    session: Session
+    prompt: string
+    message: string
+    history: Message[]
+    messages: Message[]
+  }) => Promise<PluginPromptBuildResult | void> | PluginPromptBuildResult | void
+  beforeToolCall?: (ctx: {
+    session: Session
+    toolName: string
+    input: Record<string, unknown> | null
+    runId?: string
+    toolCallId?: string
+  }) => Promise<PluginToolCallResult | Record<string, unknown> | void> | PluginToolCallResult | Record<string, unknown> | void
+  llmInput?: (ctx: {
+    session: Session
+    runId: string
+    provider: ProviderType
+    model: string
+    systemPrompt?: string
+    prompt: string
+    historyMessages: Message[]
+    imagesCount: number
+  }) => Promise<void> | void
+  llmOutput?: (ctx: {
+    session: Session
+    runId: string
+    provider: ProviderType
+    model: string
+    assistantTexts: string[]
+    response: string
+    usage?: {
+      input?: number
+      output?: number
+      total?: number
+      estimatedCost?: number
+    }
+  }) => Promise<void> | void
+  toolResultPersist?: (ctx: {
+    session: Session
+    message: Message
+    toolName?: string
+    toolCallId?: string
+    isSynthetic?: boolean
+  }) => Promise<PluginMessagePersistResult | Message | void> | PluginMessagePersistResult | Message | void
+  beforeMessageWrite?: (ctx: {
+    session: Session
+    message: Message
+    phase?: 'user' | 'system' | 'assistant_partial' | 'assistant_final' | 'heartbeat'
+    runId?: string
+  }) => Promise<PluginBeforeMessageWriteResult | Message | void> | PluginBeforeMessageWriteResult | Message | void
   afterToolExec?: (ctx: { session: Session; toolName: string; input: Record<string, unknown> | null; output: string }) => Promise<void> | void
   onMessage?: (ctx: { session: Session; message: Message }) => Promise<void> | void
+  sessionStart?: (ctx: {
+    session: Session
+    resumedFrom?: string | null
+  }) => Promise<void> | void
+  sessionEnd?: (ctx: {
+    sessionId: string
+    session?: Session | null
+    messageCount: number
+    durationMs?: number
+    reason?: string | null
+  }) => Promise<void> | void
+  subagentSpawning?: (ctx: {
+    parentSessionId?: string | null
+    agentId: string
+    agentName: string
+    message: string
+    cwd: string
+    mode: 'run' | 'session'
+    threadRequested: boolean
+  }) => Promise<PluginSubagentSpawningResult | void> | PluginSubagentSpawningResult | void
+  subagentSpawned?: (ctx: {
+    parentSessionId?: string | null
+    childSessionId: string
+    agentId: string
+    agentName: string
+    runId: string
+    mode: 'run' | 'session'
+    threadRequested: boolean
+  }) => Promise<void> | void
+  subagentEnded?: (ctx: {
+    parentSessionId?: string | null
+    childSessionId: string
+    agentId: string
+    agentName: string
+    status: 'completed' | 'failed' | 'cancelled' | 'timed_out'
+    response?: string | null
+    error?: string | null
+    durationMs?: number
+  }) => Promise<void> | void
 
   // Post-turn hook — fires after a full chat exchange (user message → agent response)
   afterChatTurn?: (ctx: {
@@ -772,7 +904,7 @@ export interface AgentWallet {
   spendingLimitLamports?: number
   /** @deprecated Use dailyLimitAtomic */
   dailyLimitLamports?: number
-  requireApproval: boolean          // default true
+  requireApproval: boolean          // default true; can be globally overridden by app settings
   createdAt: number
   updatedAt: number
 }
@@ -1325,6 +1457,7 @@ export interface AppSettings {
   safetyRequireApprovalForOutbound?: boolean
   safetyMaxDailySpendUsd?: number | null
   safetyBlockedTools?: string[]
+  walletApprovalsEnabled?: boolean
   capabilityPolicyMode?: 'permissive' | 'balanced' | 'strict'
   capabilityBlockedTools?: string[]
   capabilityBlockedCategories?: string[]

package/src/views/settings/section-wallets.tsx

@@ -0,0 +1,35 @@
+'use client'
+
+import type { SettingsSectionProps } from './types'
+
+export function WalletsSection({ appSettings, patchSettings }: SettingsSectionProps) {
+  const walletApprovalsEnabled = appSettings.walletApprovalsEnabled !== false
+
+  return (
+    <div className="mb-10">
+      <h3 className="font-display text-[12px] font-600 text-text-2 uppercase tracking-[0.08em] mb-2">
+        Wallets
+      </h3>
+      <p className="text-[12px] text-text-3 mb-5">
+        Global override for wallet approval prompts. Turn this off to auto-execute wallet sends and other wallet actions without creating pending approval steps.
+      </p>
+
+      <div className="flex items-center justify-between rounded-[14px] border border-white/[0.06] bg-white/[0.03] px-4 py-3">
+        <div className="pr-4">
+          <label className="text-[12px] font-600 text-text-2 block">Wallet Approvals</label>
+          <p className="text-[11px] text-text-3/60 mt-0.5">
+            When disabled, wallet actions bypass approval gates globally. Per-wallet approval toggles remain stored, but they are ignored until this is turned back on.
+          </p>
+        </div>
+        <button
+          type="button"
+          onClick={() => patchSettings({ walletApprovalsEnabled: !walletApprovalsEnabled })}
+          className={`relative w-9 h-5 rounded-full transition-colors ${walletApprovalsEnabled ? 'bg-accent-bright' : 'bg-white/[0.10]'}`}
+          style={{ fontFamily: 'inherit' }}
+        >
+          <span className={`absolute top-0.5 left-0.5 w-4 h-4 rounded-full bg-white transition-transform ${walletApprovalsEnabled ? 'translate-x-4' : ''}`} />
+        </button>
+      </div>
+    </div>
+  )
+}