@refrainai/cli 0.4.1

package/dist/chunk-UGPXCQY3.js

@@ -0,0 +1,778 @@
+#!/usr/bin/env node
+
+// src/harness/ai-model.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+import { anthropic } from "@ai-sdk/anthropic";
+import { APICallError as APICallError2, 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 runWithMetricsCollector(collector, fn) {
+  return metricsStorage.run(collector, fn);
+}
+function getActiveMetricsCollector() {
+  return metricsStorage.getStore() ?? activeCollector;
+}
+
+// src/harness/ai-error.ts
+import { APICallError } from "ai";
+var BILLING_PATTERNS = [
+  /credit\s*balance/i,
+  /insufficient\s*(funds|credit|balance)/i,
+  /billing/i,
+  /payment\s*required/i,
+  /quota\s*exceeded/i
+];
+var AUTH_PATTERNS = [
+  /unauthorized/i,
+  /invalid[\s_-]*api[\s_-]*key/i,
+  /authentication\s*failed/i,
+  /forbidden/i,
+  /permission\s*denied/i,
+  /invalid[\s_-]*x[\s_-]*api[\s_-]*key/i,
+  /invalid[\s_-]*bearer[\s_-]*token/i
+];
+var NETWORK_PATTERNS = [
+  /econnreset/i,
+  /etimedout/i,
+  /econnrefused/i,
+  /fetch\s*failed/i,
+  /socket\s*hang\s*up/i,
+  /network\s*error/i
+];
+var CONTENT_FILTER_PATTERNS = [
+  /content[\s_-]*filter/i,
+  /content[\s_-]*policy/i,
+  /safety[\s_-]*filter/i,
+  /content[\s_-]*moderation/i
+];
+var MODEL_NOT_FOUND_PATTERNS = [
+  /model[\s_-]*not[\s_-]*found/i,
+  /does[\s_-]*not[\s_-]*exist/i,
+  /unknown[\s_-]*model/i
+];
+function matchesAny(message, patterns) {
+  return patterns.some((p) => p.test(message));
+}
+function buildUserMessage(category, originalMessage) {
+  switch (category) {
+    case "billing":
+      return `AI API billing error: ${originalMessage}`;
+    case "auth":
+      return `AI API authentication failed: ${originalMessage}`;
+    case "rate_limit":
+      return "AI API rate limit exceeded. Retrying automatically.";
+    case "overloaded":
+      return "AI API is temporarily overloaded. Retrying automatically.";
+    case "server_error":
+      return `AI API server error: ${originalMessage}`;
+    case "network":
+      return `Network error connecting to AI API: ${originalMessage}`;
+    case "model_not_found":
+      return `AI model not found: ${originalMessage}`;
+    case "content_filter":
+      return `AI API content policy violation: ${originalMessage}`;
+    case "unknown":
+      return originalMessage;
+  }
+}
+function classifyAIError(error) {
+  const originalMessage = error instanceof Error ? error.message : String(error);
+  if (APICallError.isInstance(error)) {
+    const code = error.statusCode;
+    const body = typeof error.responseBody === "string" ? error.responseBody : "";
+    const msg = error.message + " " + body;
+    if (code !== void 0) {
+      if ((code === 400 || code === 402) && matchesAny(msg, BILLING_PATTERNS)) {
+        return { category: "billing", statusCode: code, isRetryable: false, userMessage: buildUserMessage("billing", originalMessage), originalMessage };
+      }
+      if (code === 401 || code === 403) {
+        return { category: "auth", statusCode: code, isRetryable: false, userMessage: buildUserMessage("auth", originalMessage), originalMessage };
+      }
+      if (code === 404) {
+        return { category: "model_not_found", statusCode: code, isRetryable: false, userMessage: buildUserMessage("model_not_found", originalMessage), originalMessage };
+      }
+      if (code === 429) {
+        return { category: "rate_limit", statusCode: code, isRetryable: true, userMessage: buildUserMessage("rate_limit", originalMessage), originalMessage };
+      }
+      if (code === 529) {
+        return { category: "overloaded", statusCode: code, isRetryable: true, userMessage: buildUserMessage("overloaded", originalMessage), originalMessage };
+      }
+      if (code >= 500 && code < 600) {
+        return { category: "server_error", statusCode: code, isRetryable: true, userMessage: buildUserMessage("server_error", originalMessage), originalMessage };
+      }
+    }
+    if (matchesAny(msg, BILLING_PATTERNS)) {
+      return { category: "billing", statusCode: code, isRetryable: false, userMessage: buildUserMessage("billing", originalMessage), originalMessage };
+    }
+    if (matchesAny(msg, AUTH_PATTERNS)) {
+      return { category: "auth", statusCode: code, isRetryable: false, userMessage: buildUserMessage("auth", originalMessage), originalMessage };
+    }
+    if (matchesAny(msg, CONTENT_FILTER_PATTERNS)) {
+      return { category: "content_filter", statusCode: code, isRetryable: false, userMessage: buildUserMessage("content_filter", originalMessage), originalMessage };
+    }
+    if (matchesAny(msg, MODEL_NOT_FOUND_PATTERNS)) {
+      return { category: "model_not_found", statusCode: code, isRetryable: false, userMessage: buildUserMessage("model_not_found", originalMessage), originalMessage };
+    }
+  }
+  if (error instanceof Error) {
+    const msg = error.message;
+    if (matchesAny(msg, BILLING_PATTERNS)) {
+      return { category: "billing", isRetryable: false, userMessage: buildUserMessage("billing", originalMessage), originalMessage };
+    }
+    if (matchesAny(msg, AUTH_PATTERNS)) {
+      return { category: "auth", isRetryable: false, userMessage: buildUserMessage("auth", originalMessage), originalMessage };
+    }
+    if (matchesAny(msg, NETWORK_PATTERNS)) {
+      return { category: "network", isRetryable: true, userMessage: buildUserMessage("network", originalMessage), originalMessage };
+    }
+    if (matchesAny(msg, CONTENT_FILTER_PATTERNS)) {
+      return { category: "content_filter", isRetryable: false, userMessage: buildUserMessage("content_filter", originalMessage), originalMessage };
+    }
+    if (matchesAny(msg, MODEL_NOT_FOUND_PATTERNS)) {
+      return { category: "model_not_found", isRetryable: false, userMessage: buildUserMessage("model_not_found", originalMessage), originalMessage };
+    }
+  }
+  return { category: "unknown", isRetryable: false, userMessage: originalMessage, originalMessage };
+}
+function isFatalAIError(error) {
+  const { category } = classifyAIError(error);
+  return category === "billing" || category === "auth" || category === "model_not_found";
+}
+function getUserFriendlyAIErrorFromMessage(message) {
+  if (matchesAny(message, BILLING_PATTERNS)) {
+    return buildUserMessage("billing", message);
+  }
+  if (matchesAny(message, AUTH_PATTERNS)) {
+    return buildUserMessage("auth", message);
+  }
+  if (matchesAny(message, NETWORK_PATTERNS)) {
+    return buildUserMessage("network", message);
+  }
+  if (matchesAny(message, CONTENT_FILTER_PATTERNS)) {
+    return buildUserMessage("content_filter", message);
+  }
+  if (matchesAny(message, MODEL_NOT_FOUND_PATTERNS)) {
+    return buildUserMessage("model_not_found", message);
+  }
+  if (/rate[\s_-]*limit/i.test(message) || /\b429\b/.test(message)) {
+    return buildUserMessage("rate_limit", message);
+  }
+  if (/overloaded/i.test(message) || /\b529\b/.test(message)) {
+    return buildUserMessage("overloaded", message);
+  }
+  return message;
+}
+
+// src/harness/ai-model.ts
+var DEFAULT_MODEL_ID = "claude-sonnet-4-6";
+var DEFAULT_PROVIDER = "anthropic";
+var PROVIDER_DEFAULT_MODELS = {
+  anthropic: "claude-sonnet-4-6",
+  openai: "gpt-4o",
+  "openai-compatible": "gpt-4o",
+  google: "gemini-2.5-pro",
+  azure: "gpt-4o",
+  bedrock: "anthropic.claude-sonnet-4-6-v1",
+  vertex: "claude-sonnet-4-6@20250514"
+};
+var currentModelId = DEFAULT_MODEL_ID;
+var currentProvider = DEFAULT_PROVIDER;
+var currentOverrides = {};
+var cachedModel = null;
+var overrideModelCache = /* @__PURE__ */ new Map();
+var modelFactory = null;
+var modelStorage = new AsyncLocalStorage2();
+function runWithModelContext(config, factory, fn) {
+  const model = factory(config.modelId ?? DEFAULT_MODEL_ID);
+  const ctx = {
+    modelId: config.modelId ?? DEFAULT_MODEL_ID,
+    provider: config.provider ?? DEFAULT_PROVIDER,
+    overrides: config.modelOverrides ?? {},
+    model,
+    factory,
+    overrideCache: /* @__PURE__ */ new Map()
+  };
+  return modelStorage.run(ctx, fn);
+}
+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 buildModelFactory(config) {
+  switch (config.provider) {
+    case "openai": {
+      const { createOpenAI } = await import("@ai-sdk/openai");
+      const openai = createOpenAI({
+        ...config.apiKey ? { apiKey: config.apiKey } : {},
+        ...config.baseURL ? { baseURL: config.baseURL } : {}
+      });
+      return (id) => openai(id);
+    }
+    case "google": {
+      const { createGoogleGenerativeAI } = await import("@ai-sdk/google");
+      if (!config.apiKey) throw new Error("apiKey required for google provider");
+      const google = createGoogleGenerativeAI({ apiKey: config.apiKey });
+      return (id) => google(id);
+    }
+    case "azure": {
+      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 } : {}
+      });
+      return (id) => azure(id);
+    }
+    case "openai-compatible": {
+      if (!config.baseURL) throw new Error("baseURL required for openai-compatible");
+      const { createOpenAICompatible } = await import("@ai-sdk/openai-compatible");
+      const compat = createOpenAICompatible({
+        name: "openai-compatible",
+        baseURL: config.baseURL,
+        apiKey: config.apiKey ?? ""
+      });
+      return (id) => compat(id);
+    }
+    case "bedrock": {
+      if (!config.bedrockRegion) throw new Error("bedrockRegion required for bedrock");
+      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 } : {}
+        } : {}
+      });
+      return (id) => bedrock(id);
+    }
+    case "vertex": {
+      if (!config.vertexProject) throw new Error("vertexProject required for vertex");
+      if (!config.vertexLocation) throw new Error("vertexLocation required for vertex");
+      const { createVertex } = await import("@ai-sdk/google-vertex");
+      const vertex = createVertex({
+        project: config.vertexProject,
+        location: config.vertexLocation
+      });
+      return (id) => vertex(id);
+    }
+    case "anthropic":
+    default: {
+      if (config.apiKey) {
+        const { createAnthropic } = await import("@ai-sdk/anthropic");
+        const client = createAnthropic({ apiKey: config.apiKey });
+        return (id) => client(id);
+      }
+      const { anthropic: anthropic2 } = await import("@ai-sdk/anthropic");
+      return (id) => anthropic2(id);
+    }
+  }
+}
+async function initModelExplicit(config) {
+  currentModelId = config.modelId;
+  currentProvider = config.provider;
+  currentOverrides = config.modelOverrides ?? {};
+  overrideModelCache.clear();
+  const factory = await buildModelFactory(config);
+  modelFactory = factory;
+  cachedModel = factory(config.modelId);
+}
+function getModel(purpose) {
+  const ctx = modelStorage.getStore();
+  if (ctx) {
+    if (purpose) {
+      const overrideId = ctx.overrides[purpose];
+      if (overrideId && overrideId !== ctx.modelId) {
+        const cached = ctx.overrideCache.get(purpose);
+        if (cached) return cached;
+        const model = ctx.factory(overrideId);
+        ctx.overrideCache.set(purpose, model);
+        return model;
+      }
+    }
+    return ctx.model;
+  }
+  if (purpose) {
+    const overrideId = currentOverrides[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) {
+  const ctx = modelStorage.getStore();
+  const activeOverrides = ctx ? ctx.overrides : currentOverrides;
+  const activeModelId = ctx ? ctx.modelId : currentModelId;
+  if (purpose) {
+    const overrideId = activeOverrides[purpose];
+    if (overrideId) return overrideId;
+  }
+  return activeModelId;
+}
+function getModelProvider() {
+  const ctx = modelStorage.getStore();
+  return ctx ? ctx.provider : currentProvider;
+}
+function getModelOverrides() {
+  const ctx = modelStorage.getStore();
+  return { ...ctx ? ctx.overrides : 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 (APICallError2.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;
+      }
+      if (isFatalAIError(error)) {
+        const info = classifyAIError(error);
+        const enhanced = new Error(info.userMessage);
+        enhanced.cause = error;
+        enhanced.name = "AIAPIError";
+        throw enhanced;
+      }
+      throw error;
+    }
+  }
+}
+
+export {
+  computeTotalRealInput,
+  computeCacheRate,
+  AIMetricsCollector,
+  globalMetrics,
+  runWithMetricsCollector,
+  getActiveMetricsCollector,
+  getUserFriendlyAIErrorFromMessage,
+  DEFAULT_MODEL_ID,
+  DEFAULT_PROVIDER,
+  PROVIDER_DEFAULT_MODELS,
+  runWithModelContext,
+  initModel,
+  buildModelFactory,
+  initModelExplicit,
+  getModel,
+  getModelId,
+  getModelProvider,
+  getModelOverrides,
+  trackedGenerateObject,
+  trackedGenerateText,
+  isRetryableError,
+  withAIRetry
+};
+//# sourceMappingURL=chunk-UGPXCQY3.js.map