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

package/harness/chunk-3wvjs93w.mjs

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

package/harness/chunk-4bepyxmq.mjs

@@ -0,0 +1,113 @@
+import {
+  globalRunRegistry,
+  getActiveDurableAgentWorkflowExecutions,
+  RunRegistry,
+  ExtendedRunRegistry,
+  publishAbortRequest,
+  subscribeToAbortRequests,
+  ensureRemoteAbortListener,
+  runDurableStreamUntilIdle,
+  runResumeDurableStreamUntilIdle,
+  serializeToolsMetadata,
+  serializeModelConfig,
+  serializeDurableState,
+  serializeDurableOptions,
+  createWorkflowInput,
+  resolveRuntimeDependencies,
+  rebuildRunToolsFromMastra,
+  resolveModel,
+  resolveInternalState,
+  resolveTool,
+  toolRequiresApproval,
+  runDurableFinishSideEffects,
+  prepareForDurableExecution,
+  createDurableAgentStream,
+  emitChunkEvent,
+  emitStepStartEvent,
+  emitStepFinishEvent,
+  emitFinishEvent,
+  emitErrorEvent,
+  emitSuspendedEvent,
+  executeDurableAgentScorers,
+  modelConfigSchema,
+  modelListEntrySchema,
+  accumulatedUsageSchema,
+  durableAgenticOutputSchema,
+  baseDurableAgenticInputSchema,
+  baseIterationStateSchema,
+  calculateAccumulatedUsage,
+  buildStepRecord,
+  createBaseIterationStateUpdate,
+  resolveDurableToolCallConcurrency,
+  createDurableBackgroundTaskCheckStep,
+  createDurableLLMExecutionStep,
+  createDurableToolCallStep,
+  createDurableLLMMappingStep,
+  defaultShouldPersistSnapshot,
+  createDurableAgenticWorkflow,
+  DurableAgent,
+  create_durable_agent_exports,
+  createDurableAgent,
+  isDurableAgent,
+  isLocalDurableAgent
+} from "./chunk-qcm9arf8.mjs";
+import"./chunk-ageqxj9v.mjs";
+import"./chunk-6kgqw9ny.mjs";
+import"./chunk-3m7jn5ac.mjs";
+import"./chunk-z6n9thea.mjs";
+import"./chunk-50sbrf09.mjs";
+import"./chunk-c1631s2x.mjs";
+import"./chunk-3wvjs93w.mjs";
+export {
+  prepareForDurableExecution as A,
+  serializeDurableState as B,
+  createDurableAgentStream as C,
+  emitStepFinishEvent as D,
+  emitFinishEvent as E,
+  resolveRuntimeDependencies as F,
+  ensureRemoteAbortListener as G,
+  serializeToolsMetadata as H,
+  resolveTool as I,
+  ExtendedRunRegistry as J,
+  publishAbortRequest as K,
+  toolRequiresApproval as L,
+  rebuildRunToolsFromMastra as M,
+  resolveInternalState as N,
+  emitStepStartEvent as O,
+  resolveModel as P,
+  createWorkflowInput as R,
+  executeDurableAgentScorers as S,
+  emitErrorEvent as T,
+  runDurableStreamUntilIdle as U,
+  serializeModelConfig as V,
+  runResumeDurableStreamUntilIdle as W,
+  getActiveDurableAgentWorkflowExecutions as X,
+  RunRegistry as Y,
+  globalRunRegistry as Z,
+  baseDurableAgenticInputSchema as _,
+  DurableAgent as a,
+  modelConfigSchema as b,
+  createDurableLLMMappingStep as c,
+  createDurableBackgroundTaskCheckStep as d,
+  resolveDurableToolCallConcurrency as f,
+  accumulatedUsageSchema as g,
+  createBaseIterationStateUpdate as h,
+  isLocalDurableAgent as i,
+  runDurableFinishSideEffects as j,
+  emitSuspendedEvent as k,
+  createDurableToolCallStep as l,
+  calculateAccumulatedUsage as m,
+  create_durable_agent_exports as n,
+  createDurableAgenticWorkflow as o,
+  buildStepRecord as p,
+  subscribeToAbortRequests as q,
+  isDurableAgent as r,
+  defaultShouldPersistSnapshot as s,
+  createDurableAgent as t,
+  createDurableLLMExecutionStep as u,
+  baseIterationStateSchema as v,
+  emitChunkEvent as w,
+  modelListEntrySchema as x,
+  durableAgenticOutputSchema as y,
+  serializeDurableOptions as z
+};