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

package/harness/chunk-xnqknk2r.mjs

@@ -0,0 +1,198 @@
+import {
+  getCapabilityFileName,
+  getGatewayId,
+  shouldEnableGateway
+} from "./chunk-gryka6kg.mjs";
+
+// node_modules/.bun/@mastra+core@1.71.0+95d98e20cbc6e6e1/node_modules/@mastra/core/dist/registry-generator-DTVbvs_S.js
+import path from "path";
+import fs from "fs/promises";
+var WINDOWS_RENAME_RETRY_DELAYS_MS = [
+  25,
+  50,
+  100,
+  200,
+  400
+];
+function hasAttachmentCapabilities(gateway) {
+  return "getAttachmentCapabilities" in gateway && typeof gateway.getAttachmentCapabilities === "function";
+}
+function hasTemperatureCapabilities(gateway) {
+  return "getTemperatureCapabilities" in gateway && typeof gateway.getTemperatureCapabilities === "function";
+}
+function hasStructuredOutputCapabilities(gateway) {
+  return "getStructuredOutputCapabilities" in gateway && typeof gateway.getStructuredOutputCapabilities === "function";
+}
+async function atomicWriteFile(filePath, content, encoding = "utf-8") {
+  const randomSuffix = Math.random().toString(36).substring(2, 15);
+  const tempPath = `${filePath}.${process.pid}.${Date.now()}.${randomSuffix}.tmp`;
+  try {
+    await fs.writeFile(tempPath, content, encoding);
+    for (let attempt = 0;; attempt += 1)
+      try {
+        await fs.rename(tempPath, filePath);
+        break;
+      } catch (error) {
+        const delayMs = WINDOWS_RENAME_RETRY_DELAYS_MS[attempt];
+        if (!(process.platform === "win32" && error instanceof Error && ("code" in error) && (error.code === "EPERM" || error.code === "EBUSY")) || delayMs === undefined)
+          throw error;
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+  } catch (error) {
+    try {
+      await fs.unlink(tempPath);
+    } catch {}
+    throw error;
+  }
+}
+async function fetchProvidersFromGateways(gateways) {
+  const enabledGateways = [];
+  for (const gateway of gateways)
+    if (shouldEnableGateway(gateway))
+      enabledGateways.push(gateway);
+  const allProviders = {};
+  const allModels = {};
+  const allAttachmentCapabilities = {};
+  const allTemperatureCapabilities = {};
+  const allStructuredOutputCapabilities = {};
+  const failedGateways = [];
+  const maxRetries = 3;
+  for (const gateway of enabledGateways) {
+    let providers = null;
+    for (let attempt = 1;attempt <= maxRetries; attempt++)
+      try {
+        providers = await gateway.fetchProviders();
+        break;
+      } catch {
+        if (attempt < maxRetries) {
+          const delayMs = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
+          await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+      }
+    if (!providers) {
+      failedGateways.push(getGatewayId(gateway));
+      continue;
+    }
+    const gatewayId = getGatewayId(gateway);
+    const isProviderRegistry = gatewayId === "models.dev";
+    const gatewayAttachmentCaps = hasAttachmentCapabilities(gateway) ? gateway.getAttachmentCapabilities() : undefined;
+    const gatewayTemperatureCaps = hasTemperatureCapabilities(gateway) ? gateway.getTemperatureCapabilities() : undefined;
+    const gatewayStructuredOutputCaps = hasStructuredOutputCapabilities(gateway) ? gateway.getStructuredOutputCapabilities() : undefined;
+    for (const [providerId, config] of Object.entries(providers)) {
+      const typeProviderId = isProviderRegistry ? providerId : providerId === gatewayId ? gatewayId : `${gatewayId}/${providerId}`;
+      allProviders[typeProviderId] = config;
+      allModels[typeProviderId] = config.models.sort();
+      if (gatewayAttachmentCaps?.[providerId])
+        allAttachmentCapabilities[typeProviderId] = gatewayAttachmentCaps[providerId];
+      if (gatewayTemperatureCaps?.[providerId])
+        allTemperatureCapabilities[typeProviderId] = gatewayTemperatureCaps[providerId];
+      if (gatewayStructuredOutputCaps?.[providerId])
+        allStructuredOutputCapabilities[typeProviderId] = gatewayStructuredOutputCaps[providerId];
+    }
+  }
+  return {
+    providers: allProviders,
+    models: allModels,
+    attachmentCapabilities: allAttachmentCapabilities,
+    temperatureCapabilities: allTemperatureCapabilities,
+    structuredOutputCapabilities: allStructuredOutputCapabilities,
+    failedGateways
+  };
+}
+function generateTypesContent(models) {
+  return `/**
+ * THIS FILE IS AUTO-GENERATED - DO NOT EDIT
+ * Generated from model gateway providers
+ */
+
+/**
+ * Provider models mapping type
+ * This is derived from the JSON data and provides type-safe access
+ */
+export type ProviderModelsMap = {
+${Object.entries(models).map(([provider, modelList]) => {
+    const modelsList = modelList.map((m) => `'${m}'`);
+    const providerKey = !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(provider) ? `'${provider}'` : provider;
+    const singleLine = `  readonly ${providerKey}: readonly [${modelsList.join(", ")}];`;
+    if (singleLine.length > 120)
+      return `  readonly ${providerKey}: readonly [
+${modelList.map((m) => `    '${m}',`).join(`
+`)}
+  ];`;
+    return singleLine;
+  }).join(`
+`)}
+};
+
+/**
+ * Union type of all registered provider IDs
+ */
+export type Provider = keyof ProviderModelsMap;
+
+/**
+ * Provider models mapping interface
+ */
+export interface ProviderModels {
+  [key: string]: string[];
+}
+
+/**
+ * OpenAI-compatible model ID type
+ * Dynamically derived from ProviderModelsMap
+ * Full provider/model paths (e.g., "openai/gpt-4o", "anthropic/claude-3-5-sonnet-20241022")
+ */
+export type ModelRouterModelId =
+  | {
+      [P in Provider]: \`\${P}/\${ProviderModelsMap[P][number]}\`;
+    }[Provider]
+  | \`mastra/\${ProviderModelsMap['openrouter'][number]}\`
+  | (string & {});
+
+/**
+ * Extract the model part from a ModelRouterModelId for a specific provider
+ * Dynamically derived from ProviderModelsMap
+ * Example: ModelForProvider<'openai'> = 'gpt-4o' | 'gpt-4-turbo' | ...
+ */
+export type ModelForProvider<P extends Provider> = ProviderModelsMap[P][number];
+`;
+}
+async function writeRegistryFiles(jsonPath, typesPath, providers, models, attachmentCapabilities, temperatureCapabilities, structuredOutputCapabilities) {
+  const jsonDir = path.dirname(jsonPath);
+  const typesDir = path.dirname(typesPath);
+  await fs.mkdir(jsonDir, { recursive: true });
+  await fs.mkdir(typesDir, { recursive: true });
+  await atomicWriteFile(jsonPath, JSON.stringify({
+    providers,
+    models,
+    version: "1.0.0"
+  }, null, 2), "utf-8");
+  await atomicWriteFile(typesPath, generateTypesContent(models), "utf-8");
+  const capDir = path.join(jsonDir, "capabilities");
+  const hasCapabilities = attachmentCapabilities && Object.keys(attachmentCapabilities).length > 0 || temperatureCapabilities && Object.keys(temperatureCapabilities).length > 0 || structuredOutputCapabilities && Object.keys(structuredOutputCapabilities).length > 0;
+  await fs.rm(capDir, {
+    recursive: true,
+    force: true
+  });
+  if (hasCapabilities) {
+    await fs.mkdir(capDir, { recursive: true });
+    const allProviderIds = /* @__PURE__ */ new Set([
+      ...attachmentCapabilities ? Object.keys(attachmentCapabilities) : [],
+      ...temperatureCapabilities ? Object.keys(temperatureCapabilities) : [],
+      ...structuredOutputCapabilities ? Object.keys(structuredOutputCapabilities) : []
+    ]);
+    for (const provider of allProviderIds) {
+      const capData = {};
+      if (attachmentCapabilities?.[provider])
+        capData.attachment = attachmentCapabilities[provider];
+      if (temperatureCapabilities?.[provider])
+        capData.temperature = temperatureCapabilities[provider];
+      if (structuredOutputCapabilities?.[provider])
+        capData.structuredOutput = structuredOutputCapabilities[provider];
+      await atomicWriteFile(path.join(capDir, getCapabilityFileName(provider)), JSON.stringify(capData, null, 2), "utf-8");
+    }
+  }
+}
+export {
+  fetchProvidersFromGateways,
+  writeRegistryFiles
+};