llmz 0.0.2

package/dist/chunk-ZSRC3TN4.js

@@ -0,0 +1,284 @@
+import {
+  CodeFormattingError
+} from "./chunk-RJHDQL4C.js";
+import {
+  escapeString,
+  getMultilineComment,
+  toPropertyKey
+} from "./chunk-DFZ6GX5C.js";
+
+// src/typings.ts
+import { z } from "@bpinternal/zui";
+
+// src/formatting.ts
+import { LRUCache } from "lru-cache";
+import babel from "prettier/plugins/babel";
+import estree from "prettier/plugins/estree";
+import typescript from "prettier/plugins/typescript";
+import { format } from "prettier/standalone";
+var cache = new LRUCache({ max: 1e3 });
+async function formatTypings(typings, options) {
+  if (cache.has(typings)) {
+    return cache.get(typings);
+  }
+  try {
+    options ??= {};
+    options.throwOnError ??= true;
+    const result = (await format(typings, {
+      singleAttributePerLine: true,
+      bracketSameLine: true,
+      semi: false,
+      ...options,
+      embeddedLanguageFormatting: "off",
+      plugins: [estree, babel, typescript],
+      parser: "typescript",
+      filepath: "tools.d.ts"
+    })).trim();
+    cache.set(typings, result);
+    return result;
+  } catch (err) {
+    if (options == null ? void 0 : options.throwOnError) {
+      throw new CodeFormattingError(err instanceof Error ? err.message : (err == null ? void 0 : err.toString()) ?? "Unknown Error", typings);
+    }
+    return typings;
+  }
+}
+
+// src/typings.ts
+var Primitives = [
+  "string",
+  "number",
+  "boolean",
+  "unknown",
+  "void",
+  "any",
+  "null",
+  "undefined",
+  "never",
+  "bigint",
+  "symbol",
+  "object"
+];
+var LARGE_DECLARATION_LINES = 5;
+var isPrimitive = (type) => Primitives.includes(type);
+var isArrayOfPrimitives = (type) => Primitives.map((p) => `${p}[]`).includes(type);
+var stripSpaces = (typings) => typings.replace(/ +/g, " ").trim();
+var KeyValue = class {
+  constructor(key, value) {
+    this.key = key;
+    this.value = value;
+  }
+};
+var FnParameters = class {
+  constructor(schema) {
+    this.schema = schema;
+  }
+};
+var FnReturn = class {
+  constructor(schema) {
+    this.schema = schema;
+  }
+};
+var Declaration = class {
+  constructor(schema, identifier) {
+    this.schema = schema;
+    this.identifier = identifier;
+  }
+};
+async function getTypings(schema, options) {
+  options ??= {};
+  options.declaration ??= false;
+  let wrappedSchema = schema;
+  if (options == null ? void 0 : options.declaration) {
+    if (schema instanceof z.Schema) {
+      const title = "title" in schema.ui ? schema.ui.title : null;
+      if (!title) {
+        throw new Error('Only schemas with "title" Zui property can be declared.');
+      }
+      wrappedSchema = new Declaration(schema, title);
+    }
+  }
+  let dts = await sUnwrapZodRecursive(wrappedSchema, { ...options });
+  dts = await formatTypings(dts, { throwOnError: false });
+  return dts;
+}
+async function sUnwrapZodRecursive(schema, options) {
+  return sUnwrapZod(schema, options);
+}
+async function sUnwrapZod(schema, options) {
+  var _a, _b;
+  const newOptions = {
+    ...options,
+    declaration: false,
+    parent: schema
+  };
+  if (schema instanceof Declaration) {
+    const description = getMultilineComment(schema.schema.description);
+    const withoutDesc = schema.schema.describe("");
+    const typings = await sUnwrapZodRecursive(withoutDesc, { ...newOptions, declaration: true });
+    const isLargeDeclaration = typings.split("\n").length >= LARGE_DECLARATION_LINES;
+    const closingTag = isLargeDeclaration ? `// end of ${schema.identifier}` : "";
+    if (schema.schema instanceof z.ZodFunction) {
+      return stripSpaces(`${description}
+declare function ${schema.identifier}${typings};${closingTag}`);
+    }
+    return stripSpaces(`${description}
+declare const ${schema.identifier}: ${typings};${closingTag}`);
+  }
+  if (schema instanceof KeyValue) {
+    if (schema.value instanceof z.ZodOptional) {
+      let innerType = schema.value._def.innerType;
+      if (innerType instanceof z.Schema && !innerType.description && schema.value.description) {
+        innerType = innerType == null ? void 0 : innerType.describe(schema.value.description);
+      }
+      const optionalToken = schema.key.endsWith("?") ? "" : "?";
+      return sUnwrapZodRecursive(new KeyValue(schema.key + optionalToken, innerType), newOptions);
+    }
+    const description = getMultilineComment(schema.value._def.description || schema.value.description);
+    const delimiter = (description == null ? void 0 : description.trim().length) > 0 ? "\n" : "";
+    const withoutDesc = schema.value.describe("");
+    return `${delimiter}${description}${delimiter}${schema.key}: ${await sUnwrapZodRecursive(withoutDesc, newOptions)}${delimiter}`;
+  }
+  if (schema instanceof FnParameters) {
+    if (schema.schema instanceof z.ZodTuple) {
+      let args = "";
+      for (let i = 0; i < schema.schema.items.length; i++) {
+        const argName = ((_b = (_a = schema.schema.items[i]) == null ? void 0 : _a.ui) == null ? void 0 : _b.title) ?? `arg${i}`;
+        const item = schema.schema.items[i];
+        args += `${await sUnwrapZodRecursive(new KeyValue(toPropertyKey(argName), item), newOptions)}, `;
+      }
+      return args;
+    }
+    const typings = (await sUnwrapZodRecursive(schema.schema, newOptions)).trim();
+    const startsWithPairs = typings.startsWith("{") && typings.endsWith("}") || typings.startsWith("[") && typings.endsWith("]") || typings.startsWith("(") && typings.endsWith(")") || typings.startsWith("Array<") && typings.endsWith(">") || typings.startsWith("Record<") && typings.endsWith(">") || isArrayOfPrimitives(typings);
+    if (startsWithPairs) {
+      return `args: ${typings}`;
+    } else {
+      return typings;
+    }
+  }
+  if (schema instanceof FnReturn) {
+    if (schema.schema instanceof z.ZodOptional) {
+      return `${await sUnwrapZodRecursive(schema.schema.unwrap(), newOptions)} | undefined`;
+    }
+    return sUnwrapZodRecursive(schema.schema, newOptions);
+  }
+  if (schema instanceof z.ZodDefault) {
+    return sUnwrapZodRecursive(schema._def.innerType, options);
+  }
+  if (schema instanceof z.ZodVoid) {
+    return "void";
+  }
+  if (schema instanceof z.ZodUnknown) {
+    return "unknown";
+  }
+  if (schema instanceof z.ZodAny) {
+    return "any";
+  }
+  if (schema instanceof z.ZodPromise) {
+    return `Promise<${await sUnwrapZodRecursive(schema.unwrap(), newOptions)}>`;
+  }
+  if (schema instanceof z.ZodFunction) {
+    const description = getMultilineComment(schema._def.description);
+    const input = await sUnwrapZodRecursive(new FnParameters(schema._def.args), newOptions);
+    const output = await sUnwrapZodRecursive(new FnReturn(schema._def.returns), newOptions);
+    if (options == null ? void 0 : options.declaration) {
+      return `${description}
+(${input}): ${output}`;
+    }
+    return `${description}
+(${input}) => ${output}`;
+  }
+  if (schema instanceof z.ZodArray) {
+    const item = await sUnwrapZodRecursive(schema._def.type, newOptions);
+    if (isPrimitive(item)) {
+      return `${item}[]`;
+    }
+    return `Array<${item}>`;
+  }
+  if (schema instanceof z.ZodEnum) {
+    const values = schema._def.values.map(escapeString);
+    return values.join(" | ");
+  }
+  if (schema instanceof z.ZodTuple) {
+    if (schema.items.length === 0) {
+      return "[]";
+    }
+    const items = await Promise.all(schema.items.map((i) => sUnwrapZodRecursive(i, newOptions)));
+    return `[${items.join(", ")}]`;
+  }
+  if (schema instanceof z.ZodNullable) {
+    return `${await sUnwrapZodRecursive(schema.unwrap(), options)} | null`;
+  }
+  if (schema instanceof z.ZodOptional) {
+    if ((options == null ? void 0 : options.declaration) || (options == null ? void 0 : options.parent) instanceof z.ZodRecord) {
+      return `${await sUnwrapZodRecursive(schema._def.innerType, newOptions)} | undefined`;
+    }
+    const optionalToken = options.parent instanceof KeyValue ? "| undefined" : "";
+    const val = `${await sUnwrapZodRecursive(schema._def.innerType, newOptions)}${optionalToken}`;
+    return val;
+  }
+  if (schema instanceof z.ZodObject) {
+    const props = await Promise.all(
+      Object.entries(schema.shape).map(async ([key, value]) => {
+        if (value instanceof z.Schema) {
+          return sUnwrapZodRecursive(new KeyValue(toPropertyKey(key), value), newOptions);
+        }
+        return `${key}: unknown`;
+      })
+    );
+    return `{ ${props.join("; ")} }`;
+  }
+  if (schema instanceof z.ZodString) {
+    const description = getMultilineComment(schema._def.description);
+    return `${description} string`.trim();
+  }
+  if (schema instanceof z.ZodUnion) {
+    const description = getMultilineComment(schema._def.description);
+    const options2 = await Promise.all(
+      schema.options.map(async (option) => {
+        return sUnwrapZodRecursive(option, newOptions);
+      })
+    );
+    return `${description}
+${options2.join(" | ")}`;
+  }
+  if (schema instanceof z.ZodLiteral) {
+    const description = getMultilineComment(schema._def.description);
+    return `${description}
+${typeof schema.value === "string" ? escapeString(schema.value) : schema.value}`.trim();
+  }
+  if (schema instanceof z.ZodNumber) {
+    const description = getMultilineComment(schema._def.description);
+    return `${description} number`.trim();
+  }
+  if (schema instanceof z.ZodBoolean) {
+    const description = getMultilineComment(schema._def.description);
+    return `${description} boolean`.trim();
+  }
+  if (schema instanceof z.ZodCatch) {
+    return sUnwrapZodRecursive(schema.removeCatch(), newOptions);
+  }
+  if (schema instanceof z.ZodLazy) {
+    return sUnwrapZodRecursive(schema._def.getter(), newOptions);
+  }
+  if (schema instanceof z.ZodRecord) {
+    const description = getMultilineComment(schema._def.description);
+    const keyType = await sUnwrapZodRecursive(schema._def.keyType, newOptions);
+    const valueType = await sUnwrapZodRecursive(schema._def.valueType, newOptions);
+    return `${description} { [key: (${keyType})]: (${valueType}) }`;
+  }
+  try {
+    let typings = await (schema == null ? void 0 : schema.toTypescriptAsync());
+    typings ??= "unknown";
+    return stripSpaces(typings);
+  } catch (error) {
+    console.error("Error in sUnwrapZod", { error, schema, parent: options == null ? void 0 : options.parent });
+    return "unknown";
+  }
+}
+
+export {
+  formatTypings,
+  getTypings
+};

package/dist/chunk-ZUAFUOUR.cjs

@@ -0,0 +1,161 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } var _class;
+
+var _chunkPQN6HW7Acjs = require('./chunk-PQN6HW7A.cjs');
+
+// src/errors.ts
+var errorClasses = {};
+function registerErrorClass(name, errorClass) {
+  errorClasses[name] = errorClass;
+}
+var tryParseMessage = (str) => {
+  try {
+    return JSON.parse(str);
+  } catch (e) {
+    return str;
+  }
+};
+var Signals;
+((Signals2) => {
+  function isWrappedError(error) {
+    var _a, _b;
+    const isAlreadyWrapped = error.name === "Error" && ((_a = error == null ? void 0 : error.message) == null ? void 0 : _a.startsWith("{")) && ((_b = error == null ? void 0 : error.message) == null ? void 0 : _b.endsWith("}"));
+    return isAlreadyWrapped;
+  }
+  Signals2.isWrappedError = isWrappedError;
+  function serializeError(error) {
+    if (isWrappedError(error)) {
+      const msg = tryParseMessage(error.message);
+      return JSON.stringify({
+        ...typeof msg === "object" ? msg : { message: msg },
+        properties: { ...error }
+      });
+    }
+    return JSON.stringify({
+      name: error.constructor.name,
+      message: error.message,
+      stack: _chunkPQN6HW7Acjs.cleanStackTrace.call(void 0, _nullishCoalesce(error.stack, () => ( ""))),
+      properties: { ...error }
+    });
+  }
+  Signals2.serializeError = serializeError;
+  function maybeDeserializeError(error) {
+    const errorIsAlreadyDeserialized = error instanceof Error && error.name in errorClasses;
+    if (errorIsAlreadyDeserialized) {
+      return error;
+    }
+    const serializedError = error instanceof Error ? error.message : typeof error === "string" ? error : _nullishCoalesce((error == null ? void 0 : error.toString()), () => ( ""));
+    try {
+      const parsed = JSON.parse(serializedError);
+      if (parsed && parsed.name && parsed.message) {
+        const { name, message, properties = {} } = parsed;
+        const ErrorClass = errorClasses[name] || Error;
+        const errorInstance = new ErrorClass(message);
+        errorInstance.message = message;
+        errorInstance.name = name;
+        errorInstance.stack = _chunkPQN6HW7Acjs.cleanStackTrace.call(void 0, _nullishCoalesce((error == null ? void 0 : error.stack), () => ( "")));
+        Object.assign(errorInstance, properties);
+        if (isWrappedError(errorInstance)) {
+          return maybeDeserializeError(errorInstance);
+        }
+        return errorInstance;
+      }
+    } catch (e2) {
+    }
+    return error;
+  }
+  Signals2.maybeDeserializeError = maybeDeserializeError;
+})(Signals || (Signals = exports.Signals = {}));
+var VMSignal = (_class = class extends Error {
+  constructor(message) {
+    super(message);_class.prototype.__init.call(this);_class.prototype.__init2.call(this);;
+    this.message = message;
+    this.message = Signals.serializeError(this);
+  }
+  /**
+   * The code that was executed by the VM up to the point of the signal
+   */
+  __init() {this.truncatedCode = ""}
+  /** The current tool call, if any */
+  
+  /**
+   * Contains all the declared and executed variables during the VM execution
+   * See file plugins/variable-extraction.ts for more details
+   */
+  __init2() {this.variables = {}}
+}, _class);
+var SnapshotSignal = class extends VMSignal {
+  constructor(message) {
+    super(message);
+    this.message = Signals.serializeError(this);
+  }
+};
+var VMLoopSignal = class extends VMSignal {
+  constructor(message) {
+    super(message);
+    this.message = Signals.serializeError(this);
+  }
+};
+var ThinkSignal = class extends VMLoopSignal {
+  constructor(reason, context) {
+    super("Think signal received: " + reason);
+    this.reason = reason;
+    this.context = context;
+    this.message = Signals.serializeError(this);
+  }
+  toString() {
+    return Signals.serializeError(this);
+  }
+};
+var CodeExecutionError = class extends Error {
+  constructor(message, code, stacktrace) {
+    super(message);
+    this.code = code;
+    this.stacktrace = stacktrace;
+    this.message = Signals.serializeError(this);
+  }
+};
+var InvalidCodeError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.message = Signals.serializeError(this);
+  }
+};
+var LoopExceededError = class extends Error {
+  constructor() {
+    super("Loop exceeded error");
+    this.message = Signals.serializeError(this);
+  }
+};
+var CodeFormattingError = class extends Error {
+  constructor(message, code) {
+    super(message, {
+      cause: "Code formatting error"
+    });
+    this.code = code;
+  }
+};
+var AssignmentError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.message = Signals.serializeError(this);
+  }
+};
+registerErrorClass("VMSignal", VMSignal);
+registerErrorClass("SnapshotSignal", SnapshotSignal);
+registerErrorClass("VMLoopSignal", VMLoopSignal);
+registerErrorClass("ThinkSignal", ThinkSignal);
+registerErrorClass("CodeExecutionError", CodeExecutionError);
+registerErrorClass("AssignmentError", AssignmentError);
+
+
+
+
+
+
+
+
+
+
+
+exports.Signals = Signals; exports.VMSignal = VMSignal; exports.SnapshotSignal = SnapshotSignal; exports.ThinkSignal = ThinkSignal; exports.CodeExecutionError = CodeExecutionError; exports.InvalidCodeError = InvalidCodeError; exports.LoopExceededError = LoopExceededError; exports.CodeFormattingError = CodeFormattingError; exports.AssignmentError = AssignmentError;

package/dist/compiler/compiler.d.ts

@@ -0,0 +1,28 @@
+import { type TransformOptions } from '@babel/core';
+import { ToolCallEntry } from './plugins/track-tool-calls.js';
+export declare const DEFAULT_TRANSFORM_OPTIONS: TransformOptions;
+export declare const Identifiers: {
+    JSXFnIdentifier: string;
+    AsyncIterYieldFnIdentifier: string;
+    ConsoleObjIdentifier: string;
+    LineTrackingFnIdentifier: string;
+    VariableTrackingFnIdentifier: string;
+    ToolCallTrackerFnIdentifier: string;
+    ToolTrackerRetIdentifier: string;
+    CommentFnIdentifier: string;
+};
+export type CompiledCode = ReturnType<typeof compile>;
+export declare function compile(code: string): {
+    code: string;
+    map: {
+        version: number;
+        sources: string[];
+        names: string[];
+        sourceRoot?: string | undefined;
+        sourcesContent?: string[] | undefined;
+        mappings: string;
+        file: string;
+    } | null | undefined;
+    variables: Set<string>;
+    toolCalls: Map<number, ToolCallEntry>;
+};

package/dist/compiler/index.d.ts

@@ -0,0 +1,2 @@
+export { Identifiers, compile } from './compiler.js';
+export type { CompiledCode } from './compiler.js';

package/dist/compiler/plugins/async-iterator.d.ts

@@ -0,0 +1,4 @@
+export declare const AsyncIterator: {
+    preProcessing: (code: string) => string;
+    postProcessing: (code: string) => string;
+};

package/dist/compiler/plugins/braces-tsx.d.ts

@@ -0,0 +1,3 @@
+export declare const JSXMarkdown: {
+    preProcessing: (code: string) => string;
+};

package/dist/compiler/plugins/jsx-preserve-newlines.d.ts

@@ -0,0 +1,5 @@
+import type { PluginObj } from '@babel/core';
+export declare const JSXNewLines: {
+    babelPlugin: PluginObj<import("@babel/core").PluginPass>;
+    postProcessing: (code: string) => string;
+};

package/dist/compiler/plugins/line-tracking.d.ts

@@ -0,0 +1,5 @@
+import type * as BabelCore from '@babel/core';
+export declare const LineTrackingFnIdentifier = "__track__";
+export declare const lineTrackingBabelPlugin: ({ types: t }: {
+    types: typeof BabelCore.types;
+}) => BabelCore.PluginObj;

package/dist/compiler/plugins/replace-comment.d.ts

@@ -0,0 +1,5 @@
+import type * as BabelCore from '@babel/core';
+export declare const CommentFnIdentifier = "__comment__";
+export declare const replaceCommentBabelPlugin: ({ types: t, }: {
+    types: typeof BabelCore.types;
+}) => BabelCore.PluginObj;

package/dist/compiler/plugins/return-async.d.ts

@@ -0,0 +1,4 @@
+import type * as BabelCore from '@babel/core';
+export declare const instrumentLastLinePlugin: ({ types: t, }: {
+    types: typeof BabelCore.types;
+}) => BabelCore.PluginObj;

package/dist/compiler/plugins/track-tool-calls.d.ts

@@ -0,0 +1,16 @@
+import type * as BabelCore from '@babel/core';
+export declare const ToolCallTrackerFnIdentifier = "__toolc__";
+export declare const ToolTrackerRetIdentifier = "__ret__";
+export type Assignment = {
+    type: 'single' | 'object' | 'array' | 'unsupported';
+    left: string;
+    evalFn: string;
+};
+export type ToolCallEntry = {
+    object: string;
+    tool: string;
+    assignment: Assignment;
+};
+export declare const toolCallTrackingPlugin: (calls?: Map<number, ToolCallEntry>) => ({}: {
+    types: typeof BabelCore.types;
+}) => BabelCore.PluginObj;

package/dist/compiler/plugins/variable-extraction.d.ts

@@ -0,0 +1,5 @@
+import type * as BabelCore from '@babel/core';
+export declare const VariableTrackingFnIdentifier = "__var__";
+export declare const variableTrackingPlugin: (variables?: Set<string>) => ({ types: t }: {
+    types: typeof BabelCore.types;
+}) => BabelCore.PluginObj;

package/dist/component-DWBRHLEN.cjs

@@ -0,0 +1,9 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkE5W3P7EOcjs = require('./chunk-E5W3P7EO.cjs');
+require('./chunk-A7BDFLAE.cjs');
+
+
+
+exports.assertValidComponent = _chunkE5W3P7EOcjs.assertValidComponent; exports.getComponentReference = _chunkE5W3P7EOcjs.getComponentReference;

package/dist/component-R3ZAVXUC.js

@@ -0,0 +1,9 @@
+import {
+  assertValidComponent,
+  getComponentReference
+} from "./chunk-3T465BEW.js";
+import "./chunk-YSQDPG26.js";
+export {
+  assertValidComponent,
+  getComponentReference
+};

package/dist/component.d.ts

@@ -0,0 +1,51 @@
+export type ComponentProperty = {
+    name: string;
+    type: 'string' | 'boolean' | 'number';
+    default?: string | boolean | number;
+    description?: string;
+    required: boolean;
+};
+export type Component = DefaultComponent | LeafComponent | ContainerComponent;
+export type ExampleUsage = {
+    name: string;
+    description: string;
+    code: string;
+};
+export type ComponentChild = {
+    description: string;
+    component: Component;
+};
+export type DefaultComponent = {
+    type: 'default';
+    name: string;
+    aliases: string[];
+    description: string;
+    examples: ExampleUsage[];
+    default: {
+        props: ComponentProperty[];
+        children: Array<ComponentChild>;
+    };
+};
+export type LeafComponent = {
+    type: 'leaf';
+    name: string;
+    description: string;
+    aliases?: string[];
+    examples: ExampleUsage[];
+    leaf: {
+        props: ComponentProperty[];
+    };
+};
+export type ContainerComponent = {
+    type: 'container';
+    name: string;
+    description: string;
+    aliases?: string[];
+    examples: ExampleUsage[];
+    container: {
+        props: ComponentProperty[];
+        children: Array<ComponentChild>;
+    };
+};
+export declare function assertValidComponent(component: Component): asserts component is Component;
+export declare function getComponentReference(component: Component): string;

package/dist/component.default.d.ts

@@ -0,0 +1,10 @@
+export declare const DefaultComponents: {
+    Button: import("./component.js").LeafComponent;
+    Image: import("./component.js").LeafComponent;
+    File: import("./component.js").LeafComponent;
+    Video: import("./component.js").LeafComponent;
+    Audio: import("./component.js").LeafComponent;
+    Card: import("./component.js").ContainerComponent;
+    Carousel: import("./component.js").ContainerComponent;
+    Text: import("./component.js").DefaultComponent;
+};