llmz 0.0.2

package/dist/chunk-BOLDQGES.cjs

@@ -0,0 +1,33 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunk3CGLDS5Tcjs = require('./chunk-3CGLDS5T.cjs');
+
+// src/jsx.ts
+var _zui = require('@bpinternal/zui');
+function isAnyJsxComponent(component) {
+  return typeof component === "object" && component !== null && "__jsx" in component && component.__jsx === true && typeof component.type === "string";
+}
+function isJsxComponent(type, component) {
+  return typeof component === "object" && component !== null && "__jsx" in component && component.__jsx === true && typeof component.type === "string" && typeof type === "string" && component.type.toUpperCase().trim() === type.toUpperCase().trim();
+}
+var createJsxComponent = (props) => ({
+  __jsx: true,
+  type: _chunk3CGLDS5Tcjs.isString_default.call(void 0, props.type) ? props.type.toUpperCase() : "__unknown__",
+  children: Array.isArray(props.children) ? props.children : props.children ? [props.children] : [],
+  props: _chunk3CGLDS5Tcjs.isPlainObject_default.call(void 0, props.props) ? props.props : {}
+});
+var Jsx = _zui.z.custom(
+  (value) => isAnyJsxComponent(value),
+  (value) => ({
+    params: { value },
+    message: `Invalid JSX component: ${value}`
+  })
+);
+
+
+
+
+
+
+exports.isAnyJsxComponent = isAnyJsxComponent; exports.isJsxComponent = isJsxComponent; exports.createJsxComponent = createJsxComponent; exports.Jsx = Jsx;

package/dist/chunk-C2TSWGYC.cjs

@@ -0,0 +1,91 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunkQZGFCB4Tcjs = require('./chunk-QZGFCB4T.cjs');
+
+// src/snapshots.ts
+var _ulid = require('ulid');
+var MAX_SNAPSHOT_SIZE_BYTES = 4e3;
+var Snapshot = class _Snapshot {
+  
+  
+  
+  
+  
+  #status;
+  get status() {
+    return Object.freeze({ ...this.#status });
+  }
+  constructor(props) {
+    this.id = props.id;
+    this.stack = props.stack;
+    this.reason = props.reason;
+    this.variables = props.variables;
+    this.toolCall = props.toolCall;
+    this.#status = props.status;
+  }
+  static fromSignal(signal) {
+    const variables = Object.entries(signal.variables).map(([name, value]) => {
+      const type = _chunkQZGFCB4Tcjs.extractType.call(void 0, value);
+      const bytes = JSON.stringify(value || "").length;
+      const truncated = bytes > MAX_SNAPSHOT_SIZE_BYTES;
+      return truncated ? { name, type, bytes, truncated: true, preview: _nullishCoalesce(_chunkQZGFCB4Tcjs.inspect.call(void 0, value, name), () => ( "N/A")) } : { name, type, bytes, truncated: false, value };
+    });
+    return new _Snapshot({
+      id: "snapshot_" + _ulid.ulid.call(void 0, ),
+      reason: signal.message,
+      stack: signal.truncatedCode,
+      variables,
+      toolCall: signal.toolCall,
+      status: { type: "pending" }
+    });
+  }
+  toJSON() {
+    return {
+      id: this.id,
+      reason: this.reason,
+      stack: this.stack,
+      variables: this.variables,
+      toolCall: this.toolCall
+    };
+  }
+  static fromJSON(json) {
+    return new _Snapshot({
+      id: json.id,
+      reason: json.reason,
+      stack: json.stack,
+      variables: json.variables,
+      toolCall: json.toolCall,
+      status: json.status
+    });
+  }
+  clone() {
+    return new _Snapshot({
+      id: this.id,
+      reason: this.reason,
+      stack: this.stack,
+      variables: this.variables,
+      toolCall: this.toolCall,
+      status: this.#status
+    });
+  }
+  reset() {
+    this.#status = { type: "pending" };
+  }
+  resolve(value) {
+    if (this.#status.type !== "pending") {
+      throw new Error(`Cannot resolve snapshot because it is already settled: ${this.#status.type}`);
+    }
+    this.#status = { type: "resolved", value };
+  }
+  reject(error) {
+    if (this.#status.type !== "pending") {
+      throw new Error(`Cannot reject snapshot because it is already settled: ${this.#status.type}`);
+    }
+    this.#status = { type: "rejected", error };
+  }
+};
+
+
+
+exports.Snapshot = Snapshot;

package/dist/chunk-DFZ6GX5C.js

@@ -0,0 +1,220 @@
+import {
+  camelCase_default,
+  deburr_default,
+  isPlainObject_default,
+  pickBy_default,
+  startCase_default
+} from "./chunk-7S3UY52U.js";
+
+// src/utils.ts
+import { getWasmTokenizer } from "@bpinternal/thicktoken";
+import { z } from "@bpinternal/zui";
+var tokenizer = null;
+var init = async () => {
+  if (tokenizer) {
+    return;
+  }
+  while (typeof getWasmTokenizer !== "function") {
+    await new Promise((resolve) => setTimeout(resolve, 50));
+  }
+  tokenizer = await getWasmTokenizer();
+};
+var getTokenizer = () => {
+  if (!tokenizer) {
+    throw new Error("Tokenizer not initialized, make sure to call init() first and await it");
+  }
+  return tokenizer;
+};
+var Tokens = (min, max) => {
+  return z.string().superRefine((value, ctx) => {
+    const tokens = tokenizer.count(value);
+    if (value.length < min) {
+      ctx.addIssue({
+        code: "too_small",
+        minimum: min,
+        type: "string",
+        message: `Text is ${tokens} but expected at least ${min} tokens`,
+        inclusive: true
+      });
+    }
+    if (value.length > max) {
+      ctx.addIssue({
+        code: "too_big",
+        maximum: max,
+        type: "string",
+        message: `Text is ${tokens} tokens but expected at most ${max} tokens`,
+        inclusive: true
+      });
+    }
+    return value;
+  });
+};
+var Identifier = z.string().min(1).max(100).regex(
+  /^([a-zA-Z_][a-zA-Z0-9_]*)$/,
+  "Identifiers must start with a letter and can only contain letters, numbers and underscores"
+);
+function escapeString(str) {
+  if (typeof str !== "string") {
+    return "";
+  }
+  const rawStr = String.raw`${str}`;
+  const escapedStr = rawStr.replace(/\\/g, "\\\\").replace(/\n/g, "\\n").replace(/"/g, '\\"').replace(/'/g, "\\'");
+  if (escapedStr.includes("`")) {
+    return `"${escapedStr}"`;
+  } else if (escapedStr.includes("'")) {
+    return `"${escapedStr}"`;
+  } else {
+    return `'${escapedStr}'`;
+  }
+}
+var toPropertyKey = (key) => {
+  if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)) {
+    return key;
+  }
+  return escapeString(key);
+};
+var trimEmptyLines = (lines) => {
+  var _a;
+  while (lines.length && !((_a = lines[0]) == null ? void 0 : _a.trim())) {
+    lines.shift();
+  }
+  while (lines.length && !lines[lines.length - 1].trim()) {
+    lines.pop();
+  }
+};
+var getMultilineComment = (description) => {
+  description = description == null ? void 0 : description.replace(/(\n(\s*)?){3,}/g, "\n\n");
+  const ensureLineStartsWithAsterisk = (line) => line.startsWith("* ") ? ` ${line}` : ` * ${line}`;
+  const escapeCommentEnd = (line) => line.replace(/\*\//g, "*\\/");
+  const descLines = (description ?? "").split("\n").map((line) => line.trim());
+  trimEmptyLines(descLines);
+  if (descLines.length) {
+    descLines[0] = descLines[0].replace(/^\/\*\*?/, "");
+    descLines[descLines.length - 1] = descLines[descLines.length - 1].replace(/\*\/$/, "");
+  }
+  trimEmptyLines(descLines);
+  return descLines.length === 0 ? "" : descLines.length === 1 ? `/** ${escapeCommentEnd(descLines[0])} */` : `/**
+${descLines.map(ensureLineStartsWithAsterisk).map(escapeCommentEnd).join("\n")}
+ */`;
+};
+var toValidFunctionName = (str) => {
+  let name = deburr_default(str);
+  name = name.replace(/[^a-zA-Z0-9_$]/g, "");
+  if (!/^[a-zA-Z_$]/.test(name)) {
+    name = `_${name}`;
+  }
+  return camelCase_default(name);
+};
+var awaitObject = async (obj) => {
+  const newObj = { ...obj };
+  const promises = [];
+  const setProp = async (key, value) => {
+    newObj[key] = await value;
+  };
+  for (const [key, value] of Object.entries(obj)) {
+    if (value instanceof Promise) {
+      promises.push(setProp(key, value));
+    } else if (isPlainObject_default(value)) {
+      promises.push(setProp(key, await awaitObject(value)));
+    }
+  }
+  await Promise.all(promises);
+  return newObj;
+};
+var toValidObjectName = (str) => {
+  let name = deburr_default(str);
+  name = name.split(/[^a-zA-Z0-9_$]/g).map(startCase_default).join("");
+  if (!/^[a-zA-Z_$]/.test(name)) {
+    name = `_${name}`;
+  }
+  return name.replaceAll(" ", "");
+};
+var stripInvalidIdentifiers = (object) => {
+  if (typeof object !== "object") {
+    return object;
+  }
+  if (Array.isArray(object)) {
+    return object.map(stripInvalidIdentifiers);
+  }
+  return pickBy_default(object, (__, key) => Identifier.safeParse(key).success);
+};
+var convertObjectToZuiLiterals = (obj, nested = false) => {
+  if (typeof obj === "string") {
+    return z.literal(obj).catch(() => obj);
+  }
+  if (typeof obj === "number") {
+    return z.literal(obj).catch(() => obj);
+  }
+  if (typeof obj === "boolean") {
+    return z.literal(obj).catch(() => obj);
+  }
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) {
+      return z.tuple([]).catch(() => obj);
+    }
+    return z.tuple([
+      // the tuple needs to have at least one element
+      convertObjectToZuiLiterals(obj[0]),
+      ...obj.slice(1).map((child) => convertObjectToZuiLiterals(child))
+    ]).catch(() => obj);
+  }
+  if (obj !== null && typeof obj === "object") {
+    const shape = {};
+    for (const key in obj) {
+      shape[key] = convertObjectToZuiLiterals(obj[key], true);
+    }
+    if (nested) {
+      return z.object(shape).catch(() => shape);
+    }
+    return shape;
+  }
+  if (obj === void 0) {
+    return z.undefined().catch(() => void 0);
+  }
+  if (obj === null) {
+    return z.null().catch(() => null);
+  }
+  throw new Error(`Unsupported object type ${typeof obj}, ${obj})`);
+};
+var isValidSchema = (schema) => {
+  try {
+    z.fromJsonSchema(schema);
+    return typeof schema.type === "string";
+  } catch {
+    return false;
+  }
+};
+function isJsonSchema(schema) {
+  return !!schema && typeof schema === "object" && ("$schema" in schema || "type" in schema || "properties" in schema);
+}
+function isValidIdentifier(name) {
+  if (typeof name !== "string") {
+    return false;
+  }
+  return /^[A-Z]{1,}[A-Z0-9_]{0,50}$/i.test(name);
+}
+function isValidMessageName(name) {
+  if (typeof name !== "string") {
+    return false;
+  }
+  return /^[A-Z]{1,50}$/i.test(name);
+}
+
+export {
+  init,
+  getTokenizer,
+  Tokens,
+  Identifier,
+  escapeString,
+  toPropertyKey,
+  getMultilineComment,
+  toValidFunctionName,
+  awaitObject,
+  toValidObjectName,
+  stripInvalidIdentifiers,
+  convertObjectToZuiLiterals,
+  isValidSchema,
+  isJsonSchema,
+  isValidIdentifier,
+  isValidMessageName
+};

package/dist/chunk-DILHJIMP.js

@@ -0,0 +1,180 @@
+import {
+  getTypings
+} from "./chunk-ZSRC3TN4.js";
+import {
+  convertObjectToZuiLiterals,
+  isJsonSchema,
+  isValidIdentifier
+} from "./chunk-DFZ6GX5C.js";
+import {
+  isEmpty_default,
+  uniq_default
+} from "./chunk-7S3UY52U.js";
+
+// src/tool.ts
+import { z } from "@bpinternal/zui";
+var Tool = class _Tool {
+  _staticInputValues;
+  name;
+  aliases = [];
+  description;
+  metadata;
+  input;
+  output;
+  setStaticInputValues(values) {
+    if (values === null || values === void 0) {
+      this._staticInputValues = void 0;
+      return this;
+    }
+    const input = this.input ? z.fromJsonSchema(this.input) : z.any();
+    if (input instanceof z.ZodObject && typeof values !== "object") {
+      throw new Error(
+        `Invalid static input values for tool ${this.name}. Expected an object, but got type "${typeof values}"`
+      );
+    }
+    if (input instanceof z.ZodArray && !Array.isArray(values)) {
+      throw new Error(
+        `Invalid static input values for tool ${this.name}. Expected an array, but got type "${typeof values}"`
+      );
+    }
+    this._staticInputValues = values;
+    return this;
+  }
+  get zInput() {
+    let input = this.input ? z.fromJsonSchema(this.input) : z.any();
+    if (!isEmpty_default(this._staticInputValues)) {
+      const inputExtensions = convertObjectToZuiLiterals(this._staticInputValues);
+      if (input instanceof z.ZodObject) {
+        input = input.extend(inputExtensions);
+      } else if (input instanceof z.ZodArray) {
+        input = z.array(input.element.extend(inputExtensions));
+      } else {
+        input = inputExtensions;
+      }
+    }
+    return input;
+  }
+  get zOutput() {
+    return this.output ? z.fromJsonSchema(this.output) : z.void();
+  }
+  rename(name) {
+    const before = this.name;
+    if (!isValidIdentifier(name)) {
+      throw new Error(
+        `Invalid name for tool ${name}. A tool name must start with a letter and contain only letters, numbers, and underscores. It must be 1-50 characters long.`
+      );
+    }
+    this.name = name;
+    this.aliases = uniq_default([name, ...this.aliases.map((alias) => alias === before ? name : alias)]);
+    return this;
+  }
+  clone() {
+    try {
+      return new _Tool({
+        name: this.name,
+        aliases: [...this.aliases],
+        description: this.description,
+        metadata: JSON.parse(JSON.stringify(this.metadata)),
+        input: this.input ? z.fromJsonSchema(this.input) : void 0,
+        output: this.output ? z.fromJsonSchema(this.output) : void 0,
+        handler: this._handler
+      }).setStaticInputValues(this._staticInputValues);
+    } catch (e) {
+      throw new Error(`Failed to clone tool "${this.name}": ${e}`);
+    }
+  }
+  _handler;
+  constructor(props) {
+    if (!isValidIdentifier(props.name)) {
+      throw new Error(
+        `Invalid name for tool ${props.name}. A tool name must start with a letter and contain only letters, numbers, and underscores. It must be 1-50 characters long.`
+      );
+    }
+    if (props.description !== void 0 && typeof props.description !== "string") {
+      throw new Error(
+        `Invalid description for tool ${props.name}. Expected a string, but got type "${typeof props.description}"`
+      );
+    }
+    if (props.metadata !== void 0 && typeof props.metadata !== "object") {
+      throw new Error(
+        `Invalid metadata for tool ${props.name}. Expected an object, but got type "${typeof props.metadata}"`
+      );
+    }
+    if (typeof props.handler !== "function") {
+      throw new Error(
+        `Invalid handler for tool ${props.name}. Expected a function, but got type "${typeof props.handler}"`
+      );
+    }
+    if (props.aliases !== void 0 && !Array.isArray(props.aliases)) {
+      throw new Error(
+        `Invalid aliases for tool ${props.name}. Expected an array, but got type "${typeof props.aliases}"`
+      );
+    }
+    if (props.aliases && props.aliases.some((alias) => !isValidIdentifier(alias))) {
+      throw new Error(`Invalid aliases for tool ${props.name}. Expected an array of valid identifiers.`);
+    }
+    if (typeof props.input !== "undefined") {
+      if (props.input && "toJsonSchema" in props.input && typeof props.input.toJsonSchema === "function") {
+        this.input = props.input.toJsonSchema();
+      } else if (isJsonSchema(props.input)) {
+        this.input = props.input;
+      } else {
+        throw new Error(
+          `Invalid input schema for tool ${props.name}. Expected a ZodType or JSONSchema, but got type "${typeof props.input}"`
+        );
+      }
+    }
+    if (typeof props.output !== "undefined") {
+      if (props.output && "toJsonSchema" in props.output && typeof props.output.toJsonSchema === "function") {
+        this.output = props.output.toJsonSchema();
+      } else if (isJsonSchema(props.output)) {
+        this.output = props.output;
+      } else {
+        throw new Error(
+          `Invalid output schema for tool ${props.name}. Expected a ZodType or JSONSchema, but got type "${typeof props.output}"`
+        );
+      }
+    }
+    this.name = props.name;
+    this.aliases = uniq_default([props.name, ...props.aliases ?? []]);
+    this.description = props.description;
+    this.metadata = props.metadata ?? {};
+    this._handler = props.handler;
+    this.setStaticInputValues(props.staticInputValues);
+  }
+  async execute(input) {
+    const pInput = this.zInput.safeParse(input);
+    if (!pInput.success) {
+      throw new Error(`Tool "${this.name}" received invalid input: ${pInput.error.message}`);
+    }
+    const result = await this._handler(pInput.data);
+    const pOutput = this.zOutput.safeParse(result);
+    return pOutput.success ? pOutput.data : result;
+  }
+  async getTypings() {
+    const input = this.input ? z.fromJsonSchema(this.input) : void 0;
+    const output = this.output ? z.fromJsonSchema(this.output) : z.void();
+    const fnType = z.function(input, z.promise(output)).title(this.name).describe(this.description ?? "");
+    return getTypings(fnType, {
+      declaration: true
+    });
+  }
+  static withUniqueNames = (tools) => {
+    const names = /* @__PURE__ */ new Set();
+    return tools.map((tool) => {
+      if (tools.filter((t) => t.name === tool.name).length === 1) {
+        return tool;
+      }
+      let counter = 1;
+      let toolName = tool.name + counter;
+      while (names.has(toolName)) {
+        toolName = `${tool.name}${++counter}`;
+      }
+      return tool.rename(toolName);
+    });
+  };
+};
+
+export {
+  Tool
+};