llmz 0.0.11 → 0.0.13

package/dist/inspect.d.ts

@@ -0,0 +1,6 @@
+type PreviewOptions = {
+    tokens: number;
+};
+export declare function extractType(value: unknown, generic?: boolean): string;
+export declare const inspect: (value: unknown, name?: string, options?: PreviewOptions) => string;
+export {};

package/dist/jsx-AEHVFB3L.js

@@ -0,0 +1,13 @@
+import {
+  Jsx,
+  createJsxComponent,
+  isAnyJsxComponent,
+  isJsxComponent
+} from "./chunk-ORQP26SZ.js";
+import "./chunk-7WRN4E42.js";
+export {
+  Jsx,
+  createJsxComponent,
+  isAnyJsxComponent,
+  isJsxComponent
+};

package/dist/jsx-AJAXBWFE.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+var _chunkKMZDFWYZcjs = require('./chunk-KMZDFWYZ.cjs');
+require('./chunk-UQOBUJIQ.cjs');
+
+
+
+
+
+exports.Jsx = _chunkKMZDFWYZcjs.Jsx; exports.createJsxComponent = _chunkKMZDFWYZcjs.createJsxComponent; exports.isAnyJsxComponent = _chunkKMZDFWYZcjs.isAnyJsxComponent; exports.isJsxComponent = _chunkKMZDFWYZcjs.isJsxComponent;

package/dist/jsx.d.ts

@@ -0,0 +1,11 @@
+import { z } from '@bpinternal/zui';
+export type JsxComponent<TType extends string = string, TProps extends {} = {}, TChildren = any> = {
+    __jsx: true;
+    type: TType;
+    props: TProps;
+    children: Array<TChildren>;
+};
+export declare function isAnyJsxComponent(component: any): component is JsxComponent;
+export declare function isJsxComponent<T extends JsxComponent>(type: T['type'], component: any): component is T;
+export declare const createJsxComponent: (props: Omit<JsxComponent, "__jsx">) => JsxComponent;
+export declare const Jsx: z.Schema<JsxComponent<string, {}, any>, import("@bpinternal/zui").ZodTypeDef, JsxComponent<string, {}, any>>;

package/dist/llmz-QLZBDG2Z.cjs

@@ -0,0 +1,576 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkBEPRLBPKcjs = require('./chunk-BEPRLBPK.cjs');
+
+
+
+
+
+
+var _chunkHJKOSEH2cjs = require('./chunk-HJKOSEH2.cjs');
+require('./chunk-SHJDRZF5.cjs');
+require('./chunk-C6WNNTEV.cjs');
+require('./chunk-4L6D2A6O.cjs');
+
+
+
+
+
+
+
+
+
+var _chunkJDABP4SDcjs = require('./chunk-JDABP4SD.cjs');
+
+
+var _chunkIKSIOIIPcjs = require('./chunk-IKSIOIIP.cjs');
+require('./chunk-GWFYZDUR.cjs');
+require('./chunk-ZRCU35UV.cjs');
+require('./chunk-KMZDFWYZ.cjs');
+
+
+var _chunkJGVAZO4Xcjs = require('./chunk-JGVAZO4X.cjs');
+
+
+
+var _chunk276Q6EWPcjs = require('./chunk-276Q6EWP.cjs');
+
+
+
+
+
+var _chunkUQOBUJIQcjs = require('./chunk-UQOBUJIQ.cjs');
+
+// src/llmz.ts
+var _cognitive = require('@botpress/cognitive');
+var _zui = require('@bpinternal/zui');
+var _ms = require('ms'); var _ms2 = _interopRequireDefault(_ms);
+var _ulid = require('ulid');
+var getErrorMessage = (err) => err instanceof Error ? err.message : JSON.stringify(err);
+var SLOW_TOOL_WARNING = _ms2.default.call(void 0, "15s");
+var RESPONSE_LENGTH_BUFFER = {
+  MIN_TOKENS: 1e3,
+  MAX_TOKENS: 16e3,
+  PERCENTAGE: 0.1
+};
+var getModelOutputLimit = (inputLength) => _chunkUQOBUJIQcjs.clamp_default.call(void 0, 
+  RESPONSE_LENGTH_BUFFER.PERCENTAGE * inputLength,
+  RESPONSE_LENGTH_BUFFER.MIN_TOKENS,
+  RESPONSE_LENGTH_BUFFER.MAX_TOKENS
+);
+var executeContext = async (props) => {
+  var _a, _b;
+  await _chunk276Q6EWPcjs.init.call(void 0, );
+  const result = await _executeContext(props);
+  try {
+    (_b = (_a = result.context.chat) == null ? void 0 : _a.onExecutionDone) == null ? void 0 : _b.call(_a, result);
+  } catch (e) {
+  }
+  return result;
+};
+var _executeContext = async (props) => {
+  var _a, _b, _c, _d;
+  const { signal, onIterationEnd, onTrace, onExit, onBeforeExecution } = props;
+  const cognitive = _cognitive.Cognitive.isCognitiveClient(props.client) ? props.client : new (0, _cognitive.Cognitive)({ client: props.client });
+  const cleanups = [];
+  const ctx = new (0, _chunkHJKOSEH2cjs.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 (0, _chunkHJKOSEH2cjs.ErrorExecutionResult)(ctx, new (0, _chunkJDABP4SDcjs.LoopExceededError)());
+      }
+      const iteration = await ctx.nextIteration();
+      if (signal == null ? void 0 : signal.aborted) {
+        iteration.end({
+          type: "aborted",
+          aborted: {
+            reason: _nullishCoalesce(signal.reason, () => ( "The operation was aborted"))
+          }
+        });
+        return new (0, _chunkHJKOSEH2cjs.ErrorExecutionResult)(ctx, _nullishCoalesce(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: _chunkIKSIOIIPcjs.cleanStackTrace.call(void 0, _nullishCoalesce(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 (0, _chunkHJKOSEH2cjs.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 (0, _chunkHJKOSEH2cjs.PartialExecutionResult)(
+          ctx,
+          iteration.status.callback_requested.signal,
+          _chunkHJKOSEH2cjs.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 (0, _chunkHJKOSEH2cjs.ErrorExecutionResult)(ctx, _nullishCoalesce(iteration.error, () => ( `Unknown error. Status: ${iteration.status.type}`)));
+    }
+  } catch (error) {
+    return new (0, _chunkHJKOSEH2cjs.ErrorExecutionResult)(ctx, _nullishCoalesce(error, () => ( "Unknown error")));
+  } finally {
+    for (const cleanup of cleanups) {
+      try {
+        cleanup();
+      } catch (e2) {
+      }
+    }
+  }
+};
+var executeIteration = async ({
+  iteration,
+  ctx,
+  cognitive,
+  abortSignal,
+  onExit,
+  onBeforeExecution
+}) => {
+  var _a, _b, _c, _d, _e;
+  let startedAt = Date.now();
+  const traces = iteration.traces;
+  const model = await cognitive.getModelDetails(_nullishCoalesce(ctx.model, () => ( "best")));
+  const modelLimit = model.input.maxTokens;
+  const responseLengthBuffer = getModelOutputLimit(modelLimit);
+  const messages = _chunkJGVAZO4Xcjs.truncateWrappedContent.call(void 0, {
+    messages: iteration.messages,
+    tokenLimit: modelLimit - responseLengthBuffer,
+    throwOnFailure: true
+  }).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
+      typeof x.content !== "string" || x.content.trim().length > 0
+    )
+  );
+  traces.push({
+    type: "llm_call_started",
+    started_at: startedAt,
+    ended_at: startedAt,
+    model: model.ref
+  });
+  const output = await cognitive.generateContent({
+    signal: abortSignal,
+    systemPrompt: (_a = messages.find((x) => x.role === "system")) == null ? void 0 : _a.content,
+    model: model.ref,
+    temperature: ctx.temperature,
+    responseFormat: "text",
+    messages: messages.filter((x) => x.role !== "system"),
+    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 _chunkJDABP4SDcjs.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: _chunkIKSIOIIPcjs.cleanStackTrace.call(void 0, _nullishCoalesce(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: model.ref,
+    code: iteration.code
+  });
+  const vmContext = { ..._chunk276Q6EWPcjs.stripInvalidIdentifiers.call(void 0, iteration.variables) };
+  for (const obj of iteration.objects) {
+    const internalValues = {};
+    const instance = {};
+    for (const { name, value, writable, type } of _nullishCoalesce(obj.properties, () => ( []))) {
+      internalValues[name] = value;
+      const initialValue = value;
+      const schema = _nullishCoalesce(type, () => ( _zui.z.any()));
+      Object.defineProperty(instance, name, {
+        enumerable: true,
+        configurable: true,
+        get() {
+          return internalValues[name];
+        },
+        set(value2) {
+          if (_chunkUQOBUJIQcjs.isEqual_default.call(void 0, value2, internalValues[name])) {
+            return;
+          }
+          if (!writable) {
+            throw new (0, _chunkJDABP4SDcjs.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 (0, _chunkJDABP4SDcjs.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 _nullishCoalesce(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, ..._nullishCoalesce(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: _nullishCoalesce((abortSignal == null ? void 0 : abortSignal.reason), () => ( "The operation was aborted"))
+      }
+    });
+  }
+  startedAt = Date.now();
+  const result = await _chunkBEPRLBPKcjs.runAsyncFunction.call(void 0, vmContext, iteration.code, traces, abortSignal, ctx.timeout).catch(
+    (err) => {
+      return {
+        success: false,
+        error: err,
+        lines_executed: [],
+        traces: [],
+        variables: {}
+      };
+    }
+  );
+  if (result.error && result.error instanceof _chunkJDABP4SDcjs.InvalidCodeError) {
+    return iteration.end({
+      type: "invalid_code_error",
+      invalid_code_error: {
+        message: result.error.message
+      }
+    });
+  }
+  traces.push({
+    type: "code_execution",
+    lines_executed: _nullishCoalesce(result.lines_executed, () => ( 0)),
+    started_at: startedAt,
+    ended_at: Date.now()
+  });
+  if (result.error && result.error instanceof _chunkJDABP4SDcjs.CodeExecutionError) {
+    return iteration.end({
+      type: "execution_error",
+      execution_error: {
+        message: result.error.message,
+        stack: _chunkIKSIOIIPcjs.cleanStackTrace.call(void 0, _nullishCoalesce(_nullishCoalesce(result.error.stacktrace, () => ( result.error.stack)), () => ( "No stack trace available")))
+      }
+    });
+  }
+  if (abortSignal == null ? void 0 : abortSignal.aborted) {
+    return iteration.end({
+      type: "aborted",
+      aborted: {
+        reason: _nullishCoalesce((abortSignal == null ? void 0 : abortSignal.reason), () => ( "The operation was aborted"))
+      }
+    });
+  }
+  if (!result.success) {
+    return iteration.end({
+      type: "execution_error",
+      execution_error: {
+        message: _nullishCoalesce(((_e = result == null ? void 0 : result.error) == null ? void 0 : _e.message), () => ( "Unknown error occurred")),
+        stack: _chunkIKSIOIIPcjs.cleanStackTrace.call(void 0, _nullishCoalesce(result.error.stack, () => ( "No stack trace available")))
+      }
+    });
+  }
+  if (result.signal instanceof _chunkJDABP4SDcjs.ThinkSignal) {
+    return iteration.end({
+      type: "thinking_requested",
+      thinking_requested: {
+        variables: result.signal.context,
+        reason: result.signal.reason
+      }
+    });
+  }
+  if (result.signal instanceof _chunkJDABP4SDcjs.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 = _nullishCoalesce(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 = _chunkUQOBUJIQcjs.omit_default.call(void 0, _nullishCoalesce(returnValue, () => ( {})), "action");
+    if (_chunkUQOBUJIQcjs.isPlainObject_default.call(void 0, 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) => _nullishCoalesce(tool.zInput.safeParse(input).data, () => ( input));
+  return function(input) {
+    const toolCallId = `tcall_${_ulid.ulid.call(void 0, )}`;
+    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 _chunkJDABP4SDcjs.SnapshotSignal) {
+        error2.toolCall = {
+          name: tool.name,
+          inputSchema: tool.input,
+          outputSchema: tool.output,
+          input
+        };
+        error2.message = _chunkJDABP4SDcjs.Signals.serializeError(error2);
+      }
+      if (error2 instanceof _chunkJDABP4SDcjs.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 _chunkJDABP4SDcjs.VMSignal) {
+      throw output;
+    }
+    return output;
+  };
+}
+
+
+
+exports._executeContext = _executeContext; exports.executeContext = executeContext;