llmz 0.0.14 → 0.0.15

package/dist/result.d.ts

@@ -2,6 +2,11 @@ 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';
+export declare namespace ExecutionResult {
+    type JSON = SuccessExecutionResult.JSON | ErrorExecutionResult.JSON | PartialExecutionResult.JSON;
+}
 /**
  * Base class for all execution results returned by the `execute()` function.
  *
@@ -98,10 +103,10 @@ import { Snapshot } from './snapshots.js';
  * @see {@link ErrorExecutionResult} For failed execution results
  * @see {@link PartialExecutionResult} For interrupted execution results
  */
-export declare abstract class ExecutionResult {
-    readonly status: 'success' | 'error' | 'interrupted';
+export declare abstract class ExecutionResult implements Serializable<ExecutionResult.JSON> {
+    readonly status: ExecutionStatus;
     readonly context: Context;
-    protected constructor(status: 'success' | 'error' | 'interrupted', context: Context);
+    protected constructor(status: ExecutionStatus, context: Context);
     /**
      * Type guard to check if the execution completed successfully.
      *
@@ -286,6 +291,17 @@ export declare abstract class ExecutionResult {
      * ```
      */
     get iterations(): Iteration[];
+    abstract toJSON(): ExecutionResult.JSON;
+}
+export declare namespace SuccessExecutionResult {
+    type JSON = {
+        status: 'success';
+        context: Context.JSON;
+        result: {
+            exit: Exit.JSON;
+            result: unknown;
+        };
+    };
 }
 /**
  * Result for successful executions that completed with an Exit.
@@ -333,7 +349,7 @@ export declare abstract class ExecutionResult {
  * }
  * ```
  */
-export declare class SuccessExecutionResult<TOutput = unknown> extends ExecutionResult {
+export declare class SuccessExecutionResult<TOutput = unknown> extends ExecutionResult implements Serializable<SuccessExecutionResult.JSON> {
     readonly result: ExitResult<TOutput>;
     constructor(context: Context, result: ExitResult<TOutput>);
     /**
@@ -355,6 +371,128 @@ export declare class SuccessExecutionResult<TOutput = unknown> extends Execution
      * @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("./index.js").LLMzPrompts.Message[];
+                code: string | 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;
+                    model: string;
+                } | 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;
+            temperature: number;
+            model: "best" | "fast" | `${string}:${string}` | undefined;
+            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;
+        };
+    };
+}
+export declare namespace ErrorExecutionResult {
+    type JSON = {
+        status: 'error';
+        context: Context.JSON;
+        error: unknown;
+    };
 }
 /**
  * Result for executions that failed with an unrecoverable error.
@@ -388,7 +526,7 @@ export declare class SuccessExecutionResult<TOutput = unknown> extends Execution
  * }
  * ```
  */
-export declare class ErrorExecutionResult extends ExecutionResult {
+export declare class ErrorExecutionResult extends ExecutionResult implements Serializable<ErrorExecutionResult.JSON> {
     readonly error: unknown;
     constructor(context: Context, error: unknown);
     /**
@@ -397,6 +535,113 @@ export declare class ErrorExecutionResult extends ExecutionResult {
      * @returns Always null since error executions don't produce output
      */
     get output(): null;
+    toJSON(): {
+        status: "error";
+        context: {
+            id: string;
+            iterations: {
+                id: string;
+                messages: import("./index.js").LLMzPrompts.Message[];
+                code: string | 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;
+                    model: string;
+                } | 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;
+            temperature: number;
+            model: "best" | "fast" | `${string}:${string}` | undefined;
+            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.
@@ -450,7 +695,7 @@ export declare class ErrorExecutionResult extends ExecutionResult {
  * }
  * ```
  */
-export declare class PartialExecutionResult extends ExecutionResult {
+export declare class PartialExecutionResult extends ExecutionResult implements Serializable<PartialExecutionResult.JSON> {
     readonly signal: SnapshotSignal;
     readonly snapshot: Snapshot;
     constructor(context: Context, signal: SnapshotSignal, snapshot: Snapshot);
@@ -460,4 +705,132 @@ export declare class PartialExecutionResult extends ExecutionResult {
      * @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("./index.js").LLMzPrompts.Message[];
+                code: string | 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;
+                    model: string;
+                } | 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;
+            temperature: number;
+            model: "best" | "fast" | `${string}:${string}` | undefined;
+            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;
+            };
+        };
+    };
 }
+export {};

package/dist/snapshots.d.ts

@@ -1,4 +1,5 @@
 import { ToolCall, SnapshotSignal } from './errors.js';
+import { Serializable } from './types.js';
 type Variable = {
     name: string;
     type: string;
@@ -27,6 +28,16 @@ export declare namespace SnapshotStatuses {
         error: unknown;
     };
 }
+export declare namespace Snapshot {
+    type JSON = {
+        id: string;
+        reason?: string;
+        stack: string;
+        variables: Variable[];
+        toolCall?: ToolCall;
+        status: SnapshotStatus;
+    };
+}
 /**
  * Snapshot represents a captured execution state that can be persisted and restored later.
  *
@@ -100,7 +111,7 @@ export declare namespace SnapshotStatuses {
  *
  * @see {@link https://github.com/botpress/botpress/blob/master/packages/llmz/examples/14_worker_snapshot/index.ts} Example usage
  */
-export declare class Snapshot {
+export declare class Snapshot implements Serializable<Snapshot.JSON> {
     #private;
     readonly id: string;
     readonly reason?: string;

package/dist/{tool-NS7EGK7Z.cjs → tool-O4SFRIE4.cjs}

@@ -1,11 +1,11 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkKG7DT7WDcjs = require('./chunk-KG7DT7WD.cjs');
-require('./chunk-4L6D2A6O.cjs');
+var _chunkXGJOEQMWcjs = require('./chunk-XGJOEQMW.cjs');
+require('./chunk-FZJHYLM2.cjs');
 require('./chunk-JDABP4SD.cjs');
 require('./chunk-IKSIOIIP.cjs');
-require('./chunk-276Q6EWP.cjs');
+require('./chunk-WHNOR4ZU.cjs');
 require('./chunk-UQOBUJIQ.cjs');
 
 
-exports.Tool = _chunkKG7DT7WDcjs.Tool;
+exports.Tool = _chunkXGJOEQMWcjs.Tool;

package/dist/{tool-4AJIJ3QB.js → tool-PCOYOCRH.js}

@@ -1,10 +1,10 @@
 import {
   Tool
-} from "./chunk-OKTHMXRT.js";
-import "./chunk-IH2WQFO5.js";
+} from "./chunk-A7QHWVD7.js";
+import "./chunk-EE6NVDID.js";
 import "./chunk-JKVVQN2P.js";
 import "./chunk-JQBT7UWN.js";
-import "./chunk-4MNIJGK6.js";
+import "./chunk-ZORRILUV.js";
 import "./chunk-7WRN4E42.js";
 export {
   Tool

package/dist/tool.d.ts

@@ -1,6 +1,6 @@
 import { TypeOf } from '@bpinternal/zui';
 import { JSONSchema7 } from 'json-schema';
-import { ZuiType } from './types.js';
+import { Serializable, ZuiType } from './types.js';
 /**
  * Input parameters passed to tool retry functions.
  *
@@ -48,6 +48,18 @@ type ToolCallContext = {
     /** Unique identifier for this specific tool call */
     callId: string;
 };
+export declare namespace Tool {
+    type JSON = {
+        name: string;
+        aliases: string[];
+        description?: string;
+        metadata: Record<string, unknown>;
+        input?: JSONSchema7;
+        output?: JSONSchema7;
+        staticInputValues?: SmartPartial<TypeOf<ZuiType>>;
+        maxRetries: number;
+    };
+}
 /**
  * Tool represents a callable function that agents can use to interact with external systems.
  *
@@ -189,7 +201,7 @@ type ToolCallContext = {
  * - **Type coercion**: Basic type coercion where possible
  *
  */
-export declare class Tool<I extends ZuiType = ZuiType, O extends ZuiType = ZuiType> {
+export declare class Tool<I extends ZuiType = ZuiType, O extends ZuiType = ZuiType> implements Serializable<Tool.JSON> {
     private _staticInputValues?;
     name: string;
     aliases: string[];
@@ -493,5 +505,20 @@ export declare class Tool<I extends ZuiType = ZuiType, O extends ZuiType = ZuiTy
      * @static
      */
     static withUniqueNames: (tools: Tool<any, any>[]) => Tool<any, any>[];
+    /**
+     * Converts the tool to its JSON representation.
+     *
+     * @returns JSON representation of the Tool instance
+     */
+    toJSON(): {
+        name: string;
+        aliases: string[];
+        description: string | undefined;
+        metadata: Record<string, unknown>;
+        input: JSONSchema7 | undefined;
+        output: JSONSchema7 | undefined;
+        staticInputValues: unknown;
+        maxRetries: number;
+    };
 }
 export {};

package/dist/{truncator-IY2MXOMC.js → truncator-BSP6PQPC.js}

@@ -1,8 +1,8 @@
 import {
   truncateWrappedContent,
   wrapContent
-} from "./chunk-SNDVQU5A.js";
-import "./chunk-4MNIJGK6.js";
+} from "./chunk-3JYCCI4S.js";
+import "./chunk-ZORRILUV.js";
 import "./chunk-7WRN4E42.js";
 export {
   truncateWrappedContent,

package/dist/truncator-W3NXBLYJ.cjs

@@ -0,0 +1,10 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkGZPN7RGHcjs = require('./chunk-GZPN7RGH.cjs');
+require('./chunk-WHNOR4ZU.cjs');
+require('./chunk-UQOBUJIQ.cjs');
+
+
+
+exports.truncateWrappedContent = _chunkGZPN7RGHcjs.truncateWrappedContent; exports.wrapContent = _chunkGZPN7RGHcjs.wrapContent;

package/dist/types.d.ts

@@ -103,3 +103,6 @@ export type ZuiType<Output = any, Input = Output> = {
     readonly _output: Output;
     readonly _input: Input;
 };
+export type Serializable<J = unknown> = {
+    toJSON(): J;
+};

package/dist/{typings-GDMY6VY2.js → typings-WYHEFCYB.js}

@@ -1,9 +1,9 @@
 import {
   getTypings
-} from "./chunk-IH2WQFO5.js";
+} from "./chunk-EE6NVDID.js";
 import "./chunk-JKVVQN2P.js";
 import "./chunk-JQBT7UWN.js";
-import "./chunk-4MNIJGK6.js";
+import "./chunk-ZORRILUV.js";
 import "./chunk-7WRN4E42.js";
 export {
   getTypings

package/dist/{typings-2CPHOFDN.cjs → typings-Y45GMPZT.cjs}

@@ -1,10 +1,10 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunk4L6D2A6Ocjs = require('./chunk-4L6D2A6O.cjs');
+var _chunkFZJHYLM2cjs = require('./chunk-FZJHYLM2.cjs');
 require('./chunk-JDABP4SD.cjs');
 require('./chunk-IKSIOIIP.cjs');
-require('./chunk-276Q6EWP.cjs');
+require('./chunk-WHNOR4ZU.cjs');
 require('./chunk-UQOBUJIQ.cjs');
 
 
-exports.getTypings = _chunk4L6D2A6Ocjs.getTypings;
+exports.getTypings = _chunkFZJHYLM2cjs.getTypings;

package/dist/utils-L5QAQXV2.cjs

@@ -0,0 +1,39 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkWHNOR4ZUcjs = require('./chunk-WHNOR4ZU.cjs');
+require('./chunk-UQOBUJIQ.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.Identifier = _chunkWHNOR4ZUcjs.Identifier; exports.Tokens = _chunkWHNOR4ZUcjs.Tokens; exports.awaitObject = _chunkWHNOR4ZUcjs.awaitObject; exports.convertObjectToZuiLiterals = _chunkWHNOR4ZUcjs.convertObjectToZuiLiterals; exports.escapeString = _chunkWHNOR4ZUcjs.escapeString; exports.getMultilineComment = _chunkWHNOR4ZUcjs.getMultilineComment; exports.getTokenizer = _chunkWHNOR4ZUcjs.getTokenizer; exports.init = _chunkWHNOR4ZUcjs.init; exports.isJsonSchema = _chunkWHNOR4ZUcjs.isJsonSchema; exports.isValidIdentifier = _chunkWHNOR4ZUcjs.isValidIdentifier; exports.isValidMessageName = _chunkWHNOR4ZUcjs.isValidMessageName; exports.isValidSchema = _chunkWHNOR4ZUcjs.isValidSchema; exports.isZuiSchema = _chunkWHNOR4ZUcjs.isZuiSchema; exports.stripInvalidIdentifiers = _chunkWHNOR4ZUcjs.stripInvalidIdentifiers; exports.toPropertyKey = _chunkWHNOR4ZUcjs.toPropertyKey; exports.toValidFunctionName = _chunkWHNOR4ZUcjs.toValidFunctionName; exports.toValidObjectName = _chunkWHNOR4ZUcjs.toValidObjectName;

package/dist/{utils-N24IHDFA.js → utils-RQHQ2KOG.js}

@@ -16,7 +16,7 @@ import {
   toPropertyKey,
   toValidFunctionName,
   toValidObjectName
-} from "./chunk-4MNIJGK6.js";
+} from "./chunk-ZORRILUV.js";
 import "./chunk-7WRN4E42.js";
 export {
   Identifier,

package/package.json

@@ -2,7 +2,7 @@
   "name": "llmz",
   "type": "module",
   "description": "LLMz – An LLM-native Typescript VM built on top of Zui",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {