llmz 0.0.29 → 0.0.31

package/dist/{chunk-273DEMEU.cjs → chunk-J57224PD.cjs}

@@ -94,7 +94,16 @@ var Tool = (_class = class _Tool {
    * @internal
    */
   get zInput() {
-    let input = this.input ? _zui.transforms.fromJSONSchemaLegacy(this.input) : _zui.z.any();
+    let input;
+    if (this.input) {
+      try {
+        input = _zui.transforms.fromJSONSchema(this.input);
+      } catch (e2) {
+        input = _zui.transforms.fromJSONSchemaLegacy(this.input);
+      }
+    } else {
+      input = _zui.z.any();
+    }
     if (!_chunkUQOBUJIQcjs.isEmpty_default.call(void 0, this._staticInputValues)) {
       const inputExtensions = _chunkWHNOR4ZUcjs.convertObjectToZuiLiterals.call(void 0, this._staticInputValues);
       if (input instanceof _zui.z.ZodObject) {
@@ -114,7 +123,14 @@ var Tool = (_class = class _Tool {
    * @internal
    */
   get zOutput() {
-    return this.output ? _zui.transforms.fromJSONSchemaLegacy(this.output) : _zui.z.void();
+    if (!this.output) {
+      return _zui.z.void();
+    }
+    try {
+      return _zui.transforms.fromJSONSchema(this.output);
+    } catch (e3) {
+      return _zui.transforms.fromJSONSchemaLegacy(this.output);
+    }
   }
   /**
    * Renames the tool and updates its aliases.
@@ -200,8 +216,22 @@ var Tool = (_class = class _Tool {
   clone(props = {}) {
     var _a, _b;
     try {
-      const zInput = this.input ? _zui.transforms.fromJSONSchemaLegacy(this.input) : void 0;
-      const zOutput = this.output ? _zui.transforms.fromJSONSchemaLegacy(this.output) : void 0;
+      let zInput;
+      if (this.input) {
+        try {
+          zInput = _zui.transforms.fromJSONSchema(this.input);
+        } catch (e4) {
+          zInput = _zui.transforms.fromJSONSchemaLegacy(this.input);
+        }
+      }
+      let zOutput;
+      if (this.output) {
+        try {
+          zOutput = _zui.transforms.fromJSONSchema(this.output);
+        } catch (e5) {
+          zOutput = _zui.transforms.fromJSONSchemaLegacy(this.output);
+        }
+      }
       return new _Tool({
         name: _nullishCoalesce(props.name, () => ( this.name)),
         aliases: _nullishCoalesce(props.aliases, () => ( [...this.aliases])),
@@ -324,7 +354,11 @@ var Tool = (_class = class _Tool {
     }
     if (typeof props.input !== "undefined") {
       if (_chunkWHNOR4ZUcjs.isZuiSchema.call(void 0, props.input)) {
-        this.input = _zui.transforms.toJSONSchemaLegacy(props.input);
+        try {
+          this.input = _zui.transforms.toJSONSchema(props.input);
+        } catch (e6) {
+          this.input = _zui.transforms.toJSONSchemaLegacy(props.input);
+        }
       } else if (_chunkWHNOR4ZUcjs.isJsonSchema.call(void 0, props.input)) {
         this.input = props.input;
       } else {
@@ -335,7 +369,11 @@ var Tool = (_class = class _Tool {
     }
     if (typeof props.output !== "undefined") {
       if (_chunkWHNOR4ZUcjs.isZuiSchema.call(void 0, props.output)) {
-        this.output = _zui.transforms.toJSONSchemaLegacy(props.output);
+        try {
+          this.output = _zui.transforms.toJSONSchema(props.output);
+        } catch (e7) {
+          this.output = _zui.transforms.toJSONSchemaLegacy(props.output);
+        }
       } else if (_chunkWHNOR4ZUcjs.isJsonSchema.call(void 0, props.output)) {
         this.output = props.output;
       } else {
@@ -413,8 +451,24 @@ var Tool = (_class = class _Tool {
    * @returns Promise resolving to TypeScript declaration string
    */
   async getTypings() {
-    let input = this.input ? _zui.transforms.fromJSONSchemaLegacy(this.input) : void 0;
-    const output = this.output ? _zui.transforms.fromJSONSchemaLegacy(this.output) : _zui.z.void();
+    let input;
+    if (this.input) {
+      try {
+        input = _zui.transforms.fromJSONSchema(this.input);
+      } catch (e8) {
+        input = _zui.transforms.fromJSONSchemaLegacy(this.input);
+      }
+    }
+    let output;
+    if (!this.output || Object.keys(this.output).length === 0) {
+      output = _zui.z.void();
+    } else {
+      try {
+        output = _zui.transforms.fromJSONSchema(this.output);
+      } catch (e9) {
+        output = _zui.transforms.fromJSONSchemaLegacy(this.output);
+      }
+    }
     if ((input == null ? void 0 : input.naked()) instanceof _zui.ZodObject && typeof this._staticInputValues === "object" && !_chunkUQOBUJIQcjs.isEmpty_default.call(void 0, this._staticInputValues)) {
       const inputExtensions = _chunkWHNOR4ZUcjs.convertObjectToZuiLiterals.call(void 0, this._staticInputValues);
       input = input.extend(inputExtensions);

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

@@ -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-WYFTNO2Y.js}

@@ -2,10 +2,10 @@ import {
   DualModePrompt,
   extractType,
   inspect
-} from "./chunk-HCC76DDO.js";
+} from "./chunk-AAHUDKBY.js";
 import {
   Tool
-} from "./chunk-7POUFE5M.js";
+} from "./chunk-RC6YO5UW.js";
 import {
   LoopExceededError
 } from "./chunk-MYLTD5WT.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;
@@ -1101,6 +1386,7 @@ var Context = class {
 };
 
 export {
+  parseExit,
   Snapshot,
   ExecutionResult,
   SuccessExecutionResult,

package/dist/compiler/compiler.d.ts

@@ -14,6 +14,7 @@ export declare const Identifiers: {
 export type CompiledCode = ReturnType<typeof compile>;
 export declare function compile(code: string): {
     code: string;
+    codeWithMarkers: string;
     map: {
         version: number;
         sources: string[];

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

@@ -1,3 +1,5 @@
+export declare const USER_CODE_START_MARKER = "/* __LLMZ_USER_CODE_START__ */";
+export declare const USER_CODE_END_MARKER = "/* __LLMZ_USER_CODE_END__ */";
 export declare const AsyncIterator: {
     preProcessing: (code: string) => string;
     postProcessing: (code: string) => string;

package/dist/compiler/plugins/html-to-markdown.d.ts

@@ -0,0 +1,21 @@
+import { type PluginObj } from '@babel/core';
+/**
+ * This plugin converts simple HTML tags in JSX text to markdown equivalents.
+ * Only handles basic formatting tags without attributes (except href/src).
+ *
+ * Supported conversions:
+ * - <strong>text</strong> -> **text**
+ * - <b>text</b> -> **text**
+ * - <em>text</em> -> *text*
+ * - <i>text</i> -> *text*
+ * - <u>text</u> -> __text__
+ * - <a href="url">text</a> -> [text](url)
+ * - <ul><li>item</li></ul> -> - item
+ * - <ol><li>item</li></ol> -> 1. item
+ * - <br>, <br/>, <br /> -> \n
+ * - <p>text</p> -> text\n\n
+ *
+ * Only converts tags that have no attributes (except href for links).
+ * Preserves complex HTML that can't be represented in simple markdown.
+ */
+export declare function htmlToMarkdownPlugin(): PluginObj;

package/dist/compiler/plugins/jsx-undefined-vars.d.ts

@@ -0,0 +1,14 @@
+import { type PluginObj } from '@babel/core';
+/**
+ * This plugin transforms JSX expressions that reference undefined variables
+ * into safe fallbacks that display the variable name as a string.
+ *
+ * For example:
+ *   <div>{content}</div>
+ * becomes:
+ *   <div>{(() => { try { return content } catch { return 'content' } })()}</div>
+ *
+ * This prevents "variable is not defined" errors when the LLM generates JSX
+ * with variable references that don't exist in the actual execution scope.
+ */
+export declare function jsxUndefinedVarsPlugin(): PluginObj;

package/dist/{dual-modes-DW3KRXT2.js → dual-modes-LEAHGCOF.js}

@@ -1,6 +1,6 @@
 import {
   DualModePrompt
-} from "./chunk-HCC76DDO.js";
+} from "./chunk-AAHUDKBY.js";
 import "./chunk-YEAWWJSJ.js";
 import "./chunk-GGWM6X2K.js";
 import "./chunk-ORQP26SZ.js";

package/dist/{dual-modes-F4UV5VAZ.cjs → dual-modes-UBHAMQW4.cjs}

@@ -1,6 +1,6 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkWP4F6KMWcjs = require('./chunk-WP4F6KMW.cjs');
+var _chunk5BEKU5MZcjs = require('./chunk-5BEKU5MZ.cjs');
 require('./chunk-KIN7Y247.cjs');
 require('./chunk-ZRCU35UV.cjs');
 require('./chunk-KMZDFWYZ.cjs');
@@ -9,4 +9,4 @@ require('./chunk-WHNOR4ZU.cjs');
 require('./chunk-UQOBUJIQ.cjs');
 
 
-exports.DualModePrompt = _chunkWP4F6KMWcjs.DualModePrompt;
+exports.DualModePrompt = _chunk5BEKU5MZcjs.DualModePrompt;

package/dist/exit-parser.d.ts

@@ -0,0 +1,37 @@
+import { Exit } from './exit.js';
+/**
+ * Result of parsing an exit from return value
+ */
+export type ParsedExit = {
+    success: true;
+    exit: Exit;
+    value: unknown;
+} | {
+    success: false;
+    error: string;
+    returnValue: unknown;
+};
+/**
+ * Parses and validates a return value against a list of exits.
+ * Attempts to intelligently fit the data to the expected schema.
+ *
+ * @param returnValue - The raw return value from code execution
+ * @param exits - Available exits to match against
+ * @returns Parsed exit result with validated data or error
+ *
+ * @example
+ * ```typescript
+ * const exits = [
+ *   new Exit({ name: 'done', schema: z.object({ result: z.string() }) })
+ * ]
+ *
+ * // Returns primitive value - will be smart-wrapped
+ * const result = parseExit({ action: 'done', data: 'hello' }, exits)
+ * // result.success === true
+ * // result.value === { result: 'hello' }
+ * ```
+ */
+export declare function parseExit(returnValue: {
+    action: string;
+    [key: string]: unknown;
+} | null, exits: Exit[]): ParsedExit;