@roj-ai/sdk 0.1.35 → 0.2.1

package/src/core/tools/executor.test.ts

@@ -1,161 +0,0 @@
-import { beforeEach, describe, expect, it } from 'bun:test'
-import z from 'zod/v4'
-import { generateTestAgentId } from '~/core/agents/schema.js'
-import { MemoryEventStore } from '~/core/events/index.js'
-import { MockLLMProvider } from '~/core/llm/mock.js'
-import { ModelId } from '~/core/llm/schema.js'
-import { generateSessionId } from '~/core/sessions/schema.js'
-import { createSessionState } from '~/core/sessions/state.js'
-import { Err, Ok } from '~/lib/utils/result.js'
-import { silentLogger } from '../../lib/logger/logger.js'
-import { createNodePlatform } from '~/testing/node-platform.js'
-import { SessionFileStore } from '../file-store/file-store.js'
-import type { ToolContext } from './context.js'
-import { createTool } from './definition.js'
-import { ToolExecutor } from './executor.js'
-
-// ============================================================================
-// Test Helpers
-// ============================================================================
-
-const createTestContext = (): ToolContext => {
-	const sessionId = generateSessionId()
-	const agentId = generateTestAgentId()
-	const sessionState = createSessionState(sessionId, 'test', Date.now())
-	const fileStore = new SessionFileStore('/tmp/test-session', undefined, false, createNodePlatform().fs)
-	const agentState = {
-		id: agentId,
-		definitionName: 'test',
-		parentId: null,
-		status: 'pending' as const,
-		conversationHistory: [],
-		preamble: [],
-		pendingToolCalls: [],
-		pendingToolResults: [],
-		pendingMessages: [],
-	}
-	return {
-		sessionId,
-		sessionState,
-		sessionInput: undefined,
-		environment: { sessionDir: '/tmp/test-session', sandboxed: false },
-		llm: MockLLMProvider.withFixedResponse({ content: '', toolCalls: [], finishReason: 'stop' }),
-		files: fileStore,
-		eventStore: new MemoryEventStore(),
-		platform: createNodePlatform(),
-		logger: silentLogger,
-		emitEvent: async () => {},
-		notify: () => {},
-		agentId,
-		agentState,
-		agentConfig: { systemPrompt: 'test', model: ModelId('test'), spawnableAgents: [] },
-		input: undefined,
-		parentId: null,
-		runAuxiliaryInference: async () => Err({ type: 'invalid_request', message: 'not implemented in test' }),
-	}
-}
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-describe('ToolExecutor', () => {
-	let executor: ToolExecutor
-
-	beforeEach(() => {
-		executor = new ToolExecutor(silentLogger)
-	})
-
-	describe('execute', () => {
-		it('executes tool successfully', async () => {
-			const tool = createTool({
-				name: 'add_one',
-				description: 'Adds one to the input value',
-				input: z.object({ value: z.number() }),
-				execute: async (input) => Ok(JSON.stringify({ result: input.value + 1 })),
-			})
-
-			const context = createTestContext()
-			const result = await executor.execute(tool, { value: 5 }, context)
-
-			expect(result.ok).toBe(true)
-			if (!result.ok) return
-			// Tool returns JSON string directly
-			expect(result.value).toBe('{"result":6}')
-		})
-
-		it('handles tool failure', async () => {
-			const tool = createTool({
-				name: 'failing_tool',
-				description: 'Fails intentionally',
-				input: z.object({}),
-				execute: async () => Err({ message: 'Something went wrong', recoverable: false }),
-			})
-
-			const context = createTestContext()
-			const result = await executor.execute(tool, {}, context)
-
-			expect(result.ok).toBe(false)
-			if (result.ok) return
-			expect(result.error.message).toBe('Something went wrong')
-		})
-
-		it('catches exceptions and returns error', async () => {
-			const tool = createTool({
-				name: 'throwing_tool',
-				description: 'Throws an error',
-				input: z.object({}),
-				execute: async () => {
-					throw new Error('Unexpected error')
-				},
-			})
-
-			const context = createTestContext()
-			const result = await executor.execute(tool, {}, context)
-
-			expect(result.ok).toBe(false)
-			if (result.ok) return
-			expect(result.error.message).toBe('Unexpected error')
-			expect(result.error.recoverable).toBe(false)
-		})
-
-		it('catches non-Error throws', async () => {
-			const tool = createTool({
-				name: 'throwing_string',
-				description: 'Throws a string',
-				input: z.object({}),
-				execute: async () => {
-					throw 'string error'
-				},
-			})
-
-			const context = createTestContext()
-			const result = await executor.execute(tool, {}, context)
-
-			expect(result.ok).toBe(false)
-			if (result.ok) return
-			expect(result.error.message).toBe('string error')
-		})
-
-		it('passes context to tool', async () => {
-			let capturedContext: ToolContext | null = null
-
-			const tool = createTool({
-				name: 'capture_context',
-				description: 'Captures context',
-				input: z.object({}),
-				execute: async (_, ctx) => {
-					capturedContext = ctx
-					return Ok('captured')
-				},
-			})
-
-			const context = createTestContext()
-			await executor.execute(tool, {}, context)
-
-			expect(capturedContext).toBeDefined()
-			expect(capturedContext!.sessionId).toBe(context.sessionId)
-			expect(capturedContext!.agentId).toBe(context.agentId)
-		})
-	})
-})

package/src/lib/logger/console.test.ts

@@ -1,348 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, Mock, spyOn } from 'bun:test'
-import { ConsoleLogger, JsonLogger } from './console.js'
-import type { Logger } from './logger.js'
-
-describe('ConsoleLogger', () => {
-	let consoleSpy: {
-		log: Mock<typeof console.log>
-		warn: Mock<typeof console.warn>
-		error: Mock<typeof console.error>
-	}
-
-	beforeEach(() => {
-		consoleSpy = {
-			log: spyOn(console, 'log').mockImplementation(() => {}),
-			warn: spyOn(console, 'warn').mockImplementation(() => {}),
-			error: spyOn(console, 'error').mockImplementation(() => {}),
-		}
-	})
-
-	afterEach(() => {
-		consoleSpy.log.mockRestore()
-		consoleSpy.warn.mockRestore()
-		consoleSpy.error.mockRestore()
-	})
-
-	describe('log level filtering', () => {
-		it('should log messages at or above configured level', () => {
-			const logger = new ConsoleLogger({ level: 'info', colors: false, timestamps: false })
-
-			logger.debug('debug message')
-			logger.info('info message')
-			logger.warn('warn message')
-			logger.error('error message')
-
-			// debug should be filtered out (use content-based assertions to avoid flakiness from concurrent test files)
-			expect(consoleSpy.log).not.toHaveBeenCalledWith(expect.stringContaining('DEBUG'))
-			expect(consoleSpy.log).toHaveBeenCalledWith('INFO  info message')
-			expect(consoleSpy.warn).toHaveBeenCalledWith('WARN  warn message')
-			expect(consoleSpy.error).toHaveBeenCalledWith('ERROR error message')
-		})
-
-		it('should log all messages at debug level', () => {
-			const logger = new ConsoleLogger({ level: 'debug', colors: false, timestamps: false })
-
-			logger.debug('debug message')
-			logger.info('info message')
-			logger.warn('warn message')
-			logger.error('error message')
-
-			expect(consoleSpy.log).toHaveBeenCalledWith('DEBUG debug message')
-			expect(consoleSpy.log).toHaveBeenCalledWith('INFO  info message')
-			expect(consoleSpy.warn).toHaveBeenCalledWith('WARN  warn message')
-			expect(consoleSpy.error).toHaveBeenCalledWith('ERROR error message')
-		})
-
-		it('should only log errors at error level', () => {
-			const logger = new ConsoleLogger({ level: 'error', colors: false, timestamps: false })
-
-			logger.debug('debug message')
-			logger.info('info message')
-			logger.warn('warn message')
-			logger.error('error message')
-
-			expect(consoleSpy.log).not.toHaveBeenCalledWith(expect.stringContaining('DEBUG'))
-			expect(consoleSpy.log).not.toHaveBeenCalledWith(expect.stringContaining('INFO'))
-			expect(consoleSpy.warn).not.toHaveBeenCalledWith(expect.stringContaining('WARN'))
-			expect(consoleSpy.error).toHaveBeenCalledWith('ERROR error message')
-		})
-	})
-
-	describe('message formatting', () => {
-		it('should format message without context', () => {
-			const logger = new ConsoleLogger({ level: 'info', colors: false, timestamps: false })
-
-			logger.info('test message')
-
-			expect(consoleSpy.log).toHaveBeenCalledWith('INFO  test message')
-		})
-
-		it('should format message with context', () => {
-			const logger = new ConsoleLogger({ level: 'info', colors: false, timestamps: false })
-
-			logger.info('test message', { key: 'value', num: 42 })
-
-			expect(consoleSpy.log).toHaveBeenCalledWith('INFO  test message { key=value num=42 }')
-		})
-
-		it('should format message with object context', () => {
-			const logger = new ConsoleLogger({ level: 'info', colors: false, timestamps: false })
-
-			logger.info('test message', { data: { nested: true } })
-
-			expect(consoleSpy.log).toHaveBeenCalledWith('INFO  test message { data={"nested":true} }')
-		})
-
-		it('should include timestamps when enabled', () => {
-			const logger = new ConsoleLogger({ level: 'info', colors: false, timestamps: true })
-
-			logger.info('test message')
-
-			const call = consoleSpy.log.mock.calls[0][0] as string
-			expect(call).toMatch(/^\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z\] INFO {2}test message$/)
-		})
-
-		it('should use correct console method for each level', () => {
-			const logger = new ConsoleLogger({ level: 'debug', colors: false, timestamps: false })
-
-			logger.debug('debug')
-			logger.info('info')
-			logger.warn('warn')
-			logger.error('error')
-
-			expect(consoleSpy.log).toHaveBeenCalledWith('DEBUG debug')
-			expect(consoleSpy.log).toHaveBeenCalledWith('INFO  info')
-			expect(consoleSpy.warn).toHaveBeenCalledWith('WARN  warn')
-			expect(consoleSpy.error).toHaveBeenCalledWith('ERROR error')
-		})
-	})
-
-	describe('error handling', () => {
-		it('should include error details in context', () => {
-			const logger = new ConsoleLogger({ level: 'error', colors: false, timestamps: false })
-			const error = new Error('Something went wrong')
-
-			logger.error('operation failed', error)
-
-			const call = consoleSpy.error.mock.calls[0][0] as string
-			expect(call).toContain('ERROR operation failed')
-			expect(call).toContain('error={"name":"Error","message":"Something went wrong"')
-			expect(call).toContain('stack')
-		})
-
-		it('should merge error with existing context', () => {
-			const logger = new ConsoleLogger({ level: 'error', colors: false, timestamps: false })
-			const error = new Error('test error')
-
-			logger.error('operation failed', error, { userId: '123' })
-
-			const call = consoleSpy.error.mock.calls[0][0] as string
-			expect(call).toContain('userId=123')
-			expect(call).toContain('error=')
-		})
-	})
-
-	describe('child loggers', () => {
-		it('should create child logger with inherited config', () => {
-			const logger = new ConsoleLogger({ level: 'info', colors: false, timestamps: false })
-			const child = logger.child({ component: 'test' })
-
-			expect(child.level).toBe('info')
-		})
-
-		it('should include parent context in child logs', () => {
-			const logger = new ConsoleLogger({ level: 'info', colors: false, timestamps: false }, { app: 'roj' })
-			const child = logger.child({ component: 'test' })
-
-			child.info('hello')
-
-			expect(consoleSpy.log).toHaveBeenCalledWith('INFO  hello { app=roj component=test }')
-		})
-
-		it('should merge child context with message context', () => {
-			const logger = new ConsoleLogger({ level: 'info', colors: false, timestamps: false })
-			const child = logger.child({ component: 'test' })
-
-			child.info('hello', { extra: 'data' })
-
-			expect(consoleSpy.log).toHaveBeenCalledWith('INFO  hello { component=test extra=data }')
-		})
-
-		it('should allow nested child loggers', () => {
-			const logger = new ConsoleLogger({ level: 'info', colors: false, timestamps: false })
-			const child1 = logger.child({ level1: 'a' })
-			const child2 = child1.child({ level2: 'b' })
-
-			child2.info('nested')
-
-			expect(consoleSpy.log).toHaveBeenCalledWith('INFO  nested { level1=a level2=b }')
-		})
-	})
-
-	describe('colors', () => {
-		it('should include ANSI colors when enabled', () => {
-			const logger = new ConsoleLogger({ level: 'info', colors: true, timestamps: false })
-
-			logger.info('colored message')
-
-			const call = consoleSpy.log.mock.calls[0][0] as string
-			expect(call).toContain('\x1b[32m') // green
-			expect(call).toContain('\x1b[0m') // reset
-		})
-
-		it('should not include colors when disabled', () => {
-			const logger = new ConsoleLogger({ level: 'info', colors: false, timestamps: false })
-
-			logger.info('plain message')
-
-			const call = consoleSpy.log.mock.calls[0][0] as string
-			expect(call).not.toContain('\x1b[')
-		})
-	})
-})
-
-describe('JsonLogger', () => {
-	let consoleSpy: {
-		log: Mock<typeof console.log>
-		warn: Mock<typeof console.warn>
-		error: Mock<typeof console.error>
-	}
-
-	beforeEach(() => {
-		consoleSpy = {
-			log: spyOn(console, 'log').mockImplementation(() => {}),
-			warn: spyOn(console, 'warn').mockImplementation(() => {}),
-			error: spyOn(console, 'error').mockImplementation(() => {}),
-		}
-	})
-
-	afterEach(() => {
-		consoleSpy.log.mockRestore()
-		consoleSpy.warn.mockRestore()
-		consoleSpy.error.mockRestore()
-	})
-
-	describe('log level filtering', () => {
-		it('should filter messages below configured level', () => {
-			const logger = new JsonLogger('warn')
-
-			logger.debug('debug')
-			logger.info('info')
-			logger.warn('warn')
-			logger.error('error')
-
-			expect(consoleSpy.log).toHaveBeenCalledTimes(0)
-			expect(consoleSpy.warn).toHaveBeenCalledTimes(1)
-			expect(consoleSpy.error).toHaveBeenCalledTimes(1)
-		})
-	})
-
-	describe('JSON output', () => {
-		it('should output valid JSON', () => {
-			const logger = new JsonLogger('info')
-
-			logger.info('test message')
-
-			const call = consoleSpy.log.mock.calls[0][0] as string
-			const parsed = JSON.parse(call)
-			expect(parsed).toBeDefined()
-		})
-
-		it('should include all required fields', () => {
-			const logger = new JsonLogger('info')
-
-			logger.info('test message')
-
-			const call = consoleSpy.log.mock.calls[0][0] as string
-			const parsed = JSON.parse(call)
-			expect(parsed.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T/)
-			expect(parsed.level).toBe('info')
-			expect(parsed.message).toBe('test message')
-		})
-
-		it('should include context in JSON output', () => {
-			const logger = new JsonLogger('info')
-
-			logger.info('test message', { key: 'value', count: 5 })
-
-			const call = consoleSpy.log.mock.calls[0][0] as string
-			const parsed = JSON.parse(call)
-			expect(parsed.key).toBe('value')
-			expect(parsed.count).toBe(5)
-		})
-
-		it('should use correct console method for each level', () => {
-			const logger = new JsonLogger('debug')
-
-			logger.debug('debug')
-			logger.info('info')
-			logger.warn('warn')
-			logger.error('error')
-
-			expect(consoleSpy.log).toHaveBeenCalledTimes(2) // debug + info
-			expect(consoleSpy.warn).toHaveBeenCalledTimes(1)
-			expect(consoleSpy.error).toHaveBeenCalledTimes(1)
-		})
-	})
-
-	describe('error handling', () => {
-		it('should include error in JSON output', () => {
-			const logger = new JsonLogger('error')
-			const error = new Error('test error')
-
-			logger.error('failed', error)
-
-			const call = consoleSpy.error.mock.calls[0][0] as string
-			const parsed = JSON.parse(call)
-			expect(parsed.error.name).toBe('Error')
-			expect(parsed.error.message).toBe('test error')
-			expect(parsed.error.stack).toBeDefined()
-		})
-
-		it('should merge error with context', () => {
-			const logger = new JsonLogger('error')
-			const error = new Error('test error')
-
-			logger.error('failed', error, { requestId: 'abc' })
-
-			const call = consoleSpy.error.mock.calls[0][0] as string
-			const parsed = JSON.parse(call)
-			expect(parsed.requestId).toBe('abc')
-			expect(parsed.error).toBeDefined()
-		})
-	})
-
-	describe('child loggers', () => {
-		it('should create child logger with inherited level', () => {
-			const logger = new JsonLogger('warn')
-			const child = logger.child({ service: 'test' })
-
-			expect(child.level).toBe('warn')
-		})
-
-		it('should include base context in child logs', () => {
-			const logger = new JsonLogger('info', { app: 'roj' })
-			const child = logger.child({ component: 'auth' })
-
-			child.info('test')
-
-			const call = consoleSpy.log.mock.calls[0][0] as string
-			const parsed = JSON.parse(call)
-			expect(parsed.app).toBe('roj')
-			expect(parsed.component).toBe('auth')
-		})
-
-		it('should allow nested child loggers', () => {
-			const logger = new JsonLogger('info')
-			const child1 = logger.child({ a: 1 })
-			const child2 = child1.child({ b: 2 })
-
-			child2.info('nested')
-
-			const call = consoleSpy.log.mock.calls[0][0] as string
-			const parsed = JSON.parse(call)
-			expect(parsed.a).toBe(1)
-			expect(parsed.b).toBe(2)
-		})
-	})
-})

package/src/lib/never.ts

@@ -1,3 +0,0 @@
-export const assertNever = (value: never): never => {
-	throw new Error(`Unexpected value: ${JSON.stringify(value)}`)
-}

package/src/lib/utils/concurrency.test.ts

@@ -1,169 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { mapWithConcurrency, Semaphore } from './concurrency.js'
-
-function defer<T = void>(): { promise: Promise<T>; resolve: (v: T) => void; reject: (e: unknown) => void } {
-	let resolve!: (v: T) => void
-	let reject!: (e: unknown) => void
-	const promise = new Promise<T>((res, rej) => {
-		resolve = res
-		reject = rej
-	})
-	return { promise, resolve, reject }
-}
-
-describe('mapWithConcurrency', () => {
-	it('preserves input order regardless of completion order', async () => {
-		const delays = [50, 10, 30, 5, 20]
-		const results = await mapWithConcurrency(delays, 3, async (ms, i) => {
-			await new Promise(r => setTimeout(r, ms))
-			return `${i}:${ms}`
-		})
-		expect(results).toEqual(['0:50', '1:10', '2:30', '3:5', '4:20'])
-	})
-
-	it('does not exceed the concurrency limit', async () => {
-		let active = 0
-		let peak = 0
-		const items = Array.from({ length: 20 }, (_, i) => i)
-
-		await mapWithConcurrency(items, 4, async () => {
-			active++
-			peak = Math.max(peak, active)
-			await new Promise(r => setTimeout(r, 5))
-			active--
-		})
-
-		expect(peak).toBeLessThanOrEqual(4)
-		expect(peak).toBe(4)
-	})
-
-	it('handles empty input without spawning workers', async () => {
-		let calls = 0
-		const results = await mapWithConcurrency([], 5, async () => {
-			calls++
-			return 1
-		})
-		expect(results).toEqual([])
-		expect(calls).toBe(0)
-	})
-
-	it('caps worker count at item count when concurrency > items', async () => {
-		let active = 0
-		let peak = 0
-		const items = [1, 2]
-
-		await mapWithConcurrency(items, 10, async () => {
-			active++
-			peak = Math.max(peak, active)
-			await new Promise(r => setTimeout(r, 5))
-			active--
-		})
-
-		expect(peak).toBe(2)
-	})
-
-	it('propagates errors thrown by the worker fn', async () => {
-		await expect(
-			mapWithConcurrency([1, 2, 3], 2, async (n) => {
-				if (n === 2) throw new Error('boom')
-				return n
-			}),
-		).rejects.toThrow('boom')
-	})
-})
-
-describe('Semaphore', () => {
-	it('rejects invalid limits', () => {
-		expect(() => new Semaphore(0)).toThrow()
-		expect(() => new Semaphore(-1)).toThrow()
-		expect(() => new Semaphore(1.5)).toThrow()
-	})
-
-	it('caps concurrent executions at limit', async () => {
-		const gate = new Semaphore(3)
-		let active = 0
-		let peak = 0
-
-		const tasks = Array.from({ length: 12 }, () =>
-			gate.run(async () => {
-				active++
-				peak = Math.max(peak, active)
-				await new Promise(r => setTimeout(r, 10))
-				active--
-			}),
-		)
-
-		await Promise.all(tasks)
-		expect(peak).toBe(3)
-		expect(active).toBe(0)
-	})
-
-	it('admits waiters in FIFO order', async () => {
-		const gate = new Semaphore(1)
-		const order: number[] = []
-		const blocker = defer()
-
-		// Hold the only slot
-		const held = gate.run(async () => {
-			await blocker.promise
-		})
-
-		// Queue three waiters in known order, with their own blockers so the test
-		// can observe entry order without relying on real timers.
-		const gates = [defer(), defer(), defer()]
-		const queued = gates.map((g, i) =>
-			gate.run(async () => {
-				order.push(i)
-				await g.promise
-			}),
-		)
-
-		// Yield so all three are queued.
-		await new Promise(r => setTimeout(r, 0))
-		expect(order).toEqual([])
-
-		// Release the holder; waiter 0 should run first.
-		blocker.resolve()
-		await new Promise(r => setTimeout(r, 0))
-		expect(order).toEqual([0])
-
-		gates[0]!.resolve()
-		await new Promise(r => setTimeout(r, 0))
-		expect(order).toEqual([0, 1])
-
-		gates[1]!.resolve()
-		await new Promise(r => setTimeout(r, 0))
-		expect(order).toEqual([0, 1, 2])
-
-		gates[2]!.resolve()
-		await Promise.all([held, ...queued])
-	})
-
-	it('releases the slot when the body throws', async () => {
-		const gate = new Semaphore(1)
-
-		await expect(gate.run(async () => {
-			throw new Error('boom')
-		})).rejects.toThrow('boom')
-
-		// Slot must be free again — this would deadlock otherwise.
-		const result = await gate.run(async () => 42)
-		expect(result).toBe(42)
-	})
-
-	it('serializes work under limit=1', async () => {
-		const gate = new Semaphore(1)
-		const events: string[] = []
-
-		const tasks = [0, 1, 2].map(i =>
-			gate.run(async () => {
-				events.push(`start:${i}`)
-				await new Promise(r => setTimeout(r, 5))
-				events.push(`end:${i}`)
-			}),
-		)
-
-		await Promise.all(tasks)
-		expect(events).toEqual(['start:0', 'end:0', 'start:1', 'end:1', 'start:2', 'end:2'])
-	})
-})