llmz 0.9.0 → 1.0.1

package/dist/runtime/execute.d.ts

@@ -1,3 +1,4 @@
 import { ExecutionResult } from '../result.js';
-import { ExecutionProps } from './types.js';
-export declare const executeContext: (props: ExecutionProps) => Promise<ExecutionResult>;
+import type { ExecutionProps } from './types.js';
+/** Each iteration joins generation and execution before settling its transcript. */
+export declare function executeContext(props: ExecutionProps): Promise<ExecutionResult>;

package/dist/runtime/execution-activity.d.ts

@@ -0,0 +1,11 @@
+import type { Iteration } from '../context.js';
+import { type InspectionIdentity, type Inspector } from '../inspection.js';
+import type { Traces } from '../types.js';
+export type ExecutionActivity = {
+    calls: Traces.ToolCall[];
+    deliveries: Traces.MessageDelivery[];
+};
+/** Collect recorded operations, excluding ordinary assistant text delivery. */
+export declare function getExecutionActivity(iteration: Iteration): ExecutionActivity;
+export declare function renderToolCalls(activity: ExecutionActivity, includeRecoveryValues?: boolean, inspector?: Inspector, identity?: InspectionIdentity): string | undefined;
+export declare function renderMessageDeliveries({ deliveries }: ExecutionActivity, cancelled?: boolean, inspector?: Inspector, identity?: InspectionIdentity): string | undefined;

package/dist/runtime/execution-diagnostics.d.ts

@@ -0,0 +1,11 @@
+import type { InspectionIdentity, Inspector } from '../inspection.js';
+import type { TruncatePreserve } from '../truncate.js';
+/** XML-style boundaries keep diagnostic text separate from recovery instructions. */
+export declare function reportSection(name: string, content: string, maxTokens?: number, options?: {
+    heading?: string;
+    preserve?: TruncatePreserve;
+}): string;
+/** Show the specific failure and guest source, never the host's implementation stack. */
+export declare function renderExecutionDiagnostics(error: unknown, message: string, inspector: Inspector, identity: InspectionIdentity): string[];
+/** Keep failure sites visible even when they are near the end of a long program. */
+export declare function renderSourceTrace(stack: string, inspector: Inspector, identity: InspectionIdentity): string;

package/dist/runtime/execution-report.d.ts

@@ -0,0 +1,48 @@
+import { type InspectionPolicyLookup } from '../inspect.js';
+import { type InspectionIdentity, type Inspector } from '../inspection.js';
+import type { MemoryReport } from '../session/memory.js';
+import { type ExecutionActivity } from './execution-activity.js';
+export { renderMessageDeliveries } from './execution-activity.js';
+export type ExecutionOutcome = {
+    type: 'inspect';
+    value: unknown;
+    available: boolean;
+    explicit: boolean;
+} | {
+    type: 'exit';
+    name: string;
+    value: unknown;
+} | {
+    type: 'error';
+    message: string;
+    error?: unknown;
+    exitName?: string;
+} | {
+    type: 'cancelled';
+    message: string;
+} | {
+    type: 'interrupted';
+    reason: 'stream' | 'thinking';
+    message?: string;
+    context?: unknown;
+    stacktrace?: string;
+};
+export type ExecutionReport = {
+    outcome: ExecutionOutcome;
+    activity: ExecutionActivity;
+    memory: MemoryReport;
+    source?: {
+        requested?: string;
+        executed?: string;
+    };
+    requiresExit?: boolean;
+    iteration?: number;
+    identity?: InspectionIdentity;
+    inspector?: Inspector;
+    maxTokens?: number;
+    policies?: InspectionPolicyLookup;
+};
+/** Format one settled outcome; execution is responsible for deciding what happened. */
+export declare function renderExecutionReport({ outcome, activity, memory, source, requiresExit, iteration, identity, inspector, maxTokens, policies, }: ExecutionReport): string;
+/** Keep the requested assistant call intact while disclosing the source the host actually ran. */
+export declare function renderExecutionOverride(executedCode?: string, requestedCode?: string, inspector?: Inspector, identity?: InspectionIdentity): string | undefined;

package/dist/runtime/fixtures/chat.d.ts

@@ -0,0 +1,8 @@
+import { Chat, type ChatMessage, type MessageDeltaHandler, type MessageMetadata } from '../../chat/chat.js';
+import type { Component } from '../../chat/component.js';
+/** Collect both delivery paths when testing execution order and receipts. */
+export declare function createRecordingChat({ handler, onMessageDelta, components, }: {
+    handler: (message: ChatMessage, metadata: MessageMetadata) => Promise<void> | void;
+    onMessageDelta?: MessageDeltaHandler;
+    components?: Component[];
+}): Chat;

package/dist/runtime/fixtures/long-search.d.ts

@@ -1,4 +1,4 @@
-import { CitationsManager } from '../../citations.js';
+import { CitationsManager } from '../../chat/citations.js';
 export type SearchChallenge = {
     id: string;
     size: number;

package/dist/runtime/fixtures/native-client.d.ts

@@ -0,0 +1,33 @@
+import type { CognitiveMetadata, CognitiveResponse, CognitiveStreamChunk, CognitiveToolCall } from '@botpress/cognitive';
+import { _CustomModelClient, type RuntimeGenerateContentInput } from '../../custom-client.js';
+export declare const nativeMetadata: CognitiveMetadata;
+export declare const nativeCall: (name: string, input?: Record<string, unknown>, id?: string) => CognitiveToolCall;
+export declare const javascript: (code: string) => CognitiveResponse;
+export declare const response: (output?: string, toolCalls?: CognitiveToolCall[]) => CognitiveResponse;
+export declare class NativeClient extends _CustomModelClient {
+    responses: CognitiveResponse[];
+    requests: RuntimeGenerateContentInput[];
+    constructor(responses: CognitiveResponse[]);
+    getModelDetails(id: string): Promise<{
+        id: string;
+        name: string;
+        description: string;
+        input: {
+            maxTokens: number;
+            costPer1MTokens: number;
+        };
+        output: {
+            maxTokens: number;
+            costPer1MTokens: number;
+        };
+        tags: never[];
+        lifecycle: 'production';
+    }>;
+    generateText(input: RuntimeGenerateContentInput): Promise<CognitiveResponse>;
+}
+export declare class NativeStreamClient extends NativeClient {
+    size: number;
+    probe: () => void;
+    constructor(responses: CognitiveResponse[], size?: number, probe?: () => void);
+    generateTextStream(input: RuntimeGenerateContentInput): AsyncGenerator<CognitiveStreamChunk>;
+}

package/dist/runtime/fixtures/protocol-languages.d.ts

@@ -1,4 +1,4 @@
-/** Synthetic multilingual inputs shared by parser/execution and live model tests. */
+/** Synthetic multilingual inputs for native protocol boundary tests. */
 export declare const protocolLanguages: readonly [{
     readonly language: 'English';
     readonly hello: 'Hello!';

package/dist/runtime/generate.d.ts

@@ -1,28 +1,31 @@
-import type { MessageDelta, MessageMetadata } from '../chat.js';
-import { Context, Iteration } from '../context.js';
-import type { ParsedSend } from '../prompts/prompt.js';
-import { RuntimeCognitive } from './types.js';
+import type { CognitiveMessage, CognitiveMetadata, CognitiveResponse, CognitiveToolCall } from '@botpress/cognitive';
+import type { MessageDelta, MessageMetadata } from '../chat/chat.js';
+import type { Context, Iteration } from '../context.js';
+import type { ExecutionHooks, RuntimeCognitive } from './types.js';
+export { countNativeRequestTokens } from './token-budget.js';
+/** A custom provider adapter can return the full assistant message, including opaque continuation data. */
+export type NativeResponse = CognitiveResponse & {
+    assistantMessage?: CognitiveMessage;
+    continuation?: unknown;
+};
+export type NativeGeneration = {
+    attempt: number;
+    output: string;
+    toolCalls: CognitiveToolCall[];
+    assistantMessage?: CognitiveMessage;
+    continuation?: unknown;
+    metadata: CognitiveMetadata;
+    messageMetadata: MessageMetadata;
+};
 type GenerateCodeProps = {
     iteration: Iteration;
     ctx: Context;
     cognitive: RuntimeCognitive;
     controller: AbortController;
     metadata?: Record<string, string>;
-    /**
-     * Called for each send after a complete, valid response and successful transport.
-     */
-    onSend?: (send: ParsedSend, metadata: MessageMetadata) => Promise<void>;
-    /**
-     * Called for each `■send` body chunk as it is parsed from the stream
-     * (streaming clients only), or with a restart delta before replacement output.
-     * Text errors are best-effort; restart errors terminate generation.
-     */
     onSendDelta?: (delta: MessageDelta) => Promise<void> | void;
-    /**
-     * Called as soon as the model opens a `■run` block, while the code is still
-     * being generated (streaming clients only). Used to pre-warm the VM.
-     */
-    onRunStart?: () => void;
+    onBeforeRequest?: ExecutionHooks['onBeforeRequest'];
+    /** Start a complete normalized call without waiting for execution or the stream tail. */
+    onToolCalls?: (calls: CognitiveToolCall[]) => boolean;
 };
-export declare const generateCode: ({ iteration, ctx, cognitive, controller, metadata, onSend, onSendDelta, onRunStart, }: GenerateCodeProps) => Promise<void>;
-export {};
+export declare function generateCode({ iteration, ctx, cognitive, controller, metadata, onSendDelta, onToolCalls, onBeforeRequest, }: GenerateCodeProps): Promise<NativeGeneration>;

package/dist/runtime/inspection-values.d.ts

@@ -0,0 +1,14 @@
+import type { InspectionPolicyLookup } from '../inspect.js';
+import type { TruncationPolicy } from '../truncate.js';
+/** Explicit display policies apply only to unchanged values in this JavaScript execution. */
+export declare class InspectionValues {
+    private readonly _primitives;
+    private readonly _objects;
+    capture(value: unknown, policy: TruncationPolicy): void;
+    captureDefault(value: unknown, maxTokens: number): void;
+    private _register;
+    /** Match unchanged VM copies without rebuilding a wrapped display graph. */
+    readonly getPolicy: InspectionPolicyLookup;
+    private _objectKey;
+    private _mergePolicy;
+}

package/dist/runtime/inspection-values.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/interruption-control-flow.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/interruption-settings.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/javascript-api.d.ts

@@ -0,0 +1,59 @@
+import type { ComponentRegistry, RenderedComponent } from '../chat/component.js';
+import type { Iteration } from '../context.js';
+import { ThinkSignal } from '../errors.js';
+import type { Exit } from '../exit.js';
+/** A child message keeps its identity from preparation through acknowledged delivery. */
+export type PreparedMessage = {
+    id: string;
+    component: RenderedComponent;
+};
+export type JavaScriptOutcome = {
+    type: 'inspect';
+    value: unknown;
+} | {
+    type: 'exit';
+    exit: Exit;
+    value: unknown;
+};
+type DecisionReceipt = Readonly<{
+    __llmz_decision: string;
+}>;
+type TerminalOutcome = Extract<JavaScriptOutcome, {
+    type: 'exit';
+}>;
+export type JavaScriptBindings = {
+    exit(name?: string, value?: unknown): never;
+    inspect(value: unknown): DecisionReceipt;
+    chat: Readonly<Record<string, (input: unknown) => void>>;
+};
+export type JavaScriptApi = {
+    bindings: JavaScriptBindings;
+    resolve(value: unknown): JavaScriptOutcome | undefined;
+    isReceipt(value: unknown): boolean;
+    getTerminalOutcome(): TerminalOutcome | undefined;
+    /** The first host interruption closes execution before guest handlers can consume it. */
+    getInterruption(): ThinkSignal | undefined;
+    throwIfTerminated(): void;
+    track<T>(operation: () => Promise<T>): Promise<T>;
+    assertOpen(): void;
+    /** Record validation failures and close host operations on critical configuration errors. */
+    reportError(error: unknown): void;
+    /** Called at program settlement, before background work can invoke another host operation. */
+    complete(): void;
+    /** Joins automatic message delivery and business work before the iteration can settle. */
+    close(): Promise<void>;
+};
+type JavaScriptApiOptions = {
+    iteration: Pick<Iteration, 'id' | 'nativeCallId'>;
+    components: ComponentRegistry;
+    exits: readonly Exit[];
+    deliver(messages: readonly PreparedMessage[]): Promise<void>;
+    signal?: AbortSignal;
+    onError?(error: unknown): void;
+};
+/**
+ * Component methods send synchronously; the runtime joins delivery in close().
+ * Inspection returns a decision, while exit latches an outcome and stops the program.
+ */
+export declare function createJavaScriptApi({ iteration, components, exits, deliver, signal, onError, }: JavaScriptApiOptions): JavaScriptApi;
+export {};

package/dist/runtime/javascript-api.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/native-review.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/native-tools.d.ts

@@ -0,0 +1,18 @@
+import type { CognitiveTool, CognitiveToolCall } from '@botpress/cognitive';
+export declare const WORKER_RESPONSE_INSTRUCTION = "You are running in worker mode. Respond only with a run_javascript tool call. Keep assistant text empty: do not send messages, preambles, progress updates, explanations, acknowledgements such as \"Done\", Markdown, or JSON outside the tool call. This applies before and after tools, during recovery, and when completing the task.";
+export declare const RUN_JAVASCRIPT_TOOL: CognitiveTool;
+/** Select delivery guidance without changing the native tool name or input schema. */
+export declare function getRunJavaScriptTool(chat: boolean): CognitiveTool;
+export type ValidatedNativeCall = {
+    id: string;
+    code: string;
+};
+export type NativeCallValidation = {
+    valid: true;
+    call?: ValidatedNativeCall;
+} | {
+    valid: false;
+    errors: string[];
+};
+/** Validate the entire response before any delivery or business action begins. */
+export declare function validateNativeToolCalls(calls: readonly CognitiveToolCall[]): NativeCallValidation;

package/dist/runtime/native-tools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/object-memory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/single-tool.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/token-budget.d.ts

@@ -0,0 +1,22 @@
+import type { CognitiveMessage } from '@botpress/cognitive';
+/**
+ * Estimate text, structured arguments, schemas, and message scaffolding. Media
+ * URLs carry bytes or locations, not model text. Cognitive does not expose a
+ * media-token estimator; actual media usage is reported by the provider.
+ */
+export declare function countNativeRequestTokens(messages: CognitiveMessage[], tools: unknown): number;
+type ModelLimits = {
+    input: {
+        maxTokens: number;
+    };
+    output: {
+        maxTokens: number;
+    };
+};
+/** Reserve output space within every model that can receive this request. */
+export declare function resolveTokenBudget(model: ModelLimits | readonly ModelLimits[], maxTokens?: number): {
+    limit: number;
+    output: number;
+    input: number;
+};
+export {};

package/dist/runtime/token-budget.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/tool-wrapper.d.ts

@@ -1,17 +1,16 @@
-import { Chat } from '../chat.js';
 import { Iteration } from '../context.js';
 import { type Tool } from '../tool.js';
-import { Trace } from '../types.js';
+import type { TruncationPolicy } from '../truncate.js';
 import { ExecutionHooks } from './types.js';
 type ToolWrapperProps = {
-    chat?: Chat;
     tool: Tool;
     object?: string;
-    traces: Trace[];
     iteration: Iteration;
     beforeHook?: ExecutionHooks['onBeforeTool'];
     afterHook?: ExecutionHooks['onAfterTool'];
+    onTruncation?: (value: unknown, policy: TruncationPolicy) => void;
+    onResult?: (value: unknown) => void;
     controller: AbortController;
 };
-export declare function wrapTool({ chat, tool, traces, object, iteration, beforeHook, afterHook, controller, }: ToolWrapperProps): (input: any) => Promise<any>;
+export declare function wrapTool({ tool, object, iteration, beforeHook, afterHook, onTruncation, onResult, controller, }: ToolWrapperProps): (input: any) => Promise<any>;
 export {};

package/dist/runtime/traces.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/truncation.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/types.d.ts

@@ -1,12 +1,12 @@
-import { Cognitive, type BotpressClientLike, Models, type SttModels } from '@botpress/cognitive';
-import { Chat } from '../chat.js';
+import { Cognitive, type CognitiveMessage, type BotpressClientLike, Models, type SttModels } from '@botpress/cognitive';
+import { Chat } from '../chat/chat.js';
 import { Context, Iteration } from '../context.js';
 import { _CustomModelClient } from '../custom-client.js';
-import type { Example } from '../example.js';
 import { Exit, ExitResult } from '../exit.js';
 import { ValueOrGetter } from '../getter.js';
+import type { OnInspect } from '../inspection.js';
 import { type ObjectInstance } from '../objects.js';
-import { Snapshot } from '../snapshots.js';
+import type { Session } from '../session/session.js';
 import { type Tool } from '../tool.js';
 import { Trace } from '../types.js';
 export type ExecutionHooks = {
@@ -31,9 +31,21 @@ export type ExecutionHooks = {
      *   This hook will block the execution of the iteration until it resolves.
      *
      * This hook will be called before each iteration starts, regardless of the status.
-     * This is useful for logging or dynamically change model arguments
+     * Use this for observation. Configure dynamic model arguments with their getters.
      */
-    onIterationStart?: (iteration: Iteration, controller: AbortController, context: Context) => Promise<void | Partial<Iteration>> | void | Partial<Iteration>;
+    onIterationStart?: (iteration: Iteration, controller: AbortController, context: Context) => Promise<void> | void;
+    /** Customize the assembled request after compaction. Custom messages must fit the context budget. */
+    onBeforeRequest?: (event: {
+        messages: CognitiveMessage[];
+        iteration: Iteration;
+        controller: AbortController;
+    }) => Promise<{
+        messages: CognitiveMessage[];
+    } | void> | {
+        messages: CognitiveMessage[];
+    } | void;
+    /** Format runtime values; LLMz enforces the supplied budget on custom output. */
+    onInspect?: OnInspect;
     /**
      * BLOCKING HOOK
      *   This hook will block the execution of the iteration until it resolves.
@@ -84,6 +96,8 @@ export type ExecutionHooks = {
         input: any;
         controller: AbortController;
         toolCallId: string;
+        /** Native run_javascript call owning this business call. */
+        nativeCallId?: string;
         object?: string;
     }) => Promise<{
         input?: any;
@@ -104,6 +118,8 @@ export type ExecutionHooks = {
         output: any;
         controller: AbortController;
         toolCallId: string;
+        /** Native run_javascript call owning this business call. */
+        nativeCallId?: string;
         object?: string;
     }) => Promise<{
         output?: any;
@@ -112,10 +128,15 @@ export type ExecutionHooks = {
 type Options = Partial<Pick<Context, 'loop' | 'timeout'>> & {
     /**
      * Optional cap on the model's context window, in tokens.
-     * The effective limit is `min(maxTokens, model's max input tokens)`.
+     * The effective limit is `min(maxTokens, smallest configured model input limit)`.
      * Useful to reduce cost and latency on models with very large context windows.
      */
     maxTokens?: number;
+    /**
+     * Default inspection budget for tool results, from 0 to 2,000 tokens.
+     * Defaults to 2,000. A tool's truncate() wrapper can override this limit.
+     */
+    toolResultMaxTokens?: number;
     /**
      * Maximum time to wait for the first streamed token, in milliseconds, before
      * the cognitive service falls back to the next model/provider. Only applies
@@ -126,8 +147,9 @@ type Options = Partial<Pick<Context, 'loop' | 'timeout'>> & {
     /**
      * Allow Cognitive to restart a failed stream on another model. Previews remain
      * live and are retracted with a restart delta before replacement output.
-     * Completed sends and code always wait for a valid response and successful
-     * transport. Streaming-only; defaults to false.
+     * Complete calls may execute while transport is open. Once execution starts,
+     * a stream failure or restart ends the iteration without replaying its effects.
+     * Streaming-only; defaults to false.
      */
     midStreamFallback?: boolean;
     /**
@@ -138,13 +160,15 @@ type Options = Partial<Pick<Context, 'loop' | 'timeout'>> & {
     transcriptionModel?: SttModels;
 };
 export type ExecutionProps = {
+    /** Append input to this session before execution. Retains history, queued input, and JavaScript memory. */
+    session?: Session;
     /**
      * If provided, the execution will be run in "Chat Mode".
-     * In this mode, the execution will be able to send messages to the chat and will also have access to a chat transcript.
+     * Chat configures assistant text and rich component delivery. Conversation input belongs to the session.
      * The execution can still end with a custom Exit, but a special ListenExit will be added to give back the chat control to the user.
      *
-     * If `chat` is not provided, the execution will run in "Worker Mode", where it will not have access to a chat transcript.
-     * In Worker Mode, the execution will iterate until it reaches an Exit or runs out of iterations.
+     * If `chat` is not provided, the execution will run in "Worker Mode" without chat delivery.
+     * In Worker Mode, the execution uses the same session history and memory, and iterates until an Exit or its limit.
      */
     chat?: Chat;
     /**
@@ -154,14 +178,6 @@ export type ExecutionProps = {
      * Dynamic instructions are evaluated at the start of each iteration, allowing for context-aware instructions.
      */
     instructions?: ValueOrGetter<string, Context>;
-    /**
-     * Labeled examples of one situation and one response, kept outside the live transcript.
-     * Use `new Example({ situation, code })` or `new Example({ situation, messages, exit })`.
-     * Evaluated each iteration, like instructions. Examples must use the current
-     * component/exit catalog. They are kept intact when the prompt is truncated;
-     * select a small relevant set to leave room for tools and conversation.
-     */
-    examples?: ValueOrGetter<Example[], Context>;
     /**
      * Objects available in the context.
      * Objects are useful to scope related tools together and to provide data to the VM.
@@ -194,7 +210,7 @@ export type ExecutionProps = {
      * Exits define the possible endpoints for the execution. Every execution will either end with an exit, or run out of iterations.
      *
      * When `chat` is provided, the built-in "ListenExit" is automatically added.
-     * When `exits` is not provided, the built-in "DefaultExit" is automatically added.
+     * In worker mode, omitting `exits` adds the built-in "DefaultExit". An explicit empty array provides no exits.
      *
      * Each exit has a name and can have aliases, which are alternative names for the exit that can be used to call it.
      * Exits can also have a Zui schema to validate the return value when the exit is reached.
@@ -216,14 +232,6 @@ export type ExecutionProps = {
      * Aborted iterations will end with IterationStatuses.Aborted and the execution will be marked as failed.
      */
     signal?: AbortSignal;
-    /**
-     * A snapshot is a saved state of the execution context.
-     * It can be used to resume the execution of a context at a later time.
-     * This is useful for long-running executions that may need to be paused and resumed later.
-     * The snapshot MUST be settled, which means it has to be resolved or rejected.
-     * Providing an unsettled snapshot will throw an error.
-     */
-    snapshot?: Snapshot;
     /**
      * The model to use for the LLM.
      * This can be a static model name or a function that returns a model name based on the current context.
@@ -252,8 +260,8 @@ export type ExecutionProps = {
 } & ExecutionHooks;
 export type RuntimeCognitive = Pick<Cognitive, 'getModelDetails' | 'generateText'> & {
     /**
-     * Streaming generation. When present, the runtime streams the response and
-     * parses ■ blocks incrementally.
+     * Streaming generation. Assistant text streams as provisional previews; native
+     * tool calls can execute while text streams; both settle before the next iteration.
      */
     generateTextStream?: Cognitive['generateTextStream'];
 };

package/dist/runtime/variable-recovery.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/vm-context.d.ts

@@ -1,5 +1,7 @@
 import { Context, Iteration } from '../context.js';
+import type { TruncationPolicy } from '../truncate.js';
 import { type VMContext } from '../vm/types.js';
+import type { JavaScriptApi } from './javascript-api.js';
 import { ExecutionHooks } from './types.js';
 type BuildVMContextProps = {
     ctx: Context;
@@ -7,6 +9,9 @@ type BuildVMContextProps = {
     controller: AbortController;
     onBeforeTool?: ExecutionHooks['onBeforeTool'];
     onAfterTool?: ExecutionHooks['onAfterTool'];
+    onTruncation?: (value: unknown, policy: TruncationPolicy) => void;
+    onToolResult?: (value: unknown) => void;
+    javascriptApi?: JavaScriptApi;
 };
-export declare const buildVMContext: ({ ctx, iteration, controller, onBeforeTool, onAfterTool, }: BuildVMContextProps) => VMContext;
+export declare const buildVMContext: ({ ctx, iteration, controller, onBeforeTool, onAfterTool, onTruncation, onToolResult, javascriptApi, }: BuildVMContextProps) => VMContext;
 export {};

package/dist/runtime/worker-completion.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime-names.d.ts

@@ -0,0 +1,4 @@
+/** Runtime bindings are never tool names or retained user variables. */
+export declare const RUNTIME_BINDING_NAMES: readonly ['$return', '$iterations', 'exit', 'inspect', 'chat'];
+export declare const TERMINATION_BINDING_NAMES: readonly ['__llmz_guard', '__llmz_checkpoint', '__llmz_missing_tool'];
+export declare const RESERVED_RUNTIME_NAMES: ReadonlySet<string>;

package/dist/schema-Aer_W7Al.js

@@ -0,0 +1,45 @@
+import { H as isLLMzError, b as InvalidConfigurationError } from "./errors-H4JJFH3S.js";
+import { transforms, z } from "@bpinternal/zui";
+//#region src/schema.ts
+const INPUT_SCHEMA_OPTIONS = {
+	target: "openApi3",
+	effectStrategy: "input",
+	pipeStrategy: "input"
+};
+/** Describe values supplied to a schema; JavaScript effects remain in the original validator. */
+function toModelSchema(schema) {
+	try {
+		return transforms.toJSONSchema(schema);
+	} catch {
+		try {
+			return transforms.toJSONSchemaLegacy(schema, INPUT_SCHEMA_OPTIONS);
+		} catch (cause) {
+			throw new InvalidConfigurationError(`Cannot describe schema input: ${String(cause)}`, { cause });
+		}
+	}
+}
+/** Async tool inputs still run their validator exactly once, including before retries. */
+async function parseSchemaAsync(schema, value, subject) {
+	try {
+		return await schema.safeParseAsync(value);
+	} catch (cause) {
+		if (isLLMzError(cause)) throw cause;
+		throw new InvalidConfigurationError(`${subject} schema evaluation failed: ${String(cause)}`, { cause });
+	}
+}
+/** Exit, component and property APIs are synchronous. Tool inputs use safeParseAsync instead. */
+function parseSchemaSync(schema, value, subject) {
+	try {
+		return schema.safeParse(value);
+	} catch (cause) {
+		if (isLLMzError(cause)) throw cause;
+		throw new InvalidConfigurationError(`${subject} schema could not be evaluated synchronously. Use synchronous transforms and refinements here; put asynchronous validation in a tool input schema. ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+	}
+}
+/** Unwrap root effects without executing them or losing the original schema. */
+function schemaInput(schema) {
+	if (z.is.zuiEffects(schema)) return schemaInput(schema.innerType());
+	return z.is.zuiPipeline(schema) ? schemaInput(schema._def.in) : schema;
+}
+//#endregion
+export { toModelSchema as i, parseSchemaSync as n, schemaInput as r, parseSchemaAsync as t };