llmz 0.6.0 → 0.6.2

package/dist/chunk-5WBNTV42.cjs

@@ -1,1530 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } var _class; var _class2; var _class3;
-
-
-
-var _chunkKTDBAJBBcjs = require('./chunk-KTDBAJBB.cjs');
-
-
-var _chunkPZE6PIPGcjs = require('./chunk-PZE6PIPG.cjs');
-
-
-var _chunkPK72FAKDcjs = require('./chunk-PK72FAKD.cjs');
-
-
-var _chunkDDSJTR6Qcjs = require('./chunk-DDSJTR6Q.cjs');
-
-
-var _chunkI56MPOVGcjs = require('./chunk-I56MPOVG.cjs');
-
-
-
-var _chunkHEAQAEFZcjs = require('./chunk-HEAQAEFZ.cjs');
-
-
-var _chunkGOWPACSKcjs = require('./chunk-GOWPACSK.cjs');
-
-
-
-
-var _chunkHC2QZTVTcjs = require('./chunk-HC2QZTVT.cjs');
-
-// 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 = _nullishCoalesce(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 = _chunkHC2QZTVTcjs.omit_default.call(void 0, 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 = _chunkHC2QZTVTcjs.omit_default.call(void 0, 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 = _chunkHC2QZTVTcjs.omit_default.call(void 0, 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
-var _ulid = require('ulid');
-var MAX_SNAPSHOT_SIZE_BYTES = 4e3;
-var Snapshot = class _Snapshot {
-  
-  
-  
-  
-  
-  #status;
-  /**
-   * Gets the current status of the snapshot.
-   *
-   * @returns The snapshot status (pending, resolved, or rejected)
-   */
-  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;
-  }
-  /**
-   * Creates a new Snapshot from a SnapshotSignal.
-   *
-   * This method is called internally by the LLMz execution engine when a SnapshotSignal
-   * is thrown during execution. It captures the current execution state including
-   * variables, stack trace, and tool context.
-   *
-   * @param signal The SnapshotSignal containing execution state
-   * @returns A new Snapshot instance in pending status
-   * @internal
-   */
-  static fromSignal(signal) {
-    return new _Snapshot({
-      id: "snapshot_" + _ulid.ulid.call(void 0, ),
-      reason: signal.message,
-      stack: signal.truncatedCode,
-      variables: parseVariables(signal.variables),
-      toolCall: signal.toolCall,
-      status: { type: "pending" }
-    });
-  }
-  /**
-   * Serializes the snapshot to a JSON-compatible object for persistence.
-   *
-   * Use this method to save snapshots to databases, files, or other storage systems.
-   * The serialized snapshot can be restored later using fromJSON().
-   *
-   * @returns A JSON-serializable representation of the snapshot
-   * @example
-   * ```typescript
-   * const snapshot = result.snapshot
-   * const serialized = snapshot.toJSON()
-   * await database.save('snapshots', snapshot.id, serialized)
-   * ```
-   */
-  toJSON() {
-    return {
-      id: this.id,
-      reason: this.reason,
-      stack: this.stack,
-      variables: this.variables,
-      toolCall: this.toolCall,
-      status: this.#status
-    };
-  }
-  /**
-   * Restores a snapshot from its JSON representation.
-   *
-   * Use this method to recreate snapshots from persistent storage. The restored
-   * snapshot will maintain its original state and can be resolved/rejected as needed.
-   *
-   * @param json The serialized snapshot data from toJSON()
-   * @returns A restored Snapshot instance
-   * @example
-   * ```typescript
-   * const serialized = await database.get('snapshots', snapshotId)
-   * const snapshot = Snapshot.fromJSON(serialized)
-   * ```
-   */
-  static fromJSON(json) {
-    return new _Snapshot({
-      id: json.id,
-      reason: json.reason,
-      stack: json.stack,
-      variables: json.variables,
-      toolCall: json.toolCall,
-      status: json.status
-    });
-  }
-  /**
-   * Creates a deep copy of the snapshot.
-   *
-   * @returns A new Snapshot instance with identical data
-   */
-  clone() {
-    return new _Snapshot({
-      id: this.id,
-      reason: this.reason,
-      stack: this.stack,
-      variables: this.variables,
-      toolCall: this.toolCall,
-      status: this.#status
-    });
-  }
-  /**
-   * Resets the snapshot status back to pending.
-   *
-   * This allows a previously resolved or rejected snapshot to be resolved/rejected
-   * again with different data. Useful for retry scenarios.
-   */
-  reset() {
-    this.#status = { type: "pending" };
-  }
-  /**
-   * Resolves the snapshot with a successful result value.
-   *
-   * Call this method when the long-running operation that caused the snapshot
-   * has completed successfully. The provided value will be returned as the
-   * result of the original tool call when execution resumes.
-   *
-   * @param value The result value from the completed operation
-   * @throws Error if the snapshot is not in pending status
-   * @example
-   * ```typescript
-   * // After a background job completes
-   * const result = await backgroundJob.getResult()
-   * snapshot.resolve(result)
-   *
-   * // Continue execution
-   * const continuation = await execute({ snapshot, ... })
-   * ```
-   */
-  resolve(value) {
-    var _a;
-    if (this.#status.type !== "pending") {
-      throw new Error(`Cannot resolve snapshot because it is already settled: ${this.#status.type}`);
-    }
-    const assignment = (_a = this.toolCall) == null ? void 0 : _a.assignment;
-    if (assignment) {
-      try {
-        const fn = new Function(assignment.evalFn);
-        const assignmentValue = fn(value);
-        this.variables = [...this.variables, ...parseVariables(assignmentValue)];
-      } catch (e2) {
-      }
-    }
-    this.#status = { type: "resolved", value };
-  }
-  /**
-   * Rejects the snapshot with an error.
-   *
-   * Call this method when the long-running operation that caused the snapshot
-   * has failed or encountered an error. The provided error will be thrown
-   * when execution resumes, allowing the generated code to handle it.
-   *
-   * @param error The error that occurred during the operation
-   * @throws Error if the snapshot is not in pending status
-   * @example
-   * ```typescript
-   * try {
-   *   const result = await externalAPI.call()
-   *   snapshot.resolve(result)
-   * } catch (error) {
-   *   snapshot.reject(error)
-   * }
-   *
-   * // Continue execution (will throw the error)
-   * const continuation = await execute({ snapshot, ... })
-   * ```
-   */
-  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 };
-  }
-};
-function parseVariables(variableMap) {
-  return Object.entries(variableMap).map(([name, value]) => {
-    const type = _chunkKTDBAJBBcjs.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(_chunkKTDBAJBBcjs.inspect.call(void 0, value, name), () => ( "N/A")) } : { name, type, bytes, truncated: false, value };
-  });
-}
-
-// src/transcript.ts
-var MAX_MESSAGE_LENGTH = 5e3;
-function getMessagePreview(message) {
-  if (message.role === "assistant" || message.role === "user" || message.role === "summary") {
-    return message.content;
-  }
-  if (message.role === "event") {
-    return _chunkKTDBAJBBcjs.inspect.call(void 0, message.payload, message.name, { tokens: 1e3 });
-  }
-  return _chunkKTDBAJBBcjs.inspect.call(void 0, message, void 0, { tokens: 1e3 });
-}
-function getMessageType(message) {
-  if (message.role === "assistant" || message.role === "user" || message.role === "summary") {
-    return message.role;
-  }
-  if (message.role === "event") {
-    return `event:${message.name}`;
-  }
-  return "unknown";
-}
-function isVoiceMessage(message) {
-  var _a;
-  if (message.role === "user" && message.modality === "voice") {
-    return true;
-  }
-  if (message.role === "user" || message.role === "event") {
-    return _nullishCoalesce(((_a = message.attachments) == null ? void 0 : _a.some((attachment) => attachment.type === "audio")), () => ( false));
-  }
-  return false;
-}
-var TranscriptArray = class extends Array {
-  constructor(items = []) {
-    items = Array.isArray(items) ? items : [];
-    super(...items);
-    items.forEach((item) => {
-      if (!["user", "assistant", "event", "summary"].includes(item.role)) {
-        throw new Error(`Invalid role "${item.role}" in transcript message`);
-      }
-      if ("name" in item && item.name && typeof item.name !== "string") {
-        throw new Error(`Invalid name for transcript message. Expected a string, but got type "${typeof item.name}"`);
-      }
-      if ("content" in item && typeof item.content !== "string") {
-        throw new Error(
-          `Invalid content for transcript message. Expected a string, but got type "${typeof item.content}"`
-        );
-      }
-      if ("modality" in item && item.modality !== void 0 && !["text", "voice"].includes(item.modality)) {
-        throw new Error(`Invalid modality "${item.modality}" in transcript message. Expected "text" or "voice"`);
-      }
-    });
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-  toString() {
-    if (!this.length) {
-      return "";
-    }
-    return this.map((item, idx) => {
-      var _a, _b;
-      const msgIdx = getMessageType(item) + "-" + String(idx + 1).padStart(3, "0");
-      let preview = getMessagePreview(item);
-      if (preview.length > MAX_MESSAGE_LENGTH) {
-        preview = preview.slice(0, MAX_MESSAGE_LENGTH) + "\n... (truncated)";
-      }
-      const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-      if ((item.role === "event" || item.role === "user") && ((_a = item.attachments) == null ? void 0 : _a.length)) {
-        for (let i = 0; i < item.attachments.length; i++) {
-          const attachment = item.attachments[i];
-          const ref = _nullishCoalesce(attachment.id, () => ( `${msgIdx}-${alphabet[i % alphabet.length]}`));
-          const alt = attachment.alt ? `: ${attachment.alt}` : "";
-          preview += attachment.type === "audio" ? `
-[Voice message ${ref}${alt}]` : `
-[Attachment ${ref}${alt}]`;
-        }
-      }
-      const tags = [];
-      tags.push({ key: "role", value: item.role });
-      if (isVoiceMessage(item)) {
-        tags.push({ key: "modality", value: "voice" });
-      }
-      if ("name" in item && ((_b = item.name) == null ? void 0 : _b.length)) {
-        tags.push({ key: "name", value: item.name });
-      }
-      const tagsString = tags.map(({ key, value }) => `${key}="${value}"`).join(" ");
-      return `<${msgIdx} ${tagsString}>
-${preview.trim()}
-</${msgIdx}>`;
-    }).join("\n");
-  }
-};
-
-// src/result.ts
-var ExecutionResult = class {
-  
-  
-  constructor(status, context) {
-    this.status = status;
-    this.context = context;
-  }
-  /**
-   * Type guard to check if the execution completed successfully.
-   *
-   * @returns True if the execution completed with an Exit, false otherwise
-   * @example
-   * ```typescript
-   * const result = await execute({ ... })
-   *
-   * if (result.isSuccess()) {
-   *   // TypeScript knows this is SuccessExecutionResult
-   *   console.log('Output:', result.output)
-   *   console.log('Exit name:', result.result.exit.name)
-   * }
-   * ```
-   */
-  isSuccess() {
-    return this.status === "success" && this instanceof SuccessExecutionResult;
-  }
-  /**
-   * Type guard to check if the execution failed with an error.
-   *
-   * @returns True if the execution failed with an unrecoverable error, false otherwise
-   * @example
-   * ```typescript
-   * const result = await execute({ ... })
-   *
-   * if (result.isError()) {
-   *   // TypeScript knows this is ErrorExecutionResult
-   *   console.error('Execution failed:', result.error)
-   *
-   *   // Access error details from the last iteration
-   *   const lastIteration = result.iteration
-   *   if (lastIteration?.status.type === 'execution_error') {
-   *     console.error('Stack trace:', lastIteration.status.execution_error.stack)
-   *   }
-   * }
-   * ```
-   */
-  isError() {
-    return this.status === "error" && this instanceof ErrorExecutionResult;
-  }
-  /**
-   * Type guard to check if the execution was interrupted.
-   * Interrupted means there's a snapshot available and the execution was paused and needs resuming.
-   *
-   * @returns True if the execution was interrupted, false otherwise
-   * @example
-   * ```typescript
-   * const result = await execute({ ... })
-   *
-   * if (result.isInterrupted()) {
-   *   // TypeScript knows this is PartialExecutionResult
-   *   console.log('Execution paused:', result.signal.message)
-   *
-   *   // Access snapshot for later resumption
-   *   const snapshot = result.snapshot
-   *   const serialized = snapshot.toJSON()
-   *   await storage.save('execution-state', serialized)
-   * }
-   * ```
-   */
-  isInterrupted() {
-    return this.status === "interrupted" && this instanceof PartialExecutionResult;
-  }
-  /**
-   * Type guard to check if the execution completed with a specific exit.
-   *
-   * This method provides type-safe access to the output data based on the exit's schema.
-   * It's the recommended way to handle different exit types in complex agents.
-   *
-   * @param exit - The Exit instance to check against
-   * @returns True if the execution completed with the specified exit, false otherwise
-   * @template T - The output type of the exit
-   *
-   * @example
-   * ```typescript
-   * // Define typed exits
-   * const successExit = new Exit({
-   *   name: 'success',
-   *   schema: z.object({
-   *     message: z.string(),
-   *     count: z.number(),
-   *   }),
-   * })
-   *
-   * const errorExit = new Exit({
-   *   name: 'error',
-   *   schema: z.object({
-   *     errorCode: z.string(),
-   *     details: z.string(),
-   *   }),
-   * })
-   *
-   * const result = await execute({
-   *   instructions: 'Process the data',
-   *   exits: [successExit, errorExit],
-   *   client,
-   * })
-   *
-   * // Type-safe exit handling
-   * if (result.is(successExit)) {
-   *   // TypeScript knows result.output has { message: string, count: number }
-   *   console.log(`Success: ${result.output.message}`)
-   *   console.log(`Processed ${result.output.count} items`)
-   * } else if (result.is(errorExit)) {
-   *   // TypeScript knows result.output has { errorCode: string, details: string }
-   *   console.error(`Error ${result.output.errorCode}: ${result.output.details}`)
-   * }
-   * ```
-   */
-  is(exit) {
-    return this.status === "success" && this instanceof SuccessExecutionResult && this.result.exit === exit;
-  }
-  /**
-   * Gets the output data from the last successful iteration.
-   *
-   * For successful executions, returns the data produced by the exit.
-   * For failed or interrupted executions, returns null.
-   *
-   * @returns The output data for successful executions, null otherwise
-   * @example
-   * ```typescript
-   * const result = await execute({ ... })
-   *
-   * // Generic output access
-   * if (result.isSuccess()) {
-   *   console.log('Output:', result.output)
-   * }
-   *
-   * // Type-safe output access with specific exits
-   * if (result.is(myExit)) {
-   *   // result.output is now typed based on myExit's schema
-   *   console.log(result.output.specificField)
-   * }
-   * ```
-   */
-  get output() {
-    return this.isSuccess() ? this.result.result : null;
-  }
-  /**
-   * Gets the most recent (last) iteration from the execution.
-   *
-   * Iterations represent individual steps in the execution loop where the LLM
-   * generates code, executes it, and processes the results. The last iteration
-   * contains the final generated code and execution status.
-   *
-   * @returns The last iteration, or null if no iterations were completed
-   * @example
-   * ```typescript
-   * const result = await execute({ ... })
-   *
-   * const lastIteration = result.iteration
-   * if (lastIteration) {
-   *   console.log('Generated code:', lastIteration.code)
-   *   console.log('Status:', lastIteration.status.type)
-   *   console.log('Variables:', lastIteration.variables)
-   *   console.log('Tool calls:', lastIteration.toolCalls)
-   * }
-   * ```
-   */
-  get iteration() {
-    return this.context.iterations.at(-1) || null;
-  }
-  /**
-   * Gets all iterations from the execution.
-   *
-   * This provides access to the complete execution history, showing how the agent
-   * progressed through multiple iterations to reach the final result. Useful for
-   * debugging, logging, or understanding the agent's reasoning process.
-   *
-   * @returns Array of all iterations in execution order
-   * @example
-   * ```typescript
-   * const result = await execute({ ... })
-   *
-   * // Analyze the full execution flow
-   * result.iterations.forEach((iteration, index) => {
-   *   console.log(`Iteration ${index + 1}:`)
-   *   console.log('  Status:', iteration.status.type)
-   *   console.log('  Code length:', iteration.code?.length || 0)
-   *   console.log('  Tool calls:', iteration.toolCalls.length)
-   *   console.log('  Variables:', Object.keys(iteration.variables).length)
-   * })
-   *
-   * // Find iterations with specific characteristics
-   * const iterationsWithErrors = result.iterations.filter(
-   *   iter => iter.status.type === 'execution_error'
-   * )
-   *
-   * // Calculate total execution time
-   * const totalTime = result.iterations.reduce(
-   *   (sum, iter) => sum + (iter.duration || 0), 0
-   * )
-   * ```
-   */
-  get iterations() {
-    return _nullishCoalesce(this.context.iterations, () => ( []));
-  }
-  /**
-   * Gets the total token usage of the execution, aggregated across all iterations.
-   *
-   * `input`/`output` are the provider-reported token counts of every LLM call made
-   * during the execution. Per-iteration detail (including the measured context size
-   * breakdown by prompt part) is available on each iteration's `tokens` property.
-   *
-   * @example
-   * ```typescript
-   * const result = await execute({ ... })
-   * console.log(`Execution used ${result.tokens.total} tokens`)
-   *
-   * for (const iteration of result.iterations) {
-   *   console.log(iteration.id, iteration.tokens?.context)
-   * }
-   * ```
-   */
-  get tokens() {
-    var _a, _b;
-    let input = 0;
-    let output = 0;
-    for (const iteration of this.iterations) {
-      input += _nullishCoalesce(((_a = iteration.tokens) == null ? void 0 : _a.input), () => ( 0));
-      output += _nullishCoalesce(((_b = iteration.tokens) == null ? void 0 : _b.output), () => ( 0));
-    }
-    return { input, output, total: input + output };
-  }
-};
-var SuccessExecutionResult = class extends ExecutionResult {
-  
-  constructor(context, result) {
-    super("success", context);
-    this.result = result;
-  }
-  /**
-   * Gets the typed output data from the successful execution.
-   *
-   * This overrides the base class output property to provide proper typing
-   * based on the exit schema. The output is guaranteed to match the schema
-   * of the exit that was triggered.
-   *
-   * @returns The typed output data
-   */
-  get output() {
-    return this.result.result;
-  }
-  /**
-   * Gets the final iteration from the successful execution.
-   *
-   * For successful executions, there is always at least one iteration,
-   * so this method returns the guaranteed non-null final iteration.
-   *
-   * @returns The final iteration (guaranteed to exist)
-   */
-  get iteration() {
-    return this.context.iterations.at(-1);
-  }
-  /**
-   * Serializes the execution result to JSON.
-   *
-   * This method converts the execution result into a JSON format that includes
-   * the execution status, context, and exit information. It is used for serialization
-   * and transmission of the execution result.
-   *
-   * @returns The JSON representation of the execution result.
-   */
-  toJSON() {
-    return {
-      status: "success",
-      context: this.context.toJSON(),
-      result: {
-        exit: this.result.exit.toJSON(),
-        result: this.result.result
-      }
-    };
-  }
-};
-var ErrorExecutionResult = class extends ExecutionResult {
-  
-  constructor(context, error) {
-    super("error", context);
-    this.error = error;
-  }
-  /**
-   * Gets the output data (always null for error results).
-   *
-   * @returns Always null since error executions don't produce output
-   */
-  get output() {
-    return null;
-  }
-  toJSON() {
-    return {
-      status: "error",
-      context: this.context.toJSON(),
-      error: this.error
-    };
-  }
-};
-var PartialExecutionResult = class extends ExecutionResult {
-  
-  
-  constructor(context, signal, snapshot) {
-    super("interrupted", context);
-    this.signal = signal;
-    this.snapshot = snapshot;
-  }
-  /**
-   * Gets the output data (always null for interrupted results).
-   *
-   * @returns Always null since interrupted executions don't produce final output
-   */
-  get output() {
-    return null;
-  }
-  /**
-   * Serializes the execution result to JSON.
-   *
-   * @returns The JSON representation of the execution result.
-   */
-  toJSON() {
-    return {
-      status: "interrupted",
-      context: this.context.toJSON(),
-      snapshot: this.snapshot.toJSON(),
-      signal: {
-        message: this.signal.message,
-        truncatedCode: this.signal.truncatedCode,
-        variables: this.signal.variables
-      }
-    };
-  }
-};
-
-// src/getter.ts
-var getValue = async (valueOrGetter, ctx) => {
-  if (typeof valueOrGetter === "function") {
-    try {
-      return await valueOrGetter(ctx);
-    } catch (e) {
-      throw new Error(`Error while getting value for ${valueOrGetter}: ${e}`);
-    }
-  } else {
-    return valueOrGetter;
-  }
-};
-
-// src/context.ts
-var _zui = require('@bpinternal/zui');
-
-
-// src/handlers.ts
-var Emitter = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this); }
-  __init() {this._handlers = []}
-  __init2() {this.subscribe = (fn) => {
-    this._handlers.push(fn);
-    return () => {
-      this._handlers = this._handlers.filter((handler) => handler !== fn);
-    };
-  }}
-  emit(event) {
-    this._handlers.forEach((handler) => handler(event));
-  }
-}, _class);
-var HookedArray = class extends Array {
-  #listeners = new Emitter();
-  constructor(...items) {
-    super(...items);
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-  push(...items) {
-    try {
-      this.#listeners.emit(items);
-    } finally {
-      return super.push(...items);
-    }
-  }
-  onPush(fn) {
-    return this.#listeners.subscribe(fn);
-  }
-};
-
-// src/context.ts
-var ThinkExit = new (0, _chunkDDSJTR6Qcjs.Exit)({
-  name: "think",
-  description: "Think about the current situation and provide a response"
-});
-var ListenExit = new (0, _chunkDDSJTR6Qcjs.Exit)({
-  name: "listen",
-  description: "Listen to the user and provide a response"
-});
-var DefaultExit = new (0, _chunkDDSJTR6Qcjs.Exit)({
-  name: "done",
-  description: "When the execution is sucessfully completed or when error recovery is not possible",
-  schema: _zui.z.discriminatedUnion("success", [
-    _zui.z.object({
-      success: _zui.z.literal(true),
-      result: _zui.z.any().describe("The result of the execution")
-    }),
-    _zui.z.object({
-      success: _zui.z.literal(false),
-      error: _zui.z.string().describe("The error message if the execution failed")
-    })
-  ])
-});
-var Iteration = class {
-  
-  
-  
-  /** Messages (`■send` blocks) parsed from the assistant response, in order. */
-  
-  /** The `■next` exit parsed from the assistant response, if any. */
-  
-  
-  
-  /**
-   * Token usage of this iteration's LLM call. The `context` breakdown is measured
-   * when the prompt is assembled; `input`/`output` are filled in once the LLM call
-   * completes, from the provider-reported usage.
-   */
-  
-  
-  
-  
-  
-  get mutations() {
-    return [...this._mutations.values()];
-  }
-  trackMutation(mutation) {
-    this._mutations.set(`${_nullishCoalesce(mutation.object, () => ( "global"))}:${mutation.property}`, mutation);
-  }
-  
-  get transcript() {
-    return this._parameters.transcript;
-  }
-  get tools() {
-    return this._parameters.tools;
-  }
-  get objects() {
-    return this._parameters.objects;
-  }
-  get model() {
-    return this._parameters.model;
-  }
-  set model(value) {
-    this._parameters.model = value;
-  }
-  get temperature() {
-    return this._parameters.temperature;
-  }
-  get reasoningEffort() {
-    return this._parameters.reasoningEffort;
-  }
-  get exits() {
-    const exits = [...this._parameters.exits];
-    if (this.isChatEnabled) {
-      exits.push(ListenExit);
-    }
-    return exits;
-  }
-  get instructions() {
-    return this._parameters.instructions;
-  }
-  
-  hasExited() {
-    return ["exit_success"].includes(this.status.type);
-  }
-  hasExitedWith(exit) {
-    return this.status.type === "exit_success" && this.status.exit_success.exit_name === exit.name;
-  }
-  isSuccessful() {
-    return ["callback_requested", "exit_success", "thinking_requested"].includes(
-      this.status.type
-    );
-  }
-  isFailed() {
-    return [
-      "generation_error",
-      "invalid_code_error",
-      "execution_error",
-      "exit_error",
-      "aborted"
-    ].includes(this.status.type);
-  }
-  get duration() {
-    const ms = (_nullishCoalesce(this.ended_ts, () => ( Date.now()))) - this.started_ts;
-    const trailing = this.ended_ts ? "" : " (still running)";
-    return ms.toLocaleString("en-US", { style: "unit", unit: "millisecond" }) + trailing;
-  }
-  get error() {
-    if (this.status.type === "generation_error") {
-      return `CodeGenerationError: ${this.status.generation_error.message}`;
-    }
-    if (this.status.type === "invalid_code_error") {
-      return `InvalidCodeError: ${this.status.invalid_code_error.message}`;
-    }
-    if (this.status.type === "execution_error") {
-      return `CodeExecutionError: ${this.status.execution_error.message}`;
-    }
-    if (this.status.type === "exit_error") {
-      return `ExitError: ${this.status.exit_error.message}`;
-    }
-    if (this.status.type === "aborted") {
-      return `Aborted: ${this.status.aborted.reason}`;
-    }
-    return null;
-  }
-  get isChatEnabled() {
-    return this._parameters.components.length > 0;
-  }
-  constructor(props) {
-    this.id = props.id;
-    this.status = { type: "pending" };
-    this.traces = new HookedArray();
-    this._mutations = /* @__PURE__ */ new Map();
-    this.messages = props.messages;
-    this.variables = props.variables;
-    this._parameters = props.parameters;
-    this.started_ts = Date.now();
-  }
-  end(status) {
-    if (this.status.type !== "pending") {
-      throw new Error(`Iteration ${this.id} has already ended with status ${this.status.type}`);
-    }
-    this.ended_ts = Date.now();
-    this.status = status;
-  }
-  toJSON() {
-    return {
-      id: this.id,
-      messages: [...this.messages],
-      code: this.code,
-      model: this.model,
-      temperature: this.temperature,
-      reasoningEffort: this.reasoningEffort,
-      traces: [...this.traces],
-      variables: this.variables,
-      started_ts: this.started_ts,
-      ended_ts: this.ended_ts,
-      status: this.status,
-      mutations: [...this._mutations.values()],
-      llm: this.llm,
-      tokens: this.tokens,
-      transcript: [...this._parameters.transcript],
-      tools: this._parameters.tools.map((tool) => tool.toJSON()),
-      objects: this._parameters.objects.map((obj) => obj.toJSON()),
-      exits: this._parameters.exits.map((exit) => exit.toJSON()),
-      instructions: this._parameters.instructions,
-      duration: this.duration,
-      error: this.error,
-      isChatEnabled: this.isChatEnabled
-    };
-  }
-};
-var Context = (_class2 = class {
-  
-  
-  
-  
-  
-  
-  
-  
-  
-  __init3() {this.version = _chunkKTDBAJBBcjs.DualModePrompt}
-  __init4() {this.timeout = 6e4}
-  // Default timeout of 60 seconds
-  
-  /**
-   * Optional cap on the model's context window. The effective limit is
-   * `min(maxTokens, model's max input tokens)`.
-   */
-  
-  /**
-   * Maximum time to wait for the first streamed token, in milliseconds,
-   * before the cognitive service falls back to the next model/provider.
-   */
-  
-  /**
-   * STT model used by the cognitive service to transcribe audio attachments
-   * when the target LLM does not support audio natively. Defaults to 'fast'.
-   */
-  
-  
-  
-  __init5() {this.iteration = 0}
-  
-  async nextIteration() {
-    if (this.iterations.length >= this.loop) {
-      throw new (0, _chunkPK72FAKDcjs.LoopExceededError)();
-    }
-    if (this.snapshot && this.snapshot.status.type === "pending") {
-      throw new Error(
-        `Cannot resume execution from a snapshot that is still pending: ${this.snapshot.id}. Please resolve() or reject() it first.`
-      );
-    }
-    const parameters = await this._refreshIterationParameters();
-    const { messages, parts } = await this._getIterationMessages(parameters);
-    const contextTokens = this._measureContextTokens(messages, parts);
-    const iteration = new Iteration({
-      id: `${this.id}_${this.iterations.length + 1}`,
-      variables: this._getIterationVariables(),
-      parameters,
-      messages
-    });
-    iteration.tokens = { input: 0, output: 0, total: 0, context: contextTokens };
-    this.iterations.push(iteration);
-    this.iteration = this.iterations.length;
-    this.snapshot = void 0;
-    return iteration;
-  }
-  _getIterationVariables() {
-    var _a;
-    const lastIteration = this.iterations.at(-1);
-    const variables = {};
-    if ((lastIteration == null ? void 0 : lastIteration.status.type) === "thinking_requested") {
-      const lastThinkingVariables = lastIteration.status.thinking_requested.variables;
-      if (_chunkHC2QZTVTcjs.isPlainObject_default.call(void 0, lastThinkingVariables)) {
-        Object.assign(variables, _chunkHC2QZTVTcjs.cloneDeep_default.call(void 0, lastThinkingVariables));
-      }
-    }
-    if (_chunkHC2QZTVTcjs.isPlainObject_default.call(void 0, lastIteration == null ? void 0 : lastIteration.variables)) {
-      Object.assign(variables, _chunkHC2QZTVTcjs.cloneDeep_default.call(void 0, _nullishCoalesce((lastIteration == null ? void 0 : lastIteration.variables), () => ( {}))));
-    }
-    if (((_a = this.snapshot) == null ? void 0 : _a.status.type) === "resolved") {
-      for (const v of this.snapshot.variables) {
-        if (!v.truncated && v.value !== void 0) {
-          variables[v.name] = v.value;
-        }
-      }
-    }
-    return variables;
-  }
-  /**
-   * Measures the token size of each part of the prompt (pre-truncation).
-   * The named parts come from the system prompt; everything else in the system
-   * message is `framework`. Non-system messages count towards `iterations`,
-   * except the very first user message of a fresh execution (task recap),
-   * which is prompt scaffolding.
-   */
-  _measureContextTokens(messages, parts) {
-    const tokenizer = _chunkGOWPACSKcjs.getTokenizer.call(void 0, );
-    const countText = (text) => (text == null ? void 0 : text.length) ? tokenizer.count(_chunkHEAQAEFZcjs.stripTruncationTags.call(void 0, text)) : 0;
-    const countMessage = (message) => {
-      if (typeof message.content === "string") {
-        return countText(message.content);
-      }
-      if (Array.isArray(message.content)) {
-        return message.content.reduce((acc, part) => acc + (part.type === "text" ? countText(part.text) : 0), 0);
-      }
-      return 0;
-    };
-    const instructions = countText(parts.instructions);
-    const tools = countText(parts.tools);
-    const transcript = countText(parts.transcript);
-    const protocol = countText(parts.protocol);
-    const systemTokens = messages.filter((x) => x.role === "system").reduce((acc, x) => acc + countMessage(x), 0);
-    const otherTokens = messages.filter((x) => x.role !== "system").reduce((acc, x) => acc + countMessage(x), 0);
-    const isFirstIteration = this.iterations.length === 0 && !this.snapshot;
-    const framework = Math.max(0, systemTokens - (instructions + tools + transcript + protocol));
-    const iterations = isFirstIteration ? 0 : otherTokens;
-    return {
-      total: framework + instructions + tools + transcript + protocol + iterations + (isFirstIteration ? otherTokens : 0),
-      framework: framework + (isFirstIteration ? otherTokens : 0),
-      instructions,
-      tools,
-      transcript,
-      protocol,
-      iterations
-    };
-  }
-  async _getIterationMessages(parameters) {
-    var _a, _b, _c, _d, _e, _f;
-    const lastIteration = this.iterations.at(-1);
-    const promptProps = {
-      globalTools: parameters.tools,
-      objects: parameters.objects,
-      instructions: parameters.instructions,
-      transcript: parameters.transcript,
-      // ListenExit is protocol-level in chat mode: it must be documented alongside user-defined exits
-      exits: parameters.components.length ? [...parameters.exits, ListenExit] : parameters.exits,
-      components: parameters.components
-    };
-    const { message: systemMessage, parts } = await this.version.getSystemMessage(promptProps);
-    const withParts = (messages) => ({ messages, parts });
-    if (((_a = this.snapshot) == null ? void 0 : _a.status.type) === "resolved") {
-      return withParts([
-        systemMessage,
-        this.version.getSnapshotResolvedMessage({
-          snapshot: this.snapshot
-        })
-      ]);
-    }
-    if (((_b = this.snapshot) == null ? void 0 : _b.status.type) === "rejected") {
-      return withParts([
-        systemMessage,
-        this.version.getSnapshotRejectedMessage({
-          snapshot: this.snapshot
-        })
-      ]);
-    }
-    if (!lastIteration) {
-      return withParts([systemMessage, await this.version.getInitialUserMessage(promptProps)]);
-    }
-    const lastIterationMessages = [systemMessage, ...lastIteration.messages.filter((x) => x.role !== "system")];
-    if ((lastIteration == null ? void 0 : lastIteration.status.type) === "thinking_requested") {
-      return withParts([
-        ...lastIterationMessages,
-        {
-          role: "assistant",
-          content: _chunkHEAQAEFZcjs.wrapContent.call(void 0, _nullishCoalesce(((_c = lastIteration.llm) == null ? void 0 : _c.output), () => ( "")), { preserve: "top", flex: 4, minTokens: 25 })
-        },
-        await this.version.getThinkingMessage({
-          reason: lastIteration.status.thinking_requested.reason,
-          variables: lastIteration.status.thinking_requested.variables
-        })
-      ]);
-    }
-    if ((lastIteration == null ? void 0 : lastIteration.status.type) === "exit_error") {
-      return withParts([
-        ...lastIterationMessages,
-        {
-          role: "assistant",
-          content: _chunkHEAQAEFZcjs.wrapContent.call(void 0, _nullishCoalesce(((_d = lastIteration.llm) == null ? void 0 : _d.output), () => ( "")), { preserve: "top", flex: 4, minTokens: 25 })
-        },
-        await this.version.getInvalidCodeMessage({
-          code: _nullishCoalesce(lastIteration.code, () => ( "// No code generated")),
-          message: `Invalid return statement (action: ${lastIteration.status.exit_error.exit}): ${lastIteration.status.exit_error.message}`
-        })
-      ]);
-    }
-    if ((lastIteration == null ? void 0 : lastIteration.status.type) === "invalid_code_error") {
-      return withParts([
-        ...lastIterationMessages,
-        {
-          role: "assistant",
-          content: _chunkHEAQAEFZcjs.wrapContent.call(void 0, _nullishCoalesce(((_e = lastIteration.llm) == null ? void 0 : _e.output), () => ( "")), { preserve: "top", flex: 4, minTokens: 25 })
-        },
-        await this.version.getInvalidCodeMessage({
-          code: _nullishCoalesce(lastIteration.code, () => ( "// No code generated")),
-          message: lastIteration.status.invalid_code_error.message
-        })
-      ]);
-    }
-    if ((lastIteration == null ? void 0 : lastIteration.status.type) === "execution_error") {
-      return withParts([
-        ...lastIterationMessages,
-        {
-          role: "assistant",
-          content: _chunkHEAQAEFZcjs.wrapContent.call(void 0, _nullishCoalesce(((_f = lastIteration.llm) == null ? void 0 : _f.output), () => ( "")), { preserve: "top", flex: 4, minTokens: 25 })
-        },
-        await this.version.getCodeExecutionErrorMessage({
-          message: lastIteration.status.execution_error.message,
-          stacktrace: lastIteration.status.execution_error.stack
-        })
-      ]);
-    }
-    throw new Error(
-      `Unexpected iteration status: ${lastIteration == null ? void 0 : lastIteration.status.type}. This is likely a bug, please report it.`
-    );
-  }
-  async _refreshIterationParameters() {
-    var _a, _b;
-    const instructions = await getValue(this.instructions, this);
-    const transcript = new TranscriptArray(await getValue(_nullishCoalesce(((_a = this.chat) == null ? void 0 : _a.transcript), () => ( [])), this));
-    const tools = _chunkPZE6PIPGcjs.Tool.withUniqueNames(await _asyncNullishCoalesce(await getValue(this.tools, this), async () => ( [])));
-    const objects = await _asyncNullishCoalesce(await getValue(this.objects, this), async () => ( []));
-    const exits = await _asyncNullishCoalesce(await getValue(this.exits, this), async () => ( []));
-    const components = await getValue(_nullishCoalesce(((_b = this.chat) == null ? void 0 : _b.components), () => ( [])), this);
-    const model = await _asyncNullishCoalesce(await getValue(this.model, this), async () => ( "best"));
-    const temperature = await getValue(this.temperature, this);
-    const reasoningEffort = await getValue(this.reasoningEffort, this);
-    if (objects && objects.length > 100) {
-      throw new Error("Too many objects. Expected at most 100 objects.");
-    }
-    if (tools && tools.length > 100) {
-      throw new Error("Too many tools. Expected at most 100 tools.");
-    }
-    for (const component of components) {
-      _chunkI56MPOVGcjs.assertValidComponent.call(void 0, component.definition);
-    }
-    const ReservedToolNames = [
-      "think",
-      "listen",
-      "return",
-      "exit",
-      "action",
-      "function",
-      "callback",
-      "code",
-      "execute",
-      "jsx",
-      "object",
-      "string",
-      "number",
-      "boolean",
-      "array"
-    ];
-    for (const tool of tools) {
-      for (let name of [...tool.aliases, tool.name]) {
-        name = name.toLowerCase();
-        if (ReservedToolNames.includes(name)) {
-          throw new Error(`Tool name "${name}" (${tool.name}) is reserved. Please choose a different name.`);
-        }
-        if (components.find(
-          (x) => {
-            var _a2;
-            return x.definition.name.toLowerCase() === name || ((_a2 = x.definition.aliases) == null ? void 0 : _a2.map((x2) => x2.toLowerCase()).includes(name));
-          }
-        )) {
-          throw new Error(
-            `Tool name "${name}" (${tool.name}) is already used by a component. Please choose a different name.`
-          );
-        }
-        if (exits.find((x) => x.name.toLowerCase() === name) || exits.find((x) => {
-          var _a2;
-          return (_a2 = x.aliases) == null ? void 0 : _a2.map((x2) => x2.toLowerCase()).includes(name);
-        })) {
-          throw new Error(
-            `Tool name "${name}" (${tool.name}) is already used by an exit. Please choose a different name.`
-          );
-        }
-      }
-    }
-    if (exits && exits.length > 100) {
-      throw new Error("Too many exits. Expected at most 100 exits.");
-    }
-    if (components && components.length > 100) {
-      throw new Error("Too many components. Expected at most 100 components.");
-    }
-    if (instructions && instructions.length > 1e6) {
-      throw new Error("Instructions are too long. Expected at most 1,000,000 characters.");
-    }
-    if (transcript && transcript.length > 250) {
-      throw new Error("Too many transcript messages. Expected at most 250 messages.");
-    }
-    if (!components.length && !exits.length) {
-      exits.push(DefaultExit);
-    }
-    if (typeof temperature !== "number" || isNaN(temperature) || temperature < 0 || temperature > 2) {
-      throw new Error("Invalid temperature. Expected a number between 0 and 2.");
-    }
-    const isValidModel = (m) => typeof m === "string" && (m === "best" || m === "fast" || m === "auto" || m.includes(":"));
-    if (Array.isArray(model)) {
-      if (model.length === 0 || !model.every(isValidModel)) {
-        throw new Error(
-          "Invalid model. Expected a non-empty array of model strings ('best'/'fast'/'auto' or 'provider:model')."
-        );
-      }
-    } else if (!isValidModel(model)) {
-      throw new Error("Invalid model. Expected 'best'/'fast'/'auto' or 'provider:model'.");
-    }
-    return {
-      transcript,
-      tools,
-      objects,
-      exits,
-      instructions,
-      components,
-      model,
-      temperature,
-      reasoningEffort
-    };
-  }
-  constructor(props) {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);
-    this.id = `llmz_${_ulid.ulid.call(void 0, )}`;
-    this.instructions = props.instructions;
-    this.objects = props.objects;
-    this.tools = props.tools;
-    this.exits = props.exits;
-    this.chat = props.chat;
-    this.timeout = Math.min(999999999, Math.max(0, _nullishCoalesce(props.timeout, () => ( 6e4))));
-    this.loop = _nullishCoalesce(props.loop, () => ( 3));
-    this.temperature = _nullishCoalesce(props.temperature, () => ( 0.7));
-    this.reasoningEffort = props.reasoningEffort;
-    this.model = _nullishCoalesce(props.model, () => ( "best"));
-    this.iterations = [];
-    this.metadata = _nullishCoalesce(props.metadata, () => ( {}));
-    this.snapshot = props.snapshot;
-    this.maxTokens = props.maxTokens;
-    this.maxTimeToFirstToken = props.maxTimeToFirstToken;
-    this.transcriptionModel = props.transcriptionModel;
-    if (this.loop < 1 || this.loop > 100) {
-      throw new Error("Invalid loop. Expected a number between 1 and 100.");
-    }
-    if (this.maxTokens !== void 0 && (!Number.isFinite(this.maxTokens) || this.maxTokens < 1)) {
-      throw new Error("Invalid maxTokens. Expected a positive number.");
-    }
-    if (this.maxTimeToFirstToken !== void 0 && (!Number.isFinite(this.maxTimeToFirstToken) || this.maxTimeToFirstToken < 1)) {
-      throw new Error("Invalid maxTimeToFirstToken. Expected a positive number of milliseconds.");
-    }
-  }
-  toJSON() {
-    var _a;
-    return {
-      id: this.id,
-      iterations: this.iterations.map((iteration) => iteration.toJSON()),
-      iteration: this.iteration,
-      timeout: this.timeout,
-      loop: this.loop,
-      metadata: this.metadata,
-      snapshot: (_a = this.snapshot) == null ? void 0 : _a.toJSON()
-    };
-  }
-}, _class2);
-
-// src/custom-client.ts
-var _CustomModelClient = (_class3 = class __CustomModelClient {constructor() { _class3.prototype.__init6.call(this); }
-  __init6() {this["$$COGNITIVE"] = "runtime"}
-  static isCustomClient(obj) {
-    return obj instanceof __CustomModelClient || (obj == null ? void 0 : obj["$$COGNITIVE"]) === "runtime";
-  }
-}, _class3);
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.parseExit = parseExit; exports.Snapshot = Snapshot; exports.ExecutionResult = ExecutionResult; exports.SuccessExecutionResult = SuccessExecutionResult; exports.ErrorExecutionResult = ErrorExecutionResult; exports.PartialExecutionResult = PartialExecutionResult; exports.getValue = getValue; exports.ThinkExit = ThinkExit; exports.ListenExit = ListenExit; exports.DefaultExit = DefaultExit; exports.Context = Context; exports._CustomModelClient = _CustomModelClient;