@mettlelabs/mettle 0.0.0-beta.2-linux-arm64 → 0.0.0-beta.2

package/harness/chunk-3wvjs93w.mjs

@@ -1,538 +0,0 @@
-import {
-  MastraBase
-} from "./chunk-2pm2sayw.mjs";
-import {
-  MastraError
-} from "./chunk-v66qvpnb.mjs";
-import {
-  createOpenAICompatible,
-  createOpenAI,
-  MastraModelGateway,
-  createAnthropic,
-  MASTRA_USER_AGENT,
-  createGoogleGenerativeAI
-} from "./chunk-bdv1rx4a.mjs";
-import {
-  __exportAll
-} from "./chunk-vsf2zajv.mjs";
-
-// node_modules/.bun/@isaacs+ttlcache@2.1.5/node_modules/@isaacs/ttlcache/dist/esm/index.js
-var perf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
-var now = () => perf.now();
-var isPosInt = (n) => !!n && n === Math.floor(n) && n > 0 && isFinite(n);
-var isPosIntOrInf = (n) => n === Infinity || isPosInt(n);
-var TIMER_MAX = 2 ** 31 - 1;
-
-class TTLCache {
-  expirations = Object.create(null);
-  data = new Map;
-  expirationMap = new Map;
-  ttl;
-  max;
-  updateAgeOnGet;
-  updateAgeOnHas;
-  noUpdateTTL;
-  noDisposeOnSet;
-  checkAgeOnGet;
-  checkAgeOnHas;
-  dispose;
-  timer;
-  timerExpiration;
-  immortalKeys = new Set;
-  constructor({ max = Infinity, ttl, updateAgeOnGet = false, checkAgeOnGet = false, updateAgeOnHas = false, checkAgeOnHas = false, noUpdateTTL = false, dispose, noDisposeOnSet = false } = {}) {
-    if (ttl !== undefined && !isPosIntOrInf(ttl)) {
-      throw new TypeError("ttl must be positive integer or Infinity if set");
-    }
-    if (!isPosIntOrInf(max)) {
-      throw new TypeError("max must be positive integer or Infinity");
-    }
-    this.ttl = ttl;
-    this.max = max;
-    this.updateAgeOnGet = !!updateAgeOnGet;
-    this.checkAgeOnGet = !!checkAgeOnGet;
-    this.updateAgeOnHas = !!updateAgeOnHas;
-    this.checkAgeOnHas = !!checkAgeOnHas;
-    this.noUpdateTTL = !!noUpdateTTL;
-    this.noDisposeOnSet = !!noDisposeOnSet;
-    if (dispose !== undefined) {
-      if (typeof dispose !== "function") {
-        throw new TypeError("dispose must be function if set");
-      }
-      this.dispose = dispose;
-    } else {
-      this.dispose = (_, __, ___) => {};
-    }
-    this.timer = undefined;
-    this.timerExpiration = undefined;
-  }
-  setTimer(expiration, ttl) {
-    if (this.timerExpiration && this.timerExpiration < expiration) {
-      return;
-    }
-    if (this.timer) {
-      clearTimeout(this.timer);
-    }
-    const t = setTimeout(() => {
-      this.timer = undefined;
-      this.timerExpiration = undefined;
-      this.purgeStale();
-      for (const exp in this.expirations) {
-        const e = Number(exp);
-        this.setTimer(e, e - now());
-        break;
-      }
-    }, Math.min(TIMER_MAX, Math.max(0, ttl)));
-    if (t.unref)
-      t.unref();
-    this.timerExpiration = expiration;
-    this.timer = t;
-  }
-  cancelTimer() {
-    if (this.timer) {
-      clearTimeout(this.timer);
-      this.timerExpiration = undefined;
-      this.timer = undefined;
-    }
-  }
-  cancelTimers() {
-    process.emitWarning("TTLCache.cancelTimers has been renamed to " + 'TTLCache.cancelTimer (no "s"), and will be removed in the next ' + "major version update");
-    return this.cancelTimer();
-  }
-  clear() {
-    const entries = this.dispose !== TTLCache.prototype.dispose ? [...this] : [];
-    this.data.clear();
-    this.expirationMap.clear();
-    this.cancelTimer();
-    this.expirations = Object.create(null);
-    for (const [key, val] of entries) {
-      this.dispose(val, key, "delete");
-    }
-  }
-  setTTL(key, ttl = this.ttl) {
-    const current = this.expirationMap.get(key);
-    if (current !== undefined) {
-      const exp = this.expirations[current];
-      if (!exp || exp.length <= 1) {
-        delete this.expirations[current];
-      } else {
-        this.expirations[current] = exp.filter((k) => k !== key);
-      }
-    }
-    if (ttl && ttl !== Infinity) {
-      this.immortalKeys.delete(key);
-      const expiration = Math.floor(now() + ttl);
-      this.expirationMap.set(key, expiration);
-      if (!this.expirations[expiration]) {
-        this.expirations[expiration] = [];
-        this.setTimer(expiration, ttl);
-      }
-      this.expirations[expiration].push(key);
-    } else {
-      this.immortalKeys.add(key);
-      this.expirationMap.set(key, Infinity);
-    }
-  }
-  set(key, val, { ttl = this.ttl, noUpdateTTL = this.noUpdateTTL, noDisposeOnSet = this.noDisposeOnSet } = {}) {
-    if (!isPosIntOrInf(ttl)) {
-      throw new TypeError("ttl must be positive integer or Infinity");
-    }
-    if (this.expirationMap.has(key)) {
-      if (!noUpdateTTL) {
-        this.setTTL(key, ttl);
-      }
-      const oldValue = this.data.get(key);
-      const disp = !noDisposeOnSet && this.data.has(key);
-      if (oldValue !== val) {
-        this.data.set(key, val);
-        if (disp) {
-          this.dispose(oldValue, key, "set");
-        }
-      }
-    } else {
-      this.setTTL(key, ttl);
-      this.data.set(key, val);
-    }
-    while (this.size > this.max) {
-      this.purgeToCapacity();
-    }
-    return this;
-  }
-  has(key, { checkAgeOnHas = this.checkAgeOnHas, ttl = this.ttl, updateAgeOnHas = this.updateAgeOnHas } = {}) {
-    if (this.data.has(key)) {
-      if (checkAgeOnHas && this.getRemainingTTL(key) === 0) {
-        this.delete(key);
-        return false;
-      }
-      if (updateAgeOnHas) {
-        this.setTTL(key, ttl);
-      }
-      return true;
-    }
-    return false;
-  }
-  getRemainingTTL(key) {
-    const expiration = this.expirationMap.get(key);
-    return expiration === Infinity ? expiration : expiration !== undefined ? Math.max(0, Math.ceil(expiration - now())) : 0;
-  }
-  get(key, { updateAgeOnGet = this.updateAgeOnGet, ttl = this.ttl, checkAgeOnGet = this.checkAgeOnGet } = {}) {
-    if (!this.data.has(key))
-      return;
-    const val = this.data.get(key);
-    if (checkAgeOnGet && this.getRemainingTTL(key) === 0) {
-      this.delete(key);
-      return;
-    }
-    if (updateAgeOnGet) {
-      this.setTTL(key, ttl);
-    }
-    return val;
-  }
-  delete(key) {
-    const current = this.expirationMap.get(key);
-    if (current !== undefined) {
-      const value = this.data.get(key);
-      this.data.delete(key);
-      this.expirationMap.delete(key);
-      this.immortalKeys.delete(key);
-      const exp = this.expirations[current];
-      if (exp) {
-        if (exp.length <= 1) {
-          delete this.expirations[current];
-        } else {
-          this.expirations[current] = exp.filter((k) => k !== key);
-        }
-      }
-      this.dispose(value, key, "delete");
-      if (this.size === 0) {
-        this.cancelTimer();
-      }
-      return true;
-    }
-    return false;
-  }
-  purgeToCapacity() {
-    for (const exp in this.expirations) {
-      const keys = this.expirations[exp];
-      if (this.size - keys.length >= this.max) {
-        delete this.expirations[exp];
-        const entries = [];
-        for (const key of keys) {
-          entries.push([key, this.data.get(key)]);
-          this.data.delete(key);
-          this.expirationMap.delete(key);
-        }
-        for (const [key, val] of entries) {
-          this.dispose(val, key, "evict");
-        }
-      } else {
-        const s = this.size - this.max;
-        const entries = [];
-        for (const key of keys.splice(0, s)) {
-          entries.push([key, this.data.get(key)]);
-          this.data.delete(key);
-          this.expirationMap.delete(key);
-        }
-        for (const [key, val] of entries) {
-          this.dispose(val, key, "evict");
-        }
-        return;
-      }
-    }
-  }
-  get size() {
-    return this.data.size;
-  }
-  purgeStale() {
-    const n = Math.ceil(now());
-    for (const exp in this.expirations) {
-      if (exp === "Infinity" || Number(exp) > n) {
-        return;
-      }
-      const keys = [...this.expirations[exp] || []];
-      const entries = [];
-      delete this.expirations[exp];
-      for (const key of keys) {
-        entries.push([key, this.data.get(key)]);
-        this.data.delete(key);
-        this.expirationMap.delete(key);
-      }
-      for (const [key, val] of entries) {
-        this.dispose(val, key, "stale");
-      }
-    }
-    if (this.size === 0) {
-      this.cancelTimer();
-    }
-  }
-  *entries() {
-    for (const exp in this.expirations) {
-      for (const key of this.expirations[exp]) {
-        yield [key, this.data.get(key)];
-      }
-    }
-    for (const key of this.immortalKeys) {
-      yield [key, this.data.get(key)];
-    }
-  }
-  *keys() {
-    for (const exp in this.expirations) {
-      for (const key of this.expirations[exp]) {
-        yield key;
-      }
-    }
-    for (const key of this.immortalKeys) {
-      yield key;
-    }
-  }
-  *values() {
-    for (const exp in this.expirations) {
-      for (const key of this.expirations[exp]) {
-        yield this.data.get(key);
-      }
-    }
-    for (const key of this.immortalKeys) {
-      yield this.data.get(key);
-    }
-  }
-  [Symbol.iterator]() {
-    return this.entries();
-  }
-}
-
-// node_modules/.bun/@mastra+core@1.71.0+95d98e20cbc6e6e1/node_modules/@mastra/core/dist/inmemory-D_cTX1px.js
-var MastraServerCache = class extends MastraBase {
-  constructor({ name }) {
-    super({
-      component: "SERVER_CACHE",
-      name
-    });
-  }
-  async listPushIndexed(listKey, counterKey, value) {
-    const index = await this.increment(counterKey) - 1;
-    await this.listPush(listKey, {
-      ...value,
-      index
-    });
-    return index;
-  }
-};
-var InMemoryServerCache = class extends MastraServerCache {
-  cache;
-  ttlMs;
-  constructor(options = {}) {
-    super({ name: "InMemoryServerCache" });
-    this.ttlMs = options.ttlMs ?? 1000 * 60 * 5;
-    const ttl = this.ttlMs > 0 ? this.ttlMs : Infinity;
-    this.cache = new TTLCache({
-      max: options.maxSize ?? 1000,
-      ttl
-    });
-  }
-  async get(key) {
-    return this.cache.get(key);
-  }
-  async set(key, value, ttlMs) {
-    if (ttlMs === undefined) {
-      this.cache.set(key, value);
-      return;
-    }
-    this.cache.set(key, value, { ttl: ttlMs > 0 ? ttlMs : Infinity });
-  }
-  async listLength(key) {
-    const value = this.cache.get(key);
-    if (value === undefined)
-      return 0;
-    if (!Array.isArray(value))
-      throw new Error(`${key} exists but is not an array`);
-    return value.length;
-  }
-  async listPush(key, value) {
-    const existing = this.cache.get(key);
-    if (Array.isArray(existing)) {
-      existing.push(value);
-      if (this.ttlMs > 0)
-        this.cache.set(key, existing, { ttl: this.ttlMs });
-    } else if (existing !== undefined)
-      throw new Error(`${key} exists but is not an array`);
-    else
-      this.cache.set(key, [value]);
-  }
-  async listFromTo(key, from, to = -1) {
-    const list = this.cache.get(key);
-    if (Array.isArray(list)) {
-      const endIndex = to === -1 ? undefined : to + 1;
-      return list.slice(from, endIndex);
-    }
-    return [];
-  }
-  async delete(key) {
-    this.cache.delete(key);
-  }
-  async clear() {
-    this.cache.clear();
-  }
-  async increment(key) {
-    const value = this.cache.get(key);
-    let counter;
-    if (value === undefined)
-      counter = 1;
-    else if (typeof value === "number")
-      counter = value + 1;
-    else
-      throw new Error(`${key} exists but is not a number`);
-    this.cache.set(key, counter);
-    return counter;
-  }
-};
-
-// node_modules/.bun/@mastra+core@1.71.0+95d98e20cbc6e6e1/node_modules/@mastra/core/dist/netlify-B_pyJk7y.js
-var netlify_exports = /* @__PURE__ */ __exportAll({ NetlifyGateway: () => NetlifyGateway });
-var NetlifyGateway = class extends MastraModelGateway {
-  id = "netlify";
-  name = "Netlify AI Gateway";
-  tokenCache = new InMemoryServerCache;
-  async fetchProviders() {
-    const response = await fetch("https://api.netlify.com/api/v1/ai-gateway/providers");
-    if (!response.ok)
-      throw new Error(`Failed to fetch from Netlify: ${response.statusText}`);
-    const data = await response.json();
-    const config = {
-      apiKeyEnvVar: ["NETLIFY_TOKEN", "NETLIFY_SITE_ID"],
-      apiKeyHeader: "Authorization",
-      name: `Netlify`,
-      gateway: `netlify`,
-      models: [],
-      docUrl: "https://docs.netlify.com/build/ai-gateway/overview/"
-    };
-    for (const [providerId, provider] of Object.entries(data.providers))
-      for (const model of provider.models)
-        config.models.push(`${providerId}/${model}`);
-    return { netlify: config };
-  }
-  async buildUrl(routerId, envVars) {
-    const siteId = envVars?.["NETLIFY_SITE_ID"] || process.env["NETLIFY_SITE_ID"];
-    const netlifyToken = envVars?.["NETLIFY_TOKEN"] || process.env["NETLIFY_TOKEN"];
-    if (!netlifyToken)
-      throw new MastraError({
-        id: "NETLIFY_GATEWAY_NO_TOKEN",
-        domain: "LLM",
-        category: "UNKNOWN",
-        text: `Missing NETLIFY_TOKEN environment variable required for model: ${routerId}`
-      });
-    if (!siteId)
-      throw new MastraError({
-        id: "NETLIFY_GATEWAY_NO_SITE_ID",
-        domain: "LLM",
-        category: "UNKNOWN",
-        text: `Missing NETLIFY_SITE_ID environment variable required for model: ${routerId}`
-      });
-    try {
-      const tokenData = await this.getOrFetchToken(siteId, netlifyToken);
-      return tokenData.url.endsWith(`/`) ? tokenData.url.substring(0, tokenData.url.length - 1) : tokenData.url;
-    } catch (error) {
-      throw new MastraError({
-        id: "NETLIFY_GATEWAY_TOKEN_ERROR",
-        domain: "LLM",
-        category: "UNKNOWN",
-        text: `Failed to get Netlify AI Gateway token for model ${routerId}: ${error instanceof Error ? error.message : String(error)}`
-      });
-    }
-  }
-  async getOrFetchToken(siteId, netlifyToken) {
-    const cacheKey = `netlify-token:${siteId}:${netlifyToken}`;
-    const cached = await this.tokenCache.get(cacheKey);
-    if (cached && cached.expiresAt > Date.now() / 1000 + 60)
-      return {
-        token: cached.token,
-        url: cached.url
-      };
-    const response = await fetch(`https://api.netlify.com/api/v1/sites/${siteId}/ai-gateway/token`, {
-      method: "GET",
-      headers: { Authorization: `Bearer ${netlifyToken}` }
-    });
-    if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Failed to get Netlify AI Gateway token: ${response.status} ${error}`);
-    }
-    const tokenResponse = await response.json();
-    await this.tokenCache.set(cacheKey, {
-      token: tokenResponse.token,
-      url: tokenResponse.url,
-      expiresAt: tokenResponse.expires_at
-    });
-    return {
-      token: tokenResponse.token,
-      url: tokenResponse.url
-    };
-  }
-  async getApiKey(modelId) {
-    const siteId = process.env["NETLIFY_SITE_ID"];
-    const netlifyToken = process.env["NETLIFY_TOKEN"];
-    if (!netlifyToken)
-      throw new MastraError({
-        id: "NETLIFY_GATEWAY_NO_TOKEN",
-        domain: "LLM",
-        category: "UNKNOWN",
-        text: `Missing NETLIFY_TOKEN environment variable required for model: ${modelId}`
-      });
-    if (!siteId)
-      throw new MastraError({
-        id: "NETLIFY_GATEWAY_NO_SITE_ID",
-        domain: "LLM",
-        category: "UNKNOWN",
-        text: `Missing NETLIFY_SITE_ID environment variable required for model: ${modelId}`
-      });
-    try {
-      return (await this.getOrFetchToken(siteId, netlifyToken)).token;
-    } catch (error) {
-      throw new MastraError({
-        id: "NETLIFY_GATEWAY_TOKEN_ERROR",
-        domain: "LLM",
-        category: "UNKNOWN",
-        text: `Failed to get Netlify AI Gateway token for model ${modelId}: ${error instanceof Error ? error.message : String(error)}`
-      });
-    }
-  }
-  async resolveLanguageModel({ modelId, providerId, apiKey, headers }) {
-    const baseURL = await this.buildUrl(`${providerId}/${modelId}`);
-    const mastraHeaders = {
-      "User-Agent": MASTRA_USER_AGENT,
-      ...headers
-    };
-    switch (providerId) {
-      case "openai":
-        return createOpenAI({
-          apiKey,
-          baseURL,
-          headers: mastraHeaders
-        }).responses(modelId);
-      case "gemini":
-        return createGoogleGenerativeAI({
-          baseURL: `${baseURL}/v1beta/`,
-          apiKey,
-          headers: {
-            "user-agent": "google-genai-sdk/",
-            ...mastraHeaders
-          }
-        }).chat(modelId);
-      case "anthropic":
-        return createAnthropic({
-          apiKey,
-          baseURL: `${baseURL}/v1/`,
-          headers: {
-            "anthropic-version": "2023-06-01",
-            ...mastraHeaders
-          }
-        })(modelId);
-      default:
-        return createOpenAICompatible({
-          name: providerId,
-          apiKey,
-          baseURL,
-          headers: mastraHeaders,
-          supportsStructuredOutputs: true
-        }).chatModel(modelId);
-    }
-  }
-};
-export { TTLCache, InMemoryServerCache, netlify_exports, NetlifyGateway };