@mettlelabs/mettle 0.0.0-beta.1 → 0.0.0-beta.1-linux-x64

package/harness/chunk-qr8zfqjd.mjs

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,26 @@
+// 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

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

package/harness/chunk-v66qvpnb.mjs

@@ -0,0 +1,169 @@
+// 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

@@ -0,0 +1,136 @@
+// 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
+};