llmz 0.9.0 → 1.0.2

package/dist/context.d.ts

@@ -1,39 +1,35 @@
 import { Models, SttModels } from '@botpress/cognitive';
 import { z } from '@bpinternal/zui';
-import { Chat } from './chat.js';
-import { Component } from './component.js';
-import { SnapshotSignal } from './errors.js';
-import type { Example } from './example.js';
+import { Chat } from './chat/chat.js';
+import { type ComponentRegistry } from './chat/component.js';
+import { type ResolvedResponse } from './chat/response.js';
+import { type ErrorDetails, type LLMzFailure } from './errors.js';
 import { Exit } from './exit.js';
 import { ValueOrGetter } from './getter.js';
-import { HookedArray } from './handlers.js';
-import type { Diagnostic } from './message-stream/types.js';
+import { type Inspector, type OnInspect } from './inspection.js';
 import { ObjectInstance } from './objects.js';
-import { LLMzPrompts, ParsedNext, ParsedSend, Prompt } from './prompts/prompt.js';
-import { Snapshot } from './snapshots.js';
+import { LLMzPrompts } from './prompts/prompt.js';
+import { Session } from './session/session.js';
 import { Tool } from './tool.js';
-import { Transcript, TranscriptArray } from './transcript.js';
 import { ObjectMutation, Serializable, Trace } from './types.js';
 /**
- * Tokenizer-measured size of each part of the prompt, before truncation.
- * Useful to understand what is eating up the context window.
+ * Tokenizer estimate of the final request after compaction, grouped by purpose.
+ * Categories sum to the measured request size; provider-reported usage is separate.
+ * Media transport URLs and encoded bytes are excluded; media token usage is
+ * provider-specific and is not available until the provider reports usage.
  */
 export type ContextTokens = {
-    /** Total measured size of the prompt (sum of all the parts below). */
+    /** Total measured request size (sum of all the parts below). */
     total: number;
-    /** Static prompt scaffolding: response format, VM rules, security guidelines, recap. */
+    /** System scaffolding and structured-message overhead not attributed below. */
     framework: number;
     /** The identity / instructions section. */
     instructions: number;
-    /** tools.d.ts — tools, objects and variable typings. */
+    /** Callable JavaScript declarations and native tool schemas. */
     tools: number;
-    /** The conversation transcript. */
-    transcript: number;
-    /** The ■ protocol reference documenting components and exits. */
+    /** Native execution rules documenting components and exits. */
     protocol: number;
-    /** Consumer few-shot demonstrations, separate from the live transcript. */
-    examples: number;
-    /** Messages carried over from previous iterations (assistant responses, execution results, errors). */
+    /** Current input, retained native history, tool results, and the memory overview. */
     iterations: number;
 };
 /** Token usage of a single iteration's LLM call. */
@@ -46,27 +42,27 @@ export type TokenUsage = {
     total: number;
     /**
      * The effective context window limit of this call, in tokens:
-     * `min(options.maxTokens, model's max input tokens)`. Use it to compute the
+     * `min(options.maxTokens, smallest configured model input limit)`. Use it to compute the
      * percentage of context used (e.g. `context.total / limit`).
      * Undefined until the LLM call starts.
      */
     limit?: number;
-    /** Measured context size by part of the prompt (pre-truncation). */
+    /** Measured context size by part of the request after compaction. */
     context: ContextTokens;
 };
 export type IterationParameters = {
-    transcript: TranscriptArray;
+    chatEnabled: boolean;
     tools: Tool[];
     objects: ObjectInstance[];
     exits: Exit[];
     instructions?: string;
-    examples?: Example[];
-    components: Component[];
+    components: ComponentRegistry;
+    response?: ResolvedResponse;
     model: Models | Models[];
     temperature: number;
     reasoningEffort?: 'low' | 'medium' | 'high' | 'dynamic' | 'none';
 };
-export type IterationStatus = IterationStatuses.Pending | IterationStatuses.GenerationError | IterationStatuses.ExecutionError | IterationStatuses.InvalidCodeError | IterationStatuses.Thinking | IterationStatuses.Callback | IterationStatuses.ExitSuccess | IterationStatuses.ExitError | IterationStatuses.Aborted;
+export type IterationStatus = IterationStatuses.Pending | IterationStatuses.GenerationError | IterationStatuses.ExecutionError | IterationStatuses.InvalidCodeError | IterationStatuses.Thinking | IterationStatuses.ExitSuccess | IterationStatuses.ExitError | IterationStatuses.Aborted;
 export declare namespace IterationStatuses {
     type Pending = {
         type: 'pending';
@@ -97,16 +93,10 @@ export declare namespace IterationStatuses {
             /** The value returned by the executed code (or the context provided by a ThinkSignal). */
             variables: unknown;
             metadata?: Record<string, unknown>;
-            /** A tool paused execution; it did not finish or return normally. */
+            /** A legacy VM control-flow signal paused execution. Tool ThinkSignals now use forced inspection. */
             interrupted?: boolean;
         };
     };
-    type Callback = {
-        type: 'callback_requested';
-        callback_requested: {
-            signal: SnapshotSignal;
-        };
-    };
     type ExitSuccess<T = unknown> = {
         type: 'exit_success';
         exit_success: {
@@ -130,218 +120,14 @@ export declare namespace IterationStatuses {
     };
 }
 /**
- * Built-in exit for requesting thinking time during agent execution.
- *
- * The ThinkExit allows agents to pause execution and reflect on the current situation,
- * variables, and context before continuing. There are two ways to trigger thinking:
- *
- * 1. **Agent-initiated**: Agent calls `return { action: 'think' }` to pause and reflect
- * 2. **Tool/Hook-initiated**: Tools or hooks throw `ThinkSignal` to force agent reflection
- *
- * This exit is automatically available in all LLMz executions and is commonly used for:
- * - Complex decision making that requires analysis
- * - Debugging and understanding current variable state
- * - Planning multi-step operations
- * - Tool feedback and result processing
- * - Reflecting on previous iterations and results
- *
- * @example
- * ```typescript
- * // Agent retrieves web search results and decides to think about them
- * const results = await searchWeb(query)
- *
- * // Agent decides it needs to think (look at the search results) before responding
- * return { action: 'think', results }
- * ```
- *
- * Sometimes, as the author of the tool, you may want to always force the agent to think about the results.
- * In this case, you can throw a `ThinkSignal` from the tool handler to trigger thinking.
- *
- * @example
- * ```typescript
- * // Tool-initiated thinking using ThinkSignal
- * import { ThinkSignal } from 'llmz'
- *
- * const searchTool = new Tool({
- *   name: 'search',
- *   handler: async ({ query }) => {
- *     const results = await performSearch(query)
- *
- *     if (!results.length) {
- *       // Force agent to think about alternative approaches
- *       throw new ThinkSignal(
- *         'No search results found',
- *         'No results were found. Consider rephrasing the query or using a different approach.'
- *       )
- *     }
- *
- *     // Provide context for agent to process results
- *     throw new ThinkSignal(
- *       'Search completed with results',
- *       `Found ${results.length} results. Process them carefully and provide citations.`
- *     )
- *   }
- * })
- * ```
- * When an iteration ends with ThinkExit, the agent will automatically loop and start a new iteration to continue processing, unless iteration limit is reached.
- *
- * The thinking process helps agents:
- * - Avoid rushing into incorrect solutions
- * - Better understand complex problems and tool results
- * - Maintain variable state across iterations
- * - Process feedback from tools and hooks
- * - Provide more thoughtful and accurate responses
- */
-export declare const ThinkExit: Exit<unknown>;
-/**
- * Built-in exit for waiting for user input in chat mode.
- *
- * The ListenExit is automatically available when chat mode is enabled (when a Chat
- * instance is provided to execute()). When an agent calls `return { action: 'listen' }`,
- * the execution pauses and waits for user input before continuing the conversation.
- *
- * This exit is essential for interactive conversational agents and is used to:
- * - Wait for user responses in chat interfaces
- * - Pause execution until user provides input
- * - Enable back-and-forth conversation flow
- * - Allow users to guide the conversation direction
- *
- * The ListenExit is only available in chat mode - it will not be present in
- * worker mode executions where no chat interface is provided.
- *
- * @example
- * ```typescript
- * // Agent generated code using ListenExit in chat mode
- * yield <Message>What would you like me to help you with today?</Message>
- * yield <Button action="postback" label="Get Weather" value="weather" />
- * yield <Button action="postback" label="Set Reminder" value="reminder" />
- *
- * // Wait for user to respond
- * return { action: 'listen' }
- * ```
- *
- * @example
- * ```typescript
- * // Standard chat interaction pattern
- * const calculation = 2 + 8
- * yield <Message>The result of `2 + 8` is **{calculation}**.</Message>
- * return { action: 'listen' }
- * ```
- *
- * @example
- * ```typescript
- * // CLI chat example with ListenExit handling
- * const chat = new CLIChat()
- *
- * while (chat.iterate()) {
- *   const result = await execute({
- *     instructions: 'Help the user with their questions',
- *     chat,
- *     client,
- *   })
- *
- *   if (result.is(ListenExit)) {
- *     // CLIChat handles prompting user automatically
- *     continue
- *   } else {
- *     console.log('Conversation ended')
- *     break
- *   }
- * }
- * ```
- *
- * The ListenExit enables natural conversation flow where:
- * - Agent sends messages and waits for responses
- * - User provides input to guide the conversation
- * - Conversation continues iteratively until completion
- * - Chat interface manages the input/output cycle
+ * Chat completion. JavaScript uses `return exit('listen')`
+ * to wait for user input. A plain assistant answer also implies this exit.
  */
 export declare const ListenExit: Exit<unknown>;
 /**
- * Default exit used when no custom exits are provided.
- *
- * The DefaultExit is automatically used in worker mode when no custom exits are defined.
- * It provides a standard way to complete execution with either success or failure outcomes.
- * The exit uses a discriminated union schema to ensure type-safe handling of both success
- * and error cases.
- *
- * This exit is commonly used for:
- * - Simple worker mode executions without custom completion logic
- * - Standardized success/failure reporting
- * - Basic task completion with result or error information
- * - Default fallback when no specific exit behavior is needed
- *
- * @example
- * ```typescript
- * // Agent generated code using DefaultExit for successful completion
- * const data = await fetchUserData(userId)
- * const processedResult = processData(data)
- *
- * return {
- *   action: 'done',
- *   success: true,
- *   result: processedResult
- * }
- * ```
- *
- * @example
- * ```typescript
- * // Agent generated code using DefaultExit for error cases
- * try {
- *   const result = await riskyOperation()
- *   return { action: 'done', success: true, result }
- * } catch (error) {
- *   return {
- *     action: 'done',
- *     success: false,
- *     error: `Operation failed: ${error.message}`
- *   }
- * }
- * ```
- *
- * @example
- * ```typescript
- * import { execute, DefaultExit } from 'llmz'
- *
- * // Handling DefaultExit in execution results
- * const result = await execute({
- *   instructions: 'Process the user data and return results',
- *   // No custom exits provided - DefaultExit will be used
- *   client,
- * })
- *
- * if (result.is(DefaultExit)) {
- *   if (result.output.success) {
- *     console.log('Success:', result.output.result)
- *   } else {
- *     console.error('Error:', result.output.error)
- *   }
- * }
- * ```
- *
- * @example
- * ```typescript
- * // Worker mode execution with automatic DefaultExit
- * const result = await execute({
- *   instructions: 'Calculate fibonacci numbers up to 100',
- *   tools: [mathTools],
- *   client,
- *   // No chat provided = worker mode
- *   // No exits provided = DefaultExit automatically added
- * })
- *
- * // Result will use DefaultExit for completion
- * if (result.isSuccess() && result.is(DefaultExit)) {
- *   const { success, result: data, error } = result.output
- *   // Handle success/failure cases
- * }
- * ```
- *
- * The DefaultExit provides a consistent interface for:
- * - Type-safe success/failure handling
- * - Standardized result reporting across different executions
- * - Automatic fallback behavior when no custom exits are defined
- * - Clear separation between successful results and error conditions
+ * Worker completion when exits are omitted. JavaScript returns
+ * `exit('done', { success: true, result })` or
+ * `exit('done', { success: false, error })`.
  */
 export declare const DefaultExit: Exit<{
     success: true;
@@ -353,13 +139,11 @@ export declare const DefaultExit: Exit<{
 export declare namespace Iteration {
     type JSON = {
         id: string;
-        messages: LLMzPrompts.Message[];
         code?: string;
         traces: Trace[];
         model: Models | Models[];
         temperature: number;
         reasoningEffort?: 'low' | 'medium' | 'high' | 'dynamic' | 'none';
-        variables: Record<string, any>;
         started_ts: number;
         ended_ts?: number;
         status: IterationStatus;
@@ -372,32 +156,35 @@ export declare namespace Iteration {
             tokens: number;
             spend: number;
             output: string;
-            diagnostics?: Diagnostic[];
             model: string;
             time_to_first_token?: number;
             time_to_last_token?: number;
         };
         tokens?: TokenUsage;
-        transcript: Transcript.Message[];
-        tools: Tool.JSON[];
-        objects: ObjectInstance.JSON[];
-        exits: Exit.JSON[];
-        instructions?: string;
         duration?: string;
         error?: string | null;
+        exception?: ErrorDetails;
+        errors: ErrorDetails[];
         isChatEnabled?: boolean;
     };
 }
 export declare class Iteration implements Serializable<Iteration.JSON> {
     id: string;
-    messages: LLMzPrompts.Message[];
+    readonly systemMessage: LLMzPrompts.Message;
     code?: string;
-    /** Messages (`■send` blocks) parsed from the assistant response, in order. */
-    sends?: ParsedSend[];
-    /** The `■next` exit parsed from the assistant response, if any. */
-    next?: ParsedNext;
-    traces: HookedArray<Trace>;
-    variables: Record<string, any>;
+    sessionInfo?: {
+        id: string;
+        number: number;
+        turn: number;
+        turnId: string;
+        timestamp: number;
+    };
+    /** Outer native call that owns the current JavaScript execution. */
+    nativeCallId?: string;
+    traces: Trace[];
+    private readonly _onTrace?;
+    /** Record a runtime trace and notify the observer without changing execution on observer errors. */
+    recordTrace: (trace: Trace) => void;
     /**
      * Token usage of this iteration's LLM call. The `context` breakdown is measured
      * when the prompt is assembled; `input`/`output` are filled in once the LLM call
@@ -407,12 +194,17 @@ export declare class Iteration implements Serializable<Iteration.JSON> {
     started_ts: number;
     ended_ts?: number;
     status: IterationStatus;
+    /** Original failure for programmatic handling. Execution errors retain their typed cause. */
+    exception?: LLMzFailure;
+    /** All observed failures, including tool errors caught by generated code. */
+    readonly errors: LLMzFailure[];
+    recordError(value: unknown): LLMzFailure;
     private _mutations;
     get mutations(): ObjectMutation[];
     trackMutation(mutation: ObjectMutation): void;
     private _parameters;
-    get components(): Component[];
-    get transcript(): TranscriptArray;
+    get components(): ComponentRegistry;
+    get response(): ResolvedResponse | undefined;
     get tools(): Tool<z.ZodType<any, z.ZodTypeDef, any>, z.ZodType<any, z.ZodTypeDef, any>>[];
     get objects(): ObjectInstance[];
     get model(): Models | Models[];
@@ -429,8 +221,6 @@ export declare class Iteration implements Serializable<Iteration.JSON> {
         tokens: number;
         spend: number;
         output: string;
-        /** Syntax diagnostics from the response parser; raw output remains available above. */
-        diagnostics?: Diagnostic[];
         model: string;
         /** Milliseconds between the LLM call start and the first streamed token. Only set on streaming clients. */
         time_to_first_token?: number;
@@ -450,30 +240,29 @@ export declare class Iteration implements Serializable<Iteration.JSON> {
         status: IterationStatuses.ExitSuccess<R>;
     } & this;
     isSuccessful(this: this): this is this & {
-        status: IterationStatuses.ExitSuccess | IterationStatuses.Callback | IterationStatuses.Thinking;
+        status: IterationStatuses.ExitSuccess | IterationStatuses.Thinking;
     };
     isFailed(this: this): this is this & {
         status: IterationStatuses.GenerationError | IterationStatuses.ExecutionError | IterationStatuses.InvalidCodeError | IterationStatuses.ExitError | IterationStatuses.Aborted;
     };
     get duration(): string;
+    /** Human-readable failure summary. Use exception for instanceof checks and structured details. */
     get error(): string | null;
     get isChatEnabled(): boolean;
     constructor(props: {
         id: string;
         parameters: IterationParameters;
-        messages: LLMzPrompts.Message[];
-        variables: Record<string, any>;
+        systemMessage: LLMzPrompts.Message;
+        onTrace?: (trace: Trace) => void;
     });
-    end(status: IterationStatus): void;
+    end(status: IterationStatus, exception?: unknown): void;
     toJSON(): {
         id: string;
-        messages: import("@botpress/cognitive").CognitiveMessage[];
         code: string | undefined;
         model: Models[] | 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: IterationStatus;
@@ -486,8 +275,6 @@ export declare class Iteration implements Serializable<Iteration.JSON> {
             tokens: number;
             spend: number;
             output: string;
-            /** Syntax diagnostics from the response parser; raw output remains available above. */
-            diagnostics?: Diagnostic[];
             model: string;
             /** Milliseconds between the LLM call start and the first streamed token. Only set on streaming clients. */
             time_to_first_token?: number;
@@ -501,45 +288,10 @@ export declare class Iteration implements Serializable<Iteration.JSON> {
             };
         } | undefined;
         tokens: TokenUsage | undefined;
-        transcript: 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;
+        exception: ErrorDetails | undefined;
+        errors: ErrorDetails[];
         isChatEnabled: boolean;
     };
 }
@@ -551,28 +303,30 @@ export declare namespace Context {
         timeout: number;
         loop: number;
         metadata: Record<string, any>;
-        snapshot?: Snapshot.JSON;
+        sessionId: string;
     };
 }
 export declare class Context implements Serializable<Context.JSON> {
     id: string;
     chat?: Chat;
     instructions?: ValueOrGetter<string, Context>;
-    examples?: ValueOrGetter<Example[], Context>;
     objects?: ValueOrGetter<ObjectInstance[], Context>;
     tools?: ValueOrGetter<Tool[], Context>;
     exits?: ValueOrGetter<Exit[], Context>;
     model?: ValueOrGetter<Models | Models[], Context>;
     temperature: ValueOrGetter<number, Context>;
     reasoningEffort?: ValueOrGetter<'low' | 'medium' | 'high' | 'dynamic' | 'none', Context>;
-    version: Prompt;
+    session: Session;
+    readonly inspector: Inspector;
     timeout: number;
     loop: number;
     /**
      * Optional cap on the model's context window. The effective limit is
-     * `min(maxTokens, model's max input tokens)`.
+     * `min(maxTokens, smallest configured model input limit)`.
      */
     maxTokens?: number;
+    /** Default display budget; explicitly wrapped tool results can override it. */
+    toolResultMaxTokens: number;
     /**
      * Maximum time to wait for the first streamed token, in milliseconds,
      * before the cognitive service falls back to the next model/provider.
@@ -591,12 +345,9 @@ export declare class Context implements Serializable<Context.JSON> {
      */
     transcriptionModel?: SttModels;
     metadata: Record<string, any>;
-    snapshot?: Snapshot;
-    private _lastMessageWithoutExecutionState?;
     iteration: number;
     iterations: Iteration[];
-    nextIteration(): Promise<Iteration>;
-    private _getIterationVariables;
+    nextIteration(onTrace?: (trace: Trace) => void): Promise<Iteration>;
     /**
      * Measures the token size of each part of the prompt (pre-truncation).
      * The named parts come from the system prompt; everything else in the system
@@ -610,7 +361,6 @@ export declare class Context implements Serializable<Context.JSON> {
     constructor(props: {
         chat?: Chat;
         instructions?: ValueOrGetter<string, Context>;
-        examples?: ValueOrGetter<Example[], Context>;
         objects?: ValueOrGetter<ObjectInstance[], Context>;
         tools?: ValueOrGetter<Tool[], Context>;
         exits?: ValueOrGetter<Exit[], Context>;
@@ -619,9 +369,11 @@ export declare class Context implements Serializable<Context.JSON> {
         reasoningEffort?: ValueOrGetter<'low' | 'medium' | 'high' | 'dynamic' | 'none', Context>;
         model?: ValueOrGetter<Models | Models[], Context>;
         metadata?: Record<string, any>;
-        snapshot?: Snapshot;
+        session?: Session;
+        onInspect?: OnInspect;
         timeout?: number;
         maxTokens?: number;
+        toolResultMaxTokens?: number;
         maxTimeToFirstToken?: number;
         midStreamFallback?: boolean;
         transcriptionModel?: SttModels;
@@ -630,13 +382,11 @@ export declare class Context implements Serializable<Context.JSON> {
         id: string;
         iterations: {
             id: string;
-            messages: import("@botpress/cognitive").CognitiveMessage[];
             code: string | undefined;
             model: Models[] | 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: IterationStatus;
@@ -649,8 +399,6 @@ export declare class Context implements Serializable<Context.JSON> {
                 tokens: number;
                 spend: number;
                 output: string;
-                /** Syntax diagnostics from the response parser; raw output remains available above. */
-                diagnostics?: Diagnostic[];
                 model: string;
                 /** Milliseconds between the LLM call start and the first streamed token. Only set on streaming clients. */
                 time_to_first_token?: number;
@@ -664,71 +412,16 @@ export declare class Context implements Serializable<Context.JSON> {
                 };
             } | undefined;
             tokens: TokenUsage | undefined;
-            transcript: 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;
+            exception: ErrorDetails | undefined;
+            errors: ErrorDetails[];
             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;
+        sessionId: string;
     };
 }