@kuralle-agents/core 0.12.0 → 0.14.0

package/README.md

@@ -1,6 +1,6 @@
 # @kuralle-agents/core
 
-The runtime and primitives for building conversational AI agents — text and voice — with structured flows, routing, and durable tool execution.
+The runtime and primitives for building conversational AI agents with structured flows, routing, and durable tool execution.
 
 ## Install
 
@@ -54,12 +54,97 @@ const runtime = createRuntime({ agents: [agent], defaultAgentId: 'support' });
 
 const handle = runtime.run({ input: 'Hello', sessionId: 'demo' });
 for await (const part of handle.events) {           // events is a property, not a method
-  if (part.type === 'text-delta') process.stdout.write(part.delta);
-  if (part.type === 'done') console.log('\nSession:', part.sessionId);
+  if (part.type === 'text-delta') process.stdout.write(part.payload.delta);
+  if (part.type === 'done') console.log('\nSession:', part.payload.sessionId);
 }
 await handle;   // resolves to TurnResult once the stream is consumed
 ```
 
+## Single-run trace / `runOnce`
+
+Use `runOnce` when an evaluator needs one complete, JSON-serializable turn instead
+of a live stream. The trace includes the answer, tool roll-up, and nested spans.
+
+```ts
+const trace = await runtime.runOnce({
+  sessionId: 'grounding-eval-42',
+  input: 'What was my last invoice total?',
+});
+
+const judgeContext = {
+  answer: trace.answer,
+  evidence: trace.toolResults.map(({ name, result }) => ({ name, result })),
+};
+
+const verdict = await groundingJudge(judgeContext);
+console.log(verdict, trace.usedTool, trace.traceId);
+```
+
+`runOnce` executes exactly one normal runtime turn and observes its existing event
+stream. Runtime tracing also captures normal `run()` calls; trace persistence is
+physically separate from the session store and durable effect journal.
+
+## Observability
+
+Tracing is enabled by default with an in-process `MemoryTraceStore`. Supply a native
+store for durable reads and add any number of export sinks independently of
+`sessionStore`:
+
+```ts
+import { createRuntime } from '@kuralle-agents/core';
+import { RedisTraceStore } from '@kuralle-agents/redis-store';
+
+const traceStore = new RedisTraceStore({
+  client,
+  traceTtlSeconds: 7 * 24 * 60 * 60,
+});
+
+const runtime = createRuntime({
+  agents: [agent],
+  defaultAgentId: 'support',
+  tracing: {
+    store: traceStore,
+    sampling: 0.1,
+    sinks: [externalSink],
+    redact: (span) => ({
+      ...span,
+      attributes: { ...span.attributes, input: undefined, output: undefined },
+    }),
+  },
+});
+
+const latest = (await runtime.listTraces('session-42'))[0];
+const trace = latest ? await runtime.getTrace(latest.traceId) : null;
+```
+
+Sink failures are swallowed and never change the run result. Redaction is off by
+default for useful local debugging; use the hook above before persisting sensitive
+tool inputs or outputs. Set `tracing.enabled: false` to disable capture.
+
+### OTLP and Langfuse
+
+The built-in exporter uses HTTP/JSON over `fetch`, so it runs in Bun, Node.js, and
+Cloudflare Workers without a Node OpenTelemetry SDK:
+
+```ts
+import { langfuseSink, otelSink } from '@kuralle-agents/core';
+
+const runtime = createRuntime({
+  agents: [agent],
+  defaultAgentId: 'support',
+  tracing: {
+    store: traceStore,
+    sinks: [
+      otelSink({ endpoint: 'https://collector.example.com', headers: { Authorization: 'Bearer token' } }),
+      langfuseSink({ publicKey: env.LANGFUSE_PUBLIC_KEY, secretKey: env.LANGFUSE_SECRET_KEY }),
+    ],
+  },
+});
+```
+
+Endpoints may include `/v1/traces`; otherwise the sink appends it. For self-hosted
+Langfuse, pass its OTLP base URL as `endpoint`.
+
 ## Flows
 
 A flow is a node graph that enforces a multi-step procedure without embedding a 600-line SOP in a system prompt.
@@ -145,7 +230,7 @@ return handle.toUIMessageStreamResponse({ sessionId: 'demo' });
 
 Kuralle orchestration events (flow telemetry, safety blocks, interactive choices) arrive as typed `data-kuralle-*` parts. Import `KuralleUIMessage` and `KuralleDataParts` for compile-time-safe `message.parts` and `useChat({ onData })` handlers.
 
-For non-UI consumers (curl, custom transports), use `handle.toResponseStream('sse')` to emit raw `HarnessStreamPart` JSON-SSE. Or use `@kuralle-agents/hono-server` — `POST /api/chat/sse` defaults to native `UIMessageStream`; append `?format=raw` for the legacy wire.
+For non-UI consumers (curl, custom transports), use `handle.toResponseStream('sse')` to emit raw `StreamPart` JSON-SSE. Or use `@kuralle-agents/hono-server` — `POST /api/chat/sse` defaults to native `UIMessageStream`; append `?format=raw` for the legacy wire.
 
 ## Related
 

package/dist/ai-sdk/uiMessageStream.d.ts

@@ -1,7 +1,7 @@
 import { type UIMessage } from 'ai';
 import type { ConversationOutcome } from '../outcomes/types.js';
 import type { ChoiceOption } from '../types/selection.js';
-import type { HarnessStreamPart } from '../types/stream.js';
+import type { StreamPart } from '../types/stream.js';
 export type KuralleMetadata = {
     sessionId?: string;
 };
@@ -46,6 +46,6 @@ export type KuralleDataParts = {
     };
 };
 export type KuralleUIMessage = UIMessage<KuralleMetadata, KuralleDataParts>;
-export declare function harnessToUIMessageStream(source: AsyncIterable<HarnessStreamPart>, opts?: {
+export declare function harnessToUIMessageStream(source: AsyncIterable<StreamPart>, opts?: {
     sessionId?: string;
 }): ReadableStream;

package/dist/ai-sdk/uiMessageStream.js

@@ -2,64 +2,64 @@ import { createUIMessageStream, generateId, } from 'ai';
 function writeHarnessPart(part, writer) {
     switch (part.type) {
         case 'text-start':
-            writer.write({ type: 'text-start', id: part.id });
+            writer.write({ type: 'text-start', id: part.payload.id });
             break;
         case 'text-delta':
-            writer.write({ type: 'text-delta', id: part.id, delta: part.delta });
+            writer.write({ type: 'text-delta', id: part.payload.id, delta: part.payload.delta });
             break;
         case 'text-end':
-            writer.write({ type: 'text-end', id: part.id });
+            writer.write({ type: 'text-end', id: part.payload.id });
             break;
         case 'text-cancel':
-            writer.write({ type: 'text-end', id: part.id });
+            writer.write({ type: 'text-end', id: part.payload.id });
             break;
         case 'tool-call':
             writer.write({
                 type: 'tool-input-available',
-                toolCallId: part.toolCallId ?? generateId(),
-                toolName: part.toolName,
-                input: part.args,
+                toolCallId: part.payload.toolCallId ?? generateId(),
+                toolName: part.payload.toolName,
+                input: part.payload.args,
             });
             break;
         case 'tool-result':
             writer.write({
                 type: 'tool-output-available',
-                toolCallId: part.toolCallId ?? 'unknown',
-                output: part.result,
+                toolCallId: part.payload.toolCallId ?? 'unknown',
+                output: part.payload.result,
             });
             break;
         case 'node-enter':
             writer.write({
                 type: 'data-kuralle-node',
-                data: { event: 'enter', node: part.nodeName },
+                data: { event: 'enter', node: part.payload.nodeName },
                 transient: true,
             });
             break;
         case 'node-exit':
             writer.write({
                 type: 'data-kuralle-node',
-                data: { event: 'exit', node: part.nodeName },
+                data: { event: 'exit', node: part.payload.nodeName },
                 transient: true,
             });
             break;
         case 'flow-enter':
             writer.write({
                 type: 'data-kuralle-flow',
-                data: { event: 'enter', flow: part.flow },
+                data: { event: 'enter', flow: part.payload.flow },
                 transient: true,
             });
             break;
         case 'flow-end':
             writer.write({
                 type: 'data-kuralle-flow',
-                data: { event: 'end', flow: part.flow, reason: part.reason },
+                data: { event: 'end', flow: part.payload.flow, reason: part.payload.reason },
                 transient: true,
             });
             break;
         case 'flow-transition':
             writer.write({
                 type: 'data-kuralle-flow',
-                data: { event: 'transition', from: part.from, to: part.to },
+                data: { event: 'transition', from: part.payload.from, to: part.payload.to },
                 transient: true,
             });
             break;
@@ -67,14 +67,18 @@ function writeHarnessPart(part, writer) {
             writer.write({
                 type: 'data-kuralle-handoff',
                 id: generateId(),
-                data: { targetAgent: part.targetAgent, reason: part.reason },
+                data: { targetAgent: part.payload.targetAgent, reason: part.payload.reason },
             });
             break;
         case 'interactive':
             writer.write({
                 type: 'data-kuralle-interactive',
-                id: part.nodeId,
-                data: { nodeId: part.nodeId, prompt: part.prompt, options: part.options },
+                id: part.payload.nodeId,
+                data: {
+                    nodeId: part.payload.nodeId,
+                    prompt: part.payload.prompt,
+                    options: part.payload.options,
+                },
             });
             break;
         case 'safety-blocked':
@@ -83,9 +87,9 @@ function writeHarnessPart(part, writer) {
                 id: generateId(),
                 data: {
                     kind: 'safety-blocked',
-                    moderator: part.moderator,
-                    rationale: part.rationale,
-                    userFacingMessage: part.userFacingMessage,
+                    moderator: part.payload.moderator,
+                    rationale: part.payload.rationale,
+                    userFacingMessage: part.payload.userFacingMessage,
                 },
             });
             break;
@@ -95,8 +99,8 @@ function writeHarnessPart(part, writer) {
                 id: generateId(),
                 data: {
                     kind: 'pipeline-validation-block',
-                    rationale: part.rationale,
-                    userFacingMessage: part.userFacingMessage,
+                    rationale: part.payload.rationale,
+                    userFacingMessage: part.payload.userFacingMessage,
                 },
             });
             break;
@@ -104,35 +108,44 @@ function writeHarnessPart(part, writer) {
             writer.write({
                 type: 'data-kuralle-outcome',
                 id: generateId(),
-                data: { outcome: part.outcome },
+                data: { outcome: part.payload.outcome },
             });
             break;
         case 'interrupted':
             writer.write({
                 type: 'data-kuralle-control',
-                data: { event: 'interrupted', reason: part.reason },
+                data: { event: 'interrupted', reason: part.payload.reason },
                 transient: true,
             });
             break;
         case 'paused':
             writer.write({
                 type: 'data-kuralle-control',
-                data: { event: 'paused', waitingFor: part.waitingFor },
+                data: { event: 'paused', waitingFor: part.payload.waitingFor },
                 transient: true,
             });
             break;
         case 'custom':
             writer.write({
                 type: 'data-kuralle-custom',
-                data: { name: part.name, data: part.data },
+                data: { name: part.payload.name, data: part.payload.data },
                 transient: true,
             });
             break;
         case 'error':
-            throw new Error(part.error);
+            throw new Error(part.payload.error);
         case 'done':
         case 'turn-end':
             break;
+        default: {
+            // Client-channel exhaustiveness guard. Internal-channel parts are
+            // deliberately unmapped here — they never reach a UI client. But a new
+            // `client` variant added without a case above would be silently dropped
+            // on the ADR-0005 default output path, so pin the residual to internal:
+            // adding a client variant without a case fails this assignment.
+            const _internalOnly = part;
+            void _internalOnly;
+        }
     }
 }
 export function harnessToUIMessageStream(source, opts) {
@@ -146,8 +159,8 @@ export function harnessToUIMessageStream(source, opts) {
                 });
             }
             for await (const part of source) {
-                if (part.type === 'done' && part.sessionId) {
-                    doneSessionId = doneSessionId ?? part.sessionId;
+                if (part.type === 'done' && part.payload.sessionId) {
+                    doneSessionId = doneSessionId ?? part.payload.sessionId;
                 }
                 else {
                     writeHarnessPart(part, writer);

package/dist/capabilities/LivePromptAssembler.d.ts

@@ -7,7 +7,7 @@
  * CapabilityHost with Runtime context (working memory, long-term memory,
  * policy injections) and structures the output per audio-model best practices.
  *
- * Adapters (Gemini, OpenAI Realtime, LiveKit) can extend or replace
+ * Adapters can extend or replace
  * the default with backend-specific voice rules and guardrails.
  *
  * Prompt structure follows Google's Live API best practices and

package/dist/capabilities/LivePromptAssembler.js

@@ -7,7 +7,7 @@
  * CapabilityHost with Runtime context (working memory, long-term memory,
  * policy injections) and structures the output per audio-model best practices.
  *
- * Adapters (Gemini, OpenAI Realtime, LiveKit) can extend or replace
+ * Adapters can extend or replace
  * the default with backend-specific voice rules and guardrails.
  *
  * Prompt structure follows Google's Live API best practices and
@@ -47,6 +47,7 @@ const INTERNAL_MEMORY_KEYS = [
     'flowStateByAgent',
     '__ariaAssistantText',
     '__ariaContextBudget',
+    '__goals',
 ];
 /**
  * Default LivePromptAssembler implementation.

package/dist/capabilities/index.d.ts

@@ -1,7 +1,7 @@
 import type { ZodTypeAny } from 'zod';
 /**
  * Backend-agnostic tool declaration. Produced by capabilities,
- * consumed by adapters (Gemini, AI SDK, LiveKit).
+ * consumed by adapters (AI SDK and others).
  */
 export interface ToolDeclaration<TInput = unknown, TOutput = unknown> {
     name: string;

package/dist/eval/EvalRunner.js

@@ -25,16 +25,16 @@ export class EvalRunner {
             const handle = runtime.run({ input: turn.input, sessionId });
             for await (const part of handle.events) {
                 if (part.type === 'text-delta') {
-                    response += part.delta;
+                    response += part.payload.delta;
                 }
                 if (part.type === 'tool-call') {
-                    toolsCalled.push(part.toolName);
+                    toolsCalled.push(part.payload.toolName);
                 }
                 if (part.type === 'flow-transition') {
-                    transitions.push({ from: part.from, to: part.to });
+                    transitions.push({ from: part.payload.from, to: part.payload.to });
                 }
                 if (part.type === 'done') {
-                    sessionId = part.sessionId;
+                    sessionId = part.payload.sessionId;
                 }
             }
             await handle;

package/dist/eval/simulation.js

@@ -66,10 +66,11 @@ export async function simulateConversation(options) {
         let reply = '';
         for await (const part of handle.events) {
             if (part.type === 'text-delta')
-                reply += part.delta;
+                reply += part.payload.delta;
             if (part.type === 'tool-call')
-                toolsCalled.push(part.toolName);
-            if (part.type === 'escalation' || (part.type === 'handoff' && part.targetAgent === 'human')) {
+                toolsCalled.push(part.payload.toolName);
+            if (part.type === 'escalation' ||
+                (part.type === 'handoff' && part.payload.targetAgent === 'human')) {
                 escalated = true;
             }
         }

package/dist/events/TurnHandle.d.ts

@@ -1,7 +1,7 @@
-import type { HarnessStreamPart, TurnHandle } from '../types/stream.js';
+import type { StreamPart, TurnHandle } from '../types/stream.js';
 export interface EventBus {
-    emit(part: HarnessStreamPart): void;
-    events(): AsyncIterable<HarnessStreamPart>;
+    emit(part: StreamPart): void;
+    events(): AsyncIterable<StreamPart>;
     close(): void;
 }
 export declare function createEventBus(): EventBus;

package/dist/flow/collectDigression.d.ts

@@ -1,6 +1,5 @@
 import type { AgentConfig } from '../types/agentConfig.js';
 import type { ChannelDriver } from '../types/channel.js';
-import type { CollectNode } from '../types/flow.js';
 import type { RunContext } from '../types/run-context.js';
 import type { RunState } from '../runtime/durable/types.js';
 import type { NormalizedTransition } from './normalizeTransition.js';
@@ -9,11 +8,15 @@ export interface FlowPark {
     flow: string;
     node: string;
 }
+export declare function pushFlowPark(state: Record<string, unknown>, park: FlowPark): void;
+export declare function popFlowPark(state: Record<string, unknown>): FlowPark | undefined;
 export declare function getFlowPark(state: Record<string, unknown>): FlowPark | undefined;
 export declare function looksLikeOffScriptQuestion(input: string): boolean;
 export interface CollectDigressionOptions {
     agent: AgentConfig;
-    node: CollectNode;
+    node: {
+        id: string;
+    };
     activeFlowName: string;
     run: RunState;
     driver: ChannelDriver;

package/dist/flow/collectDigression.js

@@ -1,20 +1,57 @@
 import { resolveReplyNode } from './nodeBuilders.js';
 import { selectHostTarget } from '../runtime/select.js';
-const FLOW_PARK_KEY = '__flowPark';
-export function getFlowPark(state) {
-    const raw = state[FLOW_PARK_KEY];
+import { persistTurnUsageFromTurn } from '../runtime/turnTokenUsage.js';
+const FLOW_PARK_STACK_KEY = '__flowParkStack';
+const LEGACY_FLOW_PARK_KEY = '__flowPark';
+const MAX_FLOW_PARK_DEPTH = 8;
+function isFlowPark(raw) {
     if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
-        return undefined;
+        return false;
     }
     const flow = raw.flow;
     const node = raw.node;
-    if (typeof flow === 'string' && typeof node === 'string') {
-        return { flow, node };
+    return typeof flow === 'string' && typeof node === 'string';
+}
+function getFlowParkStack(state) {
+    const raw = state[FLOW_PARK_STACK_KEY];
+    if (!Array.isArray(raw)) {
+        return undefined;
     }
-    return undefined;
+    const stack = raw.filter(isFlowPark);
+    return stack.length > 0 ? stack : undefined;
+}
+export function pushFlowPark(state, park) {
+    const stack = getFlowParkStack(state) ?? [];
+    stack.push(park);
+    while (stack.length > MAX_FLOW_PARK_DEPTH) {
+        stack.shift();
+    }
+    state[FLOW_PARK_STACK_KEY] = stack;
 }
-function setFlowPark(state, park) {
-    state[FLOW_PARK_KEY] = park;
+export function popFlowPark(state) {
+    const stack = getFlowParkStack(state);
+    if (!stack) {
+        return undefined;
+    }
+    const park = stack.pop();
+    if (stack.length === 0) {
+        delete state[FLOW_PARK_STACK_KEY];
+    }
+    else {
+        state[FLOW_PARK_STACK_KEY] = stack;
+    }
+    return park;
+}
+export function getFlowPark(state) {
+    const stack = getFlowParkStack(state);
+    if (stack) {
+        return stack[stack.length - 1];
+    }
+    const legacy = state[LEGACY_FLOW_PARK_KEY];
+    if (isFlowPark(legacy)) {
+        return legacy;
+    }
+    return undefined;
 }
 function appendAssistantMessage(run, text) {
     if (!text.trim()) {
@@ -53,7 +90,7 @@ export async function runCollectDigression(options) {
         };
     }
     if (selection.kind === 'enterFlow') {
-        setFlowPark(run.state, { flow: activeFlowName, node: node.id });
+        pushFlowPark(run.state, { flow: activeFlowName, node: node.id });
         return {
             kind: 'transition',
             transition: {
@@ -74,6 +111,7 @@ export async function runCollectDigression(options) {
         tools: ctx.globalTools,
     };
     const turn = await driver.runAgentTurn(resolveReplyNode(replyNode, run.state, { freeConversation: true }), ctx);
+    await persistTurnUsageFromTurn(ctx, turn);
     if (turn.text.trim()) {
         appendAssistantMessage(run, turn.text);
     }

package/dist/flow/collectUntilComplete.js

@@ -1,4 +1,5 @@
 import { runCollectDigression } from './collectDigression.js';
+import { persistTurnUsageFromTurn } from '../runtime/turnTokenUsage.js';
 import { hasPendingUserInput } from '../runtime/channels/inputBuffer.js';
 import { userInputToText } from '../runtime/userInput.js';
 import { resolveCollectExtractionNode } from './nodeBuilders.js';
@@ -16,8 +17,13 @@ function appendUserMessage(run, input) {
     run.messages = [...run.messages, message];
 }
 export async function collectUntilComplete(node, run, driver, ctx, options) {
+    // A satisfied collect defers completion for ONE pass when there is pending input,
+    // so a correction ("no, Tuesday") is re-extracted and overwrites before completing
+    // (G14). Bounded to a single pass so the loop cannot spin if a driver's awaitUser
+    // does not clear the pending buffer — completion no longer depends on that.
+    let pendingConsumed = false;
     for (;;) {
-        if (schemaSatisfied(node, run.state)) {
+        if (schemaSatisfied(node, run.state) && (!hasPendingUserInput(ctx.session) || pendingConsumed)) {
             const data = projectCollectData(node, run.state);
             return normalizeTransition(await node.onComplete(data, run.state));
         }
@@ -32,6 +38,7 @@ export async function collectUntilComplete(node, run, driver, ctx, options) {
         if (hasPendingUserInput(ctx.session)) {
             const signal = await driver.awaitUser(ctx);
             appendUserMessage(run, signal.input);
+            pendingConsumed = true;
         }
         else if (ctx.turnInputConsumed) {
             // No fresh input to extract this turn: ask (deterministically) for the
@@ -59,6 +66,7 @@ export async function collectUntilComplete(node, run, driver, ctx, options) {
         const turn = await (driver.runExtraction
             ? driver.runExtraction(resolved, ctx)
             : driver.runAgentTurn(resolved, ctx));
+        await persistTurnUsageFromTurn(ctx, turn);
         mergeExtractionFromTurn(node, run, turn, ctx);
         const missingAfter = computeMissingFields(node, getCollectData(run.state, node.id));
         const advanced = missingAfter.length < missingBefore.length || schemaSatisfied(node, run.state);
@@ -113,10 +121,10 @@ export function emitCollectAsk(node, run, ctx) {
         return;
     }
     const id = crypto.randomUUID();
-    ctx.emit({ type: 'text-start', id });
-    ctx.emit({ type: 'text-delta', id, delta: text });
-    ctx.emit({ type: 'text-end', id });
-    ctx.emit({ type: 'turn-end' });
+    ctx.emit({ channel: 'client', type: 'text-start', payload: { id } });
+    ctx.emit({ channel: 'client', type: 'text-delta', payload: { id, delta: text } });
+    ctx.emit({ channel: 'client', type: 'text-end', payload: { id } });
+    ctx.emit({ channel: 'internal', type: 'turn-end', payload: {} });
     appendAssistantMessage(run, text);
 }
 function mergeExtractionFromTurn(node, run, turn, ctx) {

package/dist/flow/degrade.js

@@ -7,9 +7,9 @@ export function appendSafeAssistantMessage(run, ctx, text = SAFE_DEGRADED_MESSAG
     const message = { role: 'assistant', content: text };
     run.messages = [...run.messages, message];
     const id = crypto.randomUUID();
-    ctx.emit({ type: 'text-start', id });
-    ctx.emit({ type: 'text-delta', id, delta: text });
-    ctx.emit({ type: 'text-end', id });
+    ctx.emit({ channel: 'client', type: 'text-start', payload: { id } });
+    ctx.emit({ channel: 'client', type: 'text-delta', payload: { id, delta: text } });
+    ctx.emit({ channel: 'client', type: 'text-end', payload: { id } });
 }
 export async function degradeFlowError(flow, registry, run, driver, ctx, dispatchNode) {
     appendSafeAssistantMessage(run, ctx);
@@ -29,6 +29,10 @@ export async function degradeFlowError(flow, registry, run, driver, ctx, dispatc
             // Fall through to graceful end if the escalate node also fails.
         }
     }
-    ctx.emit({ type: 'flow-end', flow: flow.name, reason: 'error_degraded' });
+    ctx.emit({
+        channel: 'internal',
+        type: 'flow-end',
+        payload: { flow: flow.name, reason: 'error_degraded' },
+    });
     return { kind: 'ended', reason: 'error_degraded' };
 }

package/dist/flow/emitInteractive.d.ts

@@ -1,3 +1,3 @@
 import type { FlowNode, FlowState } from '../types/flow.js';
-import type { HarnessStreamPart } from '../types/stream.js';
-export declare function emitInteractiveOnNodeEnter(node: FlowNode, state: FlowState, emit: (part: HarnessStreamPart) => void): void;
+import type { StreamPart } from '../types/stream.js';
+export declare function emitInteractiveOnNodeEnter(node: FlowNode, state: FlowState, emit: (part: StreamPart) => void): void;

package/dist/flow/emitInteractive.js

@@ -35,9 +35,12 @@ export function emitInteractiveOnNodeEnter(node, state, emit) {
         return;
     }
     emit({
+        channel: 'internal',
         type: 'interactive',
-        nodeId: node.id,
-        options: node.choices,
-        prompt: interactivePrompt(node, state),
+        payload: {
+            nodeId: node.id,
+            options: node.choices,
+            prompt: interactivePrompt(node, state),
+        },
     });
 }

package/dist/flow/extraction.d.ts

@@ -1,6 +1,7 @@
 import type { CollectNode, FlowState } from '../types/flow.js';
 import type { Tool } from '../types/effectTool.js';
-import type { HarnessStreamPart } from '../types/stream.js';
+import type { StreamPart } from '../types/stream.js';
+export declare function resetCollect(state: FlowState, nodeId: string): void;
 export declare function getCollectData(state: FlowState, nodeId: string): Record<string, unknown>;
 export declare function incrementCollectTurns(state: FlowState, nodeId: string): number;
 export declare function computeMissingFields(node: CollectNode, data: Record<string, unknown>): string[];
@@ -19,4 +20,4 @@ export declare function mergeTurnExtraction(node: CollectNode, state: FlowState,
     name: string;
     result: unknown;
 }>): MergeTurnExtractionResult;
-export declare function emitExtractionTelemetry(node: CollectNode, state: FlowState, incoming: Record<string, unknown>, emit: (part: HarnessStreamPart) => void): void;
+export declare function emitExtractionTelemetry(node: CollectNode, state: FlowState, incoming: Record<string, unknown>, emit: (part: StreamPart) => void): void;