@roj-ai/sdk 0.1.36 → 0.2.1

package/src/plugins/resources/resources.integration.test.ts

@@ -1,68 +0,0 @@
-import { afterEach, describe, expect, it } from 'bun:test'
-import { mkdtemp, readFile, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { MockLLMProvider } from '~/core/llm/mock.js'
-import { createTestPreset, TestHarness } from '~/testing/index.js'
-import { resourcesPlugin } from './plugin.js'
-import { resourceEvents, type ResourcesState } from './state.js'
-
-let currentHarness: TestHarness | undefined
-
-afterEach(async () => {
-	if (currentHarness) {
-		await currentHarness.shutdown()
-		currentHarness = undefined
-	}
-})
-
-describe('resources plugin', () => {
-	it('resolves targetDir callback relative to workspace and records it in state', async () => {
-		const workspaceDir = await mkdtemp(join(tmpdir(), 'roj-resources-'))
-		const targetDir = join(workspaceDir, 'packages', 'web')
-
-		try {
-			const harness = new TestHarness({
-				presets: [
-					createTestPreset({
-						workspaceDir,
-						plugins: [
-							resourcesPlugin.configure({
-								targetDir: ({ sessionId, workspaceDir: resolvedWorkspaceDir }) => {
-									expect(sessionId.length).toBeGreaterThan(0)
-									expect(resolvedWorkspaceDir).toBe(workspaceDir)
-									return 'packages/web'
-								},
-							}),
-						],
-					}),
-				],
-				llmProvider: MockLLMProvider.withFixedResponse({ content: 'Ok', toolCalls: [] }),
-			})
-			currentHarness = harness
-
-			const session = await harness.createSession('test')
-			const result = await session.callPluginMethod('resources.inject', {
-				sessionId: String(session.sessionId),
-				filename: 'hello.txt',
-				mimeType: 'text/plain',
-				size: 5,
-				fileBuffer: Buffer.from('hello'),
-			})
-
-			expect(result).toMatchObject({
-				ok: true,
-				value: { paths: ['hello.txt'] },
-			})
-			await expect(readFile(join(targetDir, 'hello.txt'), 'utf-8')).resolves.toBe('hello')
-
-			const resources = session.getPluginState<ResourcesState>('resources')
-			expect(resources?.resources[0]?.targetDir).toBe(targetDir)
-
-			const events = await session.getEventsByType(resourceEvents, 'resource_injected')
-			expect(events[0]?.targetDir).toBe(targetDir)
-		} finally {
-			await rm(workspaceDir, { recursive: true, force: true })
-		}
-	})
-})

package/src/plugins/result-eviction/result-eviction.integration.test.ts

@@ -1,332 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import z from 'zod/v4'
-import { MockLLMProvider } from '~/core/llm/mock.js'
-import { definePlugin } from '~/core/plugins/plugin-builder.js'
-import { createTool } from '~/core/tools/definition.js'
-import { ToolCallId } from '~/core/tools/schema.js'
-import { Ok } from '~/lib/utils/result.js'
-import { createTestPreset, TestHarness } from '~/testing/index.js'
-import { resultEvictionPlugin } from './index.js'
-
-/**
- * Helper plugin that provides a `generate_output` tool returning a string of given size.
- */
-const bigOutputPlugin = definePlugin('big-output')
-	.tools(() => [
-		createTool({
-			name: 'generate_output',
-			description: 'Generate output of a given size',
-			input: z.object({ size: z.number() }),
-			execute: async (input) => Ok('x'.repeat(input.size)),
-		}),
-		// Mirrors a page-snapshot style result: a large JSON/text block plus an
-		// image part. These used to bypass eviction entirely.
-		createTool({
-			name: 'generate_snapshot',
-			description: 'Generate a text + image result of a given text size',
-			input: z.object({ size: z.number() }),
-			execute: async (input) =>
-				Ok([
-					{ type: 'text' as const, text: 'x'.repeat(input.size) },
-					{ type: 'image_url' as const, imageUrl: { url: 'data:image/png;base64,AAAA' } },
-				]),
-		}),
-	])
-	.build()
-
-function createEvictionHarness(options: Omit<ConstructorParameters<typeof TestHarness>[0], 'systemPlugins'>) {
-	return new TestHarness({ ...options, systemPlugins: [resultEvictionPlugin, bigOutputPlugin] })
-}
-
-function createEvictionPreset(overrides?: Parameters<typeof createTestPreset>[0]) {
-	return createTestPreset(overrides)
-}
-
-describe('result-eviction plugin', () => {
-	it('small tool output → returned unchanged', async () => {
-		let toolResultContent: string | null = null
-		const harness = createEvictionHarness({
-			presets: [createEvictionPreset()],
-			mockHandler: (request) => {
-				const callCount = harness.llmProvider.getCallCount()
-				if (callCount === 1) {
-					return {
-						content: null,
-						toolCalls: [{ id: ToolCallId('tc1'), name: 'generate_output', input: { size: 100 } }],
-						finishReason: 'stop',
-						metrics: MockLLMProvider.defaultMetrics(),
-					}
-				}
-				// Capture the tool result
-				for (const msg of request.messages) {
-					if (msg.role === 'tool' && typeof msg.content === 'string') {
-						toolResultContent = msg.content
-					}
-				}
-				return { content: 'Done', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() }
-			},
-		})
-
-		const session = await harness.createSession('test')
-		await session.sendAndWaitForIdle('Generate small output')
-
-		expect(toolResultContent).not.toBeNull()
-		// Should be the full output (100 x's), not truncated
-		expect(toolResultContent!).toBe('x'.repeat(100))
-
-		await harness.shutdown()
-	})
-
-	it('large tool output → truncated with file path', async () => {
-		let toolResultContent: string | null = null
-		const harness = createEvictionHarness({
-			presets: [createEvictionPreset()],
-			mockHandler: (request) => {
-				const callCount = harness.llmProvider.getCallCount()
-				if (callCount === 1) {
-					return {
-						content: null,
-						toolCalls: [{ id: ToolCallId('tc1'), name: 'generate_output', input: { size: 250_000 } }],
-						finishReason: 'stop',
-						metrics: MockLLMProvider.defaultMetrics(),
-					}
-				}
-				for (const msg of request.messages) {
-					if (msg.role === 'tool' && typeof msg.content === 'string') {
-						toolResultContent = msg.content
-					}
-				}
-				return { content: 'Done', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() }
-			},
-		})
-
-		const session = await harness.createSession('test')
-		await session.sendAndWaitForIdle('Generate large output')
-
-		expect(toolResultContent).not.toBeNull()
-		expect(toolResultContent!).toContain('truncated')
-		expect(toolResultContent!).toContain('.results/')
-		expect(toolResultContent!).toContain('Full output saved to:')
-		expect(toolResultContent!.length).toBeLessThan(250_000)
-
-		await harness.shutdown()
-	})
-
-	it('large multi-part output → text evicted, image part kept', async () => {
-		let toolContent: unknown = null
-		const harness = createEvictionHarness({
-			presets: [createEvictionPreset()],
-			mockHandler: (request) => {
-				const callCount = harness.llmProvider.getCallCount()
-				if (callCount === 1) {
-					return {
-						content: null,
-						toolCalls: [{ id: ToolCallId('tc1'), name: 'generate_snapshot', input: { size: 250_000 } }],
-						finishReason: 'stop',
-						metrics: MockLLMProvider.defaultMetrics(),
-					}
-				}
-				for (const msg of request.messages) {
-					if (msg.role === 'tool' && Array.isArray(msg.content)) {
-						toolContent = msg.content
-					}
-				}
-				return { content: 'Done', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() }
-			},
-		})
-
-		const session = await harness.createSession('test')
-		await session.sendAndWaitForIdle('Generate large snapshot')
-
-		expect(Array.isArray(toolContent)).toBe(true)
-		const parts = toolContent as Array<{ type: string; text?: string }>
-
-		// Text collapsed to a preview that names the spill file...
-		const textParts = parts.filter((p) => p.type === 'text')
-		expect(textParts).toHaveLength(1)
-		expect(textParts[0].text).toContain('truncated')
-		expect(textParts[0].text).toContain('.results/')
-		expect(textParts[0].text!.length).toBeLessThan(250_000)
-
-		// ...and the image survives, because there is no partial image: the only
-		// alternative to keeping it is losing the observation.
-		expect(parts.filter((p) => p.type === 'image_url')).toHaveLength(1)
-
-		await harness.shutdown()
-	})
-
-	it('small multi-part output → returned unchanged', async () => {
-		let toolContent: unknown = null
-		const harness = createEvictionHarness({
-			presets: [createEvictionPreset()],
-			mockHandler: (request) => {
-				const callCount = harness.llmProvider.getCallCount()
-				if (callCount === 1) {
-					return {
-						content: null,
-						toolCalls: [{ id: ToolCallId('tc1'), name: 'generate_snapshot', input: { size: 100 } }],
-						finishReason: 'stop',
-						metrics: MockLLMProvider.defaultMetrics(),
-					}
-				}
-				for (const msg of request.messages) {
-					if (msg.role === 'tool' && Array.isArray(msg.content)) {
-						toolContent = msg.content
-					}
-				}
-				return { content: 'Done', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() }
-			},
-		})
-
-		const session = await harness.createSession('test')
-		await session.sendAndWaitForIdle('Generate small snapshot')
-
-		const parts = toolContent as Array<{ type: string; text?: string }>
-		expect(parts.filter((p) => p.type === 'text')[0].text).toBe('x'.repeat(100))
-		expect(parts.filter((p) => p.type === 'image_url')).toHaveLength(1)
-
-		await harness.shutdown()
-	})
-
-	it('full output saved to .results/<toolCallId>.txt', async () => {
-		const harness = createEvictionHarness({
-			presets: [createEvictionPreset()],
-			llmProvider: MockLLMProvider.withSequence([
-				{
-					toolCalls: [{ id: ToolCallId('tc1'), name: 'generate_output', input: { size: 250_000 } }],
-				},
-				{ content: 'Done', toolCalls: [] },
-			]),
-		})
-
-		const session = await harness.createSession('test')
-		await session.sendAndWaitForIdle('Generate large output')
-
-		// Verify the tool_completed event has evicted (truncated) content
-		const toolCompletedEvents = await session.getEventsByType('tool_completed')
-		expect(toolCompletedEvents.length).toBeGreaterThanOrEqual(1)
-
-		await harness.shutdown()
-	})
-
-	it('enabled: false → no eviction even for large output', async () => {
-		let toolResultContent: string | null = null
-		const harness = createEvictionHarness({
-			presets: [createEvictionPreset({
-				orchestratorPlugins: [
-					resultEvictionPlugin.configureAgent({ enabled: false }),
-				],
-			})],
-			mockHandler: (request) => {
-				const callCount = harness.llmProvider.getCallCount()
-				if (callCount === 1) {
-					return {
-						content: null,
-						toolCalls: [{ id: ToolCallId('tc1'), name: 'generate_output', input: { size: 250_000 } }],
-						finishReason: 'stop',
-						metrics: MockLLMProvider.defaultMetrics(),
-					}
-				}
-				for (const msg of request.messages) {
-					if (msg.role === 'tool' && typeof msg.content === 'string') {
-						toolResultContent = msg.content
-					}
-				}
-				return { content: 'Done', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() }
-			},
-		})
-
-		const session = await harness.createSession('test')
-		await session.sendAndWaitForIdle('Generate large output')
-
-		expect(toolResultContent).not.toBeNull()
-		// With eviction disabled, the full output should be returned
-		expect(toolResultContent!).toBe('x'.repeat(250_000))
-
-		await harness.shutdown()
-	})
-
-	it('custom maxTokens respected', async () => {
-		let toolResultContent: string | null = null
-		const harness = createEvictionHarness({
-			presets: [createEvictionPreset({
-				orchestratorPlugins: [
-					resultEvictionPlugin.configureAgent({ config: { maxTokens: 10 } }),
-				],
-			})],
-			mockHandler: (request) => {
-				const callCount = harness.llmProvider.getCallCount()
-				if (callCount === 1) {
-					return {
-						content: null,
-						toolCalls: [{ id: ToolCallId('tc1'), name: 'generate_output', input: { size: 200 } }],
-						finishReason: 'stop',
-						metrics: MockLLMProvider.defaultMetrics(),
-					}
-				}
-				for (const msg of request.messages) {
-					if (msg.role === 'tool' && typeof msg.content === 'string') {
-						toolResultContent = msg.content
-					}
-				}
-				return { content: 'Done', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() }
-			},
-		})
-
-		const session = await harness.createSession('test')
-		await session.sendAndWaitForIdle('Generate output')
-
-		expect(toolResultContent).not.toBeNull()
-		// With maxTokens=10, 200 chars should be evicted
-		expect(toolResultContent!).toContain('truncated')
-		expect(toolResultContent!).toContain('.results/')
-
-		await harness.shutdown()
-	})
-
-	it('error tool results → not evicted even if large', async () => {
-		// Create a plugin with a tool that always errors with large content
-		const errorToolPlugin = definePlugin('error-tool')
-			.tools(() => [
-				createTool({
-					name: 'always_error',
-					description: 'Always errors with large output',
-					input: z.object({}),
-					execute: async () => ({ ok: false, error: { message: 'ERROR_CONTENT_' + 'x'.repeat(250_000), recoverable: true } }),
-				}),
-			])
-			.build()
-
-		let toolResultContent: string | null = null
-		const harness = new TestHarness({
-			presets: [createEvictionPreset()],
-			systemPlugins: [resultEvictionPlugin, errorToolPlugin],
-			mockHandler: (request) => {
-				const callCount = harness.llmProvider.getCallCount()
-				if (callCount === 1) {
-					return {
-						content: null,
-						toolCalls: [{ id: ToolCallId('tc1'), name: 'always_error', input: {} }],
-						finishReason: 'stop',
-						metrics: MockLLMProvider.defaultMetrics(),
-					}
-				}
-				for (const msg of request.messages) {
-					if (msg.role === 'tool' && typeof msg.content === 'string' && msg.content.includes('ERROR_CONTENT_')) {
-						toolResultContent = msg.content
-					}
-				}
-				return { content: 'Done', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() }
-			},
-		})
-
-		const session = await harness.createSession('test')
-		await session.sendAndWaitForIdle('Try error')
-
-		// Error results should NOT be evicted — so no truncation markers
-		expect(toolResultContent).not.toBeNull()
-		expect(toolResultContent!).not.toContain('Full output saved to:')
-
-		await harness.shutdown()
-	})
-})

package/src/plugins/services/pid-registry.test.ts

@@ -1,180 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { spawn } from 'node:child_process'
-import { readdir, readFile, mkdtemp, rm, writeFile, mkdir } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { silentLogger } from '~/lib/logger/logger.js'
-import { createNodePlatform } from '~/testing/node-platform.js'
-import { ServicePidRegistry } from './pid-registry.js'
-import { getProcessStartTime } from './service.js'
-
-const fs = createNodePlatform().fs
-
-async function withDataDir<T>(fn: (dataPath: string) => Promise<T>): Promise<T> {
-	const dataPath = await mkdtemp(join(tmpdir(), 'pid-registry-'))
-	try {
-		return await fn(dataPath)
-	} finally {
-		await rm(dataPath, { recursive: true, force: true })
-	}
-}
-
-/** A detached `sleep`, so `kill(-pid)` has a real process group to take down. */
-function spawnVictim(): { pid: number; exited: Promise<void> } {
-	const child = spawn('/bin/sh', ['-c', 'sleep 60'], { detached: true, stdio: 'ignore' })
-	child.unref()
-	if (!child.pid) throw new Error('failed to spawn victim')
-	const exited = new Promise<void>(resolve => child.on('close', () => resolve()))
-	return { pid: child.pid, exited }
-}
-
-function isAlive(pid: number): boolean {
-	try {
-		process.kill(pid, 0)
-		return true
-	} catch {
-		return false
-	}
-}
-
-/** A pid the kernel cannot have handed out, so it reads as a dead agent. */
-async function unusablePid(): Promise<number> {
-	const max = Number((await readFile('/proc/sys/kernel/pid_max', 'utf-8')).trim())
-	return max + 1
-}
-
-async function writeRecord(dataPath: string, record: Record<string, unknown>): Promise<string> {
-	const dir = join(dataPath, 'service-pids')
-	await mkdir(dir, { recursive: true })
-	const path = join(dir, `${record.sessionId}__${record.serviceType}.json`)
-	await writeFile(path, JSON.stringify(record))
-	return path
-}
-
-const makeRegistry = (dataPath: string) => new ServicePidRegistry(fs, silentLogger, dataPath)
-
-describe('ServicePidRegistry', () => {
-	it('kills a service left behind by an agent that is gone, and drops the record', async () => {
-		await withDataDir(async dataPath => {
-			const victim = spawnVictim()
-			await writeRecord(dataPath, {
-				sessionId: 'sess-1',
-				serviceType: 'astro-dev',
-				pid: victim.pid,
-				pidStartTime: await getProcessStartTime(fs, victim.pid),
-				command: 'sleep 60',
-				agentPid: await unusablePid(),
-				agentStartTime: 12345,
-			})
-
-			await makeRegistry(dataPath).sweepOrphans()
-
-			await victim.exited
-			expect(isAlive(victim.pid)).toBe(false)
-			expect(await readdir(join(dataPath, 'service-pids'))).toEqual([])
-		})
-	})
-
-	it('leaves a service whose agent is still running', async () => {
-		await withDataDir(async dataPath => {
-			const victim = spawnVictim()
-			try {
-				// This test process stands in for a second, still-live agent.
-				await writeRecord(dataPath, {
-					sessionId: 'sess-1',
-					serviceType: 'astro-dev',
-					pid: victim.pid,
-					pidStartTime: await getProcessStartTime(fs, victim.pid),
-					command: 'sleep 60',
-					agentPid: process.pid,
-					agentStartTime: await getProcessStartTime(fs, process.pid),
-				})
-
-				await makeRegistry(dataPath).sweepOrphans()
-
-				expect(isAlive(victim.pid)).toBe(true)
-				expect(await readdir(join(dataPath, 'service-pids'))).toHaveLength(1)
-			} finally {
-				process.kill(-victim.pid, 'SIGKILL')
-			}
-		})
-	})
-
-	it('refuses to kill when the pid has been recycled', async () => {
-		await withDataDir(async dataPath => {
-			const victim = spawnVictim()
-			try {
-				const actual = await getProcessStartTime(fs, victim.pid)
-				await writeRecord(dataPath, {
-					sessionId: 'sess-1',
-					serviceType: 'astro-dev',
-					pid: victim.pid,
-					// Deliberately not the process now holding this pid.
-					pidStartTime: (actual ?? 0) + 999,
-					command: 'sleep 60',
-					agentPid: await unusablePid(),
-				})
-
-				await makeRegistry(dataPath).sweepOrphans()
-
-				expect(isAlive(victim.pid)).toBe(true)
-				// The record still goes — whatever holds that pid now, it is not ours to track.
-				expect(await readdir(join(dataPath, 'service-pids'))).toEqual([])
-			} finally {
-				process.kill(-victim.pid, 'SIGKILL')
-			}
-		})
-	})
-
-	it('never sweeps what this very process started', async () => {
-		await withDataDir(async dataPath => {
-			const registry = makeRegistry(dataPath)
-			const victim = spawnVictim()
-			try {
-				await registry.record({
-					sessionId: 'sess-1',
-					serviceType: 'astro-dev',
-					pid: victim.pid,
-					pidStartTime: await getProcessStartTime(fs, victim.pid),
-					command: 'sleep 60',
-				})
-
-				await registry.sweepOrphans()
-
-				expect(isAlive(victim.pid)).toBe(true)
-			} finally {
-				process.kill(-victim.pid, 'SIGKILL')
-			}
-		})
-	})
-
-	it('drops an unreadable record instead of throwing', async () => {
-		await withDataDir(async dataPath => {
-			const dir = join(dataPath, 'service-pids')
-			await mkdir(dir, { recursive: true })
-			await writeFile(join(dir, 'sess-1__astro-dev.json'), 'not json')
-
-			await makeRegistry(dataPath).sweepOrphans()
-
-			expect(await readdir(dir)).toEqual([])
-		})
-	})
-
-	it('does nothing when no service has ever been recorded', async () => {
-		await withDataDir(async dataPath => {
-			await makeRegistry(dataPath).sweepOrphans()
-		})
-	})
-
-	it('forget removes the record for a service that has exited', async () => {
-		await withDataDir(async dataPath => {
-			const registry = makeRegistry(dataPath)
-			await registry.record({ sessionId: 'sess-1', serviceType: 'astro-dev', pid: 1, pidStartTime: 1, command: 'x' })
-			expect(await readdir(join(dataPath, 'service-pids'))).toHaveLength(1)
-
-			await registry.forget('sess-1', 'astro-dev')
-
-			expect(await readdir(join(dataPath, 'service-pids'))).toEqual([])
-		})
-	})
-})