llmz 0.0.2

package/dist/chunk-YPOOKE3A.cjs

@@ -0,0 +1,180 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } var _class;
+
+var _chunkYUDUY7XWcjs = require('./chunk-YUDUY7XW.cjs');
+
+
+
+
+var _chunkENFB45AIcjs = require('./chunk-ENFB45AI.cjs');
+
+
+
+var _chunk3CGLDS5Tcjs = require('./chunk-3CGLDS5T.cjs');
+
+// src/tool.ts
+var _zui = require('@bpinternal/zui');
+var Tool = (_class = class _Tool {
+  
+  
+  __init() {this.aliases = []}
+  
+  
+  
+  
+  setStaticInputValues(values) {
+    if (values === null || values === void 0) {
+      this._staticInputValues = void 0;
+      return this;
+    }
+    const input = this.input ? _zui.z.fromJsonSchema(this.input) : _zui.z.any();
+    if (input instanceof _zui.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 _zui.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 ? _zui.z.fromJsonSchema(this.input) : _zui.z.any();
+    if (!_chunk3CGLDS5Tcjs.isEmpty_default.call(void 0, this._staticInputValues)) {
+      const inputExtensions = _chunkENFB45AIcjs.convertObjectToZuiLiterals.call(void 0, this._staticInputValues);
+      if (input instanceof _zui.z.ZodObject) {
+        input = input.extend(inputExtensions);
+      } else if (input instanceof _zui.z.ZodArray) {
+        input = _zui.z.array(input.element.extend(inputExtensions));
+      } else {
+        input = inputExtensions;
+      }
+    }
+    return input;
+  }
+  get zOutput() {
+    return this.output ? _zui.z.fromJsonSchema(this.output) : _zui.z.void();
+  }
+  rename(name) {
+    const before = this.name;
+    if (!_chunkENFB45AIcjs.isValidIdentifier.call(void 0, 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 = _chunk3CGLDS5Tcjs.uniq_default.call(void 0, [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 ? _zui.z.fromJsonSchema(this.input) : void 0,
+        output: this.output ? _zui.z.fromJsonSchema(this.output) : void 0,
+        handler: this._handler
+      }).setStaticInputValues(this._staticInputValues);
+    } catch (e) {
+      throw new Error(`Failed to clone tool "${this.name}": ${e}`);
+    }
+  }
+  
+  constructor(props) {;_class.prototype.__init.call(this);
+    if (!_chunkENFB45AIcjs.isValidIdentifier.call(void 0, 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) => !_chunkENFB45AIcjs.isValidIdentifier.call(void 0, 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 (_chunkENFB45AIcjs.isJsonSchema.call(void 0, 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 (_chunkENFB45AIcjs.isJsonSchema.call(void 0, 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 = _chunk3CGLDS5Tcjs.uniq_default.call(void 0, [props.name, ..._nullishCoalesce(props.aliases, () => ( []))]);
+    this.description = props.description;
+    this.metadata = _nullishCoalesce(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 ? _zui.z.fromJsonSchema(this.input) : void 0;
+    const output = this.output ? _zui.z.fromJsonSchema(this.output) : _zui.z.void();
+    const fnType = _zui.z.function(input, _zui.z.promise(output)).title(this.name).describe(_nullishCoalesce(this.description, () => ( "")));
+    return _chunkYUDUY7XWcjs.getTypings.call(void 0, fnType, {
+      declaration: true
+    });
+  }
+  static __initStatic() {this.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);
+    });
+  }}
+}, _class.__initStatic(), _class);
+
+
+
+exports.Tool = Tool;

package/dist/chunk-YSQDPG26.js

@@ -0,0 +1,30 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __toESM
+};

package/dist/chunk-YUDUY7XW.cjs

@@ -0,0 +1,284 @@
+"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 _chunkZUAFUOURcjs = require('./chunk-ZUAFUOUR.cjs');
+
+
+
+
+var _chunkENFB45AIcjs = require('./chunk-ENFB45AI.cjs');
+
+// src/typings.ts
+var _zui = require('@bpinternal/zui');
+
+// src/formatting.ts
+var _lrucache = require('lru-cache');
+var _babel = require('prettier/plugins/babel'); var _babel2 = _interopRequireDefault(_babel);
+var _estree = require('prettier/plugins/estree'); var _estree2 = _interopRequireDefault(_estree);
+var _typescript = require('prettier/plugins/typescript'); var _typescript2 = _interopRequireDefault(_typescript);
+var _standalone = require('prettier/standalone');
+var cache = new (0, _lrucache.LRUCache)({ max: 1e3 });
+async function formatTypings(typings, options) {
+  if (cache.has(typings)) {
+    return cache.get(typings);
+  }
+  try {
+    options ??= {};
+    options.throwOnError ??= true;
+    const result = (await _standalone.format.call(void 0, typings, {
+      singleAttributePerLine: true,
+      bracketSameLine: true,
+      semi: false,
+      ...options,
+      embeddedLanguageFormatting: "off",
+      plugins: [_estree2.default, _babel2.default, _typescript2.default],
+      parser: "typescript",
+      filepath: "tools.d.ts"
+    })).trim();
+    cache.set(typings, result);
+    return result;
+  } catch (err) {
+    if (options == null ? void 0 : options.throwOnError) {
+      throw new (0, _chunkZUAFUOURcjs.CodeFormattingError)(err instanceof Error ? err.message : _nullishCoalesce((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 _zui.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 = _chunkENFB45AIcjs.getMultilineComment.call(void 0, 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 _zui.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 _zui.z.ZodOptional) {
+      let innerType = schema.value._def.innerType;
+      if (innerType instanceof _zui.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 = _chunkENFB45AIcjs.getMultilineComment.call(void 0, 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 _zui.z.ZodTuple) {
+      let args = "";
+      for (let i = 0; i < schema.schema.items.length; i++) {
+        const argName = _nullishCoalesce(((_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(_chunkENFB45AIcjs.toPropertyKey.call(void 0, 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 _zui.z.ZodOptional) {
+      return `${await sUnwrapZodRecursive(schema.schema.unwrap(), newOptions)} | undefined`;
+    }
+    return sUnwrapZodRecursive(schema.schema, newOptions);
+  }
+  if (schema instanceof _zui.z.ZodDefault) {
+    return sUnwrapZodRecursive(schema._def.innerType, options);
+  }
+  if (schema instanceof _zui.z.ZodVoid) {
+    return "void";
+  }
+  if (schema instanceof _zui.z.ZodUnknown) {
+    return "unknown";
+  }
+  if (schema instanceof _zui.z.ZodAny) {
+    return "any";
+  }
+  if (schema instanceof _zui.z.ZodPromise) {
+    return `Promise<${await sUnwrapZodRecursive(schema.unwrap(), newOptions)}>`;
+  }
+  if (schema instanceof _zui.z.ZodFunction) {
+    const description = _chunkENFB45AIcjs.getMultilineComment.call(void 0, 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 _zui.z.ZodArray) {
+    const item = await sUnwrapZodRecursive(schema._def.type, newOptions);
+    if (isPrimitive(item)) {
+      return `${item}[]`;
+    }
+    return `Array<${item}>`;
+  }
+  if (schema instanceof _zui.z.ZodEnum) {
+    const values = schema._def.values.map(_chunkENFB45AIcjs.escapeString);
+    return values.join(" | ");
+  }
+  if (schema instanceof _zui.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 _zui.z.ZodNullable) {
+    return `${await sUnwrapZodRecursive(schema.unwrap(), options)} | null`;
+  }
+  if (schema instanceof _zui.z.ZodOptional) {
+    if ((options == null ? void 0 : options.declaration) || (options == null ? void 0 : options.parent) instanceof _zui.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 _zui.z.ZodObject) {
+    const props = await Promise.all(
+      Object.entries(schema.shape).map(async ([key, value]) => {
+        if (value instanceof _zui.z.Schema) {
+          return sUnwrapZodRecursive(new KeyValue(_chunkENFB45AIcjs.toPropertyKey.call(void 0, key), value), newOptions);
+        }
+        return `${key}: unknown`;
+      })
+    );
+    return `{ ${props.join("; ")} }`;
+  }
+  if (schema instanceof _zui.z.ZodString) {
+    const description = _chunkENFB45AIcjs.getMultilineComment.call(void 0, schema._def.description);
+    return `${description} string`.trim();
+  }
+  if (schema instanceof _zui.z.ZodUnion) {
+    const description = _chunkENFB45AIcjs.getMultilineComment.call(void 0, schema._def.description);
+    const options2 = await Promise.all(
+      schema.options.map(async (option) => {
+        return sUnwrapZodRecursive(option, newOptions);
+      })
+    );
+    return `${description}
+${options2.join(" | ")}`;
+  }
+  if (schema instanceof _zui.z.ZodLiteral) {
+    const description = _chunkENFB45AIcjs.getMultilineComment.call(void 0, schema._def.description);
+    return `${description}
+${typeof schema.value === "string" ? _chunkENFB45AIcjs.escapeString.call(void 0, schema.value) : schema.value}`.trim();
+  }
+  if (schema instanceof _zui.z.ZodNumber) {
+    const description = _chunkENFB45AIcjs.getMultilineComment.call(void 0, schema._def.description);
+    return `${description} number`.trim();
+  }
+  if (schema instanceof _zui.z.ZodBoolean) {
+    const description = _chunkENFB45AIcjs.getMultilineComment.call(void 0, schema._def.description);
+    return `${description} boolean`.trim();
+  }
+  if (schema instanceof _zui.z.ZodCatch) {
+    return sUnwrapZodRecursive(schema.removeCatch(), newOptions);
+  }
+  if (schema instanceof _zui.z.ZodLazy) {
+    return sUnwrapZodRecursive(schema._def.getter(), newOptions);
+  }
+  if (schema instanceof _zui.z.ZodRecord) {
+    const description = _chunkENFB45AIcjs.getMultilineComment.call(void 0, 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";
+  }
+}
+
+
+
+
+exports.formatTypings = formatTypings; exports.getTypings = getTypings;