@bratsos/workflow-engine 0.0.11 → 0.2.0

package/dist/chunk-P4KMGCT3.js

@@ -0,0 +1,2292 @@
+import { createLogger } from './chunk-MUWP5SF2.js';
+import z2, { z } from 'zod';
+import { Anthropic } from '@anthropic-ai/sdk';
+import { jsonSchema, generateText, Output, embed, streamText } from 'ai';
+import { GoogleGenAI, FunctionCallingConfigMode, JobState } from '@google/genai';
+import OpenAI from 'openai';
+import { google } from '@ai-sdk/google';
+import { openrouter } from '@openrouter/ai-sdk-provider';
+
+var NoInputSchema = z.object({});
+function requireStageOutput(workflowContext, stageId, field) {
+  const stageOutput = workflowContext[stageId];
+  if (!stageOutput) {
+    throw new Error(
+      `Missing output from required stage: ${stageId}. Check that this stage has been executed before the current stage. Available stages: ${Object.keys(workflowContext).join(", ")}`
+    );
+  }
+  if (field) {
+    if (typeof stageOutput !== "object" || stageOutput === null) {
+      throw new Error(
+        `Stage ${stageId} output is not an object, cannot access field '${field}'. Received: ${typeof stageOutput}`
+      );
+    }
+    if (!(field in stageOutput)) {
+      const availableFields = Object.keys(stageOutput);
+      throw new Error(
+        `Missing required field '${field}' in ${stageId} output. Available fields: ${availableFields.join(", ")}`
+      );
+    }
+    return stageOutput[field];
+  }
+  return stageOutput;
+}
+
+// src/core/stage-factory.ts
+function defineStage(definition) {
+  const inputSchema = definition.schemas.input === "none" ? NoInputSchema : definition.schemas.input;
+  const isAsyncBatch = "mode" in definition && definition.mode === "async-batch";
+  const stage = {
+    id: definition.id,
+    name: definition.name,
+    description: definition.description,
+    mode: isAsyncBatch ? "async-batch" : "sync",
+    dependencies: definition.dependencies,
+    inputSchema,
+    outputSchema: definition.schemas.output,
+    configSchema: definition.schemas.config,
+    async execute(context) {
+      const enhancedContext = createEnhancedContext(
+        context
+      );
+      const result = await definition.execute(enhancedContext);
+      if ("suspended" in result && result.suspended === true) {
+        const suspendedResult = result;
+        return {
+          suspended: true,
+          state: suspendedResult.state,
+          pollConfig: suspendedResult.pollConfig,
+          metrics: {
+            startTime: 0,
+            endTime: 0,
+            duration: 0,
+            ...suspendedResult.customMetrics
+          }
+        };
+      }
+      const simpleResult = result;
+      const stageResult = {
+        output: simpleResult.output,
+        metrics: {
+          // Timing is set by executor - we provide placeholders
+          startTime: 0,
+          endTime: 0,
+          duration: 0,
+          // Custom metrics from stage (including AI metrics if stage tracked them)
+          ...simpleResult.customMetrics
+        },
+        artifacts: simpleResult.artifacts
+      };
+      return stageResult;
+    },
+    estimateCost: definition.estimateCost
+  };
+  if (isAsyncBatch) {
+    const asyncDef = definition;
+    stage.checkCompletion = asyncDef.checkCompletion;
+  }
+  return stage;
+}
+function createEnhancedContext(context) {
+  return {
+    ...context,
+    require(stageId) {
+      const output = context.workflowContext[stageId];
+      if (output === void 0) {
+        const availableStages = Object.keys(context.workflowContext);
+        throw new Error(
+          `Missing required stage output: "${String(stageId)}". Available stages: ${availableStages.length > 0 ? availableStages.join(", ") : "(none)"}`
+        );
+      }
+      return output;
+    },
+    optional(stageId) {
+      return context.workflowContext[stageId];
+    }
+  };
+}
+function defineAsyncBatchStage(definition) {
+  return defineStage(definition);
+}
+var tiktokenPromise = null;
+async function getTiktoken() {
+  if (!tiktokenPromise) {
+    tiktokenPromise = Promise.all([
+      import('js-tiktoken/lite'),
+      import('js-tiktoken/ranks/cl100k_base')
+    ]).then(([{ Tiktoken }, cl100kModule]) => ({
+      Tiktoken,
+      cl100k_base: cl100kModule.default
+    }));
+  }
+  return tiktokenPromise;
+}
+var MODEL_REGISTRY = {};
+function registerModels(models) {
+  Object.assign(MODEL_REGISTRY, models);
+}
+function getRegisteredModel(key) {
+  return MODEL_REGISTRY[key];
+}
+function listRegisteredModels() {
+  return Object.entries(MODEL_REGISTRY).map(([key, config]) => ({
+    key,
+    config
+  }));
+}
+var ModelKeyEnum = z2.enum(["gemini-2.5-flash"]);
+var ModelKey = z2.string().refine(
+  (key) => {
+    if (ModelKeyEnum.safeParse(key).success) {
+      return true;
+    }
+    return MODEL_REGISTRY[key] !== void 0;
+  },
+  {
+    message: "Model not found. Make sure to import the generated models file or register the model."
+  }
+).transform((key) => key);
+var AVAILABLE_MODELS = {
+  [ModelKeyEnum.enum["gemini-2.5-flash"]]: {
+    id: "google/gemini-2.5-flash-preview-09-2025",
+    name: "Gemini 2.5 Flash Preview",
+    inputCostPerMillion: 0.3,
+    outputCostPerMillion: 2.5,
+    provider: "openrouter",
+    description: "Fast, efficient model for general tasks",
+    supportsAsyncBatch: true,
+    batchDiscountPercent: 50
+  }
+};
+var DEFAULT_MODEL_KEY = "gemini-2.5-flash";
+function getModel(key) {
+  const builtInModel = AVAILABLE_MODELS[key];
+  if (builtInModel) {
+    return builtInModel;
+  }
+  const registeredModel = MODEL_REGISTRY[key];
+  if (registeredModel) {
+    return registeredModel;
+  }
+  const allKeys = [
+    ...Object.keys(AVAILABLE_MODELS),
+    ...Object.keys(MODEL_REGISTRY)
+  ];
+  throw new Error(
+    `Model "${key}" not found. Available models: ${allKeys.join(", ")}`
+  );
+}
+function getDefaultModel() {
+  return getModel(DEFAULT_MODEL_KEY);
+}
+function listModels(filter) {
+  const builtIn = Object.entries(AVAILABLE_MODELS).map(([key, config]) => ({
+    key,
+    config
+  }));
+  const registered = Object.entries(MODEL_REGISTRY).map(([key, config]) => ({
+    key,
+    config
+  }));
+  const merged = /* @__PURE__ */ new Map();
+  for (const item of builtIn) {
+    merged.set(item.key, item);
+  }
+  for (const item of registered) {
+    merged.set(item.key, item);
+  }
+  let models = Array.from(merged.values());
+  if (filter) {
+    models = models.filter((item) => {
+      const { config } = item;
+      if (filter.isEmbeddingModel !== void 0) {
+        if (filter.isEmbeddingModel && !config.isEmbeddingModel) return false;
+        if (!filter.isEmbeddingModel && config.isEmbeddingModel) return false;
+      }
+      if (filter.supportsTools !== void 0) {
+        if (filter.supportsTools && !config.supportsTools) return false;
+        if (!filter.supportsTools && config.supportsTools) return false;
+      }
+      if (filter.supportsStructuredOutputs !== void 0) {
+        if (filter.supportsStructuredOutputs && !config.supportsStructuredOutputs)
+          return false;
+        if (!filter.supportsStructuredOutputs && config.supportsStructuredOutputs)
+          return false;
+      }
+      if (filter.supportsAsyncBatch !== void 0) {
+        if (filter.supportsAsyncBatch && !config.supportsAsyncBatch)
+          return false;
+        if (!filter.supportsAsyncBatch && config.supportsAsyncBatch)
+          return false;
+      }
+      return true;
+    });
+  }
+  return models.sort((a, b) => a.key.localeCompare(b.key));
+}
+function modelSupportsBatch(modelKey) {
+  const model = getModel(modelKey);
+  return model.supportsAsyncBatch === true;
+}
+function getModelById(modelKey, tracker) {
+  const modelConfig = getModel(modelKey);
+  return {
+    id: modelConfig.id,
+    name: modelConfig.name,
+    recordCall: (inputTokens, outputTokens) => {
+      if (!tracker) {
+        throw new Error("ModelStatsTracker required to use recordCall()");
+      }
+      tracker.recordCall(inputTokens, outputTokens, modelKey);
+    }
+  };
+}
+function calculateCost(modelKey, inputTokens, outputTokens) {
+  const model = getModel(modelKey);
+  const inputCost = inputTokens / 1e6 * model.inputCostPerMillion;
+  const outputCost = outputTokens / 1e6 * model.outputCostPerMillion;
+  const totalCost = inputCost + outputCost;
+  return {
+    inputCost,
+    outputCost,
+    totalCost
+  };
+}
+var ModelStatsTracker = class _ModelStatsTracker {
+  modelKey;
+  modelConfig;
+  stats;
+  perModelStats = /* @__PURE__ */ new Map();
+  isAggregating = false;
+  constructor(modelKey = DEFAULT_MODEL_KEY) {
+    this.modelKey = modelKey;
+    this.modelConfig = getModel(modelKey);
+    this.stats = {
+      apiCalls: 0,
+      inputTokens: 0,
+      outputTokens: 0
+    };
+  }
+  /**
+   * Create an aggregating tracker that combines stats from multiple models
+   * Perfect for parallel execution where different calls use different models
+   */
+  static createAggregating() {
+    const tracker = new _ModelStatsTracker();
+    tracker.isAggregating = true;
+    tracker.modelKey = void 0;
+    tracker.modelConfig = void 0;
+    return tracker;
+  }
+  /**
+   * Get the model ID for use with AI SDK
+   * @deprecated Use getModelById(modelKey).id instead for parallel execution
+   */
+  getModelId() {
+    if (!this.modelConfig) {
+      throw new Error("Model not set for this tracker");
+    }
+    return this.modelConfig.id;
+  }
+  /**
+   * Get the model configuration
+   * @deprecated Use getModelById(modelKey) instead for parallel execution
+   */
+  getModelConfig() {
+    if (!this.modelConfig) {
+      throw new Error("Model not set for this tracker");
+    }
+    return this.modelConfig;
+  }
+  /**
+   * Switch model (useful for sequential model switching)
+   * @deprecated For parallel execution, pass model key to recordCall() instead
+   */
+  switchModel(modelKey) {
+    this.modelKey = modelKey;
+    this.modelConfig = getModel(modelKey);
+  }
+  /**
+   * Get a model helper with bound recordCall for parallel execution
+   * Perfect for running multiple AI calls in parallel with different models
+   *
+   * Usage:
+   *   const flashModel = tracker.getModelById("gemini-2.5-flash");
+   *   const liteModel = tracker.getModelById("gemini-2.5-flash-lite");
+   *
+   *   const [result1, result2] = await Promise.all([
+   *     generateText({
+   *       model: openRouter(flashModel.id),
+   *       prompt: prompt1,
+   *     }).then(r => { flashModel.recordCall(r.usage.inputTokens, r.usage.outputTokens); return r; }),
+   *     generateText({
+   *       model: openRouter(liteModel.id),
+   *       prompt: prompt2,
+   *     }).then(r => { liteModel.recordCall(r.usage.inputTokens, r.usage.outputTokens); return r; }),
+   *   ]);
+   */
+  getModelById(modelKey) {
+    const modelConfig = getModel(modelKey);
+    return {
+      id: modelConfig.id,
+      name: modelConfig.name,
+      recordCall: (inputTokens, outputTokens) => {
+        this.recordCall(inputTokens, outputTokens, modelKey);
+      }
+    };
+  }
+  /**
+   * Record an API call with token usage
+   *
+   * For sequential execution:
+   *   tracker.switchModel("gemini-2.5-flash")
+   *   tracker.recordCall(inputTokens, outputTokens)
+   *
+   * For parallel execution:
+   *   tracker.recordCall(inputTokens, outputTokens, "gemini-2.5-flash")
+   *   tracker.recordCall(inputTokens, outputTokens, "gemini-2.5-pro")
+   */
+  recordCall(inputTokens = 0, outputTokens = 0, modelKeyOverride) {
+    const modelKeyToUse = modelKeyOverride || this.modelKey;
+    if (!modelKeyToUse) {
+      throw new Error(
+        "Model not set and no modelKeyOverride provided to recordCall()"
+      );
+    }
+    const modelConfig = getModel(modelKeyToUse);
+    this.stats.apiCalls += 1;
+    this.stats.inputTokens += inputTokens;
+    this.stats.outputTokens += outputTokens;
+    if (this.isAggregating) {
+      const modelId = modelConfig.id;
+      const existing = this.perModelStats.get(modelId) || {
+        modelName: modelConfig.name,
+        apiCalls: 0,
+        inputTokens: 0,
+        outputTokens: 0,
+        totalTokens: 0,
+        inputCost: 0,
+        outputCost: 0,
+        totalCost: 0
+      };
+      const costs = calculateCost(modelKeyToUse, inputTokens, outputTokens);
+      this.perModelStats.set(modelId, {
+        modelId,
+        modelName: modelConfig.name,
+        apiCalls: existing.apiCalls + 1,
+        inputTokens: existing.inputTokens + inputTokens,
+        outputTokens: existing.outputTokens + outputTokens,
+        totalTokens: existing.totalTokens + inputTokens + outputTokens,
+        inputCost: existing.inputCost + costs.inputCost,
+        outputCost: existing.outputCost + costs.outputCost,
+        totalCost: existing.totalCost + costs.totalCost
+      });
+    }
+  }
+  /**
+   * Estimate cost for a prompt without making an API call
+   * Useful for dry-run mode to preview costs
+   *
+   * Note: This method is async because it lazy-loads the tiktoken library
+   * to avoid bundling 2MB of tokenizer data for browser clients.
+   *
+   * @param prompt - The prompt text to estimate
+   * @param estimatedOutputTokens - Estimated number of output tokens (default: 500)
+   * @returns Object with token counts and cost estimates
+   */
+  async estimateCost(prompt, estimatedOutputTokens = 500) {
+    if (!this.modelKey) {
+      throw new Error("Model not set for estimation");
+    }
+    const { Tiktoken, cl100k_base } = await getTiktoken();
+    const encoding = new Tiktoken(cl100k_base);
+    const inputTokens = encoding.encode(prompt).length;
+    const costs = calculateCost(
+      this.modelKey,
+      inputTokens,
+      estimatedOutputTokens
+    );
+    return {
+      inputTokens,
+      outputTokens: estimatedOutputTokens,
+      totalTokens: inputTokens + estimatedOutputTokens,
+      inputCost: costs.inputCost,
+      outputCost: costs.outputCost,
+      totalCost: costs.totalCost
+    };
+  }
+  /**
+   * Get current statistics (single model or aggregated)
+   * Returns null only if tracker is in aggregating mode - use getAggregatedStats() instead
+   */
+  getStats() {
+    if (this.isAggregating) {
+      return null;
+    }
+    if (!this.modelKey || !this.modelConfig) {
+      throw new Error("Model not set for this tracker");
+    }
+    const totalTokens = this.stats.inputTokens + this.stats.outputTokens;
+    const costs = calculateCost(
+      this.modelKey,
+      this.stats.inputTokens,
+      this.stats.outputTokens
+    );
+    return {
+      modelId: this.modelConfig.id,
+      modelName: this.modelConfig.name,
+      apiCalls: this.stats.apiCalls,
+      inputTokens: this.stats.inputTokens,
+      outputTokens: this.stats.outputTokens,
+      totalTokens,
+      inputCost: costs.inputCost,
+      outputCost: costs.outputCost,
+      totalCost: costs.totalCost
+    };
+  }
+  /**
+   * Get aggregated statistics from all models
+   */
+  getAggregatedStats() {
+    const perModel = Array.from(this.perModelStats.values());
+    const totals = {
+      totalApiCalls: perModel.reduce((sum, m) => sum + m.apiCalls, 0),
+      totalInputTokens: perModel.reduce((sum, m) => sum + m.inputTokens, 0),
+      totalOutputTokens: perModel.reduce((sum, m) => sum + m.outputTokens, 0),
+      totalTokens: perModel.reduce((sum, m) => sum + m.totalTokens, 0),
+      totalInputCost: perModel.reduce((sum, m) => sum + m.inputCost, 0),
+      totalOutputCost: perModel.reduce((sum, m) => sum + m.outputCost, 0),
+      totalCost: perModel.reduce((sum, m) => sum + m.totalCost, 0)
+    };
+    return { perModel, totals };
+  }
+  /**
+   * Print statistics to console
+   */
+  printStats() {
+    if (this.isAggregating) {
+      this.printAggregatedStats();
+    } else {
+      const stats = this.getStats();
+      if (!stats) {
+        console.log("No statistics available");
+        return;
+      }
+      console.log("\n\u{1F4CA} API Usage Statistics:");
+      console.log(`  Model: ${stats.modelName} (${stats.modelId})`);
+      console.log(`  API Calls: ${stats.apiCalls}`);
+      console.log(`  Input Tokens: ${stats.inputTokens.toLocaleString()}`);
+      console.log(`  Output Tokens: ${stats.outputTokens.toLocaleString()}`);
+      console.log(`  Total Tokens: ${stats.totalTokens.toLocaleString()}`);
+      if (stats.totalCost > 0) {
+        console.log(`  Input Cost: $${stats.inputCost.toFixed(4)}`);
+        console.log(`  Output Cost: $${stats.outputCost.toFixed(4)}`);
+        console.log(`  Total Cost: $${stats.totalCost.toFixed(4)}`);
+      } else {
+        console.log("  Cost: Free / Not calculated");
+      }
+    }
+  }
+  /**
+   * Print aggregated statistics from all models
+   */
+  printAggregatedStats() {
+    const { perModel, totals } = this.getAggregatedStats();
+    console.log("\n\u{1F4CA} Aggregated API Usage Statistics:");
+    console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n");
+    console.log("Per-Model Breakdown:");
+    for (const stats of perModel) {
+      console.log(`
+  ${stats.modelName}`);
+      console.log(`    API Calls: ${stats.apiCalls}`);
+      console.log(`    Input Tokens: ${stats.inputTokens.toLocaleString()}`);
+      console.log(`    Output Tokens: ${stats.outputTokens.toLocaleString()}`);
+      console.log(`    Total Tokens: ${stats.totalTokens.toLocaleString()}`);
+      if (stats.totalCost > 0) {
+        console.log(`    Input Cost: $${stats.inputCost.toFixed(4)}`);
+        console.log(`    Output Cost: $${stats.outputCost.toFixed(4)}`);
+        console.log(`    Total Cost: $${stats.totalCost.toFixed(4)}`);
+      } else {
+        console.log(`    Cost: Free`);
+      }
+    }
+    console.log("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    console.log("Totals Across All Models:");
+    console.log(`  Total API Calls: ${totals.totalApiCalls}`);
+    console.log(
+      `  Total Input Tokens: ${totals.totalInputTokens.toLocaleString()}`
+    );
+    console.log(
+      `  Total Output Tokens: ${totals.totalOutputTokens.toLocaleString()}`
+    );
+    console.log(`  Total Tokens: ${totals.totalTokens.toLocaleString()}`);
+    console.log(`  Total Input Cost: $${totals.totalInputCost.toFixed(4)}`);
+    console.log(`  Total Output Cost: $${totals.totalOutputCost.toFixed(4)}`);
+    console.log(`  TOTAL COST: $${totals.totalCost.toFixed(4)}`);
+    console.log("\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\n");
+  }
+  /**
+   * Reset statistics
+   */
+  reset() {
+    this.stats = {
+      apiCalls: 0,
+      inputTokens: 0,
+      outputTokens: 0
+    };
+    this.perModelStats.clear();
+  }
+};
+function printAvailableModels() {
+  console.log("\n\u{1F4CB} Available Models:");
+  const models = listModels();
+  for (const { key, config } of models) {
+    const isDefault = key === DEFAULT_MODEL_KEY;
+    const defaultMarker = isDefault ? " (DEFAULT)" : "";
+    const costInfo = config.inputCostPerMillion === 0 && config.outputCostPerMillion === 0 ? "Free" : `$${config.inputCostPerMillion}/1M in, $${config.outputCostPerMillion}/1M out`;
+    console.log(`  ${key}${defaultMarker}`);
+    console.log(`    Name: ${config.name}`);
+    console.log(`    ID: ${config.id}`);
+    console.log(`    Cost: ${costInfo}`);
+    if (config.description) {
+      console.log(`    Description: ${config.description}`);
+    }
+    console.log("");
+  }
+}
+z2.enum(["google", "anthropic", "openai"]);
+function extractNativeModelId(openRouterId, provider) {
+  const prefix = `${provider}/`;
+  if (openRouterId.startsWith(prefix)) {
+    return openRouterId.slice(prefix.length);
+  }
+  if (provider === "google" && openRouterId.startsWith("google/")) {
+    return openRouterId.slice("google/".length);
+  }
+  return openRouterId;
+}
+function getProviderFromOpenRouterId(openRouterId) {
+  if (openRouterId.startsWith("google/") || openRouterId.includes("gemini")) {
+    return "google";
+  }
+  if (openRouterId.startsWith("anthropic/") || openRouterId.includes("claude")) {
+    return "anthropic";
+  }
+  if (openRouterId.startsWith("openai/") || openRouterId.includes("gpt")) {
+    return "openai";
+  }
+  return void 0;
+}
+function getDefaultModelForProvider(provider) {
+  const models = listModels({
+    supportsAsyncBatch: true,
+    isEmbeddingModel: false
+  });
+  for (const { config } of models) {
+    const modelProvider = getProviderFromOpenRouterId(config.id);
+    if (modelProvider === provider) {
+      return extractNativeModelId(config.id, provider);
+    }
+  }
+  throw new Error(
+    `No batch-compatible models found for ${provider}. Ensure you have models with supportsAsyncBatch: true in your generated models file.`
+  );
+}
+function resolveModelForProvider(modelKey, provider) {
+  if (!modelKey) {
+    return getDefaultModelForProvider(provider);
+  }
+  const modelConfig = getModel(modelKey);
+  if (!modelConfig.supportsAsyncBatch) {
+    throw new Error(
+      `Model "${modelKey}" does not support async batch processing.`
+    );
+  }
+  const modelProvider = getProviderFromOpenRouterId(modelConfig.id);
+  if (modelProvider !== provider) {
+    throw new Error(
+      `Model "${modelKey}" belongs to ${modelProvider || "unknown"} provider, not ${provider}. Use a ${provider} model or change the batch provider.`
+    );
+  }
+  return extractNativeModelId(modelConfig.id, provider);
+}
+function getBestProviderForModel(modelKey) {
+  const modelConfig = getModel(modelKey);
+  if (!modelConfig.supportsAsyncBatch) {
+    return void 0;
+  }
+  return getProviderFromOpenRouterId(modelConfig.id);
+}
+var AnthropicBatchProvider = class {
+  name = "anthropic";
+  supportsBatching = true;
+  client;
+  logger;
+  constructor(config = {}, logger2) {
+    const apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "Anthropic API key is required. Set ANTHROPIC_API_KEY or pass apiKey in config."
+      );
+    }
+    this.client = new Anthropic({ apiKey });
+    this.logger = logger2;
+  }
+  async submit(requests, options) {
+    if (requests.length === 0) {
+      throw new Error("Cannot submit empty batch");
+    }
+    const modelKey = requests[0]?.model;
+    const model = resolveModelForProvider(modelKey, "anthropic");
+    this.logger?.log("INFO", "Submitting Anthropic batch", {
+      requestCount: requests.length,
+      modelKey: modelKey || "default",
+      model
+    });
+    const batchRequests = requests.map((req, i) => {
+      const reqModel = req.model ? resolveModelForProvider(req.model, "anthropic") : model;
+      const anthropicTools = req.tools && Object.keys(req.tools).length > 0 ? Object.entries(req.tools).map(([name, tool]) => ({
+        name,
+        description: tool.description || "",
+        input_schema: tool.inputSchema ? jsonSchema(tool.inputSchema) : {
+          type: "object",
+          properties: {}
+        }
+      })) : void 0;
+      let toolChoice;
+      if (req.toolChoice) {
+        if (req.toolChoice === "auto") {
+          toolChoice = { type: "auto" };
+        } else if (req.toolChoice === "required") {
+          toolChoice = { type: "any" };
+        } else if (typeof req.toolChoice === "object" && req.toolChoice.type === "tool") {
+          toolChoice = { type: "tool", name: req.toolChoice.toolName };
+        }
+      }
+      return {
+        custom_id: req.customId || `request-${i}`,
+        params: {
+          model: reqModel,
+          max_tokens: req.maxTokens || 1024,
+          messages: [{ role: "user", content: req.prompt }],
+          ...req.system && { system: req.system },
+          ...req.temperature !== void 0 && {
+            temperature: req.temperature
+          },
+          ...anthropicTools && req.toolChoice !== "none" && { tools: anthropicTools },
+          ...toolChoice && { tool_choice: toolChoice }
+        }
+      };
+    });
+    const response = await this.client.messages.batches.create({
+      requests: batchRequests
+    });
+    this.logger?.log("INFO", "Anthropic batch submitted", {
+      batchId: response.id,
+      requestCount: requests.length,
+      processingStatus: response.processing_status
+    });
+    return {
+      id: response.id,
+      provider: this.name,
+      requestCount: requests.length,
+      createdAt: new Date(response.created_at),
+      metadata: {
+        model,
+        processingStatus: response.processing_status,
+        ...options?.metadata
+      }
+    };
+  }
+  async checkStatus(handle) {
+    const batch = await this.client.messages.batches.retrieve(handle.id);
+    const succeededCount = batch.request_counts?.succeeded || 0;
+    const erroredCount = batch.request_counts?.errored || 0;
+    const canceledCount = batch.request_counts?.canceled || 0;
+    const expiredCount = batch.request_counts?.expired || 0;
+    const processingCount = batch.request_counts?.processing || 0;
+    const processedCount = succeededCount + erroredCount + canceledCount + expiredCount;
+    const totalCount = processedCount + processingCount;
+    const status = {
+      state: this.mapStatus(batch.processing_status),
+      processedCount,
+      totalCount: totalCount || handle.requestCount,
+      succeededCount,
+      failedCount: erroredCount + canceledCount + expiredCount
+    };
+    this.logger?.log("DEBUG", "Anthropic batch status", {
+      batchId: handle.id,
+      state: status.state,
+      processed: status.processedCount,
+      total: status.totalCount
+    });
+    return status;
+  }
+  async getResults(handle) {
+    const status = await this.checkStatus(handle);
+    if (status.state !== "completed" && status.state !== "failed") {
+      throw new Error(`Batch not complete: state=${status.state}`);
+    }
+    this.logger?.log("INFO", "Retrieving Anthropic batch results", {
+      batchId: handle.id
+    });
+    const results = [];
+    let index = 0;
+    const resultsIterator = await this.client.messages.batches.results(
+      handle.id
+    );
+    for await (const entry of resultsIterator) {
+      if (entry.result.type === "succeeded") {
+        const message = entry.result.message;
+        const textContent = message.content.find(
+          (c) => c.type === "text"
+        );
+        results.push({
+          index,
+          customId: entry.custom_id,
+          text: textContent?.text || "",
+          inputTokens: message.usage?.input_tokens || 0,
+          outputTokens: message.usage?.output_tokens || 0
+        });
+      } else {
+        let errorMsg;
+        switch (entry.result.type) {
+          case "errored":
+            errorMsg = entry.result.error?.message || `Error type: ${entry.result.error?.type}` || "Request errored";
+            break;
+          case "canceled":
+            errorMsg = "Request was canceled";
+            break;
+          case "expired":
+            errorMsg = "Request expired";
+            break;
+          default:
+            errorMsg = `Unknown result type: ${entry.result.type}`;
+        }
+        results.push({
+          index,
+          customId: entry.custom_id,
+          text: "",
+          inputTokens: 0,
+          outputTokens: 0,
+          error: errorMsg
+        });
+      }
+      index++;
+    }
+    this.logger?.log("INFO", "Anthropic batch results retrieved", {
+      batchId: handle.id,
+      resultCount: results.length,
+      successCount: results.filter((r) => !r.error).length,
+      errorCount: results.filter((r) => r.error).length
+    });
+    return results;
+  }
+  async cancel(handle) {
+    await this.client.messages.batches.cancel(handle.id);
+    this.logger?.log("INFO", "Anthropic batch cancelled", {
+      batchId: handle.id
+    });
+  }
+  mapStatus(status) {
+    switch (status) {
+      case "ended":
+        return "completed";
+      case "canceling":
+      case "canceled":
+        return "cancelled";
+      case "in_progress":
+        return "processing";
+      default:
+        return "pending";
+    }
+  }
+};
+var GoogleBatchProvider = class {
+  name = "google";
+  supportsBatching = true;
+  ai;
+  logger;
+  constructor(config = {}, logger2) {
+    const apiKey = config.apiKey || process.env.GOOGLE_GENERATIVE_AI_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "Google API key is required. Set GOOGLE_GENERATIVE_AI_API_KEY or pass apiKey in config."
+      );
+    }
+    this.ai = new GoogleGenAI({ apiKey });
+    this.logger = logger2;
+  }
+  async submit(requests, options) {
+    if (requests.length === 0) {
+      throw new Error("Cannot submit empty batch");
+    }
+    const modelKey = requests[0]?.model;
+    const model = resolveModelForProvider(modelKey, "google");
+    const customIds = requests.map(
+      (req, idx) => req.id || `request-${idx}`
+    );
+    this.logger?.log("INFO", "Submitting Google batch", {
+      requestCount: requests.length,
+      modelKey: modelKey || "default",
+      model
+    });
+    const inlinedRequests = requests.map((req) => {
+      const parts = [{ text: req.prompt }];
+      if (req.schema) {
+        parts.push({
+          text: `Please respond with a JSON object matching the expected schema structure.`
+        });
+      }
+      if (req.maxTokens) {
+        parts.push({
+          text: `Limit your response to a maximum of ${req.maxTokens} tokens.`
+        });
+      }
+      if (req.temperature !== void 0) {
+        parts.push({
+          text: `Use a temperature setting of ${req.temperature} for this response.`
+        });
+      }
+      const customId = req.id || `request-${requests.indexOf(req)}`;
+      const response = {
+        contents: [
+          {
+            role: "user",
+            parts
+          }
+        ],
+        // Store customId in metadata - Google SDK supports this
+        metadata: { customId }
+      };
+      if (req.tools && Object.keys(req.tools).length > 0) {
+        const config = {
+          tools: [
+            {
+              functionDeclarations: Object.entries(req.tools).map(
+                ([name, tool]) => ({
+                  name,
+                  description: tool.description,
+                  // AI SDK uses inputSchema, convert to JSON Schema for Google
+                  parameters: tool.inputSchema ? jsonSchema(tool.inputSchema) : void 0
+                })
+              )
+            }
+          ]
+        };
+        if (req.toolChoice) {
+          if (req.toolChoice === "required") {
+            config.toolConfig = {
+              functionCallingConfig: { mode: FunctionCallingConfigMode.ANY }
+            };
+          } else if (req.toolChoice === "none") {
+            config.toolConfig = {
+              functionCallingConfig: { mode: FunctionCallingConfigMode.NONE }
+            };
+          } else if (typeof req.toolChoice === "object" && req.toolChoice.type === "tool") {
+            config.toolConfig = {
+              functionCallingConfig: {
+                mode: FunctionCallingConfigMode.ANY,
+                allowedFunctionNames: [req.toolChoice.toolName]
+              }
+            };
+          }
+        }
+        response.config = config;
+      }
+      return response;
+    });
+    const batchJob = await this.ai.batches.create({
+      model,
+      src: { inlinedRequests },
+      config: {
+        displayName: options?.displayName || `batch-${Date.now()}-${requests.length}`
+      }
+    });
+    if (!batchJob.name) {
+      throw new Error("Batch job created but no name returned");
+    }
+    this.logger?.log("INFO", "Google batch submitted", {
+      batchName: batchJob.name,
+      requestCount: requests.length
+    });
+    return {
+      id: batchJob.name,
+      provider: this.name,
+      requestCount: requests.length,
+      createdAt: /* @__PURE__ */ new Date(),
+      metadata: {
+        model,
+        displayName: options?.displayName,
+        customIds
+        // Store for getResults to use
+      }
+    };
+  }
+  async checkStatus(handle) {
+    const batch = await this.ai.batches.get({ name: handle.id });
+    const status = {
+      state: this.mapState(batch.state),
+      processedCount: Number(batch.completionStats?.successfulCount) || 0,
+      totalCount: handle.requestCount,
+      succeededCount: batch.completionStats?.successfulCount ? Number(batch.completionStats.successfulCount) : void 0,
+      failedCount: batch.completionStats?.failedCount ? Number(batch.completionStats.failedCount) : void 0,
+      error: batch.error ? String(batch.error) : void 0
+    };
+    if (batch.state === JobState.JOB_STATE_SUCCEEDED || batch.state === JobState.JOB_STATE_FAILED) {
+      const inlinedResponses = batch.dest?.inlinedResponses;
+      if (inlinedResponses && Array.isArray(inlinedResponses)) {
+        let totalInputTokens = 0;
+        let totalOutputTokens = 0;
+        for (const inlinedResponse of inlinedResponses) {
+          const usageMetadata = inlinedResponse.response?.usageMetadata;
+          if (usageMetadata) {
+            totalInputTokens += usageMetadata.promptTokenCount ?? 0;
+            totalOutputTokens += usageMetadata.candidatesTokenCount ?? 0;
+          }
+        }
+        status.totalInputTokens = totalInputTokens;
+        status.totalOutputTokens = totalOutputTokens;
+        this.logger?.log("INFO", "Google batch token usage", {
+          batchId: handle.id,
+          totalInputTokens,
+          totalOutputTokens,
+          responseCount: inlinedResponses.length
+        });
+      }
+    }
+    this.logger?.log("DEBUG", "sdk response", { batch });
+    this.logger?.log("DEBUG", "Google batch status", {
+      batchId: handle.id,
+      state: status.state,
+      processed: status.processedCount,
+      total: status.totalCount,
+      startTime: batch.startTime,
+      endTime: batch.endTime,
+      totalInputTokens: status.totalInputTokens,
+      totalOutputTokens: status.totalOutputTokens
+    });
+    return status;
+  }
+  async getResults(handle, customIds) {
+    const requestIds = customIds || handle.metadata?.customIds;
+    this.logger?.log("DEBUG", "Google batch getResults - customIds lookup", {
+      batchId: handle.id,
+      hasCustomIdsParam: !!customIds,
+      hasHandleMetadata: !!handle.metadata,
+      hasMetadataCustomIds: !!handle.metadata?.customIds,
+      requestIdsFound: requestIds?.length ?? 0
+    });
+    const batch = await this.ai.batches.get({ name: handle.id });
+    if (batch.state !== JobState.JOB_STATE_SUCCEEDED && batch.state !== JobState.JOB_STATE_FAILED) {
+      throw new Error(`Batch not complete: state=${batch.state}`);
+    }
+    if (batch.state === JobState.JOB_STATE_FAILED) {
+      const errorMsg = batch.error || "Unknown error";
+      throw new Error(`Batch failed: ${errorMsg}`);
+    }
+    const maybeInlinedResponses = batch.dest?.inlinedResponses;
+    if (!maybeInlinedResponses) {
+      throw new Error(
+        "Batch response format unexpected - could not find inlinedResponses array"
+      );
+    }
+    if (!maybeInlinedResponses || !Array.isArray(maybeInlinedResponses)) {
+      this.logger?.log("ERROR", "Unexpected batch response format", {
+        batchId: handle.id,
+        hasResponse: !!maybeInlinedResponses,
+        destKeys: batch.dest ? Object.keys(batch.dest) : []
+      });
+      throw new Error(
+        "Batch response format unexpected - could not find inlinedResponses array"
+      );
+    }
+    this.logger?.log("INFO", "Processing Google batch results", {
+      batchId: handle.id,
+      responseCount: maybeInlinedResponses.length,
+      firstItem: JSON.stringify(maybeInlinedResponses[0])
+      // Log entire first item structure to be sure
+    });
+    return maybeInlinedResponses.map((inlinedResponse, index) => {
+      try {
+        const responseMetadata = inlinedResponse.metadata;
+        const customId = responseMetadata?.customId || requestIds?.[index] || `request-${index}`;
+        if (!requestIds?.[index] && !responseMetadata?.customId) {
+          this.logger?.log(
+            "WARN",
+            `No customId found for index ${index}, using fallback`,
+            { index }
+          );
+        }
+        if (inlinedResponse.error) {
+          const result2 = {
+            index,
+            customId,
+            text: "",
+            inputTokens: 0,
+            outputTokens: 0,
+            error: inlinedResponse.error.message || "Unknown error"
+          };
+          this.logger?.log("DEBUG", `Response ${index} has error`, {
+            customId,
+            error: result2.error
+          });
+          return result2;
+        }
+        const response = inlinedResponse.response;
+        if (!response) {
+          const result2 = {
+            index,
+            text: "",
+            inputTokens: 0,
+            outputTokens: 0,
+            error: "InlinedResponse missing response field"
+          };
+          this.logger?.log(
+            "DEBUG",
+            `Response ${index} missing response field`,
+            { customId }
+          );
+          return result2;
+        }
+        const text = response.text || response.candidates?.[0]?.content?.parts?.[0]?.text || "";
+        const usageMetadata = response.usageMetadata;
+        const result = {
+          index,
+          customId,
+          // Use the already-resolved customId from above
+          text,
+          inputTokens: usageMetadata?.promptTokenCount ?? 0,
+          outputTokens: usageMetadata?.candidatesTokenCount ?? 0
+        };
+        this.logger?.log("DEBUG", `Response ${index} parsed successfully`, {
+          customId,
+          textLength: text.length,
+          inputTokens: result.inputTokens,
+          outputTokens: result.outputTokens
+        });
+        return result;
+      } catch (error) {
+        const result = {
+          index,
+          text: "",
+          inputTokens: 0,
+          outputTokens: 0,
+          error: error instanceof Error ? error.message : String(error)
+        };
+        this.logger?.log("ERROR", `Response ${index} threw exception`, {
+          error: result.error
+        });
+        return result;
+      }
+    });
+  }
+  async cancel(handle) {
+    try {
+      await this.ai.batches.delete({ name: handle.id });
+      this.logger?.log("INFO", "Google batch cancelled", {
+        batchId: handle.id
+      });
+    } catch (error) {
+      this.logger?.log("WARN", "Failed to cancel Google batch", {
+        batchId: handle.id,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  mapState(state) {
+    switch (state) {
+      case JobState.JOB_STATE_SUCCEEDED:
+        return "completed";
+      case JobState.JOB_STATE_FAILED:
+        return "failed";
+      case JobState.JOB_STATE_CANCELLED:
+        return "cancelled";
+      case JobState.JOB_STATE_PENDING:
+        return "pending";
+      case JobState.JOB_STATE_RUNNING:
+        return "processing";
+      default:
+        return "processing";
+    }
+  }
+};
+var OpenAIBatchProvider = class {
+  name = "openai";
+  supportsBatching = true;
+  client;
+  logger;
+  constructor(config = {}, logger2) {
+    const apiKey = config.apiKey || process.env.OPENAI_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "OpenAI API key is required. Set OPENAI_API_KEY or pass apiKey in config."
+      );
+    }
+    this.client = new OpenAI({ apiKey });
+    this.logger = logger2;
+  }
+  async submit(requests, options) {
+    if (requests.length === 0) {
+      throw new Error("Cannot submit empty batch");
+    }
+    const modelKey = requests[0]?.model;
+    const model = resolveModelForProvider(modelKey, "openai");
+    this.logger?.log("INFO", "Submitting OpenAI batch", {
+      requestCount: requests.length,
+      modelKey: modelKey || "default",
+      model
+    });
+    const jsonlContent = requests.map((req, i) => {
+      const reqModel = req.model ? resolveModelForProvider(req.model, "openai") : model;
+      const openaiTools = req.tools && Object.keys(req.tools).length > 0 ? Object.entries(req.tools).map(([name, tool]) => ({
+        type: "function",
+        function: {
+          name,
+          description: tool.description,
+          parameters: tool.inputSchema ? jsonSchema(tool.inputSchema) : void 0
+        }
+      })) : void 0;
+      let toolChoice;
+      if (req.toolChoice) {
+        if (req.toolChoice === "auto") {
+          toolChoice = "auto";
+        } else if (req.toolChoice === "required") {
+          toolChoice = "required";
+        } else if (req.toolChoice === "none") {
+          toolChoice = "none";
+        } else if (typeof req.toolChoice === "object" && req.toolChoice.type === "tool") {
+          toolChoice = {
+            type: "function",
+            function: { name: req.toolChoice.toolName }
+          };
+        }
+      }
+      return JSON.stringify({
+        custom_id: req.customId || `request-${i}`,
+        method: "POST",
+        url: "/v1/chat/completions",
+        body: {
+          model: reqModel,
+          messages: [
+            ...req.system ? [{ role: "system", content: req.system }] : [],
+            { role: "user", content: req.prompt }
+          ],
+          max_tokens: req.maxTokens || 1024,
+          ...req.temperature !== void 0 && {
+            temperature: req.temperature
+          },
+          ...openaiTools && { tools: openaiTools },
+          ...toolChoice && { tool_choice: toolChoice }
+        }
+      });
+    }).join("\n");
+    const file = await this.client.files.create({
+      file: new File([jsonlContent], "batch-requests.jsonl", {
+        type: "application/jsonl"
+      }),
+      purpose: "batch"
+    });
+    this.logger?.log("DEBUG", "OpenAI batch file uploaded", {
+      fileId: file.id,
+      filename: file.filename
+    });
+    const batch = await this.client.batches.create({
+      input_file_id: file.id,
+      endpoint: "/v1/chat/completions",
+      completion_window: "24h",
+      // OpenAI only supports 24h
+      metadata: options?.metadata
+    });
+    this.logger?.log("INFO", "OpenAI batch submitted", {
+      batchId: batch.id,
+      requestCount: requests.length,
+      status: batch.status
+    });
+    return {
+      id: batch.id,
+      provider: this.name,
+      requestCount: requests.length,
+      createdAt: new Date(batch.created_at * 1e3),
+      metadata: {
+        model,
+        inputFileId: file.id,
+        outputFileId: batch.output_file_id,
+        errorFileId: batch.error_file_id,
+        ...options?.metadata
+      }
+    };
+  }
+  async checkStatus(handle) {
+    const batch = await this.client.batches.retrieve(handle.id);
+    const requestCounts = batch.request_counts;
+    const completedCount = requestCounts?.completed || 0;
+    const failedCount = requestCounts?.failed || 0;
+    const totalCount = requestCounts?.total || handle.requestCount;
+    let state = this.mapStatus(batch.status);
+    if (state === "completed" && !batch.output_file_id) {
+      this.logger?.log(
+        "WARN",
+        "Batch shows completed but output file not ready yet",
+        {
+          batchId: handle.id,
+          status: batch.status
+        }
+      );
+      state = "processing";
+    }
+    const status = {
+      state,
+      processedCount: completedCount + failedCount,
+      totalCount,
+      succeededCount: completedCount,
+      failedCount,
+      error: batch.errors?.data?.[0]?.message
+    };
+    this.logger?.log("INFO", "OpenAI batch status check", {
+      batchId: handle.id,
+      rawStatus: batch.status,
+      mappedState: status.state,
+      processed: status.processedCount,
+      total: status.totalCount,
+      outputFileId: batch.output_file_id
+    });
+    return status;
+  }
+  async getResults(handle) {
+    const batch = await this.client.batches.retrieve(handle.id);
+    this.logger?.log("INFO", "OpenAI batch retrieve for results", {
+      batchId: handle.id,
+      status: batch.status,
+      outputFileId: batch.output_file_id,
+      errorFileId: batch.error_file_id
+    });
+    if (batch.status !== "completed" && batch.status !== "failed") {
+      throw new Error(`Batch not complete: status=${batch.status}`);
+    }
+    if (batch.status === "failed") {
+      const errorMessage = batch.errors?.data?.[0]?.message || "Unknown batch error";
+      throw new Error(`Batch failed: ${errorMessage}`);
+    }
+    if (!batch.output_file_id) {
+      this.logger?.log("ERROR", "Batch completed but no output file", {
+        batchId: handle.id,
+        status: batch.status,
+        requestCounts: batch.request_counts,
+        errors: batch.errors
+      });
+      throw new Error(
+        `Batch output file not available. Status: ${batch.status}, Request counts: ${JSON.stringify(batch.request_counts)}`
+      );
+    }
+    this.logger?.log("INFO", "Retrieving OpenAI batch results", {
+      batchId: handle.id,
+      outputFileId: batch.output_file_id
+    });
+    const fileContent = await this.client.files.content(batch.output_file_id);
+    const text = await fileContent.text();
+    const lines = text.trim().split("\n").filter(Boolean);
+    const results = lines.map(
+      (line, index) => {
+        try {
+          const result = JSON.parse(line);
+          const response = result.response?.body;
+          const choice = response?.choices?.[0];
+          if (result.error) {
+            return {
+              index,
+              customId: result.custom_id,
+              text: "",
+              inputTokens: 0,
+              outputTokens: 0,
+              error: result.error.message || "Unknown error"
+            };
+          }
+          return {
+            index,
+            customId: result.custom_id,
+            text: choice?.message?.content || "",
+            inputTokens: response?.usage?.prompt_tokens || 0,
+            outputTokens: response?.usage?.completion_tokens || 0
+          };
+        } catch (error) {
+          return {
+            index,
+            customId: void 0,
+            text: "",
+            inputTokens: 0,
+            outputTokens: 0,
+            error: error instanceof Error ? error.message : String(error)
+          };
+        }
+      }
+    );
+    this.logger?.log("INFO", "OpenAI batch results retrieved", {
+      batchId: handle.id,
+      resultCount: results.length,
+      successCount: results.filter((r) => !r.error).length,
+      errorCount: results.filter((r) => r.error).length
+    });
+    return results;
+  }
+  async cancel(handle) {
+    await this.client.batches.cancel(handle.id);
+    this.logger?.log("INFO", "OpenAI batch cancelled", { batchId: handle.id });
+  }
+  mapStatus(status) {
+    switch (status) {
+      case "completed":
+        return "completed";
+      case "failed":
+      case "expired":
+        return "failed";
+      case "cancelling":
+      case "cancelled":
+        return "cancelled";
+      case "validating":
+      case "in_progress":
+      case "finalizing":
+        return "processing";
+      default:
+        return "pending";
+    }
+  }
+};
+var logger = createLogger("AIHelper");
+var DEFAULT_EMBEDDING_DIMENSIONS = 768;
+function getModelProvider(modelConfig) {
+  if (modelConfig.provider === "openrouter") {
+    return openrouter(modelConfig.id, {
+      extraBody: {
+        provider: {
+          sort: "throughput",
+          require_parameters: true,
+          max_price: {
+            prompt: modelConfig.inputCostPerMillion,
+            completion: modelConfig.outputCostPerMillion
+          }
+        }
+      }
+    });
+  }
+  return google(modelConfig.id);
+}
+function calculateCostWithDiscount(modelKey, inputTokens, outputTokens, isBatch = false) {
+  const model = getModel(modelKey);
+  const baseCost = calculateCost(modelKey, inputTokens, outputTokens);
+  if (isBatch && model.batchDiscountPercent) {
+    return baseCost.totalCost * (1 - model.batchDiscountPercent / 100);
+  }
+  return baseCost.totalCost;
+}
+var AIHelperImpl = class _AIHelperImpl {
+  topic;
+  aiCallLogger;
+  logContext;
+  batchLogFn;
+  constructor(topic, aiCallLogger, logContext) {
+    if (!aiCallLogger) {
+      throw new Error(
+        "AIHelperImpl requires a logger. Create one using createPrismaAICallLogger(prisma)."
+      );
+    }
+    this.topic = topic;
+    this.aiCallLogger = aiCallLogger;
+    this.logContext = logContext;
+    if (logContext) {
+      this.batchLogFn = (level, message, meta) => {
+        logContext.createLog({
+          workflowRunId: logContext.workflowRunId,
+          workflowStageId: logContext.stageRecordId,
+          level,
+          message,
+          metadata: meta
+        }).catch((err) => logger.error("Failed to persist log:", err));
+        logger.debug(`[${level}] ${message}`, meta ? JSON.stringify(meta) : "");
+      };
+    }
+  }
+  async generateText(modelKey, prompt, options = {}) {
+    const modelConfig = getModel(modelKey);
+    const model = getModelProvider(modelConfig);
+    const startTime = Date.now();
+    const isMultimodal = Array.isArray(prompt);
+    const hasTools = options.tools !== void 0;
+    const hasOutputSchema = options.experimental_output !== void 0;
+    const promptForLog = isMultimodal ? prompt.filter((p) => p.type === "text").map((p) => p.text).join("\n") || "[multimodal content]" : prompt;
+    if (hasTools || hasOutputSchema) {
+      logger.debug(
+        `generateText config: hasTools=${hasTools}, hasOutputSchema=${hasOutputSchema}, toolNames=${hasTools ? Object.keys(options.tools || {}).join(", ") : "none"}`
+      );
+    }
+    const wrappedOnStepFinish = options.onStepFinish ? async (stepResult) => {
+      if (stepResult.toolResults && Array.isArray(stepResult.toolResults)) {
+        for (const toolResult of stepResult.toolResults) {
+          const result = toolResult;
+          if (result.toolName) {
+            const childTopic = `${this.topic}.tool.${result.toolName}`;
+            this.aiCallLogger.logCall({
+              topic: childTopic,
+              callType: "text",
+              modelKey,
+              modelId: modelConfig.id,
+              prompt: JSON.stringify(result.input ?? {}, null, 2),
+              response: JSON.stringify(result.output ?? {}, null, 2),
+              inputTokens: stepResult.usage.inputTokens || 0,
+              outputTokens: stepResult.usage.outputTokens || 0,
+              cost: calculateCostWithDiscount(
+                modelKey,
+                stepResult.usage.inputTokens || 0,
+                stepResult.usage.outputTokens || 0
+              ),
+              metadata: {
+                toolName: result.toolName,
+                toolCallId: result.toolCallId,
+                finishReason: stepResult.finishReason
+              }
+            });
+          }
+        }
+      }
+      await options.onStepFinish?.(stepResult);
+    } : void 0;
+    const baseOptions = {
+      model,
+      temperature: options.temperature ?? 0.7,
+      maxOutputTokens: options.maxTokens,
+      // Tool-related options (only included if tools are provided)
+      ...hasTools && {
+        tools: options.tools,
+        // Cast to any because TTools generic doesn't match NoInfer<ToolSet> at compile time
+        toolChoice: options.toolChoice,
+        stopWhen: options.stopWhen,
+        onStepFinish: wrappedOnStepFinish
+      },
+      // Experimental structured output (for tools + schema)
+      ...hasOutputSchema && {
+        experimental_output: options.experimental_output
+      }
+    };
+    logger.debug(`generateText request`, {
+      model: modelKey,
+      modelId: modelConfig.id,
+      prompt: promptForLog.substring(0, 500) + (promptForLog.length > 500 ? "..." : ""),
+      temperature: options.temperature ?? 0.7,
+      maxTokens: options.maxTokens,
+      hasTools,
+      hasOutputSchema,
+      isMultimodal
+    });
+    try {
+      const result = isMultimodal ? await generateText({
+        ...baseOptions,
+        messages: [
+          {
+            role: "user",
+            content: prompt.map(
+              (part) => part.type === "text" ? { type: "text", text: part.text } : {
+                type: "file",
+                data: part.data,
+                mediaType: part.mediaType,
+                ...part.filename && { filename: part.filename }
+              }
+            )
+          }
+        ]
+      }) : await generateText({
+        ...baseOptions,
+        prompt
+      });
+      if (hasTools || hasOutputSchema) {
+        const resultAny = result;
+        logger.debug(
+          `generateText result: stepsCount=${resultAny.steps?.length ?? 0}, hasOutput=${resultAny.output !== void 0}, finishReason=${result.finishReason}`
+        );
+      }
+      const inputTokens = result.usage?.inputTokens ?? 0;
+      const outputTokens = result.usage?.outputTokens ?? 0;
+      const cost = calculateCostWithDiscount(
+        modelKey,
+        inputTokens,
+        outputTokens
+      );
+      const durationMs = Date.now() - startTime;
+      this.aiCallLogger.logCall({
+        topic: this.topic,
+        callType: "text",
+        modelKey,
+        modelId: modelConfig.id,
+        prompt: promptForLog,
+        response: result.text,
+        inputTokens,
+        outputTokens,
+        cost,
+        metadata: {
+          temperature: options.temperature,
+          maxTokens: options.maxTokens,
+          finishReason: result.finishReason,
+          durationMs,
+          isMultimodal,
+          ...result.finishReason === "error" && { status: "error" },
+          ...isMultimodal && {
+            mediaTypes: prompt.filter((p) => p.type === "file").map((p) => p.mediaType)
+          }
+        }
+      });
+      logger.debug(`generateText response`, {
+        model: modelKey,
+        response: result.text.substring(0, 500) + (result.text.length > 500 ? "..." : ""),
+        inputTokens,
+        outputTokens,
+        cost: cost.toFixed(6),
+        durationMs,
+        finishReason: result.finishReason
+      });
+      return {
+        text: result.text,
+        inputTokens,
+        outputTokens,
+        cost,
+        // Include structured output if experimental_output was used
+        ...hasOutputSchema && {
+          output: result.output
+        }
+      };
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error(`generateText error`, {
+        model: modelKey,
+        error: errorMessage,
+        durationMs
+      });
+      this.aiCallLogger.logCall({
+        topic: this.topic,
+        callType: "text",
+        modelKey,
+        modelId: modelConfig.id,
+        prompt: promptForLog,
+        response: "",
+        inputTokens: 0,
+        outputTokens: 0,
+        cost: 0,
+        metadata: {
+          temperature: options.temperature,
+          maxTokens: options.maxTokens,
+          finishReason: "error",
+          durationMs,
+          isMultimodal,
+          status: "error",
+          error: errorMessage
+        }
+      });
+      throw error;
+    }
+  }
+  async generateObject(modelKey, prompt, schema, options = {}) {
+    const modelConfig = getModel(modelKey);
+    const model = getModelProvider(modelConfig);
+    const startTime = Date.now();
+    const isMultimodal = Array.isArray(prompt);
+    const hasTools = options.tools !== void 0;
+    const promptForLog = isMultimodal ? prompt.filter((p) => p.type === "text").map((p) => p.text).join("\n") || "[multimodal content]" : prompt;
+    const baseOptions = {
+      model,
+      output: Output.object({ schema }),
+      temperature: options.temperature ?? 0,
+      maxOutputTokens: options.maxTokens,
+      // Tool-related options (only included if tools are provided)
+      ...hasTools && {
+        tools: options.tools,
+        stopWhen: options.stopWhen,
+        onStepFinish: options.onStepFinish
+      }
+    };
+    logger.debug(`generateObject request`, {
+      model: modelKey,
+      modelId: modelConfig.id,
+      prompt: promptForLog.substring(0, 500) + (promptForLog.length > 500 ? "..." : ""),
+      temperature: options.temperature ?? 0,
+      maxTokens: options.maxTokens,
+      hasTools,
+      isMultimodal
+    });
+    try {
+      const result = isMultimodal ? await generateText({
+        ...baseOptions,
+        messages: [
+          {
+            role: "user",
+            content: prompt.map(
+              (part) => part.type === "text" ? { type: "text", text: part.text } : {
+                type: "file",
+                data: part.data,
+                mediaType: part.mediaType,
+                ...part.filename && { filename: part.filename }
+              }
+            )
+          }
+        ]
+      }) : await generateText({
+        ...baseOptions,
+        prompt
+      });
+      const inputTokens = result.usage?.inputTokens ?? 0;
+      const outputTokens = result.usage?.outputTokens ?? 0;
+      const cost = calculateCostWithDiscount(
+        modelKey,
+        inputTokens,
+        outputTokens
+      );
+      const durationMs = Date.now() - startTime;
+      this.aiCallLogger.logCall({
+        topic: this.topic,
+        callType: "object",
+        modelKey,
+        modelId: modelConfig.id,
+        prompt: promptForLog,
+        response: JSON.stringify(result.output, null, 2),
+        inputTokens,
+        outputTokens,
+        cost,
+        metadata: {
+          temperature: options.temperature,
+          maxTokens: options.maxTokens,
+          finishReason: result.finishReason,
+          durationMs,
+          isMultimodal,
+          ...result.finishReason === "error" && { status: "error" },
+          ...isMultimodal && {
+            mediaTypes: prompt.filter((p) => p.type === "file").map((p) => p.mediaType)
+          }
+        }
+      });
+      const responseStr = JSON.stringify(result.output);
+      logger.debug(`generateObject response`, {
+        model: modelKey,
+        response: responseStr.substring(0, 500) + (responseStr.length > 500 ? "..." : ""),
+        inputTokens,
+        outputTokens,
+        cost: cost.toFixed(6),
+        durationMs,
+        finishReason: result.finishReason
+      });
+      return {
+        object: result.output,
+        inputTokens,
+        outputTokens,
+        cost
+      };
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error(`generateObject error`, {
+        model: modelKey,
+        error: errorMessage,
+        durationMs
+      });
+      this.aiCallLogger.logCall({
+        topic: this.topic,
+        callType: "object",
+        modelKey,
+        modelId: modelConfig.id,
+        prompt: promptForLog,
+        response: "",
+        inputTokens: 0,
+        outputTokens: 0,
+        cost: 0,
+        metadata: {
+          temperature: options.temperature,
+          maxTokens: options.maxTokens,
+          finishReason: "error",
+          durationMs,
+          isMultimodal,
+          status: "error",
+          error: errorMessage
+        }
+      });
+      throw error;
+    }
+  }
+  async embed(modelKey, text, options = {}) {
+    const modelConfig = getModel(modelKey);
+    const texts = Array.isArray(text) ? text : [text];
+    const startTime = Date.now();
+    const dimensions = options.dimensions ?? DEFAULT_EMBEDDING_DIMENSIONS;
+    const textPreview = texts.length === 1 ? texts[0].substring(0, 200) + (texts[0].length > 200 ? "..." : "") : `[${texts.length} texts]`;
+    logger.debug(`embed request`, {
+      model: modelKey,
+      modelId: modelConfig.id,
+      textCount: texts.length,
+      textPreview,
+      dimensions,
+      taskType: options.taskType ?? "RETRIEVAL_DOCUMENT"
+    });
+    try {
+      const embeddings = [];
+      let totalInputTokens = 0;
+      for (const t of texts) {
+        const embeddingModelId = modelConfig.id.replace(/^google\//, "");
+        const result = await embed({
+          model: google.embeddingModel(embeddingModelId),
+          value: t,
+          providerOptions: {
+            google: {
+              outputDimensionality: dimensions,
+              taskType: options.taskType ?? "RETRIEVAL_DOCUMENT"
+            }
+          }
+        });
+        embeddings.push(result.embedding);
+        totalInputTokens += result.usage?.tokens || 0;
+      }
+      const outputTokens = 0;
+      const cost = calculateCostWithDiscount(
+        modelKey,
+        totalInputTokens,
+        outputTokens
+      );
+      const durationMs = Date.now() - startTime;
+      this.aiCallLogger.logCall({
+        topic: this.topic,
+        callType: "embed",
+        modelKey,
+        modelId: modelConfig.id,
+        prompt: texts.length === 1 ? texts[0] : `[${texts.length} texts]`,
+        response: `[${embeddings.length} embeddings, ${dimensions} dims]`,
+        inputTokens: totalInputTokens,
+        outputTokens,
+        cost,
+        metadata: {
+          taskType: options.taskType,
+          textCount: texts.length,
+          dimensions,
+          durationMs
+        }
+      });
+      logger.debug(`embed response`, {
+        model: modelKey,
+        embeddingsCount: embeddings.length,
+        dimensions,
+        inputTokens: totalInputTokens,
+        cost: cost.toFixed(6),
+        durationMs
+      });
+      return {
+        embedding: embeddings[0],
+        // Convenience: first embedding
+        embeddings,
+        // All embeddings
+        dimensions,
+        // Dimensionality used
+        inputTokens: totalInputTokens,
+        cost
+      };
+    } catch (error) {
+      const durationMs = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error(`embed error`, {
+        model: modelKey,
+        error: errorMessage,
+        durationMs
+      });
+      this.aiCallLogger.logCall({
+        topic: this.topic,
+        callType: "embed",
+        modelKey,
+        modelId: modelConfig.id,
+        prompt: texts.length === 1 ? texts[0] : `[${texts.length} texts]`,
+        response: "",
+        inputTokens: 0,
+        outputTokens: 0,
+        cost: 0,
+        metadata: {
+          taskType: options.taskType,
+          textCount: texts.length,
+          dimensions,
+          durationMs,
+          status: "error",
+          error: errorMessage
+        }
+      });
+      throw error;
+    }
+  }
+  streamText(modelKey, input, options = {}) {
+    const modelConfig = getModel(modelKey);
+    const model = getModelProvider(modelConfig);
+    const startTime = Date.now();
+    const hasTools = options.tools !== void 0;
+    const promptForLog = "prompt" in input && input.prompt ? input.prompt : JSON.stringify(input.messages);
+    let errorLogged = false;
+    const logError = (error) => {
+      if (errorLogged) return;
+      errorLogged = true;
+      const durationMs = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.aiCallLogger.logCall({
+        topic: this.topic,
+        callType: "stream",
+        modelKey,
+        modelId: modelConfig.id,
+        prompt: promptForLog,
+        response: "",
+        inputTokens: 0,
+        outputTokens: 0,
+        cost: 0,
+        metadata: {
+          temperature: options.temperature,
+          maxTokens: options.maxTokens,
+          durationMs,
+          status: "error",
+          error: errorMessage,
+          ...input.system ? { system: input.system } : {}
+        }
+      });
+    };
+    logger.debug(`streamText request`, {
+      model: modelKey,
+      modelId: modelConfig.id,
+      prompt: promptForLog.substring(0, 500) + (promptForLog.length > 500 ? "..." : ""),
+      temperature: options.temperature ?? 0.7,
+      maxTokens: options.maxTokens,
+      hasTools,
+      hasSystem: !!input.system
+    });
+    const baseParams = {
+      model,
+      temperature: options.temperature ?? 0.7,
+      maxOutputTokens: options.maxTokens,
+      ...input.system ? { system: input.system } : {},
+      // Tool-related options (only included if tools are provided)
+      ...hasTools && {
+        tools: options.tools,
+        stopWhen: options.stopWhen,
+        onStepFinish: options.onStepFinish
+      },
+      // Error callback to log streaming errors
+      onError: ({ error }) => {
+        logError(error);
+      }
+    };
+    const result = "messages" in input && input.messages ? streamText({ ...baseParams, messages: input.messages }) : streamText({
+      ...baseParams,
+      prompt: input.prompt
+    });
+    let fullText = "";
+    let chunkCount = 0;
+    let streamConsumed = false;
+    let usageResolved = false;
+    let cachedUsage = null;
+    const streamIterable = {
+      [Symbol.asyncIterator]: () => {
+        const reader = result.textStream[Symbol.asyncIterator]();
+        return {
+          async next() {
+            try {
+              const { done, value } = await reader.next();
+              if (done) {
+                streamConsumed = true;
+                return { done: true, value: void 0 };
+              }
+              fullText += value;
+              chunkCount++;
+              options.onChunk?.(value);
+              return { done: false, value };
+            } catch (error) {
+              logError(error);
+              throw error;
+            }
+          }
+        };
+      }
+    };
+    const getUsage = async () => {
+      if (usageResolved && cachedUsage) {
+        return cachedUsage;
+      }
+      if (!streamConsumed) {
+        for await (const _ of streamIterable) {
+        }
+      }
+      const usage = await result.usage;
+      const inputTokens = usage?.inputTokens ?? 0;
+      const outputTokens = usage?.outputTokens ?? 0;
+      const cost = calculateCostWithDiscount(
+        modelKey,
+        inputTokens,
+        outputTokens
+      );
+      const durationMs = Date.now() - startTime;
+      if (!usageResolved) {
+        usageResolved = true;
+        cachedUsage = { inputTokens, outputTokens, cost };
+        logger.debug(`streamText response`, {
+          model: modelKey,
+          response: fullText.substring(0, 500) + (fullText.length > 500 ? "..." : ""),
+          inputTokens,
+          outputTokens,
+          cost: cost.toFixed(6),
+          durationMs,
+          chunkCount
+        });
+        this.aiCallLogger.logCall({
+          topic: this.topic,
+          callType: "stream",
+          modelKey,
+          modelId: modelConfig.id,
+          prompt: promptForLog,
+          response: fullText,
+          inputTokens,
+          outputTokens,
+          cost,
+          metadata: {
+            temperature: options.temperature,
+            maxTokens: options.maxTokens,
+            streamChunks: chunkCount,
+            durationMs,
+            ...input.system ? { system: input.system } : {}
+          }
+        });
+      }
+      return cachedUsage ?? { inputTokens, outputTokens, cost };
+    };
+    return {
+      stream: streamIterable,
+      getUsage,
+      rawResult: result
+    };
+  }
+  batch(modelKey, provider) {
+    const resolvedProvider = provider ?? getBestProviderForModel(modelKey) ?? "google";
+    return new AIBatchImpl(
+      this,
+      modelKey,
+      resolvedProvider,
+      this.batchLogFn
+    );
+  }
+  createChild(segment, id) {
+    const newTopic = id ? `${this.topic}.${segment}.${id}` : `${this.topic}.${segment}`;
+    return new _AIHelperImpl(newTopic, this.aiCallLogger, this.logContext);
+  }
+  /** @internal Get the logger for batch operations */
+  getLogger() {
+    return this.aiCallLogger;
+  }
+  // Overloaded recordCall to support both new object-based API and legacy positional API
+  recordCall(paramsOrModelKey, prompt, response, tokens, options) {
+    let modelKey;
+    let actualPrompt;
+    let actualResponse;
+    let inputTokens;
+    let outputTokens;
+    let callType;
+    let isBatch;
+    let metadata;
+    if (typeof paramsOrModelKey === "object" && "modelKey" in paramsOrModelKey) {
+      const params = paramsOrModelKey;
+      modelKey = params.modelKey;
+      actualPrompt = params.prompt;
+      actualResponse = params.response;
+      inputTokens = params.inputTokens;
+      outputTokens = params.outputTokens;
+      callType = params.callType;
+      isBatch = callType === "batch";
+      metadata = params.metadata;
+    } else {
+      if (!prompt || !response || !tokens) {
+        throw new Error(
+          "recordCall: legacy API requires prompt, response, and tokens"
+        );
+      }
+      modelKey = paramsOrModelKey;
+      actualPrompt = prompt;
+      actualResponse = response;
+      inputTokens = tokens.input;
+      outputTokens = tokens.output;
+      callType = options?.callType ?? "text";
+      isBatch = options?.isBatch ?? false;
+      metadata = options?.metadata;
+    }
+    const modelConfig = getModel(modelKey);
+    const cost = calculateCostWithDiscount(
+      modelKey,
+      inputTokens,
+      outputTokens,
+      isBatch
+    );
+    this.aiCallLogger.logCall({
+      topic: this.topic,
+      callType,
+      modelKey,
+      modelId: modelConfig.id,
+      prompt: actualPrompt,
+      response: actualResponse,
+      inputTokens,
+      outputTokens,
+      cost,
+      metadata: isBatch ? { ...metadata, isBatch: true } : metadata
+    });
+  }
+  async getStats() {
+    return this.aiCallLogger.getStats(this.topic);
+  }
+};
+var AIBatchImpl = class {
+  constructor(helper, modelKey, provider, batchLogFn) {
+    this.helper = helper;
+    this.modelKey = modelKey;
+    this.provider = provider;
+    this.batchLogFn = batchLogFn;
+    const batchLogger = {
+      log: (level, message, meta) => {
+        if (this.batchLogFn) {
+          this.batchLogFn(level, `[Batch:${provider}] ${message}`, meta);
+        } else {
+          logger.debug(
+            `[Batch:${provider}] [${level}] ${message}`,
+            meta ? JSON.stringify(meta) : ""
+          );
+        }
+      }
+    };
+    if (provider === "google") {
+      this.googleProvider = new GoogleBatchProvider({}, batchLogger);
+    } else if (provider === "anthropic") {
+      this.anthropicProvider = new AnthropicBatchProvider({}, batchLogger);
+    } else if (provider === "openai") {
+      this.openaiProvider = new OpenAIBatchProvider({}, batchLogger);
+    }
+  }
+  googleProvider = null;
+  anthropicProvider = null;
+  openaiProvider = null;
+  async submit(requests) {
+    logger.debug(`batch submit request`, {
+      provider: this.provider,
+      model: this.modelKey,
+      requestCount: requests.length,
+      requestIds: requests.slice(0, 10).map((r) => r.id),
+      hasMoreRequests: requests.length > 10
+    });
+    const jsonSystemPrompt = "You must respond with valid JSON only. No markdown, no explanation, just the JSON object.";
+    if (this.provider === "google" && this.googleProvider) {
+      const googleRequests = requests.map((req) => ({
+        id: req.id,
+        prompt: req.prompt,
+        model: this.modelKey,
+        ...req.schema && { system: jsonSystemPrompt, schema: req.schema }
+      }));
+      const handle = await this.googleProvider.submit(googleRequests);
+      logger.debug(`batch submitted`, {
+        provider: "google",
+        batchId: handle.id,
+        requestCount: requests.length
+      });
+      return { id: handle.id, status: "pending", provider: this.provider };
+    }
+    if (this.provider === "anthropic" && this.anthropicProvider) {
+      const anthropicRequests = requests.map((req) => ({
+        customId: req.id,
+        prompt: req.prompt,
+        model: this.modelKey,
+        ...req.schema && { system: jsonSystemPrompt }
+      }));
+      const handle = await this.anthropicProvider.submit(anthropicRequests);
+      logger.debug(`batch submitted`, {
+        provider: "anthropic",
+        batchId: handle.id,
+        requestCount: requests.length
+      });
+      return { id: handle.id, status: "pending", provider: this.provider };
+    }
+    if (this.provider === "openai" && this.openaiProvider) {
+      const openaiRequests = requests.map((req) => ({
+        customId: req.id,
+        prompt: req.prompt,
+        model: this.modelKey,
+        ...req.schema && { system: jsonSystemPrompt }
+      }));
+      const handle = await this.openaiProvider.submit(openaiRequests);
+      logger.debug(`batch submitted`, {
+        provider: "openai",
+        batchId: handle.id,
+        requestCount: requests.length
+      });
+      return { id: handle.id, status: "pending", provider: this.provider };
+    }
+    throw new Error(
+      `Batch submission for provider "${this.provider}" not yet implemented. Use recordCall() to manually record batch results.`
+    );
+  }
+  async getStatus(batchId) {
+    const handle = {
+      id: batchId,
+      provider: this.provider,
+      requestCount: 0,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    let status;
+    if (this.provider === "google" && this.googleProvider) {
+      status = await this.googleProvider.checkStatus(handle);
+    } else if (this.provider === "anthropic" && this.anthropicProvider) {
+      status = await this.anthropicProvider.checkStatus(handle);
+    } else if (this.provider === "openai" && this.openaiProvider) {
+      status = await this.openaiProvider.checkStatus(handle);
+    } else {
+      throw new Error(
+        `Batch status check for provider "${this.provider}" not yet implemented.`
+      );
+    }
+    let batchStatus;
+    switch (status.state) {
+      case "completed":
+        batchStatus = "completed";
+        break;
+      case "failed":
+        batchStatus = "failed";
+        break;
+      case "processing":
+        batchStatus = "processing";
+        break;
+      default:
+        batchStatus = "pending";
+    }
+    return { id: batchId, status: batchStatus, provider: this.provider };
+  }
+  async getResults(batchId, metadata) {
+    if (this.batchLogFn) {
+      this.batchLogFn("DEBUG", `[AIBatch:getResults] Received metadata`, {
+        hasMetadata: !!metadata,
+        metadataKeys: metadata ? Object.keys(metadata) : [],
+        hasCustomIds: !!metadata?.customIds,
+        customIdsCount: Array.isArray(metadata?.customIds) ? metadata.customIds.length : 0
+      });
+    }
+    const handle = {
+      id: batchId,
+      provider: this.provider,
+      requestCount: 0,
+      createdAt: /* @__PURE__ */ new Date(),
+      metadata
+    };
+    let rawResults;
+    if (this.provider === "google" && this.googleProvider) {
+      rawResults = await this.googleProvider.getResults(handle);
+    } else if (this.provider === "anthropic" && this.anthropicProvider) {
+      rawResults = await this.anthropicProvider.getResults(handle);
+    } else if (this.provider === "openai" && this.openaiProvider) {
+      rawResults = await this.openaiProvider.getResults(handle);
+    } else {
+      throw new Error(
+        `Batch results for provider "${this.provider}" not yet implemented. Use recordCall() to manually record batch results.`
+      );
+    }
+    const totalInputTokens = rawResults.reduce(
+      (sum, r) => sum + (r.inputTokens || 0),
+      0
+    );
+    const totalOutputTokens = rawResults.reduce(
+      (sum, r) => sum + (r.outputTokens || 0),
+      0
+    );
+    const failedCount = rawResults.filter((r) => r.error).length;
+    logger.debug(`batch getResults response`, {
+      batchId,
+      provider: this.provider,
+      resultCount: rawResults.length,
+      failedCount,
+      totalInputTokens,
+      totalOutputTokens
+    });
+    const results = rawResults.map((raw, index) => {
+      if (raw.error) {
+        return {
+          id: raw.customId || `result-${index}`,
+          prompt: "",
+          // Not available from raw results
+          result: {},
+          // Empty result for failed requests
+          inputTokens: raw.inputTokens || 0,
+          outputTokens: raw.outputTokens || 0,
+          status: "failed",
+          error: raw.error
+        };
+      }
+      let parsedResult;
+      try {
+        let cleaned = raw.text.trim();
+        if (cleaned.startsWith("```json")) {
+          cleaned = cleaned.slice(7);
+        } else if (cleaned.startsWith("```")) {
+          cleaned = cleaned.slice(3);
+        }
+        if (cleaned.endsWith("```")) {
+          cleaned = cleaned.slice(0, -3);
+        }
+        cleaned = cleaned.trim();
+        parsedResult = JSON.parse(cleaned);
+      } catch {
+        parsedResult = raw.text;
+      }
+      return {
+        id: raw.customId || `result-${index}`,
+        prompt: "",
+        // Not available from raw results
+        result: parsedResult,
+        inputTokens: raw.inputTokens || 0,
+        outputTokens: raw.outputTokens || 0,
+        status: "succeeded"
+      };
+    });
+    await this.recordResults(batchId, results);
+    return results;
+  }
+  async isRecorded(batchId) {
+    return this.helper.getLogger().isRecorded(batchId);
+  }
+  /**
+   * Record batch results manually.
+   * Use this when batch provider integration is not yet implemented.
+   */
+  async recordResults(batchId, results) {
+    if (await this.isRecorded(batchId)) {
+      logger.debug(`Batch ${batchId} already recorded, skipping.`);
+      return;
+    }
+    const modelConfig = getModel(this.modelKey);
+    const discountPercent = modelConfig.batchDiscountPercent ?? 0;
+    await this.helper.getLogger().logBatchResults(
+      batchId,
+      results.map((r) => {
+        const baseCost = calculateCost(
+          this.modelKey,
+          r.inputTokens,
+          r.outputTokens
+        );
+        const cost = baseCost.totalCost * (1 - discountPercent / 100);
+        return {
+          topic: this.helper.topic,
+          callType: "batch",
+          modelKey: this.modelKey,
+          modelId: modelConfig.id,
+          prompt: r.prompt,
+          response: typeof r.result === "string" ? r.result : JSON.stringify(r.result),
+          inputTokens: r.inputTokens,
+          outputTokens: r.outputTokens,
+          cost,
+          metadata: { batchId, requestId: r.id }
+        };
+      })
+    );
+  }
+};
+function createAIHelper(topic, logger2, logContext) {
+  return new AIHelperImpl(topic, logger2, logContext);
+}
+
+export { AVAILABLE_MODELS, AnthropicBatchProvider, DEFAULT_MODEL_KEY, GoogleBatchProvider, ModelKey, ModelStatsTracker, NoInputSchema, OpenAIBatchProvider, calculateCost, createAIHelper, defineAsyncBatchStage, defineStage, getBestProviderForModel, getDefaultModel, getModel, getModelById, getRegisteredModel, listModels, listRegisteredModels, modelSupportsBatch, printAvailableModels, registerModels, requireStageOutput, resolveModelForProvider };
+//# sourceMappingURL=chunk-P4KMGCT3.js.map
+//# sourceMappingURL=chunk-P4KMGCT3.js.map