@pikku/core 0.12.83 → 0.12.86

package/src/wirings/{ai-agent/ai-agent-agui.test.ts → agent/agent-agui.test.ts}

@@ -1,12 +1,12 @@
 import { describe, it, mock } from 'node:test'
 import assert from 'node:assert/strict'
 import { EventSchemas } from '@ag-ui/core'
-import { wrapChannelWithAGUI } from './ai-agent-agui.js'
-import type { AIStreamChannel, AIStreamEvent } from './ai-agent.types.js'
+import { wrapChannelWithAGUI } from './agent-agui.js'
+import type { AgentStreamChannel, AgentStreamEvent } from './agent.types.js'
 
-function makeChannel(): { channel: AIStreamChannel; events: unknown[] } {
+function makeChannel(): { channel: AgentStreamChannel; events: unknown[] } {
   const events: unknown[] = []
-  const channel: AIStreamChannel = {
+  const channel: AgentStreamChannel = {
     channelId: 'test-id',
     openingData: null,
     state: 'open',
@@ -39,9 +39,9 @@ describe('wrapChannelWithAGUI — text streaming', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'text-delta', text: 'a' } as AIStreamEvent)
-    wrapped.send({ type: 'text-delta', text: 'b' } as AIStreamEvent)
-    wrapped.send({ type: 'text-delta', text: 'c' } as AIStreamEvent)
+    wrapped.send({ type: 'text-delta', text: 'a' } as AgentStreamEvent)
+    wrapped.send({ type: 'text-delta', text: 'b' } as AgentStreamEvent)
+    wrapped.send({ type: 'text-delta', text: 'c' } as AgentStreamEvent)
 
     assert.equal(
       events.filter((e: any) => e.type === 'TEXT_MESSAGE_START').length,
@@ -57,9 +57,9 @@ describe('wrapChannelWithAGUI — text streaming', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'text-delta', text: 'hello' } as AIStreamEvent)
-    wrapped.send({ type: 'text-delta', text: ' world' } as AIStreamEvent)
-    wrapped.send({ type: 'done' } as AIStreamEvent)
+    wrapped.send({ type: 'text-delta', text: 'hello' } as AgentStreamEvent)
+    wrapped.send({ type: 'text-delta', text: ' world' } as AgentStreamEvent)
+    wrapped.send({ type: 'done' } as AgentStreamEvent)
 
     const start = find(events, 'TEXT_MESSAGE_START')
     const end = find(events, 'TEXT_MESSAGE_END')
@@ -79,8 +79,8 @@ describe('wrapChannelWithAGUI — text streaming', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'text-delta', text: 'hi' } as AIStreamEvent)
-    wrapped.send({ type: 'done' } as AIStreamEvent)
+    wrapped.send({ type: 'text-delta', text: 'hi' } as AgentStreamEvent)
+    wrapped.send({ type: 'done' } as AgentStreamEvent)
 
     assert.ok(find(events, 'TEXT_MESSAGE_END'))
   })
@@ -89,8 +89,8 @@ describe('wrapChannelWithAGUI — text streaming', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'text-delta', text: 'partial' } as AIStreamEvent)
-    wrapped.send({ type: 'error', message: 'oops' } as AIStreamEvent)
+    wrapped.send({ type: 'text-delta', text: 'partial' } as AgentStreamEvent)
+    wrapped.send({ type: 'error', message: 'oops' } as AgentStreamEvent)
 
     const t = types(events)
     assert.ok(t.indexOf('TEXT_MESSAGE_END') < t.indexOf('RUN_ERROR'))
@@ -100,7 +100,7 @@ describe('wrapChannelWithAGUI — text streaming', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'done' } as AIStreamEvent)
+    wrapped.send({ type: 'done' } as AgentStreamEvent)
 
     assert.equal(
       events.filter((e: any) => e.type === 'TEXT_MESSAGE_END').length,
@@ -114,8 +114,14 @@ describe('wrapChannelWithAGUI — reasoning streaming', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'reasoning-delta', text: 'step 1' } as AIStreamEvent)
-    wrapped.send({ type: 'reasoning-delta', text: 'step 2' } as AIStreamEvent)
+    wrapped.send({
+      type: 'reasoning-delta',
+      text: 'step 1',
+    } as AgentStreamEvent)
+    wrapped.send({
+      type: 'reasoning-delta',
+      text: 'step 2',
+    } as AgentStreamEvent)
 
     assert.equal(
       events.filter((e: any) => e.type === 'THINKING_TEXT_MESSAGE_START')
@@ -133,8 +139,11 @@ describe('wrapChannelWithAGUI — reasoning streaming', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'reasoning-delta', text: 'thinking' } as AIStreamEvent)
-    wrapped.send({ type: 'text-delta', text: 'answer' } as AIStreamEvent)
+    wrapped.send({
+      type: 'reasoning-delta',
+      text: 'thinking',
+    } as AgentStreamEvent)
+    wrapped.send({ type: 'text-delta', text: 'answer' } as AgentStreamEvent)
 
     const t = types(events)
     assert.ok(t.includes('THINKING_TEXT_MESSAGE_END'))
@@ -150,13 +159,13 @@ describe('wrapChannelWithAGUI — reasoning streaming', () => {
     wrapped.send({
       type: 'reasoning-delta',
       text: 'reasoning',
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
     wrapped.send({
       type: 'tool-call',
       toolCallId: 'tc1',
       toolName: 'fn',
       args: {},
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     const t = types(events)
     assert.ok(
@@ -168,8 +177,11 @@ describe('wrapChannelWithAGUI — reasoning streaming', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'reasoning-delta', text: 'reason' } as AIStreamEvent)
-    wrapped.send({ type: 'done' } as AIStreamEvent)
+    wrapped.send({
+      type: 'reasoning-delta',
+      text: 'reason',
+    } as AgentStreamEvent)
+    wrapped.send({ type: 'done' } as AgentStreamEvent)
 
     const start = find(events, 'THINKING_TEXT_MESSAGE_START')
     const end = find(events, 'THINKING_TEXT_MESSAGE_END')
@@ -186,13 +198,13 @@ describe('wrapChannelWithAGUI — tool calls', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'text-delta', text: 'preamble' } as AIStreamEvent)
+    wrapped.send({ type: 'text-delta', text: 'preamble' } as AgentStreamEvent)
     wrapped.send({
       type: 'tool-call',
       toolCallId: 'tc1',
       toolName: 'myTool',
       args: { x: 1 },
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     const t = types(events)
     assert.ok(t.indexOf('TEXT_MESSAGE_END') < t.indexOf('TOOL_CALL_START'))
@@ -207,7 +219,7 @@ describe('wrapChannelWithAGUI — tool calls', () => {
       toolCallId: 'tc1',
       toolName: 'search',
       args: { q: 'hi' },
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     const t = types(events)
     const startIdx = t.indexOf('TOOL_CALL_START')
@@ -227,7 +239,7 @@ describe('wrapChannelWithAGUI — tool calls', () => {
       toolCallId: 'abc',
       toolName: 'myFunc',
       args: { n: 42 },
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     const start = find(events, 'TOOL_CALL_START')
     const args = find(events, 'TOOL_CALL_ARGS')
@@ -248,13 +260,13 @@ describe('wrapChannelWithAGUI — tool calls', () => {
       toolCallId: 'tc1',
       toolName: 'fn1',
       args: {},
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
     wrapped.send({
       type: 'tool-call',
       toolCallId: 'tc2',
       toolName: 'fn2',
       args: {},
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     const starts = (events as any[]).filter((e) => e.type === 'TOOL_CALL_START')
     const ends = (events as any[]).filter((e) => e.type === 'TOOL_CALL_END')
@@ -273,7 +285,7 @@ describe('wrapChannelWithAGUI — tool calls', () => {
       toolCallId: 'tc1',
       toolName: 'fn',
       result: { ok: true },
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     const r = find(events, 'TOOL_CALL_RESULT')
     assert.equal(r.content, '{"ok":true}')
@@ -289,7 +301,7 @@ describe('wrapChannelWithAGUI — tool calls', () => {
       toolCallId: 'tc1',
       toolName: 'fn',
       result: 'plain text',
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     const r = find(events, 'TOOL_CALL_RESULT')
     assert.equal(r.content, 'plain text')
@@ -305,8 +317,8 @@ describe('wrapChannelWithAGUI — run lifecycle', () => {
       type: 'usage',
       tokens: { input: 100, output: 50 },
       model: 'claude-3-5',
-    } as AIStreamEvent)
-    wrapped.send({ type: 'done' } as AIStreamEvent)
+    } as AgentStreamEvent)
+    wrapped.send({ type: 'done' } as AgentStreamEvent)
 
     const f = find(events, 'RUN_FINISHED')
     assert.ok(f)
@@ -324,8 +336,8 @@ describe('wrapChannelWithAGUI — run lifecycle', () => {
       type: 'usage',
       tokens: { input: 1, output: 1 },
       model: 'm',
-    } as AIStreamEvent)
-    wrapped.send({ type: 'done' } as AIStreamEvent)
+    } as AgentStreamEvent)
+    wrapped.send({ type: 'done' } as AgentStreamEvent)
 
     assert.equal(events.filter((e: any) => e.type === 'RUN_FINISHED').length, 1)
   })
@@ -334,7 +346,7 @@ describe('wrapChannelWithAGUI — run lifecycle', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'done' } as AIStreamEvent)
+    wrapped.send({ type: 'done' } as AgentStreamEvent)
 
     assert.ok(find(events, 'RUN_FINISHED'))
   })
@@ -343,13 +355,13 @@ describe('wrapChannelWithAGUI — run lifecycle', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'text-delta', text: 'hi' } as AIStreamEvent)
+    wrapped.send({ type: 'text-delta', text: 'hi' } as AgentStreamEvent)
     wrapped.send({
       type: 'usage',
       tokens: { input: 1, output: 1 },
       model: 'm',
-    } as AIStreamEvent)
-    wrapped.send({ type: 'done' } as AIStreamEvent)
+    } as AgentStreamEvent)
+    wrapped.send({ type: 'done' } as AgentStreamEvent)
 
     const t = types(events)
     assert.ok(t.indexOf('TEXT_MESSAGE_END') < t.indexOf('RUN_FINISHED'))
@@ -359,8 +371,11 @@ describe('wrapChannelWithAGUI — run lifecycle', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'text-delta', text: 'partial' } as AIStreamEvent)
-    wrapped.send({ type: 'error', message: 'network timeout' } as AIStreamEvent)
+    wrapped.send({ type: 'text-delta', text: 'partial' } as AgentStreamEvent)
+    wrapped.send({
+      type: 'error',
+      message: 'network timeout',
+    } as AgentStreamEvent)
 
     const err = find(events, 'RUN_ERROR')
     assert.ok(err)
@@ -373,8 +388,11 @@ describe('wrapChannelWithAGUI — run lifecycle', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'reasoning-delta', text: 'thinking' } as AIStreamEvent)
-    wrapped.send({ type: 'error', message: 'fail' } as AIStreamEvent)
+    wrapped.send({
+      type: 'reasoning-delta',
+      text: 'thinking',
+    } as AgentStreamEvent)
+    wrapped.send({ type: 'error', message: 'fail' } as AgentStreamEvent)
 
     const t = types(events)
     assert.ok(t.indexOf('THINKING_TEXT_MESSAGE_END') < t.indexOf('RUN_ERROR'))
@@ -390,7 +408,7 @@ describe('wrapChannelWithAGUI — step events', () => {
       type: 'step-start',
       stepNumber: 1,
       agent: 'researcher',
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     const s = find(events, 'STEP_STARTED')
     assert.ok(s)
@@ -403,7 +421,7 @@ describe('wrapChannelWithAGUI — step events', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'step-start', stepNumber: 1 } as AIStreamEvent)
+    wrapped.send({ type: 'step-start', stepNumber: 1 } as AgentStreamEvent)
 
     const s = find(events, 'STEP_STARTED')
     assert.ok(s)
@@ -424,7 +442,7 @@ describe('wrapChannelWithAGUI — Pikku CUSTOM events', () => {
       reason: 'irreversible action',
       agent: 'admin-agent',
       session: 'sess-1',
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     const c = find(events, 'CUSTOM', 'pikku:approval-request')
     assert.ok(c)
@@ -440,13 +458,16 @@ describe('wrapChannelWithAGUI — Pikku CUSTOM events', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'text-delta', text: 'about to ask' } as AIStreamEvent)
+    wrapped.send({
+      type: 'text-delta',
+      text: 'about to ask',
+    } as AgentStreamEvent)
     wrapped.send({
       type: 'approval-request',
       toolCallId: 'tc1',
       toolName: 'fn',
       args: {},
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     const t = types(events)
     assert.ok(t.indexOf('TEXT_MESSAGE_END') < t.indexOf('CUSTOM'))
@@ -466,7 +487,7 @@ describe('wrapChannelWithAGUI — Pikku CUSTOM events', () => {
       connectUrl: 'https://github.com/oauth',
       runId: 'run-abc',
       agent: 'dev-agent',
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     const c = find(events, 'CUSTOM', 'pikku:credential-request')
     assert.ok(c)
@@ -484,7 +505,7 @@ describe('wrapChannelWithAGUI — Pikku CUSTOM events', () => {
     wrapped.send({
       type: 'generative-ui',
       spec: { component: 'Chart', props: { data: [1, 2] } },
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     const c = find(events, 'CUSTOM', 'pikku:generative-ui')
     assert.ok(c)
@@ -502,7 +523,7 @@ describe('wrapChannelWithAGUI — Pikku CUSTOM events', () => {
       type: 'data',
       name: 'search-results',
       data: [{ title: 'foo' }],
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     const c = find(events, 'CUSTOM', 'pikku:data')
     assert.ok(c)
@@ -519,7 +540,7 @@ describe('wrapChannelWithAGUI — Pikku CUSTOM events', () => {
       agentName: 'sub-agent',
       session: 'sess-2',
       input: { query: 'hello' },
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     const c = find(events, 'CUSTOM', 'pikku:agent-call')
     assert.ok(c)
@@ -537,7 +558,7 @@ describe('wrapChannelWithAGUI — Pikku CUSTOM events', () => {
       agentName: 'sub-agent',
       session: 'sess-2',
       result: 'done',
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     const c = find(events, 'CUSTOM', 'pikku:agent-result')
     assert.ok(c)
@@ -553,7 +574,7 @@ describe('wrapChannelWithAGUI — Pikku CUSTOM events', () => {
       type: 'suspended',
       reason: 'rpc-missing',
       missingRpcs: ['stripe.charge'],
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     const c = find(events, 'CUSTOM', 'pikku:suspended')
     assert.ok(c)
@@ -571,7 +592,7 @@ describe('wrapChannelWithAGUI — speech', () => {
       type: 'audio-delta',
       data: 'base64abc',
       format: 'mp3',
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     // AG-UI has no speech event, but dropping it makes a voice agent reached
     // over HTTP inaudible: every sentence is synthesized and billed, then
@@ -585,7 +606,7 @@ describe('wrapChannelWithAGUI — speech', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'audio-done' } as AIStreamEvent)
+    wrapped.send({ type: 'audio-done' } as AgentStreamEvent)
 
     assert.ok(find(events, 'CUSTOM', 'pikku:audio-done'))
   })
@@ -597,7 +618,7 @@ describe('wrapChannelWithAGUI — speech', () => {
     wrapped.send({
       type: 'transcript',
       text: 'what the user said',
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     // The client sent audio, so this is the only way it learns what its own
     // turn was. Dropped, the user's message renders as an empty bubble.
@@ -610,13 +631,13 @@ describe('wrapChannelWithAGUI — speech', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'text-delta', text: 'hello' } as AIStreamEvent)
+    wrapped.send({ type: 'text-delta', text: 'hello' } as AgentStreamEvent)
     wrapped.send({
       type: 'audio-delta',
       data: 'abc',
       format: 'mp3',
-    } as AIStreamEvent)
-    wrapped.send({ type: 'text-delta', text: ' there' } as AIStreamEvent)
+    } as AgentStreamEvent)
+    wrapped.send({ type: 'text-delta', text: ' there' } as AgentStreamEvent)
 
     // Audio arrives interleaved with the text it is saying. Ending the message
     // around it would render one reply as several.
@@ -786,8 +807,8 @@ describe('wrapChannelWithAGUI — AG-UI protocol conformance', () => {
       runId: 'run-1',
     })
 
-    wrapped.send({ type: 'text-delta', text: 'hi' } as AIStreamEvent)
-    wrapped.send({ type: 'done' } as AIStreamEvent)
+    wrapped.send({ type: 'text-delta', text: 'hi' } as AgentStreamEvent)
+    wrapped.send({ type: 'done' } as AgentStreamEvent)
 
     const first = events[0] as any
     assert.equal(first.type, 'RUN_STARTED')
@@ -802,7 +823,7 @@ describe('wrapChannelWithAGUI — AG-UI protocol conformance', () => {
       runId: 'run-1',
     })
 
-    wrapped.send({ type: 'done' } as AIStreamEvent)
+    wrapped.send({ type: 'done' } as AgentStreamEvent)
 
     const f = find(events, 'RUN_FINISHED')
     assert.equal(f.threadId, 'thread-1')
@@ -813,35 +834,35 @@ describe('wrapChannelWithAGUI — AG-UI protocol conformance', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'step-start', stepNumber: 0 } as AIStreamEvent)
+    wrapped.send({ type: 'step-start', stepNumber: 0 } as AgentStreamEvent)
     wrapped.send({
       type: 'tool-call',
       toolCallId: 'tc1',
       toolName: 'listTodos',
       args: {},
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
     wrapped.send({
       type: 'tool-result',
       toolCallId: 'tc1',
       toolName: 'listTodos',
       result: ['a'],
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
     wrapped.send({
       type: 'usage',
       tokens: { input: 10, output: 5 },
       model: 'gpt-4o',
-    } as AIStreamEvent)
-    wrapped.send({ type: 'step-start', stepNumber: 1 } as AIStreamEvent)
+    } as AgentStreamEvent)
+    wrapped.send({ type: 'step-start', stepNumber: 1 } as AgentStreamEvent)
     wrapped.send({
       type: 'text-delta',
       text: 'You have 1 todo',
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
     wrapped.send({
       type: 'usage',
       tokens: { input: 20, output: 8 },
       model: 'gpt-4o',
-    } as AIStreamEvent)
-    wrapped.send({ type: 'done' } as AIStreamEvent)
+    } as AgentStreamEvent)
+    wrapped.send({ type: 'done' } as AgentStreamEvent)
 
     const finishes = (events as any[]).filter((e) => e.type === 'RUN_FINISHED')
     assert.equal(finishes.length, 1)
@@ -861,14 +882,14 @@ describe('wrapChannelWithAGUI — AG-UI protocol conformance', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'done' } as AIStreamEvent)
+    wrapped.send({ type: 'done' } as AgentStreamEvent)
     wrapped.send({
       type: 'usage',
       tokens: { input: 1, output: 1 },
       model: 'm',
-    } as AIStreamEvent)
-    wrapped.send({ type: 'text-delta', text: 'late' } as AIStreamEvent)
-    wrapped.send({ type: 'done' } as AIStreamEvent)
+    } as AgentStreamEvent)
+    wrapped.send({ type: 'text-delta', text: 'late' } as AgentStreamEvent)
+    wrapped.send({ type: 'done' } as AgentStreamEvent)
 
     assert.equal((events as any[]).at(-1).type, 'RUN_FINISHED')
     assert.equal(events.filter((e: any) => e.type === 'RUN_FINISHED').length, 1)
@@ -883,7 +904,7 @@ describe('wrapChannelWithAGUI — AG-UI protocol conformance', () => {
       toolCallId: 'tc1',
       toolName: 'fn',
       result: 'ok',
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     const r = find(events, 'TOOL_CALL_RESULT')
     assert.ok(r.messageId, 'TOOL_CALL_RESULT requires a messageId')
@@ -898,7 +919,7 @@ describe('wrapChannelWithAGUI — AG-UI protocol conformance', () => {
       toolCallId: 'tc1',
       toolName: 'addTodo',
       args: { text: 'buy milk' },
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     const t = types(events)
     const argsIdx = t.indexOf('TOOL_CALL_ARGS')
@@ -913,9 +934,9 @@ describe('wrapChannelWithAGUI — AG-UI protocol conformance', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'reasoning-delta', text: 'hmm' } as AIStreamEvent)
-    wrapped.send({ type: 'text-delta', text: 'answer' } as AIStreamEvent)
-    wrapped.send({ type: 'done' } as AIStreamEvent)
+    wrapped.send({ type: 'reasoning-delta', text: 'hmm' } as AgentStreamEvent)
+    wrapped.send({ type: 'text-delta', text: 'answer' } as AgentStreamEvent)
+    wrapped.send({ type: 'done' } as AgentStreamEvent)
 
     const t = types(events)
     assert.ok(
@@ -931,14 +952,14 @@ describe('wrapChannelWithAGUI — AG-UI protocol conformance', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'step-start', stepNumber: 0 } as AIStreamEvent)
+    wrapped.send({ type: 'step-start', stepNumber: 0 } as AgentStreamEvent)
     wrapped.send({
       type: 'step-start',
       stepNumber: 0,
       agent: 'todoAgent',
-    } as AIStreamEvent)
-    wrapped.send({ type: 'step-start', stepNumber: 1 } as AIStreamEvent)
-    wrapped.send({ type: 'done' } as AIStreamEvent)
+    } as AgentStreamEvent)
+    wrapped.send({ type: 'step-start', stepNumber: 1 } as AgentStreamEvent)
+    wrapped.send({ type: 'done' } as AgentStreamEvent)
 
     const startNames = (events as any[])
       .filter((e) => e.type === 'STEP_STARTED')
@@ -954,7 +975,7 @@ describe('wrapChannelWithAGUI — AG-UI protocol conformance', () => {
       runId: 'r1',
     })
 
-    const send = (e: any) => wrapped.send(e as AIStreamEvent)
+    const send = (e: any) => wrapped.send(e as AgentStreamEvent)
     send({ type: 'step-start', stepNumber: 0 })
     send({
       type: 'tool-call',
@@ -1034,13 +1055,13 @@ describe('wrapChannelWithAGUI — AG-UI protocol conformance', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel)
 
-    wrapped.send({ type: 'step-start', stepNumber: 0 } as AIStreamEvent)
+    wrapped.send({ type: 'step-start', stepNumber: 0 } as AgentStreamEvent)
     wrapped.send({
       type: 'tool-call',
       toolCallId: 'tc1',
       toolName: 'addTodo',
       args: { text: 'x' },
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
     wrapped.send({
       type: 'approval-request',
       toolCallId: 'tc1',
@@ -1048,8 +1069,8 @@ describe('wrapChannelWithAGUI — AG-UI protocol conformance', () => {
       args: { text: 'x' },
       reason: 'Add a todo',
       runId: 'run-9',
-    } as AIStreamEvent)
-    wrapped.send({ type: 'done' } as AIStreamEvent)
+    } as AgentStreamEvent)
+    wrapped.send({ type: 'done' } as AgentStreamEvent)
 
     assertClientAcceptsStream(events as any[])
     const c = find(events, 'CUSTOM', 'pikku:approval-request')
@@ -1067,33 +1088,33 @@ describe('wrapChannelWithAGUI — realistic full turn', () => {
     wrapped.send({
       type: 'reasoning-delta',
       text: 'let me search',
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
     wrapped.send({
       type: 'text-delta',
       text: 'I will look that up.',
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
     wrapped.send({
       type: 'tool-call',
       toolCallId: 'tc1',
       toolName: 'search',
       args: { q: 'pikku' },
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
     wrapped.send({
       type: 'tool-result',
       toolCallId: 'tc1',
       toolName: 'search',
       result: 'found it',
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
     wrapped.send({
       type: 'text-delta',
       text: 'Here is what I found.',
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
     wrapped.send({
       type: 'usage',
       tokens: { input: 200, output: 80 },
       model: 'gpt-4o',
-    } as AIStreamEvent)
-    wrapped.send({ type: 'done' } as AIStreamEvent)
+    } as AgentStreamEvent)
+    wrapped.send({ type: 'done' } as AgentStreamEvent)
 
     const t = types(events)
     assert.ok(t.includes('THINKING_TEXT_MESSAGE_START'))
@@ -1119,8 +1140,8 @@ describe('wrapChannelWithAGUI — late-bound runId', () => {
     })
 
     runId = 'run-from-state-service'
-    wrapped.send({ type: 'text-delta', text: 'hi' } as AIStreamEvent)
-    wrapped.send({ type: 'done' } as AIStreamEvent)
+    wrapped.send({ type: 'text-delta', text: 'hi' } as AgentStreamEvent)
+    wrapped.send({ type: 'done' } as AgentStreamEvent)
 
     const started = find(events, 'RUN_STARTED')
     const finished = find(events, 'RUN_FINISHED')
@@ -1133,13 +1154,13 @@ describe('wrapChannelWithAGUI — late-bound runId', () => {
     wrapChannelWithAGUI(explicit.channel, {
       runId: 'explicit-run',
       getRunId: () => 'ignored',
-    }).send({ type: 'done' } as AIStreamEvent)
+    }).send({ type: 'done' } as AgentStreamEvent)
     assert.equal(find(explicit.events, 'RUN_STARTED').runId, 'explicit-run')
 
     const fallback = makeChannel()
     wrapChannelWithAGUI(fallback.channel, {
       getRunId: () => undefined,
-    }).send({ type: 'done' } as AIStreamEvent)
+    }).send({ type: 'done' } as AgentStreamEvent)
     const started = find(fallback.events, 'RUN_STARTED')
     assert.ok(started.runId)
     assert.equal(started.runId, find(fallback.events, 'RUN_FINISHED').runId)
@@ -1154,13 +1175,13 @@ describe('wrapChannelWithAGUI — interruption', () => {
     wrapped.send({
       type: 'text-delta',
       text: 'I will delete the ',
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
     wrapped.send({
       type: 'interrupted',
       runId: 'r',
       text: 'I will delete the ',
       reason: 'speech',
-    } as AIStreamEvent)
+    } as AgentStreamEvent)
 
     // Leaving TEXT_MESSAGE_END unsent would strand the assistant bubble in a
     // streaming state that never resolves.
@@ -1177,14 +1198,14 @@ describe('wrapChannelWithAGUI — interruption', () => {
     const { channel, events } = makeChannel()
     const wrapped = wrapChannelWithAGUI(channel, { threadId: 't', runId: 'r' })
 
-    wrapped.send({ type: 'text-delta', text: 'partial' } as AIStreamEvent)
+    wrapped.send({ type: 'text-delta', text: 'partial' } as AgentStreamEvent)
     wrapped.send({
       type: 'interrupted',
       runId: 'r',
       text: 'partial',
       reason: 'speech',
-    } as AIStreamEvent)
-    wrapped.send({ type: 'done' } as AIStreamEvent)
+    } as AgentStreamEvent)
+    wrapped.send({ type: 'done' } as AgentStreamEvent)
 
     assert.equal(events.filter((e: any) => e.type === 'RUN_FINISHED').length, 1)
     assert.equal(events.filter((e: any) => e.type === 'RUN_ERROR').length, 0)