llmz 0.0.10 → 0.0.12

package/dist/component.default.d.ts

@@ -0,0 +1,316 @@
+import { Component } from './component.js';
+export declare const DefaultComponents: {
+    Button: Component<{
+        type: "leaf";
+        description: string;
+        name: string;
+        aliases: string[];
+        examples: {
+            name: string;
+            description: string;
+            code: string;
+        }[];
+        leaf: {
+            props: import("@bpinternal/zui").ZodObject<{
+                action: import("@bpinternal/zui").ZodDefault<import("@bpinternal/zui").ZodEnum<["say", "url", "postback"]>>;
+                label: import("@bpinternal/zui").ZodString;
+                value: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodString>;
+                url: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodString>;
+            }, "strip", {
+                label: string;
+                action: "say" | "url" | "postback";
+                value?: string | undefined;
+                url?: string | undefined;
+            }, {
+                label: string;
+                value?: string | undefined;
+                action?: "say" | "url" | "postback" | undefined;
+                url?: string | undefined;
+            }>;
+        };
+    }>;
+    Image: Component<{
+        type: "leaf";
+        name: string;
+        description: string;
+        aliases: never[];
+        examples: {
+            name: string;
+            description: string;
+            code: string;
+        }[];
+        leaf: {
+            props: import("@bpinternal/zui").ZodObject<{
+                url: import("@bpinternal/zui").ZodString;
+                alt: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodString>;
+            }, "strip", {
+                url: string;
+                alt?: string | undefined;
+            }, {
+                url: string;
+                alt?: string | undefined;
+            }>;
+        };
+    }>;
+    File: Component<{
+        type: "leaf";
+        name: string;
+        description: string;
+        aliases: never[];
+        examples: {
+            name: string;
+            description: string;
+            code: string;
+        }[];
+        leaf: {
+            props: import("@bpinternal/zui").ZodObject<{
+                url: import("@bpinternal/zui").ZodString;
+                name: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodString>;
+            }, "strip", {
+                url: string;
+                name?: string | undefined;
+            }, {
+                url: string;
+                name?: string | undefined;
+            }>;
+        };
+    }>;
+    Video: Component<{
+        type: "leaf";
+        name: string;
+        description: string;
+        aliases: never[];
+        examples: {
+            name: string;
+            description: string;
+            code: string;
+        }[];
+        leaf: {
+            props: import("@bpinternal/zui").ZodObject<{
+                url: import("@bpinternal/zui").ZodString;
+                title: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodString>;
+            }, "strip", {
+                url: string;
+                title?: string | undefined;
+            }, {
+                url: string;
+                title?: string | undefined;
+            }>;
+        };
+    }>;
+    Audio: Component<{
+        type: "leaf";
+        name: string;
+        description: string;
+        aliases: never[];
+        examples: {
+            name: string;
+            description: string;
+            code: string;
+        }[];
+        leaf: {
+            props: import("@bpinternal/zui").ZodObject<{
+                url: import("@bpinternal/zui").ZodString;
+                title: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodString>;
+            }, "strip", {
+                url: string;
+                title?: string | undefined;
+            }, {
+                url: string;
+                title?: string | undefined;
+            }>;
+        };
+    }>;
+    Card: Component<{
+        type: "container";
+        name: string;
+        description: string;
+        aliases: never[];
+        examples: {
+            name: string;
+            description: string;
+            code: string;
+        }[];
+        container: {
+            props: import("@bpinternal/zui").ZodObject<{
+                title: import("@bpinternal/zui").ZodString;
+                subtitle: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodString>;
+            }, "strip", {
+                title: string;
+                subtitle?: string | undefined;
+            }, {
+                title: string;
+                subtitle?: string | undefined;
+            }>;
+            children: ({
+                description: string;
+                component: {
+                    type: "leaf";
+                    name: string;
+                    description: string;
+                    aliases: never[];
+                    examples: {
+                        name: string;
+                        description: string;
+                        code: string;
+                    }[];
+                    leaf: {
+                        props: import("@bpinternal/zui").ZodObject<{
+                            url: import("@bpinternal/zui").ZodString;
+                            alt: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodString>;
+                        }, "strip", {
+                            url: string;
+                            alt?: string | undefined;
+                        }, {
+                            url: string;
+                            alt?: string | undefined;
+                        }>;
+                    };
+                };
+            } | {
+                description: string;
+                component: {
+                    type: "leaf";
+                    description: string;
+                    name: string;
+                    aliases: string[];
+                    examples: {
+                        name: string;
+                        description: string;
+                        code: string;
+                    }[];
+                    leaf: {
+                        props: import("@bpinternal/zui").ZodObject<{
+                            action: import("@bpinternal/zui").ZodDefault<import("@bpinternal/zui").ZodEnum<["say", "url", "postback"]>>;
+                            label: import("@bpinternal/zui").ZodString;
+                            value: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodString>;
+                            url: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodString>;
+                        }, "strip", {
+                            label: string;
+                            action: "say" | "url" | "postback";
+                            value?: string | undefined;
+                            url?: string | undefined;
+                        }, {
+                            label: string;
+                            value?: string | undefined;
+                            action?: "say" | "url" | "postback" | undefined;
+                            url?: string | undefined;
+                        }>;
+                    };
+                };
+            })[];
+        };
+    }>;
+    Carousel: Component<{
+        type: "container";
+        name: string;
+        description: string;
+        aliases: never[];
+        examples: {
+            name: string;
+            description: string;
+            code: string;
+        }[];
+        container: {
+            props: import("@bpinternal/zui").ZodObject<{}, "strip", {}, {}>;
+            children: {
+                description: string;
+                component: {
+                    type: "container";
+                    name: string;
+                    description: string;
+                    aliases: never[];
+                    examples: {
+                        name: string;
+                        description: string;
+                        code: string;
+                    }[];
+                    container: {
+                        props: import("@bpinternal/zui").ZodObject<{
+                            title: import("@bpinternal/zui").ZodString;
+                            subtitle: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodString>;
+                        }, "strip", {
+                            title: string;
+                            subtitle?: string | undefined;
+                        }, {
+                            title: string;
+                            subtitle?: string | undefined;
+                        }>;
+                        children: ({
+                            description: string;
+                            component: {
+                                type: "leaf";
+                                name: string;
+                                description: string;
+                                aliases: never[];
+                                examples: {
+                                    name: string;
+                                    description: string;
+                                    code: string;
+                                }[];
+                                leaf: {
+                                    props: import("@bpinternal/zui").ZodObject<{
+                                        url: import("@bpinternal/zui").ZodString;
+                                        alt: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodString>;
+                                    }, "strip", {
+                                        url: string;
+                                        alt?: string | undefined;
+                                    }, {
+                                        url: string;
+                                        alt?: string | undefined;
+                                    }>;
+                                };
+                            };
+                        } | {
+                            description: string;
+                            component: {
+                                type: "leaf";
+                                description: string;
+                                name: string;
+                                aliases: string[];
+                                examples: {
+                                    name: string;
+                                    description: string;
+                                    code: string;
+                                }[];
+                                leaf: {
+                                    props: import("@bpinternal/zui").ZodObject<{
+                                        action: import("@bpinternal/zui").ZodDefault<import("@bpinternal/zui").ZodEnum<["say", "url", "postback"]>>;
+                                        label: import("@bpinternal/zui").ZodString;
+                                        value: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodString>;
+                                        url: import("@bpinternal/zui").ZodOptional<import("@bpinternal/zui").ZodString>;
+                                    }, "strip", {
+                                        label: string;
+                                        action: "say" | "url" | "postback";
+                                        value?: string | undefined;
+                                        url?: string | undefined;
+                                    }, {
+                                        label: string;
+                                        value?: string | undefined;
+                                        action?: "say" | "url" | "postback" | undefined;
+                                        url?: string | undefined;
+                                    }>;
+                                };
+                            };
+                        })[];
+                    };
+                };
+            }[];
+        };
+    }>;
+    Text: Component<{
+        type: "default";
+        name: string;
+        aliases: string[];
+        description: string;
+        examples: {
+            name: string;
+            description: string;
+            code: string;
+        }[];
+        default: {
+            props: import("@bpinternal/zui").ZodObject<{}, "strip", {}, {}>;
+            children: never[];
+        };
+    }>;
+};

package/dist/context.d.ts

@@ -0,0 +1,176 @@
+import { type Cognitive } from '@botpress/cognitive';
+import { Chat } from './chat.js';
+import { Component } from './component.js';
+import { SnapshotSignal } from './errors.js';
+import { Exit } from './exit.js';
+import { ValueOrGetter } from './getter.js';
+import { HookedArray } from './handlers.js';
+import { ObjectInstance } from './objects.js';
+import { LLMzPrompts, Prompt } from './prompts/prompt.js';
+import { Snapshot } from './snapshots.js';
+import { Tool } from './tool.js';
+import { TranscriptArray } from './transcript.js';
+import { ObjectMutation, Trace } from './types.js';
+type Model = Parameters<InstanceType<typeof Cognitive>['generateContent']>[0]['model'];
+export type IterationParameters = {
+    transcript: TranscriptArray;
+    tools: Tool[];
+    objects: ObjectInstance[];
+    exits: Exit[];
+    instructions?: string;
+    components: Component[];
+};
+export type IterationStatus = IterationStatuses.Pending | IterationStatuses.GenerationError | IterationStatuses.ExecutionError | IterationStatuses.InvalidCodeError | IterationStatuses.Thinking | IterationStatuses.Callback | IterationStatuses.ExitSuccess | IterationStatuses.ExitError | IterationStatuses.Aborted;
+export declare namespace IterationStatuses {
+    type Pending = {
+        type: 'pending';
+    };
+    type GenerationError = {
+        type: 'generation_error';
+        generation_error: {
+            message: string;
+        };
+    };
+    type InvalidCodeError = {
+        type: 'invalid_code_error';
+        invalid_code_error: {
+            message: string;
+        };
+    };
+    type ExecutionError = {
+        type: 'execution_error';
+        execution_error: {
+            message: string;
+            stack: string;
+        };
+    };
+    type Thinking = {
+        type: 'thinking_requested';
+        thinking_requested: {
+            reason?: string;
+            variables: Record<string, unknown>;
+        };
+    };
+    type Callback = {
+        type: 'callback_requested';
+        callback_requested: {
+            signal: SnapshotSignal;
+        };
+    };
+    type ExitSuccess<T = unknown> = {
+        type: 'exit_success';
+        exit_success: {
+            exit_name: string;
+            return_value: T;
+        };
+    };
+    type ExitError = {
+        type: 'exit_error';
+        exit_error: {
+            exit: string;
+            return_value: unknown;
+            message: string;
+        };
+    };
+    type Aborted = {
+        type: 'aborted';
+        aborted: {
+            reason: string;
+        };
+    };
+}
+export declare const ThinkExit: Exit<unknown>;
+export declare const ListenExit: Exit<unknown>;
+export declare const DefaultExit: Exit<{
+    success: true;
+    result?: any;
+} | {
+    error: string;
+    success: false;
+}>;
+export declare class Iteration {
+    id: string;
+    messages: LLMzPrompts.Message[];
+    code?: string;
+    traces: HookedArray<Trace>;
+    variables: Record<string, any>;
+    started_ts: number;
+    ended_ts?: number;
+    status: IterationStatus;
+    private _mutations;
+    get mutations(): ObjectMutation[];
+    trackMutation(mutation: ObjectMutation): void;
+    private _parameters;
+    get transcript(): TranscriptArray;
+    get tools(): Tool<import("./types.js").ZuiType, import("./types.js").ZuiType>[];
+    get objects(): ObjectInstance[];
+    get exits(): Exit<unknown>[];
+    get instructions(): string | undefined;
+    llm?: {
+        started_at: number;
+        ended_at: number;
+        status: 'success' | 'error';
+        cached: boolean;
+        tokens: number;
+        spend: number;
+        output: string;
+        model: string;
+    };
+    hasExited(this: this): this is this & {
+        status: IterationStatuses.ExitSuccess;
+    };
+    hasExitedWith<R>(this: this, exit: Exit<R>): this is {
+        status: IterationStatuses.ExitSuccess<R>;
+    } & this;
+    isSuccessful(this: this): this is this & {
+        status: IterationStatuses.ExitSuccess | IterationStatuses.Callback | IterationStatuses.Thinking;
+    };
+    isFailed(this: this): this is this & {
+        status: IterationStatuses.GenerationError | IterationStatuses.ExecutionError | IterationStatuses.InvalidCodeError | IterationStatuses.ExitError | IterationStatuses.Aborted;
+    };
+    get duration(): string;
+    get error(): string | null;
+    get isChatEnabled(): boolean;
+    constructor(props: {
+        id: string;
+        parameters: IterationParameters;
+        messages: LLMzPrompts.Message[];
+        variables: Record<string, any>;
+    });
+    end(status: IterationStatus): void;
+}
+export declare class Context {
+    id: string;
+    chat?: Chat;
+    instructions?: ValueOrGetter<string, Context>;
+    objects?: ValueOrGetter<ObjectInstance[], Context>;
+    tools?: ValueOrGetter<Tool[], Context>;
+    exits?: ValueOrGetter<Exit[], Context>;
+    version: Prompt;
+    timeout: number;
+    loop: number;
+    temperature: number;
+    model?: Model;
+    metadata: Record<string, any>;
+    snapshot?: Snapshot;
+    iteration: number;
+    iterations: Iteration[];
+    nextIteration(): Promise<Iteration>;
+    private _getIterationVariables;
+    private _getIterationMessages;
+    private _refreshIterationParameters;
+    constructor(props: {
+        chat?: Chat;
+        instructions?: ValueOrGetter<string, Context>;
+        objects?: ValueOrGetter<ObjectInstance[], Context>;
+        tools?: ValueOrGetter<Tool[], Context>;
+        exits?: ValueOrGetter<Exit[], Context>;
+        loop?: number;
+        temperature?: number;
+        model?: Model;
+        metadata?: Record<string, any>;
+        snapshot?: Snapshot;
+        timeout?: number;
+    });
+}
+export {};

package/dist/dual-modes-T53P72CH.js

@@ -0,0 +1,12 @@
+import {
+  DualModePrompt
+} from "./chunk-KH6JQYQA.js";
+import "./chunk-JQBT7UWN.js";
+import "./chunk-GGWM6X2K.js";
+import "./chunk-ORQP26SZ.js";
+import "./chunk-SNDVQU5A.js";
+import "./chunk-4MNIJGK6.js";
+import "./chunk-7WRN4E42.js";
+export {
+  DualModePrompt
+};

package/dist/dual-modes-VLIGPIHX.cjs

@@ -0,0 +1,12 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkSHJDRZF5cjs = require('./chunk-SHJDRZF5.cjs');
+require('./chunk-IKSIOIIP.cjs');
+require('./chunk-ZRCU35UV.cjs');
+require('./chunk-KMZDFWYZ.cjs');
+require('./chunk-JGVAZO4X.cjs');
+require('./chunk-276Q6EWP.cjs');
+require('./chunk-UQOBUJIQ.cjs');
+
+
+exports.DualModePrompt = _chunkSHJDRZF5cjs.DualModePrompt;

package/dist/errors.d.ts

@@ -0,0 +1,64 @@
+import { JSONSchema7 } from 'json-schema';
+import { type Assignment } from './compiler/plugins/track-tool-calls.js';
+export type ToolCall = {
+    name: string;
+    inputSchema?: JSONSchema7;
+    outputSchema?: JSONSchema7;
+    input?: unknown;
+    assignment?: Assignment;
+};
+export declare namespace Signals {
+    function isWrappedError(error: Error): boolean;
+    function serializeError(error: Error): string;
+    function maybeDeserializeError(error: unknown): any;
+}
+export declare class VMSignal extends Error {
+    message: string;
+    /**
+     * The code that was executed by the VM up to the point of the signal
+     */
+    truncatedCode: string;
+    /** The current tool call, if any */
+    toolCall?: ToolCall;
+    /**
+     * Contains all the declared and executed variables during the VM execution
+     * See file plugins/variable-extraction.ts for more details
+     */
+    variables: {
+        [key: string]: any;
+    };
+    constructor(message: string);
+}
+/** Request a snapshot from inside a tool call */
+export declare class SnapshotSignal extends VMSignal {
+    constructor(message: string);
+}
+/** Loop means LLMz will continue the execution (unless it exhausted its iterations) */
+export declare class VMLoopSignal extends VMSignal {
+    constructor(message: string);
+}
+export declare class ThinkSignal extends VMLoopSignal {
+    reason: string;
+    context?: any;
+    constructor(reason: string, context?: any);
+    toString(): string;
+}
+export declare class CodeExecutionError extends Error {
+    code: string;
+    stacktrace: string;
+    constructor(message: string, code: string, stacktrace: string);
+}
+export declare class InvalidCodeError extends Error {
+    code: string;
+    constructor(message: string, code: string);
+}
+export declare class LoopExceededError extends Error {
+    constructor();
+}
+export declare class CodeFormattingError extends Error {
+    code: string;
+    constructor(message: string, code: string);
+}
+export declare class AssignmentError extends Error {
+    constructor(message: string);
+}

package/dist/exit-TRXEU4OU.cjs

@@ -0,0 +1,8 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkGWFYZDURcjs = require('./chunk-GWFYZDUR.cjs');
+require('./chunk-276Q6EWP.cjs');
+require('./chunk-UQOBUJIQ.cjs');
+
+
+exports.Exit = _chunkGWFYZDURcjs.Exit;

package/dist/exit-YORW76T3.js

@@ -0,0 +1,8 @@
+import {
+  Exit
+} from "./chunk-JMSZKB4T.js";
+import "./chunk-4MNIJGK6.js";
+import "./chunk-7WRN4E42.js";
+export {
+  Exit
+};

package/dist/exit.d.ts

@@ -0,0 +1,26 @@
+import { JSONSchema7 } from 'json-schema';
+import { ZuiType } from './types.js';
+export type ExitResult<T = unknown> = {
+    exit: Exit<T>;
+    result: T;
+};
+export declare class Exit<T = unknown> {
+    name: string;
+    aliases: string[];
+    description: string;
+    metadata: Record<string, unknown>;
+    schema?: JSONSchema7;
+    get zSchema(): import("@bpinternal/zui").ZodTypeAny | undefined;
+    rename(name: string): this;
+    clone(): Exit<any>;
+    is<T>(exit: Exit<T>): this is Exit<T>;
+    match(result: ExitResult): result is ExitResult<T>;
+    constructor(props: {
+        name: string;
+        aliases?: string[];
+        description: string;
+        metadata?: Record<string, unknown>;
+        schema?: ZuiType<T>;
+    });
+    static withUniqueNames: (exits: Exit[]) => Exit<unknown>[];
+}

package/dist/formatting.d.ts

@@ -0,0 +1,5 @@
+import { format } from 'prettier/standalone';
+export type CodeFormatOptions = Parameters<typeof format>[1] & {
+    throwOnError?: boolean;
+};
+export declare function formatTypings(typings: string, options?: CodeFormatOptions): Promise<string>;

package/dist/getter.d.ts

@@ -0,0 +1,2 @@
+export type ValueOrGetter<T, I> = T | ((ctx: I) => T) | ((ctx: I) => Promise<T>);
+export declare const getValue: <T, I>(valueOrGetter: ValueOrGetter<T, I>, ctx?: I) => Promise<T>;

package/dist/handlers.d.ts

@@ -0,0 +1,10 @@
+type UnsubscribeFn = () => void;
+type EventHandler<T> = (event: T) => void;
+export type SubscribeFn<T> = (fn: EventHandler<T>) => UnsubscribeFn;
+export declare class HookedArray<T> extends Array<T> {
+    #private;
+    constructor(...items: T[]);
+    push(...items: T[]): number;
+    onPush(fn: EventHandler<T[]>): UnsubscribeFn;
+}
+export {};

package/dist/hoist.d.ts

@@ -0,0 +1,2 @@
+import { CodeFormatOptions } from './formatting.js';
+export declare function hoistTypings(code: string, formatOptions?: CodeFormatOptions): Promise<string>;