@x12i/ai-gateway 7.9.1

package/dist-cjs/gateway.cjs

@@ -0,0 +1,434 @@
+"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");
+/** 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).';
+/**
+ * Simplified AI Gateway - Clean proxy implementation
+ */
+class AIGateway {
+    router;
+    config;
+    logger;
+    activityManager;
+    messageBuilderConfig;
+    _autoRegisterDone = false;
+    constructor(config = {}, activityManager) {
+        this.config = config;
+        this.activityManager = activityManager;
+        // Load configuration and initialize components
+        const { defaultModelConfig, defaultInstructionsBlocks, defaultTemplateRendering } = (0, gateway_config_js_1.loadConfig)();
+        const components = (0, gateway_config_js_1.initializeGatewayComponents)(config, defaultModelConfig, defaultInstructionsBlocks, defaultTemplateRendering);
+        this.logger = components.logger;
+        this.router = components.router;
+        this.activityManager = components.activityManager;
+        this.messageBuilderConfig = components.messageBuilderConfig;
+        (0, runtime_objects_js_1.setGatewayRuntimeClients)({
+            activix: this.activityManager?.getTracker(),
+            logger: this.logger
+        });
+        this.logger.info('AI Gateway initialized with full component stack', {
+            hasActivityManager: !!this.activityManager,
+            hasMessageBuilder: !!this.messageBuilderConfig
+        });
+    }
+    /**
+     * Invoke chat request (without structured output requirements)
+     */
+    async invokeChat(request) {
+        const startTime = Date.now();
+        // Basic validation
+        (0, gateway_validation_js_1.validateChatRequest)(request);
+        if (!this.activityManager) {
+            (0, activity_manager_js_1.ensureGatewayRequestIdentity)(request);
+        }
+        (0, runtime_objects_js_1.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);
+        // 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);
+            this._autoRegisterDone = true;
+        }
+        // Start activity tracking if available
+        let activity = undefined;
+        if (this.activityManager) {
+            try {
+                activity = await this.activityManager.startActivity(request, startTime);
+            }
+            catch (activityError) {
+                // Log activity tracking error but don't fail the request
+                this.logger.warn('Failed to start activity tracking', {
+                    aiRequestId: request.aiRequestId,
+                    error: activityError instanceof Error ? activityError.message : String(activityError)
+                });
+            }
+        }
+        try {
+            // Call router directly with merged config
+            const response = await this.router.invoke({
+                request: {
+                    messages,
+                    config: mergedConfig,
+                    identity: request.identity
+                },
+                mode: 'sync'
+            });
+            // Create enhanced response
+            const enhancedResponse = {
+                content: response.content || '',
+                metadata: {
+                    aiRequestId: request.aiRequestId,
+                    identity: request.identity,
+                    latencyMs: Date.now() - startTime,
+                    tokens: response.usage || { prompt: 0, completion: 0, total: 0 },
+                    taskTypeId,
+                    agentType: 'chat'
+                }
+            };
+            // Track activity success if activity was started
+            if (activity) {
+                try {
+                    await this.activityManager.logSuccess(activity, {
+                        response: enhancedResponse,
+                        endTime: Date.now(),
+                        duration: Date.now() - startTime
+                    });
+                }
+                catch (activityError) {
+                    // Log activity tracking error but don't fail the request
+                    this.logger.warn('Failed to track activity success', {
+                        aiRequestId: request.aiRequestId,
+                        error: activityError instanceof Error ? activityError.message : String(activityError)
+                    });
+                }
+            }
+            return enhancedResponse;
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            if (err.message.includes(NO_PROVIDER_ERROR)) {
+                throw new Error(err.message + NO_PROVIDER_HINT);
+            }
+            throw err;
+        }
+    }
+    /**
+     * Invoke AI request (with structured output support)
+     */
+    async invoke(request) {
+        const startTime = Date.now();
+        // Basic validation
+        (0, gateway_validation_js_1.validateAIRequest)(request);
+        if (!this.activityManager) {
+            (0, activity_manager_js_1.ensureGatewayRequestIdentity)(request);
+        }
+        (0, runtime_objects_js_1.setGatewayLastJobId)(resolveRuntimeJobId(request));
+        // Generate simple task type ID
+        const taskTypeId = request.taskTypeId || `task-${Date.now()}`;
+        // Resolve instructions and build messages using proper components
+        let resolvedRequest = request;
+        let messages = [];
+        // Create parsedSnapshot to store parsed request data and messages
+        const parsedSnapshot = {};
+        // Use proper instruction resolution and message building
+        let builtMessages;
+        try {
+            builtMessages = await (0, message_builder_js_1.buildMessages)(request, this.messageBuilderConfig, {
+                parsedSnapshot
+            });
+            messages = builtMessages.messages;
+            resolvedRequest = request;
+        }
+        catch (error) {
+            // If message building fails (e.g., prompt/instruction resolution error), log as bad request
+            const err = error instanceof Error ? error : new Error(String(error));
+            const endTime = Date.now();
+            const duration = endTime - startTime;
+            // Determine if this is a prompt/instruction resolution error
+            // If a key was provided but couldn't be resolved to content, it's a bad request
+            const errWithCode = err; // Type assertion for error with optional code property
+            const isResolutionError = err.name === 'InstructionNotFoundError' ||
+                err.name === 'InstructionBackendError' ||
+                err.name === 'TemplateResolutionError' ||
+                errWithCode.code === 'PROMPT_NOT_FOUND' ||
+                errWithCode.code === 'PROMPT_RESOLUTION_ERROR' ||
+                errWithCode.code === 'PROMPT_RENDERED_EMPTY' ||
+                errWithCode.code === 'TEMPLATE_RESOLUTION_ERROR' ||
+                errWithCode.code === 'TEMPLATE_VARIABLE_MISSING' ||
+                err.message.includes('Failed to resolve') ||
+                err.message.includes('Failed to render prompt template') ||
+                err.message.includes('not found') ||
+                err.message.includes('Instruction not found') ||
+                err.message.includes('Prompt not found');
+            if (isResolutionError && this.activityManager) {
+                // Log to bad requests collection
+                await this.activityManager.logBadRequest(request, err, {
+                    endTime,
+                    duration,
+                    error: err.message,
+                    errorType: errWithCode.code || 'MessageBuildError',
+                    diagnosticInfo: {
+                        errorCode: errWithCode.code,
+                        errorName: err.name,
+                        failureType: 'validation-failure',
+                        stage: 'message-building',
+                        prompt: request.prompt,
+                        instructions: typeof request.instructions === 'string' ? request.instructions.substring(0, 100) : '(object)'
+                    },
+                    failureType: 'validation-failure'
+                }, startTime);
+            }
+            // Re-throw the error so it propagates to the caller
+            throw err;
+        }
+        // Store messages in parsedSnapshot for activity tracking
+        parsedSnapshot.messages = messages;
+        // parsed.instructions and parsed.prompt are set by buildMessages to the resolved/rendered content
+        // (after key resolution and Rendrix). Do not overwrite with raw request keys.
+        if (parsedSnapshot.context === undefined) {
+            parsedSnapshot.context = request.context;
+        }
+        // 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);
+        // 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);
+            this._autoRegisterDone = true;
+        }
+        // Start activity tracking if available
+        let activity = undefined;
+        if (this.activityManager) {
+            try {
+                activity = await this.activityManager.startActivity(request, startTime);
+            }
+            catch (activityError) {
+                // Log activity tracking error but don't fail the request
+                this.logger.warn('Failed to start activity tracking', {
+                    aiRequestId: request.aiRequestId,
+                    error: activityError instanceof Error ? activityError.message : String(activityError)
+                });
+            }
+        }
+        try {
+            // Call router directly with merged config
+            const response = await this.router.invoke({
+                request: {
+                    messages,
+                    config: mergedConfig,
+                    identity: request.identity
+                },
+                mode: 'sync'
+            });
+            // Contract output processing removed - expectedSchema no longer supported
+            // Create enhanced response - extract content properly from router response
+            const routerResponse = response;
+            // Extract content from router response - router returns outputText, not content
+            let content = routerResponse.content || routerResponse.outputText || '';
+            // If content is still empty, try to extract from ai-activities metadata
+            if (!content && routerResponse.metadata?.['ai-activities-response']?.outputText) {
+                content = routerResponse.metadata['ai-activities-response'].outputText;
+            }
+            // Parse content using available parsers (flex-md, content normalizer, etc.)
+            let parsedContent = undefined;
+            let contentType = undefined;
+            let parsingMethod = undefined;
+            // Actually use flex-md parsing - extract structured data from markdown
+            try {
+                this.logger.debug('Attempting flex-md extraction', {
+                    aiRequestId: request.aiRequestId,
+                    contentLength: content.length,
+                    hasInstructions: !!resolvedRequest.instructions
+                });
+                // Let flex-md extract structured data from the response content
+                const extractionResult = await (0, flex_md_loader_js_1.extractJsonFromFlexMd)(content);
+                this.logger.debug('Flex-md extraction result', {
+                    aiRequestId: request.aiRequestId,
+                    hasResult: !!extractionResult,
+                    hasJson: !!(extractionResult && extractionResult.json),
+                    method: extractionResult?.method,
+                    jsonType: extractionResult?.json ? typeof extractionResult.json : 'none'
+                });
+                if (extractionResult && extractionResult.json) {
+                    // Successfully extracted structured data
+                    parsedContent = extractionResult.json;
+                    this.logger.info('Flex-md extraction successful - parsed into structured object', {
+                        aiRequestId: request.aiRequestId,
+                        method: extractionResult.method,
+                        extractedKeys: Object.keys(extractionResult.json)
+                    });
+                }
+                else {
+                    // Extraction failed, fall back to raw text wrapper
+                    this.logger.warn('Flex-md extraction failed - no structured data extracted', {
+                        aiRequestId: request.aiRequestId,
+                        hasResult: !!extractionResult,
+                        method: extractionResult?.method || 'none'
+                    });
+                    parsedContent = { rawText: content };
+                }
+            }
+            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', {
+                    aiRequestId: request.aiRequestId,
+                    error: errorMessage,
+                    issue: 'flex-md uses require() in ES module context - needs fixing in flex-md-loader.ts',
+                    fallback: 'using rawText wrapper'
+                });
+                parsedContent = { rawText: content };
+            }
+            contentType = 'structured';
+            parsingMethod = 'flex-md';
+            // Extract token usage properly
+            let tokens = { prompt: 0, completion: 0, total: 0 };
+            if (routerResponse.usage) {
+                tokens = {
+                    prompt: routerResponse.usage.promptTokens || routerResponse.usage.inputTokens || 0,
+                    completion: routerResponse.usage.completionTokens || routerResponse.usage.outputTokens || 0,
+                    total: routerResponse.usage.totalTokens || 0
+                };
+            }
+            else if (routerResponse.metadata?.['ai-activities-response']?.usage) {
+                const usage = routerResponse.metadata['ai-activities-response'].usage;
+                tokens = {
+                    prompt: usage.promptTokens || usage.inputTokens || 0,
+                    completion: usage.completionTokens || usage.outputTokens || 0,
+                    total: usage.totalTokens || 0
+                };
+            }
+            const enhancedResponse = {
+                content: content,
+                parsedContent: parsedContent,
+                metadata: {
+                    aiRequestId: request.aiRequestId,
+                    identity: request.identity,
+                    latencyMs: Date.now() - startTime,
+                    tokens: tokens,
+                    taskTypeId,
+                    agentType: 'ai',
+                    contentType,
+                    parsingMethod
+                }
+            };
+            // Track activity success if activity was started
+            if (activity) {
+                try {
+                    // Create activity response with proper structure for ActivityTracker
+                    const activityResponse = {
+                        content: {
+                            rawContent: content, // Store the actual response content as rawContent
+                            fullResponse: routerResponse.rawResponse || routerResponse // Include full router response
+                        },
+                        parsed: parsedContent, // Include parsed content in activity record
+                        metadata: enhancedResponse.metadata,
+                        status: 'success',
+                        error: null,
+                        usage: tokens
+                    };
+                    await this.activityManager.logSuccess(activity, {
+                        response: activityResponse,
+                        endTime: Date.now(),
+                        duration: Date.now() - startTime
+                    });
+                }
+                catch (activityError) {
+                    // Log activity tracking error but don't fail the request
+                    this.logger.warn('Failed to track activity success', {
+                        aiRequestId: request.aiRequestId,
+                        error: activityError instanceof Error ? activityError.message : String(activityError)
+                    });
+                }
+            }
+            console.debug('gateway: enhancedResponse:', enhancedResponse);
+            return enhancedResponse;
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            if (err.message.includes(NO_PROVIDER_ERROR)) {
+                throw new Error(err.message + NO_PROVIDER_HINT);
+            }
+            throw err;
+        }
+    }
+    /**
+     * Build simple messages from request (instructions and prompt as literal template text; no registry).
+     */
+    buildSimpleMessages(request) {
+        const messages = [];
+        // Add instructions as system message if present
+        if (request.instructions) {
+            const instructions = typeof request.instructions === 'string'
+                ? request.instructions
+                : 'Default instructions';
+            messages.push({ role: 'system', content: instructions });
+        }
+        // Add context as assistant message if present
+        if (request.context) {
+            const context = typeof request.context === 'string'
+                ? request.context
+                : JSON.stringify(request.context);
+            messages.push({ role: 'assistant', content: context });
+        }
+        // Add prompt/input as user message
+        // Input field has been removed - prompt template should contain {{input}} which resolves from workingMemory.input
+        const userContent = request.prompt || '';
+        if (userContent) {
+            messages.push({ role: 'user', content: userContent });
+        }
+        // Add direct messages if present
+        if (request.messages) {
+            messages.push(...request.messages);
+        }
+        return messages;
+    }
+    // Provider management methods
+    register(provider) {
+        this.router.registerProvider(provider);
+    }
+    listProviders() {
+        return this.router.listProviders ? this.router.listProviders() : [];
+    }
+    // Utility methods
+    getRouter() {
+        return this.router;
+    }
+    getLogger() {
+        return this.logger;
+    }
+    getActivityManager() {
+        return this.activityManager;
+    }
+    setActivityManager(activityManager) {
+        this.activityManager = activityManager;
+        (0, runtime_objects_js_1.setGatewayRuntimeClients)({
+            activix: this.activityManager.getTracker(),
+            logger: this.logger
+        });
+    }
+}
+exports.AIGateway = AIGateway;
+function resolveRuntimeJobId(request) {
+    return request.identity?.jobId ?? request.jobId ?? request.identity?.sessionId ?? request.aiRequestId;
+}

package/dist-cjs/gateway.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @x12i/ai-gateway
+ *
+ * Simplified AI Gateway - Clean proxy implementation
+ */
+import { LLMProviderRouter } from '@x12i/ai-providers-router';
+import type { GatewayConfig, ChatRequest, AIRequest, EnhancedLLMResponse } from './types.js';
+import type { Logxer } from '@x12i/logxer';
+import { ActivityManager } from './activity-manager.js';
+/**
+ * Simplified AI Gateway - Clean proxy implementation
+ */
+export declare class AIGateway {
+    private router;
+    private config;
+    private logger;
+    private activityManager?;
+    private messageBuilderConfig?;
+    private _autoRegisterDone;
+    constructor(config?: GatewayConfig, activityManager?: ActivityManager);
+    /**
+     * Invoke chat request (without structured output requirements)
+     */
+    invokeChat<TContent = unknown>(request: ChatRequest): Promise<EnhancedLLMResponse<TContent>>;
+    /**
+     * Invoke AI request (with structured output support)
+     */
+    invoke<TContent = unknown>(request: AIRequest): Promise<EnhancedLLMResponse<TContent>>;
+    /**
+     * Build simple messages from request (instructions and prompt as literal template text; no registry).
+     */
+    private buildSimpleMessages;
+    register(provider: any): void;
+    listProviders(): string[];
+    getRouter(): LLMProviderRouter;
+    getLogger(): Logxer;
+    getActivityManager(): ActivityManager | undefined;
+    setActivityManager(activityManager: ActivityManager): void;
+}

package/dist-cjs/index.cjs

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * @x12i/ai-gateway
+ *
+ * Unified gateway for LLM provider routing and management.
+ * This package exposes all functionality from @x12i/ai-providers-router
+ * with enhanced features: context propagation, usage tier tracking, and comprehensive metadata.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetObjectTypesLibrary = exports.getObjectTypesLibrary = exports.initializeObjectTypesLibrary = exports.getObjectTypesForAgent = exports.getObjectType = exports.OBJECT_TYPES_LIBRARY = exports.assertValidAIRequest = exports.formatDiagnostic = exports.runValidationTests = exports.createValidationTestCases = exports.createTestAIRequest = exports.supportsJSONMode = exports.diagnoseResponse = exports.diagnoseRequest = exports.validateResponse = exports.extractJSON = exports.validateJSON = exports.validateAIRequest = exports.DEFAULT_RATE_LIMIT_ENABLED = exports.DEFAULT_RATE_LIMIT_MIN_INTERVAL_MS = exports.GatewayRateLimiter = exports.runtimeObjects = exports.createLogxer = exports.ensureGatewayRequestIdentity = exports.ActivityManager = exports.Activix = exports.mergeTemplateRenderOptions = exports.autoRegisterProviders = exports.InstructionBackendError = exports.InstructionNotFoundError = exports.AIGateway = exports.FallbackExhaustedError = exports.ProviderNotFoundError = exports.createRouterFromConfig = exports.createRouter = exports.LLMProviderRouter = void 0;
+// Re-export router class and types (base functionality)
+var ai_providers_router_1 = require("@x12i/ai-providers-router");
+Object.defineProperty(exports, "LLMProviderRouter", { enumerable: true, get: function () { return ai_providers_router_1.LLMProviderRouter; } });
+// Re-export factory functions
+var ai_providers_router_2 = require("@x12i/ai-providers-router");
+Object.defineProperty(exports, "createRouter", { enumerable: true, get: function () { return ai_providers_router_2.createRouter; } });
+Object.defineProperty(exports, "createRouterFromConfig", { enumerable: true, get: function () { return ai_providers_router_2.createRouterFromConfig; } });
+// Re-export error classes
+var ai_providers_router_3 = require("@x12i/ai-providers-router");
+Object.defineProperty(exports, "ProviderNotFoundError", { enumerable: true, get: function () { return ai_providers_router_3.ProviderNotFoundError; } });
+Object.defineProperty(exports, "FallbackExhaustedError", { enumerable: true, get: function () { return ai_providers_router_3.FallbackExhaustedError; } });
+// Re-export all from router (includes everything it exports)
+__exportStar(require("@x12i/ai-providers-router"), exports);
+// Export enhanced gateway
+var gateway_js_1 = require("./gateway.cjs");
+Object.defineProperty(exports, "AIGateway", { enumerable: true, get: function () { return gateway_js_1.AIGateway; } });
+var instruction_errors_js_1 = require("./instruction-errors.cjs");
+Object.defineProperty(exports, "InstructionNotFoundError", { enumerable: true, get: function () { return instruction_errors_js_1.InstructionNotFoundError; } });
+Object.defineProperty(exports, "InstructionBackendError", { enumerable: true, get: function () { return instruction_errors_js_1.InstructionBackendError; } });
+var gateway_provider_auto_register_js_1 = require("./gateway-provider-auto-register.cjs");
+Object.defineProperty(exports, "autoRegisterProviders", { enumerable: true, get: function () { return gateway_provider_auto_register_js_1.autoRegisterProviders; } });
+var template_render_merge_js_1 = require("./template-render-merge.cjs");
+Object.defineProperty(exports, "mergeTemplateRenderOptions", { enumerable: true, get: function () { return template_render_merge_js_1.mergeTemplateRenderOptions; } });
+// Usage tracking: UsageTracker class methods are available but consumption calculation is disabled
+// (x-models was previously used for RPM/TPM tracking but is no longer integrated)
+// Re-export activity tracking primitives (Activix)
+var activix_1 = require("@x12i/activix");
+Object.defineProperty(exports, "Activix", { enumerable: true, get: function () { return activix_1.Activix; } });
+var activity_manager_js_1 = require("./activity-manager.cjs");
+Object.defineProperty(exports, "ActivityManager", { enumerable: true, get: function () { return activity_manager_js_1.ActivityManager; } });
+Object.defineProperty(exports, "ensureGatewayRequestIdentity", { enumerable: true, get: function () { return activity_manager_js_1.ensureGatewayRequestIdentity; } });
+// Re-export logging (@x12i/logxer)
+var logxer_1 = require("@x12i/logxer");
+Object.defineProperty(exports, "createLogxer", { enumerable: true, get: function () { return logxer_1.createLogxer; } });
+// Runtime observability surface (leaf package: no downstream runtime objects)
+var runtime_objects_js_1 = require("./runtime-objects.cjs");
+Object.defineProperty(exports, "runtimeObjects", { enumerable: true, get: function () { return runtime_objects_js_1.runtimeObjects; } });
+// Export rate limiter
+var gateway_rate_limiter_js_1 = require("./gateway-rate-limiter.cjs");
+Object.defineProperty(exports, "GatewayRateLimiter", { enumerable: true, get: function () { return gateway_rate_limiter_js_1.GatewayRateLimiter; } });
+var gateway_rate_limiter_constants_js_1 = require("./gateway-rate-limiter-constants.cjs");
+Object.defineProperty(exports, "DEFAULT_RATE_LIMIT_MIN_INTERVAL_MS", { enumerable: true, get: function () { return gateway_rate_limiter_constants_js_1.DEFAULT_RATE_LIMIT_MIN_INTERVAL_MS; } });
+Object.defineProperty(exports, "DEFAULT_RATE_LIMIT_ENABLED", { enumerable: true, get: function () { return gateway_rate_limiter_constants_js_1.DEFAULT_RATE_LIMIT_ENABLED; } });
+// Export troubleshooting helpers
+var troubleshooting_helper_js_1 = require("./troubleshooting-helper.cjs");
+Object.defineProperty(exports, "validateAIRequest", { enumerable: true, get: function () { return troubleshooting_helper_js_1.validateAIRequest; } });
+Object.defineProperty(exports, "validateJSON", { enumerable: true, get: function () { return troubleshooting_helper_js_1.validateJSON; } });
+Object.defineProperty(exports, "extractJSON", { enumerable: true, get: function () { return troubleshooting_helper_js_1.extractJSON; } });
+Object.defineProperty(exports, "validateResponse", { enumerable: true, get: function () { return troubleshooting_helper_js_1.validateResponse; } });
+Object.defineProperty(exports, "diagnoseRequest", { enumerable: true, get: function () { return troubleshooting_helper_js_1.diagnoseRequest; } });
+Object.defineProperty(exports, "diagnoseResponse", { enumerable: true, get: function () { return troubleshooting_helper_js_1.diagnoseResponse; } });
+Object.defineProperty(exports, "supportsJSONMode", { enumerable: true, get: function () { return troubleshooting_helper_js_1.supportsJSONMode; } });
+Object.defineProperty(exports, "createTestAIRequest", { enumerable: true, get: function () { return troubleshooting_helper_js_1.createTestAIRequest; } });
+Object.defineProperty(exports, "createValidationTestCases", { enumerable: true, get: function () { return troubleshooting_helper_js_1.createValidationTestCases; } });
+Object.defineProperty(exports, "runValidationTests", { enumerable: true, get: function () { return troubleshooting_helper_js_1.runValidationTests; } });
+Object.defineProperty(exports, "formatDiagnostic", { enumerable: true, get: function () { return troubleshooting_helper_js_1.formatDiagnostic; } });
+Object.defineProperty(exports, "assertValidAIRequest", { enumerable: true, get: function () { return troubleshooting_helper_js_1.assertValidAIRequest; } });
+// Export object types library
+var object_types_library_js_1 = require("./object-types-library.cjs");
+Object.defineProperty(exports, "OBJECT_TYPES_LIBRARY", { enumerable: true, get: function () { return object_types_library_js_1.OBJECT_TYPES_LIBRARY; } });
+Object.defineProperty(exports, "getObjectType", { enumerable: true, get: function () { return object_types_library_js_1.getObjectType; } });
+Object.defineProperty(exports, "getObjectTypesForAgent", { enumerable: true, get: function () { return object_types_library_js_1.getObjectTypesForAgent; } });
+// Re-export outputs library integration functions
+var object_types_library_integration_js_1 = require("./object-types-library-integration.cjs");
+Object.defineProperty(exports, "initializeObjectTypesLibrary", { enumerable: true, get: function () { return object_types_library_integration_js_1.initializeObjectTypesLibrary; } });
+Object.defineProperty(exports, "getObjectTypesLibrary", { enumerable: true, get: function () { return object_types_library_integration_js_1.getObjectTypesLibrary; } });
+Object.defineProperty(exports, "resetObjectTypesLibrary", { enumerable: true, get: function () { return object_types_library_integration_js_1.resetObjectTypesLibrary; } });
+// Re-export outputs library types and utilities for convenience
+// Note: Since we use dynamic imports for the outputs library, these types may not be available
+// at compile time if the package isn't installed. Users can import directly from
+// @x12i/outputs-library if they need these types or utilities.
+//
+// Recommended: Import types and utilities directly from @x12i/outputs-library:
+//   import type { ClassificationOutput } from '@x12i/outputs-library/types';
+//   import { ResponseParser } from '@x12i/outputs-library/parsers';
+//   import type { ObjectTypesLibrary, FlexMdSupport } from '@x12i/outputs-library';
+//
+// The gateway integrates with the outputs library internally via dynamic imports,
+// so these re-exports are optional and mainly for convenience.
+//
+// For outputs-library v3.3.1+ with flex-md support:
+//   - ObjectTypesLibrary class with flex-md methods (getFlexMdTemplate, getFlexMdFormatSpec, etc.)
+//   - FlexMdSupport type for object type definitions
+//   - All flex-md methods are available on the library instance returned by getObjectTypesLibrary()

package/dist-cjs/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @x12i/ai-gateway
+ *
+ * Unified gateway for LLM provider routing and management.
+ * This package exposes all functionality from @x12i/ai-providers-router
+ * with enhanced features: context propagation, usage tier tracking, and comprehensive metadata.
+ */
+export { LLMProviderRouter } from '@x12i/ai-providers-router';
+export type { RouterConfig, HealthCheckResult } from '@x12i/ai-providers-router';
+export { createRouter, createRouterFromConfig } from '@x12i/ai-providers-router';
+export type { CreateRouterConfig } from '@x12i/ai-providers-router';
+export { ProviderNotFoundError, FallbackExhaustedError } from '@x12i/ai-providers-router';
+export type { RequestInterceptor, ResponseInterceptor } from '@x12i/ai-providers-router';
+export type { UsageTracker } from '@x12i/ai-providers-router';
+export * from '@x12i/ai-providers-router';
+export { AIGateway } from './gateway.js';
+export { InstructionNotFoundError, InstructionBackendError } from './instruction-errors.js';
+export { autoRegisterProviders } from './gateway-provider-auto-register.js';
+export type { GatewayConfig, ProviderModelRef, ModelConfig, RetryConfig, ChatRequest, AIRequest, EnhancedLLMResponse, InstructionMetadata, ValidationRule, ResponseTransformationConfig, TemplateRenderOptions } from './types.js';
+export { mergeTemplateRenderOptions } from './template-render-merge.js';
+export type { UsageTier } from './types.js';
+export { Activix } from '@x12i/activix';
+export type { ActivixRunContext, FindByRunContextCriteria } from '@x12i/activix';
+export { ActivityManager, ensureGatewayRequestIdentity } from './activity-manager.js';
+export type { ActivityIdentity } from './types.js';
+export { createLogxer } from '@x12i/logxer';
+export type { Logxer } from '@x12i/logxer';
+export { runtimeObjects } from './runtime-objects.js';
+export type { ActivixQueryableClient, LogxerQueryableClient, PackageRuntimeObjects, RuntimeObjects } from './runtime-objects.js';
+export { GatewayRateLimiter } from './gateway-rate-limiter.js';
+export { DEFAULT_RATE_LIMIT_MIN_INTERVAL_MS, DEFAULT_RATE_LIMIT_ENABLED } from './gateway-rate-limiter-constants.js';
+export { validateAIRequest, validateJSON, extractJSON, validateResponse, diagnoseRequest, diagnoseResponse, supportsJSONMode, createTestAIRequest, createValidationTestCases, runValidationTests, formatDiagnostic, assertValidAIRequest } from './troubleshooting-helper.js';
+export type { ValidationResult, DiagnosticInfo } from './troubleshooting-helper.js';
+export { OBJECT_TYPES_LIBRARY, getObjectType, getObjectTypesForAgent } from './object-types-library.js';
+export type { ReasoningResult, AuditReport, ScopeDefinition, DiscoveryFindings, ActionPlan, ExecutionResult } from './object-types-library.js';
+export { initializeObjectTypesLibrary, getObjectTypesLibrary, resetObjectTypesLibrary } from './object-types-library-integration.js';

package/dist-cjs/instruction-errors.cjs

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * Errors for instruction / prompt template and instructions-block resolution.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstructionBackendError = exports.InstructionNotFoundError = void 0;
+class InstructionNotFoundError extends Error {
+    key;
+    backend;
+    originalKey;
+    constructor(key, backend, message, originalKey) {
+        super(message);
+        this.key = key;
+        this.backend = backend;
+        this.originalKey = originalKey;
+        this.name = 'InstructionNotFoundError';
+    }
+}
+exports.InstructionNotFoundError = InstructionNotFoundError;
+class InstructionBackendError extends Error {
+    key;
+    backend;
+    isRetryable;
+    originalError;
+    constructor(key, backend, message, isRetryable, originalError) {
+        super(message);
+        this.key = key;
+        this.backend = backend;
+        this.isRetryable = isRetryable;
+        this.originalError = originalError;
+        this.name = 'InstructionBackendError';
+    }
+}
+exports.InstructionBackendError = InstructionBackendError;