llmz 0.9.0 → 1.0.2

package/dist/result.d.ts

@@ -1,891 +1,60 @@
-import { Context, Iteration } from './context.js';
-import { SnapshotSignal } from './errors.js';
-import { Exit, ExitResult } from './exit.js';
-import { Snapshot } from './snapshots.js';
-import { Serializable } from './types.js';
-type ExecutionStatus = 'success' | 'error' | 'interrupted';
+import type { Context, Iteration } from './context.js';
+import { type LLMzFailure } from './errors.js';
+import type { Exit, ExitResult } from './exit.js';
+import type { Session } from './session/session.js';
+type ExecutionStatus = 'success' | 'error';
+type ResultSummary = {
+    sessionId: string;
+    tokens: {
+        input: number;
+        output: number;
+        total: number;
+    };
+};
 export declare namespace ExecutionResult {
-    type JSON = SuccessExecutionResult.JSON | ErrorExecutionResult.JSON | PartialExecutionResult.JSON;
+    type JSON = SuccessExecutionResult.JSON | ErrorExecutionResult.JSON;
 }
-/**
- * Base class for all execution results returned by the `execute()` function.
- *
- * ExecutionResult provides a type-safe way to handle the different outcomes of LLMz
- * agent execution. All results contain the execution context and provide methods
- * to check the final status and access relevant data.
- *
- * ## Result Types
- *
- * LLMz execution can result in three different outcomes:
- * - **Success**: Agent completed with an Exit (SuccessExecutionResult)
- * - **Error**: Execution failed with an unrecoverable error (ErrorExecutionResult)
- * - **Interrupted**: Execution was paused for snapshots or cancellation (PartialExecutionResult)
- *
- * ## Usage Patterns
- *
- * ### Basic Status Checking
- * ```typescript
- * const result = await execute({
- *   instructions: 'Calculate the sum of numbers 1 to 100',
- *   client,
- * })
- *
- * if (result.isSuccess()) {
- *   console.log('Success:', result.output)
- * } else if (result.isError()) {
- *   console.error('Error:', result.error)
- * } else if (result.isInterrupted()) {
- *   console.log('Interrupted - snapshot available:', !!result.snapshot)
- * }
- * ```
- *
- * ### Type-Safe Exit Checking
- * ```typescript
- * const dataExit = new Exit({
- *   name: 'dataProcessed',
- *   schema: z.object({
- *     recordCount: z.number(),
- *     processingTime: z.number(),
- *   }),
- * })
- *
- * const result = await execute({
- *   instructions: 'Process the data',
- *   exits: [dataExit],
- *   client,
- * })
- *
- * // Type-safe exit checking with typed output access
- * if (result.is(dataExit)) {
- *   console.log(`Processed ${result.output.recordCount} records`)
- *   console.log(`Processing took ${result.output.processingTime}ms`)
- * }
- * ```
- *
- * ### Accessing Execution Details
- * ```typescript
- * if (result.isSuccess()) {
- *   // Access the generated code from the final iteration
- *   console.log('Generated code:', result.iteration.code)
- *
- *   // Access all iterations to see the full execution flow
- *   result.iterations.forEach((iteration, index) => {
- *     console.log(`Iteration ${index + 1}:`, iteration.status.type)
- *   })
- *
- *   // Access execution context
- *   console.log('Original instructions:', result.context.instructions)
- * }
- * ```
- *
- * ### Snapshot Handling
- * ```typescript
- * if (result.isInterrupted()) {
- *   // Serialize snapshot for persistence
- *   const serialized = result.snapshot.toJSON()
- *   await database.saveSnapshot(serialized)
- *
- *   // Later, resume from snapshot
- *   const snapshot = Snapshot.fromJSON(serialized)
- *   snapshot.resolve({ data: 'resolved data' })
- *
- *   const continuation = await execute({
- *     snapshot,
- *     instructions: result.context.instructions,
- *     tools: result.context.tools,
- *     exits: result.context.exits,
- *     client,
- *   })
- * }
- * ```
- *
- * @see {@link SuccessExecutionResult} For successful execution results
- * @see {@link ErrorExecutionResult} For failed execution results
- * @see {@link PartialExecutionResult} For interrupted execution results
- */
-export declare abstract class ExecutionResult implements Serializable<ExecutionResult.JSON> {
+/** An execution outcome. Persist Session separately; diagnostics belong to this run. */
+export declare abstract class ExecutionResult {
     readonly status: ExecutionStatus;
     readonly context: Context;
     protected constructor(status: ExecutionStatus, context: Context);
-    /**
-     * Type guard to check if the execution completed successfully.
-     *
-     * @returns True if the execution completed with an Exit, false otherwise
-     * @example
-     * ```typescript
-     * const result = await execute({ ... })
-     *
-     * if (result.isSuccess()) {
-     *   // TypeScript knows this is SuccessExecutionResult
-     *   console.log('Output:', result.output)
-     *   console.log('Exit name:', result.result.exit.name)
-     * }
-     * ```
-     */
     isSuccess(): this is SuccessExecutionResult;
-    /**
-     * Type guard to check if the execution failed with an error.
-     *
-     * @returns True if the execution failed with an unrecoverable error, false otherwise
-     * @example
-     * ```typescript
-     * const result = await execute({ ... })
-     *
-     * if (result.isError()) {
-     *   // TypeScript knows this is ErrorExecutionResult
-     *   console.error('Execution failed:', result.error)
-     *
-     *   // Access error details from the last iteration
-     *   const lastIteration = result.iteration
-     *   if (lastIteration?.status.type === 'execution_error') {
-     *     console.error('Stack trace:', lastIteration.status.execution_error.stack)
-     *   }
-     * }
-     * ```
-     */
     isError(): this is ErrorExecutionResult;
-    /**
-     * Type guard to check if the execution was interrupted.
-     * Interrupted means there's a snapshot available and the execution was paused and needs resuming.
-     *
-     * @returns True if the execution was interrupted, false otherwise
-     * @example
-     * ```typescript
-     * const result = await execute({ ... })
-     *
-     * if (result.isInterrupted()) {
-     *   // TypeScript knows this is PartialExecutionResult
-     *   console.log('Execution paused:', result.signal.message)
-     *
-     *   // Access snapshot for later resumption
-     *   const snapshot = result.snapshot
-     *   const serialized = snapshot.toJSON()
-     *   await storage.save('execution-state', serialized)
-     * }
-     * ```
-     */
-    isInterrupted(): this is PartialExecutionResult;
-    /**
-     * Type guard to check if the execution completed with a specific exit.
-     *
-     * This method provides type-safe access to the output data based on the exit's schema.
-     * It's the recommended way to handle different exit types in complex agents.
-     *
-     * @param exit - The Exit instance to check against
-     * @returns True if the execution completed with the specified exit, false otherwise
-     * @template T - The output type of the exit
-     *
-     * @example
-     * ```typescript
-     * // Define typed exits
-     * const successExit = new Exit({
-     *   name: 'success',
-     *   schema: z.object({
-     *     message: z.string(),
-     *     count: z.number(),
-     *   }),
-     * })
-     *
-     * const errorExit = new Exit({
-     *   name: 'error',
-     *   schema: z.object({
-     *     errorCode: z.string(),
-     *     details: z.string(),
-     *   }),
-     * })
-     *
-     * const result = await execute({
-     *   instructions: 'Process the data',
-     *   exits: [successExit, errorExit],
-     *   client,
-     * })
-     *
-     * // Type-safe exit handling
-     * if (result.is(successExit)) {
-     *   // TypeScript knows result.output has { message: string, count: number }
-     *   console.log(`Success: ${result.output.message}`)
-     *   console.log(`Processed ${result.output.count} items`)
-     * } else if (result.is(errorExit)) {
-     *   // TypeScript knows result.output has { errorCode: string, details: string }
-     *   console.error(`Error ${result.output.errorCode}: ${result.output.details}`)
-     * }
-     * ```
-     */
     is<T>(exit: Exit<T>): this is SuccessExecutionResult<T>;
-    /**
-     * Gets the output data from the last successful iteration.
-     *
-     * For successful executions, returns the data produced by the exit.
-     * For failed or interrupted executions, returns null.
-     *
-     * @returns The output data for successful executions, null otherwise
-     * @example
-     * ```typescript
-     * const result = await execute({ ... })
-     *
-     * // Generic output access
-     * if (result.isSuccess()) {
-     *   console.log('Output:', result.output)
-     * }
-     *
-     * // Type-safe output access with specific exits
-     * if (result.is(myExit)) {
-     *   // result.output is now typed based on myExit's schema
-     *   console.log(result.output.specificField)
-     * }
-     * ```
-     */
-    get output(): unknown | null;
-    /**
-     * Gets the most recent (last) iteration from the execution.
-     *
-     * Iterations represent individual steps in the execution loop where the LLM
-     * generates code, executes it, and processes the results. The last iteration
-     * contains the final generated code and execution status.
-     *
-     * @returns The last iteration, or null if no iterations were completed
-     * @example
-     * ```typescript
-     * const result = await execute({ ... })
-     *
-     * const lastIteration = result.iteration
-     * if (lastIteration) {
-     *   console.log('Generated code:', lastIteration.code)
-     *   console.log('Status:', lastIteration.status.type)
-     *   console.log('Variables:', lastIteration.variables)
-     *   console.log('Tool calls:', lastIteration.toolCalls)
-     * }
-     * ```
-     */
+    get session(): Session;
+    get output(): unknown;
     get iteration(): Iteration | null;
-    /**
-     * Gets all iterations from the execution.
-     *
-     * This provides access to the complete execution history, showing how the agent
-     * progressed through multiple iterations to reach the final result. Useful for
-     * debugging, logging, or understanding the agent's reasoning process.
-     *
-     * @returns Array of all iterations in execution order
-     * @example
-     * ```typescript
-     * const result = await execute({ ... })
-     *
-     * // Analyze the full execution flow
-     * result.iterations.forEach((iteration, index) => {
-     *   console.log(`Iteration ${index + 1}:`)
-     *   console.log('  Status:', iteration.status.type)
-     *   console.log('  Code length:', iteration.code?.length || 0)
-     *   console.log('  Tool calls:', iteration.toolCalls.length)
-     *   console.log('  Variables:', Object.keys(iteration.variables).length)
-     * })
-     *
-     * // Find iterations with specific characteristics
-     * const iterationsWithErrors = result.iterations.filter(
-     *   iter => iter.status.type === 'execution_error'
-     * )
-     *
-     * // Calculate total execution time
-     * const totalTime = result.iterations.reduce(
-     *   (sum, iter) => sum + (iter.duration || 0), 0
-     * )
-     * ```
-     */
     get iterations(): Iteration[];
-    /**
-     * Gets the total token usage of the execution, aggregated across all iterations.
-     *
-     * `input`/`output` are the provider-reported token counts of every LLM call made
-     * during the execution. Per-iteration detail (including the measured context size
-     * breakdown by prompt part) is available on each iteration's `tokens` property.
-     *
-     * @example
-     * ```typescript
-     * const result = await execute({ ... })
-     * console.log(`Execution used ${result.tokens.total} tokens`)
-     *
-     * for (const iteration of result.iterations) {
-     *   console.log(iteration.id, iteration.tokens?.context)
-     * }
-     * ```
-     */
-    get tokens(): {
-        input: number;
-        output: number;
-        total: number;
-    };
+    get tokens(): ResultSummary['tokens'];
+    /** Explicit diagnostic export without conversation or memory persistence. */
+    diagnostics(): Context.JSON;
     abstract toJSON(): ExecutionResult.JSON;
 }
 export declare namespace SuccessExecutionResult {
-    type JSON = {
+    type JSON = ResultSummary & {
         status: 'success';
-        context: Context.JSON;
-        result: {
-            exit: Exit.JSON;
-            result: unknown;
-        };
+        exit: string;
+        output: unknown;
     };
 }
-/**
- * Result for successful executions that completed with an Exit.
- *
- * SuccessExecutionResult indicates that the agent successfully completed its task
- * and returned structured data through one of the provided exits. This is the
- * most common positive outcome for LLMz executions.
- *
- * In *Worker Mode* (ie. no `chat` provided), if no exits were provided, the "DefaultExit" will be used.
- * If *Chat Mode* is enabled, most likely the "ListenExit" will be used if no exits were provided.
- *
- * You can check for a specific exit using the `is()` method, which provides type-safe access to the output data of the exit.
- * You can import "ListenExit" and "DefaultExit" from `llmz`.
- *
- * @template TOutput - The type of the output data based on the exit schema
- *
- * @example
- * ```typescript
- * import { execute, Exit, DefaultExit, ListenExit } from 'llmz'
- *
- * const exit = new Exit({
- *   name: 'dataProcessed',
- *   schema: z.object({
- *     recordCount: z.number(),
- *     summary: z.string(),
- *   }),
- * })
- *
- * const result = await execute({
- *   instructions: 'Process the user data',
- *   exits: [exit],
- *   client,
- * })
- *
- * if (result.isSuccess() && result.is(exit)) {
- *   // Access the exit information
- *   console.log('Exit name:', result.result.exit.name)
- *
- *   // Access typed output data
- *   console.log('Records processed:', result.output.recordCount)
- *   console.log('Summary:', result.output.summary)
- *
- *   // Access the final iteration (guaranteed to exist)
- *   console.log('Generated code:', result.iteration.code)
- * }
- * ```
- */
-export declare class SuccessExecutionResult<TOutput = unknown> extends ExecutionResult implements Serializable<SuccessExecutionResult.JSON> {
+export declare class SuccessExecutionResult<TOutput = unknown> extends ExecutionResult {
     readonly result: ExitResult<TOutput>;
     constructor(context: Context, result: ExitResult<TOutput>);
-    /**
-     * Gets the typed output data from the successful execution.
-     *
-     * This overrides the base class output property to provide proper typing
-     * based on the exit schema. The output is guaranteed to match the schema
-     * of the exit that was triggered.
-     *
-     * @returns The typed output data
-     */
     get output(): TOutput;
-    /**
-     * Gets the final iteration from the successful execution.
-     *
-     * For successful executions, there is always at least one iteration,
-     * so this method returns the guaranteed non-null final iteration.
-     *
-     * @returns The final iteration (guaranteed to exist)
-     */
     get iteration(): Iteration;
-    /**
-     * Serializes the execution result to JSON.
-     *
-     * This method converts the execution result into a JSON format that includes
-     * the execution status, context, and exit information. It is used for serialization
-     * and transmission of the execution result.
-     *
-     * @returns The JSON representation of the execution result.
-     */
-    toJSON(): {
-        status: 'success';
-        context: {
-            id: string;
-            iterations: {
-                id: string;
-                messages: import("@botpress/cognitive").CognitiveMessage[];
-                code: string | undefined;
-                model: import("@botpress/cognitive").Models[] | import("@botpress/cognitive").Models;
-                temperature: number;
-                reasoningEffort: "dynamic" | "high" | "low" | "medium" | "none" | undefined;
-                traces: import("./types.js").Traces.Trace[];
-                variables: Record<string, any>;
-                started_ts: number;
-                ended_ts: number | undefined;
-                status: import("./context.js").IterationStatus;
-                mutations: import("./types.js").ObjectMutation[];
-                llm: {
-                    started_at: number;
-                    ended_at: number;
-                    status: 'success' | 'error';
-                    cached: boolean;
-                    tokens: number;
-                    spend: number;
-                    output: string;
-                    diagnostics?: import("./index.js").Diagnostic[];
-                    model: string;
-                    time_to_first_token?: number;
-                    time_to_last_token?: number;
-                    usage: {
-                        inputCost: number;
-                        outputCost: number;
-                        inputTokens: number;
-                        outputTokens: number;
-                    };
-                } | undefined;
-                tokens: import("./context.js").TokenUsage | undefined;
-                transcript: import("./transcript.js").Transcript.Message[];
-                tools: {
-                    name: string;
-                    aliases: string[];
-                    description: string | undefined;
-                    metadata: Record<string, unknown>;
-                    input: import("json-schema").JSONSchema7 | undefined;
-                    output: import("json-schema").JSONSchema7 | undefined;
-                    staticInputValues: unknown;
-                    maxRetries: number;
-                }[];
-                objects: {
-                    name: string;
-                    description: string | undefined;
-                    properties: import("./objects.js").ObjectProperty[] | undefined;
-                    tools: {
-                        name: string;
-                        aliases: string[];
-                        description: string | undefined;
-                        metadata: Record<string, unknown>;
-                        input: import("json-schema").JSONSchema7 | undefined;
-                        output: import("json-schema").JSONSchema7 | undefined;
-                        staticInputValues: unknown;
-                        maxRetries: number;
-                    }[];
-                    metadata: Record<string, unknown> | undefined;
-                }[];
-                exits: {
-                    name: string;
-                    aliases: string[];
-                    description: string;
-                    metadata: {
-                        [x: string]: unknown;
-                    };
-                    schema: import("json-schema").JSONSchema7 | undefined;
-                }[];
-                instructions: string | undefined;
-                duration: string;
-                error: string | null;
-                isChatEnabled: boolean;
-            }[];
-            iteration: number;
-            timeout: number;
-            loop: number;
-            metadata: Record<string, any>;
-            snapshot: {
-                id: string;
-                reason: string | undefined;
-                stack: string;
-                variables: ({
-                    name: string;
-                    type: string;
-                    bytes: number;
-                    preview?: string;
-                    value?: unknown;
-                    truncated: boolean;
-                } & ({
-                    truncated: true;
-                    preview: string;
-                } | {
-                    truncated: false;
-                    value: unknown;
-                }))[];
-                toolCall: import("./errors.js").ToolCall | undefined;
-                status: import("./snapshots.js").SnapshotStatus;
-            } | undefined;
-        };
-        result: {
-            exit: {
-                name: string;
-                aliases: string[];
-                description: string;
-                metadata: {
-                    [x: string]: unknown;
-                };
-                schema: import("json-schema").JSONSchema7 | undefined;
-            };
-            result: TOutput;
-        };
-    };
+    toJSON(): SuccessExecutionResult.JSON;
 }
 export declare namespace ErrorExecutionResult {
-    type JSON = {
+    type JSON = ResultSummary & {
         status: 'error';
-        context: Context.JSON;
         error: unknown;
     };
 }
-/**
- * Result for executions that failed with an unrecoverable error.
- *
- * ErrorExecutionResult indicates that the execution encountered an error that could not be recovered from, such as:
- * - Execution has been aborted by the user (eg. via the `signal` AbortSignal parameter)
- * - Iterations exceeded the maximum allowed limit
- *
- * Upon iteration failure, the execution will continue until the maximum iteration limit is reached or an exit is triggered.
- *
- * @example
- * ```typescript
- * const result = await execute({
- *   instructions: 'Call a non-existent function',
- *   client,
- * })
- *
- * if (result.isError()) {
- *   console.error('Execution failed:', result.error)
- *
- *   // Access error details from the last iteration
- *   const lastIteration = result.iteration
- *   if (lastIteration?.status.type === 'execution_error') {
- *     console.error('Error type:', lastIteration.status.execution_error.type)
- *     console.error('Stack trace:', lastIteration.status.execution_error.stack)
- *     console.error('Generated code:', lastIteration.code)
- *   }
- *
- *   // Access all iterations to understand the failure progression
- *   console.log('Total iterations before failure:', result.iterations.length)
- * }
- * ```
- */
-export declare class ErrorExecutionResult extends ExecutionResult implements Serializable<ErrorExecutionResult.JSON> {
-    readonly error: unknown;
+export declare class ErrorExecutionResult extends ExecutionResult {
+    readonly error: LLMzFailure;
     constructor(context: Context, error: unknown);
-    /**
-     * Gets the output data (always null for error results).
-     *
-     * @returns Always null since error executions don't produce output
-     */
     get output(): null;
-    toJSON(): {
-        status: 'error';
-        context: {
-            id: string;
-            iterations: {
-                id: string;
-                messages: import("@botpress/cognitive").CognitiveMessage[];
-                code: string | undefined;
-                model: import("@botpress/cognitive").Models[] | import("@botpress/cognitive").Models;
-                temperature: number;
-                reasoningEffort: "dynamic" | "high" | "low" | "medium" | "none" | undefined;
-                traces: import("./types.js").Traces.Trace[];
-                variables: Record<string, any>;
-                started_ts: number;
-                ended_ts: number | undefined;
-                status: import("./context.js").IterationStatus;
-                mutations: import("./types.js").ObjectMutation[];
-                llm: {
-                    started_at: number;
-                    ended_at: number;
-                    status: 'success' | 'error';
-                    cached: boolean;
-                    tokens: number;
-                    spend: number;
-                    output: string;
-                    diagnostics?: import("./index.js").Diagnostic[];
-                    model: string;
-                    time_to_first_token?: number;
-                    time_to_last_token?: number;
-                    usage: {
-                        inputCost: number;
-                        outputCost: number;
-                        inputTokens: number;
-                        outputTokens: number;
-                    };
-                } | undefined;
-                tokens: import("./context.js").TokenUsage | undefined;
-                transcript: import("./transcript.js").Transcript.Message[];
-                tools: {
-                    name: string;
-                    aliases: string[];
-                    description: string | undefined;
-                    metadata: Record<string, unknown>;
-                    input: import("json-schema").JSONSchema7 | undefined;
-                    output: import("json-schema").JSONSchema7 | undefined;
-                    staticInputValues: unknown;
-                    maxRetries: number;
-                }[];
-                objects: {
-                    name: string;
-                    description: string | undefined;
-                    properties: import("./objects.js").ObjectProperty[] | undefined;
-                    tools: {
-                        name: string;
-                        aliases: string[];
-                        description: string | undefined;
-                        metadata: Record<string, unknown>;
-                        input: import("json-schema").JSONSchema7 | undefined;
-                        output: import("json-schema").JSONSchema7 | undefined;
-                        staticInputValues: unknown;
-                        maxRetries: number;
-                    }[];
-                    metadata: Record<string, unknown> | undefined;
-                }[];
-                exits: {
-                    name: string;
-                    aliases: string[];
-                    description: string;
-                    metadata: {
-                        [x: string]: unknown;
-                    };
-                    schema: import("json-schema").JSONSchema7 | undefined;
-                }[];
-                instructions: string | undefined;
-                duration: string;
-                error: string | null;
-                isChatEnabled: boolean;
-            }[];
-            iteration: number;
-            timeout: number;
-            loop: number;
-            metadata: Record<string, any>;
-            snapshot: {
-                id: string;
-                reason: string | undefined;
-                stack: string;
-                variables: ({
-                    name: string;
-                    type: string;
-                    bytes: number;
-                    preview?: string;
-                    value?: unknown;
-                    truncated: boolean;
-                } & ({
-                    truncated: true;
-                    preview: string;
-                } | {
-                    truncated: false;
-                    value: unknown;
-                }))[];
-                toolCall: import("./errors.js").ToolCall | undefined;
-                status: import("./snapshots.js").SnapshotStatus;
-            } | undefined;
-        };
-        error: unknown;
-    };
-}
-export declare namespace PartialExecutionResult {
-    type JSON = {
-        status: 'interrupted';
-        context: Context.JSON;
-        snapshot: Snapshot.JSON;
-        signal: {
-            message: string;
-            truncatedCode?: string;
-            variables: Record<string, any>;
-        };
-    };
-}
-/**
- * Result for executions that were interrupted before completion.
- *
- * PartialExecutionResult indicates that a snapshot was created during the execution.
- * Interrupted executions can be resumed using the provided snapshot.
- *
- * @example
- * ```typescript
- * // Tool that throws SnapshotSignal for long-running operations
- * const longRunningTool = new Tool({
- *   name: 'processLargeDataset',
- *   async handler({ datasetId }) {
- *     // Start background processing
- *     const jobId = await startBackgroundJob(datasetId)
- *
- *     // Pause execution until job completes
- *     throw new SnapshotSignal('Processing dataset', 'Waiting for background job completion', {
- *       jobId,
- *       datasetId,
- *       startTime: Date.now(),
- *     })
- *   },
- * })
- *
- * const result = await execute({
- *   instructions: 'Process the large dataset',
- *   tools: [longRunningTool],
- *   client,
- * })
- *
- * if (result.isInterrupted()) {
- *   console.log('Execution paused:', result.signal.message)
- *   console.log('Reason:', result.signal.longMessage)
- *
- *   // Serialize snapshot for later resumption
- *   const serialized = result.snapshot.toJSON()
- *   await database.saveSnapshot('job-123', serialized)
- *
- *   // Later, when the background job completes...
- *   const snapshot = Snapshot.fromJSON(serialized)
- *   snapshot.resolve({ jobResult: 'Processing completed successfully' })
- *
- *   const continuation = await execute({
- *     snapshot,
- *     instructions: result.context.instructions,
- *     tools: result.context.tools,
- *     exits: result.context.exits,
- *     client,
- *   })
- * }
- * ```
- */
-export declare class PartialExecutionResult extends ExecutionResult implements Serializable<PartialExecutionResult.JSON> {
-    readonly signal: SnapshotSignal;
-    readonly snapshot: Snapshot;
-    constructor(context: Context, signal: SnapshotSignal, snapshot: Snapshot);
-    /**
-     * Gets the output data (always null for interrupted results).
-     *
-     * @returns Always null since interrupted executions don't produce final output
-     */
-    get output(): null;
-    /**
-     * Serializes the execution result to JSON.
-     *
-     * @returns The JSON representation of the execution result.
-     */
-    toJSON(): {
-        status: 'interrupted';
-        context: {
-            id: string;
-            iterations: {
-                id: string;
-                messages: import("@botpress/cognitive").CognitiveMessage[];
-                code: string | undefined;
-                model: import("@botpress/cognitive").Models[] | import("@botpress/cognitive").Models;
-                temperature: number;
-                reasoningEffort: "dynamic" | "high" | "low" | "medium" | "none" | undefined;
-                traces: import("./types.js").Traces.Trace[];
-                variables: Record<string, any>;
-                started_ts: number;
-                ended_ts: number | undefined;
-                status: import("./context.js").IterationStatus;
-                mutations: import("./types.js").ObjectMutation[];
-                llm: {
-                    started_at: number;
-                    ended_at: number;
-                    status: 'success' | 'error';
-                    cached: boolean;
-                    tokens: number;
-                    spend: number;
-                    output: string;
-                    diagnostics?: import("./index.js").Diagnostic[];
-                    model: string;
-                    time_to_first_token?: number;
-                    time_to_last_token?: number;
-                    usage: {
-                        inputCost: number;
-                        outputCost: number;
-                        inputTokens: number;
-                        outputTokens: number;
-                    };
-                } | undefined;
-                tokens: import("./context.js").TokenUsage | undefined;
-                transcript: import("./transcript.js").Transcript.Message[];
-                tools: {
-                    name: string;
-                    aliases: string[];
-                    description: string | undefined;
-                    metadata: Record<string, unknown>;
-                    input: import("json-schema").JSONSchema7 | undefined;
-                    output: import("json-schema").JSONSchema7 | undefined;
-                    staticInputValues: unknown;
-                    maxRetries: number;
-                }[];
-                objects: {
-                    name: string;
-                    description: string | undefined;
-                    properties: import("./objects.js").ObjectProperty[] | undefined;
-                    tools: {
-                        name: string;
-                        aliases: string[];
-                        description: string | undefined;
-                        metadata: Record<string, unknown>;
-                        input: import("json-schema").JSONSchema7 | undefined;
-                        output: import("json-schema").JSONSchema7 | undefined;
-                        staticInputValues: unknown;
-                        maxRetries: number;
-                    }[];
-                    metadata: Record<string, unknown> | undefined;
-                }[];
-                exits: {
-                    name: string;
-                    aliases: string[];
-                    description: string;
-                    metadata: {
-                        [x: string]: unknown;
-                    };
-                    schema: import("json-schema").JSONSchema7 | undefined;
-                }[];
-                instructions: string | undefined;
-                duration: string;
-                error: string | null;
-                isChatEnabled: boolean;
-            }[];
-            iteration: number;
-            timeout: number;
-            loop: number;
-            metadata: Record<string, any>;
-            snapshot: {
-                id: string;
-                reason: string | undefined;
-                stack: string;
-                variables: ({
-                    name: string;
-                    type: string;
-                    bytes: number;
-                    preview?: string;
-                    value?: unknown;
-                    truncated: boolean;
-                } & ({
-                    truncated: true;
-                    preview: string;
-                } | {
-                    truncated: false;
-                    value: unknown;
-                }))[];
-                toolCall: import("./errors.js").ToolCall | undefined;
-                status: import("./snapshots.js").SnapshotStatus;
-            } | undefined;
-        };
-        snapshot: {
-            id: string;
-            reason: string | undefined;
-            stack: string;
-            variables: ({
-                name: string;
-                type: string;
-                bytes: number;
-                preview?: string;
-                value?: unknown;
-                truncated: boolean;
-            } & ({
-                truncated: true;
-                preview: string;
-            } | {
-                truncated: false;
-                value: unknown;
-            }))[];
-            toolCall: import("./errors.js").ToolCall | undefined;
-            status: import("./snapshots.js").SnapshotStatus;
-        };
-        signal: {
-            message: string;
-            truncatedCode: string;
-            variables: {
-                [key: string]: any;
-            };
-        };
-    };
+    toJSON(): ErrorExecutionResult.JSON;
 }
 export {};