@mastra/nestjs 0.1.8-alpha.0 → 0.1.8-alpha.2

package/dist/_types/rxjs/dist/types/internal/util/NotFoundError.d.ts

@@ -0,0 +1,19 @@
+export interface NotFoundError extends Error {
+}
+export interface NotFoundErrorCtor {
+    /**
+     * @deprecated Internal implementation detail. Do not construct error instances.
+     * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269
+     */
+    new (message: string): NotFoundError;
+}
+/**
+ * An error thrown when a value or values are missing from an
+ * observable sequence.
+ *
+ * @see {@link operators/single}
+ *
+ * @class NotFoundError
+ */
+export declare const NotFoundError: NotFoundErrorCtor;
+//# sourceMappingURL=NotFoundError.d.ts.map

package/dist/_types/rxjs/dist/types/internal/util/ObjectUnsubscribedError.d.ts

@@ -0,0 +1,20 @@
+export interface ObjectUnsubscribedError extends Error {
+}
+export interface ObjectUnsubscribedErrorCtor {
+    /**
+     * @deprecated Internal implementation detail. Do not construct error instances.
+     * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269
+     */
+    new (): ObjectUnsubscribedError;
+}
+/**
+ * An error thrown when an action is invalid because the object has been
+ * unsubscribed.
+ *
+ * @see {@link Subject}
+ * @see {@link BehaviorSubject}
+ *
+ * @class ObjectUnsubscribedError
+ */
+export declare const ObjectUnsubscribedError: ObjectUnsubscribedErrorCtor;
+//# sourceMappingURL=ObjectUnsubscribedError.d.ts.map

package/dist/_types/rxjs/dist/types/internal/util/SequenceError.d.ts

@@ -0,0 +1,19 @@
+export interface SequenceError extends Error {
+}
+export interface SequenceErrorCtor {
+    /**
+     * @deprecated Internal implementation detail. Do not construct error instances.
+     * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269
+     */
+    new (message: string): SequenceError;
+}
+/**
+ * An error thrown when something is wrong with the sequence of
+ * values arriving on the observable.
+ *
+ * @see {@link operators/single}
+ *
+ * @class SequenceError
+ */
+export declare const SequenceError: SequenceErrorCtor;
+//# sourceMappingURL=SequenceError.d.ts.map

package/dist/_types/rxjs/dist/types/internal/util/UnsubscriptionError.d.ts

@@ -0,0 +1,16 @@
+export interface UnsubscriptionError extends Error {
+    readonly errors: any[];
+}
+export interface UnsubscriptionErrorCtor {
+    /**
+     * @deprecated Internal implementation detail. Do not construct error instances.
+     * Cannot be tagged as internal: https://github.com/ReactiveX/rxjs/issues/6269
+     */
+    new (errors: any[]): UnsubscriptionError;
+}
+/**
+ * An error thrown when one or more errors have occurred during the
+ * `unsubscribe` of a {@link Subscription}.
+ */
+export declare const UnsubscriptionError: UnsubscriptionErrorCtor;
+//# sourceMappingURL=UnsubscriptionError.d.ts.map

package/dist/_types/rxjs/dist/types/internal/util/identity.d.ts

@@ -0,0 +1,44 @@
+/**
+ * This function takes one parameter and just returns it. Simply put,
+ * this is like `<T>(x: T): T => x`.
+ *
+ * ## Examples
+ *
+ * This is useful in some cases when using things like `mergeMap`
+ *
+ * ```ts
+ * import { interval, take, map, range, mergeMap, identity } from 'rxjs';
+ *
+ * const source$ = interval(1000).pipe(take(5));
+ *
+ * const result$ = source$.pipe(
+ *   map(i => range(i)),
+ *   mergeMap(identity) // same as mergeMap(x => x)
+ * );
+ *
+ * result$.subscribe({
+ *   next: console.log
+ * });
+ * ```
+ *
+ * Or when you want to selectively apply an operator
+ *
+ * ```ts
+ * import { interval, take, identity } from 'rxjs';
+ *
+ * const shouldLimit = () => Math.random() < 0.5;
+ *
+ * const source$ = interval(1000);
+ *
+ * const result$ = source$.pipe(shouldLimit() ? take(5) : identity);
+ *
+ * result$.subscribe({
+ *   next: console.log
+ * });
+ * ```
+ *
+ * @param x Any value that is returned by this function
+ * @returns The value passed as the first parameter to this function
+ */
+export declare function identity<T>(x: T): T;
+//# sourceMappingURL=identity.d.ts.map

package/dist/_types/rxjs/dist/types/internal/util/isObservable.d.ts

@@ -0,0 +1,8 @@
+/** prettier */
+import { Observable } from '../Observable';
+/**
+ * Tests to see if the object is an RxJS {@link Observable}
+ * @param obj the object to test
+ */
+export declare function isObservable(obj: any): obj is Observable<unknown>;
+//# sourceMappingURL=isObservable.d.ts.map

package/dist/_types/rxjs/dist/types/internal/util/noop.d.ts

@@ -0,0 +1,2 @@
+export declare function noop(): void;
+//# sourceMappingURL=noop.d.ts.map

package/dist/_types/rxjs/dist/types/internal/util/pipe.d.ts

@@ -0,0 +1,14 @@
+import { identity } from './identity';
+import { UnaryFunction } from '../types';
+export declare function pipe(): typeof identity;
+export declare function pipe<T, A>(fn1: UnaryFunction<T, A>): UnaryFunction<T, A>;
+export declare function pipe<T, A, B>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>): UnaryFunction<T, B>;
+export declare function pipe<T, A, B, C>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>): UnaryFunction<T, C>;
+export declare function pipe<T, A, B, C, D>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>): UnaryFunction<T, D>;
+export declare function pipe<T, A, B, C, D, E>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>, fn5: UnaryFunction<D, E>): UnaryFunction<T, E>;
+export declare function pipe<T, A, B, C, D, E, F>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>, fn5: UnaryFunction<D, E>, fn6: UnaryFunction<E, F>): UnaryFunction<T, F>;
+export declare function pipe<T, A, B, C, D, E, F, G>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>, fn5: UnaryFunction<D, E>, fn6: UnaryFunction<E, F>, fn7: UnaryFunction<F, G>): UnaryFunction<T, G>;
+export declare function pipe<T, A, B, C, D, E, F, G, H>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>, fn5: UnaryFunction<D, E>, fn6: UnaryFunction<E, F>, fn7: UnaryFunction<F, G>, fn8: UnaryFunction<G, H>): UnaryFunction<T, H>;
+export declare function pipe<T, A, B, C, D, E, F, G, H, I>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>, fn5: UnaryFunction<D, E>, fn6: UnaryFunction<E, F>, fn7: UnaryFunction<F, G>, fn8: UnaryFunction<G, H>, fn9: UnaryFunction<H, I>): UnaryFunction<T, I>;
+export declare function pipe<T, A, B, C, D, E, F, G, H, I>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>, fn5: UnaryFunction<D, E>, fn6: UnaryFunction<E, F>, fn7: UnaryFunction<F, G>, fn8: UnaryFunction<G, H>, fn9: UnaryFunction<H, I>, ...fns: UnaryFunction<any, any>[]): UnaryFunction<T, unknown>;
+//# sourceMappingURL=pipe.d.ts.map

package/dist/index.cjs

@@ -3,6 +3,7 @@
 var common = require('@nestjs/common');
 var serverAdapter = require('@mastra/server/server-adapter');
 var error = require('@mastra/server/handlers/error');
+var zod = require('zod');
 var auth = require('@mastra/server/auth');
 var requestContext = require('@mastra/core/request-context');
 var core = require('@nestjs/core');
@@ -11652,232 +11653,6 @@ var MASTRA = /* @__PURE__ */ Symbol("MASTRA");
 var MASTRA_OPTIONS = /* @__PURE__ */ Symbol("MASTRA_OPTIONS");
 var IS_PUBLIC_KEY = "isPublic";
 var THROTTLE_KEY = "mastraThrottle";
-
-// ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/helpers/util.js
-var util;
-(function(util2) {
-  util2.assertEqual = (_) => {
-  };
-  function assertIs(_arg) {
-  }
-  __name(assertIs, "assertIs");
-  util2.assertIs = assertIs;
-  function assertNever(_x) {
-    throw new Error();
-  }
-  __name(assertNever, "assertNever");
-  util2.assertNever = assertNever;
-  util2.arrayToEnum = (items) => {
-    const obj = {};
-    for (const item of items) {
-      obj[item] = item;
-    }
-    return obj;
-  };
-  util2.getValidEnumValues = (obj) => {
-    const validKeys = util2.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
-    const filtered = {};
-    for (const k of validKeys) {
-      filtered[k] = obj[k];
-    }
-    return util2.objectValues(filtered);
-  };
-  util2.objectValues = (obj) => {
-    return util2.objectKeys(obj).map(function(e) {
-      return obj[e];
-    });
-  };
-  util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
-    const keys = [];
-    for (const key in object) {
-      if (Object.prototype.hasOwnProperty.call(object, key)) {
-        keys.push(key);
-      }
-    }
-    return keys;
-  };
-  util2.find = (arr, checker) => {
-    for (const item of arr) {
-      if (checker(item)) return item;
-    }
-    return void 0;
-  };
-  util2.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
-  function joinValues(array, separator = " | ") {
-    return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
-  }
-  __name(joinValues, "joinValues");
-  util2.joinValues = joinValues;
-  util2.jsonStringifyReplacer = (_, value) => {
-    if (typeof value === "bigint") {
-      return value.toString();
-    }
-    return value;
-  };
-})(util || (util = {}));
-var objectUtil;
-(function(objectUtil2) {
-  objectUtil2.mergeShapes = (first, second) => {
-    return {
-      ...first,
-      ...second
-    };
-  };
-})(objectUtil || (objectUtil = {}));
-util.arrayToEnum([
-  "string",
-  "nan",
-  "number",
-  "integer",
-  "float",
-  "boolean",
-  "date",
-  "bigint",
-  "symbol",
-  "function",
-  "undefined",
-  "null",
-  "array",
-  "object",
-  "unknown",
-  "promise",
-  "void",
-  "never",
-  "map",
-  "set"
-]);
-
-// ../../node_modules/.pnpm/zod@3.25.76/node_modules/zod/v3/ZodError.js
-util.arrayToEnum([
-  "invalid_type",
-  "invalid_literal",
-  "custom",
-  "invalid_union",
-  "invalid_union_discriminator",
-  "invalid_enum_value",
-  "unrecognized_keys",
-  "invalid_arguments",
-  "invalid_return_type",
-  "invalid_date",
-  "invalid_string",
-  "too_small",
-  "too_big",
-  "invalid_intersection_types",
-  "not_multiple_of",
-  "not_finite"
-]);
-var ZodError = class _ZodError extends Error {
-  static {
-    __name(this, "ZodError");
-  }
-  get errors() {
-    return this.issues;
-  }
-  constructor(issues) {
-    super();
-    this.issues = [];
-    this.addIssue = (sub) => {
-      this.issues = [
-        ...this.issues,
-        sub
-      ];
-    };
-    this.addIssues = (subs = []) => {
-      this.issues = [
-        ...this.issues,
-        ...subs
-      ];
-    };
-    const actualProto = new.target.prototype;
-    if (Object.setPrototypeOf) {
-      Object.setPrototypeOf(this, actualProto);
-    } else {
-      this.__proto__ = actualProto;
-    }
-    this.name = "ZodError";
-    this.issues = issues;
-  }
-  format(_mapper) {
-    const mapper = _mapper || function(issue) {
-      return issue.message;
-    };
-    const fieldErrors = {
-      _errors: []
-    };
-    const processError = /* @__PURE__ */ __name((error) => {
-      for (const issue of error.issues) {
-        if (issue.code === "invalid_union") {
-          issue.unionErrors.map(processError);
-        } else if (issue.code === "invalid_return_type") {
-          processError(issue.returnTypeError);
-        } else if (issue.code === "invalid_arguments") {
-          processError(issue.argumentsError);
-        } else if (issue.path.length === 0) {
-          fieldErrors._errors.push(mapper(issue));
-        } else {
-          let curr = fieldErrors;
-          let i = 0;
-          while (i < issue.path.length) {
-            const el = issue.path[i];
-            const terminal = i === issue.path.length - 1;
-            if (!terminal) {
-              curr[el] = curr[el] || {
-                _errors: []
-              };
-            } else {
-              curr[el] = curr[el] || {
-                _errors: []
-              };
-              curr[el]._errors.push(mapper(issue));
-            }
-            curr = curr[el];
-            i++;
-          }
-        }
-      }
-    }, "processError");
-    processError(this);
-    return fieldErrors;
-  }
-  static assert(value) {
-    if (!(value instanceof _ZodError)) {
-      throw new Error(`Not a ZodError: ${value}`);
-    }
-  }
-  toString() {
-    return this.message;
-  }
-  get message() {
-    return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
-  }
-  get isEmpty() {
-    return this.issues.length === 0;
-  }
-  flatten(mapper = (issue) => issue.message) {
-    const fieldErrors = {};
-    const formErrors = [];
-    for (const sub of this.issues) {
-      if (sub.path.length > 0) {
-        const firstEl = sub.path[0];
-        fieldErrors[firstEl] = fieldErrors[firstEl] || [];
-        fieldErrors[firstEl].push(mapper(sub));
-      } else {
-        formErrors.push(mapper(sub));
-      }
-    }
-    return {
-      formErrors,
-      fieldErrors
-    };
-  }
-  get formErrors() {
-    return this.flatten();
-  }
-};
-ZodError.create = (issues) => {
-  const error = new ZodError(issues);
-  return error;
-};
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -11896,7 +11671,7 @@ function _ts_param(paramIndex, decorator) {
 }
 __name(_ts_param, "_ts_param");
 function isZodErrorLike(error) {
-  return error instanceof ZodError || typeof error === "object" && error !== null && "name" in error && error.name === "ZodError" && "issues" in error && Array.isArray(error.issues);
+  return error instanceof zod.ZodError || typeof error === "object" && error !== null && "name" in error && error.name === "ZodError" && "issues" in error && Array.isArray(error.issues);
 }
 __name(isZodErrorLike, "isZodErrorLike");
 exports.RouteHandlerService = class _RouteHandlerService {
@@ -12114,7 +11889,7 @@ function _ts_decorate2(decorators, target, key, desc) {
 }
 __name(_ts_decorate2, "_ts_decorate");
 function isZodErrorLike2(exception) {
-  return exception instanceof ZodError || typeof exception === "object" && exception !== null && "name" in exception && exception.name === "ZodError" && "issues" in exception && Array.isArray(exception.issues);
+  return exception instanceof zod.ZodError || typeof exception === "object" && exception !== null && "name" in exception && exception.name === "ZodError" && "issues" in exception && Array.isArray(exception.issues);
 }
 __name(isZodErrorLike2, "isZodErrorLike");
 exports.MastraExceptionFilter = class _MastraExceptionFilter {