llmz 0.0.4 → 0.0.6

package/dist/llmz-LAN4WDFW.js

@@ -0,0 +1,581 @@
+import {
+  runAsyncFunction
+} from "./chunk-D3ESDRLH.js";
+import {
+  Context,
+  ErrorExecutionResult,
+  PartialExecutionResult,
+  Snapshot,
+  SuccessExecutionResult
+} from "./chunk-XJNRORSK.js";
+import "./chunk-WLUVY5QU.js";
+import "./chunk-QBXIE6EY.js";
+import "./chunk-UNMKB2DA.js";
+import {
+  AssignmentError,
+  CodeExecutionError,
+  InvalidCodeError,
+  LoopExceededError,
+  Signals,
+  SnapshotSignal,
+  ThinkSignal,
+  VMSignal
+} from "./chunk-JKVVQN2P.js";
+import {
+  cleanStackTrace
+} from "./chunk-JQBT7UWN.js";
+import "./chunk-S6FOL2HY.js";
+import "./chunk-HP7RKM25.js";
+import "./chunk-ORQP26SZ.js";
+import {
+  truncateWrappedContent
+} from "./chunk-QT4QF3YA.js";
+import {
+  init,
+  stripInvalidIdentifiers
+} from "./chunk-5TRUJES5.js";
+import {
+  clamp_default,
+  isEqual_default,
+  isPlainObject_default,
+  omit_default
+} from "./chunk-7WRN4E42.js";
+
+// src/llmz.ts
+import { Cognitive } from "@botpress/cognitive";
+import { z } from "@bpinternal/zui";
+import ms from "ms";
+import { ulid } from "ulid";
+var getErrorMessage = (err) => err instanceof Error ? err.message : JSON.stringify(err);
+var SLOW_TOOL_WARNING = ms("15s");
+var RESPONSE_LENGTH_BUFFER = {
+  MIN_TOKENS: 1e3,
+  MAX_TOKENS: 16e3,
+  PERCENTAGE: 0.1
+};
+var getModelOutputLimit = (inputLength) => clamp_default(
+  RESPONSE_LENGTH_BUFFER.PERCENTAGE * inputLength,
+  RESPONSE_LENGTH_BUFFER.MIN_TOKENS,
+  RESPONSE_LENGTH_BUFFER.MAX_TOKENS
+);
+var executeContext = async (props) => {
+  var _a, _b;
+  await init();
+  const result = await _executeContext(props);
+  try {
+    (_b = (_a = result.context.chat) == null ? void 0 : _a.onExecutionDone) == null ? void 0 : _b.call(_a, result);
+  } catch {
+  }
+  return result;
+};
+var _executeContext = async (props) => {
+  var _a, _b, _c, _d;
+  const { signal, onIterationEnd, onTrace, onExit, onBeforeExecution } = props;
+  const cognitive = props.client instanceof Cognitive ? props.client : new Cognitive({ client: props.client });
+  const cleanups = [];
+  const ctx = new Context({
+    chat: props.chat,
+    instructions: props.instructions,
+    objects: props.objects,
+    tools: props.tools,
+    loop: (_a = props.options) == null ? void 0 : _a.loop,
+    temperature: (_b = props.options) == null ? void 0 : _b.temperature,
+    model: (_c = props.options) == null ? void 0 : _c.model,
+    timeout: (_d = props.options) == null ? void 0 : _d.timeout,
+    exits: props.exits,
+    snapshot: props.snapshot
+  });
+  try {
+    while (true) {
+      if (ctx.iterations.length >= ctx.loop) {
+        return new ErrorExecutionResult(ctx, new LoopExceededError());
+      }
+      const iteration = await ctx.nextIteration();
+      if (signal == null ? void 0 : signal.aborted) {
+        iteration.end({
+          type: "aborted",
+          aborted: {
+            reason: signal.reason ?? "The operation was aborted"
+          }
+        });
+        return new ErrorExecutionResult(ctx, signal.reason ?? "The operation was aborted");
+      }
+      cleanups.push(
+        iteration.traces.onPush((traces) => {
+          for (const trace of traces) {
+            onTrace == null ? void 0 : onTrace({ trace, iteration: ctx.iterations.length });
+          }
+        })
+      );
+      try {
+        await executeIteration({
+          iteration,
+          ctx,
+          cognitive,
+          abortSignal: signal,
+          onExit,
+          onBeforeExecution
+        });
+      } catch (err) {
+        iteration.end({
+          type: "execution_error",
+          execution_error: {
+            message: "An unexpected error occurred: " + getErrorMessage(err),
+            stack: cleanStackTrace(err.stack ?? "No stack trace available")
+          }
+        });
+      }
+      try {
+        await (onIterationEnd == null ? void 0 : onIterationEnd(iteration));
+      } catch (err) {
+        console.error(err);
+      }
+      if (iteration.status.type === "exit_success") {
+        const exitName = iteration.status.exit_success.exit_name;
+        return new SuccessExecutionResult(ctx, {
+          exit: iteration.exits.find((x) => x.name === exitName),
+          result: iteration.status.exit_success.return_value
+        });
+      }
+      if (iteration.status.type === "callback_requested") {
+        return new PartialExecutionResult(
+          ctx,
+          iteration.status.callback_requested.signal,
+          Snapshot.fromSignal(iteration.status.callback_requested.signal)
+        );
+      }
+      if (iteration.status.type === "thinking_requested" || iteration.status.type === "exit_error" || iteration.status.type === "execution_error" || iteration.status.type === "invalid_code_error") {
+        continue;
+      }
+      return new ErrorExecutionResult(ctx, iteration.error ?? `Unknown error. Status: ${iteration.status.type}`);
+    }
+  } catch (error) {
+    return new ErrorExecutionResult(ctx, error ?? "Unknown error");
+  } finally {
+    for (const cleanup of cleanups) {
+      try {
+        cleanup();
+      } catch {
+      }
+    }
+  }
+};
+var executeIteration = async ({
+  iteration,
+  ctx,
+  cognitive,
+  abortSignal,
+  onExit,
+  onBeforeExecution
+}) => {
+  var _a, _b, _c, _d, _e;
+  let startedAt = Date.now();
+  const traces = iteration.traces;
+  const modelLimit = 128e3;
+  const responseLengthBuffer = getModelOutputLimit(modelLimit);
+  const messages = truncateWrappedContent({
+    messages: iteration.messages,
+    tokenLimit: modelLimit - responseLengthBuffer,
+    throwOnFailure: false
+  }).filter(
+    (x) => (
+      // Filter out empty messages, as they are not valid inputs for the LLM
+      // This can happen when a message is truncated and the content is empty
+      x.content.trim().length > 0
+    )
+  );
+  traces.push({
+    type: "llm_call_started",
+    started_at: startedAt,
+    ended_at: startedAt,
+    model: ctx.model ?? ""
+  });
+  const output = await cognitive.generateContent({
+    signal: abortSignal,
+    systemPrompt: (_a = messages.find((x) => x.role === "system")) == null ? void 0 : _a.content,
+    model: ctx.model,
+    temperature: ctx.temperature,
+    responseFormat: "text",
+    messages: messages.filter((x) => x.role === "user" || x.role === "assistant").map(
+      (x) => ({
+        role: x.role === "user" ? "user" : "assistant",
+        type: "text",
+        content: x.content
+      })
+    ),
+    stopSequences: ctx.version.getStopTokens()
+  });
+  const out = ((_c = (_b = output.output.choices) == null ? void 0 : _b[0]) == null ? void 0 : _c.type) === "text" && typeof ((_d = output.output.choices) == null ? void 0 : _d[0].content) === "string" ? output.output.choices[0].content : null;
+  if (!out) {
+    throw new Error("No output from LLM");
+  }
+  const assistantResponse = ctx.version.parseAssistantResponse(out);
+  iteration.code = assistantResponse.code.trim();
+  if (typeof onBeforeExecution === "function") {
+    try {
+      await onBeforeExecution(iteration);
+    } catch (err) {
+      if (err instanceof ThinkSignal) {
+        return iteration.end({
+          type: "thinking_requested",
+          thinking_requested: {
+            variables: err.context,
+            reason: err.reason
+          }
+        });
+      }
+      return iteration.end({
+        type: "execution_error",
+        execution_error: {
+          message: `Error in onBeforeExecution hook: ${getErrorMessage(err)}`,
+          stack: cleanStackTrace(err.stack ?? "No stack trace available")
+        }
+      });
+    }
+  }
+  iteration.llm = {
+    cached: output.meta.cached || false,
+    ended_at: Date.now(),
+    started_at: startedAt,
+    status: "success",
+    tokens: output.meta.tokens.input + output.meta.tokens.output,
+    spend: output.meta.cost.input + output.meta.cost.output,
+    output: assistantResponse.raw,
+    model: `${output.meta.model.integration}:${output.meta.model.model}`
+  };
+  traces.push({
+    type: "llm_call_success",
+    started_at: startedAt,
+    ended_at: iteration.llm.ended_at,
+    model: ctx.model ?? "",
+    code: iteration.code
+  });
+  const vmContext = { ...stripInvalidIdentifiers(iteration.variables) };
+  for (const obj of iteration.objects) {
+    const internalValues = {};
+    const instance = {};
+    for (const { name, value, writable, type } of obj.properties ?? []) {
+      internalValues[name] = value;
+      const initialValue = value;
+      const schema = type ?? z.any();
+      Object.defineProperty(instance, name, {
+        enumerable: true,
+        configurable: true,
+        get() {
+          return internalValues[name];
+        },
+        set(value2) {
+          if (isEqual_default(value2, internalValues[name])) {
+            return;
+          }
+          if (!writable) {
+            throw new AssignmentError(`Property ${obj.name}.${name} is read-only and cannot be modified`);
+          }
+          if (value2 === internalValues[name]) {
+            return;
+          }
+          const parsed = schema.safeParse(value2);
+          if (!parsed.success) {
+            throw new AssignmentError(
+              `Invalid value for Object property ${obj.name}.${name}: ${getErrorMessage(parsed.error)}`
+            );
+          }
+          internalValues[name] = parsed.data;
+          traces.push({
+            type: "property",
+            started_at: Date.now(),
+            object: obj.name,
+            property: name,
+            value: parsed.data
+          });
+          iteration.trackMutation({ object: obj.name, property: name, before: initialValue, after: parsed.data });
+        }
+      });
+    }
+    for (const tool of obj.tools ?? []) {
+      instance[tool.name] = wrapTool({ tool, traces, object: obj.name });
+    }
+    Object.preventExtensions(instance);
+    Object.seal(instance);
+    vmContext[obj.name] = instance;
+  }
+  for (const tool of iteration.tools) {
+    const wrapped = wrapTool({ tool, traces });
+    for (const key of [tool.name, ...tool.aliases ?? []]) {
+      vmContext[key] = wrapped;
+    }
+  }
+  if (abortSignal == null ? void 0 : abortSignal.aborted) {
+    traces.push({
+      type: "abort_signal",
+      started_at: Date.now(),
+      reason: "The operation was aborted by user."
+    });
+    return iteration.end({
+      type: "aborted",
+      aborted: {
+        reason: (abortSignal == null ? void 0 : abortSignal.reason) ?? "The operation was aborted"
+      }
+    });
+  }
+  startedAt = Date.now();
+  const result = await runAsyncFunction(vmContext, iteration.code, traces, abortSignal, ctx.timeout).catch(
+    (err) => {
+      return {
+        success: false,
+        error: err,
+        lines_executed: [],
+        traces: [],
+        variables: {}
+      };
+    }
+  );
+  if (result.error && result.error instanceof InvalidCodeError) {
+    return iteration.end({
+      type: "invalid_code_error",
+      invalid_code_error: {
+        message: result.error.message
+      }
+    });
+  }
+  traces.push({
+    type: "code_execution",
+    lines_executed: result.lines_executed ?? 0,
+    started_at: startedAt,
+    ended_at: Date.now()
+  });
+  if (result.error && result.error instanceof CodeExecutionError) {
+    return iteration.end({
+      type: "execution_error",
+      execution_error: {
+        message: result.error.message,
+        stack: cleanStackTrace(result.error.stacktrace ?? result.error.stack ?? "No stack trace available")
+      }
+    });
+  }
+  if (abortSignal == null ? void 0 : abortSignal.aborted) {
+    return iteration.end({
+      type: "aborted",
+      aborted: {
+        reason: (abortSignal == null ? void 0 : abortSignal.reason) ?? "The operation was aborted"
+      }
+    });
+  }
+  if (!result.success) {
+    return iteration.end({
+      type: "execution_error",
+      execution_error: {
+        message: ((_e = result == null ? void 0 : result.error) == null ? void 0 : _e.message) ?? "Unknown error occurred",
+        stack: cleanStackTrace(result.error.stack ?? "No stack trace available")
+      }
+    });
+  }
+  if (result.signal instanceof ThinkSignal) {
+    return iteration.end({
+      type: "thinking_requested",
+      thinking_requested: {
+        variables: result.signal.context,
+        reason: result.signal.reason
+      }
+    });
+  }
+  if (result.signal instanceof SnapshotSignal) {
+    return iteration.end({
+      type: "callback_requested",
+      callback_requested: {
+        signal: result.signal
+      }
+    });
+  }
+  const validActions = [...iteration.exits.map((x) => x.name.toLowerCase()), "think"];
+  let returnValue = result.success && result.return_value ? result.return_value : null;
+  const returnAction = returnValue == null ? void 0 : returnValue.action;
+  const returnExit = iteration.exits.find((x) => x.name.toLowerCase() === (returnAction == null ? void 0 : returnAction.toLowerCase())) ?? iteration.exits.find((x) => x.aliases.some((a) => a.toLowerCase() === (returnAction == null ? void 0 : returnAction.toLowerCase())));
+  if (returnAction === "think") {
+    const variables = omit_default(returnValue ?? {}, "action");
+    if (isPlainObject_default(variables) && Object.keys(variables).length > 0) {
+      return iteration.end({
+        type: "thinking_requested",
+        thinking_requested: {
+          variables,
+          reason: "Thinking requested"
+        }
+      });
+    }
+    return iteration.end({
+      type: "thinking_requested",
+      thinking_requested: {
+        reason: "Thinking requested",
+        variables: iteration.variables
+      }
+    });
+  }
+  if (!returnAction) {
+    return iteration.end({
+      type: "exit_error",
+      exit_error: {
+        exit: "n/a",
+        message: `Code did not return an action. Valid actions are: ${validActions.join(", ")}`,
+        return_value: returnValue
+      }
+    });
+  }
+  if (!returnExit) {
+    return iteration.end({
+      type: "exit_error",
+      exit_error: {
+        exit: returnAction,
+        message: `Exit "${returnAction}" not found. Valid actions are: ${validActions.join(", ")}`,
+        return_value: returnValue
+      }
+    });
+  }
+  if (returnExit.zSchema) {
+    const parsed = returnExit.zSchema.safeParse(returnValue == null ? void 0 : returnValue.value);
+    if (!parsed.success) {
+      return iteration.end({
+        type: "exit_error",
+        exit_error: {
+          exit: returnExit.name,
+          message: `Invalid return value for exit ${returnExit.name}: ${getErrorMessage(parsed.error)}`,
+          return_value: returnValue
+        }
+      });
+    }
+    returnValue = { action: returnExit.name, value: parsed.data };
+  }
+  try {
+    await (onExit == null ? void 0 : onExit({
+      exit: returnExit,
+      result: returnValue == null ? void 0 : returnValue.value
+    }));
+  } catch (err) {
+    return iteration.end({
+      type: "exit_error",
+      exit_error: {
+        exit: returnExit.name,
+        message: `Error executing exit ${returnExit.name}: ${getErrorMessage(err)}`,
+        return_value: returnValue
+      }
+    });
+  }
+  return iteration.end({
+    type: "exit_success",
+    exit_success: {
+      exit_name: returnExit.name,
+      return_value: returnValue == null ? void 0 : returnValue.value
+    }
+  });
+};
+function wrapTool({ tool, traces, object }) {
+  const getToolInput = (input) => tool.zInput.safeParse(input).data ?? input;
+  return function(input) {
+    const toolCallId = `tcall_${ulid()}`;
+    const alertSlowTool = setTimeout(
+      () => traces.push({
+        type: "tool_slow",
+        tool_name: tool.name,
+        tool_call_id: toolCallId,
+        started_at: Date.now(),
+        input: getToolInput(input),
+        object,
+        duration: SLOW_TOOL_WARNING
+      }),
+      SLOW_TOOL_WARNING
+    );
+    const cancelSlowTool = () => clearTimeout(alertSlowTool);
+    const toolStart = Date.now();
+    let output;
+    let error;
+    let success = true;
+    const handleSignals = (error2) => {
+      if (output === error2) {
+        return true;
+      }
+      if (error2 instanceof SnapshotSignal) {
+        error2.toolCall = {
+          name: tool.name,
+          inputSchema: tool.input,
+          outputSchema: tool.output,
+          input
+        };
+        error2.message = Signals.serializeError(error2);
+      }
+      if (error2 instanceof ThinkSignal) {
+        traces.push({
+          type: "think_signal",
+          started_at: Date.now(),
+          line: 0,
+          ended_at: Date.now()
+        });
+        success = true;
+        output = error2;
+        return true;
+      }
+      return false;
+    };
+    try {
+      const result = tool.execute(input, {
+        callId: toolCallId
+      });
+      if (result instanceof Promise || (result == null ? void 0 : result.then) && (result == null ? void 0 : result.catch)) {
+        return result.then((res) => {
+          output = res;
+          success = true;
+          return res;
+        }).catch((err) => {
+          if (!handleSignals(err)) {
+            success = false;
+            error = err;
+          }
+          throw err;
+        }).finally(() => {
+          cancelSlowTool();
+          traces.push({
+            type: "tool_call",
+            tool_call_id: toolCallId,
+            started_at: toolStart,
+            ended_at: Date.now(),
+            tool_name: tool.name,
+            object,
+            input: getToolInput(input),
+            output,
+            error,
+            success
+          });
+        });
+      }
+      success = true;
+      output = result;
+    } catch (err) {
+      if (!handleSignals(err)) {
+        success = false;
+        error = err;
+      }
+    }
+    cancelSlowTool();
+    traces.push({
+      type: "tool_call",
+      tool_call_id: toolCallId,
+      started_at: toolStart,
+      ended_at: Date.now(),
+      tool_name: tool.name,
+      object,
+      input: getToolInput(input),
+      output,
+      error,
+      success
+    });
+    if (!success) {
+      throw error;
+    }
+    if (output instanceof VMSignal) {
+      throw output;
+    }
+    return output;
+  };
+}
+export {
+  _executeContext,
+  executeContext
+};

package/dist/llmz.d.ts

@@ -1,13 +1,13 @@
 import { Cognitive, type BotpressClientLike } from '@botpress/cognitive';
-import { Component } from './component.js';
+import { Chat } from './chat.js';
 import { Context, Iteration } from './context.js';
-import { Exit } from './exit.js';
+import { Exit, ExitResult } from './exit.js';
 import { ValueOrGetter } from './getter.js';
 import { type ObjectInstance } from './objects.js';
 import { Snapshot } from './snapshots.js';
 import { type Tool } from './tool.js';
-import { TranscriptMessage } from './transcript.js';
-import { ExecutionResult, Trace } from './types.js';
+import { Trace } from './types.js';
+import { ExecutionResult } from './result.js';
 export type ExecutionHooks = {
     /**
      * Called after each iteration ends
@@ -19,24 +19,22 @@ export type ExecutionHooks = {
         trace: Trace;
         iteration: number;
     }) => void;
-    onExit?: <T = unknown>(exit: Exit<T>, value: T) => Promise<void> | void;
+    onExit?: <T = unknown>(result: ExitResult<T>) => Promise<void> | void;
     onBeforeExecution?: (iteration: Iteration) => Promise<void> | void;
 };
 type Options = Partial<Pick<Context, 'loop' | 'temperature' | 'model' | 'timeout'>>;
 export type ExecutionProps = {
+    chat?: Chat;
     instructions?: ValueOrGetter<string, Context>;
-    components?: ValueOrGetter<Component[], Context>;
     objects?: ValueOrGetter<ObjectInstance[], Context>;
     tools?: ValueOrGetter<Tool[], Context>;
     exits?: ValueOrGetter<Exit[], Context>;
-    transcript?: ValueOrGetter<TranscriptMessage[], Context>;
     options?: Options;
     /** An instance of a Botpress Client, or an instance of Cognitive Client (@botpress/cognitive) */
     client: Cognitive | BotpressClientLike;
     signal?: AbortSignal;
     snapshot?: Snapshot;
 } & ExecutionHooks;
-export declare const llmz: {
-    executeContext: (props: ExecutionProps) => Promise<ExecutionResult>;
-};
+export declare const executeContext: (props: ExecutionProps) => Promise<ExecutionResult>;
+export declare const _executeContext: (props: ExecutionProps) => Promise<ExecutionResult>;
 export {};

package/dist/result.d.ts

@@ -0,0 +1,33 @@
+import { Context, Iteration } from './context.js';
+import { SnapshotSignal } from './errors.js';
+import { Exit, ExitResult } from './exit.js';
+import { Snapshot } from './snapshots.js';
+export declare abstract class ExecutionResult {
+    readonly status: 'success' | 'error' | 'interrupted';
+    readonly context: Context;
+    protected constructor(status: 'success' | 'error' | 'interrupted', context: Context);
+    isSuccess(): this is SuccessExecutionResult;
+    isError(): this is ErrorExecutionResult;
+    isInterrupted(): this is PartialExecutionResult;
+    is<T>(exit: Exit<T>): this is SuccessExecutionResult<T>;
+    get output(): unknown | null;
+    get iteration(): Iteration | null;
+    get iterations(): Iteration[];
+}
+export declare class SuccessExecutionResult<TOutput = unknown> extends ExecutionResult {
+    readonly result: ExitResult<TOutput>;
+    constructor(context: Context, result: ExitResult<TOutput>);
+    get output(): TOutput;
+    get iteration(): Iteration;
+}
+export declare class ErrorExecutionResult extends ExecutionResult {
+    readonly error: unknown;
+    constructor(context: Context, error: unknown);
+    get output(): null;
+}
+export declare class PartialExecutionResult extends ExecutionResult {
+    readonly signal: SnapshotSignal;
+    readonly snapshot: Snapshot;
+    constructor(context: Context, signal: SnapshotSignal, snapshot: Snapshot);
+    get output(): null;
+}

package/dist/types.d.ts

@@ -1,6 +1,4 @@
-import { Iteration, type Context } from './context.js';
-import { type SnapshotSignal, type VMSignal } from './errors.js';
-import { type Snapshot } from './snapshots.js';
+import { type VMSignal } from './errors.js';
 export declare namespace Traces {
     type Comment = TraceTemplate<'comment', {
         comment: string;
@@ -100,36 +98,6 @@ export type ObjectMutation = {
     before: any;
     after: any;
 };
-export type SuccessExecutionResult = {
-    status: 'success';
-    iterations: Iteration[];
-    context: Context;
-};
-export type PartialExecutionResult = {
-    status: 'interrupted';
-    iterations: Iteration[];
-    context: Context;
-    signal: SnapshotSignal;
-    snapshot: Snapshot;
-};
-export type ErrorExecutionResult = {
-    status: 'error';
-    iterations: Iteration[];
-    context: Context;
-    error: string;
-};
-export type ExecutionResult = SuccessExecutionResult | PartialExecutionResult | ErrorExecutionResult;
-export declare function expectStatus<T extends ExecutionResult['status']>(execution: ExecutionResult, status: T): asserts execution is Extract<ExecutionResult, {
-    status: T;
-}>;
-export type Tool = {
-    name: string;
-    aliases?: string[];
-    description?: string;
-    input?: unknown;
-    output?: unknown;
-    metadata?: Record<string, any>;
-};
 export type ZuiType<Output = any, Input = Output> = {
     readonly __type__: 'ZuiType';
     readonly _output: Output;