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

package/harness/chunk-fjx29qvp.mjs

@@ -0,0 +1,50 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM2 = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+export { __toESM2, __commonJS, __export, __require };

package/harness/chunk-gryka6kg.mjs

@@ -0,0 +1,39 @@
+import {
+  MastraError
+} from "./chunk-v66qvpnb.mjs";
+
+// node_modules/.bun/@mastra+core@1.71.0+95d98e20cbc6e6e1/node_modules/@mastra/core/dist/gateway-helpers-Dh-2ojNA.js
+function getCapabilityFileName(provider) {
+  return `${encodeURIComponent(provider)}.json`;
+}
+function getGatewayId(gateway) {
+  return gateway.getId?.() ?? gateway.id;
+}
+function shouldEnableGateway(gateway) {
+  return gateway.shouldEnable?.() ?? true;
+}
+function hasAuthCredentials(auth) {
+  return Boolean(auth?.apiKey || auth?.bearerToken || auth?.headers && Object.keys(auth.headers).length > 0);
+}
+function findGatewayForModel(gatewayId, gateways) {
+  const prefixedGateway = gateways.find((g) => {
+    const id = getGatewayId(g);
+    return id !== "models.dev" && (id === gatewayId || gatewayId.startsWith(`${id}/`));
+  });
+  if (prefixedGateway)
+    return prefixedGateway;
+  const claimingGateway = gateways.find((g) => getGatewayId(g) !== "models.dev" && g.handlesModel?.(gatewayId) === true);
+  if (claimingGateway)
+    return claimingGateway;
+  const modelsDevGateway = gateways.find((g) => getGatewayId(g) === "models.dev");
+  if (modelsDevGateway)
+    return modelsDevGateway;
+  throw new MastraError({
+    id: "MODEL_ROUTER_NO_GATEWAY_FOUND",
+    category: "USER",
+    domain: "MODEL_ROUTER",
+    text: `No Mastra model router gateway found for model id ${gatewayId}`
+  });
+}
+
+export { getCapabilityFileName, getGatewayId, shouldEnableGateway, hasAuthCredentials, findGatewayForModel };

package/harness/chunk-jb0r19et.mjs

@@ -0,0 +1,180 @@
+import {
+  string,
+  number,
+  boolean,
+  _null,
+  unknown,
+  object,
+  union,
+  record,
+  _enum
+} from "./chunk-1sygmp11.mjs";
+
+// node_modules/.bun/@mastra+core@1.71.0+95d98e20cbc6e6e1/node_modules/@mastra/core/dist/define-vaqWwloq.js
+var AGENT_SCHEDULE_PREFIX = "agent_";
+var WORKFLOW_SCHEDULE_PREFIX = "schedule_";
+var SCHEDULE_SIGNAL_TYPES = [
+  "user",
+  "state",
+  "reactive",
+  "notification",
+  "user-message",
+  "system-reminder"
+];
+var ScheduleAttributesSchema = record(string(), union([
+  string(),
+  number(),
+  boolean(),
+  _null()
+]));
+var ScheduleStreamOptionsSchema = object({ requestContext: record(string(), unknown()).optional() });
+var ScheduleIfActiveSchema = object({
+  behavior: _enum([
+    "deliver",
+    "persist",
+    "discard"
+  ]).optional(),
+  attributes: ScheduleAttributesSchema.optional()
+});
+var ScheduleIfIdleSchema = object({
+  behavior: _enum([
+    "wake",
+    "persist",
+    "discard"
+  ]).optional(),
+  attributes: ScheduleAttributesSchema.optional(),
+  streamOptions: ScheduleStreamOptionsSchema.optional()
+});
+var ScheduleInputSchema = object({
+  scheduleId: string(),
+  agentId: string(),
+  prompt: string(),
+  threadId: string().optional(),
+  resourceId: string().optional(),
+  signalType: _enum(SCHEDULE_SIGNAL_TYPES).optional(),
+  tagName: string().optional(),
+  attributes: ScheduleAttributesSchema.optional(),
+  providerOptions: record(string(), unknown()).optional(),
+  ifActive: ScheduleIfActiveSchema.optional(),
+  ifIdle: ScheduleIfIdleSchema.optional()
+});
+var ScheduleOutputSchema = object({
+  status: _enum([
+    "fired",
+    "signal-accepted",
+    "skipped-thread-blocked",
+    "thread-missing",
+    "agent-missing",
+    "invalid-input"
+  ]),
+  reason: string().optional()
+});
+var FS_AGENT_SCHEDULE_PREFIX = "fsa_";
+function encodeRowIdPart(value) {
+  return encodeURIComponent(value).replace(/_/g, "%5F");
+}
+function fsAgentScheduleRowId(agentId, key) {
+  return `${FS_AGENT_SCHEDULE_PREFIX}${encodeRowIdPart(agentId)}__${encodeRowIdPart(key)}`;
+}
+function parseFsAgentScheduleRowId(rowId) {
+  if (!rowId.startsWith("fsa_"))
+    return;
+  const rest = rowId.slice(4);
+  const separator = rest.indexOf("__");
+  if (separator <= 0)
+    return;
+  try {
+    return {
+      agentId: decodeURIComponent(rest.slice(0, separator)),
+      key: decodeURIComponent(rest.slice(separator + 2))
+    };
+  } catch {
+    return;
+  }
+}
+
+// node_modules/.bun/@mastra+core@1.71.0+95d98e20cbc6e6e1/node_modules/@mastra/core/dist/pull-transport-D6pSbsAj.js
+var MastraWorker = class {
+  mastra;
+  deps;
+  __registerMastra(mastra) {
+    this.mastra = mastra;
+  }
+  async init(deps) {
+    this.deps = deps;
+    if (!this.mastra && deps.mastra)
+      this.mastra = deps.mastra;
+  }
+};
+var MAX_DRAIN_TIMEOUT_MS = 2147483647;
+function assertDrainTimeout(value, label) {
+  if (!Number.isFinite(value) || value < 0 || value > 2147483647)
+    throw new RangeError(`${label} drainTimeout must be a finite number of milliseconds between 0 and ${MAX_DRAIN_TIMEOUT_MS}`);
+  return value;
+}
+var TOPIC_WORKFLOWS = "workflows";
+var DEFAULT_DRAIN_TIMEOUT_MS = 5000;
+var PullTransport = class {
+  #pubsub;
+  #group;
+  #topic;
+  #logger;
+  #drainTimeout;
+  #callbacks = [];
+  #inFlight = /* @__PURE__ */ new Set;
+  constructor({ pubsub, group, topic, logger, drainTimeout }) {
+    this.#pubsub = pubsub;
+    this.#group = group;
+    this.#topic = topic ?? TOPIC_WORKFLOWS;
+    this.#logger = logger;
+    this.#drainTimeout = assertDrainTimeout(drainTimeout ?? DEFAULT_DRAIN_TIMEOUT_MS, "PullTransport");
+  }
+  async start(router) {
+    if (this.#callbacks.length > 0) {
+      this.#logger?.debug("[PullTransport] start() called while already subscribed; ignoring duplicate call");
+      return;
+    }
+    const cb = (event, ack, nack) => {
+      const inFlight = router.route(event, ack, nack).catch((err) => {
+        try {
+          if (typeof nack === "function")
+            nack();
+        } finally {
+          this.#logger?.error("[PullTransport] router.route rejected", { err });
+        }
+      });
+      this.#inFlight.add(inFlight);
+      inFlight.finally(() => this.#inFlight.delete(inFlight));
+    };
+    await this.#pubsub.subscribe(this.#topic, cb, { group: this.#group });
+    this.#callbacks.push({
+      topic: this.#topic,
+      cb
+    });
+  }
+  async stop(options) {
+    const drainTimeout = assertDrainTimeout(options?.drainTimeout ?? this.#drainTimeout, "PullTransport.stop()");
+    for (const { topic, cb } of this.#callbacks)
+      await this.#pubsub.unsubscribe(topic, cb);
+    this.#callbacks = [];
+    await this.#drainInFlight(drainTimeout);
+    await this.#pubsub.flush();
+  }
+  async#drainInFlight(drainTimeout) {
+    if (this.#inFlight.size === 0)
+      return;
+    const pending = this.#inFlight.size;
+    let timeoutHandle;
+    try {
+      if (await Promise.race([Promise.allSettled([...this.#inFlight]).then(() => false), new Promise((resolve) => {
+        timeoutHandle = setTimeout(() => resolve(true), drainTimeout);
+      })]))
+        this.#logger?.warn(`[PullTransport] stop() timed out after ${drainTimeout}ms waiting for ${pending} in-flight event(s)`);
+    } finally {
+      if (timeoutHandle)
+        clearTimeout(timeoutHandle);
+    }
+  }
+};
+
+export { AGENT_SCHEDULE_PREFIX, WORKFLOW_SCHEDULE_PREFIX, fsAgentScheduleRowId, parseFsAgentScheduleRowId, MastraWorker, assertDrainTimeout, PullTransport };

package/harness/chunk-mfn574ss.mjs

@@ -0,0 +1,179 @@
+// node_modules/.bun/@mastra+core@1.71.0+95d98e20cbc6e6e1/node_modules/@mastra/core/dist/request-context-BGr5xGOr.js
+var MASTRA_RESOURCE_ID_KEY = "mastra__resourceId";
+var MASTRA_THREAD_ID_KEY = "mastra__threadId";
+var MASTRA_VERSIONS_KEY = "mastra__versions";
+var MASTRA_AUTH_TOKEN_KEY = "mastra__authToken";
+var MASTRA_INHERITED_MEMORY_KEY = "mastra__inheritedMemory";
+var MASTRA_MESSAGE_AUTHOR_KEY = "mastra__messageAuthor";
+function mergeVersionOverrides(base, overrides) {
+  if (!base && !overrides)
+    return;
+  return {
+    ...base,
+    ...overrides,
+    agents: {
+      ...base?.agents,
+      ...overrides?.agents
+    },
+    ...overrides?.defaultStatus ? { defaultStatus: overrides.defaultStatus } : base?.defaultStatus ? { defaultStatus: base.defaultStatus } : {}
+  };
+}
+var CyclicRequestContextToJSONError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CyclicRequestContextToJSONError";
+  }
+};
+var _toJSONInProgress = /* @__PURE__ */ new WeakSet;
+var _toJSONDepth = 0;
+var SERIALIZATION_PROBE_BUDGET = 1e6;
+var _typedArrayLength = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Int8Array.prototype), "length").get;
+function isPlainObjectOrArray(value) {
+  try {
+    if (Array.isArray(value))
+      return true;
+    if (value === null || typeof value !== "object")
+      return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+  } catch {
+    return false;
+  }
+}
+var _probeBudgetActive = false;
+var _probeBudgetRemaining = 0;
+var RequestContext = class {
+  registry = /* @__PURE__ */ new Map;
+  constructor(iterable) {
+    if (iterable && typeof iterable === "object" && typeof iterable[Symbol.iterator] !== "function")
+      this.registry = new Map(Object.entries(iterable));
+    else
+      this.registry = new Map(iterable);
+  }
+  set(key, value) {
+    this.registry.set(key, value);
+  }
+  setRaw(key, value) {
+    this.registry.set(key, value);
+  }
+  get(key) {
+    return this.registry.get(key);
+  }
+  getRaw(key) {
+    return this.registry.get(key);
+  }
+  has(key) {
+    return this.registry.has(key);
+  }
+  hasRaw(key) {
+    return this.registry.has(key);
+  }
+  delete(key) {
+    return this.registry.delete(key);
+  }
+  deleteRaw(key) {
+    return this.registry.delete(key);
+  }
+  clear() {
+    this.registry.clear();
+  }
+  keys() {
+    return this.registry.keys();
+  }
+  values() {
+    return this.registry.values();
+  }
+  entries() {
+    return this.registry.entries();
+  }
+  size() {
+    return this.registry.size;
+  }
+  forEach(callbackfn) {
+    this.registry.forEach(callbackfn);
+  }
+  toJSON() {
+    if (_toJSONInProgress.has(this))
+      throw new CyclicRequestContextToJSONError("RequestContext.toJSON: detected cyclic re-entry (a stored value transitively references this context)");
+    _toJSONInProgress.add(this);
+    _toJSONDepth++;
+    try {
+      const result = {};
+      for (const [key, value] of this.registry.entries())
+        if (this.isSerializable(value))
+          result[key] = value;
+      return result;
+    } finally {
+      _toJSONInProgress.delete(this);
+      _toJSONDepth--;
+    }
+  }
+  isSerializable(value) {
+    if (value === null || value === undefined)
+      return true;
+    if (typeof value === "function")
+      return false;
+    if (typeof value === "symbol")
+      return false;
+    if (typeof value !== "object" && typeof value !== "bigint")
+      return true;
+    const outermostProbe = !_probeBudgetActive;
+    if (outermostProbe) {
+      _probeBudgetActive = true;
+      _probeBudgetRemaining = SERIALIZATION_PROBE_BUDGET;
+    }
+    try {
+      JSON.stringify(value, (_key, probed) => {
+        if (--_probeBudgetRemaining < 0)
+          throw new RangeError("RequestContext.isSerializable: value expands past the serialization probe budget");
+        if (ArrayBuffer.isView(probed)) {
+          let elementCount;
+          try {
+            elementCount = _typedArrayLength.call(probed);
+          } catch {
+            return probed;
+          }
+          if (typeof probed[0] === "bigint")
+            return probed;
+          _probeBudgetRemaining -= elementCount;
+          if (_probeBudgetRemaining < 0)
+            throw new RangeError("RequestContext.isSerializable: value expands past the serialization probe budget");
+          const surrogate = Object.create(null);
+          for (const key of Object.keys(probed)) {
+            const index = Number(key);
+            if (!(Number.isInteger(index) && index >= 0 && String(index) === key))
+              surrogate[key] = probed[key];
+          }
+          return surrogate;
+        }
+        return probed;
+      });
+      return true;
+    } catch (e) {
+      if (e instanceof CyclicRequestContextToJSONError && _toJSONDepth > 1)
+        throw e;
+      return false;
+    } finally {
+      if (outermostProbe)
+        _probeBudgetActive = false;
+    }
+  }
+  serializeForSpan() {
+    const safe = {};
+    for (const [key, value] of this.registry.entries())
+      if (key === "mastra__authToken")
+        safe[key] = "[REDACTED]";
+      else if (value === null || value === undefined || typeof value === "string" || typeof value === "number" || typeof value === "boolean")
+        safe[key] = value;
+      else if (isPlainObjectOrArray(value))
+        safe[key] = value;
+      else
+        safe[key] = `[${typeof value}]`;
+    return safe;
+  }
+  get all() {
+    return Object.fromEntries(this.registry);
+  }
+};
+
+export { MASTRA_RESOURCE_ID_KEY, MASTRA_THREAD_ID_KEY, MASTRA_VERSIONS_KEY, MASTRA_AUTH_TOKEN_KEY, MASTRA_INHERITED_MEMORY_KEY, MASTRA_MESSAGE_AUTHOR_KEY, mergeVersionOverrides, RequestContext };