@x12i/ai-gateway 9.1.6 → 9.3.0

package/dist-cjs/gateway-utils.d.ts

@@ -4,6 +4,7 @@
  */
 import type { AIInvokeRequest, ChatRequest, GatewayConfig, GatewayInvokeRejectionMetadata, GatewayTraceMergedConfig, GatewayTraceRequestIds, ModelConfig } from './types.js';
 import type { Logxer } from '@x12i/logxer';
+import { type AiModelsCatalogClient, type CostCalculator } from '@x12i/ai-tools';
 /**
  * Generates MD5 hash of a string
  */
@@ -12,13 +13,17 @@ export declare function generateMD5Hash(text: string): string;
  * Auto-generates taskTypeId from MD5 hash of pre-parsed instructions if not provided
  */
 export declare function ensureTaskTypeId(request: ChatRequest, logger: Logxer): Promise<string>;
+export type MergeConfigOptions = {
+    defaultModelConfig?: Record<string, unknown>;
+    catalog?: AiModelsCatalogClient | null;
+};
 /**
  * Merges config with defaults
  * Supports using internal system action defaults (internalSkill or skillAudit) when useInternalDefaults is set
  */
 export declare function mergeConfig(request: ChatRequest & {
     useInternalDefaults?: 'skill' | 'audit';
-}, config: GatewayConfig, logger: Logxer): Promise<ChatRequest['config']>;
+}, config: GatewayConfig, logger: Logxer, mergeOptions?: MergeConfigOptions): Promise<ChatRequest['config']>;
 /**
  * Maps provider/router usage objects to gateway token counts (`metadata.tokens`, Activix, trace attempts).
  * Handles promptTokens/inputTokens, OpenAI-style snake_case, Responses-style input/output tokens, and missing total (sum prompt+completion).
@@ -43,6 +48,57 @@ export declare function extractTokenUsageFromRouterResponse(routerResponse: unkn
  * Does not compute cost from tokens — adapters must populate normalized fields or raw usage.cost-style keys.
  */
 export declare function extractCostUsdFromRouterResponse(routerResponse: unknown): number | undefined;
+/** Activity billing state when token usage is recorded (Run Analysis G8). */
+export type ActivityCostStatus = 'priced' | 'unpriced';
+export type ResolvedActivityCost = {
+    cost?: number;
+    costStatus?: ActivityCostStatus;
+    costBreakdown?: {
+        promptCostUsd: number;
+        completionCostUsd: number;
+        cachingCostUsd?: number;
+        reasoningCostUsd?: number;
+        audioCostUsd?: number;
+        imageCostUsd?: number;
+        requestFlatCostUsd?: number;
+    };
+};
+export declare function hasNonZeroTokenUsage(tokens: {
+    prompt: number;
+    completion: number;
+    total: number;
+}): boolean;
+/**
+ * Gateway fallback when the router does not set `metadata.costStatus`.
+ * Prefer {@link resolveCostCompletionForActivity} at invoke boundaries.
+ */
+export declare function resolveActivityCostCompletion(tokens: {
+    prompt: number;
+    completion: number;
+    total: number;
+}, costUsd: number | undefined): ResolvedActivityCost;
+/**
+ * Activity cost slice for Activix: router `metadata.costStatus` / cost wins when present;
+ * otherwise gateway applies the G8 fallback (usage + no price → `unpriced`).
+ */
+export declare function resolveCostCompletionForActivity(routerResponse: unknown, tokens: {
+    prompt: number;
+    completion: number;
+    total: number;
+}): ResolvedActivityCost;
+export type ResolveCostCompletionOptions = {
+    mergedConfig?: unknown;
+    calculator?: CostCalculator | null;
+    calculateCost?: boolean;
+};
+/**
+ * Router cost passthrough, then optional @x12i/ai-tools catalog pricing when still unpriced.
+ */
+export declare function resolveCostCompletionWithAiTools(routerResponse: unknown, tokens: {
+    prompt: number;
+    completion: number;
+    total: number;
+}, options?: ResolveCostCompletionOptions): Promise<ResolvedActivityCost>;
 /**
  * Stable routing facts for gateway response metadata (router metadata + merged config fallbacks).
  * Matches trace-mode resolution; intended for every successful invoke(), not only diagnostics.trace.

package/dist-cjs/gateway-validation.cjs

@@ -1,11 +1,7 @@
-"use strict";
 /**
  * Gateway Validation Module
  * Basic validation for clean proxy implementation
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateChatRequest = validateChatRequest;
-exports.validateAIRequest = validateAIRequest;
 function validateMandatoryRuntimeIdentity(request) {
     const id = request.identity;
     if (id === undefined || id === null || typeof id !== 'object') {
@@ -16,7 +12,7 @@ function validateMandatoryRuntimeIdentity(request) {
 /**
  * Validates ChatRequest has required fields
  */
-function validateChatRequest(request) {
+export function validateChatRequest(request) {
     if (!request.aiRequestId) {
         throw new Error('aiRequestId is required');
     }
@@ -40,7 +36,7 @@ const GATEWAY_ACTION_TYPES = ['skill', 'preSkill', 'postSkill'];
 /**
  * Validates AIInvokeRequest has required fields
  */
-function validateAIRequest(request) {
+export function validateAIRequest(request) {
     if (!request.aiRequestId) {
         throw new Error('aiRequestId is required for AI requests');
     }

package/dist-cjs/gateway.cjs

@@ -1,21 +1,20 @@
-"use strict";
 /**
  * @x12i/ai-gateway
  *
  * Simplified AI Gateway - Clean proxy implementation
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AIGateway = void 0;
-const gateway_validation_js_1 = require("./gateway-validation.cjs");
-const activity_manager_js_1 = require("./activity-manager.cjs");
-const gateway_config_js_1 = require("./gateway-config.cjs");
-const message_builder_js_1 = require("./message-builder.cjs");
-const flex_md_loader_js_1 = require("./flex-md-loader.cjs");
-const gateway_utils_js_1 = require("./gateway-utils.cjs");
-const gateway_provider_auto_register_js_1 = require("./gateway-provider-auto-register.cjs");
-const runtime_objects_js_1 = require("./runtime-objects.cjs");
-const gateway_log_meta_js_1 = require("./gateway-log-meta.cjs");
-const gateway_retry_js_1 = require("./gateway-retry.cjs");
+import { validateChatRequest, validateAIRequest } from './gateway-validation.js';
+import { ensureGatewayRequestIdentity } from './activity-manager.js';
+import { initializeGatewayComponents } from './gateway-config.js';
+import { buildMessages } from './message-builder.js';
+import { extractJsonFromFlexMd } from './flex-md-loader.js';
+import { enrichParsedContentForOutputContract, resolveOutputContractFieldKeys } from './output-contract-normalizer.js';
+import { attachGatewayInvokeRejectionMetadata, buildInvokeRejectionMetadata, capActivityFullResponsePayload, DEFAULT_ACTIVITY_FULL_RESPONSE_MAX_CHARS, extractCostUsdFromRouterResponse, extractTokenUsageFromRouterResponse, mergeConfig, pickEffectiveModelConfigForMetadata, pickInvokeRoutingMetadataSlice, pickTraceMergedRouterConfig, resolveCostCompletionWithAiTools, tryExtractRouterLikePayloadFromErrorChain } from './gateway-utils.js';
+import { getAiToolsClient } from './ai-tools-client.js';
+import { autoRegisterProviders } from './gateway-provider-auto-register.js';
+import { setGatewayLastJobId, setGatewayRuntimeClients } from './runtime-objects.js';
+import { gatewayLogDebug, withActivityIdentity } from './gateway-log-meta.js';
+import { invokeWithRetry } from './gateway-retry.js';
 /** Error message thrown by the router when no provider is registered or specified */
 const NO_PROVIDER_ERROR = 'No provider specified and no providers registered';
 const NO_PROVIDER_HINT = ' Set OPEN_ROUTER_KEY (or OPENROUTER_API_KEY) in the environment to use OpenRouter, or register a provider with the router (e.g. via autoRegisterProviders or gateway config).';
@@ -27,7 +26,7 @@ function warnIfSuccessfulInvokeReportsZeroUsageOrCost(logger, identity, meta, in
     const zeroCost = typeof cost === 'number' && cost === 0;
     if (!zeroTokens && !zeroCostUsd && !zeroCost)
         return;
-    logger.warn('Successful provider response reported zero token usage and/or zero cost; verify router adapter usage and billing metadata', (0, gateway_log_meta_js_1.withActivityIdentity)(identity, {
+    logger.warn('Successful provider response reported zero token usage and/or zero cost; verify router adapter usage and billing metadata', withActivityIdentity(identity, {
         invokeKind,
         zeroTokens,
         zeroCostUsd,
@@ -35,28 +34,31 @@ function warnIfSuccessfulInvokeReportsZeroUsageOrCost(logger, identity, meta, in
         tokens,
         costUsd,
         cost,
-        debugKind: gateway_log_meta_js_1.gatewayLogDebug.anomaly
+        debugKind: gatewayLogDebug.anomaly
     }));
 }
 /**
  * Simplified AI Gateway - Clean proxy implementation
  */
-class AIGateway {
+export class AIGateway {
     router;
     config;
     logger;
     activityManager;
     messageBuilderConfig;
+    defaultModelConfig = {};
     _autoRegisterDone = false;
+    _aiToolsClient = null;
     constructor(config = {}, activityManager) {
         this.config = config;
         this.activityManager = activityManager;
-        const components = (0, gateway_config_js_1.initializeGatewayComponents)(config);
+        const components = initializeGatewayComponents(config);
         this.logger = components.logger;
         this.router = components.router;
         this.activityManager = components.activityManager;
         this.messageBuilderConfig = components.messageBuilderConfig;
-        (0, runtime_objects_js_1.setGatewayRuntimeClients)({
+        this.defaultModelConfig = components.defaultModelConfig ?? {};
+        setGatewayRuntimeClients({
             activix: this.activityManager?.getTracker(),
             logger: this.logger
         });
@@ -71,20 +73,24 @@ class AIGateway {
     async invokeChat(request) {
         const startTime = Date.now();
         // Basic validation
-        (0, gateway_validation_js_1.validateChatRequest)(request);
-        (0, activity_manager_js_1.ensureGatewayRequestIdentity)(request, undefined, this.logger);
-        (0, runtime_objects_js_1.setGatewayLastJobId)(resolveRuntimeJobId(request));
+        validateChatRequest(request);
+        ensureGatewayRequestIdentity(request, undefined, this.logger);
+        setGatewayLastJobId(resolveRuntimeJobId(request));
         // Generate simple task type ID
         const taskTypeId = request.taskTypeId || `task-${Date.now()}`;
         // Simple message construction
         const messages = this.buildSimpleMessages(request);
         // Merge config (modelConfig > request.config > gateway defaults)
-        const mergedConfig = await (0, gateway_utils_js_1.mergeConfig)(request, this.config, this.logger);
+        const aiTools = await this.getAiTools();
+        const mergedConfig = await mergeConfig(request, this.config, this.logger, {
+            defaultModelConfig: this.defaultModelConfig,
+            catalog: aiTools?.catalog ?? null
+        });
         // Activix start snapshot must match what the router receives (modelConfig-only callers omit request.config.model).
         request._mergedRouterConfig = mergedConfig;
         // Lazy auto-register providers from env (OPENAI_API_KEY, etc.) so consumers don't have to call init
         if (!this._autoRegisterDone) {
-            await (0, gateway_provider_auto_register_js_1.autoRegisterProviders)(this.router, this.logger);
+            await autoRegisterProviders(this.router, this.logger);
             this._autoRegisterDone = true;
         }
         // Start activity tracking if available
@@ -111,8 +117,13 @@ class AIGateway {
                 },
                 mode: 'sync'
             });
-            const costUsdChat = (0, gateway_utils_js_1.extractCostUsdFromRouterResponse)(response);
             const metaChat = response?.metadata || {};
+            const tokensChat = extractTokenUsageFromRouterResponse(response);
+            const costCompletionChat = await resolveCostCompletionWithAiTools(response, tokensChat, {
+                mergedConfig,
+                calculator: aiTools?.calculator ?? null,
+                calculateCost: this.config.aiTools?.calculateCost
+            });
             // Create enhanced response
             const enhancedResponse = {
                 content: response.content || '',
@@ -120,22 +131,25 @@ class AIGateway {
                     aiRequestId: request.aiRequestId,
                     identity: request.identity,
                     latencyMs: Date.now() - startTime,
-                    tokens: (0, gateway_utils_js_1.extractTokenUsageFromRouterResponse)(response),
+                    tokens: tokensChat,
                     taskTypeId,
                     agentType: 'chat',
-                    ...(typeof costUsdChat === 'number'
+                    ...(costCompletionChat.costStatus === 'priced'
                         ? {
-                            costUsd: costUsdChat,
-                            ...(typeof metaChat.cost === 'number' ? { cost: metaChat.cost } : { cost: costUsdChat })
+                            costUsd: costCompletionChat.cost,
+                            ...(typeof metaChat.cost === 'number'
+                                ? { cost: metaChat.cost }
+                                : { cost: costCompletionChat.cost })
                         }
-                        : {})
+                        : {}),
+                    ...(costCompletionChat.costStatus ? { costStatus: costCompletionChat.costStatus } : {})
                 }
             };
             // Track activity success if activity was started
             if (activity) {
                 try {
                     await this.activityManager.logSuccess(activity, {
-                        ...(typeof costUsdChat === 'number' ? { cost: costUsdChat } : {}),
+                        ...costCompletionChat,
                         response: enhancedResponse,
                         endTime: Date.now(),
                         duration: Date.now() - startTime
@@ -170,9 +184,9 @@ class AIGateway {
     async invoke(request) {
         const startTime = Date.now();
         // Basic validation
-        (0, gateway_validation_js_1.validateAIRequest)(request);
-        (0, activity_manager_js_1.ensureGatewayRequestIdentity)(request, undefined, this.logger);
-        (0, runtime_objects_js_1.setGatewayLastJobId)(resolveRuntimeJobId(request));
+        validateAIRequest(request);
+        ensureGatewayRequestIdentity(request, undefined, this.logger);
+        setGatewayLastJobId(resolveRuntimeJobId(request));
         // Generate simple task type ID
         const taskTypeId = request.taskTypeId || `task-${Date.now()}`;
         // Resolve instructions and build messages using proper components
@@ -183,7 +197,7 @@ class AIGateway {
         // Use proper instruction resolution and message building
         let builtMessages;
         try {
-            builtMessages = await (0, message_builder_js_1.buildMessages)(request, this.messageBuilderConfig, {
+            builtMessages = await buildMessages(request, this.messageBuilderConfig, {
                 parsedSnapshot
             });
             messages = builtMessages.messages;
@@ -228,13 +242,13 @@ class AIGateway {
                     failureType: 'validation-failure'
                 }, startTime);
             }
-            const rejectMeta = (0, gateway_utils_js_1.buildInvokeRejectionMetadata)({
+            const rejectMeta = buildInvokeRejectionMetadata({
                 request,
                 taskTypeId,
                 startTime,
                 gatewayAiRequestId: request.aiRequestId
             });
-            (0, gateway_utils_js_1.attachGatewayInvokeRejectionMetadata)(err, rejectMeta);
+            attachGatewayInvokeRejectionMetadata(err, rejectMeta);
             // Re-throw the error so it propagates to the caller
             throw err;
         }
@@ -248,14 +262,18 @@ class AIGateway {
         // Attach parsedSnapshot to request for activity tracking
         request._parsedRequest = parsedSnapshot;
         // Merge config (modelConfig > request.config > gateway defaults)
-        const mergedConfig = await (0, gateway_utils_js_1.mergeConfig)(request, this.config, this.logger);
+        const aiTools = await this.getAiTools();
+        const mergedConfig = await mergeConfig(request, this.config, this.logger, {
+            defaultModelConfig: this.defaultModelConfig,
+            catalog: aiTools?.catalog ?? null
+        });
         request._mergedRouterConfig = mergedConfig;
         const diagnosticsMode = request.diagnostics?.mode;
         const traceEnabled = diagnosticsMode === 'trace';
         const includeRawProviderPayload = request.diagnostics?.includeRawProviderPayload === true;
         // Lazy auto-register providers from env (OPENAI_API_KEY, etc.) so consumers don't have to call init
         if (!this._autoRegisterDone) {
-            await (0, gateway_provider_auto_register_js_1.autoRegisterProviders)(this.router, this.logger);
+            await autoRegisterProviders(this.router, this.logger);
             this._autoRegisterDone = true;
         }
         // Start activity tracking if available
@@ -346,7 +364,7 @@ class AIGateway {
                     // Track per-retry attempt objects through retry hooks.
                     const attemptIndexByRetry = new Map();
                     try {
-                        const result = await (0, gateway_retry_js_1.invokeWithRetry)({
+                        const result = await invokeWithRetry({
                             ...baseRequest,
                             request: {
                                 ...baseRequest.request,
@@ -386,7 +404,7 @@ class AIGateway {
                                 const respAny = tryResp;
                                 if (ok && respAny) {
                                     const meta = respAny.metadata || {};
-                                    const tokenCounts = (0, gateway_utils_js_1.extractTokenUsageFromRouterResponse)(respAny);
+                                    const tokenCounts = extractTokenUsageFromRouterResponse(respAny);
                                     a.usage = {
                                         tokens: tokenCounts,
                                         maxTokensRequested: typeof meta?.maxTokensRequested === 'number'
@@ -415,7 +433,7 @@ class AIGateway {
                                     a.routing.requestIds = requestIds;
                                     a.modelUsed =
                                         meta?.modelUsed || meta?.model || respAny.model || candidate.model;
-                                    const attemptCostUsd = (0, gateway_utils_js_1.extractCostUsdFromRouterResponse)(respAny);
+                                    const attemptCostUsd = extractCostUsdFromRouterResponse(respAny);
                                     if (typeof attemptCostUsd === 'number')
                                         a.costUsd = attemptCostUsd;
                                     if (includeRawProviderPayload) {
@@ -480,35 +498,35 @@ class AIGateway {
             let parsingMethod = undefined;
             // Actually use flex-md parsing - extract structured data from markdown
             try {
-                this.logger.debug('Attempting flex-md extraction', (0, gateway_log_meta_js_1.withActivityIdentity)(request.identity, {
+                this.logger.debug('Attempting flex-md extraction', withActivityIdentity(request.identity, {
                     contentLength: content.length,
                     hasInstructions: !!resolvedRequest.instructions,
-                    debugKind: gateway_log_meta_js_1.gatewayLogDebug.intent
+                    debugKind: gatewayLogDebug.intent
                 }));
                 // Let flex-md extract structured data from the response content
-                const extractionResult = await (0, flex_md_loader_js_1.extractJsonFromFlexMd)(content, this.logger);
-                this.logger.debug('Flex-md extraction result', (0, gateway_log_meta_js_1.withActivityIdentity)(request.identity, {
+                const extractionResult = await extractJsonFromFlexMd(content, this.logger);
+                this.logger.debug('Flex-md extraction result', withActivityIdentity(request.identity, {
                     hasResult: !!extractionResult,
                     hasJson: !!(extractionResult && extractionResult.json),
                     method: extractionResult?.method,
                     jsonType: extractionResult?.json ? typeof extractionResult.json : 'none',
-                    debugKind: gateway_log_meta_js_1.gatewayLogDebug.state
+                    debugKind: gatewayLogDebug.state
                 }));
                 if (extractionResult && extractionResult.json) {
                     // Successfully extracted structured data
                     parsedContent = extractionResult.json;
-                    this.logger.info('Flex-md extraction successful - parsed into structured object', (0, gateway_log_meta_js_1.withActivityIdentity)(request.identity, {
+                    this.logger.info('Flex-md extraction successful - parsed into structured object', withActivityIdentity(request.identity, {
                         method: extractionResult.method,
                         extractedKeys: Object.keys(extractionResult.json),
-                        debugKind: gateway_log_meta_js_1.gatewayLogDebug.event
+                        debugKind: gatewayLogDebug.event
                     }));
                 }
                 else {
                     // Extraction failed, fall back to raw text wrapper
-                    this.logger.warn('Flex-md extraction failed - no structured data extracted', (0, gateway_log_meta_js_1.withActivityIdentity)(request.identity, {
+                    this.logger.warn('Flex-md extraction failed - no structured data extracted', withActivityIdentity(request.identity, {
                         hasResult: !!extractionResult,
                         method: extractionResult?.method || 'none',
-                        debugKind: gateway_log_meta_js_1.gatewayLogDebug.anomaly
+                        debugKind: gatewayLogDebug.anomaly
                     }));
                     parsedContent = { rawText: content };
                 }
@@ -516,30 +534,36 @@ class AIGateway {
             catch (extractionError) {
                 // Extraction failed, fall back to raw text wrapper
                 const errorMessage = extractionError instanceof Error ? extractionError.message : String(extractionError);
-                this.logger.warn('Flex-md extraction failed - flex-md library compatibility issue', (0, gateway_log_meta_js_1.withActivityIdentity)(request.identity, {
+                this.logger.warn('Flex-md extraction failed - flex-md library compatibility issue', withActivityIdentity(request.identity, {
                     error: errorMessage,
                     issue: 'flex-md uses require() in ES module context - needs fixing in flex-md-loader.ts',
                     fallback: 'using rawText wrapper',
-                    debugKind: gateway_log_meta_js_1.gatewayLogDebug.anomaly
+                    debugKind: gatewayLogDebug.anomaly
                 }));
                 parsedContent = { rawText: content };
             }
             contentType = 'structured';
             parsingMethod = 'flex-md';
-            let tokens = (0, gateway_utils_js_1.extractTokenUsageFromRouterResponse)(routerResponse);
+            const outputContractKeys = resolveOutputContractFieldKeys(request);
+            parsedContent = await enrichParsedContentForOutputContract(parsedContent, content, outputContractKeys, this.logger);
+            let tokens = extractTokenUsageFromRouterResponse(routerResponse);
             if (!(tokens.prompt || tokens.completion || tokens.total)) {
                 const alt = routerResponse?.rawResponse ?? routerResponse?.raw;
                 if (alt != null && typeof alt === 'object' && alt !== routerResponse) {
-                    const second = (0, gateway_utils_js_1.extractTokenUsageFromRouterResponse)(alt);
+                    const second = extractTokenUsageFromRouterResponse(alt);
                     if (second.prompt || second.completion || second.total)
                         tokens = second;
                 }
             }
-            const resolvedCostUsd = (0, gateway_utils_js_1.extractCostUsdFromRouterResponse)(routerResponse);
+            const costCompletion = await resolveCostCompletionWithAiTools(routerResponse, tokens, {
+                mergedConfig,
+                calculator: aiTools?.calculator ?? null,
+                calculateCost: this.config.aiTools?.calculateCost
+            });
             const routerMetaForCost = routerResponse?.metadata || {};
-            const routingMetadataSlice = (0, gateway_utils_js_1.pickInvokeRoutingMetadataSlice)(routerResponse, mergedConfig);
-            const effectiveModelConfig = (0, gateway_utils_js_1.pickEffectiveModelConfigForMetadata)(mergedConfig);
-            const traceMergedRouterSnapshot = traceEnabled ? (0, gateway_utils_js_1.pickTraceMergedRouterConfig)(mergedConfig) : undefined;
+            const routingMetadataSlice = pickInvokeRoutingMetadataSlice(routerResponse, mergedConfig);
+            const effectiveModelConfig = pickEffectiveModelConfigForMetadata(mergedConfig);
+            const traceMergedRouterSnapshot = traceEnabled ? pickTraceMergedRouterConfig(mergedConfig) : undefined;
             const enhancedResponse = {
                 content: content,
                 parsedContent: parsedContent,
@@ -554,14 +578,15 @@ class AIGateway {
                     parsingMethod,
                     ...routingMetadataSlice,
                     ...(effectiveModelConfig !== undefined ? { effectiveModelConfig } : {}),
-                    ...(typeof resolvedCostUsd === 'number'
+                    ...(costCompletion.costStatus === 'priced'
                         ? {
-                            costUsd: resolvedCostUsd,
+                            costUsd: costCompletion.cost,
                             ...(typeof routerMetaForCost.cost === 'number'
                                 ? { cost: routerMetaForCost.cost }
-                                : { cost: resolvedCostUsd })
+                                : { cost: costCompletion.cost })
                         }
                         : {}),
+                    ...(costCompletion.costStatus ? { costStatus: costCompletion.costStatus } : {}),
                     ...(traceEnabled
                         ? {
                             requestIds: traceRequestIds,
@@ -582,10 +607,10 @@ class AIGateway {
                     const includeFullProviderBlob = diag?.includeFullProviderResponseInActivity !== false;
                     const maxFullChars = typeof diag?.activityFullResponseMaxChars === 'number' && diag.activityFullResponseMaxChars > 0
                         ? diag.activityFullResponseMaxChars
-                        : gateway_utils_js_1.DEFAULT_ACTIVITY_FULL_RESPONSE_MAX_CHARS;
+                        : DEFAULT_ACTIVITY_FULL_RESPONSE_MAX_CHARS;
                     const rawFull = routerResponse.rawResponse || routerResponse;
                     const fullResponseForActivity = includeFullProviderBlob
-                        ? (0, gateway_utils_js_1.capActivityFullResponsePayload)(rawFull, maxFullChars)
+                        ? capActivityFullResponsePayload(rawFull, maxFullChars)
                         : undefined;
                     // Create activity response with proper structure for ActivityTracker
                     const activityResponse = {
@@ -600,7 +625,7 @@ class AIGateway {
                         usage: tokens
                     };
                     await this.activityManager.logSuccess(activity, {
-                        ...(typeof resolvedCostUsd === 'number' ? { cost: resolvedCostUsd } : {}),
+                        ...costCompletion,
                         response: activityResponse,
                         endTime: Date.now(),
                         duration: Date.now() - startTime
@@ -619,17 +644,17 @@ class AIGateway {
                 costUsd: enhancedResponse.metadata.costUsd,
                 cost: enhancedResponse.metadata.cost
             }, 'invoke');
-            this.logger.debug('gateway: enhancedResponse', (0, gateway_log_meta_js_1.withActivityIdentity)(request.identity, {
+            this.logger.debug('gateway: enhancedResponse', withActivityIdentity(request.identity, {
                 latencyMs: enhancedResponse.metadata?.latencyMs,
                 contentType: enhancedResponse.metadata?.contentType,
-                debugKind: gateway_log_meta_js_1.gatewayLogDebug.state
+                debugKind: gatewayLogDebug.state
             }));
             return enhancedResponse;
         }
         catch (error) {
             const err = error instanceof Error ? error : new Error(String(error));
-            const partial = (0, gateway_utils_js_1.tryExtractRouterLikePayloadFromErrorChain)(err);
-            const rejectMeta = (0, gateway_utils_js_1.buildInvokeRejectionMetadata)({
+            const partial = tryExtractRouterLikePayloadFromErrorChain(err);
+            const rejectMeta = buildInvokeRejectionMetadata({
                 request,
                 taskTypeId,
                 startTime,
@@ -637,11 +662,11 @@ class AIGateway {
                 partialRouterPayload: partial,
                 gatewayAiRequestId: request.aiRequestId
             });
-            (0, gateway_utils_js_1.attachGatewayInvokeRejectionMetadata)(err, rejectMeta);
+            attachGatewayInvokeRejectionMetadata(err, rejectMeta);
             if (err.message.includes(NO_PROVIDER_ERROR)) {
                 const wrapped = new Error(err.message + NO_PROVIDER_HINT);
                 wrapped.cause = err;
-                (0, gateway_utils_js_1.attachGatewayInvokeRejectionMetadata)(wrapped, rejectMeta);
+                attachGatewayInvokeRejectionMetadata(wrapped, rejectMeta);
                 throw wrapped;
             }
             throw err;
@@ -697,13 +722,16 @@ class AIGateway {
     }
     setActivityManager(activityManager) {
         this.activityManager = activityManager;
-        (0, runtime_objects_js_1.setGatewayRuntimeClients)({
+        setGatewayRuntimeClients({
             activix: this.activityManager.getTracker(),
             logger: this.logger
         });
     }
+    getAiTools() {
+        this._aiToolsClient ??= getAiToolsClient(this.config, this.logger);
+        return this._aiToolsClient;
+    }
 }
-exports.AIGateway = AIGateway;
 function resolveRuntimeJobId(request) {
     return request.identity.jobId || request.identity.sessionId || request.aiRequestId;
 }

package/dist-cjs/gateway.d.ts

@@ -16,7 +16,9 @@ export declare class AIGateway {
     private logger;
     private activityManager?;
     private messageBuilderConfig?;
+    private defaultModelConfig;
     private _autoRegisterDone;
+    private _aiToolsClient;
     constructor(config?: GatewayConfig, activityManager?: ActivityManager);
     /**
      * Invoke chat request (without structured output requirements)
@@ -36,4 +38,5 @@ export declare class AIGateway {
     getLogger(): Logxer;
     getActivityManager(): ActivityManager | undefined;
     setActivityManager(activityManager: ActivityManager): void;
+    private getAiTools;
 }