llmz 0.0.30 → 0.0.32

package/dist/{chunk-7POUFE5M.js → chunk-23SY6IDW.js}

@@ -1,6 +1,6 @@
 import {
   getTypings
-} from "./chunk-IUE5BW56.js";
+} from "./chunk-U4HWJLF2.js";
 import {
   convertObjectToZuiLiterals,
   isJsonSchema,
@@ -94,7 +94,16 @@ var Tool = class _Tool {
    * @internal
    */
   get zInput() {
-    let input = this.input ? transforms.fromJSONSchemaLegacy(this.input) : z.any();
+    let input;
+    if (this.input) {
+      try {
+        input = transforms.fromJSONSchema(this.input);
+      } catch {
+        input = transforms.fromJSONSchemaLegacy(this.input);
+      }
+    } else {
+      input = z.any();
+    }
     if (!isEmpty_default(this._staticInputValues)) {
       const inputExtensions = convertObjectToZuiLiterals(this._staticInputValues);
       if (input instanceof z.ZodObject) {
@@ -114,7 +123,14 @@ var Tool = class _Tool {
    * @internal
    */
   get zOutput() {
-    return this.output ? transforms.fromJSONSchemaLegacy(this.output) : z.void();
+    if (!this.output) {
+      return z.void();
+    }
+    try {
+      return transforms.fromJSONSchema(this.output);
+    } catch {
+      return transforms.fromJSONSchemaLegacy(this.output);
+    }
   }
   /**
    * Renames the tool and updates its aliases.
@@ -200,8 +216,22 @@ var Tool = class _Tool {
   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;
+      let zInput;
+      if (this.input) {
+        try {
+          zInput = transforms.fromJSONSchema(this.input);
+        } catch {
+          zInput = transforms.fromJSONSchemaLegacy(this.input);
+        }
+      }
+      let zOutput;
+      if (this.output) {
+        try {
+          zOutput = transforms.fromJSONSchema(this.output);
+        } catch {
+          zOutput = transforms.fromJSONSchemaLegacy(this.output);
+        }
+      }
       return new _Tool({
         name: props.name ?? this.name,
         aliases: props.aliases ?? [...this.aliases],
@@ -324,7 +354,11 @@ var Tool = class _Tool {
     }
     if (typeof props.input !== "undefined") {
       if (isZuiSchema(props.input)) {
-        this.input = transforms.toJSONSchemaLegacy(props.input);
+        try {
+          this.input = transforms.toJSONSchema(props.input);
+        } catch {
+          this.input = transforms.toJSONSchemaLegacy(props.input);
+        }
       } else if (isJsonSchema(props.input)) {
         this.input = props.input;
       } else {
@@ -335,7 +369,11 @@ var Tool = class _Tool {
     }
     if (typeof props.output !== "undefined") {
       if (isZuiSchema(props.output)) {
-        this.output = transforms.toJSONSchemaLegacy(props.output);
+        try {
+          this.output = transforms.toJSONSchema(props.output);
+        } catch {
+          this.output = transforms.toJSONSchemaLegacy(props.output);
+        }
       } else if (isJsonSchema(props.output)) {
         this.output = props.output;
       } else {
@@ -413,8 +451,24 @@ var Tool = class _Tool {
    * @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();
+    let input;
+    if (this.input) {
+      try {
+        input = transforms.fromJSONSchema(this.input);
+      } catch {
+        input = transforms.fromJSONSchemaLegacy(this.input);
+      }
+    }
+    let output;
+    if (!this.output || Object.keys(this.output).length === 0) {
+      output = z.void();
+    } else {
+      try {
+        output = transforms.fromJSONSchema(this.output);
+      } catch {
+        output = transforms.fromJSONSchemaLegacy(this.output);
+      }
+    }
     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);

package/dist/{chunk-KQPGB6GB.js → chunk-4JN4PPGP.js}

@@ -2,13 +2,13 @@ import {
   DualModePrompt,
   extractType,
   inspect
-} from "./chunk-HCC76DDO.js";
+} from "./chunk-AAHUDKBY.js";
 import {
   Tool
-} from "./chunk-7POUFE5M.js";
+} from "./chunk-23SY6IDW.js";
 import {
   LoopExceededError
-} from "./chunk-MYLTD5WT.js";
+} from "./chunk-WSVDMGMR.js";
 import {
   Exit
 } from "./chunk-VPTFUOIK.js";
@@ -20,9 +20,294 @@ import {
 } from "./chunk-3JYCCI4S.js";
 import {
   cloneDeep_default,
-  isPlainObject_default
+  isPlainObject_default,
+  omit_default
 } from "./chunk-7WRN4E42.js";
 
+// src/exit-parser.ts
+function isValuePrimitive(value) {
+  return value === null || value === void 0 || typeof value !== "object" || Array.isArray(value);
+}
+function generatePossibleWraps(value, shape, discriminator) {
+  const possibleWraps = [];
+  const commonNames = ["result", "value", "data", "message", "error", "output", "response"];
+  if (shape && typeof shape === "object") {
+    for (const key of Object.keys(shape)) {
+      if (key !== discriminator) {
+        const wrap = discriminator ? { [discriminator]: shape[discriminator]._def.value, [key]: value } : { [key]: value };
+        possibleWraps.push(wrap);
+      }
+    }
+  }
+  for (const name of commonNames) {
+    const hasName = possibleWraps.some((w) => Object.keys(w).includes(name));
+    if (!hasName) {
+      const wrap = discriminator && (shape == null ? void 0 : shape[discriminator]) ? { [discriminator]: shape[discriminator]._def.value, [name]: value } : { [name]: value };
+      possibleWraps.push(wrap);
+    }
+  }
+  return possibleWraps;
+}
+function tryObjectWrapping(schema, candidateValue) {
+  const possibleWraps = generatePossibleWraps(candidateValue, schema.shape);
+  for (const wrap of possibleWraps) {
+    const testParse = schema.safeParse(wrap);
+    if (testParse.success) {
+      return { success: true, valueToValidate: wrap, parsed: testParse };
+    }
+  }
+  return { success: false, valueToValidate: candidateValue, parsed: { success: false } };
+}
+function detectDiscriminator(options) {
+  if (options.length === 0 || options[0]._def.typeName !== "ZodObject") {
+    return void 0;
+  }
+  const firstShape = options[0].shape;
+  for (const key in firstShape) {
+    const firstFieldType = firstShape[key]._def.typeName;
+    if (firstFieldType === "ZodLiteral") {
+      const allHaveLiteral = options.every((opt) => {
+        var _a;
+        return ((_a = opt.shape[key]) == null ? void 0 : _a._def.typeName) === "ZodLiteral";
+      });
+      if (allHaveLiteral) {
+        return key;
+      }
+    }
+  }
+  return void 0;
+}
+function tryAddDiscriminator(schema, options, discriminator, valueToValidate) {
+  const matchingOptions = [];
+  for (const option of options) {
+    if (option._def.typeName === "ZodObject" && option.shape[discriminator]) {
+      const discriminatorValue = option.shape[discriminator]._def.value;
+      const wrappedValue = { [discriminator]: discriminatorValue, ...valueToValidate };
+      const testParse = schema.safeParse(wrappedValue);
+      if (testParse.success) {
+        matchingOptions.push({ wrappedValue });
+      }
+    }
+  }
+  if (matchingOptions.length === 1) {
+    const wrapped = matchingOptions[0].wrappedValue;
+    return { success: true, valueToValidate: wrapped, parsed: schema.safeParse(wrapped) };
+  }
+  return { success: false, valueToValidate, parsed: { success: false } };
+}
+function tryUnionPrimitiveWrapping(schema, options, discriminator, valueToValidate) {
+  const allSuccessfulWraps = [];
+  for (const option of options) {
+    if (option._def.typeName === "ZodObject" && option.shape[discriminator]) {
+      const discriminatorValue = option.shape[discriminator]._def.value;
+      const possibleWraps = generatePossibleWraps(valueToValidate, option.shape, discriminator);
+      for (const wrap of possibleWraps) {
+        const finalWrap = { [discriminator]: discriminatorValue, ...wrap };
+        const testParse = schema.safeParse(finalWrap);
+        if (testParse.success) {
+          allSuccessfulWraps.push({ wrap: finalWrap });
+          break;
+        }
+      }
+    }
+  }
+  if (allSuccessfulWraps.length === 1) {
+    const wrapped = allSuccessfulWraps[0].wrap;
+    return { success: true, valueToValidate: wrapped, parsed: schema.safeParse(wrapped) };
+  }
+  return { success: false, valueToValidate, parsed: { success: false } };
+}
+function tryUnionWrapping(schema, valueToValidate) {
+  const options = schema._def.options;
+  let discriminator = schema._def.discriminator;
+  if (!discriminator) {
+    discriminator = detectDiscriminator(options);
+  }
+  if (!discriminator) {
+    return { success: false, valueToValidate, parsed: { success: false } };
+  }
+  const isValueObject = valueToValidate !== null && typeof valueToValidate === "object" && !Array.isArray(valueToValidate);
+  const isPrimitive = isValuePrimitive(valueToValidate);
+  if (isValueObject && !(discriminator in valueToValidate)) {
+    const result = tryAddDiscriminator(schema, options, discriminator, valueToValidate);
+    if (result.success) {
+      return result;
+    }
+  }
+  if (isPrimitive) {
+    return tryUnionPrimitiveWrapping(schema, options, discriminator, valueToValidate);
+  }
+  return { success: false, valueToValidate, parsed: { success: false } };
+}
+function trySmartWrapping(schema, schemaType, valueToValidate, alternativeValue) {
+  const valuesToTry = [valueToValidate];
+  if (alternativeValue !== void 0 && alternativeValue !== valueToValidate) {
+    valuesToTry.push(alternativeValue);
+  }
+  for (const candidateValue of valuesToTry) {
+    const isPrimitive = isValuePrimitive(candidateValue);
+    if (schemaType === "ZodObject" && isPrimitive) {
+      const result = tryObjectWrapping(schema, candidateValue);
+      if (result.success) {
+        return result;
+      }
+    }
+  }
+  if (alternativeValue !== void 0 && alternativeValue !== valueToValidate) {
+    valueToValidate = alternativeValue;
+  }
+  if (schemaType === "ZodDiscriminatedUnion" || schemaType === "ZodUnion") {
+    const result = tryUnionWrapping(schema, valueToValidate);
+    if (result.success) {
+      return result;
+    }
+  }
+  return { valueToValidate, parsed: { success: false } };
+}
+function parseExit(returnValue, exits) {
+  if (!returnValue) {
+    return {
+      success: false,
+      error: "No return value provided",
+      returnValue
+    };
+  }
+  const returnAction = returnValue.action;
+  if (!returnAction) {
+    return {
+      success: false,
+      error: `Code did not return an action. Valid actions are: ${exits.map((x) => x.name).join(", ")}`,
+      returnValue
+    };
+  }
+  const returnExit = exits.find((x) => x.name.toLowerCase() === returnAction.toLowerCase()) ?? exits.find((x) => x.aliases.some((a) => a.toLowerCase() === returnAction.toLowerCase()));
+  if (!returnExit) {
+    return {
+      success: false,
+      error: `Exit "${returnAction}" not found. Valid actions are: ${exits.map((x) => x.name).join(", ")}`,
+      returnValue
+    };
+  }
+  if (!returnExit.zSchema) {
+    const otherProps = omit_default(returnValue, "action");
+    const value = Object.keys(otherProps).length === 1 ? Object.values(otherProps)[0] : otherProps;
+    return {
+      success: true,
+      exit: returnExit,
+      value
+    };
+  }
+  let valueToValidate = returnValue.value;
+  let alternativeValue = void 0;
+  if (valueToValidate === void 0) {
+    const otherProps = omit_default(returnValue, "action");
+    if (Object.keys(otherProps).length > 0) {
+      valueToValidate = otherProps;
+      if (Object.keys(otherProps).length === 1) {
+        alternativeValue = Object.values(otherProps)[0];
+      }
+    }
+  }
+  const schema = returnExit.zSchema;
+  const schemaType = schema._def.typeName;
+  let parsed = schema.safeParse(valueToValidate);
+  if (!parsed.success && alternativeValue !== void 0 && alternativeValue !== valueToValidate) {
+    const altParsed = schema.safeParse(alternativeValue);
+    if (altParsed.success) {
+      parsed = altParsed;
+      valueToValidate = alternativeValue;
+    }
+  }
+  if (!parsed.success) {
+    const result = trySmartWrapping(schema, schemaType, valueToValidate, alternativeValue);
+    valueToValidate = result.valueToValidate;
+    parsed = result.parsed;
+  }
+  if (!parsed.success) {
+    const getValueTypeDescription = (val) => {
+      if (val === null)
+        return "null";
+      if (val === void 0)
+        return "undefined";
+      if (Array.isArray(val))
+        return "array";
+      return typeof val;
+    };
+    const generatedType = getValueTypeDescription(valueToValidate);
+    let generatedStatement = `return { action: '${returnAction}'`;
+    if (returnValue.value !== void 0) {
+      generatedStatement += `, value: ${generatedType}`;
+    } else {
+      const otherProps = omit_default(returnValue, "action");
+      const propKeys = Object.keys(otherProps);
+      if (propKeys.length === 1) {
+        generatedStatement += `, ${propKeys[0]}: ${generatedType}`;
+      } else if (propKeys.length > 1) {
+        generatedStatement += `, ${propKeys.join(", ")}`;
+      }
+    }
+    generatedStatement += " }";
+    const expectedStatements = [];
+    for (const exit of exits) {
+      let statement = `return { action: '${exit.name}'`;
+      if (exit.zSchema) {
+        const schema2 = exit.zSchema;
+        const typeName = schema2._def.typeName;
+        if (typeName === "ZodObject") {
+          const shape = schema2.shape;
+          const properties = Object.keys(shape).map((key) => {
+            var _a;
+            const field = shape[key];
+            const fieldType = field._def.typeName || "unknown";
+            const isOptional = ((_a = field.isOptional) == null ? void 0 : _a.call(field)) || false;
+            return `${key}${isOptional ? "?" : ""}: ${fieldType.replace("Zod", "").toLowerCase()}`;
+          });
+          statement += `, value: { ${properties.join(", ")} }`;
+        } else if (typeName === "ZodUnion" || typeName === "ZodDiscriminatedUnion") {
+          const options = schema2._def.options || [];
+          const variants = options.map((opt) => {
+            if (opt._def.typeName === "ZodObject") {
+              const shape = opt.shape;
+              const properties = Object.keys(shape).map((key) => {
+                const field = shape[key];
+                const fieldType = field._def.typeName || "unknown";
+                return `${key}: ${fieldType.replace("Zod", "").toLowerCase()}`;
+              });
+              return `{ ${properties.join(", ")} }`;
+            }
+            return "unknown";
+          });
+          statement += `, value: ${variants.join(" | ")}`;
+        } else {
+          const schemaTypeName = (typeName == null ? void 0 : typeName.replace("Zod", "").toLowerCase()) || "unknown";
+          statement += `, value: ${schemaTypeName}`;
+        }
+      }
+      statement += " }";
+      expectedStatements.push(statement);
+    }
+    const errorMessage = [
+      `Invalid return value for exit "${returnExit.name}"`,
+      "",
+      "You generated:",
+      `  ${generatedStatement}`,
+      "",
+      "But expected one of:",
+      ...expectedStatements.map((s) => `  ${s}`)
+    ].join("\n");
+    return {
+      success: false,
+      error: errorMessage,
+      returnValue
+    };
+  }
+  return {
+    success: true,
+    exit: returnExit,
+    value: parsed.data
+  };
+}
+
 // src/snapshots.ts
 import { ulid } from "ulid";
 var MAX_SNAPSHOT_SIZE_BYTES = 4e3;
@@ -687,6 +972,9 @@ var Iteration = class {
   get model() {
     return this._parameters.model;
   }
+  set model(value) {
+    this._parameters.model = value;
+  }
   get temperature() {
     return this._parameters.temperature;
   }
@@ -1101,6 +1389,7 @@ var Context = class {
 };
 
 export {
+  parseExit,
   Snapshot,
   ExecutionResult,
   SuccessExecutionResult,