agentic-qe 3.9.36 → 3.10.1

package/dist/mcp/qe-tool-bridge.js

@@ -75,7 +75,14 @@ export function registerMissingQETools(registerFn) {
                 parameters: schemaToParameters(tool),
             },
             handler: async (params) => {
-                const result = await tool.invoke(params);
+                // ADR-043: explicitly forward the shared HybridRouter (registered
+                // by QEKernelImpl during initialize() in production, or built
+                // lazily for MCP-only contexts) so the MCPToolContext.llmRouter
+                // field carries the actual instance rather than relying on each
+                // tool's getLLMRouter(context) singleton fallback.
+                const { getSharedLLMRouter } = await import('./tools/base.js');
+                const llmRouter = (await getSharedLLMRouter()) ?? undefined;
+                const result = await tool.invoke(params, { llmRouter });
                 return result;
             },
         };

package/dist/mcp/tools/base.d.ts

@@ -26,6 +26,41 @@ export declare function resetSharedMemoryBackend(): void;
  * Get memory backend from context or create shared one
  */
 export declare function getMemoryBackend(context?: MCPToolContext): Promise<MemoryBackend>;
+/**
+ * Register an externally-built HybridRouter as the shared singleton.
+ * Called by QEKernelImpl during initialize() so kernel-mode and MCP-mode
+ * tools share the same router instance. Idempotent — calling with the
+ * same router twice is a no-op; calling with a different router
+ * replaces the previous one (and any in-flight lazy init is cancelled
+ * for next-read semantics).
+ */
+export declare function setSharedLLMRouter(router: import('../../shared/llm/router/hybrid-router.js').HybridRouter): void;
+/**
+ * Get or create the shared HybridRouter for standalone MCP tools that
+ * construct their service directly (without going through the kernel /
+ * plugin chain that Phase 2 wired up).
+ *
+ * Returns null when:
+ *   - AQE_LLM_ROUTER_DISABLED env kill-switch is set, OR
+ *   - no provider key is in env and the project has no llm-config.json
+ *
+ * Callers MUST tolerate a null return value and fall back to
+ * deterministic-only behavior in that case.
+ *
+ * Resets via `resetSharedLLMRouter()` for tests.
+ */
+export declare function getSharedLLMRouter(): Promise<import('../../shared/llm/router/hybrid-router.js').HybridRouter | null>;
+/**
+ * Reset the shared LLM router singleton. For tests.
+ */
+export declare function resetSharedLLMRouter(): void;
+/**
+ * Get LLM router from context or shared singleton. Returns undefined
+ * (not null) when no router is available, so it can be spread directly
+ * into a `{ memory, llmRouter }` dependency bag without contaminating
+ * the value.
+ */
+export declare function getLLMRouter(context?: MCPToolContext): Promise<import('../../shared/llm/router/hybrid-router.js').HybridRouter | undefined>;
 /**
  * JSON Schema property definition for tool parameters
  */
@@ -79,6 +114,13 @@ export interface MCPToolContext {
     demoMode?: boolean;
     /** Shared memory backend for persistent storage */
     memory?: import('../../kernel/interfaces').MemoryBackend;
+    /**
+     * ADR-043: HybridRouter for LLM-enhanced analysis. Standalone MCP
+     * tools that construct services directly should fetch this via
+     * `getLLMRouter(context)` and pass it into the service dependency
+     * bag so isLLMAnalysisAvailable() returns true.
+     */
+    llmRouter?: import('../../shared/llm/router/hybrid-router.js').HybridRouter;
 }
 /**
  * Data source tracking for audit/transparency
@@ -167,6 +209,20 @@ export declare abstract class MCPToolBase<TParams extends Record<string, unknown
         abortSignal?: AbortSignal;
         /** Explicit demo mode - returns sample data without calling real services */
         demoMode?: boolean;
+        /**
+         * ADR-043: Optional memory backend injection. When provided, the
+         * context.memory field is populated and tools skip the shared
+         * singleton fallback.
+         */
+        memory?: import('../../kernel/interfaces').MemoryBackend;
+        /**
+         * ADR-043: Optional LLM router injection. When provided, the
+         * context.llmRouter field is populated so getLLMRouter(context)
+         * returns it directly — used by the MCP runtime to forward the
+         * kernel singleton without going through getSharedLLMRouter()'s
+         * lazy build path.
+         */
+        llmRouter?: import('../../shared/llm/router/hybrid-router.js').HybridRouter;
     }): Promise<ToolResult<TResult>>;
     /**
      * Create result metadata

package/dist/mcp/tools/base.js

@@ -97,6 +97,101 @@ export async function getMemoryBackend(context) {
     }
     return getSharedMemoryBackend();
 }
+// ============================================================================
+// Shared LLM Router for MCP Tools (ADR-043)
+// ============================================================================
+//
+// Two paths populate this singleton:
+//
+//   1. QEKernelImpl._initializeLLMRouter() calls setSharedLLMRouter() on
+//      boot, so kernel-mode AND MCP-mode share ONE HybridRouter — one
+//      cost tracker, one metrics collector, one provider circuit breaker.
+//      This is the production path.
+//
+//   2. Pure-MCP processes (no kernel — e.g. standalone CLI invocations
+//      that go directly through the MCP tool surface) lazily construct
+//      a router on first getSharedLLMRouter() call. Subordinate to (1).
+//
+// AQE_LLM_ROUTER_DISABLED env kill-switch is honored in both paths so a
+// user can opt out without code changes.
+let sharedLLMRouter = null;
+let llmRouterInitPromise = null;
+/**
+ * Returns true when the AQE_LLM_ROUTER_DISABLED env kill-switch is set.
+ * Honors '1', 'true', 'yes', 'on'; ignores '', '0', 'false', 'no', 'off'.
+ */
+function isRouterKillSwitchSet() {
+    const v = (process.env.AQE_LLM_ROUTER_DISABLED ?? '').trim().toLowerCase();
+    if (!v)
+        return false;
+    return v !== 'false' && v !== '0' && v !== 'no' && v !== 'off';
+}
+/**
+ * Register an externally-built HybridRouter as the shared singleton.
+ * Called by QEKernelImpl during initialize() so kernel-mode and MCP-mode
+ * tools share the same router instance. Idempotent — calling with the
+ * same router twice is a no-op; calling with a different router
+ * replaces the previous one (and any in-flight lazy init is cancelled
+ * for next-read semantics).
+ */
+export function setSharedLLMRouter(router) {
+    sharedLLMRouter = router;
+    llmRouterInitPromise = null;
+}
+/**
+ * Get or create the shared HybridRouter for standalone MCP tools that
+ * construct their service directly (without going through the kernel /
+ * plugin chain that Phase 2 wired up).
+ *
+ * Returns null when:
+ *   - AQE_LLM_ROUTER_DISABLED env kill-switch is set, OR
+ *   - no provider key is in env and the project has no llm-config.json
+ *
+ * Callers MUST tolerate a null return value and fall back to
+ * deterministic-only behavior in that case.
+ *
+ * Resets via `resetSharedLLMRouter()` for tests.
+ */
+export async function getSharedLLMRouter() {
+    if (isRouterKillSwitchSet()) {
+        return null;
+    }
+    if (sharedLLMRouter) {
+        return sharedLLMRouter;
+    }
+    if (llmRouterInitPromise) {
+        return llmRouterInitPromise;
+    }
+    llmRouterInitPromise = (async () => {
+        const { createLLMRouterService } = await import('../../shared/llm/llm-router-service.js');
+        const built = await createLLMRouterService();
+        if (!built)
+            return null;
+        sharedLLMRouter = built.router;
+        return sharedLLMRouter;
+    })();
+    return llmRouterInitPromise;
+}
+/**
+ * Reset the shared LLM router singleton. For tests.
+ */
+export function resetSharedLLMRouter() {
+    sharedLLMRouter = null;
+    llmRouterInitPromise = null;
+}
+/**
+ * Get LLM router from context or shared singleton. Returns undefined
+ * (not null) when no router is available, so it can be spread directly
+ * into a `{ memory, llmRouter }` dependency bag without contaminating
+ * the value.
+ */
+export async function getLLMRouter(context) {
+    if (context?.llmRouter) {
+        return context.llmRouter;
+    }
+    const shared = await getSharedLLMRouter();
+    return shared ?? undefined;
+}
 /**
  * Default console logger
  */
@@ -245,7 +340,13 @@ export class MCPToolBase {
                 metadata: this.createMetadata(startTime, requestId),
             };
         }
-        // Create execution context
+        // Create execution context.
+        // ADR-043: memory + llmRouter are populated from invoke() options so
+        // the MCP runtime (qe-tool-bridge, registry, daemon) can forward the
+        // kernel singleton explicitly rather than relying on the shared
+        // singleton fallback. When unset, getLLMRouter(context) falls back
+        // to getSharedLLMRouter() — which itself is kernel-aware via
+        // setSharedLLMRouter() registered during kernel.initialize().
         const context = {
             requestId,
             startTime,
@@ -253,6 +354,8 @@ export class MCPToolBase {
             onStream: options.onStream,
             abortSignal: options.abortSignal,
             demoMode: options.demoMode,
+            memory: options.memory,
+            llmRouter: options.llmRouter,
         };
         try {
             // Execute the tool

package/dist/mcp/tools/chaos-resilience/inject.js

@@ -7,7 +7,7 @@
  * - ChaosEngineerService for fault injection and experiment execution
  */
 import { v4 as uuidv4 } from 'uuid';
-import { MCPToolBase, getSharedMemoryBackend } from '../base.js';
+import { MCPToolBase, getSharedMemoryBackend, getLLMRouter } from '../base.js';
 import { ChaosEngineerService } from '../../../domains/chaos-resilience/services/chaos-engineer.js';
 import { toErrorMessage } from '../../../shared/error-utils.js';
 // ============================================================================
@@ -26,7 +26,9 @@ export class ChaosInjectTool extends MCPToolBase {
     async getService(context) {
         if (!this.chaosEngineer) {
             const memory = context.memory || await getSharedMemoryBackend();
-            this.chaosEngineer = new ChaosEngineerService({ memory }, {
+            // ADR-043 wiring.
+            const llmRouter = await getLLMRouter(context);
+            this.chaosEngineer = new ChaosEngineerService({ memory, llmRouter }, {
                 enableDryRun: true,
                 autoRollbackOnFailure: true,
             });

package/dist/mcp/tools/code-intelligence/analyze.js

@@ -8,7 +8,7 @@
  * - SemanticAnalyzerService for semantic code search
  * - ImpactAnalyzerService for change impact analysis
  */
-import { MCPToolBase, getSharedMemoryBackend } from '../base';
+import { MCPToolBase, getSharedMemoryBackend, getLLMRouter } from '../base';
 import { KnowledgeGraphService } from '../../../domains/code-intelligence/services/knowledge-graph';
 import { SemanticAnalyzerService } from '../../../domains/code-intelligence/services/semantic-analyzer';
 import { ImpactAnalyzerService } from '../../../domains/code-intelligence/services/impact-analyzer';
@@ -35,8 +35,10 @@ export class CodeAnalyzeTool extends MCPToolBase {
      */
     async getKnowledgeGraph(context) {
         if (!this.knowledgeGraph) {
-            const memory = context.memory;
-            this.knowledgeGraph = new KnowledgeGraphService(memory || await getSharedMemoryBackend());
+            // ADR-043 wiring.
+            const memory = context.memory ?? await getSharedMemoryBackend();
+            const llmRouter = await getLLMRouter(context);
+            this.knowledgeGraph = new KnowledgeGraphService({ memory, llmRouter });
         }
         return this.knowledgeGraph;
     }

package/dist/mcp/tools/contract-testing/validate.js

@@ -7,7 +7,7 @@
  * - ContractValidatorService for contract/schema validation
  * - ApiCompatibilityService for breaking change detection
  */
-import { MCPToolBase, getSharedMemoryBackend } from '../base.js';
+import { MCPToolBase, getSharedMemoryBackend, getLLMRouter } from '../base.js';
 import { safeJsonParse } from '../../../shared/safe-json.js';
 import { Version } from '../../../shared/value-objects/index.js';
 import { ContractValidatorService } from '../../../domains/contract-testing/services/contract-validator.js';
@@ -67,7 +67,9 @@ export class ContractValidateTool extends MCPToolBase {
     async getServices(context) {
         if (!this.contractValidator || !this.apiCompatibility) {
             const memory = context.memory || await getSharedMemoryBackend();
-            this.contractValidator = new ContractValidatorService({ memory });
+            // ADR-043 wiring.
+            const llmRouter = await getLLMRouter(context);
+            this.contractValidator = new ContractValidatorService({ memory, llmRouter });
             this.apiCompatibility = new ApiCompatibilityService(memory);
         }
         return {

package/dist/mcp/tools/coverage-analysis/index.js

@@ -7,7 +7,7 @@
  * This module wraps the REAL coverage-analysis domain services.
  * Uses actual LCOV/JSON parsing and vector-based gap detection.
  */
-import { MCPToolBase, getSharedMemoryBackend } from '../base';
+import { MCPToolBase, getSharedMemoryBackend, getLLMRouter } from '../base';
 import { CoverageAnalyzerService } from '../../../domains/coverage-analysis/services/coverage-analyzer';
 import { GapDetectorService } from '../../../domains/coverage-analysis/services/gap-detector';
 import { findAndParseCoverage, parseCoverage, } from '../../../domains/coverage-analysis/services/coverage-parser';
@@ -83,8 +83,12 @@ export class CoverageAnalyzeTool extends MCPToolBase {
     analyzerService = null;
     async getService(context) {
         if (!this.analyzerService) {
-            const memory = context.memory;
-            this.analyzerService = new CoverageAnalyzerService(memory || await getSharedMemoryBackend());
+            // ADR-043 wiring: pull the shared HybridRouter (returns undefined
+            // when no provider key is present) so isLLMAnalysisAvailable()
+            // returns true in MCP mode the same way it does in kernel mode.
+            const memory = context.memory ?? await getSharedMemoryBackend();
+            const llmRouter = await getLLMRouter(context);
+            this.analyzerService = new CoverageAnalyzerService({ memory, llmRouter });
         }
         return this.analyzerService;
     }
@@ -296,8 +300,10 @@ export class CoverageGapsTool extends MCPToolBase {
     gapService = null;
     async getService(context) {
         if (!this.gapService) {
-            const memory = context.memory;
-            this.gapService = new GapDetectorService(memory || await getSharedMemoryBackend());
+            // ADR-043 wiring.
+            const memory = context.memory ?? await getSharedMemoryBackend();
+            const llmRouter = await getLLMRouter(context);
+            this.gapService = new GapDetectorService({ memory, llmRouter });
         }
         return this.gapService;
     }

package/dist/mcp/tools/defect-intelligence/predict.js

@@ -6,7 +6,7 @@
  * This tool wraps the REAL defect-intelligence domain service.
  * Uses actual code analysis, git history, and weighted feature prediction.
  */
-import { MCPToolBase, getSharedMemoryBackend } from '../base';
+import { MCPToolBase, getSharedMemoryBackend, getLLMRouter } from '../base';
 import { DefectPredictorService } from '../../../domains/defect-intelligence/services/defect-predictor';
 import { toErrorMessage } from '../../../shared/error-utils.js';
 // ============================================================================
@@ -44,15 +44,10 @@ export class DefectPredictTool extends MCPToolBase {
      */
     async getService(context) {
         if (!this.predictorService) {
-            // Create a memory backend from context or use shared persistent backend
-            const memory = context.memory;
-            if (memory) {
-                this.predictorService = new DefectPredictorService(memory);
-            }
-            else {
-                // Use shared persistent memory backend
-                this.predictorService = new DefectPredictorService(await getSharedMemoryBackend());
-            }
+            // ADR-043 wiring.
+            const memory = context.memory ?? await getSharedMemoryBackend();
+            const llmRouter = await getLLMRouter(context);
+            this.predictorService = new DefectPredictorService({ memory, llmRouter });
         }
         return this.predictorService;
     }

package/dist/mcp/tools/learning-optimization/optimize.js

@@ -8,7 +8,7 @@
  * - MetricsOptimizerService for strategy optimization
  * - TransferSpecialistService for knowledge transfer
  */
-import { MCPToolBase, getSharedMemoryBackend } from '../base.js';
+import { MCPToolBase, getSharedMemoryBackend, getLLMRouter } from '../base.js';
 import { TimeRange } from '../../../shared/value-objects/index.js';
 import { LearningCoordinatorService } from '../../../domains/learning-optimization/services/learning-coordinator.js';
 import { MetricsOptimizerService } from '../../../domains/learning-optimization/services/metrics-optimizer.js';
@@ -33,7 +33,9 @@ export class LearningOptimizeTool extends MCPToolBase {
     async getServices(context) {
         if (!this.learningCoordinator || !this.metricsOptimizer || !this.transferSpecialist) {
             const memory = context.memory || await getSharedMemoryBackend();
-            this.learningCoordinator = new LearningCoordinatorService({ memory });
+            // ADR-043 wiring.
+            const llmRouter = await getLLMRouter(context);
+            this.learningCoordinator = new LearningCoordinatorService({ memory, llmRouter });
             this.metricsOptimizer = new MetricsOptimizerService(memory);
             this.transferSpecialist = new TransferSpecialistService(memory);
         }

package/dist/mcp/tools/registry.js

@@ -166,7 +166,14 @@ export function registerAllQETools(registry) {
             category: 'domain',
             domain: tool.domain,
             lazyLoad: false, // QE tools are always available
-        }, async (params) => tool.invoke(params));
+        }, 
+        // ADR-043: forward the shared HybridRouter so the tool's
+        // MCPToolContext.llmRouter is populated explicitly.
+        async (params) => {
+            const { getSharedLLMRouter } = await import('./base.js');
+            const llmRouter = (await getSharedLLMRouter()) ?? undefined;
+            return tool.invoke(params, { llmRouter });
+        });
     }
 }
 /**

package/dist/mcp/tools/test-generation/generate.js

@@ -6,8 +6,8 @@
  * This tool wraps the test-generation domain service and exposes it via MCP.
  * Supports unit, integration, and e2e test generation with AI enhancement.
  */
-import { MCPToolBase, getSharedMemoryBackend } from '../base';
-import { createTestGeneratorService } from '../../../domains/test-generation/services/test-generator';
+import { MCPToolBase, getSharedMemoryBackend, getLLMRouter } from '../base';
+import { createTestGeneratorServiceWithDependencies } from '../../../domains/test-generation/services/test-generator';
 import { TokenOptimizerService } from '../../../optimization/token-optimizer-service.js';
 import { toErrorMessage } from '../../../shared/error-utils.js';
 // ============================================================================
@@ -27,10 +27,13 @@ export class TestGenerateTool extends MCPToolBase {
      * Initialize or get the test generator service with persistent storage
      * Uses factory function for proper dependency injection
      */
-    async getService() {
+    async getService(context) {
         if (!this.testGeneratorService) {
+            // ADR-043 wiring: dependencies factory accepts llmRouter so the
+            // ADR-051 LLM-enhanced generation branch is reachable in MCP mode.
             const memory = await getSharedMemoryBackend();
-            this.testGeneratorService = createTestGeneratorService(memory, {
+            const llmRouter = await getLLMRouter(context);
+            this.testGeneratorService = createTestGeneratorServiceWithDependencies({ memory, llmRouter }, {
                 defaultFramework: 'vitest',
                 maxTestsPerFile: 50,
                 coverageTargetDefault: 80,
@@ -71,8 +74,9 @@ export class TestGenerateTool extends MCPToolBase {
                         `saving ~${earlyExitResult.estimatedTokensSaved} tokens`);
                 }
             }
-            // Get the domain service and call it with the request
-            const service = await this.getService();
+            // Get the domain service and call it with the request.
+            // Pass context so ADR-043 llmRouter reaches the service.
+            const service = await this.getService(context);
             // Build the domain request from MCP params
             const domainRequest = {
                 sourceFiles,

package/dist/mcp/tools/visual-accessibility/index.js

@@ -8,8 +8,8 @@
  * - VisualTesterService for screenshot capture and comparison
  * - AccessibilityTesterService for WCAG compliance auditing
  */
-import { MCPToolBase, getSharedMemoryBackend } from '../base';
-import { createVisualTesterService } from '../../../domains/visual-accessibility/services/visual-tester';
+import { MCPToolBase, getSharedMemoryBackend, getLLMRouter } from '../base';
+import { createVisualTesterServiceWithDependencies } from '../../../domains/visual-accessibility/services/visual-tester';
 import { AccessibilityTesterService } from '../../../domains/visual-accessibility/services/accessibility-tester';
 import { toErrorMessage } from '../../../shared/error-utils.js';
 // ============================================================================
@@ -30,8 +30,11 @@ export class VisualCompareTool extends MCPToolBase {
      */
     async getService(context) {
         if (!this.visualTester) {
-            const memory = context.memory;
-            this.visualTester = createVisualTesterService(memory || await getSharedMemoryBackend());
+            // ADR-043 wiring: dependencies factory accepts llmRouter so the
+            // ADR-051 LLM-enhanced visual analysis branch is reachable in MCP mode.
+            const memory = context.memory ?? await getSharedMemoryBackend();
+            const llmRouter = await getLLMRouter(context);
+            this.visualTester = createVisualTesterServiceWithDependencies({ memory, llmRouter });
         }
         return this.visualTester;
     }

package/dist/shared/llm/llm-router-service.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Agentic QE v3 - LLM Router Service (kernel singleton)
+ *
+ * Thin wrapper around ProviderManager + HybridRouter that:
+ *   1. Loads RouterConfig via config-store (defaults <- disk <- env <- override)
+ *   2. Builds a ProviderManager whose enabled provider set matches what's
+ *      actually available (key in env OR explicitly enabled on disk)
+ *   3. Picks `primary` and `fallbacks` from the enabled set in a sensible
+ *      order, honoring the user's defaultProvider when possible
+ *   4. Constructs the HybridRouter and initializes it once
+ *
+ * This is what the QEKernelImpl instantiates and exposes as
+ * `kernel.llmRouter`. Domain plugins receive it via their factory's
+ * 4th argument and pass it down to coordinators/services so the
+ * isLLMAnalysisAvailable() branches in 14 services actually fire.
+ *
+ * Why a service wrapper rather than constructing HybridRouter inline
+ * in the kernel: the kernel already has too much going on, and the
+ * provider-selection + fallback-ordering logic is non-trivial enough
+ * to deserve its own test surface (see llm-router-service.test.ts).
+ */
+import { ProviderManager } from './provider-manager.js';
+import { HybridRouter } from './router/hybrid-router.js';
+import type { RouterConfig, ExtendedProviderType } from './router/types.js';
+/**
+ * Options accepted by createLLMRouterService(). All optional — defaults
+ * produce a router suitable for kernel boot when at least one provider
+ * key is in env.
+ */
+export interface LLMRouterServiceOptions {
+    /** Project root (used to find .agentic-qe/llm-config.json). Defaults to findProjectRoot(). */
+    projectRoot?: string;
+    /** Explicit config override (highest precedence). */
+    override?: Partial<RouterConfig>;
+    /** Custom env (for testing). Defaults to process.env. */
+    env?: NodeJS.ProcessEnv;
+    /**
+     * Inject a pre-built ProviderManager (for tests with mock providers).
+     * When supplied, config loading and provider construction is skipped.
+     */
+    providerManager?: ProviderManager;
+}
+/**
+ * Result of building a router. Carries the router plus the resolved
+ * config (useful for logging at boot) and the set of providers we
+ * actually wired up.
+ */
+export interface BuiltLLMRouter {
+    router: HybridRouter;
+    resolvedConfig: RouterConfig;
+    enabledProviders: ExtendedProviderType[];
+}
+/**
+ * Build (and initialize) a HybridRouter for use as the kernel singleton.
+ * Returns null when no providers are available — caller decides whether
+ * that's an error or a "router-disabled" boot.
+ */
+export declare function createLLMRouterService(options?: LLMRouterServiceOptions): Promise<BuiltLLMRouter | null>;
+/**
+ * Determine which providers are actually usable. A provider is enabled if:
+ *   - its config has `enabled: true`, AND
+ *   - it's either local (ollama, onnx) OR has a detected env key
+ *
+ * Returns a deduped list in FALLBACK_PRIORITY order with the user's
+ * defaultProvider hoisted to the front when present.
+ */
+export declare function pickEnabledProviders(config: RouterConfig, env?: NodeJS.ProcessEnv): ExtendedProviderType[];
+/**
+ * Choose the primary provider and fallback chain from the enabled set.
+ * Honors config.defaultProvider when it's in the enabled set, otherwise
+ * picks the first enabled provider in priority order.
+ */
+export declare function pickPrimaryAndFallbacks(config: RouterConfig, enabled: ExtendedProviderType[]): {
+    primary: ExtendedProviderType;
+    fallbacks: ExtendedProviderType[];
+};
+//# sourceMappingURL=llm-router-service.d.ts.map