@roj-ai/sdk 0.0.2

package/src/plugins/limits-guard/limit-guard.test.ts

@@ -0,0 +1,161 @@
+import { describe, expect, it } from 'bun:test'
+import { checkLimits, resolveAgentLimits } from './limit-guard.js'
+import { createAgentCounters } from './plugin.js'
+import type { AgentCounters } from './plugin.js'
+
+describe('resolveAgentLimits', () => {
+	it('returns defaults when no config', () => {
+		const limits = resolveAgentLimits()
+		expect(limits.maxTurns).toBe(100)
+		expect(limits.maxToolCalls).toBe(200)
+		expect(limits.maxConsecutiveToolFailures).toBe(3)
+		expect(limits.maxSpawnedAgents).toBe(10)
+		expect(limits.maxMessagesSent).toBe(100)
+		expect(limits.softLimitRatio).toBe(0.8)
+		expect(limits.maxRepeatedToolCalls).toBe(3)
+		expect(limits.maxRepeatedResponses).toBe(3)
+	})
+
+	it('returns defaults when empty config', () => {
+		const limits = resolveAgentLimits({})
+		expect(limits.maxTurns).toBe(100)
+	})
+
+	it('overrides specific values', () => {
+		const limits = resolveAgentLimits({ maxTurns: 10, maxToolCalls: 50 })
+		expect(limits.maxTurns).toBe(10)
+		expect(limits.maxToolCalls).toBe(50)
+		expect(limits.maxSpawnedAgents).toBe(10) // default
+	})
+})
+
+describe('checkLimits', () => {
+	const defaultLimits = resolveAgentLimits()
+
+	const makeCounters = (overrides: Partial<AgentCounters> = {}): AgentCounters => ({
+		...createAgentCounters(),
+		...overrides,
+	})
+
+	it('returns ok for fresh counters', () => {
+		const result = checkLimits(makeCounters(), defaultLimits)
+		expect(result.status).toBe('ok')
+	})
+
+	// --- Hard limits ---
+
+	it('detects maxTurns hard limit', () => {
+		const result = checkLimits(makeCounters({ inferenceCount: 100 }), defaultLimits)
+		expect(result.status).toBe('hard_limit')
+		if (result.status === 'hard_limit') {
+			expect(result.limitName).toBe('maxTurns')
+		}
+	})
+
+	it('detects maxToolCalls hard limit', () => {
+		const result = checkLimits(makeCounters({ toolCallCount: 200 }), defaultLimits)
+		expect(result.status).toBe('hard_limit')
+		if (result.status === 'hard_limit') {
+			expect(result.limitName).toBe('maxToolCalls')
+		}
+	})
+
+	it('detects maxSpawnedAgents hard limit', () => {
+		const result = checkLimits(makeCounters({ spawnedAgentCount: 10 }), defaultLimits)
+		expect(result.status).toBe('hard_limit')
+		if (result.status === 'hard_limit') {
+			expect(result.limitName).toBe('maxSpawnedAgents')
+		}
+	})
+
+	it('detects maxMessagesSent hard limit', () => {
+		const result = checkLimits(makeCounters({ messagesSentCount: 100 }), defaultLimits)
+		expect(result.status).toBe('hard_limit')
+		if (result.status === 'hard_limit') {
+			expect(result.limitName).toBe('maxMessagesSent')
+		}
+	})
+
+	// --- Pattern-based hard limits ---
+
+	it('detects repeated tool calls', () => {
+		const result = checkLimits(
+			makeCounters({ recentToolCallHashes: ['a:1', 'a:1', 'a:1'] }),
+			defaultLimits,
+		)
+		expect(result.status).toBe('hard_limit')
+		if (result.status === 'hard_limit') {
+			expect(result.limitName).toBe('maxRepeatedToolCalls')
+		}
+	})
+
+	it('does not trigger repeated tool calls for different hashes', () => {
+		const result = checkLimits(
+			makeCounters({ recentToolCallHashes: ['a:1', 'a:2', 'a:1'] }),
+			defaultLimits,
+		)
+		expect(result.status).not.toBe('hard_limit')
+	})
+
+	it('detects repeated responses', () => {
+		const result = checkLimits(
+			makeCounters({ recentResponseHashes: ['abc', 'abc', 'abc'] }),
+			defaultLimits,
+		)
+		expect(result.status).toBe('hard_limit')
+		if (result.status === 'hard_limit') {
+			expect(result.limitName).toBe('maxRepeatedResponses')
+		}
+	})
+
+	it('detects consecutive tool failures', () => {
+		const result = checkLimits(
+			makeCounters({ consecutiveToolFailures: { read_file: { count: 3, lastError: 'file not found' } } }),
+			defaultLimits,
+		)
+		expect(result.status).toBe('hard_limit')
+		if (result.status === 'hard_limit') {
+			expect(result.limitName).toBe('maxConsecutiveToolFailures')
+			expect(result.reason).toContain('file not found')
+		}
+	})
+
+	it('does not trigger for tool failures below threshold', () => {
+		const result = checkLimits(
+			makeCounters({ consecutiveToolFailures: { read_file: { count: 2, lastError: 'file not found' } } }),
+			defaultLimits,
+		)
+		expect(result.status).not.toBe('hard_limit')
+	})
+
+	// --- Soft limits ---
+
+	it('detects soft limit warning for maxTurns', () => {
+		const result = checkLimits(makeCounters({ inferenceCount: 80 }), defaultLimits)
+		expect(result.status).toBe('soft_warning')
+		if (result.status === 'soft_warning') {
+			expect(result.limitName).toBe('maxTurns')
+		}
+	})
+
+	it('detects soft limit warning for maxToolCalls', () => {
+		const result = checkLimits(makeCounters({ toolCallCount: 160 }), defaultLimits)
+		expect(result.status).toBe('soft_warning')
+		if (result.status === 'soft_warning') {
+			expect(result.limitName).toBe('maxToolCalls')
+		}
+	})
+
+	// --- Priority: hard > soft > ok ---
+
+	it('hard limit takes priority over soft warning', () => {
+		const result = checkLimits(
+			makeCounters({
+				inferenceCount: 100, // hard
+				toolCallCount: 160, // soft
+			}),
+			defaultLimits,
+		)
+		expect(result.status).toBe('hard_limit')
+	})
+})

package/src/plugins/limits-guard/limit-guard.ts

@@ -0,0 +1,164 @@
+/**
+ * Limit guard - checks agent counters against configured limits.
+ *
+ * Returns the worst result: hard_limit > soft_warning > ok.
+ */
+
+import type { AgentLimits } from '~/plugins/limits-guard/config.js'
+import type { AgentCounters } from './plugin.js'
+
+// ============================================================================
+// Resolved limits (all fields required with defaults)
+// ============================================================================
+
+export interface ResolvedAgentLimits {
+	maxTurns: number
+	maxToolCalls: number
+	maxConsecutiveToolFailures: number
+	maxSpawnedAgents: number
+	maxMessagesSent: number
+	softLimitRatio: number
+	maxRepeatedToolCalls: number
+	maxRepeatedResponses: number
+}
+
+const DEFAULTS: ResolvedAgentLimits = {
+	maxTurns: 100,
+	maxToolCalls: 200,
+	maxConsecutiveToolFailures: 3,
+	maxSpawnedAgents: 10,
+	maxMessagesSent: 100,
+	softLimitRatio: 0.8,
+	maxRepeatedToolCalls: 3,
+	maxRepeatedResponses: 3,
+}
+
+export function resolveAgentLimits(config?: AgentLimits): ResolvedAgentLimits {
+	if (!config) return DEFAULTS
+	return {
+		maxTurns: config.maxTurns ?? DEFAULTS.maxTurns,
+		maxToolCalls: config.maxToolCalls ?? DEFAULTS.maxToolCalls,
+		maxConsecutiveToolFailures: config.maxConsecutiveToolFailures ?? DEFAULTS.maxConsecutiveToolFailures,
+		maxSpawnedAgents: config.maxSpawnedAgents ?? DEFAULTS.maxSpawnedAgents,
+		maxMessagesSent: config.maxMessagesSent ?? DEFAULTS.maxMessagesSent,
+		softLimitRatio: config.softLimitRatio ?? DEFAULTS.softLimitRatio,
+		maxRepeatedToolCalls: config.maxRepeatedToolCalls ?? DEFAULTS.maxRepeatedToolCalls,
+		maxRepeatedResponses: config.maxRepeatedResponses ?? DEFAULTS.maxRepeatedResponses,
+	}
+}
+
+// ============================================================================
+// Check result
+// ============================================================================
+
+export type LimitCheckResult =
+	| { status: 'ok' }
+	| { status: 'soft_warning'; limitName: string; currentValue: number; hardLimit: number; message: string }
+	| { status: 'hard_limit'; limitName: string; currentValue: number; hardLimit: number; reason: string }
+
+// ============================================================================
+// Check logic
+// ============================================================================
+
+export function checkLimits(counters: AgentCounters, limits: ResolvedAgentLimits): LimitCheckResult {
+	// --- Hard limits (counter-based) ---
+
+	const hardChecks: Array<{ name: string; current: number; max: number }> = [
+		{ name: 'maxTurns', current: counters.inferenceCount, max: limits.maxTurns },
+		{ name: 'maxToolCalls', current: counters.toolCallCount, max: limits.maxToolCalls },
+		{ name: 'maxSpawnedAgents', current: counters.spawnedAgentCount, max: limits.maxSpawnedAgents },
+		{ name: 'maxMessagesSent', current: counters.messagesSentCount, max: limits.maxMessagesSent },
+	]
+
+	for (const check of hardChecks) {
+		if (check.current >= check.max) {
+			return {
+				status: 'hard_limit',
+				limitName: check.name,
+				currentValue: check.current,
+				hardLimit: check.max,
+				reason: `${check.name} reached: ${check.current}/${check.max}`,
+			}
+		}
+	}
+
+	// --- Hard limits (pattern-based) ---
+
+	// Consecutive identical tool calls
+	const repeatedToolCalls = countConsecutiveTailDuplicates(counters.recentToolCallHashes)
+	if (repeatedToolCalls >= limits.maxRepeatedToolCalls) {
+		return {
+			status: 'hard_limit',
+			limitName: 'maxRepeatedToolCalls',
+			currentValue: repeatedToolCalls,
+			hardLimit: limits.maxRepeatedToolCalls,
+			reason: `Repeated identical tool call detected (${repeatedToolCalls} times)`,
+		}
+	}
+
+	// Consecutive identical responses
+	const repeatedResponses = countConsecutiveTailDuplicates(counters.recentResponseHashes)
+	if (repeatedResponses >= limits.maxRepeatedResponses) {
+		return {
+			status: 'hard_limit',
+			limitName: 'maxRepeatedResponses',
+			currentValue: repeatedResponses,
+			hardLimit: limits.maxRepeatedResponses,
+			reason: `Repeated identical response detected (${repeatedResponses} times)`,
+		}
+	}
+
+	// Consecutive tool failures (any tool)
+	for (const [toolName, entry] of Object.entries(counters.consecutiveToolFailures)) {
+		if (entry.count >= limits.maxConsecutiveToolFailures) {
+			return {
+				status: 'hard_limit',
+				limitName: 'maxConsecutiveToolFailures',
+				currentValue: entry.count,
+				hardLimit: limits.maxConsecutiveToolFailures,
+				reason: `Tool '${toolName}' failed ${entry.count} consecutive times. Last error: ${entry.lastError}`,
+			}
+		}
+	}
+
+	// --- Soft limits (counter-based) ---
+
+	const softThreshold = limits.softLimitRatio
+
+	for (const check of hardChecks) {
+		const threshold = Math.floor(check.max * softThreshold)
+		if (check.current >= threshold) {
+			return {
+				status: 'soft_warning',
+				limitName: check.name,
+				currentValue: check.current,
+				hardLimit: check.max,
+				message: `Approaching ${check.name} limit: ${check.current}/${check.max}`,
+			}
+		}
+	}
+
+	return { status: 'ok' }
+}
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+/**
+ * Count how many consecutive identical items appear at the end of an array.
+ * Returns 1 if the last item is unique, 0 if array is empty.
+ */
+export function countConsecutiveTailDuplicates(arr: string[]): number {
+	if (arr.length === 0) return 0
+	const last = arr[arr.length - 1]
+	let count = 0
+	for (let i = arr.length - 1; i >= 0; i--) {
+		if (arr[i] === last) {
+			count++
+		} else {
+			break
+		}
+	}
+	return count
+}