llmz 0.0.13 → 0.0.15

package/dist/chunk-A7QHWVD7.js

@@ -0,0 +1,493 @@
+import {
+  getTypings
+} from "./chunk-EE6NVDID.js";
+import {
+  convertObjectToZuiLiterals,
+  isJsonSchema,
+  isValidIdentifier,
+  isZuiSchema
+} from "./chunk-ZORRILUV.js";
+import {
+  isEmpty_default,
+  uniq_default
+} from "./chunk-7WRN4E42.js";
+
+// src/tool.ts
+import { z, transforms, ZodObject, ZodType } from "@bpinternal/zui";
+var Tool = class _Tool {
+  _staticInputValues;
+  name;
+  aliases = [];
+  description;
+  metadata;
+  input;
+  output;
+  retry;
+  MAX_RETRIES = 1e3;
+  /**
+   * Sets static input values that will be automatically applied to all tool calls.
+   *
+   * Static values allow you to pre-configure certain parameters that shouldn't change
+   * between calls, effectively removing them from the LLM's control while ensuring
+   * they're always present when the tool executes.
+   *
+   * @param values - Partial input values to apply statically. Set to null/undefined to clear.
+   * @returns The tool instance for method chaining
+   *
+   * @example
+   * ```typescript
+   * // Create a tool with configurable parameters
+   * const searchTool = new Tool({
+   *   name: 'search',
+   *   input: z.object({
+   *     query: z.string(),
+   *     maxResults: z.number().default(10),
+   *     includeSnippets: z.boolean().default(true),
+   *   }),
+   *   handler: async ({ query, maxResults, includeSnippets }) => {
+   *     // Implementation
+   *   },
+   * })
+   *
+   * // Create a restricted version with static values
+   * const restrictedSearch = searchTool.setStaticInputValues({
+   *   maxResults: 5, // Always limit to 5 results
+   *   includeSnippets: false, // Never include snippets
+   * })
+   *
+   * // LLM can only control 'query' parameter now
+   * // The tool will always use maxResults: 5, includeSnippets: false
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Clear static values
+   * const unrestricted = restrictedTool.setStaticInputValues(null)
+   * ```
+   */
+  setStaticInputValues(values) {
+    if (values === null || values === void 0) {
+      this._staticInputValues = void 0;
+      return this;
+    }
+    const input = this.input ? transforms.fromJSONSchemaLegacy(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;
+  }
+  /**
+   * Gets the computed input schema with static values applied.
+   *
+   * This property returns the final input schema that will be used for validation,
+   * including any static input values that have been set via setStaticInputValues().
+   *
+   * @returns The Zui schema for input validation
+   * @internal
+   */
+  get zInput() {
+    let input = this.input ? transforms.fromJSONSchemaLegacy(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;
+  }
+  /**
+   * Gets the output schema for validation.
+   *
+   * @returns The Zui schema for output validation
+   * @internal
+   */
+  get zOutput() {
+    return this.output ? transforms.fromJSONSchemaLegacy(this.output) : z.void();
+  }
+  /**
+   * Renames the tool and updates its aliases.
+   *
+   * @param name - New name for the tool (must be a valid identifier)
+   * @returns The tool instance for method chaining
+   * @throws Error if the name is not a valid identifier
+   *
+   * @example
+   * ```typescript
+   * const weatherTool = new Tool({ name: 'getWeather', ... })
+   * weatherTool.rename('getCurrentWeather')
+   * console.log(weatherTool.name) // 'getCurrentWeather'
+   * ```
+   */
+  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;
+  }
+  /**
+   * Creates a new tool based on this one with modified properties.
+   *
+   * Clone allows you to create variations of existing tools with different names,
+   * schemas, handlers, or other configuration. This is useful for creating specialized
+   * versions of tools or adding additional functionality.
+   *
+   * @param props - Properties to override in the cloned tool
+   * @returns A new Tool instance with the specified modifications
+   * @throws Error if cloning fails due to invalid configuration
+   *
+   * @example
+   * ```typescript
+   * // Create a basic search tool
+   * const basicSearch = new Tool({
+   *   name: 'search',
+   *   input: z.object({ query: z.string() }),
+   *   output: z.object({ results: z.array(z.string()) }),
+   *   handler: async ({ query }) => ({ results: await search(query) }),
+   * })
+   *
+   * // Clone with enhanced output schema
+   * const enhancedSearch = basicSearch.clone({
+   *   name: 'enhancedSearch',
+   *   description: 'Search with additional metadata',
+   *   output: (original) => original!.extend({
+   *     totalResults: z.number(),
+   *     searchTime: z.number(),
+   *   }),
+   *   handler: async ({ query }) => {
+   *     const startTime = Date.now()
+   *     const results = await search(query)
+   *     return {
+   *       results: results.items,
+   *       totalResults: results.total,
+   *       searchTime: Date.now() - startTime,
+   *     }
+   *   },
+   * })
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Clone with restricted access
+   * const restrictedTool = adminTool.clone({
+   *   name: 'userTool',
+   *   handler: async (input, ctx) => {
+   *     // Add authorization check
+   *     if (!isAuthorized(ctx.callId)) {
+   *       throw new Error('Unauthorized access')
+   *     }
+   *     return adminTool.execute(input, ctx)
+   *   },
+   * })
+   * ```
+   */
+  clone(props = {}) {
+    var _a, _b;
+    try {
+      const zInput = this.input ? transforms.fromJSONSchemaLegacy(this.input) : void 0;
+      const zOutput = this.output ? transforms.fromJSONSchemaLegacy(this.output) : void 0;
+      return new _Tool({
+        name: props.name ?? this.name,
+        aliases: props.aliases ?? [...this.aliases],
+        description: props.description ?? this.description,
+        metadata: JSON.parse(JSON.stringify(props.metadata ?? this.metadata)),
+        input: typeof props.input === "function" ? (_a = props.input) == null ? void 0 : _a.call(props, zInput) : props.input instanceof ZodType ? props.input : zInput,
+        output: typeof props.output === "function" ? (_b = props.output) == null ? void 0 : _b.call(props, zOutput) : props.output instanceof ZodType ? props.output : zOutput,
+        handler: props.handler ?? this._handler,
+        retry: props.retry ?? this.retry
+      }).setStaticInputValues(props.staticInputValues ?? this._staticInputValues);
+    } catch (e) {
+      throw new Error(`Failed to clone tool "${this.name}": ${e}`);
+    }
+  }
+  _handler;
+  /**
+   * Creates a new Tool instance.
+   *
+   * @param props - Tool configuration properties
+   * @param props.name - Unique tool name (must be valid TypeScript identifier)
+   * @param props.description - Human-readable description for the LLM
+   * @param props.input - Zui/Zod schema for input validation (optional)
+   * @param props.output - Zui/Zod schema for output validation (optional)
+   * @param props.handler - Async function that implements the tool logic
+   * @param props.aliases - Alternative names for the tool (optional)
+   * @param props.metadata - Additional metadata for the tool (optional)
+   * @param props.staticInputValues - Default input values (optional)
+   * @param props.retry - Custom retry logic function (optional)
+   *
+   * @throws Error if name is not a valid identifier
+   * @throws Error if description is not a string
+   * @throws Error if metadata is not an object
+   * @throws Error if handler is not a function
+   * @throws Error if aliases contains invalid identifiers
+   * @throws Error if input/output schemas are invalid
+   *
+   * @example
+   * ```typescript
+   * const weatherTool = new Tool({
+   *   name: 'getCurrentWeather',
+   *   description: 'Fetches current weather data for a given city',
+   *   aliases: ['weather', 'getWeather'], // Alternative names
+   *
+   *   input: z.object({
+   *     city: z.string().min(1).describe('City name to get weather for'),
+   *     units: z.enum(['celsius', 'fahrenheit']).default('celsius'),
+   *     includeHourly: z.boolean().default(false),
+   *   }),
+   *
+   *   output: z.object({
+   *     temperature: z.number(),
+   *     description: z.string(),
+   *     humidity: z.number().min(0).max(100),
+   *     hourlyForecast: z.array(z.object({
+   *       hour: z.number(),
+   *       temp: z.number(),
+   *       condition: z.string(),
+   *     })).optional(),
+   *   }),
+   *
+   *   async handler({ city, units, includeHourly }) {
+   *     const response = await fetch(`/api/weather?city=${encodeURIComponent(city)}&units=${units}`)
+   *     const data = await response.json()
+   *
+   *     const result = {
+   *       temperature: data.main.temp,
+   *       description: data.weather[0].description,
+   *       humidity: data.main.humidity,
+   *     }
+   *
+   *     if (includeHourly) {
+   *       result.hourlyForecast = data.hourly?.slice(0, 24) || []
+   *     }
+   *
+   *     return result
+   *   },
+   *
+   *   // Optional: Add retry logic for network errors
+   *   retry: ({ attempt, error }) => {
+   *     return attempt < 3 && error.message.includes('network')
+   *   },
+   *
+   *   // Optional: Add metadata
+   *   metadata: {
+   *     category: 'weather',
+   *     rateLimit: 100,
+   *     cacheable: true,
+   *   },
+   * })
+   * ```
+   */
+  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 (isZuiSchema(props.input)) {
+        this.input = transforms.toJSONSchemaLegacy(props.input);
+      } 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 (isZuiSchema(props.output)) {
+        this.output = transforms.toJSONSchemaLegacy(props.output);
+      } 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);
+    this.retry = props.retry;
+  }
+  /**
+   * Executes the tool with the given input and context.
+   *
+   * This method handles input validation, retry logic, output validation, and error handling.
+   * It's called internally by the LLMz execution engine when generated code calls the tool.
+   *
+   * @param input - Input data to pass to the tool handler
+   * @param ctx - Tool call context containing call ID and other metadata
+   * @returns Promise resolving to the tool's output
+   * @throws Error if input validation fails
+   * @throws Error if tool execution fails after all retries
+   *
+   * @example
+   * ```typescript
+   * // Direct tool execution (usually done by LLMz internally)
+   * const result = await weatherTool.execute(
+   *   { city: 'San Francisco', units: 'fahrenheit' },
+   *   { callId: 'call_123' }
+   * )
+   * console.log(result.temperature) // 72
+   * ```
+   *
+   * @internal This method is primarily used internally by the LLMz execution engine
+   */
+  async execute(input, ctx) {
+    var _a;
+    const pInput = this.zInput.safeParse(input);
+    if (!pInput.success) {
+      throw new Error(`Tool "${this.name}" received invalid input: ${pInput.error.message}`);
+    }
+    let attempt = 0;
+    while (attempt < this.MAX_RETRIES) {
+      try {
+        const result = await this._handler(pInput.data, ctx);
+        const pOutput = this.zOutput.safeParse(result);
+        return pOutput.success ? pOutput.data : result;
+      } catch (err) {
+        const shouldRetry = await ((_a = this.retry) == null ? void 0 : _a.call(this, {
+          input: pInput.data,
+          attempt: ++attempt,
+          error: err
+        }));
+        if (!shouldRetry) {
+          throw err;
+        }
+      }
+    }
+    throw new Error(
+      `Tool "${this.name}" failed after ${this.MAX_RETRIES} attempts. Last error: ${JSON.stringify(input)}`
+    );
+  }
+  /**
+   * Generates TypeScript type definitions for this tool.
+   *
+   * This method creates TypeScript function declarations that are included in the
+   * LLM's context to help it understand how to call the tool correctly. The generated
+   * types include parameter types, return types, and JSDoc comments with descriptions.
+   *
+   * @returns Promise resolving to TypeScript declaration string
+   */
+  async getTypings() {
+    let input = this.input ? transforms.fromJSONSchemaLegacy(this.input) : void 0;
+    const output = this.output ? transforms.fromJSONSchemaLegacy(this.output) : z.void();
+    if ((input == null ? void 0 : input.naked()) instanceof ZodObject && typeof this._staticInputValues === "object" && !isEmpty_default(this._staticInputValues)) {
+      const inputExtensions = convertObjectToZuiLiterals(this._staticInputValues);
+      input = input.extend(inputExtensions);
+    } else if (this._staticInputValues !== void 0) {
+      input = convertObjectToZuiLiterals(this._staticInputValues);
+    }
+    const fnType = z.function(input, z.promise(output)).title(this.name).describe(this.description ?? "");
+    return getTypings(fnType, {
+      declaration: true
+    });
+  }
+  /**
+   * Ensures all tools in an array have unique names by appending numbers to duplicates.
+   *
+   * When multiple tools have the same name, this method renames them by appending
+   * incrementing numbers (tool1, tool2, etc.) to avoid conflicts. Tools with already
+   * unique names are left unchanged.
+   *
+   * You usually don't need to call this method directly, as LLMz will automatically detect and rename tools with conflicting names.
+   *
+   * @param tools - Array of tools to process for unique names
+   * @returns Array of tools with guaranteed unique names
+   *
+   * @example
+   * ```typescript
+   * const tools = [
+   *   new Tool({ name: 'search', handler: async () => {} }),
+   *   new Tool({ name: 'search', handler: async () => {} }),
+   *   new Tool({ name: 'unique', handler: async () => {} }),
+   *   new Tool({ name: 'search', handler: async () => {} }),
+   * ]
+   *
+   * const uniqueTools = Tool.withUniqueNames(tools)
+   * console.log(uniqueTools.map(t => t.name))
+   * // Output: ['search1', 'search1', 'unique', 'search']
+   * // Note: The last occurrence keeps the original name
+   * ```
+   *
+   * @static
+   */
+  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);
+    });
+  };
+  /**
+   * Converts the tool to its JSON representation.
+   *
+   * @returns JSON representation of the Tool instance
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      aliases: [...this.aliases],
+      description: this.description,
+      metadata: this.metadata,
+      input: this.input,
+      output: this.output,
+      staticInputValues: this._staticInputValues,
+      maxRetries: this.MAX_RETRIES
+    };
+  }
+};
+
+export {
+  Tool
+};

package/dist/{chunk-IH2WQFO5.js → chunk-EE6NVDID.js}

@@ -5,7 +5,7 @@ import {
   escapeString,
   getMultilineComment,
   toPropertyKey
-} from "./chunk-4MNIJGK6.js";
+} from "./chunk-ZORRILUV.js";
 
 // src/typings.ts
 import { z } from "@bpinternal/zui";

package/dist/{chunk-4L6D2A6O.cjs → chunk-FZJHYLM2.cjs}

@@ -5,7 +5,7 @@ var _chunkJDABP4SDcjs = require('./chunk-JDABP4SD.cjs');
 
 
 
-var _chunk276Q6EWPcjs = require('./chunk-276Q6EWP.cjs');
+var _chunkWHNOR4ZUcjs = require('./chunk-WHNOR4ZU.cjs');
 
 // src/typings.ts
 var _zui = require('@bpinternal/zui');
@@ -111,7 +111,7 @@ async function sUnwrapZod(schema, options) {
     parent: schema
   };
   if (schema instanceof Declaration) {
-    const description = _chunk276Q6EWPcjs.getMultilineComment.call(void 0, schema.schema.description);
+    const description = _chunkWHNOR4ZUcjs.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;
@@ -132,7 +132,7 @@ declare const ${schema.identifier}: ${typings};${closingTag}`);
       const optionalToken = schema.key.endsWith("?") ? "" : "?";
       return sUnwrapZodRecursive(new KeyValue(schema.key + optionalToken, innerType), newOptions);
     }
-    const description = _chunk276Q6EWPcjs.getMultilineComment.call(void 0, schema.value._def.description || schema.value.description);
+    const description = _chunkWHNOR4ZUcjs.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}`;
@@ -143,7 +143,7 @@ declare const ${schema.identifier}: ${typings};${closingTag}`);
       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(_chunk276Q6EWPcjs.toPropertyKey.call(void 0, argName), item), newOptions)}, `;
+        args += `${await sUnwrapZodRecursive(new KeyValue(_chunkWHNOR4ZUcjs.toPropertyKey.call(void 0, argName), item), newOptions)}, `;
       }
       return args;
     }
@@ -178,7 +178,7 @@ declare const ${schema.identifier}: ${typings};${closingTag}`);
     return `Promise<${await sUnwrapZodRecursive(schema.unwrap(), newOptions)}>`;
   }
   if (schema instanceof _zui.z.ZodFunction) {
-    const description = _chunk276Q6EWPcjs.getMultilineComment.call(void 0, schema._def.description);
+    const description = _chunkWHNOR4ZUcjs.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) {
@@ -196,7 +196,7 @@ declare const ${schema.identifier}: ${typings};${closingTag}`);
     return `Array<${item}>`;
   }
   if (schema instanceof _zui.z.ZodEnum) {
-    const values = schema._def.values.map(_chunk276Q6EWPcjs.escapeString);
+    const values = schema._def.values.map(_chunkWHNOR4ZUcjs.escapeString);
     return values.join(" | ");
   }
   if (schema instanceof _zui.z.ZodTuple) {
@@ -221,7 +221,7 @@ declare const ${schema.identifier}: ${typings};${closingTag}`);
     const props = await Promise.all(
       Object.entries(schema.shape).map(async ([key, value]) => {
         if (value instanceof _zui.z.Schema) {
-          return sUnwrapZodRecursive(new KeyValue(_chunk276Q6EWPcjs.toPropertyKey.call(void 0, key), value), newOptions);
+          return sUnwrapZodRecursive(new KeyValue(_chunkWHNOR4ZUcjs.toPropertyKey.call(void 0, key), value), newOptions);
         }
         return `${key}: unknown`;
       })
@@ -229,11 +229,11 @@ declare const ${schema.identifier}: ${typings};${closingTag}`);
     return `{ ${props.join("; ")} }`;
   }
   if (schema instanceof _zui.z.ZodString) {
-    const description = _chunk276Q6EWPcjs.getMultilineComment.call(void 0, schema._def.description);
+    const description = _chunkWHNOR4ZUcjs.getMultilineComment.call(void 0, schema._def.description);
     return `${description} string`.trim();
   }
   if (schema instanceof _zui.z.ZodUnion) {
-    const description = _chunk276Q6EWPcjs.getMultilineComment.call(void 0, schema._def.description);
+    const description = _chunkWHNOR4ZUcjs.getMultilineComment.call(void 0, schema._def.description);
     const options2 = await Promise.all(
       schema.options.map(async (option) => {
         return sUnwrapZodRecursive(option, newOptions);
@@ -243,16 +243,16 @@ declare const ${schema.identifier}: ${typings};${closingTag}`);
 ${options2.join(" | ")}`;
   }
   if (schema instanceof _zui.z.ZodLiteral) {
-    const description = _chunk276Q6EWPcjs.getMultilineComment.call(void 0, schema._def.description);
+    const description = _chunkWHNOR4ZUcjs.getMultilineComment.call(void 0, schema._def.description);
     return `${description}
-${typeof schema.value === "string" ? _chunk276Q6EWPcjs.escapeString.call(void 0, schema.value) : schema.value}`.trim();
+${typeof schema.value === "string" ? _chunkWHNOR4ZUcjs.escapeString.call(void 0, schema.value) : schema.value}`.trim();
   }
   if (schema instanceof _zui.z.ZodNumber) {
-    const description = _chunk276Q6EWPcjs.getMultilineComment.call(void 0, schema._def.description);
+    const description = _chunkWHNOR4ZUcjs.getMultilineComment.call(void 0, schema._def.description);
     return `${description} number`.trim();
   }
   if (schema instanceof _zui.z.ZodBoolean) {
-    const description = _chunk276Q6EWPcjs.getMultilineComment.call(void 0, schema._def.description);
+    const description = _chunkWHNOR4ZUcjs.getMultilineComment.call(void 0, schema._def.description);
     return `${description} boolean`.trim();
   }
   if (schema instanceof _zui.z.ZodCatch) {
@@ -262,7 +262,7 @@ ${typeof schema.value === "string" ? _chunk276Q6EWPcjs.escapeString.call(void 0,
     return sUnwrapZodRecursive(schema._def.getter(), newOptions);
   }
   if (schema instanceof _zui.z.ZodRecord) {
-    const description = _chunk276Q6EWPcjs.getMultilineComment.call(void 0, schema._def.description);
+    const description = _chunkWHNOR4ZUcjs.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}) }`;

package/dist/{chunk-JGVAZO4X.cjs → chunk-GZPN7RGH.cjs}

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
 
-var _chunk276Q6EWPcjs = require('./chunk-276Q6EWP.cjs');
+var _chunkWHNOR4ZUcjs = require('./chunk-WHNOR4ZU.cjs');
 
 // src/truncator.ts
 var DEFAULT_REMOVE_CHUNK = 250;
@@ -25,7 +25,7 @@ function truncateWrappedContent({
   throwOnFailure = true
 }) {
   var _a, _b, _c;
-  const tokenizer = _chunk276Q6EWPcjs.getTokenizer.call(void 0, );
+  const tokenizer = _chunkWHNOR4ZUcjs.getTokenizer.call(void 0, );
   const parts = [];
   for (const msg of messages) {
     const current = [];