@basemachina/agentic-browser-cli 0.3.0

package/dist/chunk-XAEHXRUC.js

@@ -0,0 +1,607 @@
+#!/usr/bin/env node
+
+// src/harness/ai-model.ts
+import { anthropic } from "@ai-sdk/anthropic";
+import { APICallError, Output, generateText } from "ai";
+
+// src/harness/ai-metrics.ts
+import { AsyncLocalStorage } from "async_hooks";
+var PRICING_TABLE = {
+  // Anthropic — cacheWrite = input × 1.25, cacheRead = input × 0.10
+  "claude-sonnet-4-6": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-sonnet-4-5": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-sonnet-4": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-haiku-4-5": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+  "claude-haiku-3-5": { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 },
+  "claude-opus-4-6": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-opus-4-5": { input: 5, output: 25, cacheRead: 0.5, cacheWrite: 6.25 },
+  "claude-opus-4-1": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  "claude-opus-4": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  // OpenAI (Azure OpenAI も同名モデルのため部分一致で対応) — キャッシュ書き込み追加課金なし
+  "gpt-4o": { input: 2.5, output: 10, cacheRead: 1.25, cacheWrite: 0 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6, cacheRead: 0.075, cacheWrite: 0 },
+  "gpt-4.1": { input: 2, output: 8, cacheRead: 0.5, cacheWrite: 0 },
+  "gpt-4.1-mini": { input: 0.4, output: 1.6, cacheRead: 0.1, cacheWrite: 0 },
+  "gpt-4.1-nano": { input: 0.1, output: 0.4, cacheRead: 0.025, cacheWrite: 0 },
+  "o3": { input: 2, output: 8, cacheRead: 0.5, cacheWrite: 0 },
+  "o4-mini": { input: 1.1, output: 4.4, cacheRead: 0.55, cacheWrite: 0 },
+  // Google Gemini — キャッシュ書き込み追加課金なし
+  "gemini-2.5-pro": { input: 1.25, output: 10, cacheRead: 0.315, cacheWrite: 0 },
+  "gemini-2.5-flash": { input: 0.15, output: 0.6, cacheRead: 0.0375, cacheWrite: 0 },
+  "gemini-2.0-flash": { input: 0.1, output: 0.4, cacheRead: 0.025, cacheWrite: 0 }
+};
+var DEFAULT_PRICING = { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 };
+function getPricing(modelId) {
+  if (PRICING_TABLE[modelId]) return PRICING_TABLE[modelId];
+  for (const [key, pricing] of Object.entries(PRICING_TABLE)) {
+    if (modelId.includes(key)) return pricing;
+  }
+  return DEFAULT_PRICING;
+}
+function calculateCost(metric) {
+  const pricing = getPricing(metric.modelId);
+  return metric.inputTokens * pricing.input / 1e6 + metric.cachedInputTokens * pricing.cacheRead / 1e6 + metric.cacheCreationTokens * pricing.cacheWrite / 1e6 + metric.outputTokens * pricing.output / 1e6;
+}
+function computeTotalRealInput(tokens) {
+  const input = tokens.totalInputTokens ?? tokens.inputTokens ?? 0;
+  const cached = tokens.totalCachedInputTokens ?? tokens.cachedInputTokens ?? 0;
+  const creation = tokens.totalCacheCreationTokens ?? tokens.cacheCreationTokens ?? 0;
+  return input + cached + creation;
+}
+function computeCacheRate(tokens) {
+  const total = computeTotalRealInput(tokens);
+  const cached = tokens.totalCachedInputTokens ?? tokens.cachedInputTokens ?? 0;
+  return total > 0 ? cached / total : 0;
+}
+var AIMetricsCollector = class {
+  constructor() {
+    this.metrics = [];
+  }
+  record(metric) {
+    this.metrics.push(metric);
+  }
+  getSummary() {
+    const totalCalls = this.metrics.length;
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let totalCachedInputTokens = 0;
+    let totalCacheCreationTokens = 0;
+    let totalDurationMs = 0;
+    let estimatedCostUsd = 0;
+    const byPurpose = {};
+    const byModel = {};
+    for (const m of this.metrics) {
+      totalInputTokens += m.inputTokens;
+      totalOutputTokens += m.outputTokens;
+      totalCachedInputTokens += m.cachedInputTokens;
+      totalCacheCreationTokens += m.cacheCreationTokens;
+      totalDurationMs += m.durationMs;
+      const cost = calculateCost(m);
+      estimatedCostUsd += cost;
+      const bp = byPurpose[m.purpose] ??= {
+        calls: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cachedInputTokens: 0,
+        cacheCreationTokens: 0,
+        durationMs: 0
+      };
+      bp.calls++;
+      bp.inputTokens += m.inputTokens;
+      bp.outputTokens += m.outputTokens;
+      bp.cachedInputTokens += m.cachedInputTokens;
+      bp.cacheCreationTokens += m.cacheCreationTokens;
+      bp.durationMs += m.durationMs;
+      const bm = byModel[m.modelId] ??= {
+        calls: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        cachedInputTokens: 0,
+        cacheCreationTokens: 0,
+        durationMs: 0,
+        estimatedCostUsd: 0
+      };
+      bm.calls++;
+      bm.inputTokens += m.inputTokens;
+      bm.outputTokens += m.outputTokens;
+      bm.cachedInputTokens += m.cachedInputTokens;
+      bm.cacheCreationTokens += m.cacheCreationTokens;
+      bm.durationMs += m.durationMs;
+      bm.estimatedCostUsd += cost;
+    }
+    const cacheHitRate = computeCacheRate({
+      inputTokens: totalInputTokens,
+      cachedInputTokens: totalCachedInputTokens,
+      cacheCreationTokens: totalCacheCreationTokens
+    });
+    let latencyPercentiles;
+    if (this.metrics.length > 0) {
+      const sorted = this.metrics.map((m) => m.durationMs).sort((a, b) => a - b);
+      const percentile = (p) => {
+        const idx = Math.ceil(p / 100 * sorted.length) - 1;
+        return sorted[Math.max(0, Math.min(idx, sorted.length - 1))];
+      };
+      latencyPercentiles = {
+        p50: Math.round(percentile(50)),
+        p95: Math.round(percentile(95)),
+        p99: Math.round(percentile(99))
+      };
+    }
+    return {
+      totalCalls,
+      totalInputTokens,
+      totalOutputTokens,
+      totalCachedInputTokens,
+      totalCacheCreationTokens,
+      cacheHitRate,
+      estimatedCostUsd: Math.round(estimatedCostUsd * 1e6) / 1e6,
+      totalDurationMs,
+      latencyPercentiles,
+      byPurpose,
+      byModel
+    };
+  }
+  /** メトリクスをリセットする（eval ケース間で使用） */
+  reset() {
+    this.metrics = [];
+  }
+  /** 蓄積済みの個別メトリクスを返す（デバッグ用） */
+  getMetrics() {
+    return this.metrics;
+  }
+  /** 蓄積済みメトリクスの件数 */
+  get count() {
+    return this.metrics.length;
+  }
+};
+var globalMetrics = new AIMetricsCollector();
+var metricsStorage = new AsyncLocalStorage();
+var activeCollector = globalMetrics;
+function getActiveMetricsCollector() {
+  return metricsStorage.getStore() ?? activeCollector;
+}
+
+// src/harness/ai-model.ts
+var DEFAULT_MODEL_ID = "claude-sonnet-4-6";
+var DEFAULT_PROVIDER = "anthropic";
+var DEFAULT_PURPOSE_MODELS = {
+  selector: "claude-haiku-4-5-20251001",
+  extraction: "claude-haiku-4-5-20251001",
+  "exploration-light": "claude-haiku-4-5-20251001"
+};
+var currentModelId = DEFAULT_MODEL_ID;
+var currentProvider = DEFAULT_PROVIDER;
+var currentOverrides = {};
+var cachedModel = null;
+var overrideModelCache = /* @__PURE__ */ new Map();
+var modelFactory = null;
+async function initModel(config) {
+  const modelId = config?.modelId ?? DEFAULT_MODEL_ID;
+  const provider = config?.provider ?? DEFAULT_PROVIDER;
+  currentModelId = modelId;
+  currentProvider = provider;
+  currentOverrides = config?.modelOverrides ?? {};
+  overrideModelCache.clear();
+  switch (provider) {
+    case "openai": {
+      const { createOpenAI } = await import("@ai-sdk/openai");
+      const apiKey = config?.apiKey ?? process.env.OPENAI_API_KEY;
+      const openai = createOpenAI({
+        ...apiKey ? { apiKey } : {},
+        ...config?.baseURL ? { baseURL: config.baseURL } : {}
+      });
+      modelFactory = (id) => openai(id);
+      cachedModel = openai(modelId);
+      break;
+    }
+    case "google": {
+      const { createGoogleGenerativeAI } = await import("@ai-sdk/google");
+      const apiKey = config?.apiKey ?? process.env.GOOGLE_GENERATIVE_AI_API_KEY;
+      if (!apiKey) {
+        throw new Error(
+          "google \u30D7\u30ED\u30D0\u30A4\u30C0\u30FC\u306B\u306F GOOGLE_GENERATIVE_AI_API_KEY \u74B0\u5883\u5909\u6570\u307E\u305F\u306F apiKey \u304C\u5FC5\u8981\u3067\u3059"
+        );
+      }
+      const google = createGoogleGenerativeAI({
+        apiKey,
+        ...config?.baseURL ? { baseURL: config.baseURL } : {}
+      });
+      modelFactory = (id) => google(id);
+      cachedModel = google(modelId);
+      break;
+    }
+    case "azure": {
+      const { createAzure } = await import("@ai-sdk/azure");
+      const apiKey = config?.apiKey ?? process.env.AZURE_API_KEY;
+      const resourceName = config?.azureResourceName ?? process.env.AZURE_RESOURCE_NAME;
+      const apiVersion = config?.azureApiVersion ?? process.env.AZURE_API_VERSION;
+      if (!resourceName && !config?.baseURL) {
+        throw new Error(
+          "azure \u30D7\u30ED\u30D0\u30A4\u30C0\u30FC\u306B\u306F AZURE_RESOURCE_NAME \u74B0\u5883\u5909\u6570\uFF08\u307E\u305F\u306F --model-base-url\uFF09\u304C\u5FC5\u8981\u3067\u3059"
+        );
+      }
+      const azure = createAzure({
+        ...resourceName ? { resourceName } : {},
+        ...apiKey ? { apiKey } : {},
+        ...apiVersion ? { apiVersion } : {},
+        ...config?.baseURL ? { baseURL: config.baseURL } : {}
+      });
+      modelFactory = (id) => azure(id);
+      cachedModel = azure(modelId);
+      break;
+    }
+    case "openai-compatible": {
+      const { createOpenAICompatible } = await import("@ai-sdk/openai-compatible");
+      const baseURL = config?.baseURL ?? process.env.OPENAI_COMPATIBLE_BASE_URL;
+      if (!baseURL) {
+        throw new Error(
+          "openai-compatible \u30D7\u30ED\u30D0\u30A4\u30C0\u30FC\u306B\u306F OPENAI_COMPATIBLE_BASE_URL \u74B0\u5883\u5909\u6570\u307E\u305F\u306F --model-base-url \u304C\u5FC5\u8981\u3067\u3059"
+        );
+      }
+      const apiKey = config?.apiKey ?? process.env.OPENAI_COMPATIBLE_API_KEY ?? "";
+      const openaiCompatible = createOpenAICompatible({
+        name: "openai-compatible",
+        baseURL,
+        apiKey
+      });
+      modelFactory = (id) => openaiCompatible(id);
+      cachedModel = openaiCompatible(modelId);
+      break;
+    }
+    case "bedrock": {
+      const { createAmazonBedrock } = await import("@ai-sdk/amazon-bedrock");
+      const region = config?.bedrockRegion ?? process.env.AWS_REGION;
+      if (!region) {
+        throw new Error(
+          "bedrock \u30D7\u30ED\u30D0\u30A4\u30C0\u30FC\u306B\u306F AWS_REGION \u74B0\u5883\u5909\u6570\u304C\u5FC5\u8981\u3067\u3059"
+        );
+      }
+      const accessKeyId = config?.bedrockAccessKeyId ?? process.env.AWS_ACCESS_KEY_ID;
+      const secretAccessKey = config?.bedrockSecretAccessKey ?? process.env.AWS_SECRET_ACCESS_KEY;
+      const sessionToken = config?.bedrockSessionToken ?? process.env.AWS_SESSION_TOKEN;
+      const bedrock = createAmazonBedrock({
+        region,
+        ...accessKeyId && secretAccessKey ? { accessKeyId, secretAccessKey, ...sessionToken ? { sessionToken } : {} } : {}
+      });
+      modelFactory = (id) => bedrock(id);
+      cachedModel = bedrock(modelId);
+      break;
+    }
+    case "vertex": {
+      const { createVertex } = await import("@ai-sdk/google-vertex");
+      const project = config?.vertexProject ?? process.env.GOOGLE_VERTEX_PROJECT;
+      const location = config?.vertexLocation ?? process.env.GOOGLE_VERTEX_LOCATION;
+      if (!project) {
+        throw new Error(
+          "vertex \u30D7\u30ED\u30D0\u30A4\u30C0\u30FC\u306B\u306F GOOGLE_VERTEX_PROJECT \u74B0\u5883\u5909\u6570\u304C\u5FC5\u8981\u3067\u3059"
+        );
+      }
+      if (!location) {
+        throw new Error(
+          "vertex \u30D7\u30ED\u30D0\u30A4\u30C0\u30FC\u306B\u306F GOOGLE_VERTEX_LOCATION \u74B0\u5883\u5909\u6570\u304C\u5FC5\u8981\u3067\u3059"
+        );
+      }
+      const vertex = createVertex({ project, location });
+      modelFactory = (id) => vertex(id);
+      cachedModel = vertex(modelId);
+      break;
+    }
+    case "anthropic":
+    default:
+      modelFactory = (id) => anthropic(id);
+      cachedModel = anthropic(modelId);
+      break;
+  }
+}
+async function initModelExplicit(config) {
+  const modelId = config.modelId;
+  const provider = config.provider;
+  currentModelId = modelId;
+  currentProvider = provider;
+  currentOverrides = config.modelOverrides ?? {};
+  overrideModelCache.clear();
+  switch (provider) {
+    case "openai": {
+      const { createOpenAI } = await import("@ai-sdk/openai");
+      const openai = createOpenAI({
+        ...config.apiKey ? { apiKey: config.apiKey } : {},
+        ...config.baseURL ? { baseURL: config.baseURL } : {}
+      });
+      modelFactory = (id) => openai(id);
+      cachedModel = openai(modelId);
+      break;
+    }
+    case "google": {
+      if (!config.apiKey) {
+        throw new Error("apiKey is required for google provider in SDK mode");
+      }
+      const { createGoogleGenerativeAI } = await import("@ai-sdk/google");
+      const google = createGoogleGenerativeAI({
+        apiKey: config.apiKey,
+        ...config.baseURL ? { baseURL: config.baseURL } : {}
+      });
+      modelFactory = (id) => google(id);
+      cachedModel = google(modelId);
+      break;
+    }
+    case "azure": {
+      if (!config.azureResourceName && !config.baseURL) {
+        throw new Error("azureResourceName or baseURL is required for azure provider in SDK mode");
+      }
+      const { createAzure } = await import("@ai-sdk/azure");
+      const azure = createAzure({
+        ...config.azureResourceName ? { resourceName: config.azureResourceName } : {},
+        ...config.apiKey ? { apiKey: config.apiKey } : {},
+        ...config.azureApiVersion ? { apiVersion: config.azureApiVersion } : {},
+        ...config.baseURL ? { baseURL: config.baseURL } : {}
+      });
+      modelFactory = (id) => azure(id);
+      cachedModel = azure(modelId);
+      break;
+    }
+    case "openai-compatible": {
+      if (!config.baseURL) {
+        throw new Error("baseURL is required for openai-compatible provider in SDK mode");
+      }
+      if (!config.apiKey) {
+        throw new Error("apiKey is required for openai-compatible provider in SDK mode");
+      }
+      const { createOpenAICompatible } = await import("@ai-sdk/openai-compatible");
+      const openaiCompatible = createOpenAICompatible({
+        name: "openai-compatible",
+        baseURL: config.baseURL,
+        apiKey: config.apiKey
+      });
+      modelFactory = (id) => openaiCompatible(id);
+      cachedModel = openaiCompatible(modelId);
+      break;
+    }
+    case "bedrock": {
+      if (!config.bedrockRegion) {
+        throw new Error("bedrockRegion is required for bedrock provider in SDK mode");
+      }
+      const { createAmazonBedrock } = await import("@ai-sdk/amazon-bedrock");
+      const bedrock = createAmazonBedrock({
+        region: config.bedrockRegion,
+        ...config.bedrockAccessKeyId && config.bedrockSecretAccessKey ? {
+          accessKeyId: config.bedrockAccessKeyId,
+          secretAccessKey: config.bedrockSecretAccessKey,
+          ...config.bedrockSessionToken ? { sessionToken: config.bedrockSessionToken } : {}
+        } : {}
+      });
+      modelFactory = (id) => bedrock(id);
+      cachedModel = bedrock(modelId);
+      break;
+    }
+    case "vertex": {
+      if (!config.vertexProject) {
+        throw new Error("vertexProject is required for vertex provider in SDK mode");
+      }
+      if (!config.vertexLocation) {
+        throw new Error("vertexLocation is required for vertex provider in SDK mode");
+      }
+      const { createVertex } = await import("@ai-sdk/google-vertex");
+      const vertex = createVertex({
+        project: config.vertexProject,
+        location: config.vertexLocation
+      });
+      modelFactory = (id) => vertex(id);
+      cachedModel = vertex(modelId);
+      break;
+    }
+    case "anthropic":
+    default: {
+      if (config.apiKey) {
+        const { createAnthropic } = await import("@ai-sdk/anthropic");
+        const client = createAnthropic({ apiKey: config.apiKey });
+        modelFactory = (id) => client(id);
+        cachedModel = client(modelId);
+      } else {
+        modelFactory = (id) => anthropic(id);
+        cachedModel = anthropic(modelId);
+      }
+      break;
+    }
+  }
+}
+function getModel(purpose) {
+  if (purpose) {
+    const overrideId = currentOverrides[purpose] ?? DEFAULT_PURPOSE_MODELS[purpose];
+    if (overrideId && overrideId !== currentModelId) {
+      const cached = overrideModelCache.get(purpose);
+      if (cached) return cached;
+      const factory = modelFactory ?? ((id) => anthropic(id));
+      const model = factory(overrideId);
+      overrideModelCache.set(purpose, model);
+      return model;
+    }
+  }
+  if (!cachedModel) {
+    cachedModel = anthropic(DEFAULT_MODEL_ID);
+  }
+  return cachedModel;
+}
+function getModelId(purpose) {
+  if (purpose) {
+    const overrideId = currentOverrides[purpose] ?? DEFAULT_PURPOSE_MODELS[purpose];
+    if (overrideId) return overrideId;
+  }
+  return currentModelId;
+}
+function getModelProvider() {
+  return currentProvider;
+}
+function getModelOverrides() {
+  return { ...currentOverrides };
+}
+function extractCachedTokens(usage) {
+  return usage.inputTokenDetails?.cacheReadTokens ?? usage.cachedInputTokens ?? 0;
+}
+function extractCacheCreationTokensFromUsage(usage) {
+  return usage.inputTokenDetails?.cacheWriteTokens ?? 0;
+}
+function extractNonCachedInputTokens(usage) {
+  if (usage.inputTokenDetails?.noCacheTokens != null) {
+    return usage.inputTokenDetails.noCacheTokens;
+  }
+  const total = usage.inputTokens ?? 0;
+  const cached = extractCachedTokens(usage);
+  const cacheCreation = extractCacheCreationTokensFromUsage(usage);
+  return Math.max(0, total - cached - cacheCreation);
+}
+function recordMetrics(purpose, usage, durationMs, cacheCreationTokens, rawProviderUsage) {
+  getActiveMetricsCollector().record({
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    purpose,
+    modelId: getModelId(purpose),
+    inputTokens: extractNonCachedInputTokens(usage),
+    outputTokens: usage.outputTokens ?? 0,
+    cachedInputTokens: extractCachedTokens(usage),
+    cacheCreationTokens: cacheCreationTokens ?? 0,
+    durationMs: Math.round(durationMs),
+    rawProviderUsage
+  });
+}
+function extractCacheCreationTokens(result) {
+  if (Array.isArray(result.steps) && result.steps.length > 0) {
+    let total = 0;
+    for (const step of result.steps) {
+      total += step.providerMetadata?.anthropic?.cacheCreationInputTokens ?? 0;
+    }
+    return total;
+  }
+  return result.providerMetadata?.anthropic?.cacheCreationInputTokens ?? 0;
+}
+async function trackedGenerateObject(purpose, params) {
+  const start = performance.now();
+  const { schema, ...rest } = params;
+  let result;
+  try {
+    result = await generateText({
+      ...rest,
+      maxRetries: 0,
+      // AI SDK 内部リトライを無効化、withAIRetry に委譲
+      output: Output.object({ schema })
+    });
+  } catch (error) {
+    getActiveMetricsCollector().record({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      purpose,
+      modelId: getModelId(purpose),
+      inputTokens: 0,
+      outputTokens: 0,
+      cachedInputTokens: 0,
+      cacheCreationTokens: 0,
+      durationMs: Math.round(performance.now() - start)
+    });
+    throw error;
+  }
+  const step = result.steps?.[0];
+  const rawUsage = step?.providerMetadata?.anthropic ?? result.providerMetadata?.anthropic;
+  recordMetrics(purpose, result.usage, performance.now() - start, extractCacheCreationTokens(result), rawUsage);
+  return { ...result, object: result.output };
+}
+async function trackedGenerateText(purpose, params) {
+  const start = performance.now();
+  let lastStepTime = start;
+  let stepsRecorded = 0;
+  const onStepFinish = (stepResult) => {
+    const now = performance.now();
+    const stepDuration = now - lastStepTime;
+    lastStepTime = now;
+    const modelId = stepResult.response?.modelId || getModelId(purpose);
+    const rawUsage = stepResult.providerMetadata?.anthropic;
+    getActiveMetricsCollector().record({
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      purpose,
+      modelId,
+      inputTokens: extractNonCachedInputTokens(stepResult.usage ?? {}),
+      outputTokens: stepResult.usage?.outputTokens ?? 0,
+      cachedInputTokens: extractCachedTokens(stepResult.usage ?? {}),
+      cacheCreationTokens: Number(stepResult.providerMetadata?.anthropic?.cacheCreationInputTokens ?? 0),
+      durationMs: Math.round(stepDuration),
+      rawProviderUsage: rawUsage
+    });
+    stepsRecorded++;
+  };
+  try {
+    const result = await generateText({
+      ...params,
+      maxRetries: 0,
+      // AI SDK 内部リトライを無効化、withAIRetry に委譲
+      onStepFinish
+    });
+    return result;
+  } catch (error) {
+    if (stepsRecorded === 0) {
+      getActiveMetricsCollector().record({
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        purpose,
+        modelId: getModelId(purpose),
+        inputTokens: 0,
+        outputTokens: 0,
+        cachedInputTokens: 0,
+        cacheCreationTokens: 0,
+        durationMs: Math.round(performance.now() - start)
+      });
+    }
+    throw error;
+  }
+}
+function isRetryableError(error) {
+  if (APICallError.isInstance(error)) {
+    if (error.isRetryable) return true;
+    const code = error.statusCode;
+    if (code !== void 0) {
+      if (code === 429 || code === 529) return true;
+      if (code >= 500 && code < 600) return true;
+    }
+  }
+  if (error instanceof Error) {
+    const msg = error.message.toLowerCase();
+    if (msg.includes("econnreset") || msg.includes("etimedout") || msg.includes("econnrefused") || msg.includes("fetch failed") || msg.includes("socket hang up")) {
+      return true;
+    }
+    if (msg.includes("rate limit") || msg.includes("rate_limit")) return true;
+    if (msg.includes("overloaded")) return true;
+    if (/\b(429|529)\b/.test(msg)) return true;
+    if (/\b5\d{2}\b/.test(error.message)) return true;
+  }
+  return false;
+}
+async function withAIRetry(fn, opts) {
+  const maxRetries = opts?.maxRetries ?? 2;
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (attempt < maxRetries && isRetryableError(error)) {
+        const delay = Math.pow(2, attempt) * 1e3;
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        continue;
+      }
+      throw error;
+    }
+  }
+}
+
+export {
+  computeTotalRealInput,
+  computeCacheRate,
+  globalMetrics,
+  getActiveMetricsCollector,
+  DEFAULT_MODEL_ID,
+  DEFAULT_PROVIDER,
+  DEFAULT_PURPOSE_MODELS,
+  initModel,
+  initModelExplicit,
+  getModel,
+  getModelId,
+  getModelProvider,
+  getModelOverrides,
+  trackedGenerateObject,
+  trackedGenerateText,
+  isRetryableError,
+  withAIRetry
+};
+//# sourceMappingURL=chunk-XAEHXRUC.js.map