@statelyai/agent 0.0.8 → 0.1.0

package/dist/index.js

@@ -20,55 +20,36 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  agentDecide: () => agentDecide,
+  agentGenerateText: () => agentGenerateText,
   createAgent: () => createAgent,
-  createOpenAIAdapter: () => createOpenAIAdapter,
-  defineEvents: () => defineEvents
+  fromDecision: () => fromDecision,
+  fromText: () => fromText,
+  fromTextStream: () => fromTextStream
 });
 module.exports = __toCommonJS(src_exports);
 
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/errorMessages.js
-function addErrorMessage(res, key, errorMessage, refs) {
-  if (!refs?.errorMessages)
-    return;
-  if (errorMessage) {
-    res.errorMessage = {
-      ...res.errorMessage,
-      [key]: errorMessage
-    };
-  }
+// src/agent.ts
+var import_xstate3 = require("xstate");
+
+// src/planners/simplePlanner.ts
+var import_ai = require("ai");
+
+// src/utils.ts
+function getAllTransitions(state) {
+  const nodes = state._nodes;
+  const transitions = nodes.map((node) => [...node.transitions.values()]).flat(2).map((transition) => ({
+    ...transition,
+    guard: typeof transition.guard === "string" ? { type: transition.guard } : transition.guard
+    // TODO: fix
+  }));
+  return transitions;
 }
-function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
-  res[key] = value;
-  addErrorMessage(res, key, errorMessage, refs);
+function wrapInXml(tagName, content) {
+  return `<${tagName}>${content}</${tagName}>`;
 }
 
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/Options.js
-var defaultOptions = {
-  name: void 0,
-  $refStrategy: "root",
-  basePath: ["#"],
-  effectStrategy: "input",
-  pipeStrategy: "all",
-  dateStrategy: "string",
-  mapStrategy: "entries",
-  definitionPath: "definitions",
-  target: "jsonSchema7",
-  strictUnions: false,
-  definitions: {},
-  errorMessages: false,
-  markdownDescription: false,
-  patternStrategy: "escape",
-  emailStrategy: "format:email"
-};
-var getDefaultOptions = (options) => typeof options === "string" ? {
-  ...defaultOptions,
-  name: options
-} : {
-  ...defaultOptions,
-  ...options
-};
-
-// node_modules/.pnpm/zod@3.22.4/node_modules/zod/lib/index.mjs
+// node_modules/.pnpm/zod@3.23.8/node_modules/zod/lib/index.mjs
 var util;
 (function(util2) {
   util2.assertEqual = (val) => val;
@@ -222,7 +203,7 @@ var quotelessJson = (obj) => {
   const json = JSON.stringify(obj, null, 2);
   return json.replace(/"([^"]+)":/g, "$1:");
 };
-var ZodError = class extends Error {
+var ZodError = class _ZodError extends Error {
   constructor(issues) {
     super();
     this.issues = [];
@@ -280,6 +261,11 @@ var ZodError = class extends Error {
     processError(this);
     return fieldErrors;
   }
+  static assert(value) {
+    if (!(value instanceof _ZodError)) {
+      throw new Error(`Not a ZodError: ${value}`);
+    }
+  }
   toString() {
     return this.message;
   }
@@ -422,6 +408,13 @@ var makeIssue = (params) => {
     ...issueData,
     path: fullPath
   };
+  if (issueData.message !== void 0) {
+    return {
+      ...issueData,
+      path: fullPath,
+      message: issueData.message
+    };
+  }
   let errorMessage = "";
   const maps = errorMaps.filter((m) => !!m).slice().reverse();
   for (const map of maps) {
@@ -430,11 +423,12 @@ var makeIssue = (params) => {
   return {
     ...issueData,
     path: fullPath,
-    message: issueData.message || errorMessage
+    message: errorMessage
   };
 };
 var EMPTY_PATH = [];
 function addIssueToContext(ctx, issueData) {
+  const overrideMap = getErrorMap();
   const issue = makeIssue({
     issueData,
     data: ctx.data,
@@ -442,8 +436,8 @@ function addIssueToContext(ctx, issueData) {
     errorMaps: [
       ctx.common.contextualErrorMap,
       ctx.schemaErrorMap,
-      getErrorMap(),
-      errorMap
+      overrideMap,
+      overrideMap === errorMap ? void 0 : errorMap
       // then global default map
     ].filter((x) => !!x)
   });
@@ -475,9 +469,11 @@ var ParseStatus = class _ParseStatus {
   static async mergeObjectAsync(status, pairs) {
     const syncPairs = [];
     for (const pair of pairs) {
+      const key = await pair.key;
+      const value = await pair.value;
       syncPairs.push({
-        key: await pair.key,
-        value: await pair.value
+        key,
+        value
       });
     }
     return _ParseStatus.mergeObjectSync(status, syncPairs);
@@ -510,11 +506,24 @@ var isAborted = (x) => x.status === "aborted";
 var isDirty = (x) => x.status === "dirty";
 var isValid = (x) => x.status === "valid";
 var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
+function __classPrivateFieldGet(receiver, state, kind, f) {
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+  if (kind === "m") throw new TypeError("Private method is not writable");
+  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+  return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+}
 var errorUtil;
 (function(errorUtil2) {
   errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
   errorUtil2.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
 })(errorUtil || (errorUtil = {}));
+var _ZodEnum_cache;
+var _ZodNativeEnum_cache;
 var ParseInputLazyPath = class {
   constructor(parent, value, path, key) {
     this._cachedPath = [];
@@ -563,12 +572,17 @@ function processCreateParams(params) {
   if (errorMap2)
     return { errorMap: errorMap2, description };
   const customMap = (iss, ctx) => {
-    if (iss.code !== "invalid_type")
-      return { message: ctx.defaultError };
+    var _a, _b;
+    const { message } = params;
+    if (iss.code === "invalid_enum_value") {
+      return { message: message !== null && message !== void 0 ? message : ctx.defaultError };
+    }
     if (typeof ctx.data === "undefined") {
-      return { message: required_error !== null && required_error !== void 0 ? required_error : ctx.defaultError };
+      return { message: (_a = message !== null && message !== void 0 ? message : required_error) !== null && _a !== void 0 ? _a : ctx.defaultError };
     }
-    return { message: invalid_type_error !== null && invalid_type_error !== void 0 ? invalid_type_error : ctx.defaultError };
+    if (iss.code !== "invalid_type")
+      return { message: ctx.defaultError };
+    return { message: (_b = message !== null && message !== void 0 ? message : invalid_type_error) !== null && _b !== void 0 ? _b : ctx.defaultError };
   };
   return { errorMap: customMap, description };
 }
@@ -816,35 +830,40 @@ var ZodType = class {
   }
 };
 var cuidRegex = /^c[^\s-]{8,}$/i;
-var cuid2Regex = /^[a-z][a-z0-9]*$/;
+var cuid2Regex = /^[0-9a-z]+$/;
 var ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/;
 var uuidRegex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i;
-var emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_+-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i;
+var nanoidRegex = /^[a-z0-9_-]{21}$/i;
+var durationRegex = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
+var emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i;
 var _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
 var emojiRegex;
-var ipv4Regex = /^(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))$/;
+var ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
 var ipv6Regex = /^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$/;
-var datetimeRegex = (args) => {
+var base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
+var dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
+var dateRegex = new RegExp(`^${dateRegexSource}$`);
+function timeRegexSource(args) {
+  let regex = `([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d`;
   if (args.precision) {
-    if (args.offset) {
-      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{${args.precision}}(([+-]\\d{2}(:?\\d{2})?)|Z)$`);
-    } else {
-      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\.\\d{${args.precision}}Z$`);
-    }
-  } else if (args.precision === 0) {
-    if (args.offset) {
-      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(([+-]\\d{2}(:?\\d{2})?)|Z)$`);
-    } else {
-      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}Z$`);
-    }
-  } else {
-    if (args.offset) {
-      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(([+-]\\d{2}(:?\\d{2})?)|Z)$`);
-    } else {
-      return new RegExp(`^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?Z$`);
-    }
+    regex = `${regex}\\.\\d{${args.precision}}`;
+  } else if (args.precision == null) {
+    regex = `${regex}(\\.\\d+)?`;
   }
-};
+  return regex;
+}
+function timeRegex(args) {
+  return new RegExp(`^${timeRegexSource(args)}$`);
+}
+function datetimeRegex(args) {
+  let regex = `${dateRegexSource}T${timeRegexSource(args)}`;
+  const opts = [];
+  opts.push(args.local ? `Z?` : `Z`);
+  if (args.offset)
+    opts.push(`([+-]\\d{2}:?\\d{2})`);
+  regex = `${regex}(${opts.join("|")})`;
+  return new RegExp(`^${regex}$`);
+}
 function isValidIP(ip, version) {
   if ((version === "v4" || !version) && ipv4Regex.test(ip)) {
     return true;
@@ -862,15 +881,11 @@ var ZodString = class _ZodString extends ZodType {
     const parsedType = this._getType(input);
     if (parsedType !== ZodParsedType.string) {
       const ctx2 = this._getOrReturnCtx(input);
-      addIssueToContext(
-        ctx2,
-        {
-          code: ZodIssueCode.invalid_type,
-          expected: ZodParsedType.string,
-          received: ctx2.parsedType
-        }
-        //
-      );
+      addIssueToContext(ctx2, {
+        code: ZodIssueCode.invalid_type,
+        expected: ZodParsedType.string,
+        received: ctx2.parsedType
+      });
       return INVALID;
     }
     const status = new ParseStatus();
@@ -961,6 +976,16 @@ var ZodString = class _ZodString extends ZodType {
           });
           status.dirty();
         }
+      } else if (check.kind === "nanoid") {
+        if (!nanoidRegex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            validation: "nanoid",
+            code: ZodIssueCode.invalid_string,
+            message: check.message
+          });
+          status.dirty();
+        }
       } else if (check.kind === "cuid") {
         if (!cuidRegex.test(input.data)) {
           ctx = this._getOrReturnCtx(input, ctx);
@@ -1062,6 +1087,38 @@ var ZodString = class _ZodString extends ZodType {
           });
           status.dirty();
         }
+      } else if (check.kind === "date") {
+        const regex = dateRegex;
+        if (!regex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_string,
+            validation: "date",
+            message: check.message
+          });
+          status.dirty();
+        }
+      } else if (check.kind === "time") {
+        const regex = timeRegex(check);
+        if (!regex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            code: ZodIssueCode.invalid_string,
+            validation: "time",
+            message: check.message
+          });
+          status.dirty();
+        }
+      } else if (check.kind === "duration") {
+        if (!durationRegex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            validation: "duration",
+            code: ZodIssueCode.invalid_string,
+            message: check.message
+          });
+          status.dirty();
+        }
       } else if (check.kind === "ip") {
         if (!isValidIP(input.data, check.version)) {
           ctx = this._getOrReturnCtx(input, ctx);
@@ -1072,6 +1129,16 @@ var ZodString = class _ZodString extends ZodType {
           });
           status.dirty();
         }
+      } else if (check.kind === "base64") {
+        if (!base64Regex.test(input.data)) {
+          ctx = this._getOrReturnCtx(input, ctx);
+          addIssueToContext(ctx, {
+            validation: "base64",
+            code: ZodIssueCode.invalid_string,
+            message: check.message
+          });
+          status.dirty();
+        }
       } else {
         util.assertNever(check);
       }
@@ -1103,6 +1170,9 @@ var ZodString = class _ZodString extends ZodType {
   uuid(message) {
     return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message) });
   }
+  nanoid(message) {
+    return this._addCheck({ kind: "nanoid", ...errorUtil.errToObj(message) });
+  }
   cuid(message) {
     return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) });
   }
@@ -1112,16 +1182,20 @@ var ZodString = class _ZodString extends ZodType {
   ulid(message) {
     return this._addCheck({ kind: "ulid", ...errorUtil.errToObj(message) });
   }
+  base64(message) {
+    return this._addCheck({ kind: "base64", ...errorUtil.errToObj(message) });
+  }
   ip(options) {
     return this._addCheck({ kind: "ip", ...errorUtil.errToObj(options) });
   }
   datetime(options) {
-    var _a;
+    var _a, _b;
     if (typeof options === "string") {
       return this._addCheck({
         kind: "datetime",
         precision: null,
         offset: false,
+        local: false,
         message: options
       });
     }
@@ -1129,9 +1203,30 @@ var ZodString = class _ZodString extends ZodType {
       kind: "datetime",
       precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === "undefined" ? null : options === null || options === void 0 ? void 0 : options.precision,
       offset: (_a = options === null || options === void 0 ? void 0 : options.offset) !== null && _a !== void 0 ? _a : false,
+      local: (_b = options === null || options === void 0 ? void 0 : options.local) !== null && _b !== void 0 ? _b : false,
+      ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message)
+    });
+  }
+  date(message) {
+    return this._addCheck({ kind: "date", message });
+  }
+  time(options) {
+    if (typeof options === "string") {
+      return this._addCheck({
+        kind: "time",
+        precision: null,
+        message: options
+      });
+    }
+    return this._addCheck({
+      kind: "time",
+      precision: typeof (options === null || options === void 0 ? void 0 : options.precision) === "undefined" ? null : options === null || options === void 0 ? void 0 : options.precision,
       ...errorUtil.errToObj(options === null || options === void 0 ? void 0 : options.message)
     });
   }
+  duration(message) {
+    return this._addCheck({ kind: "duration", ...errorUtil.errToObj(message) });
+  }
   regex(regex, message) {
     return this._addCheck({
       kind: "regex",
@@ -1210,6 +1305,15 @@ var ZodString = class _ZodString extends ZodType {
   get isDatetime() {
     return !!this._def.checks.find((ch) => ch.kind === "datetime");
   }
+  get isDate() {
+    return !!this._def.checks.find((ch) => ch.kind === "date");
+  }
+  get isTime() {
+    return !!this._def.checks.find((ch) => ch.kind === "time");
+  }
+  get isDuration() {
+    return !!this._def.checks.find((ch) => ch.kind === "duration");
+  }
   get isEmail() {
     return !!this._def.checks.find((ch) => ch.kind === "email");
   }
@@ -1222,6 +1326,9 @@ var ZodString = class _ZodString extends ZodType {
   get isUUID() {
     return !!this._def.checks.find((ch) => ch.kind === "uuid");
   }
+  get isNANOID() {
+    return !!this._def.checks.find((ch) => ch.kind === "nanoid");
+  }
   get isCUID() {
     return !!this._def.checks.find((ch) => ch.kind === "cuid");
   }
@@ -1234,6 +1341,9 @@ var ZodString = class _ZodString extends ZodType {
   get isIP() {
     return !!this._def.checks.find((ch) => ch.kind === "ip");
   }
+  get isBase64() {
+    return !!this._def.checks.find((ch) => ch.kind === "base64");
+  }
   get minLength() {
     let min = null;
     for (const ch of this._def.checks) {
@@ -2123,8 +2233,7 @@ var ZodObject = class _ZodObject extends ZodType {
           });
           status.dirty();
         }
-      } else if (unknownKeys === "strip")
-        ;
+      } else if (unknownKeys === "strip") ;
       else {
         throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
       }
@@ -2147,9 +2256,10 @@ var ZodObject = class _ZodObject extends ZodType {
         const syncPairs = [];
         for (const pair of pairs) {
           const key = await pair.key;
+          const value = await pair.value;
           syncPairs.push({
             key,
-            value: await pair.value,
+            value,
             alwaysSet: pair.alwaysSet
           });
         }
@@ -2500,15 +2610,25 @@ var getDiscriminator = (type) => {
   } else if (type instanceof ZodEnum) {
     return type.options;
   } else if (type instanceof ZodNativeEnum) {
-    return Object.keys(type.enum);
+    return util.objectValues(type.enum);
   } else if (type instanceof ZodDefault) {
     return getDiscriminator(type._def.innerType);
   } else if (type instanceof ZodUndefined) {
     return [void 0];
   } else if (type instanceof ZodNull) {
     return [null];
+  } else if (type instanceof ZodOptional) {
+    return [void 0, ...getDiscriminator(type.unwrap())];
+  } else if (type instanceof ZodNullable) {
+    return [null, ...getDiscriminator(type.unwrap())];
+  } else if (type instanceof ZodBranded) {
+    return getDiscriminator(type.unwrap());
+  } else if (type instanceof ZodReadonly) {
+    return getDiscriminator(type.unwrap());
+  } else if (type instanceof ZodCatch) {
+    return getDiscriminator(type._def.innerType);
   } else {
-    return null;
+    return [];
   }
 };
 var ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType {
@@ -2568,7 +2688,7 @@ var ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType {
     const optionsMap = /* @__PURE__ */ new Map();
     for (const type of options) {
       const discriminatorValues = getDiscriminator(type.shape[discriminator]);
-      if (!discriminatorValues) {
+      if (!discriminatorValues.length) {
         throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
       }
       for (const value of discriminatorValues) {
@@ -2768,7 +2888,8 @@ var ZodRecord = class _ZodRecord extends ZodType {
     for (const key in ctx.data) {
       pairs.push({
         key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
-        value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key))
+        value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
+        alwaysSet: key in ctx.data
       });
     }
     if (ctx.common.async) {
@@ -3112,6 +3233,10 @@ function createZodEnum(values, params) {
   });
 }
 var ZodEnum = class _ZodEnum extends ZodType {
+  constructor() {
+    super(...arguments);
+    _ZodEnum_cache.set(this, void 0);
+  }
   _parse(input) {
     if (typeof input.data !== "string") {
       const ctx = this._getOrReturnCtx(input);
@@ -3123,7 +3248,10 @@ var ZodEnum = class _ZodEnum extends ZodType {
       });
       return INVALID;
     }
-    if (this._def.values.indexOf(input.data) === -1) {
+    if (!__classPrivateFieldGet(this, _ZodEnum_cache, "f")) {
+      __classPrivateFieldSet(this, _ZodEnum_cache, new Set(this._def.values), "f");
+    }
+    if (!__classPrivateFieldGet(this, _ZodEnum_cache, "f").has(input.data)) {
       const ctx = this._getOrReturnCtx(input);
       const expectedValues = this._def.values;
       addIssueToContext(ctx, {
@@ -3159,15 +3287,26 @@ var ZodEnum = class _ZodEnum extends ZodType {
     }
     return enumValues;
   }
-  extract(values) {
-    return _ZodEnum.create(values);
+  extract(values, newDef = this._def) {
+    return _ZodEnum.create(values, {
+      ...this._def,
+      ...newDef
+    });
   }
-  exclude(values) {
-    return _ZodEnum.create(this.options.filter((opt) => !values.includes(opt)));
+  exclude(values, newDef = this._def) {
+    return _ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {
+      ...this._def,
+      ...newDef
+    });
   }
 };
+_ZodEnum_cache = /* @__PURE__ */ new WeakMap();
 ZodEnum.create = createZodEnum;
 var ZodNativeEnum = class extends ZodType {
+  constructor() {
+    super(...arguments);
+    _ZodNativeEnum_cache.set(this, void 0);
+  }
   _parse(input) {
     const nativeEnumValues = util.getValidEnumValues(this._def.values);
     const ctx = this._getOrReturnCtx(input);
@@ -3180,7 +3319,10 @@ var ZodNativeEnum = class extends ZodType {
       });
       return INVALID;
     }
-    if (nativeEnumValues.indexOf(input.data) === -1) {
+    if (!__classPrivateFieldGet(this, _ZodNativeEnum_cache, "f")) {
+      __classPrivateFieldSet(this, _ZodNativeEnum_cache, new Set(util.getValidEnumValues(this._def.values)), "f");
+    }
+    if (!__classPrivateFieldGet(this, _ZodNativeEnum_cache, "f").has(input.data)) {
       const expectedValues = util.objectValues(nativeEnumValues);
       addIssueToContext(ctx, {
         received: ctx.data,
@@ -3195,6 +3337,7 @@ var ZodNativeEnum = class extends ZodType {
     return this._def.values;
   }
 };
+_ZodNativeEnum_cache = /* @__PURE__ */ new WeakMap();
 ZodNativeEnum.create = (values, params) => {
   return new ZodNativeEnum({
     values,
@@ -3258,26 +3401,38 @@ var ZodEffects = class extends ZodType {
     checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
     if (effect.type === "preprocess") {
       const processed = effect.transform(ctx.data, checkCtx);
-      if (ctx.common.issues.length) {
-        return {
-          status: "dirty",
-          value: ctx.data
-        };
-      }
       if (ctx.common.async) {
-        return Promise.resolve(processed).then((processed2) => {
-          return this._def.schema._parseAsync({
+        return Promise.resolve(processed).then(async (processed2) => {
+          if (status.value === "aborted")
+            return INVALID;
+          const result = await this._def.schema._parseAsync({
             data: processed2,
             path: ctx.path,
             parent: ctx
           });
+          if (result.status === "aborted")
+            return INVALID;
+          if (result.status === "dirty")
+            return DIRTY(result.value);
+          if (status.value === "dirty")
+            return DIRTY(result.value);
+          return result;
         });
       } else {
-        return this._def.schema._parseSync({
+        if (status.value === "aborted")
+          return INVALID;
+        const result = this._def.schema._parseSync({
           data: processed,
           path: ctx.path,
           parent: ctx
         });
+        if (result.status === "aborted")
+          return INVALID;
+        if (result.status === "dirty")
+          return DIRTY(result.value);
+        if (status.value === "dirty")
+          return DIRTY(result.value);
+        return result;
       }
     }
     if (effect.type === "refinement") {
@@ -3566,10 +3721,16 @@ var ZodPipeline = class _ZodPipeline extends ZodType {
 var ZodReadonly = class extends ZodType {
   _parse(input) {
     const result = this._def.innerType._parse(input);
-    if (isValid(result)) {
-      result.value = Object.freeze(result.value);
-    }
-    return result;
+    const freeze = (data) => {
+      if (isValid(data)) {
+        data.value = Object.freeze(data.value);
+      }
+      return data;
+    };
+    return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
+  }
+  unwrap() {
+    return this._def.innerType;
   }
 };
 ZodReadonly.create = (type, params) => {
@@ -3579,7 +3740,7 @@ ZodReadonly.create = (type, params) => {
     ...processCreateParams(params)
   });
 };
-var custom = (check, params = {}, fatal) => {
+function custom(check, params = {}, fatal) {
   if (check)
     return ZodAny.create().superRefine((data, ctx) => {
       var _a, _b;
@@ -3591,7 +3752,7 @@ var custom = (check, params = {}, fatal) => {
       }
     });
   return ZodAny.create();
-};
+}
 var late = {
   object: ZodObject.lazycreate
 };
@@ -3710,6 +3871,7 @@ var z = /* @__PURE__ */ Object.freeze({
   ZodParsedType,
   getParsedType,
   ZodType,
+  datetimeRegex,
   ZodString,
   ZodNumber,
   ZodBigInt,
@@ -3801,1183 +3963,491 @@ var z = /* @__PURE__ */ Object.freeze({
   ZodError
 });
 
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/any.js
-function parseAnyDef() {
-  return {};
-}
+// src/templates/defaultText.ts
+var defaultTextTemplate = (data) => {
+  const preamble = [
+    data.context ? wrapInXml("context", JSON.stringify(data.context)) : void 0
+  ].filter(Boolean).join("\n");
+  return `
+${preamble}
 
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/array.js
-function parseArrayDef(def, refs) {
-  const res = {
-    type: "array"
-  };
-  if (def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
-    res.items = parseDef(def.type._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "items"]
-    });
-  }
-  if (def.minLength) {
-    setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
-  }
-  if (def.maxLength) {
-    setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
-  }
-  if (def.exactLength) {
-    setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
-    setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
-  }
-  return res;
-}
+${data.goal}
+  `.trim();
+};
 
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
-function parseBigintDef(def, refs) {
-  const res = {
-    type: "integer",
-    format: "int64"
-  };
-  if (!def.checks)
-    return res;
-  for (const check of def.checks) {
-    switch (check.kind) {
-      case "min":
-        if (refs.target === "jsonSchema7") {
-          if (check.inclusive) {
-            setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
-          } else {
-            setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
-          }
-        } else {
-          if (!check.inclusive) {
-            res.exclusiveMinimum = true;
-          }
-          setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
-        }
-        break;
-      case "max":
-        if (refs.target === "jsonSchema7") {
-          if (check.inclusive) {
-            setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
-          } else {
-            setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
-          }
-        } else {
-          if (!check.inclusive) {
-            res.exclusiveMaximum = true;
-          }
-          setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
-        }
-        break;
-      case "multipleOf":
-        setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
-        break;
-    }
+// src/planners/simplePlanner.ts
+function getTransitions(state, machine) {
+  if (!machine) {
+    return [];
   }
-  return res;
-}
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
-function parseBooleanDef() {
-  return {
-    type: "boolean"
-  };
-}
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
-function parseBrandedDef(_def, refs) {
-  return parseDef(_def.type._def, refs);
+  const resolvedState = machine.resolveState(state);
+  return getAllTransitions(resolvedState);
 }
+var simplePlannerPromptTemplate = (data) => {
+  return `
+${defaultTextTemplate(data)}
 
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
-var parseCatchDef = (def, refs) => {
-  return parseDef(def.innerType._def, refs);
+Only make a single tool call to achieve the above goal.
+  `.trim();
 };
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/date.js
-function parseDateDef(def, refs) {
-  if (refs.dateStrategy == "integer") {
-    return integerDateParser(def, refs);
-  } else {
+async function simplePlanner(agent, input) {
+  const transitions = input.machine ? getTransitions(input.state, input.machine) : Object.entries(input.events).map(([eventType, { description }]) => ({
+    eventType,
+    description
+  }));
+  const filter = (eventType) => Object.keys(input.events).includes(eventType);
+  const functionNameMapping = {};
+  const toolTransitions = transitions.filter((t) => {
+    return filter(t.eventType);
+  }).map((t) => {
+    const name = t.eventType.replace(/\./g, "_");
+    functionNameMapping[name] = t.eventType;
     return {
-      type: "string",
-      format: "date-time"
+      type: "function",
+      eventType: t.eventType,
+      description: t.description,
+      name
     };
+  });
+  const toolMap = {};
+  for (const toolTransitionData of toolTransitions) {
+    const toolZodType = input.events?.[toolTransitionData.eventType];
+    toolMap[toolTransitionData.name] = (0, import_ai.tool)({
+      description: toolZodType?.description ?? toolTransitionData.description,
+      parameters: toolZodType ?? z.object({}),
+      execute: async (params) => {
+        const event = {
+          type: toolTransitionData.eventType,
+          ...params
+        };
+        return event;
+      }
+    });
   }
-}
-var integerDateParser = (def, refs) => {
-  const res = {
-    type: "integer",
-    format: "unix-time"
-  };
-  for (const check of def.checks) {
-    switch (check.kind) {
-      case "min":
-        if (refs.target === "jsonSchema7") {
-          setResponseValueAndErrors(
-            res,
-            "minimum",
-            check.value,
-            // This is in milliseconds
-            check.message,
-            refs
-          );
-        }
-        break;
-      case "max":
-        if (refs.target === "jsonSchema7") {
-          setResponseValueAndErrors(
-            res,
-            "maximum",
-            check.value,
-            // This is in milliseconds
-            check.message,
-            refs
-          );
-        }
-        break;
-    }
+  const prompt = simplePlannerPromptTemplate({
+    context: input.state.context,
+    goal: input.goal
+  });
+  const result = await agent.generateText({
+    prompt,
+    tools: toolMap,
+    toolChoice: "required",
+    ...input
+  });
+  const singleResult = result.toolResults[0];
+  if (!singleResult) {
+    console.warn("No tool call results returned");
+    return void 0;
   }
-  return res;
-};
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/default.js
-function parseDefaultDef(_def, refs) {
   return {
-    ...parseDef(_def.innerType._def, refs),
-    default: _def.defaultValue()
+    goal: input.goal,
+    state: input.state,
+    steps: [
+      {
+        event: singleResult.result
+      }
+    ],
+    nextEvent: singleResult.result,
+    sessionId: agent.sessionId,
+    timestamp: Date.now()
   };
 }
 
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/effects.js
-function parseEffectsDef(_def, refs) {
-  return refs.effectStrategy === "input" ? parseDef(_def.schema._def, refs) : {};
-}
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/enum.js
-function parseEnumDef(def) {
-  return {
-    type: "string",
-    enum: def.values
-  };
-}
+// src/agent.ts
+var import_crypto2 = require("crypto");
 
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/intersection.js
-var isJsonSchema7AllOfType = (type) => {
-  if ("type" in type && type.type === "string")
-    return false;
-  return "allOf" in type;
-};
-function parseIntersectionDef(def, refs) {
-  const allOf = [
-    parseDef(def.left._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "allOf", "0"]
-    }),
-    parseDef(def.right._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "allOf", "1"]
-    })
-  ].filter((x) => !!x);
-  let unevaluatedProperties = refs.target === "jsonSchema2019-09" ? { unevaluatedProperties: false } : void 0;
-  const mergedAllOf = [];
-  allOf.forEach((schema) => {
-    if (isJsonSchema7AllOfType(schema)) {
-      mergedAllOf.push(...schema.allOf);
-      if (schema.unevaluatedProperties === void 0) {
-        unevaluatedProperties = void 0;
-      }
-    } else {
-      let nestedSchema = schema;
-      if ("additionalProperties" in schema && schema.additionalProperties === false) {
-        const { additionalProperties, ...rest } = schema;
-        nestedSchema = rest;
-      } else {
-        unevaluatedProperties = void 0;
-      }
-      mergedAllOf.push(nestedSchema);
-    }
+// src/text.ts
+var import_crypto = require("crypto");
+var import_xstate = require("xstate");
+async function getMessages(agent, prompt, options) {
+  let messages = [];
+  if (options.messages === true) {
+    messages = agent.select((s) => s.messages);
+  } else if (typeof options.messages === "function") {
+    messages = await options.messages(agent);
+  } else if (options.messages) {
+    messages = options.messages;
+  }
+  messages = messages.concat({
+    role: "user",
+    content: prompt
   });
-  return mergedAllOf.length ? {
-    allOf: mergedAllOf,
-    ...unevaluatedProperties
-  } : void 0;
+  return messages;
 }
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/literal.js
-function parseLiteralDef(def, refs) {
-  const parsedType = typeof def.value;
-  if (parsedType !== "bigint" && parsedType !== "number" && parsedType !== "boolean" && parsedType !== "string") {
-    return {
-      type: Array.isArray(def.value) ? "array" : "object"
-    };
-  }
-  if (refs.target === "openApi3") {
-    return {
-      type: parsedType === "bigint" ? "integer" : parsedType,
-      enum: [def.value]
-    };
-  }
-  return {
-    type: parsedType === "bigint" ? "integer" : parsedType,
-    const: def.value
+async function agentGenerateText(agent, options) {
+  const resolvedOptions = {
+    ...agent.defaultOptions,
+    ...options
   };
+  const template = resolvedOptions.template ?? defaultTextTemplate;
+  const id = (0, import_crypto.randomUUID)();
+  const goal = typeof resolvedOptions.prompt === "string" ? resolvedOptions.prompt : await resolvedOptions.prompt(agent);
+  const promptWithContext = template({
+    goal,
+    context: resolvedOptions.context
+  });
+  const messages = await getMessages(agent, promptWithContext, resolvedOptions);
+  agent.addMessage({
+    id,
+    role: "user",
+    content: promptWithContext,
+    timestamp: Date.now()
+  });
+  const result = await agent.adapter.generateText({
+    ...resolvedOptions,
+    prompt: void 0,
+    messages
+  });
+  agent.addMessage({
+    content: result.text,
+    id,
+    role: "assistant",
+    timestamp: Date.now(),
+    responseId: id,
+    result
+  });
+  return result;
 }
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/string.js
-var zodPatterns = {
-  /**
-   * `c` was changed to `[cC]` to replicate /i flag
-   */
-  cuid: "^[cC][^\\s-]{8,}$",
-  cuid2: "^[a-z][a-z0-9]*$",
-  ulid: "^[0-9A-HJKMNP-TV-Z]{26}$",
-  /**
-   * `a-z` was added to replicate /i flag
-   */
-  email: "^(?!\\.)(?!.*\\.\\.)([a-zA-Z0-9_+-\\.]*)[a-zA-Z0-9_+-]@([a-zA-Z0-9][a-zA-Z0-9\\-]*\\.)+[a-zA-Z]{2,}$",
-  emoji: "^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$",
-  /**
-   * Unused
-   */
-  uuid: "^[0-9a-fA-F]{8}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{4}\\b-[0-9a-fA-F]{12}$",
-  /**
-   * Unused
-   */
-  ipv4: "^(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))$",
-  /**
-   * Unused
-   */
-  ipv6: "^(([a-f0-9]{1,4}:){7}|::([a-f0-9]{1,4}:){0,6}|([a-f0-9]{1,4}:){1}:([a-f0-9]{1,4}:){0,5}|([a-f0-9]{1,4}:){2}:([a-f0-9]{1,4}:){0,4}|([a-f0-9]{1,4}:){3}:([a-f0-9]{1,4}:){0,3}|([a-f0-9]{1,4}:){4}:([a-f0-9]{1,4}:){0,2}|([a-f0-9]{1,4}:){5}:([a-f0-9]{1,4}:){0,1})([a-f0-9]{1,4}|(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2})))$"
-};
-function parseStringDef(def, refs) {
-  const res = {
-    type: "string"
+async function agentStreamText(agent, options) {
+  const resolvedOptions = {
+    ...agent.defaultOptions,
+    ...options
   };
-  function processPattern(value) {
-    return refs.patternStrategy === "escape" ? escapeNonAlphaNumeric(value) : value;
-  }
-  if (def.checks) {
-    for (const check of def.checks) {
-      switch (check.kind) {
-        case "min":
-          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
-          break;
-        case "max":
-          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
-          break;
-        case "email":
-          switch (refs.emailStrategy) {
-            case "format:email":
-              addFormat(res, "email", check.message, refs);
-              break;
-            case "format:idn-email":
-              addFormat(res, "idn-email", check.message, refs);
-              break;
-            case "pattern:zod":
-              addPattern(res, zodPatterns.email, check.message, refs);
-              break;
-          }
-          break;
-        case "url":
-          addFormat(res, "uri", check.message, refs);
-          break;
-        case "uuid":
-          addFormat(res, "uuid", check.message, refs);
-          break;
-        case "regex":
-          addPattern(res, check.regex.source, check.message, refs);
-          break;
-        case "cuid":
-          addPattern(res, zodPatterns.cuid, check.message, refs);
-          break;
-        case "cuid2":
-          addPattern(res, zodPatterns.cuid2, check.message, refs);
-          break;
-        case "startsWith":
-          addPattern(res, "^" + processPattern(check.value), check.message, refs);
-          break;
-        case "endsWith":
-          addPattern(res, processPattern(check.value) + "$", check.message, refs);
-          break;
-        case "datetime":
-          addFormat(res, "date-time", check.message, refs);
-          break;
-        case "length":
-          setResponseValueAndErrors(res, "minLength", typeof res.minLength === "number" ? Math.max(res.minLength, check.value) : check.value, check.message, refs);
-          setResponseValueAndErrors(res, "maxLength", typeof res.maxLength === "number" ? Math.min(res.maxLength, check.value) : check.value, check.message, refs);
-          break;
-        case "includes": {
-          addPattern(res, processPattern(check.value), check.message, refs);
-          break;
-        }
-        case "ip": {
-          if (check.version !== "v6") {
-            addFormat(res, "ipv4", check.message, refs);
-          }
-          if (check.version !== "v4") {
-            addFormat(res, "ipv6", check.message, refs);
-          }
-          break;
-        }
-        case "emoji":
-          addPattern(res, zodPatterns.emoji, check.message, refs);
-          break;
-        case "ulid": {
-          addPattern(res, zodPatterns.ulid, check.message, refs);
-          break;
-        }
-        case "toLowerCase":
-        case "toUpperCase":
-        case "trim":
-          break;
-        default:
-          /* @__PURE__ */ ((_) => {
-          })(check);
-      }
-    }
-  }
-  return res;
-}
-var escapeNonAlphaNumeric = (value) => Array.from(value).map((c) => /[a-zA-Z0-9]/.test(c) ? c : `\\${c}`).join("");
-var addFormat = (schema, value, message, refs) => {
-  if (schema.format || schema.anyOf?.some((x) => x.format)) {
-    if (!schema.anyOf) {
-      schema.anyOf = [];
-    }
-    if (schema.format) {
-      schema.anyOf.push({
-        format: schema.format,
-        ...schema.errorMessage && refs.errorMessages && {
-          errorMessage: { format: schema.errorMessage.format }
-        }
+  const template = resolvedOptions.template ?? defaultTextTemplate;
+  const id = (0, import_crypto.randomUUID)();
+  const goal = typeof resolvedOptions.prompt === "string" ? resolvedOptions.prompt : await resolvedOptions.prompt(agent);
+  const promptWithContext = template({
+    goal,
+    context: resolvedOptions.context
+  });
+  const messages = await getMessages(agent, promptWithContext, resolvedOptions);
+  agent.addMessage({
+    role: "user",
+    content: promptWithContext,
+    id,
+    timestamp: Date.now()
+  });
+  const result = await agent.adapter.streamText({
+    ...resolvedOptions,
+    prompt: void 0,
+    messages,
+    onFinish: async (res) => {
+      agent.addMessage({
+        role: "assistant",
+        result: {
+          text: res.text,
+          finishReason: res.finishReason,
+          logprobs: void 0,
+          responseMessages: [],
+          toolCalls: [],
+          toolResults: [],
+          usage: res.usage,
+          warnings: res.warnings,
+          rawResponse: res.rawResponse
+        },
+        content: res.text,
+        id: (0, import_crypto.randomUUID)(),
+        timestamp: Date.now(),
+        responseId: id
       });
-      delete schema.format;
-      if (schema.errorMessage) {
-        delete schema.errorMessage.format;
-        if (Object.keys(schema.errorMessage).length === 0) {
-          delete schema.errorMessage;
-        }
-      }
-    }
-    schema.anyOf.push({
-      format: value,
-      ...message && refs.errorMessages && { errorMessage: { format: message } }
-    });
-  } else {
-    setResponseValueAndErrors(schema, "format", value, message, refs);
-  }
-};
-var addPattern = (schema, value, message, refs) => {
-  if (schema.pattern || schema.allOf?.some((x) => x.pattern)) {
-    if (!schema.allOf) {
-      schema.allOf = [];
     }
-    if (schema.pattern) {
-      schema.allOf.push({
-        pattern: schema.pattern,
-        ...schema.errorMessage && refs.errorMessages && {
-          errorMessage: { pattern: schema.errorMessage.pattern }
-        }
+  });
+  return result;
+}
+function fromTextStream(agent, defaultOptions) {
+  return (0, import_xstate.fromObservable)(({ input, self }) => {
+    const context = input.context === true ? (self._parent?.getSnapshot()).context : input.context;
+    const observers = /* @__PURE__ */ new Set();
+    (async () => {
+      const result = await agentStreamText(agent, {
+        ...defaultOptions,
+        ...input,
+        context
       });
-      delete schema.pattern;
-      if (schema.errorMessage) {
-        delete schema.errorMessage.pattern;
-        if (Object.keys(schema.errorMessage).length === 0) {
-          delete schema.errorMessage;
+      for await (const part of result.fullStream) {
+        if (part.type === "text-delta") {
+          observers.forEach((observer) => {
+            observer.next?.(part);
+          });
         }
       }
-    }
-    schema.allOf.push({
-      pattern: value,
-      ...message && refs.errorMessages && { errorMessage: { pattern: message } }
-    });
-  } else {
-    setResponseValueAndErrors(schema, "pattern", value, message, refs);
-  }
-};
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/record.js
-function parseRecordDef(def, refs) {
-  if (refs.target === "openApi3" && def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
+    })();
     return {
-      type: "object",
-      required: def.keyType._def.values,
-      properties: def.keyType._def.values.reduce((acc, key) => ({
-        ...acc,
-        [key]: parseDef(def.valueType._def, {
-          ...refs,
-          currentPath: [...refs.currentPath, "properties", key]
-        }) ?? {}
-      }), {}),
-      additionalProperties: false
-    };
-  }
-  const schema = {
-    type: "object",
-    additionalProperties: parseDef(def.valueType._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "additionalProperties"]
-    }) ?? {}
-  };
-  if (refs.target === "openApi3") {
-    return schema;
-  }
-  if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodString && def.keyType._def.checks?.length) {
-    const keyType = Object.entries(parseStringDef(def.keyType._def, refs)).reduce((acc, [key, value]) => key === "type" ? acc : { ...acc, [key]: value }, {});
-    return {
-      ...schema,
-      propertyNames: keyType
-    };
-  } else if (def.keyType?._def.typeName === ZodFirstPartyTypeKind.ZodEnum) {
-    return {
-      ...schema,
-      propertyNames: {
-        enum: def.keyType._def.values
+      subscribe: (...args) => {
+        const observer = (0, import_xstate.toObserver)(...args);
+        observers.add(observer);
+        return {
+          unsubscribe: () => {
+            observers.delete(observer);
+          }
+        };
       }
     };
-  }
-  return schema;
-}
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/map.js
-function parseMapDef(def, refs) {
-  if (refs.mapStrategy === "record") {
-    return parseRecordDef(def, refs);
-  }
-  const keys = parseDef(def.keyType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "items", "items", "0"]
-  }) || {};
-  const values = parseDef(def.valueType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "items", "items", "1"]
-  }) || {};
-  return {
-    type: "array",
-    maxItems: 125,
-    items: {
-      type: "array",
-      items: [keys, values],
-      minItems: 2,
-      maxItems: 2
-    }
-  };
-}
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/nativeEnum.js
-function parseNativeEnumDef(def) {
-  const object = def.values;
-  const actualKeys = Object.keys(def.values).filter((key) => {
-    return typeof object[object[key]] !== "number";
   });
-  const actualValues = actualKeys.map((key) => object[key]);
-  const parsedTypes = Array.from(new Set(actualValues.map((values) => typeof values)));
-  return {
-    type: parsedTypes.length === 1 ? parsedTypes[0] === "string" ? "string" : "number" : ["string", "number"],
-    enum: actualValues
-  };
 }
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/never.js
-function parseNeverDef() {
-  return {
-    not: {}
-  };
+function fromText(agent, defaultOptions) {
+  return (0, import_xstate.fromPromise)(async ({ input, self }) => {
+    const context = input.context === true ? (self._parent?.getSnapshot()).context : input.context;
+    return await agentGenerateText(agent, {
+      ...input,
+      ...defaultOptions,
+      context
+    });
+  });
 }
 
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/null.js
-function parseNullDef(refs) {
-  return refs.target === "openApi3" ? {
-    enum: ["null"],
-    nullable: true
-  } : {
-    type: "null"
+// src/decision.ts
+var import_xstate2 = require("xstate");
+async function agentDecide(agent, options) {
+  const resolvedOptions = {
+    ...agent.defaultOptions,
+    ...options
   };
-}
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/union.js
-var primitiveMappings = {
-  ZodString: "string",
-  ZodNumber: "number",
-  ZodBigInt: "integer",
-  ZodBoolean: "boolean",
-  ZodNull: "null"
-};
-function parseUnionDef(def, refs) {
-  if (refs.target === "openApi3")
-    return asAnyOf(def, refs);
-  const options = def.options instanceof Map ? Array.from(def.options.values()) : def.options;
-  if (options.every((x) => x._def.typeName in primitiveMappings && (!x._def.checks || !x._def.checks.length))) {
-    const types = options.reduce((types2, x) => {
-      const type = primitiveMappings[x._def.typeName];
-      return type && !types2.includes(type) ? [...types2, type] : types2;
-    }, []);
-    return {
-      type: types.length > 1 ? types : types[0]
-    };
-  } else if (options.every((x) => x._def.typeName === "ZodLiteral" && !x.description)) {
-    const types = options.reduce((acc, x) => {
-      const type = typeof x._def.value;
-      switch (type) {
-        case "string":
-        case "number":
-        case "boolean":
-          return [...acc, type];
-        case "bigint":
-          return [...acc, "integer"];
-        case "object":
-          if (x._def.value === null)
-            return [...acc, "null"];
-        case "symbol":
-        case "undefined":
-        case "function":
-        default:
-          return acc;
-      }
-    }, []);
-    if (types.length === options.length) {
-      const uniqueTypes = types.filter((x, i, a) => a.indexOf(x) === i);
-      return {
-        type: uniqueTypes.length > 1 ? uniqueTypes : uniqueTypes[0],
-        enum: options.reduce((acc, x) => {
-          return acc.includes(x._def.value) ? acc : [...acc, x._def.value];
-        }, [])
-      };
-    }
-  } else if (options.every((x) => x._def.typeName === "ZodEnum")) {
-    return {
-      type: "string",
-      enum: options.reduce((acc, x) => [
-        ...acc,
-        ...x._def.values.filter((x2) => !acc.includes(x2))
-      ], [])
-    };
+  const {
+    planner = simplePlanner,
+    goal,
+    events = agent.events,
+    state,
+    machine,
+    model = agent.model,
+    ...otherPlanInput
+  } = resolvedOptions;
+  const plan = await planner(agent, {
+    model,
+    goal,
+    events,
+    state,
+    machine,
+    ...otherPlanInput
+  });
+  if (plan?.nextEvent) {
+    agent.addPlan(plan);
+    await resolvedOptions.execute?.(plan.nextEvent);
   }
-  return asAnyOf(def, refs);
+  return plan;
 }
-var asAnyOf = (def, refs) => {
-  const anyOf = (def.options instanceof Map ? Array.from(def.options.values()) : def.options).map((x, i) => parseDef(x._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "anyOf", `${i}`]
-  })).filter((x) => !!x && (!refs.strictUnions || typeof x === "object" && Object.keys(x).length > 0));
-  return anyOf.length ? { anyOf } : void 0;
-};
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/nullable.js
-function parseNullableDef(def, refs) {
-  if (["ZodString", "ZodNumber", "ZodBigInt", "ZodBoolean", "ZodNull"].includes(def.innerType._def.typeName) && (!def.innerType._def.checks || !def.innerType._def.checks.length)) {
-    if (refs.target === "openApi3") {
-      return {
-        type: primitiveMappings[def.innerType._def.typeName],
-        nullable: true
-      };
+function fromDecision(agent, defaultInput) {
+  return (0, import_xstate2.fromPromise)(async ({ input, self }) => {
+    const parentRef = self._parent;
+    if (!parentRef) {
+      return;
     }
-    return {
-      type: [
-        primitiveMappings[def.innerType._def.typeName],
-        "null"
-      ]
+    const snapshot = parentRef.getSnapshot();
+    const inputObject = typeof input === "string" ? { goal: input } : input;
+    const resolvedInput = {
+      ...defaultInput,
+      ...inputObject
     };
-  }
-  if (refs.target === "openApi3") {
-    const base2 = parseDef(def.innerType._def, {
-      ...refs,
-      currentPath: [...refs.currentPath]
+    const contextToInclude = resolvedInput.context === true ? (
+      // include entire context
+      parentRef.getSnapshot().context
+    ) : resolvedInput.context;
+    const state = {
+      value: snapshot.value,
+      context: contextToInclude
+    };
+    const plan = await agentDecide(agent, {
+      machine: parentRef.src,
+      state,
+      execute: async (event) => {
+        parentRef.send(event);
+      },
+      ...resolvedInput
     });
-    if (base2 && "$ref" in base2)
-      return { allOf: [base2], nullable: true };
-    return base2 && { ...base2, nullable: true };
-  }
-  const base = parseDef(def.innerType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "anyOf", "0"]
+    return plan;
   });
-  return base && { anyOf: [base, { type: "null" }] };
 }
 
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/number.js
-function parseNumberDef(def, refs) {
-  const res = {
-    type: "number"
-  };
-  if (!def.checks)
-    return res;
-  for (const check of def.checks) {
-    switch (check.kind) {
-      case "int":
-        res.type = "integer";
-        addErrorMessage(res, "type", check.message, refs);
+// src/adapters/vercel.ts
+var import_ai2 = require("ai");
+var vercelAdapter = {
+  generateText: import_ai2.generateText,
+  streamText: import_ai2.streamText
+};
+
+// src/agent.ts
+var agentLogic = (0, import_xstate3.fromTransition)(
+  (state, event, { emit }) => {
+    switch (event.type) {
+      case "agent.feedback": {
+        state.feedback.push(event.feedback);
+        emit({
+          type: "feedback",
+          // @ts-ignore TODO: fix types in XState
+          feedback: event.feedback
+        });
         break;
-      case "min":
-        if (refs.target === "jsonSchema7") {
-          if (check.inclusive) {
-            setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
-          } else {
-            setResponseValueAndErrors(res, "exclusiveMinimum", check.value, check.message, refs);
-          }
-        } else {
-          if (!check.inclusive) {
-            res.exclusiveMinimum = true;
-          }
-          setResponseValueAndErrors(res, "minimum", check.value, check.message, refs);
-        }
+      }
+      case "agent.observe": {
+        state.observations.push(event.observation);
+        emit({
+          type: "observation",
+          // @ts-ignore TODO: fix types in XState
+          observation: event.observation
+        });
         break;
-      case "max":
-        if (refs.target === "jsonSchema7") {
-          if (check.inclusive) {
-            setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
-          } else {
-            setResponseValueAndErrors(res, "exclusiveMaximum", check.value, check.message, refs);
-          }
-        } else {
-          if (!check.inclusive) {
-            res.exclusiveMaximum = true;
-          }
-          setResponseValueAndErrors(res, "maximum", check.value, check.message, refs);
-        }
+      }
+      case "agent.message": {
+        state.messages.push(event.message);
+        emit({
+          type: "message",
+          // @ts-ignore TODO: fix types in XState
+          message: event.message
+        });
+        break;
+      }
+      case "agent.plan": {
+        state.plans.push(event.plan);
+        emit({
+          type: "plan",
+          // @ts-ignore TODO: fix types in XState
+          plan: event.plan
+        });
         break;
-      case "multipleOf":
-        setResponseValueAndErrors(res, "multipleOf", check.value, check.message, refs);
+      }
+      default:
         break;
     }
-  }
-  return res;
-}
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/object.js
-function parseObjectDef(def, refs) {
-  const result = {
-    type: "object",
-    ...Object.entries(def.shape()).reduce((acc, [propName, propDef]) => {
-      if (propDef === void 0 || propDef._def === void 0)
-        return acc;
-      const parsedDef = parseDef(propDef._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "properties", propName],
-        propertyPath: [...refs.currentPath, "properties", propName]
-      });
-      if (parsedDef === void 0)
-        return acc;
-      return {
-        properties: { ...acc.properties, [propName]: parsedDef },
-        required: propDef.isOptional() ? acc.required : [...acc.required, propName]
-      };
-    }, { properties: {}, required: [] }),
-    additionalProperties: def.catchall._def.typeName === "ZodNever" ? def.unknownKeys === "passthrough" : parseDef(def.catchall._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "additionalProperties"]
-    }) ?? true
+    return state;
+  },
+  {
+    feedback: [],
+    messages: [],
+    observations: [],
+    plans: []
+  }
+);
+function createAgent({
+  name,
+  description,
+  model,
+  events,
+  planner = simplePlanner,
+  stringify = JSON.stringify,
+  getMemory,
+  logic = agentLogic,
+  adapter = vercelAdapter,
+  ...generateTextOptions
+}) {
+  const messageHistoryListeners = [];
+  const agent = (0, import_xstate3.createActor)(logic);
+  agent.events = events;
+  agent.model = model;
+  agent.name = name;
+  agent.description = description;
+  agent.adapter = adapter;
+  agent.defaultOptions = { ...generateTextOptions, model };
+  agent.select = (selector) => {
+    return selector(agent.getSnapshot().context);
   };
-  if (!result.required.length)
-    delete result.required;
-  return result;
-}
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/optional.js
-var parseOptionalDef = (def, refs) => {
-  if (refs.currentPath.toString() === refs.propertyPath?.toString()) {
-    return parseDef(def.innerType._def, refs);
-  }
-  const innerSchema = parseDef(def.innerType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "anyOf", "1"]
-  });
-  return innerSchema ? {
-    anyOf: [
-      {
-        not: {}
-      },
-      innerSchema
-    ]
-  } : {};
-};
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/pipeline.js
-var parsePipelineDef = (def, refs) => {
-  if (refs.pipeStrategy === "input") {
-    return parseDef(def.in._def, refs);
-  } else if (refs.pipeStrategy === "output") {
-    return parseDef(def.out._def, refs);
-  }
-  const a = parseDef(def.in._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "allOf", "0"]
-  });
-  const b = parseDef(def.out._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "allOf", a ? "1" : "0"]
-  });
-  return {
-    allOf: [a, b].filter((x) => x !== void 0)
+  agent.memory = getMemory ? getMemory(agent) : void 0;
+  agent.onMessage = (callback) => {
+    messageHistoryListeners.push((0, import_xstate3.toObserver)(callback));
   };
-};
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/promise.js
-function parsePromiseDef(def, refs) {
-  return parseDef(def.type._def, refs);
-}
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/set.js
-function parseSetDef(def, refs) {
-  const items = parseDef(def.valueType._def, {
-    ...refs,
-    currentPath: [...refs.currentPath, "items"]
-  });
-  const schema = {
-    type: "array",
-    uniqueItems: true,
-    items
+  agent.decide = (opts) => {
+    return agentDecide(agent, opts);
   };
-  if (def.minSize) {
-    setResponseValueAndErrors(schema, "minItems", def.minSize.value, def.minSize.message, refs);
-  }
-  if (def.maxSize) {
-    setResponseValueAndErrors(schema, "maxItems", def.maxSize.value, def.maxSize.message, refs);
-  }
-  return schema;
-}
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/tuple.js
-function parseTupleDef(def, refs) {
-  if (def.rest) {
-    return {
-      type: "array",
-      minItems: def.items.length,
-      items: def.items.map((x, i) => parseDef(x._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "items", `${i}`]
-      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], []),
-      additionalItems: parseDef(def.rest._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "additionalItems"]
-      })
+  agent.addMessage = (messageInput) => {
+    const message = {
+      ...messageInput,
+      id: messageInput.id ?? (0, import_crypto2.randomUUID)(),
+      timestamp: messageInput.timestamp ?? Date.now(),
+      sessionId: agent.sessionId
     };
-  } else {
-    return {
-      type: "array",
-      minItems: def.items.length,
-      maxItems: def.items.length,
-      items: def.items.map((x, i) => parseDef(x._def, {
-        ...refs,
-        currentPath: [...refs.currentPath, "items", `${i}`]
-      })).reduce((acc, x) => x === void 0 ? acc : [...acc, x], [])
-    };
-  }
-}
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/undefined.js
-function parseUndefinedDef() {
-  return {
-    not: {}
+    agent.send({
+      type: "agent.message",
+      message
+    });
+    return message;
   };
-}
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/unknown.js
-function parseUnknownDef() {
-  return {};
-}
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parsers/readonly.js
-var parseReadonlyDef = (def, refs) => {
-  return parseDef(def.innerType._def, refs);
-};
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/parseDef.js
-function parseDef(def, refs, forceResolution = false) {
-  const seenItem = refs.seen.get(def);
-  if (seenItem && !forceResolution) {
-    const seenSchema = get$ref(seenItem, refs);
-    if (seenSchema !== void 0) {
-      return seenSchema;
-    }
-  }
-  const newItem = { def, path: refs.currentPath, jsonSchema: void 0 };
-  refs.seen.set(def, newItem);
-  const jsonSchema = selectParser(def, def.typeName, refs);
-  if (jsonSchema) {
-    addMeta(def, refs, jsonSchema);
-  }
-  newItem.jsonSchema = jsonSchema;
-  return jsonSchema;
-}
-var get$ref = (item, refs) => {
-  switch (refs.$refStrategy) {
-    case "root":
-      return { $ref: item.path.join("/") };
-    case "relative":
-      return { $ref: getRelativePath(refs.currentPath, item.path) };
-    case "none":
-    case "seen": {
-      if (item.path.length < refs.currentPath.length && item.path.every((value, index) => refs.currentPath[index] === value)) {
-        console.warn(`Recursive reference detected at ${refs.currentPath.join("/")}! Defaulting to any`);
-        return {};
-      }
-      return refs.$refStrategy === "seen" ? {} : void 0;
-    }
-  }
-};
-var getRelativePath = (pathA, pathB) => {
-  let i = 0;
-  for (; i < pathA.length && i < pathB.length; i++) {
-    if (pathA[i] !== pathB[i])
-      break;
-  }
-  return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
-};
-var selectParser = (def, typeName, refs) => {
-  switch (typeName) {
-    case ZodFirstPartyTypeKind.ZodString:
-      return parseStringDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodNumber:
-      return parseNumberDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodObject:
-      return parseObjectDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodBigInt:
-      return parseBigintDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodBoolean:
-      return parseBooleanDef();
-    case ZodFirstPartyTypeKind.ZodDate:
-      return parseDateDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodUndefined:
-      return parseUndefinedDef();
-    case ZodFirstPartyTypeKind.ZodNull:
-      return parseNullDef(refs);
-    case ZodFirstPartyTypeKind.ZodArray:
-      return parseArrayDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodUnion:
-    case ZodFirstPartyTypeKind.ZodDiscriminatedUnion:
-      return parseUnionDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodIntersection:
-      return parseIntersectionDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodTuple:
-      return parseTupleDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodRecord:
-      return parseRecordDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodLiteral:
-      return parseLiteralDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodEnum:
-      return parseEnumDef(def);
-    case ZodFirstPartyTypeKind.ZodNativeEnum:
-      return parseNativeEnumDef(def);
-    case ZodFirstPartyTypeKind.ZodNullable:
-      return parseNullableDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodOptional:
-      return parseOptionalDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodMap:
-      return parseMapDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodSet:
-      return parseSetDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodLazy:
-      return parseDef(def.getter()._def, refs);
-    case ZodFirstPartyTypeKind.ZodPromise:
-      return parsePromiseDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodNaN:
-    case ZodFirstPartyTypeKind.ZodNever:
-      return parseNeverDef();
-    case ZodFirstPartyTypeKind.ZodEffects:
-      return parseEffectsDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodAny:
-      return parseAnyDef();
-    case ZodFirstPartyTypeKind.ZodUnknown:
-      return parseUnknownDef();
-    case ZodFirstPartyTypeKind.ZodDefault:
-      return parseDefaultDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodBranded:
-      return parseBrandedDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodReadonly:
-      return parseReadonlyDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodCatch:
-      return parseCatchDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodPipeline:
-      return parsePipelineDef(def, refs);
-    case ZodFirstPartyTypeKind.ZodFunction:
-    case ZodFirstPartyTypeKind.ZodVoid:
-    case ZodFirstPartyTypeKind.ZodSymbol:
-      return void 0;
-    default:
-      return /* @__PURE__ */ ((_) => void 0)(typeName);
-  }
-};
-var addMeta = (def, refs, jsonSchema) => {
-  if (def.description) {
-    jsonSchema.description = def.description;
-    if (refs.markdownDescription) {
-      jsonSchema.markdownDescription = def.description;
-    }
-  }
-  return jsonSchema;
-};
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/Refs.js
-var getRefs = (options) => {
-  const _options = getDefaultOptions(options);
-  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
-  return {
-    ..._options,
-    currentPath,
-    propertyPath: void 0,
-    seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
-      def._def,
-      {
-        def: def._def,
-        path: [..._options.basePath, _options.definitionPath, name],
-        // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
-        jsonSchema: void 0
-      }
-    ]))
+  agent.generateText = (opts) => agentGenerateText(agent, opts);
+  agent.streamText = (opts) => agentStreamText(agent, opts);
+  agent.addFeedback = (feedbackInput) => {
+    const feedback = {
+      ...feedbackInput,
+      timestamp: feedbackInput.timestamp ?? Date.now(),
+      sessionId: agent.sessionId
+    };
+    agent.send({
+      type: "agent.feedback",
+      feedback
+    });
+    return feedback;
   };
-};
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/zodToJsonSchema.js
-var zodToJsonSchema = (schema, options) => {
-  const refs = getRefs(options);
-  const definitions = typeof options === "object" && options.definitions ? Object.entries(options.definitions).reduce((acc, [name2, schema2]) => ({
-    ...acc,
-    [name2]: parseDef(schema2._def, {
-      ...refs,
-      currentPath: [...refs.basePath, refs.definitionPath, name2]
-    }, true) ?? {}
-  }), {}) : void 0;
-  const name = typeof options === "string" ? options : options?.name;
-  const main = parseDef(schema._def, name === void 0 ? refs : {
-    ...refs,
-    currentPath: [...refs.basePath, refs.definitionPath, name]
-  }, false) ?? {};
-  const combined = name === void 0 ? definitions ? {
-    ...main,
-    [refs.definitionPath]: definitions
-  } : main : {
-    $ref: [
-      ...refs.$refStrategy === "relative" ? [] : refs.basePath,
-      refs.definitionPath,
-      name
-    ].join("/"),
-    [refs.definitionPath]: {
-      ...definitions,
-      [name]: main
-    }
+  agent.addObservation = (observationInput) => {
+    const observation = {
+      ...observationInput,
+      id: observationInput.id ?? (0, import_crypto2.randomUUID)(),
+      sessionId: agent.sessionId,
+      timestamp: observationInput.timestamp ?? Date.now()
+    };
+    agent.send({
+      type: "agent.observe",
+      observation
+    });
+    return observation;
   };
-  if (refs.target === "jsonSchema7") {
-    combined.$schema = "http://json-schema.org/draft-07/schema#";
-  } else if (refs.target === "jsonSchema2019-09") {
-    combined.$schema = "https://json-schema.org/draft/2019-09/schema#";
-  }
-  return combined;
-};
-
-// node_modules/.pnpm/zod-to-json-schema@3.22.4_zod@3.22.4/node_modules/zod-to-json-schema/dist/esm/index.js
-var esm_default = zodToJsonSchema;
-
-// src/utils.ts
-function getAllTransitions(state) {
-  const nodes = state._nodes;
-  const transitions = nodes.map((node) => [...node.transitions.values()]).flat(2);
-  return transitions;
-}
-function createZodEventSchemas(eventSchemaMap) {
-  const resolvedEventSchemaMap = {};
-  for (const [eventType, zodType] of Object.entries(eventSchemaMap)) {
-    resolvedEventSchemaMap[eventType] = esm_default(
-      zodType.extend({
-        type: z.literal(eventType)
-      })
-    );
-  }
-  return resolvedEventSchemaMap;
-}
-
-// src/schemas.ts
-function defineEvents(events) {
-  return {
-    types: {},
-    schemas: createZodEventSchemas(events)
+  agent.addPlan = (plan) => {
+    agent.send({
+      type: "agent.plan",
+      plan
+    });
   };
-}
-
-// src/agent.ts
-var import_xstate = require("xstate");
-function createAgent(...args) {
-  const [machine, options] = args;
-  return (0, import_xstate.createActor)(machine, options);
-}
-
-// src/adapters/openai.ts
-var import_xstate2 = require("xstate");
-function fromChatCompletion(openai, agentSettings, inputFn) {
-  return (0, import_xstate2.fromPromise)(
-    async ({ input }) => {
-      const openAiInput = inputFn(input);
-      const params = typeof openAiInput === "string" ? {
-        model: agentSettings.model,
-        messages: [
-          {
-            role: "user",
-            content: openAiInput
-          }
-        ]
-      } : openAiInput;
-      const response = await openai.chat.completions.create(params);
-      return response;
-    }
-  );
-}
-function fromChatStream(openai, agentSettings, inputFn) {
-  return (0, import_xstate2.fromObservable)(
-    ({ input }) => {
-      const observers = /* @__PURE__ */ new Set();
-      (async () => {
-        const openAiInput = inputFn(input);
-        const resolvedParams = typeof openAiInput === "string" ? {
-          model: agentSettings.model,
-          messages: [
-            {
-              role: "user",
-              content: openAiInput
-            }
-          ]
-        } : openAiInput;
-        const stream = await openai.chat.completions.create({
-          ...resolvedParams,
-          stream: true
-        });
-        for await (const part of stream) {
-          observers.forEach((observer) => {
-            observer.next?.(part);
-          });
-        }
-      })();
-      return {
-        subscribe: (...args) => {
-          const observer = (0, import_xstate2.toObserver)(...args);
-          observers.add(observer);
-          return {
-            unsubscribe: () => {
-              observers.delete(observer);
-            }
-          };
-        }
-      };
-    }
-  );
-}
-function fromEvent(openai, agentSettings, inputFn) {
-  return (0, import_xstate2.fromPromise)(
-    async ({ input, self, system }) => {
-      const parentSnapshot = self._parent?.getSnapshot();
-      if (!parentSnapshot || !(0, import_xstate2.isMachineSnapshot)(parentSnapshot)) {
-        return void 0;
-      }
-      const schemas = parentSnapshot.machine.schemas;
-      const eventSchemaMap = schemas.events ?? {};
-      const transitions = getAllTransitions(self._parent.getSnapshot());
-      const functionNameMapping = {};
-      const tools = transitions.filter((t) => {
-        return !t.eventType.startsWith("xstate.");
-      }).map((t) => {
-        const name = t.eventType.replace(/\./g, "_");
-        functionNameMapping[name] = t.eventType;
-        const eventSchema = eventSchemaMap[t.eventType];
-        const {
-          description,
-          properties: { type, ...properties }
-        } = eventSchema ?? {};
-        return {
-          type: "function",
-          function: {
-            name,
-            description: t.description ?? description,
-            parameters: {
-              type: "object",
-              properties: properties ?? {}
-            }
-          }
-        };
-      });
-      const openAiInput = inputFn(input);
-      const completionParams = typeof openAiInput === "string" ? {
-        model: agentSettings.model,
-        messages: [
-          {
-            role: "user",
-            content: openAiInput
-          }
-        ]
-      } : openAiInput;
-      const completion = await openai.chat.completions.create({
-        ...completionParams,
-        tools
-      });
-      const toolCalls = completion.choices[0]?.message.tool_calls;
-      if (toolCalls?.length) {
-        const events = toolCalls.map((tc) => {
-          return {
-            type: functionNameMapping[tc.function.name],
-            ...JSON.parse(tc.function.arguments)
-          };
+  agent.interact = (actorRef, getInput) => {
+    let prevState = void 0;
+    let subscribed = true;
+    async function handleObservation(observationInput) {
+      const observation = agent.addObservation(observationInput);
+      const input = getInput?.(observation);
+      if (input) {
+        await agentDecide(agent, {
+          machine: actorRef.src,
+          state: observation.state,
+          execute: async (event) => {
+            actorRef.send(event);
+          },
+          ...input
         });
-        const event = events[0];
-        system._relay(self, self._parent, event);
       }
-      return void 0;
+      prevState = observationInput.state;
     }
-  );
-}
-function fromTool(openai, agentSettings, tools, inputFn) {
-  return (0, import_xstate2.fromPromise)(async ({ input }) => {
-    const resolvedTools = Object.entries(tools).map(([key, value]) => {
-      return {
-        type: "function",
-        function: {
-          name: key,
-          description: value.description,
-          parameters: value.inputSchema
+    actorRef.system.inspect({
+      next: async (inspEvent) => {
+        if (!subscribed || inspEvent.actorRef !== actorRef || inspEvent.type !== "@xstate.snapshot") {
+          return;
         }
-      };
-    });
-    const openAiInput = inputFn(input);
-    const completionParams = typeof openAiInput === "string" ? {
-      model: agentSettings.model,
-      messages: [
-        {
-          role: "user",
-          content: openAiInput
-        }
-      ]
-    } : openAiInput;
-    const completion = await openai.chat.completions.create({
-      ...completionParams,
-      tools: resolvedTools
-    });
-    const toolCalls = completion.choices[0]?.message.tool_calls;
-    if (toolCalls?.length) {
-      const toolCall = toolCalls[0];
-      const tool = tools[toolCall.function.name];
-      const args = JSON.parse(toolCall.function.arguments);
-      if (tool) {
-        const result = await tool.run(args);
-        return {
-          toolCall,
-          tool: toolCall.function.name,
-          result
+        const observationInput = {
+          event: inspEvent.event,
+          prevState,
+          state: inspEvent.snapshot
         };
+        await handleObservation(observationInput);
       }
+    });
+    if (actorRef._processingStatus === 1) {
+      handleObservation({
+        prevState: void 0,
+        event: { type: "" },
+        // TODO: unknown events?
+        state: actorRef.getSnapshot()
+      });
     }
-    return void 0;
-  });
-}
-function createOpenAIAdapter(openai, settings) {
-  const agentSettings = {
-    model: settings.model,
-    fromEvent: (input) => fromEvent(openai, agentSettings, input),
-    fromChat: (input) => fromChatCompletion(openai, agentSettings, input),
-    fromChatStream: (input) => fromChatStream(openai, agentSettings, input),
-    fromTool: (input, tools) => fromTool(openai, agentSettings, tools, input)
+    return {
+      unsubscribe: () => {
+        subscribed = false;
+      }
+      // TODO: make this actually unsubscribe
+    };
   };
-  return agentSettings;
+  agent.start();
+  return agent;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  agentDecide,
+  agentGenerateText,
   createAgent,
-  createOpenAIAdapter,
-  defineEvents
+  fromDecision,
+  fromText,
+  fromTextStream
 });