@namzu/sdk 2.0.0 → 3.0.0

package/src/agents/__tests__/reachability.test.ts

@@ -0,0 +1,224 @@
+import { mkdtemp, rm } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { z } from 'zod'
+
+import { MockLLMProvider } from '../../provider/mock.js'
+import { ToolRegistry } from '../../registry/tool/execute.js'
+import type { ReactiveAgentConfig } from '../../types/agent/reactive.js'
+import type { SessionId, TenantId } from '../../types/ids/index.js'
+import { createUserMessage } from '../../types/message/index.js'
+import type { ProjectId, ThreadId } from '../../types/session/ids.js'
+import type { ToolDefinition } from '../../types/tool/index.js'
+import { ReactiveAgent } from '../ReactiveAgent.js'
+
+/**
+ * `ReactiveAgent` is the entry point consumers actually use — it is what
+ * `AgentManager` spawns and what the estate's own applications call. It
+ * forwarded none of the loop-control seams on `QueryParams`, so a per-tool
+ * deadline, a retry policy, a guardrail or a stop condition was reachable
+ * only by dropping to `query()` and rebuilding the run wiring by hand.
+ *
+ * A feature a consumer cannot reach is a feature that does not exist for
+ * them, so these assert reachability rather than behavior — the behavior
+ * already has its own tests one layer down.
+ */
+
+const agent = () =>
+	new ReactiveAgent({
+		id: 'reach',
+		name: 'Reach',
+		version: '1.0.0',
+		category: 'test',
+		description: 'reachability probe',
+	})
+
+const dirs: string[] = []
+
+afterEach(async () => {
+	await Promise.all(dirs.map((d) => rm(d, { recursive: true, force: true })))
+	dirs.length = 0
+})
+
+function fsTool(name: string): ToolDefinition {
+	return {
+		name,
+		description: `${name} tool`,
+		inputSchema: z.object({}),
+		category: 'filesystem',
+		permissions: ['file_read'],
+		execute: () => Promise.resolve({ success: true, output: 'ok' }),
+	} as unknown as ToolDefinition
+}
+
+async function baseConfig(provider: MockLLMProvider, tools: ToolRegistry) {
+	const workingDirectory = await mkdtemp(join(tmpdir(), 'namzu-reach-'))
+	dirs.push(workingDirectory)
+	return {
+		workingDirectory,
+		config: {
+			model: 'mock-model',
+			tokenBudget: 100_000,
+			timeoutMs: 10_000,
+			maxIterations: 4,
+			provider,
+			tools,
+			sessionId: 'ses_r' as SessionId,
+			threadId: 'thd_r' as ThreadId,
+			projectId: 'prj_r' as ProjectId,
+			tenantId: 'tnt_r' as TenantId,
+		} satisfies ReactiveAgentConfig,
+	}
+}
+
+describe('ReactiveAgent forwards the loop-control seams', () => {
+	it('reaches an output guardrail', async () => {
+		const provider = new MockLLMProvider({ turns: [{ text: 'raw answer' }] })
+		const { workingDirectory, config } = await baseConfig(provider, new ToolRegistry())
+
+		const result = await agent().run(
+			{ messages: [createUserMessage('go')], workingDirectory },
+			{ ...config, outputGuardrails: [() => ({ action: 'rewrite', output: 'cleaned' })] },
+		)
+
+		expect(result.result).toBe('cleaned')
+	})
+
+	it('reaches a stop condition', async () => {
+		const provider = new MockLLMProvider({
+			turns: [{ text: 'one' }, { text: 'two' }, { text: 'three' }],
+		})
+		const { workingDirectory, config } = await baseConfig(provider, new ToolRegistry())
+
+		await agent().run(
+			{ messages: [createUserMessage('go')], workingDirectory },
+			{ ...config, stopWhen: () => true },
+		)
+
+		expect(provider.requests).toHaveLength(1)
+	})
+
+	it('reaches prepareStep', async () => {
+		const provider = new MockLLMProvider({ turns: [{ text: 'done' }] })
+		const { workingDirectory, config } = await baseConfig(provider, new ToolRegistry())
+
+		await agent().run(
+			{ messages: [createUserMessage('go')], workingDirectory },
+			{ ...config, prepareStep: () => ({ model: 'swapped-model' }) },
+		)
+
+		expect(provider.requests[0]?.model).toBe('swapped-model')
+	})
+
+	it('reaches an input guardrail, so a refusal costs nothing', async () => {
+		const provider = new MockLLMProvider({ turns: [{ text: 'never' }] })
+		const { workingDirectory, config } = await baseConfig(provider, new ToolRegistry())
+
+		const result = await agent().run(
+			{ messages: [createUserMessage('go')], workingDirectory },
+			{ ...config, inputGuardrails: [() => ({ action: 'block', reason: 'no' })] },
+		)
+
+		expect(provider.requests).toHaveLength(0)
+		expect(result.stopReason).toBe('input_guardrail')
+	})
+
+	it('reaches onStepFinish', async () => {
+		// A step is recorded per TOOL-CALLING turn: a text-only turn breaks
+		// out of the loop before `recordStep` runs, so drive one tool call.
+		// (That the final text turn produces no step is worth revisiting on
+		// its own — it is a real hole in `Run.steps` — but changing loop
+		// semantics is not what this test is for.)
+		const provider = new MockLLMProvider({
+			turns: [{ toolCalls: [{ name: 'read_file', args: {} }] }, { text: 'done' }],
+		})
+		const tools = new ToolRegistry()
+		tools.register(fsTool('read_file'))
+		const { workingDirectory, config } = await baseConfig(provider, tools)
+		const onStepFinish = vi.fn()
+
+		await agent().run(
+			{ messages: [createUserMessage('go')], workingDirectory },
+			{ ...config, onStepFinish },
+		)
+
+		expect(onStepFinish).toHaveBeenCalled()
+	})
+})
+
+describe('the <env> block keys on what a tool declares, not its name', () => {
+	it('emits it for a filesystem tool that is not one of the four built-in names', async () => {
+		// A host registering `read_file` with `category: 'filesystem'` and
+		// `permissions: ['file_read']` used to get NO env block, so the model
+		// was never told its working directory and the host hand-encoded
+		// paths into the system prompt instead.
+		const tools = new ToolRegistry()
+		tools.register(fsTool('read_file'))
+		const provider = new MockLLMProvider({ turns: [{ text: 'done' }] })
+		const { workingDirectory, config } = await baseConfig(provider, tools)
+
+		await agent().run({ messages: [createUserMessage('go')], workingDirectory }, config)
+
+		const system = (provider.requests[0]?.messages ?? [])
+			.filter((m) => m.role === 'system')
+			.map((m) => m.content)
+			.join('\n')
+		expect(system).toContain(workingDirectory)
+	})
+
+	it('still says nothing when no tool touches the filesystem', async () => {
+		const tools = new ToolRegistry()
+		tools.register({
+			name: 'add',
+			description: 'add numbers',
+			inputSchema: z.object({}),
+			category: 'analysis',
+			execute: () => Promise.resolve({ success: true, output: '2' }),
+		} as unknown as ToolDefinition)
+		const provider = new MockLLMProvider({ turns: [{ text: 'done' }] })
+		const { workingDirectory, config } = await baseConfig(provider, tools)
+
+		await agent().run({ messages: [createUserMessage('go')], workingDirectory }, config)
+
+		const system = (provider.requests[0]?.messages ?? [])
+			.filter((m) => m.role === 'system')
+			.map((m) => m.content)
+			.join('\n')
+		expect(system).not.toContain(workingDirectory)
+	})
+})
+
+describe('a provider is not handed the live run array', () => {
+	it('what a driver retained at turn 1 still reads as turn 1 afterwards', async () => {
+		// `runMgr.messages` is the live array and the loop pushes onto it
+		// after the call returns, so a driver that retained its input watched
+		// it grow new turns underneath. A capture provider in the estate
+		// recorded every turn as identical to the last for exactly this.
+		const provider = new MockLLMProvider({
+			turns: [{ toolCalls: [{ name: 'read_file', args: {} }] }, { text: 'done' }],
+		})
+		// Retain the REFERENCE, exactly as a logging or caching driver would,
+		// and read it only after the whole run has finished. Reading it
+		// during the call proves nothing — the divergence appears later.
+		const retained: (readonly unknown[])[] = []
+		const original = provider.chatStream.bind(provider)
+		provider.chatStream = (params) => {
+			retained.push(params.messages)
+			return original(params)
+		}
+
+		const tools = new ToolRegistry()
+		tools.register(fsTool('read_file'))
+		const { workingDirectory, config } = await baseConfig(provider, tools)
+
+		await agent().run({ messages: [createUserMessage('go')], workingDirectory }, config)
+
+		expect(retained.length).toBeGreaterThanOrEqual(2)
+		// Two distinct arrays, not one aliased one.
+		expect(retained[0]).not.toBe(retained[1])
+		// And turn 1's copy still describes turn 1. With the live array both
+		// entries had grown to the final length by now.
+		expect(retained[0]?.length).toBeLessThan(retained[1]?.length as number)
+	})
+})

package/src/agents/__tests__/supervisor-ledger.test.ts

@@ -54,7 +54,7 @@ describe('supervisor ledger truthfulness', () => {
 			// A worker that ended with no result is NOT a success even when the
 			// handle reports a terminal 'completed' state — this is the exact
 			// fabrication that made the supervisor claim "3 workers done" with
-			// empty outputs (cowork task 02c5cf2b).
+			// empty outputs (observed in a live supervised run).
 			const results = synthesizeTaskResults(
 				[handle({ state: 'completed', result: undefined })],
 				RUN_ID,

package/src/agents/index.ts

@@ -6,4 +6,4 @@ export { SupervisorAgent } from './SupervisorAgent.js'
 export { defineAgent } from './defineAgent.js'
 export type { DefineAgentOptions } from './defineAgent.js'
 export { InvocationLock, ConcurrentInvocationError } from './lock.js'
-export type { ConcurrencyMode, Disposable } from './lock.js'
+export type { Disposable } from './lock.js'

package/src/agents/lock.ts

@@ -3,8 +3,6 @@
  * Uses a simple boolean flag with RAII-style cleanup via Disposable pattern.
  */
 
-export type ConcurrencyMode = 'throw' | 'queue'
-
 export interface Disposable {
 	[Symbol.dispose](): void
 }

package/src/bridge/a2a/late-events.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, it } from 'vitest'
+
+import type { RunId } from '../../types/ids/index.js'
+import type { RunEvent } from '../../types/run/events.js'
+import { mapRunToA2AEvent } from './mapper.js'
+import { messageToA2A } from './message.js'
+
+/**
+ * Three mappings added after this bridge's original test was written,
+ * none of which it covered — and a peer on the far side has no schema to
+ * check them against, only the shapes it happens to receive.
+ */
+
+const RID = 'run_1' as RunId
+const ctx = { taskId: 'task_1', contextId: 'ctx_1' } as never
+
+const map = (event: RunEvent) => mapRunToA2AEvent(event, ctx)
+
+describe('what a remote peer is told', () => {
+	it('reports a retry as still running, not as a failure', () => {
+		// The call has not given up, and a peer that read this as failed
+		// would tear down a task that is about to succeed.
+		const mapped = map({
+			type: 'provider_retry',
+			runId: RID,
+			iteration: 1,
+			attempt: 2,
+			maxRetries: 3,
+			delayMs: 1_500,
+			code: 'overloaded',
+			serverDirected: false,
+		} as RunEvent)
+
+		const status = (mapped as { status?: { state?: string; message?: unknown } })?.status
+		expect(status?.state).toBe('running')
+		expect(JSON.stringify(status?.message)).toContain('attempt 2 of 3')
+	})
+
+	it('parks the task as input-required when a question is raised', () => {
+		// A peer polling a task needs to know the difference between slow
+		// and waiting-on-a-human; only one of them will ever finish on its
+		// own.
+		const mapped = map({
+			type: 'user_question_asked',
+			runId: RID,
+			checkpointId: 'cp_1',
+			questionId: 'call_1:env',
+			question: 'which environment?',
+		} as RunEvent)
+
+		const status = (mapped as { status?: { state?: string; message?: unknown } })?.status
+		expect(status?.state).toBe('input-required')
+		expect(JSON.stringify(status?.message)).toContain('which environment?')
+	})
+
+	it('sends a failure classification as data, not as prose', () => {
+		// A peer deciding whether to retry needs the code and the retryable
+		// flag, not a sentence it would have to pattern-match.
+		const mapped = map({
+			type: 'run_failed',
+			runId: RID,
+			error: 'the model call failed',
+			failure: {
+				code: 'rate_limit',
+				message: 'the provider is rate limiting',
+				retryable: true,
+				details: { status: 429 },
+			},
+		} as RunEvent)
+
+		const text = JSON.stringify(mapped)
+		expect(text).toContain('rate_limit')
+		expect(text).toContain('retryable')
+	})
+
+	it('refuses a message role it has no mapping for', () => {
+		// The exhaustiveness guard: a new role added to the union without a
+		// mapping here must fail loudly rather than crossing the wire as
+		// something a peer will misread.
+		expect(() => messageToA2A({ role: 'nonsense', content: 'x' } as never)).toThrow(
+			/Unhandled message role/,
+		)
+	})
+})

package/src/bridge/a2a/mapper.test.ts

@@ -96,7 +96,7 @@ describe('mapRunToA2AEvent — mapped variants', () => {
 		}
 	})
 
-	it('message_completed with content → running status + text part (codex M5)', () => {
+	it('message_completed with content → running status + text part', () => {
 		const event: RunEvent = {
 			type: 'message_completed',
 			runId: RID,

package/src/bridge/a2a/mapper.ts

@@ -12,6 +12,7 @@ function statusEvent(
 	isFinal: boolean,
 	contextId?: string,
 	message?: TaskStatusUpdateEvent['status']['message'],
+	metadata?: Record<string, unknown>,
 ): TaskStatusUpdateEvent {
 	return {
 		taskId,
@@ -22,6 +23,7 @@ function statusEvent(
 			timestamp: new Date().toISOString(),
 		},
 		final: isFinal,
+		...(metadata !== undefined ? { metadata } : {}),
 	}
 }
 
@@ -55,10 +57,27 @@ const MAPPING: {
 	},
 
 	run_failed: (e, ctx) =>
-		statusEvent(e.runId, 'failed', true, ctx, {
-			role: 'agent',
-			parts: [{ kind: 'text', text: e.error }],
-		}),
+		statusEvent(
+			e.runId,
+			'failed',
+			true,
+			ctx,
+			{
+				role: 'agent',
+				parts: [{ kind: 'text', text: e.error }],
+			},
+			// The classification travels as metadata rather than being
+			// flattened into the text: a remote peer deciding whether to
+			// retry needs `retryable` and the code, not prose it would have
+			// to pattern-match.
+			e.failure
+				? {
+						code: e.failure.code,
+						retryable: e.failure.retryable,
+						...(e.failure.details ? { details: e.failure.details } : {}),
+					}
+				: undefined,
+		),
 
 	// Capability degradation is host-facing diagnostics, not A2A task state.
 	capability_warning: null,
@@ -69,6 +88,24 @@ const MAPPING: {
 			parts: [{ kind: 'text', text: `Iteration ${e.iteration} started` }],
 		}),
 
+	// A2A models discrete artifacts and task-status transitions; a progress
+	// tick is neither, so it has no A2A representation.
+	tool_progress: null,
+
+	// A retry IS a task-status transition in A2A's model — the task is
+	// still running and this says why nothing is arriving. Reported as
+	// working rather than failed: the call has not given up.
+	provider_retry: (e, ctx) =>
+		statusEvent(e.runId, 'running', false, ctx, {
+			role: 'agent',
+			parts: [
+				{
+					kind: 'text',
+					text: `Model call failed (${e.code}); retrying in ${e.delayMs}ms — attempt ${e.attempt} of ${e.maxRetries}`,
+				},
+			],
+		}),
+
 	tool_completed: (e, ctx) =>
 		artifactEvent(e.runId, ctx, {
 			artifactId: `tool-${e.toolName}-${Date.now()}`,
@@ -81,6 +118,23 @@ const MAPPING: {
 			},
 		}),
 
+	user_question_asked: (e, ctx) =>
+		statusEvent(e.runId, 'input-required', false, ctx, {
+			role: 'agent',
+			parts: [
+				{ kind: 'text', text: e.question },
+				{
+					kind: 'data',
+					data: { questionId: e.questionId, checkpointId: e.checkpointId },
+					mimeType: 'application/x-namzu-user-question',
+				},
+			],
+		}),
+
+	// The task leaves `input-required` by the next status event it emits;
+	// a second one here would only restate what the resumed run says.
+	user_question_answered: null,
+
 	tool_review_requested: (e, ctx) => {
 		const toolNames = e.toolCalls.map((tc) => tc.name).join(', ')
 		return statusEvent(e.runId, 'input-required', false, ctx, {
@@ -131,6 +185,17 @@ const MAPPING: {
 		}),
 
 	iteration_completed: null,
+	// Context management is kernel-internal bookkeeping; A2A peers model a
+	// task lifecycle, not the host runtime's memory strategy.
+	compaction_completed: null,
+	// A refusal is the run's own policy decision; the peer sees it in the
+	// terminal task state, not as a separate signal.
+	guardrail_triggered: null,
+	// Reasoning is kernel-internal: an A2A peer models a task lifecycle,
+	// not the host runtime's inner monologue.
+	reasoning_started: null,
+	reasoning_delta: null,
+	reasoning_completed: null,
 	tool_executing: null,
 	tool_review_completed: null,
 	checkpoint_created: null,
@@ -167,7 +232,7 @@ const MAPPING: {
 	// v3 message + tool-input lifecycle (ses_001-tool-stream-events). A2A's
 	// status-update model is coarse-grained, so per-delta events are dropped
 	// at this layer. `message_completed` carries the aggregated assistant
-	// content (codex A1) — A2A surfaces a single status event with the
+	// content — A2A surfaces a single status event with the
 	// full text, replacing the per-iteration `llm_response` mapping.
 	message_started: null,
 	text_delta: null,

package/src/bridge/a2a/message.ts

@@ -1,4 +1,5 @@
 import type { A2AMessage, A2AMessageRole, A2APart, TextPart } from '../../types/a2a/index.js'
+import { toolResultToText } from '../../types/message/content.js'
 import type { Message, MessageRole } from '../../types/message/index.js'
 
 function toA2ARole(role: MessageRole): A2AMessageRole {
@@ -20,7 +21,10 @@ export function messageToA2A(msg: Message): A2AMessage {
 	const parts: A2APart[] = []
 
 	if (msg.content) {
-		parts.push({ kind: 'text', text: msg.content })
+		// A2A parts are text; a tool result carrying blocks is flattened,
+		// with non-text blocks becoming an explicit placeholder rather than
+		// silently vanishing from the peer's view.
+		parts.push({ kind: 'text', text: toolResultToText(msg.content) })
 	}
 
 	if (msg.role === 'assistant' && 'toolCalls' in msg && msg.toolCalls) {

package/src/bridge/sse/late-events.test.ts

@@ -0,0 +1,182 @@
+import { describe, expect, it } from 'vitest'
+
+import type { RunId } from '../../types/ids/index.js'
+import type { RunEvent } from '../../types/run/events.js'
+import { mapRunToStreamEvent } from './mapper.js'
+
+/**
+ * The nine event kinds added after this mapper's original test was
+ * written, none of which it covered.
+ *
+ * A wire transform with no test is a contract nobody checked: the field
+ * names here are what a remote consumer parses, and renaming one is a
+ * silent break that type-checking cannot see, because the transform's
+ * return type is `Record<string, unknown>`.
+ */
+
+const RID = 'run_1' as RunId
+
+const map = (event: RunEvent) => mapRunToStreamEvent(event, RID)
+
+describe('the events the original mapper test predates', () => {
+	it('carries a reasoning block through its whole lifecycle', () => {
+		const started = map({
+			type: 'reasoning_started',
+			runId: RID,
+			iteration: 1,
+			messageId: 'msg_1',
+			blockIndex: 0,
+			reasoningType: 'thinking',
+		} as RunEvent)
+		const delta = map({
+			type: 'reasoning_delta',
+			runId: RID,
+			iteration: 1,
+			messageId: 'msg_1',
+			blockIndex: 0,
+			text: 'weighing it up',
+		} as RunEvent)
+		const completed = map({
+			type: 'reasoning_completed',
+			runId: RID,
+			iteration: 1,
+			messageId: 'msg_1',
+			blockIndex: 0,
+			signed: true,
+		} as RunEvent)
+
+		expect(started?.wire).toBe('reasoning.started')
+		expect(delta?.wire).toBe('reasoning.delta')
+		expect(completed?.wire).toBe('reasoning.completed')
+		// The index is what groups fragments into one block on the far side.
+		expect(delta?.data).toMatchObject({ run_id: RID, block_index: 0, text: 'weighing it up' })
+	})
+
+	it('says which guardrail fired and what it did', () => {
+		const mapped = map({
+			type: 'guardrail_triggered',
+			runId: RID,
+			guardrail: 'secret-redaction',
+			stage: 'output',
+			action: 'rewrite',
+			reason: 'a credential was present',
+		} as RunEvent)
+
+		expect(mapped?.wire).toBe('guardrail.triggered')
+		// A consumer showing "blocked" versus "rewritten" needs the action,
+		// not only that something happened.
+		expect(mapped?.data).toMatchObject({
+			run_id: RID,
+			guardrail: 'secret-redaction',
+			action: 'rewrite',
+		})
+	})
+
+	it('reports what compaction actually reclaimed', () => {
+		const mapped = map({
+			type: 'compaction_completed',
+			runId: RID,
+			messagesBefore: 40,
+			messagesAfter: 12,
+			tokensBefore: 90_000,
+			tokensAfter: 30_000,
+		} as RunEvent)
+
+		expect(mapped?.wire).toBe('compaction.completed')
+		expect(mapped?.data).toMatchObject({
+			messages_before: 40,
+			messages_after: 12,
+			tokens_before: 90_000,
+			tokens_after: 30_000,
+		})
+	})
+
+	it('names the tool a progress report belongs to', () => {
+		// A batch runs several tools at once; progress with no tool id is
+		// progress a host cannot render.
+		const mapped = map({
+			type: 'tool_progress',
+			runId: RID,
+			toolUseId: 'call_1',
+			toolName: 'build',
+			message: 'compiling',
+			fraction: 0.4,
+		} as RunEvent)
+
+		expect(mapped?.wire).toBe('tool.progress')
+		expect(mapped?.data).toMatchObject({
+			tool_use_id: 'call_1',
+			tool_name: 'build',
+			message: 'compiling',
+			fraction: 0.4,
+		})
+	})
+
+	it('tells a waiting client that a retry is why nothing is arriving', () => {
+		const mapped = map({
+			type: 'provider_retry',
+			runId: RID,
+			iteration: 2,
+			attempt: 1,
+			maxRetries: 3,
+			delayMs: 2_000,
+			code: 'rate_limit',
+			status: 429,
+			serverDirected: true,
+		} as RunEvent)
+
+		expect(mapped?.wire).toBe('provider.retry')
+		// Without the delay the client has no way to tell a run that is
+		// waiting from a run that has hung.
+		expect(mapped?.data).toMatchObject({
+			attempt: 1,
+			max_retries: 3,
+			delay_ms: 2_000,
+			code: 'rate_limit',
+			server_directed: true,
+		})
+	})
+
+	it('carries a question and the answer that resolves it', () => {
+		const asked = map({
+			type: 'user_question_asked',
+			runId: RID,
+			checkpointId: 'cp_1',
+			questionId: 'call_1:env',
+			question: 'which environment?',
+		} as RunEvent)
+		const answered = map({
+			type: 'user_question_answered',
+			runId: RID,
+			checkpointId: 'cp_1',
+			questionId: 'call_1:env',
+			answered: true,
+		} as RunEvent)
+
+		expect(asked?.wire).toBe('question.asked')
+		expect(answered?.wire).toBe('question.answered')
+		// The id is what routes an answer back to the pause that asked, so
+		// it has to survive the wire in both directions.
+		expect(asked?.data).toMatchObject({ question_id: 'call_1:env' })
+		expect(answered?.data).toMatchObject({ question_id: 'call_1:env', answered: true })
+	})
+
+	it('always stamps the run id it was given', () => {
+		const events: RunEvent[] = [
+			{
+				type: 'reasoning_delta',
+				runId: RID,
+				iteration: 1,
+				messageId: 'm',
+				blockIndex: 0,
+				text: 'x',
+			},
+			{ type: 'guardrail_triggered', runId: RID, guardrail: 'g', stage: 'input', action: 'block' },
+			{ type: 'tool_progress', runId: RID, toolUseId: 'c', toolName: 't', message: 'm' },
+		] as RunEvent[]
+
+		for (const event of events) {
+			expect(map(event)?.data.run_id).toBe(RID)
+		}
+	})
+})