@roj-ai/sdk 0.1.36 → 0.2.1

package/src/core/reasoning-round-trip.integration.test.ts

@@ -1,188 +0,0 @@
-import { describe, expect, it } from 'bun:test'
-import type { AssistantLLMMessage } from '~/core/agents/state.js'
-import { MemoryEventStore } from '~/core/events/memory.js'
-import { MockLLMProvider } from '~/core/llm/mock.js'
-import type { InferenceRequest, InferenceResponse } from '~/core/llm/provider.js'
-import { llmEvents } from '~/core/llm/state.js'
-import { ToolCallId } from '~/core/tools/schema.js'
-import { createTestPreset, TestHarness } from '~/testing/index.js'
-
-// Reasoning blocks have to survive the whole conversation path — the event log,
-// a replay of it, and the message list handed to the next inference — or a
-// reasoning model restarts its chain of thought at every tool call.
-
-const REASONING_DETAILS = [
-	{ type: 'reasoning.encrypted', data: 'EroBCkYIBRgCKkCr0hZ0opaque', id: 'rd-1', format: 'openai-responses-v1', index: 0 },
-]
-
-/** The Anthropic half of the same contract — a separate field, see ThinkingBlocks. */
-const THINKING_BLOCKS = [
-	{ type: 'thinking', thinking: 'Working it out.', signature: 'EqQBCgIYAhIM1gbcDa9GJwZopaque' },
-]
-
-const assistantMessages = (request: InferenceRequest): AssistantLLMMessage[] =>
-	request.messages.filter((m): m is AssistantLLMMessage => m.role === 'assistant')
-
-/** Same shape as reasoningThenPlainMock, on the Anthropic field. */
-const thinkingThenPlainMock = (): MockLLMProvider => {
-	let call = 0
-	return new MockLLMProvider((): InferenceResponse => {
-		call++
-		if (call === 1) {
-			return {
-				content: null,
-				toolCalls: [{ id: ToolCallId('tc1'), name: 'tell_user', input: { message: 'Hi!' } }],
-				finishReason: 'tool_calls',
-				metrics: MockLLMProvider.defaultMetrics(),
-				thinkingBlocks: THINKING_BLOCKS,
-			}
-		}
-		return { content: 'Done', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() }
-	})
-}
-
-/** Turn 1 reasons its way to a tool call; every later turn just finishes, without reasoning. */
-const reasoningThenPlainMock = (): MockLLMProvider => {
-	let call = 0
-	return new MockLLMProvider((): InferenceResponse => {
-		call++
-		if (call === 1) {
-			return {
-				content: null,
-				toolCalls: [{ id: ToolCallId('tc1'), name: 'tell_user', input: { message: 'Hi!' } }],
-				finishReason: 'tool_calls',
-				metrics: MockLLMProvider.defaultMetrics(),
-				reasoningDetails: REASONING_DETAILS,
-			}
-		}
-		return { content: 'Done', toolCalls: [], finishReason: 'stop', metrics: MockLLMProvider.defaultMetrics() }
-	})
-}
-
-describe('reasoning round trip', () => {
-	it('echoes the blocks back on the follow-up request of the same turn', async () => {
-		const llmProvider = reasoningThenPlainMock()
-		const harness = new TestHarness({ presets: [createTestPreset()], llmProvider })
-
-		const session = await harness.createSession('test')
-		await session.sendAndWaitForIdle('Do something')
-
-		const [, second] = llmProvider.getCallHistory()
-		const assistants = assistantMessages(second)
-		expect(assistants).toHaveLength(1)
-		expect(assistants[0].reasoningDetails).toEqual(REASONING_DETAILS)
-
-		await harness.shutdown()
-	})
-
-	it('stores the blocks in the inference_completed event, serialized verbatim', async () => {
-		const llmProvider = reasoningThenPlainMock()
-		const harness = new TestHarness({ presets: [createTestPreset()], llmProvider })
-
-		const session = await harness.createSession('test')
-		await session.sendAndWaitForIdle('Do something')
-
-		const completed = await session.getEventsByType(llmEvents, 'inference_completed')
-		expect(completed[0].response.reasoningDetails).toEqual(REASONING_DETAILS)
-		// The event is what a restarted server replays, so it has to survive JSON as-is.
-		expect(JSON.stringify(completed[0])).toContain(`"reasoningDetails":${JSON.stringify(REASONING_DETAILS)}`)
-		expect(completed[1].response.reasoningDetails).toBeUndefined()
-
-		await harness.shutdown()
-	})
-
-	it('keeps the blocks after the session is reloaded from the event store', async () => {
-		const eventStore = new MemoryEventStore()
-		const llmProvider = reasoningThenPlainMock()
-
-		const harness1 = new TestHarness({ eventStore, presets: [createTestPreset()], llmProvider })
-		const session1 = await harness1.createSession('test')
-		await session1.sendAndWaitForIdle('Do something')
-		const sessionId = session1.sessionId
-		await harness1.shutdown()
-
-		// Fresh harness over the same log: conversation history comes from replay only.
-		const harness2 = new TestHarness({ eventStore, presets: [createTestPreset()], llmProvider })
-		const session2 = await harness2.openSession(sessionId)
-		await session2.sendAndWaitForIdle('And again')
-
-		const assistants = assistantMessages(llmProvider.getCallHistory()[2])
-		expect(assistants[0].reasoningDetails).toEqual(REASONING_DETAILS)
-
-		await harness2.shutdown()
-	})
-
-	it('leaves the assistant message untouched when the model returns no reasoning', async () => {
-		const llmProvider = MockLLMProvider.withSequence([
-			{ toolCalls: [{ id: ToolCallId('tc1'), name: 'tell_user', input: { message: 'Hi!' } }] },
-			{ content: 'Done', toolCalls: [] },
-		])
-		const harness = new TestHarness({ presets: [createTestPreset()], llmProvider })
-
-		const session = await harness.createSession('test')
-		await session.sendAndWaitForIdle('Do something')
-
-		const assistants = assistantMessages(llmProvider.getCallHistory()[1])
-		expect(assistants).toHaveLength(1)
-		expect(assistants[0].reasoningDetails).toBeUndefined()
-
-		await harness.shutdown()
-	})
-})
-
-// Anthropic needs this harder than OpenRouter does: with extended thinking on, the API
-// rejects a tool-use turn whose thinking blocks are missing, rather than quietly
-// degrading. The two fields stay separate so a mid-conversation model switch cannot put
-// one provider's blocks in front of the other.
-describe('thinking round trip', () => {
-	it('echoes the blocks back on the follow-up request of the same turn', async () => {
-		const llmProvider = thinkingThenPlainMock()
-		const harness = new TestHarness({ presets: [createTestPreset()], llmProvider })
-
-		const session = await harness.createSession('test')
-		await session.sendAndWaitForIdle('Do something')
-
-		const [, second] = llmProvider.getCallHistory()
-		const assistants = assistantMessages(second)
-		expect(assistants).toHaveLength(1)
-		expect(assistants[0].thinkingBlocks).toEqual(THINKING_BLOCKS)
-		// The other field stays empty: nothing cross-populates.
-		expect(assistants[0].reasoningDetails).toBeUndefined()
-
-		await harness.shutdown()
-	})
-
-	it('keeps the blocks after the session is reloaded from the event store', async () => {
-		const eventStore = new MemoryEventStore()
-		const llmProvider = thinkingThenPlainMock()
-
-		const harness1 = new TestHarness({ eventStore, presets: [createTestPreset()], llmProvider })
-		const session1 = await harness1.createSession('test')
-		await session1.sendAndWaitForIdle('Do something')
-		const sessionId = session1.sessionId
-		await harness1.shutdown()
-
-		const harness2 = new TestHarness({ eventStore, presets: [createTestPreset()], llmProvider })
-		const session2 = await harness2.openSession(sessionId)
-		await session2.sendAndWaitForIdle('And again')
-
-		const assistants = assistantMessages(llmProvider.getCallHistory()[2])
-		expect(assistants[0].thinkingBlocks).toEqual(THINKING_BLOCKS)
-
-		await harness2.shutdown()
-	})
-
-	it('stores the blocks in the inference_completed event, serialized verbatim', async () => {
-		const llmProvider = thinkingThenPlainMock()
-		const harness = new TestHarness({ presets: [createTestPreset()], llmProvider })
-
-		const session = await harness.createSession('test')
-		await session.sendAndWaitForIdle('Do something')
-
-		const completed = await session.getEventsByType(llmEvents, 'inference_completed')
-		expect(JSON.stringify(completed[0])).toContain(`"thinkingBlocks":${JSON.stringify(THINKING_BLOCKS)}`)
-		expect(completed[1].response.thinkingBlocks).toBeUndefined()
-
-		await harness.shutdown()
-	})
-})

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()
-	})
-})