@roj-ai/sdk 0.1.35 → 0.2.1

package/src/core/session-lifecycle.integration.test.ts

@@ -1,202 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { AgentId } from '~/core/agents/schema.js'
-import { agentEvents } from '~/core/agents/state.js'
-import { MockLLMProvider } from '~/core/llm/mock.js'
-import { ModelId } from '~/core/llm/schema.js'
-import { SessionId } from '~/core/sessions/schema.js'
-import { sessionEvents } from '~/core/sessions/state.js'
-import { createTestPreset, TestHarness } from '~/testing/index.js'
-
-describe('core: session lifecycle', () => {
-	it('create session → session_created event emitted', async () => {
-		const harness = new TestHarness({
-			presets: [createTestPreset()],
-			llmProvider: MockLLMProvider.withFixedResponse({ content: 'Ok', toolCalls: [] }),
-		})
-
-		const session = await harness.createSession('test')
-
-		const events = await session.getEventsByType(sessionEvents, 'session_created')
-		expect(events).toHaveLength(1)
-		expect(events[0].presetId).toBe('test')
-
-		await harness.shutdown()
-	})
-
-	it('create session → orchestrator agent spawned automatically', async () => {
-		const harness = new TestHarness({
-			presets: [createTestPreset()],
-			llmProvider: MockLLMProvider.withFixedResponse({ content: 'Ok', toolCalls: [] }),
-		})
-
-		const session = await harness.createSession('test')
-
-		const spawnEvents = await session.getEventsByType(agentEvents, 'agent_spawned')
-		expect(spawnEvents.length).toBeGreaterThanOrEqual(1)
-
-		// The orchestrator should be the entry agent
-		const entryAgentId = session.getEntryAgentId()
-		expect(entryAgentId).not.toBeNull()
-
-		const agentState = session.state.agents.get(entryAgentId!)
-		expect(agentState).toBeDefined()
-
-		await harness.shutdown()
-	})
-
-	it('create session with communicator config → both communicator and orchestrator spawned', async () => {
-		const harness = new TestHarness({
-			presets: [{
-				id: 'test-comm',
-				name: 'Test with communicator',
-				orchestrator: {
-					system: 'Orchestrator.',
-					model: ModelId('mock'),
-					tools: [],
-					agents: [],
-					debounceMs: 0,
-				},
-				communicator: {
-					system: 'Communicator.',
-					model: ModelId('mock'),
-					debounceMs: 0,
-				},
-				agents: [],
-			}],
-			llmProvider: MockLLMProvider.withFixedResponse({ content: 'Ok', toolCalls: [] }),
-		})
-
-		const session = await harness.createSession('test-comm')
-
-		const spawnEvents = await session.getEventsByType(agentEvents, 'agent_spawned')
-		// Should have both communicator and orchestrator
-		expect(spawnEvents.length).toBeGreaterThanOrEqual(2)
-
-		// Entry agent should be the communicator
-		const entryAgentId = session.getEntryAgentId()
-		expect(entryAgentId).not.toBeNull()
-
-		// Both agents should exist in state
-		expect(session.state.agents.size).toBeGreaterThanOrEqual(2)
-
-		await harness.shutdown()
-	})
-
-	it('close session → session_closed event → status becomes closed', async () => {
-		const harness = new TestHarness({
-			presets: [createTestPreset()],
-			llmProvider: MockLLMProvider.withFixedResponse({ content: 'Ok', toolCalls: [] }),
-		})
-
-		const session = await harness.createSession('test')
-		await session.sendAndWaitForIdle('Hi')
-
-		await session.close()
-
-		// Reload the session to check state
-		const reloaded = await harness.sessionManager.getSession(session.sessionId)
-		expect(reloaded.ok).toBe(true)
-		if (reloaded.ok) {
-			expect(reloaded.value.state.status).toBe('closed')
-
-			const closedEvents = await harness.eventStore.getEventsByType(session.sessionId, 'session_closed')
-			expect(closedEvents).toHaveLength(1)
-		}
-
-		await harness.shutdown()
-	})
-
-	it('reopen session → session_reopened event → agents can process again', async () => {
-		const harness = new TestHarness({
-			presets: [createTestPreset()],
-			llmProvider: MockLLMProvider.withFixedResponse({ content: 'Ok', toolCalls: [] }),
-		})
-
-		const session = await harness.createSession('test')
-		await session.sendAndWaitForIdle('Hi')
-
-		// Close
-		await session.close()
-
-		// Reopen via plugin method (need to reload first)
-		const reloaded = await harness.sessionManager.getSession(session.sessionId)
-		expect(reloaded.ok).toBe(true)
-		if (reloaded.ok) {
-			const reopenResult = await reloaded.value.callPluginMethod('sessions.reopen', {})
-			expect(reopenResult.ok).toBe(true)
-
-			const reopenedEvents = await harness.eventStore.getEventsByType(session.sessionId, 'session_reopened')
-			expect(reopenedEvents).toHaveLength(1)
-
-			// Session should be active again
-			expect(reloaded.value.state.status).toBe('active')
-		}
-
-		await harness.shutdown()
-	})
-
-	it('session state reconstructed correctly from events', async () => {
-		const harness = new TestHarness({
-			presets: [createTestPreset()],
-			llmProvider: MockLLMProvider.withFixedResponse({ content: 'Ok', toolCalls: [] }),
-		})
-
-		const session = await harness.createSession('test')
-		await session.sendAndWaitForIdle('Hello')
-
-		const originalState = session.state
-		const originalAgentCount = originalState.agents.size
-		const originalPresetId = originalState.presetId
-
-		// Reload session from event store (simulates restart)
-		const reloaded = await harness.sessionManager.getSession(session.sessionId)
-		expect(reloaded.ok).toBe(true)
-		if (reloaded.ok) {
-			const reloadedState = reloaded.value.state
-			expect(reloadedState.presetId).toBe(originalPresetId)
-			expect(reloadedState.agents.size).toBe(originalAgentCount)
-			expect(reloadedState.status).toBe('active')
-		}
-
-		await harness.shutdown()
-	})
-
-	it('fork session → new session with events up to fork point, independent processing', async () => {
-		const harness = new TestHarness({
-			presets: [createTestPreset()],
-			llmProvider: MockLLMProvider.withFixedResponse({ content: 'Ok', toolCalls: [] }),
-		})
-
-		const session = await harness.createSession('test')
-		await session.sendAndWaitForIdle('Message 1')
-		await session.sendAndWaitForIdle('Message 2')
-
-		const originalEvents = await session.getEvents()
-		// Fork at roughly half the events
-		const forkIndex = Math.floor(originalEvents.length / 2)
-
-		const forkResult = await harness.sessionManager.callManagerMethod('sessions.fork', {
-			sessionId: String(session.sessionId),
-			eventIndex: forkIndex,
-		})
-
-		expect(forkResult.ok).toBe(true)
-		if (forkResult.ok) {
-			expect(forkResult.value).toMatchObject({ sessionId: expect.any(String) })
-		}
-
-		if (forkResult.ok && typeof forkResult.value === 'object' && forkResult.value !== null && 'sessionId' in forkResult.value) {
-			const forkedSessionId = SessionId(String(forkResult.value.sessionId))
-
-			// Forked session should have fewer events than the original
-			const forkedEvents = await harness.eventStore.load(forkedSessionId)
-			expect(forkedEvents.length).toBeLessThan(originalEvents.length)
-
-			// Original session should be unaffected
-			const originalEventsAfter = await session.getEvents()
-			expect(originalEventsAfter.length).toBe(originalEvents.length)
-		}
-
-		await harness.shutdown()
-	})
-})

package/src/core/sessions/fork-utils.test.ts

@@ -1,158 +0,0 @@
-import { AgentId } from '~/core/agents/schema.js'
-import { agentEvents } from '~/core/agents/state.js'
-import { withSessionId } from '~/core/events/test-helpers.js'
-import type { DomainEvent, FactoryEventType } from '~/core/events/types.js'
-import { SessionId } from '~/core/sessions/schema.js'
-import { sessionEvents } from '~/core/sessions/state.js'
-import type { SessionCreatedEvent } from '~/core/sessions/state.js'
-import { ToolCallId } from '~/core/tools/schema.js'
-import { toolEvents } from '~/core/tools/state.js'
-
-type ToolEvent = FactoryEventType<typeof toolEvents>
-import { describe, expect, it } from 'bun:test'
-import { findSnapshotRefsAtIndex, rewriteEventsForFork } from './fork-utils.js'
-
-const sourceSessionId = SessionId('source-session-id')
-const newSessionId = SessionId('new-session-id')
-const agentId = AgentId('agent-1')
-
-function makeEvents(): DomainEvent[] {
-	return [
-		{
-			...withSessionId(
-				sourceSessionId,
-				sessionEvents.create('session_created', {
-					presetId: 'test-preset',
-					workspaceDir: '/workspace/source',
-				}),
-			),
-			timestamp: 1000,
-		},
-		{
-			...withSessionId(
-				sourceSessionId,
-				agentEvents.create('agent_spawned', {
-					agentId,
-					definitionName: 'orchestrator',
-					parentId: null,
-				}),
-			),
-			timestamp: 1001,
-		},
-		{
-			...withSessionId(
-				sourceSessionId,
-				toolEvents.create('tool_completed', {
-					agentId,
-					toolCallId: ToolCallId('tc-1'),
-					result: 'done',
-					sessionRef: 'session-ref-1',
-					workspaceRef: 'workspace-ref-1',
-				}),
-			),
-			timestamp: 1002,
-		},
-		{
-			...withSessionId(
-				sourceSessionId,
-				toolEvents.create('tool_completed', {
-					agentId,
-					toolCallId: ToolCallId('tc-2'),
-					result: 'done again',
-					sessionRef: 'session-ref-2',
-				}),
-			),
-			timestamp: 1003,
-		},
-		{
-			...withSessionId(
-				sourceSessionId,
-				toolEvents.create('tool_failed', {
-					agentId,
-					toolCallId: ToolCallId('tc-3'),
-					error: 'oops',
-					workspaceRef: 'workspace-ref-3',
-					sessionRef: 'session-ref-3',
-				}),
-			),
-			timestamp: 1004,
-		},
-	]
-}
-
-describe('rewriteEventsForFork', () => {
-	it('slices events up to eventIndex inclusive', () => {
-		const events = makeEvents()
-		const result = rewriteEventsForFork(events, 2, newSessionId, sourceSessionId)
-		expect(result).toHaveLength(3)
-	})
-
-	it('rewrites sessionId on all events', () => {
-		const events = makeEvents()
-		const result = rewriteEventsForFork(events, 2, newSessionId, sourceSessionId)
-		for (const event of result) {
-			expect(event.sessionId).toBe(newSessionId)
-		}
-	})
-
-	it('adds forkedFrom to session_created event', () => {
-		const events = makeEvents()
-		const result = rewriteEventsForFork(events, 2, newSessionId, sourceSessionId)
-		const created = result[0] as SessionCreatedEvent
-		expect(created.type).toBe('session_created')
-		expect(created.forkedFrom).toEqual({
-			sessionId: sourceSessionId,
-			eventIndex: 2,
-		})
-	})
-
-	it('preserves all other event fields', () => {
-		const events = makeEvents()
-		const result = rewriteEventsForFork(events, 2, newSessionId, sourceSessionId)
-		const toolEvent = result[2] as ToolEvent
-		expect(toolEvent.type).toBe('tool_completed')
-		if (toolEvent.type === 'tool_completed') {
-			expect(toolEvent.sessionRef).toBe('session-ref-1')
-			expect(toolEvent.workspaceRef).toBe('workspace-ref-1')
-			expect(toolEvent.result).toBe('done')
-		}
-	})
-
-	it('handles eventIndex 0 (only session_created)', () => {
-		const events = makeEvents()
-		const result = rewriteEventsForFork(events, 0, newSessionId, sourceSessionId)
-		expect(result).toHaveLength(1)
-		expect(result[0].type).toBe('session_created')
-	})
-})
-
-describe('findSnapshotRefsAtIndex', () => {
-	it('finds the most recent refs scanning backwards', () => {
-		const events = makeEvents()
-		const refs = findSnapshotRefsAtIndex(events, 4)
-		expect(refs.sessionRef).toBe('session-ref-3')
-		expect(refs.workspaceRef).toBe('workspace-ref-3')
-	})
-
-	it('finds refs at exact index', () => {
-		const events = makeEvents()
-		const refs = findSnapshotRefsAtIndex(events, 2)
-		expect(refs.sessionRef).toBe('session-ref-1')
-		expect(refs.workspaceRef).toBe('workspace-ref-1')
-	})
-
-	it('falls back to earlier events for missing refs', () => {
-		const events = makeEvents()
-		// Event 3 has sessionRef but no workspaceRef, should fall back to event 2 for workspaceRef
-		const refs = findSnapshotRefsAtIndex(events, 3)
-		expect(refs.sessionRef).toBe('session-ref-2')
-		expect(refs.workspaceRef).toBe('workspace-ref-1')
-	})
-
-	it('returns undefined refs when no events have them', () => {
-		const events = makeEvents()
-		const refs = findSnapshotRefsAtIndex(events, 1)
-		expect(refs.sessionRef).toBeUndefined()
-		expect(refs.workspaceRef).toBeUndefined()
-	})
-})

package/src/core/sessions/session-overrides.integration.test.ts

@@ -1,210 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import { ORCHESTRATOR_ROLE } from '~/core/agents/agent-roles.js'
-import { MockLLMProvider } from '~/core/llm/mock.js'
-import { ModelId } from '~/core/llm/schema.js'
-import { createTestPreset, TestHarness } from '~/testing/index.js'
-
-const LUNA = ModelId('openai/gpt-5.6-luna')
-const KIMI = ModelId('moonshotai/kimi-k3')
-
-/** Models the mock provider was actually asked for, in call order. */
-const modelsUsed = (llmProvider: MockLLMProvider): string[] => llmProvider.getCallHistory().map(request => String(request.model))
-
-const newHarness = () =>
-	new TestHarness({
-		presets: [createTestPreset({ agents: [{ name: 'worker', system: 'worker' }] })],
-		llmProvider: MockLLMProvider.withFixedResponse({ content: 'ok', toolCalls: [] }),
-	})
-
-describe('session overrides', () => {
-	it('uses the preset model when no override is set', async () => {
-		const harness = newHarness()
-		const session = await harness.createSession('test')
-
-		await session.sendAndWaitForIdle('hello')
-
-		expect(modelsUsed(harness.llmProvider)).toEqual(['mock'])
-
-		await harness.shutdown()
-	})
-
-	it('applies an override seeded at session creation', async () => {
-		const harness = newHarness()
-		const session = await harness.createSession('test', {
-			overrides: { agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } },
-		})
-
-		await session.sendAndWaitForIdle('hello')
-
-		expect(modelsUsed(harness.llmProvider)).toEqual([String(LUNA)])
-
-		await harness.shutdown()
-	})
-
-	// The point of resolving the model per inference instead of freezing it on the
-	// Agent at construction: this agent is already built and has already run a turn.
-	it('applies an override set at runtime to an already-running agent', async () => {
-		const harness = newHarness()
-		const session = await harness.createSession('test')
-
-		await session.sendAndWaitForIdle('before')
-		await session.setOverrides({ agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } })
-		await session.sendAndWaitForIdle('after')
-
-		expect(modelsUsed(harness.llmProvider)).toEqual(['mock', String(LUNA)])
-
-		await harness.shutdown()
-	})
-
-	it('reverts to the preset model when an override is cleared with null', async () => {
-		const harness = newHarness()
-		const session = await harness.createSession('test', {
-			overrides: { agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } },
-		})
-
-		await session.sendAndWaitForIdle('before')
-		await session.setOverrides({ agents: { [ORCHESTRATOR_ROLE]: null } })
-		await session.sendAndWaitForIdle('after')
-
-		expect(modelsUsed(harness.llmProvider)).toEqual([String(LUNA), 'mock'])
-
-		await harness.shutdown()
-	})
-
-	it('falls back to defaults for an agent with no entry of its own', async () => {
-		const harness = newHarness()
-		const session = await harness.createSession('test', { overrides: { defaults: { model: KIMI } } })
-
-		await session.sendAndWaitForIdle('hello')
-
-		expect(modelsUsed(harness.llmProvider)).toEqual([String(KIMI)])
-
-		await harness.shutdown()
-	})
-
-	it('lets a per-agent entry win over defaults', async () => {
-		const harness = newHarness()
-		const session = await harness.createSession('test', {
-			overrides: { defaults: { model: KIMI }, agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } },
-		})
-
-		await session.sendAndWaitForIdle('hello')
-
-		expect(modelsUsed(harness.llmProvider)).toEqual([String(LUNA)])
-
-		await harness.shutdown()
-	})
-
-	it('leaves defaults alone when a patch only touches agents', async () => {
-		const harness = newHarness()
-		const session = await harness.createSession('test', { overrides: { defaults: { model: KIMI } } })
-
-		await session.setOverrides({ agents: { worker: { model: LUNA } } })
-		await session.sendAndWaitForIdle('hello')
-
-		// The orchestrator still resolves through the untouched defaults.
-		expect(modelsUsed(harness.llmProvider)).toEqual([String(KIMI)])
-
-		await harness.shutdown()
-	})
-
-	it('rejects an override targeting an agent the preset does not define', async () => {
-		const harness = newHarness()
-
-		const result = await harness.createSessionResult('test', {
-			overrides: { agents: { 'no-such-agent': { model: LUNA } } },
-		})
-
-		expect(result.ok).toBe(false)
-		if (!result.ok) {
-			expect(result.error.message).toContain('no-such-agent')
-		}
-
-		await harness.shutdown()
-	})
-
-	// The RPC surface the worker actually calls.
-	describe('sessions.setOverrides', () => {
-		it('sets the override and echoes back the resolved state', async () => {
-			const harness = newHarness()
-			const session = await harness.createSession('test')
-
-			const result = await harness.sessionManager.callManagerMethod('sessions.setOverrides', {
-				sessionId: String(session.sessionId),
-				overrides: { agents: { worker: { model: LUNA } }, defaults: { model: KIMI } },
-			})
-
-			expect(result.ok).toBe(true)
-			if (result.ok) {
-				expect(result.value).toEqual({
-					agents: { worker: { model: LUNA } },
-					defaults: { model: KIMI },
-				})
-			}
-
-			await harness.shutdown()
-		})
-
-		it('rejects an unknown agent name and names what the preset defines', async () => {
-			const harness = newHarness()
-			const session = await harness.createSession('test')
-
-			const result = await harness.sessionManager.callManagerMethod('sessions.setOverrides', {
-				sessionId: String(session.sessionId),
-				overrides: { agents: { wrker: { model: LUNA } } },
-			})
-
-			expect(result.ok).toBe(false)
-			if (!result.ok) {
-				expect(result.error.message).toContain('wrker')
-				expect(result.error.message).toContain('worker')
-			}
-
-			await harness.shutdown()
-		})
-
-		it('reports the effective overrides back through sessions.get', async () => {
-			const harness = newHarness()
-			const session = await harness.createSession('test', {
-				overrides: { agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } },
-			})
-
-			const result = await harness.sessionManager.callPluginMethod(
-				session.sessionId,
-				'sessions.get',
-				{ sessionId: String(session.sessionId) },
-			)
-
-			expect(result.ok).toBe(true)
-			if (result.ok) {
-				expect(result.value).toMatchObject({
-					overrides: { agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } },
-				})
-			}
-
-			await harness.shutdown()
-		})
-	})
-
-	// Overrides are state like any other, so they must survive a replay rather than
-	// living only on the in-memory Session that happened to accept the patch.
-	it('reconstructs overrides when the session is reopened from the event store', async () => {
-		const harness = newHarness()
-		const session = await harness.createSession('test')
-		await session.setOverrides({ agents: { [ORCHESTRATOR_ROLE]: { model: LUNA } } })
-		await harness.shutdown()
-
-		const restarted = new TestHarness({
-			presets: [createTestPreset({ agents: [{ name: 'worker', system: 'worker' }] })],
-			llmProvider: MockLLMProvider.withFixedResponse({ content: 'ok', toolCalls: [] }),
-			eventStore: harness.eventStore,
-		})
-		const reopened = await restarted.openSession(session.sessionId)
-
-		await reopened.sendAndWaitForIdle('hello')
-
-		expect(modelsUsed(restarted.llmProvider)).toEqual([String(LUNA)])
-
-		await restarted.shutdown()
-	})
-})