ai-sdk-cost-calculator 0.1.2 → 0.1.3

package/README.md

@@ -9,6 +9,8 @@ Cost calculator for [Vercel AI SDK](https://sdk.vercel.ai/) token usage. Calcula
 - **Session tracking**: Track costs across multiple calls with `createCostAwareAI()`
 - **Multi-model tracking**: Track costs across different models in a single tracker
 - **Web search pricing**: Calculate costs for grounding/search features
+- **Google Maps pricing**: Calculate costs for Google Maps API requests
+- **Auto-detection**: Automatically detect web search/maps tool calls from results
 - **Long context pricing**: Automatic tier-based pricing (e.g., Claude Sonnet 4.5 >200K tokens)
 - **Prompt caching**: Separate pricing for cache reads and writes
 - **Reasoning tokens**: Support for o1/o3/R1 reasoning model costs
@@ -187,31 +189,94 @@ console.log(`Models: ${tracker.getModels().join(", ")}`);
 tracker.reset();
 ```
 
-## Web Search Costs
+## Web Search & Google Maps Costs
 
-Calculate costs including web search/grounding features.
+Calculate costs including web search/grounding and Google Maps features.
 
 ```typescript
 const cost = calculateCost({
-  model: "gpt-4o",
+  model: "gemini-2.0-flash",
   usage: result.usage,
-  webSearchRequests: 10, // Number of web searches
+  webSearchRequests: 10,   // Number of web searches
+  googleMapsRequests: 5,   // Number of Google Maps API calls
+});
+
+console.log(cost.webSearchCost);   // $0.14 for 10 searches
+console.log(cost.googleMapsCost);  // $0.035 for 5 maps requests
+```
+
+### Auto-Detection from Tool Calls
+
+Automatically detect web search and Google Maps usage from AI SDK results:
+
+```typescript
+import { createTracker } from "ai-sdk-cost-calculator";
+
+const tracker = createTracker();
+
+await generateText({
+  model: google("gemini-2.0-flash"),
+  prompt: "Find coffee shops near Tokyo Station",
+  tools: { web_search: mySearchTool, places: myPlacesTool },
+  onFinish: tracker.onFinish("gemini-2.0-flash", undefined, {
+    webSearchTools: [],  // Use default tool names for detection
+  }),
+});
+
+// Or add custom tool names
+await generateText({
+  model: openai("gpt-4o"),
+  prompt: "Search the web",
+  tools: { my_custom_search: customSearchTool },
+  onFinish: tracker.onFinish("gpt-4o", undefined, {
+    webSearchTools: ["my_custom_search"],  // Add to defaults
+  }),
 });
+```
 
-console.log(cost.webSearchCost); // $0.10 for 10 searches
+#### Using `detectRequestsFromResult` Directly
+
+```typescript
+import { detectRequestsFromResult, calculateCost } from "ai-sdk-cost-calculator";
+
+const result = await generateText({
+  model: google("gemini-2.0-flash"),
+  prompt: "What's the weather?",
+  tools: { web_search: searchTool },
+});
+
+// Detect tool usage
+const { webSearchRequests, googleMapsRequests } = detectRequestsFromResult(result, {
+  webSearchTools: ["my_search"],  // Optional: add custom tool names
+});
+
+const cost = calculateCost({
+  model: "gemini-2.0-flash",
+  usage: result.usage,
+  webSearchRequests,
+  googleMapsRequests,
+});
 ```
 
-### Web Search Pricing by Provider
+#### Default Tool Names
 
-| Provider      | Model            | Cost per 1k searches | Notes                      |
-| ------------- | ---------------- | -------------------- | -------------------------- |
-| **OpenAI**    | GPT-4o, GPT-4.1  | $10                  | + tokens at model rate     |
-| **OpenAI**    | GPT-4o-mini      | $10                  | + 8k tokens per search     |
-| **Google**    | Gemini Flash     | $14                  | Grounding with Google      |
-| **Google**    | Gemini Pro       | $35                  | Grounding with Google      |
-| **xAI**       | Grok models      | $5                   | Web Search / X Search      |
-| **Perplexity** | Sonar           | $5                   | Search-native              |
-| **Perplexity** | Sonar Pro       | $6                   | Search-native              |
+The following tool names are detected by default:
+
+**Web Search**: `web_search`, `webSearch`, `google_search`, `googleSearch`, `grounding`, `web_search_preview`, `tavily_search`, `brave_search`, `bing_search`, `duckduckgo_search`
+
+**Google Maps**: `google_maps`, `googleMaps`, `place_search`, `placeSearch`, `geocode`, `places`
+
+### Pricing by Provider
+
+| Provider       | Model            | Web Search (/1k) | Google Maps (/1k) | Notes                  |
+| -------------- | ---------------- | ---------------- | ----------------- | ---------------------- |
+| **OpenAI**     | GPT-4o, GPT-4.1  | $10              | -                 | + tokens at model rate |
+| **OpenAI**     | GPT-4o-mini      | $10              | -                 | + 8k tokens per search |
+| **Google**     | Gemini Flash     | $14              | $7                | Grounding with Google  |
+| **Google**     | Gemini Pro       | $35              | $7                | Grounding with Google  |
+| **xAI**        | Grok models      | $5               | -                 | Web Search / X Search  |
+| **Perplexity** | Sonar            | $5               | -                 | Search-native          |
+| **Perplexity** | Sonar Pro        | $6               | -                 | Search-native          |
 
 ## API Reference
 
@@ -243,26 +308,28 @@ const cost = calculateCost({
 
 #### Options
 
-| Property            | Type                 | Required | Description                                                |
-| ------------------- | -------------------- | -------- | ---------------------------------------------------------- |
-| `model`             | `string`             | Yes      | Model identifier (e.g., `"gpt-4o"`, `"claude-sonnet-4-5"`) |
-| `usage`             | `LanguageModelUsage` | Yes      | Token usage from AI SDK                                    |
-| `customPricing`     | `ModelPricing`       | No       | Override default pricing                                   |
-| `webSearchRequests` | `number`             | No       | Number of web search requests                              |
+| Property             | Type                 | Required | Description                                                |
+| -------------------- | -------------------- | -------- | ---------------------------------------------------------- |
+| `model`              | `string`             | Yes      | Model identifier (e.g., `"gpt-4o"`, `"claude-sonnet-4-5"`) |
+| `usage`              | `LanguageModelUsage` | Yes      | Token usage from AI SDK                                    |
+| `customPricing`      | `ModelPricing`       | No       | Override default pricing                                   |
+| `webSearchRequests`  | `number`             | No       | Number of web search requests                              |
+| `googleMapsRequests` | `number`             | No       | Number of Google Maps API requests                         |
 
 #### Return Value: `CostBreakdown`
 
-| Property        | Type      | Description                                  |
-| --------------- | --------- | -------------------------------------------- |
-| `inputCost`     | `number`  | Cost for input tokens (excluding cache)      |
-| `outputCost`    | `number`  | Cost for output tokens (excluding reasoning) |
-| `cacheReadCost` | `number`  | Cost for cached input tokens                 |
-| `cacheWriteCost`| `number`  | Cost for writing to cache                    |
-| `reasoningCost` | `number`  | Cost for reasoning tokens                    |
-| `webSearchCost` | `number`  | Cost for web search requests                 |
-| `totalCost`     | `number`  | Sum of all costs                             |
-| `currency`      | `"USD"`   | Always USD                                   |
-| `isLongContext` | `boolean` | Whether long context pricing was applied     |
+| Property         | Type      | Description                                  |
+| ---------------- | --------- | -------------------------------------------- |
+| `inputCost`      | `number`  | Cost for input tokens (excluding cache)      |
+| `outputCost`     | `number`  | Cost for output tokens (excluding reasoning) |
+| `cacheReadCost`  | `number`  | Cost for cached input tokens                 |
+| `cacheWriteCost` | `number`  | Cost for writing to cache                    |
+| `reasoningCost`  | `number`  | Cost for reasoning tokens                    |
+| `webSearchCost`  | `number`  | Cost for web search requests                 |
+| `googleMapsCost` | `number`  | Cost for Google Maps API requests            |
+| `totalCost`      | `number`  | Sum of all costs                             |
+| `currency`       | `"USD"`   | Always USD                                   |
+| `isLongContext`  | `boolean` | Whether long context pricing was applied     |
 
 ### `createTracker(options?)`
 
@@ -408,7 +475,8 @@ const output = formatCostBreakdown(cost);
 // Cache Read:   $0.000060
 // Output:       $0.007500
 // Web Search:   $0.050000
-// Total:        $0.059960
+// Google Maps:  $0.007000
+// Total:        $0.066960
 ```
 
 ### `calculateStreamCost(streamResult, options)`
@@ -432,6 +500,57 @@ const cost = await calculateStreamCost(stream, {
 });
 ```
 
+### `detectRequestsFromResult(result, options?)`
+
+Detect web search and Google Maps tool calls from an AI SDK result.
+
+```typescript
+import { detectRequestsFromResult } from "ai-sdk-cost-calculator";
+
+const result = await generateText({
+  model: google("gemini-2.0-flash"),
+  prompt: "Find restaurants",
+  tools: { web_search: searchTool, places: placesTool },
+});
+
+const { webSearchRequests, googleMapsRequests } = detectRequestsFromResult(result);
+
+// With custom tool names (added to defaults)
+const detected = detectRequestsFromResult(result, {
+  webSearchTools: ["my_search", "custom_tavily"],
+  googleMapsTools: ["location_finder"],
+});
+```
+
+| Parameter              | Type                  | Required | Description                                |
+| ---------------------- | --------------------- | -------- | ------------------------------------------ |
+| `result`               | `ResultWithToolCalls` | Yes      | AI SDK result with toolCalls/steps         |
+| `options.webSearchTools`   | `string[]`        | No       | Additional tool names to count as search   |
+| `options.googleMapsTools`  | `string[]`        | No       | Additional tool names to count as maps     |
+
+### `withDetectedRequests(result, options?)`
+
+Convenience wrapper that returns detected requests for spreading into `calculateCost`.
+
+```typescript
+import { withDetectedRequests, calculateCost } from "ai-sdk-cost-calculator";
+
+const cost = calculateCost({
+  model: "gemini-2.0-flash",
+  usage: result.usage,
+  ...withDetectedRequests(result),
+});
+
+// With custom tool names
+const cost2 = calculateCost({
+  model: "gemini-2.0-flash",
+  usage: result.usage,
+  ...withDetectedRequests(result, {
+    webSearchTools: ["my_search"],
+  }),
+});
+```
+
 ## Supported Models
 
 ### OpenAI (23 models)
@@ -508,6 +627,7 @@ const cost = calculateCost({
     outputPer1MTokens: 8.0,
     cacheReadPer1MTokens: 1.0,
     webSearchPer1kRequests: 15,
+    googleMapsPer1kRequests: 10,
   },
 });
 ```
@@ -537,6 +657,10 @@ import type {
   CostAwareOptions,
   ResultWithCost,
   FinishResultWithCost,
+  // Auto-detection
+  DetectOptions,
+  DetectedRequests,
+  ResultWithToolCalls,
 } from "ai-sdk-cost-calculator";
 ```
 

package/dist/index.d.mts

@@ -13,6 +13,7 @@ interface ModelPricing {
     longContextCacheWritePer1MTokens?: number;
     webSearchPer1kRequests?: number;
     webSearchTokensPerRequest?: number;
+    googleMapsPer1kRequests?: number;
 }
 interface ProviderPricing {
     [modelId: string]: ModelPricing;
@@ -47,6 +48,7 @@ interface CostBreakdown {
     cacheWriteCost: number;
     reasoningCost: number;
     webSearchCost: number;
+    googleMapsCost: number;
     totalCost: number;
     currency: "USD";
     isLongContext: boolean;
@@ -58,6 +60,8 @@ interface CalculateCostOptions {
     customPricing?: ModelPricing;
     /** Number of web search requests made (for grounding/live search) */
     webSearchRequests?: number;
+    /** Number of Google Maps API requests made */
+    googleMapsRequests?: number;
 }
 declare function calculateCost(options: CalculateCostOptions): CostBreakdown;
 declare function formatCost(cost: number, decimals?: number): string;
@@ -86,12 +90,116 @@ declare function calculateStreamCost<T extends {
     usage: LanguageModelUsage;
 }>;
 
+/**
+ * Utility for auto-detecting web search and Google Maps requests from AI SDK results
+ */
+/** Default web search tool names across providers */
+declare const DEFAULT_WEB_SEARCH_TOOLS: string[];
+/** Default Google Maps tool names */
+declare const DEFAULT_GOOGLE_MAPS_TOOLS: string[];
+interface DetectedRequests {
+    webSearchRequests: number;
+    googleMapsRequests: number;
+}
+interface DetectOptions {
+    /** Additional tool names to count as web search (added to defaults) */
+    webSearchTools?: string[];
+    /** Additional tool names to count as Google Maps (added to defaults) */
+    googleMapsTools?: string[];
+}
+interface ToolCall {
+    toolName?: string;
+    type?: string;
+    name?: string;
+}
+interface Step {
+    toolCalls?: ToolCall[];
+    toolResults?: unknown[];
+}
+interface ProviderMetadata {
+    google?: {
+        groundingMetadata?: {
+            webSearchQueries?: unknown[];
+            searchEntryPoint?: unknown;
+            groundingChunks?: unknown[];
+            groundingSupports?: unknown[];
+        };
+    };
+    [key: string]: unknown;
+}
+interface ResultWithToolCalls {
+    toolCalls?: ToolCall[];
+    steps?: Step[];
+    experimental_providerMetadata?: ProviderMetadata;
+    providerMetadata?: ProviderMetadata;
+}
+/**
+ * Detects web search and Google Maps requests from an AI SDK result object.
+ *
+ * Supports:
+ * - Tool calls (toolCalls array)
+ * - Multi-step generations (steps array)
+ * - Google Gemini grounding metadata (experimental_providerMetadata.google.groundingMetadata)
+ *
+ * @example
+ * ```typescript
+ * const result = await generateText({
+ *   model: google("gemini-2.0-flash"),
+ *   prompt: "What's the weather today?",
+ *   tools: { web_search: webSearchTool },
+ * });
+ *
+ * // Use defaults
+ * const { webSearchRequests, googleMapsRequests } = detectRequestsFromResult(result);
+ *
+ * // Or add custom tool names
+ * const detected = detectRequestsFromResult(result, {
+ *   webSearchTools: ["my_search_tool", "custom_search"],
+ *   googleMapsTools: ["location_finder"],
+ * });
+ * ```
+ */
+declare function detectRequestsFromResult(result: ResultWithToolCalls, options?: DetectOptions): DetectedRequests;
+/**
+ * Creates options with auto-detected web search and Google Maps requests.
+ * Merges detected counts with any manually specified counts.
+ *
+ * @example
+ * ```typescript
+ * const result = await generateText({
+ *   model: google("gemini-2.0-flash"),
+ *   prompt: "Find coffee shops near Tokyo Station",
+ * });
+ *
+ * const cost = calculateCost({
+ *   model: "gemini-2.0-flash",
+ *   usage: result.usage,
+ *   ...withDetectedRequests(result),
+ * });
+ *
+ * // With custom tool names
+ * const cost2 = calculateCost({
+ *   model: "gemini-2.0-flash",
+ *   usage: result.usage,
+ *   ...withDetectedRequests(result, {
+ *     webSearchTools: ["my_search"],
+ *   }),
+ * });
+ * ```
+ */
+declare function withDetectedRequests(result: ResultWithToolCalls, options?: DetectOptions & {
+    webSearchRequests?: number;
+    googleMapsRequests?: number;
+}): DetectedRequests;
+
 /**
  * Options for adding usage to the tracker
  */
-interface AddUsageOptions {
+interface AddUsageOptions extends DetectOptions {
     /** Number of web search requests made */
     webSearchRequests?: number;
+    /** Number of Google Maps API requests made */
+    googleMapsRequests?: number;
 }
 /**
  * Per-model cost summary
@@ -202,11 +310,13 @@ interface FinishResultWithCost {
 /**
  * Options for cost-aware wrappers
  */
-interface CostAwareOptions {
+interface CostAwareOptions extends DetectOptions {
     /** Custom pricing override */
     customPricing?: ModelPricing;
     /** Number of web search requests */
     webSearchRequests?: number;
+    /** Number of Google Maps API requests */
+    googleMapsRequests?: number;
     /** Callback when cost is calculated */
     onCost?: (cost: CostBreakdown, usage: LanguageModelUsage) => void;
 }
@@ -325,4 +435,4 @@ declare function createCostAwareAI(options?: CreateCostAwareAIOptions): CostAwar
  */
 declare function getCost(model: LanguageModel | string, usage: LanguageModelUsage, options?: CostAwareOptions): CostBreakdown;
 
-export { type AddUsageOptions, type CalculateCostOptions, type CostAwareAI, type CostAwareOptions, type CostBreakdown, type CostTracker, type CreateCostAwareAIOptions, type CreateCostTrackerOptions, type CreateMultiModelTrackerOptions, type FinishResultWithCost, type ModelCostSummary, type ModelPricing, type MultiModelCostTracker, type Provider, type ProviderPricing, type ResultWithCost, type StreamCostOptions, allPricing, anthropicPricing, calculateCost, calculateStreamCost, createCostAwareAI, createCostTracker, createTracker, deepseekPricing, flatPricing, formatCost, formatCostBreakdown, getAllSupportedModels, getCost, getModelId, getModelPricing, getModelPricingByModelId, googlePricing, onFinishWithCost, openaiPricing, perplexityPricing, withCost, xaiPricing };
+export { type AddUsageOptions, type CalculateCostOptions, type CostAwareAI, type CostAwareOptions, type CostBreakdown, type CostTracker, type CreateCostAwareAIOptions, type CreateCostTrackerOptions, type CreateMultiModelTrackerOptions, DEFAULT_GOOGLE_MAPS_TOOLS, DEFAULT_WEB_SEARCH_TOOLS, type DetectOptions, type DetectedRequests, type FinishResultWithCost, type ModelCostSummary, type ModelPricing, type MultiModelCostTracker, type Provider, type ProviderPricing, type ResultWithCost, type ResultWithToolCalls, type StreamCostOptions, allPricing, anthropicPricing, calculateCost, calculateStreamCost, createCostAwareAI, createCostTracker, createTracker, deepseekPricing, detectRequestsFromResult, flatPricing, formatCost, formatCostBreakdown, getAllSupportedModels, getCost, getModelId, getModelPricing, getModelPricingByModelId, googlePricing, onFinishWithCost, openaiPricing, perplexityPricing, withCost, withDetectedRequests, xaiPricing };

package/dist/index.d.ts

@@ -13,6 +13,7 @@ interface ModelPricing {
     longContextCacheWritePer1MTokens?: number;
     webSearchPer1kRequests?: number;
     webSearchTokensPerRequest?: number;
+    googleMapsPer1kRequests?: number;
 }
 interface ProviderPricing {
     [modelId: string]: ModelPricing;
@@ -47,6 +48,7 @@ interface CostBreakdown {
     cacheWriteCost: number;
     reasoningCost: number;
     webSearchCost: number;
+    googleMapsCost: number;
     totalCost: number;
     currency: "USD";
     isLongContext: boolean;
@@ -58,6 +60,8 @@ interface CalculateCostOptions {
     customPricing?: ModelPricing;
     /** Number of web search requests made (for grounding/live search) */
     webSearchRequests?: number;
+    /** Number of Google Maps API requests made */
+    googleMapsRequests?: number;
 }
 declare function calculateCost(options: CalculateCostOptions): CostBreakdown;
 declare function formatCost(cost: number, decimals?: number): string;
@@ -86,12 +90,116 @@ declare function calculateStreamCost<T extends {
     usage: LanguageModelUsage;
 }>;
 
+/**
+ * Utility for auto-detecting web search and Google Maps requests from AI SDK results
+ */
+/** Default web search tool names across providers */
+declare const DEFAULT_WEB_SEARCH_TOOLS: string[];
+/** Default Google Maps tool names */
+declare const DEFAULT_GOOGLE_MAPS_TOOLS: string[];
+interface DetectedRequests {
+    webSearchRequests: number;
+    googleMapsRequests: number;
+}
+interface DetectOptions {
+    /** Additional tool names to count as web search (added to defaults) */
+    webSearchTools?: string[];
+    /** Additional tool names to count as Google Maps (added to defaults) */
+    googleMapsTools?: string[];
+}
+interface ToolCall {
+    toolName?: string;
+    type?: string;
+    name?: string;
+}
+interface Step {
+    toolCalls?: ToolCall[];
+    toolResults?: unknown[];
+}
+interface ProviderMetadata {
+    google?: {
+        groundingMetadata?: {
+            webSearchQueries?: unknown[];
+            searchEntryPoint?: unknown;
+            groundingChunks?: unknown[];
+            groundingSupports?: unknown[];
+        };
+    };
+    [key: string]: unknown;
+}
+interface ResultWithToolCalls {
+    toolCalls?: ToolCall[];
+    steps?: Step[];
+    experimental_providerMetadata?: ProviderMetadata;
+    providerMetadata?: ProviderMetadata;
+}
+/**
+ * Detects web search and Google Maps requests from an AI SDK result object.
+ *
+ * Supports:
+ * - Tool calls (toolCalls array)
+ * - Multi-step generations (steps array)
+ * - Google Gemini grounding metadata (experimental_providerMetadata.google.groundingMetadata)
+ *
+ * @example
+ * ```typescript
+ * const result = await generateText({
+ *   model: google("gemini-2.0-flash"),
+ *   prompt: "What's the weather today?",
+ *   tools: { web_search: webSearchTool },
+ * });
+ *
+ * // Use defaults
+ * const { webSearchRequests, googleMapsRequests } = detectRequestsFromResult(result);
+ *
+ * // Or add custom tool names
+ * const detected = detectRequestsFromResult(result, {
+ *   webSearchTools: ["my_search_tool", "custom_search"],
+ *   googleMapsTools: ["location_finder"],
+ * });
+ * ```
+ */
+declare function detectRequestsFromResult(result: ResultWithToolCalls, options?: DetectOptions): DetectedRequests;
+/**
+ * Creates options with auto-detected web search and Google Maps requests.
+ * Merges detected counts with any manually specified counts.
+ *
+ * @example
+ * ```typescript
+ * const result = await generateText({
+ *   model: google("gemini-2.0-flash"),
+ *   prompt: "Find coffee shops near Tokyo Station",
+ * });
+ *
+ * const cost = calculateCost({
+ *   model: "gemini-2.0-flash",
+ *   usage: result.usage,
+ *   ...withDetectedRequests(result),
+ * });
+ *
+ * // With custom tool names
+ * const cost2 = calculateCost({
+ *   model: "gemini-2.0-flash",
+ *   usage: result.usage,
+ *   ...withDetectedRequests(result, {
+ *     webSearchTools: ["my_search"],
+ *   }),
+ * });
+ * ```
+ */
+declare function withDetectedRequests(result: ResultWithToolCalls, options?: DetectOptions & {
+    webSearchRequests?: number;
+    googleMapsRequests?: number;
+}): DetectedRequests;
+
 /**
  * Options for adding usage to the tracker
  */
-interface AddUsageOptions {
+interface AddUsageOptions extends DetectOptions {
     /** Number of web search requests made */
     webSearchRequests?: number;
+    /** Number of Google Maps API requests made */
+    googleMapsRequests?: number;
 }
 /**
  * Per-model cost summary
@@ -202,11 +310,13 @@ interface FinishResultWithCost {
 /**
  * Options for cost-aware wrappers
  */
-interface CostAwareOptions {
+interface CostAwareOptions extends DetectOptions {
     /** Custom pricing override */
     customPricing?: ModelPricing;
     /** Number of web search requests */
     webSearchRequests?: number;
+    /** Number of Google Maps API requests */
+    googleMapsRequests?: number;
     /** Callback when cost is calculated */
     onCost?: (cost: CostBreakdown, usage: LanguageModelUsage) => void;
 }
@@ -325,4 +435,4 @@ declare function createCostAwareAI(options?: CreateCostAwareAIOptions): CostAwar
  */
 declare function getCost(model: LanguageModel | string, usage: LanguageModelUsage, options?: CostAwareOptions): CostBreakdown;
 
-export { type AddUsageOptions, type CalculateCostOptions, type CostAwareAI, type CostAwareOptions, type CostBreakdown, type CostTracker, type CreateCostAwareAIOptions, type CreateCostTrackerOptions, type CreateMultiModelTrackerOptions, type FinishResultWithCost, type ModelCostSummary, type ModelPricing, type MultiModelCostTracker, type Provider, type ProviderPricing, type ResultWithCost, type StreamCostOptions, allPricing, anthropicPricing, calculateCost, calculateStreamCost, createCostAwareAI, createCostTracker, createTracker, deepseekPricing, flatPricing, formatCost, formatCostBreakdown, getAllSupportedModels, getCost, getModelId, getModelPricing, getModelPricingByModelId, googlePricing, onFinishWithCost, openaiPricing, perplexityPricing, withCost, xaiPricing };
+export { type AddUsageOptions, type CalculateCostOptions, type CostAwareAI, type CostAwareOptions, type CostBreakdown, type CostTracker, type CreateCostAwareAIOptions, type CreateCostTrackerOptions, type CreateMultiModelTrackerOptions, DEFAULT_GOOGLE_MAPS_TOOLS, DEFAULT_WEB_SEARCH_TOOLS, type DetectOptions, type DetectedRequests, type FinishResultWithCost, type ModelCostSummary, type ModelPricing, type MultiModelCostTracker, type Provider, type ProviderPricing, type ResultWithCost, type ResultWithToolCalls, type StreamCostOptions, allPricing, anthropicPricing, calculateCost, calculateStreamCost, createCostAwareAI, createCostTracker, createTracker, deepseekPricing, detectRequestsFromResult, flatPricing, formatCost, formatCostBreakdown, getAllSupportedModels, getCost, getModelId, getModelPricing, getModelPricingByModelId, googlePricing, onFinishWithCost, openaiPricing, perplexityPricing, withCost, withDetectedRequests, xaiPricing };