@mettlelabs/mettle 0.0.0-beta.1-linux-arm64 → 0.0.0-beta.10

package/harness/chunk-qr8zfqjd.mjs

@@ -1,24 +0,0 @@
-import {
-  MastraGateway,
-  provider_registry_exports,
-  PROVIDER_REGISTRY,
-  parseModelString,
-  getProviderConfig,
-  modelSupportsAttachments,
-  modelSupportsTemperature,
-  modelSupportsStructuredOutput,
-  GatewayRegistry
-} from "./chunk-50sbrf09.mjs";
-import"./chunk-c1631s2x.mjs";
-import"./chunk-3wvjs93w.mjs";
-export {
-  modelSupportsTemperature as c,
-  MastraGateway as d,
-  parseModelString as l,
-  PROVIDER_REGISTRY as n,
-  modelSupportsAttachments as o,
-  getProviderConfig as r,
-  modelSupportsStructuredOutput as s,
-  GatewayRegistry as t,
-  provider_registry_exports as u
-};

package/harness/chunk-rz2tz6jp.mjs

@@ -1,26 +0,0 @@
-// node_modules/.bun/@mastra+core@1.71.0+95d98e20cbc6e6e1/node_modules/@mastra/core/dist/resolve-agent-LNSk8IsI.js
-async function resolveAgentById(mastra, agentId) {
-  try {
-    return {
-      status: "found",
-      agent: mastra.getAgentById(agentId)
-    };
-  } catch {}
-  const editor = mastra.getEditor?.();
-  if (!editor)
-    return { status: "missing" };
-  try {
-    const agent = await editor.agent.getById(agentId);
-    return agent ? {
-      status: "found",
-      agent
-    } : { status: "missing" };
-  } catch (error) {
-    return {
-      status: "error",
-      error
-    };
-  }
-}
-
-export { resolveAgentById };

package/harness/chunk-sbkgc3kn.mjs

@@ -1,8 +0,0 @@
-import {
-  netlify_exports,
-  NetlifyGateway
-} from "./chunk-3wvjs93w.mjs";
-export {
-  netlify_exports as n,
-  NetlifyGateway as t
-};

package/harness/chunk-v66qvpnb.mjs

@@ -1,169 +0,0 @@
-// node_modules/.bun/@mastra+core@1.71.0+95d98e20cbc6e6e1/node_modules/@mastra/core/dist/error-MjDSls8S.js
-function safeParseErrorObject(obj) {
-  if (typeof obj !== "object" || obj === null)
-    return String(obj);
-  try {
-    const stringified = JSON.stringify(obj);
-    if (stringified === "{}")
-      return String(obj);
-    return stringified;
-  } catch {
-    return String(obj);
-  }
-}
-function getErrorFromUnknown(unknown, options = {}) {
-  const defaultOptions = {
-    fallbackMessage: "Unknown error",
-    maxDepth: 5,
-    supportSerialization: true,
-    serializeStack: true
-  };
-  const mergedOptions = options ? {
-    ...defaultOptions,
-    ...options
-  } : defaultOptions;
-  const { fallbackMessage, maxDepth, supportSerialization, serializeStack } = mergedOptions;
-  if (unknown && unknown instanceof Error) {
-    if (supportSerialization)
-      addErrorToJSON(unknown, serializeStack, { maxDepth });
-    return unknown;
-  }
-  let error;
-  if (unknown && typeof unknown === "object") {
-    const errorMessage = unknown && "message" in unknown && typeof unknown.message === "string" ? unknown.message : safeParseErrorObject(unknown);
-    const errorCause = "cause" in unknown && unknown.cause !== undefined ? unknown.cause instanceof Error ? unknown.cause : maxDepth > 0 ? getErrorFromUnknown(unknown.cause, {
-      ...mergedOptions,
-      maxDepth: maxDepth - 1
-    }) : undefined : undefined;
-    error = new Error(errorMessage, errorCause ? { cause: errorCause } : undefined);
-    Object.assign(error, unknown);
-    error.stack = "stack" in unknown && typeof unknown.stack === "string" ? unknown.stack : undefined;
-  } else if (unknown && typeof unknown === "string") {
-    error = new Error(unknown);
-    error.stack = undefined;
-  } else
-    error = new Error(fallbackMessage);
-  if (supportSerialization)
-    addErrorToJSON(error, serializeStack, { maxDepth });
-  return error;
-}
-var DEFAULT_MAX_DEPTH = 5;
-function addErrorToJSON(error, serializeStack = true, options) {
-  const maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
-  const currentDepth = options?.currentDepth ?? 0;
-  if (error.toJSON)
-    return;
-  if (error.cause instanceof Error && currentDepth < maxDepth)
-    addErrorToJSON(error.cause, serializeStack, {
-      maxDepth,
-      currentDepth: currentDepth + 1
-    });
-  Object.defineProperty(error, "toJSON", {
-    value: function() {
-      const json = {
-        message: this.message,
-        name: this.name
-      };
-      if (serializeStack && this.stack !== undefined)
-        json.stack = this.stack;
-      if (this.cause !== undefined)
-        if (this.cause instanceof Error && "toJSON" in this.cause && typeof this.cause.toJSON === "function")
-          json.cause = this.cause.toJSON();
-        else
-          json.cause = this.cause;
-      const errorAsAny = this;
-      for (const key in errorAsAny)
-        if (errorAsAny.hasOwnProperty(key) && !(key in json) && key !== "toJSON")
-          json[key] = errorAsAny[key];
-      return json;
-    },
-    enumerable: false,
-    writable: true,
-    configurable: true
-  });
-}
-var ErrorDomain = /* @__PURE__ */ function(ErrorDomain) {
-  ErrorDomain["TOOL"] = "TOOL";
-  ErrorDomain["AGENT"] = "AGENT";
-  ErrorDomain["MCP"] = "MCP";
-  ErrorDomain["AGENT_NETWORK"] = "AGENT_NETWORK";
-  ErrorDomain["MASTRA_SERVER"] = "MASTRA_SERVER";
-  ErrorDomain["MASTRA_OBSERVABILITY"] = "MASTRA_OBSERVABILITY";
-  ErrorDomain["MASTRA_WORKFLOW"] = "MASTRA_WORKFLOW";
-  ErrorDomain["MASTRA_VOICE"] = "MASTRA_VOICE";
-  ErrorDomain["MASTRA_VECTOR"] = "MASTRA_VECTOR";
-  ErrorDomain["MASTRA_MEMORY"] = "MASTRA_MEMORY";
-  ErrorDomain["LLM"] = "LLM";
-  ErrorDomain["EVAL"] = "EVAL";
-  ErrorDomain["SCORER"] = "SCORER";
-  ErrorDomain["A2A"] = "A2A";
-  ErrorDomain["MASTRA_INSTANCE"] = "MASTRA_INSTANCE";
-  ErrorDomain["MASTRA"] = "MASTRA";
-  ErrorDomain["DEPLOYER"] = "DEPLOYER";
-  ErrorDomain["STORAGE"] = "STORAGE";
-  ErrorDomain["MODEL_ROUTER"] = "MODEL_ROUTER";
-  return ErrorDomain;
-}({});
-var ErrorCategory = /* @__PURE__ */ function(ErrorCategory) {
-  ErrorCategory["UNKNOWN"] = "UNKNOWN";
-  ErrorCategory["USER"] = "USER";
-  ErrorCategory["SYSTEM"] = "SYSTEM";
-  ErrorCategory["THIRD_PARTY"] = "THIRD_PARTY";
-  return ErrorCategory;
-}({});
-var MastraBaseError = class extends Error {
-  id;
-  domain;
-  category;
-  details = {};
-  message;
-  cause;
-  constructor(errorDefinition, originalError) {
-    const error = originalError ? getErrorFromUnknown(originalError, {
-      serializeStack: false,
-      fallbackMessage: "Unknown error"
-    }) : undefined;
-    const message = errorDefinition.text ?? error?.message ?? "Unknown error";
-    super(message, { cause: error });
-    this.id = errorDefinition.id;
-    this.domain = errorDefinition.domain;
-    this.category = errorDefinition.category;
-    this.details = errorDefinition.details ?? {};
-    this.message = message;
-    this.cause = error;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-  toJSONDetails() {
-    return {
-      message: this.message,
-      domain: this.domain,
-      category: this.category,
-      details: this.details
-    };
-  }
-  toJSON() {
-    return {
-      message: this.message,
-      domain: this.domain,
-      category: this.category,
-      code: this.id,
-      details: this.details,
-      cause: this.cause?.toJSON?.()
-    };
-  }
-  toString() {
-    return JSON.stringify(this.toJSON());
-  }
-};
-var MastraError = class extends MastraBaseError {
-};
-var MastraNonRetryableError = class extends Error {
-  isNonRetryable = true;
-  constructor(message, options) {
-    super(message, options);
-    this.name = "MastraNonRetryableError";
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-
-export { getErrorFromUnknown, ErrorDomain, ErrorCategory, MastraError, MastraNonRetryableError };

package/harness/chunk-vjaxzab3.mjs

@@ -1,136 +0,0 @@
-// node_modules/.bun/p-map@7.0.8/node_modules/p-map/index.js
-async function pMap(iterable, mapper, {
-  concurrency = Number.POSITIVE_INFINITY,
-  stopOnError = true,
-  signal
-} = {}) {
-  return new Promise((resolve_, reject_) => {
-    if (iterable[Symbol.iterator] === undefined && iterable[Symbol.asyncIterator] === undefined) {
-      throw new TypeError(`Expected \`input\` to be either an \`Iterable\` or \`AsyncIterable\`, got (${typeof iterable})`);
-    }
-    if (typeof mapper !== "function") {
-      throw new TypeError("Mapper function is required");
-    }
-    if (!(Number.isSafeInteger(concurrency) && concurrency >= 1 || concurrency === Number.POSITIVE_INFINITY)) {
-      throw new TypeError(`Expected \`concurrency\` to be an integer from 1 and up or \`Infinity\`, got \`${concurrency}\` (${typeof concurrency})`);
-    }
-    const result = [];
-    const errors = [];
-    const skippedIndexesMap = new Map;
-    let isRejected = false;
-    let isResolved = false;
-    let isIterableDone = false;
-    let resolvingCount = 0;
-    let currentIndex = 0;
-    const iterator = iterable[Symbol.asyncIterator] === undefined ? iterable[Symbol.iterator]() : iterable[Symbol.asyncIterator]();
-    const signalListener = () => {
-      reject(signal.reason);
-    };
-    const cleanup = () => {
-      signal?.removeEventListener("abort", signalListener);
-    };
-    const resolve = (value) => {
-      resolve_(value);
-      cleanup();
-    };
-    const reject = (reason) => {
-      if (isResolved) {
-        return;
-      }
-      isRejected = true;
-      isResolved = true;
-      reject_(reason);
-      cleanup();
-      if (!isIterableDone) {
-        closeIterator(iterator);
-      }
-    };
-    if (signal) {
-      if (signal.aborted) {
-        reject(signal.reason);
-        return;
-      }
-      signal.addEventListener("abort", signalListener, { once: true });
-    }
-    const next = async () => {
-      if (isResolved) {
-        return;
-      }
-      const nextItem = isIterableDone ? { done: true } : await iterator.next();
-      const index = currentIndex;
-      currentIndex++;
-      if (nextItem.done) {
-        isIterableDone = true;
-        if (resolvingCount === 0 && !isResolved) {
-          if (!stopOnError && errors.length > 0) {
-            reject(new AggregateError(errors));
-            return;
-          }
-          isResolved = true;
-          if (skippedIndexesMap.size === 0) {
-            resolve(result);
-            return;
-          }
-          const pureResult = [];
-          for (const [index, value] of result.entries()) {
-            if (skippedIndexesMap.get(index) === pMapSkip) {
-              continue;
-            }
-            pureResult.push(value);
-          }
-          resolve(pureResult);
-        }
-        return;
-      }
-      resolvingCount++;
-      (async () => {
-        try {
-          const element = await nextItem.value;
-          if (isResolved) {
-            return;
-          }
-          const value = await mapper(element, index);
-          if (value === pMapSkip) {
-            skippedIndexesMap.set(index, value);
-          }
-          result[index] = value;
-        } catch (error) {
-          if (stopOnError) {
-            reject(error);
-            return;
-          }
-          errors.push(error);
-        }
-        resolvingCount--;
-        try {
-          await next();
-        } catch (error) {
-          reject(error);
-        }
-      })();
-    };
-    (async () => {
-      for (let index = 0;index < concurrency; index++) {
-        try {
-          await next();
-        } catch (error) {
-          reject(error);
-          break;
-        }
-        if (isIterableDone || isRejected) {
-          break;
-        }
-      }
-    })();
-  });
-}
-var pMapSkip = Symbol("skip");
-async function closeIterator(iterator) {
-  try {
-    await iterator.return?.();
-  } catch {}
-}
-export {
-  pMap as default,
-  pMapSkip
-};