llmz 0.0.2

package/dist/context.d.ts

@@ -0,0 +1,167 @@
+import { type Cognitive } from '@botpress/cognitive';
+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 type { OAI } from './openai.js';
+import { Prompt } from './prompts/prompt.js';
+import { Snapshot } from './snapshots.js';
+import { Tool } from './tool.js';
+import { TranscriptArray, TranscriptMessage } 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 class Iteration {
+    id: string;
+    messages: OAI.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<unknown, unknown>[];
+    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: OAI.Message[];
+        variables: Record<string, any>;
+    });
+    end(status: IterationStatus): void;
+}
+export declare class Context {
+    id: string;
+    transcript?: ValueOrGetter<TranscriptArray, Context>;
+    instructions?: ValueOrGetter<string, Context>;
+    objects?: ValueOrGetter<ObjectInstance[], Context>;
+    tools?: ValueOrGetter<Tool[], Context>;
+    exits?: ValueOrGetter<Exit[], Context>;
+    components?: ValueOrGetter<Component[], Context>;
+    version: Prompt;
+    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: {
+        instructions?: ValueOrGetter<string, Context>;
+        objects?: ValueOrGetter<ObjectInstance[], Context>;
+        tools?: ValueOrGetter<Tool[], Context>;
+        exits?: ValueOrGetter<Exit[], Context>;
+        transcript?: ValueOrGetter<TranscriptMessage[], Context>;
+        components?: ValueOrGetter<Component[], Context>;
+        loop?: number;
+        temperature?: number;
+        model?: Model;
+        metadata?: Record<string, any>;
+        snapshot?: Snapshot;
+    });
+}
+export {};

package/dist/dual-modes-2VDEOJ5D.js

@@ -0,0 +1,13 @@
+import {
+  DualModePrompt
+} from "./chunk-QPSUMPLP.js";
+import "./chunk-Q4DEJGXD.js";
+import "./chunk-MSTBEKOQ.js";
+import "./chunk-3T465BEW.js";
+import "./chunk-UVSOAH2H.js";
+import "./chunk-DFZ6GX5C.js";
+import "./chunk-7S3UY52U.js";
+import "./chunk-YSQDPG26.js";
+export {
+  DualModePrompt
+};

package/dist/dual-modes-3MH5N6RY.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkE2B5DRICcjs = require('./chunk-E2B5DRIC.cjs');
+require('./chunk-QZGFCB4T.cjs');
+require('./chunk-PQN6HW7A.cjs');
+require('./chunk-E5W3P7EO.cjs');
+require('./chunk-VP6WWAE2.cjs');
+require('./chunk-ENFB45AI.cjs');
+require('./chunk-3CGLDS5T.cjs');
+require('./chunk-A7BDFLAE.cjs');
+
+
+exports.DualModePrompt = _chunkE2B5DRICcjs.DualModePrompt;

package/dist/errors.d.ts

@@ -0,0 +1,64 @@
+import { JSONSchema } from '@bpinternal/zui';
+import { type Assignment } from './compiler/plugins/track-tool-calls.js';
+export type ToolCall = {
+    name: string;
+    inputSchema?: JSONSchema;
+    outputSchema?: JSONSchema;
+    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 | undefined;
+    constructor(reason: string, context?: any | undefined);
+    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-GYMXZZ4I.js

@@ -0,0 +1,9 @@
+import {
+  Exit
+} from "./chunk-6QDFMQHA.js";
+import "./chunk-DFZ6GX5C.js";
+import "./chunk-7S3UY52U.js";
+import "./chunk-YSQDPG26.js";
+export {
+  Exit
+};

package/dist/exit-PQHMJEOG.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkR2N2UUKCcjs = require('./chunk-R2N2UUKC.cjs');
+require('./chunk-ENFB45AI.cjs');
+require('./chunk-3CGLDS5T.cjs');
+require('./chunk-A7BDFLAE.cjs');
+
+
+exports.Exit = _chunkR2N2UUKCcjs.Exit;

package/dist/exit.d.ts

@@ -0,0 +1,20 @@
+import { type JSONSchema } from '@bpinternal/zui';
+import { ZuiType } from './types.js';
+export declare class Exit<T = unknown> {
+    name: string;
+    aliases: string[];
+    description: string;
+    metadata: Record<string, unknown>;
+    schema?: JSONSchema;
+    get zSchema(): import("@bpinternal/zui").ZodTypeAny | undefined;
+    rename(name: string): this;
+    clone(): Exit<any>;
+    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>;