@kuralle-agents/core 0.13.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,8 +54,8 @@ 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
 ```
@@ -230,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

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/collectUntilComplete.js

@@ -121,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,6 @@
 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;
@@ -20,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;

package/dist/flow/extraction.js

@@ -129,16 +129,22 @@ export function emitExtractionTelemetry(node, state, incoming, emit) {
         }
     }
     emit({
+        channel: 'internal',
         type: 'custom',
-        name: 'flow.extraction.submission',
-        data: { node: node.id, fieldsAccepted, fieldsRejected },
+        payload: {
+            name: 'flow.extraction.submission',
+            data: { node: node.id, fieldsAccepted, fieldsRejected },
+        },
     });
     const collected = getCollectData(state, node.id);
     const missing = computeMissingFields(node, collected);
     emit({
+        channel: 'internal',
         type: 'custom',
-        name: 'flow.extraction.update',
-        data: { nodeId: node.id, collected, missing },
+        payload: {
+            name: 'flow.extraction.update',
+            data: { nodeId: node.id, collected, missing },
+        },
     });
 }
 function fieldPopulated(value) {

package/dist/flow/reduceTransition.d.ts

@@ -1,7 +1,7 @@
 import type { LanguageModel } from 'ai';
 import type { Flow, FlowNode } from '../types/flow.js';
 import type { RunState } from '../runtime/durable/types.js';
-import type { HarnessStreamPart } from '../types/stream.js';
+import type { StreamPart } from '../types/stream.js';
 export interface ReduceTransitionInput {
     fromNodeId: string;
     toNode: FlowNode;
@@ -9,7 +9,7 @@ export interface ReduceTransitionInput {
     flow: Flow;
     model: LanguageModel;
     data?: Record<string, unknown>;
-    emit: (part: HarnessStreamPart) => void;
+    emit: (part: StreamPart) => void;
     abortSignal?: AbortSignal;
 }
 export declare function reduceTransition(input: ReduceTransitionInput): Promise<void>;

package/dist/flow/reduceTransition.js

@@ -8,9 +8,13 @@ function resolveNodeContext(toNode, flow) {
 }
 export async function reduceTransition(input) {
     const { fromNodeId, toNode, run, flow, model, data, emit, abortSignal } = input;
-    emit({ type: 'node-exit', nodeName: fromNodeId });
-    emit({ type: 'flow-transition', from: fromNodeId, to: toNode.id });
-    emit({ type: 'node-enter', nodeName: toNode.id });
+    emit({ channel: 'internal', type: 'node-exit', payload: { nodeName: fromNodeId } });
+    emit({
+        channel: 'internal',
+        type: 'flow-transition',
+        payload: { from: fromNodeId, to: toNode.id },
+    });
+    emit({ channel: 'internal', type: 'node-enter', payload: { nodeName: toNode.id } });
     emitInteractiveOnNodeEnter(toNode, run.state, emit);
     await applyContextStrategy({
         strategy: resolveNodeContext(toNode, flow),

package/dist/flow/runFlow.js

@@ -11,8 +11,7 @@ import { evaluateReplyControl } from './controlEvaluator.js';
 import { runNodeVerify, VerifyBlockedError } from './verify.js';
 import { loadRecordedSteps } from '../runtime/durable/replay.js';
 import { persistTurnUsageFromTurn } from '../runtime/turnTokenUsage.js';
-import { SuspendError } from '../runtime/durable/RunStore.js';
-import { ToolApprovalDeniedError } from '../tools/effect/errors.js';
+import { isApprovalDenial, isControlFlowSignal } from '../runtime/controlFlowSignal.js';
 import { emitInteractiveOnNodeEnter } from './emitInteractive.js';
 import { appendConversationAudit } from '../audit/record.js';
 import { appendSafeAssistantMessage, degradeFlowError, findEscalateNode, } from './degrade.js';
@@ -265,8 +264,8 @@ export async function runFlow(flow, run, driver, ctx, agent) {
     if (!run.activeNode) {
         run.activeNode = node.id;
         run.activeFlow = flow.name;
-        ctx.emit({ type: 'flow-enter', flow: flow.name });
-        ctx.emit({ type: 'node-enter', nodeName: node.id });
+        ctx.emit({ channel: 'internal', type: 'flow-enter', payload: { flow: flow.name } });
+        ctx.emit({ channel: 'internal', type: 'node-enter', payload: { nodeName: node.id } });
         emitInteractiveOnNodeEnter(node, run.state, ctx.emit);
     }
     const edgeCounts = new Map();
@@ -277,11 +276,14 @@ export async function runFlow(flow, run, driver, ctx, agent) {
             transition = await dispatchNode(node, run, driver, ctx, agent, flow);
         }
         catch (error) {
-            if (error instanceof SuspendError || error instanceof ToolApprovalDeniedError) {
+            // Neither is a malfunction, so neither may reach degradeFlowError and be reported to
+            // the user as "something went wrong on my side". A suspend resumes later; a denial is
+            // the action node author's to handle, since they chose to call the tool.
+            if (isControlFlowSignal(error) || isApprovalDenial(error)) {
                 throw error;
             }
             const message = error instanceof Error ? error.message : String(error);
-            ctx.emit({ type: 'error', error: message });
+            ctx.emit({ channel: 'client', type: 'error', payload: { error: message } });
             return degradeFlowError(flow, registry, run, driver, ctx, (n, r, d, c) => dispatchNode(n, r, d, c, agent, flow));
         }
         if (transition.kind === 'switchFlow') {
@@ -298,15 +300,27 @@ export async function runFlow(flow, run, driver, ctx, agent) {
                     run.activeFlow = park.flow;
                     run.activeNode = park.node;
                     await ctx.runStore.putRunState(run);
-                    ctx.emit({ type: 'flow-end', flow: flow.name, reason: transition.reason });
+                    ctx.emit({
+                        channel: 'internal',
+                        type: 'flow-end',
+                        payload: { flow: flow.name, reason: transition.reason },
+                    });
                     return runFlow(parkedFlow, run, driver, ctx, agent);
                 }
             }
-            ctx.emit({ type: 'flow-end', flow: flow.name, reason: transition.reason });
+            ctx.emit({
+                channel: 'internal',
+                type: 'flow-end',
+                payload: { flow: flow.name, reason: transition.reason },
+            });
             return { kind: 'ended', reason: transition.reason };
         }
         if (transition.kind === 'handoff') {
-            ctx.emit({ type: 'handoff', targetAgent: transition.to, reason: transition.reason });
+            ctx.emit({
+                channel: 'internal',
+                type: 'handoff',
+                payload: { targetAgent: transition.to, reason: transition.reason },
+            });
             return { kind: 'handoff', to: transition.to, reason: transition.reason };
         }
         if (transition.kind === 'escalate') {
@@ -337,14 +351,18 @@ export async function runFlow(flow, run, driver, ctx, agent) {
         }
         catch (error) {
             if (error instanceof VerifyBlockedError) {
-                ctx.emit({ type: 'error', error: error.message });
+                ctx.emit({ channel: 'client', type: 'error', payload: { error: error.message } });
                 return { kind: 'awaitingUser' };
             }
             throw error;
         }
         const oscillation = bumpOscillation(edgeCounts, node.id, target.id);
         if (oscillation > maxOscillations) {
-            ctx.emit({ type: 'error', error: `Flow oscillation blocked: ${node.id} -> ${target.id}` });
+            ctx.emit({
+                channel: 'client',
+                type: 'error',
+                payload: { error: `Flow oscillation blocked: ${node.id} -> ${target.id}` },
+            });
             const escalateNode = findEscalateNode(registry);
             if (escalateNode) {
                 appendSafeAssistantMessage(run, ctx);
@@ -363,7 +381,11 @@ export async function runFlow(flow, run, driver, ctx, agent) {
                 continue;
             }
             appendSafeAssistantMessage(run, ctx);
-            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' };
         }
         await reduceTransition({

package/dist/foundation/AgentStateController.d.ts

@@ -1,7 +1,7 @@
 import type { Session } from '../types/index.js';
 /**
  * Manages active agent resolution, handoff recording, and agent state.
- * Shared by Runtime and VoiceEngine.
+ * Used by Runtime.
  */
 export interface AgentStateController {
     /** Resolve the active agent ID, falling back to the provided default. */

package/dist/foundation/ToolExecutor.d.ts

@@ -1,7 +1,7 @@
 import type { Session, ToolCallRecord } from '../types/index.js';
 /**
  * Minimal tool shape required by the executor.
- * Compatible with AI SDK `Tool`, VoiceToolDef, and plain `{ execute }` objects.
+ * Compatible with AI SDK `Tool` and plain `{ execute }` objects.
  */
 export interface ExecutableTool {
     execute: (args: unknown, options?: unknown) => Promise<unknown>;
@@ -9,7 +9,7 @@ export interface ExecutableTool {
 }
 /**
  * Encapsulates tool execution with enforcement, idempotency, and context enrichment.
- * Shared by Runtime (text path) and VoiceEngine (audio path).
+ * Used by Runtime.
  */
 export interface ToolExecutor {
     /**

package/dist/foundation/index.d.ts

@@ -1,14 +1,3 @@
-export type { AgentDefinition } from './AgentDefinition.js';
 export type { ToolExecutor, ExecutableTool } from './ToolExecutor.js';
-export type { ConversationState } from './ConversationState.js';
-export type { ConversationEventLog, ConversationEvent } from './ConversationEventLog.js';
 export type { AgentStateController } from './AgentStateController.js';
-export { DefaultToolExecutor, ToolTimeoutError } from './DefaultToolExecutor.js';
-export type { DefaultToolExecutorConfig } from './DefaultToolExecutor.js';
-export { DefaultConversationState } from './DefaultConversationState.js';
-export type { DefaultConversationStateConfig } from './DefaultConversationState.js';
-export { DefaultConversationEventLog } from './DefaultConversationEventLog.js';
-export type { DefaultConversationEventLogConfig } from './DefaultConversationEventLog.js';
 export { DefaultAgentStateController } from './DefaultAgentStateController.js';
-export { createFoundation } from './createFoundation.js';
-export type { Foundation, FoundationConfig } from './createFoundation.js';

package/dist/foundation/index.js

@@ -1,7 +1,2 @@
 // Default implementations
-export { DefaultToolExecutor, ToolTimeoutError } from './DefaultToolExecutor.js';
-export { DefaultConversationState } from './DefaultConversationState.js';
-export { DefaultConversationEventLog } from './DefaultConversationEventLog.js';
 export { DefaultAgentStateController } from './DefaultAgentStateController.js';
-// Factory
-export { createFoundation } from './createFoundation.js';