agentic-qe 3.9.36 → 3.10.1

package/dist/shared/llm/llm-router-service.js

@@ -0,0 +1,166 @@
+/**
+ * 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 { loadRouterConfig, shouldEnableRouter, detectAvailableProvidersFromEnv, } from './router/config-store.js';
+/**
+ * Order in which we pick fallbacks when the user hasn't specified any.
+ * Local-first (free), then cheapest cloud, then richer providers. This
+ * is a defensive default; users who care should set
+ * `routerConfig.fallbackChain` explicitly.
+ */
+const FALLBACK_PRIORITY = [
+    'ollama',
+    'onnx',
+    'gemini',
+    'openrouter',
+    'openai',
+    'claude',
+    'azure-openai',
+    'bedrock',
+];
+/**
+ * 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 async function createLLMRouterService(options = {}) {
+    // Honor the test-injected ProviderManager path first.
+    if (options.providerManager) {
+        const config = loadRouterConfig({
+            projectRoot: options.projectRoot,
+            override: options.override,
+            env: options.env,
+        });
+        const router = new HybridRouter(options.providerManager, config);
+        await router.initialize();
+        return {
+            router,
+            resolvedConfig: config,
+            enabledProviders: providersFromConfig(config),
+        };
+    }
+    // Real path: detect env, load config, build provider manager.
+    if (!shouldEnableRouter({ projectRoot: options.projectRoot, env: options.env })) {
+        return null;
+    }
+    const config = loadRouterConfig({
+        projectRoot: options.projectRoot,
+        override: options.override,
+        env: options.env,
+    });
+    const enabled = pickEnabledProviders(config, options.env ?? process.env);
+    if (enabled.length === 0) {
+        return null;
+    }
+    const { primary, fallbacks } = pickPrimaryAndFallbacks(config, enabled);
+    const providerManagerConfig = {
+        primary: primary,
+        fallbacks: fallbacks,
+        providers: extractProviderConfigs(config, enabled),
+        loadBalancing: 'round-robin',
+        global: { enableCostTracking: true, enableMetrics: true },
+    };
+    const providerManager = new ProviderManager(providerManagerConfig);
+    const router = new HybridRouter(providerManager, config);
+    await router.initialize();
+    return {
+        router,
+        resolvedConfig: config,
+        enabledProviders: enabled,
+    };
+}
+/**
+ * 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 function pickEnabledProviders(config, env = process.env) {
+    const detected = detectAvailableProvidersFromEnv(env);
+    const result = [];
+    const consider = (p) => {
+        if (result.includes(p))
+            return;
+        const cfg = config.providers?.[p];
+        if (!cfg?.enabled)
+            return;
+        if (!detected.has(p))
+            return;
+        result.push(p);
+    };
+    // User's preferred default first
+    consider(config.defaultProvider);
+    // Then fallback chain order if user set it
+    for (const entry of config.fallbackChain?.entries ?? []) {
+        consider(entry.provider);
+    }
+    // Then our defensive priority
+    for (const p of FALLBACK_PRIORITY) {
+        consider(p);
+    }
+    return result;
+}
+/**
+ * Collect the unique provider list from a RouterConfig — used by the
+ * test-injected ProviderManager path where we don't run the env-detect
+ * filter.
+ */
+function providersFromConfig(config) {
+    const seen = new Set([config.defaultProvider]);
+    for (const entry of config.fallbackChain?.entries ?? []) {
+        seen.add(entry.provider);
+    }
+    return Array.from(seen);
+}
+/**
+ * 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 function pickPrimaryAndFallbacks(config, enabled) {
+    if (enabled.length === 0) {
+        throw new Error('pickPrimaryAndFallbacks: no enabled providers');
+    }
+    const preferred = enabled.includes(config.defaultProvider)
+        ? config.defaultProvider
+        : enabled[0];
+    const fallbacks = enabled.filter((p) => p !== preferred);
+    return { primary: preferred, fallbacks };
+}
+/**
+ * Extract only the provider configs for the enabled set, so
+ * ProviderManager doesn't try to construct providers we don't need.
+ */
+function extractProviderConfigs(config, enabled) {
+    const out = {};
+    for (const p of enabled) {
+        const cfg = config.providers?.[p];
+        if (cfg) {
+            out[p] = cfg;
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=llm-router-service.js.map

package/dist/shared/llm/providers/gemini.js

@@ -84,7 +84,7 @@ export class GeminiProvider {
         if (!apiKey) {
             return {
                 healthy: false,
-                error: 'API key not configured. Set GOOGLE_AI_API_KEY or GEMINI_API_KEY environment variable.',
+                error: 'API key not configured. Set GOOGLE_AI_API_KEY, GEMINI_API_KEY, or GOOGLE_API_KEY environment variable.',
             };
         }
         const start = Date.now();
@@ -438,7 +438,10 @@ export class GeminiProvider {
      * Get API key from config or environment
      */
     getApiKey() {
-        return this.config.apiKey ?? process.env.GOOGLE_AI_API_KEY ?? process.env.GEMINI_API_KEY;
+        return (this.config.apiKey ??
+            process.env.GOOGLE_AI_API_KEY ??
+            process.env.GEMINI_API_KEY ??
+            process.env.GOOGLE_API_KEY);
     }
     /**
      * Get base URL

package/dist/shared/llm/router/config-store.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Agentic QE v3 - LLM Router Config Store (ADR-043)
+ *
+ * Persistent storage and environment-aware merging for HybridRouter
+ * configuration. Lives next to the project's .agentic-qe/ data dir so
+ * each project can carry its own routing policy without leaking secrets.
+ *
+ * Precedence (highest wins):
+ *   1. Explicit override passed to loadRouterConfig()
+ *   2. Environment variables (provider API keys, AQE_LLM_* settings)
+ *   3. .agentic-qe/llm-config.json (project file)
+ *   4. DEFAULT_ROUTER_CONFIG from types.ts
+ *
+ * Provider enablement: a provider whose API key is present in the
+ * environment is force-enabled (overriding any disk value of `enabled:
+ * false`). A provider whose key is absent is left in its disk/default
+ * state — we don't disable it implicitly, because users may set keys
+ * later via `aqe llm config --set`.
+ */
+import type { RouterConfig, ExtendedProviderType } from './types.js';
+/** Filename under .agentic-qe/ */
+export declare const ROUTER_CONFIG_FILENAME = "llm-config.json";
+/**
+ * Return the resolved config-file path for a project.
+ * Caller may override projectRoot for tests; defaults to findProjectRoot().
+ */
+export declare function getRouterConfigPath(projectRoot?: string): string;
+/**
+ * Detect which providers have a non-empty API key in the current env.
+ * Ollama and ONNX always count as detected (they're local).
+ */
+export declare function detectAvailableProvidersFromEnv(env?: NodeJS.ProcessEnv): Set<ExtendedProviderType>;
+/**
+ * Load the project-level router config from disk. Returns the parsed
+ * partial config, or {} if the file doesn't exist or is unreadable.
+ * Malformed JSON throws — we don't silently corrupt user config.
+ */
+export declare function loadRouterConfigFile(projectRoot?: string): Partial<RouterConfig>;
+/**
+ * Save the project-level router config to disk. Creates the .agentic-qe
+ * directory if missing. Writes atomically via a temp-file + rename so a
+ * crashed write can't leave a half-written config behind.
+ *
+ * IMPORTANT: this file is project-local and may end up checked into the
+ * repo. Callers MUST NOT pass API keys in `config.providers[*].apiKey`
+ * — keys belong in env vars. We strip apiKey fields defensively.
+ */
+export declare function saveRouterConfigFile(config: Partial<RouterConfig>, projectRoot?: string): void;
+/**
+ * Merge a partial config onto a base. Provider entries are shallow-merged
+ * (so a partial provider override doesn't wipe the default model). The
+ * top-level scalars use last-wins.
+ */
+export declare function mergeRouterConfig(base: RouterConfig, override: Partial<RouterConfig>): RouterConfig;
+/**
+ * Apply env-detection on top of a merged config: providers whose API
+ * keys are present in env are force-enabled (so a user who sets
+ * GOOGLE_API_KEY doesn't also have to remember to flip gemini.enabled
+ * to true). Providers without keys are left at their existing setting.
+ *
+ * COUNTERINTUITIVE: env presence OVERRIDES an explicit `enabled: false`
+ * on disk. The reasoning: env is more recent / more authoritative than
+ * a stale checked-in config file, and users who set an API key in env
+ * usually intend to use the provider. To truly disable a provider that
+ * has a key in env, either unset the env key OR set the env-only
+ * kill-switch `AQE_LLM_ROUTER_DISABLED=1` (which disables the entire
+ * router). This precedence is documented in ADR-043's addendum.
+ */
+export declare function applyEnvProviderDetection(config: RouterConfig, env?: NodeJS.ProcessEnv): RouterConfig;
+/**
+ * The full load path: defaults <- disk <- env detection <- override.
+ * This is what the kernel and CLI both call. Returns a fully-resolved
+ * RouterConfig ready to hand to HybridRouter.
+ */
+export declare function loadRouterConfig(options?: {
+    projectRoot?: string;
+    override?: Partial<RouterConfig>;
+    env?: NodeJS.ProcessEnv;
+}): RouterConfig;
+/**
+ * Quick check used by the kernel to decide whether to construct a
+ * router at all. Returns true if at least one non-local provider has
+ * a key in env, OR the disk config explicitly enables a provider.
+ */
+export declare function shouldEnableRouter(options?: {
+    projectRoot?: string;
+    env?: NodeJS.ProcessEnv;
+}): boolean;
+//# sourceMappingURL=config-store.d.ts.map

package/dist/shared/llm/router/config-store.js

@@ -0,0 +1,261 @@
+/**
+ * Agentic QE v3 - LLM Router Config Store (ADR-043)
+ *
+ * Persistent storage and environment-aware merging for HybridRouter
+ * configuration. Lives next to the project's .agentic-qe/ data dir so
+ * each project can carry its own routing policy without leaking secrets.
+ *
+ * Precedence (highest wins):
+ *   1. Explicit override passed to loadRouterConfig()
+ *   2. Environment variables (provider API keys, AQE_LLM_* settings)
+ *   3. .agentic-qe/llm-config.json (project file)
+ *   4. DEFAULT_ROUTER_CONFIG from types.ts
+ *
+ * Provider enablement: a provider whose API key is present in the
+ * environment is force-enabled (overriding any disk value of `enabled:
+ * false`). A provider whose key is absent is left in its disk/default
+ * state — we don't disable it implicitly, because users may set keys
+ * later via `aqe llm config --set`.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { findProjectRoot } from '../../../kernel/unified-memory.js';
+import { DEFAULT_ROUTER_CONFIG, ALL_PROVIDER_TYPES } from './types.js';
+/** Filename under .agentic-qe/ */
+export const ROUTER_CONFIG_FILENAME = 'llm-config.json';
+/**
+ * Env var names per provider — multiple aliases supported where the
+ * upstream provider accepts more than one name. First non-empty wins.
+ *
+ * Empty array means "local provider, no key required". The set of
+ * runtime-constructible providers is narrower than ExtendedProviderType
+ * (e.g. onnx is in the type system but ProviderManager doesn't yet
+ * have a case for it) — see RUNTIME_CONSTRUCTIBLE_PROVIDERS below.
+ */
+const PROVIDER_ENV_KEYS = {
+    claude: ['ANTHROPIC_API_KEY', 'CLAUDE_API_KEY'],
+    openai: ['OPENAI_API_KEY'],
+    ollama: [], // ollama is local; no key required
+    openrouter: ['OPENROUTER_API_KEY'],
+    gemini: ['GOOGLE_AI_API_KEY', 'GEMINI_API_KEY', 'GOOGLE_API_KEY'],
+    'azure-openai': ['AZURE_OPENAI_API_KEY'],
+    bedrock: ['AWS_ACCESS_KEY_ID'], // bedrock auth is more complex; presence is a hint
+    onnx: [], // local
+};
+/**
+ * Providers that ProviderManager.createProvider() can actually
+ * instantiate today. Anything not in this set is dropped from the
+ * "available" set even if its env keys are present, so we don't emit
+ * a "Failed to create X provider" warning at every kernel boot.
+ *
+ * Keep this in sync with src/shared/llm/provider-manager.ts:createProvider().
+ */
+const RUNTIME_CONSTRUCTIBLE_PROVIDERS = new Set([
+    'claude',
+    'openai',
+    'ollama',
+    'openrouter',
+    'gemini',
+    'azure-openai',
+    'bedrock',
+]);
+/**
+ * Return the resolved config-file path for a project.
+ * Caller may override projectRoot for tests; defaults to findProjectRoot().
+ */
+export function getRouterConfigPath(projectRoot) {
+    const root = projectRoot ?? findProjectRoot();
+    return path.join(root, '.agentic-qe', ROUTER_CONFIG_FILENAME);
+}
+/**
+ * Detect which providers have a non-empty API key in the current env.
+ * Ollama and ONNX always count as detected (they're local).
+ */
+export function detectAvailableProvidersFromEnv(env = process.env) {
+    const available = new Set();
+    for (const provider of ALL_PROVIDER_TYPES) {
+        if (!RUNTIME_CONSTRUCTIBLE_PROVIDERS.has(provider)) {
+            // ProviderManager has no case for this provider yet (e.g. onnx).
+            // Pretending it's available leads to "Failed to create" noise.
+            continue;
+        }
+        const keys = PROVIDER_ENV_KEYS[provider];
+        if (keys.length === 0) {
+            // local providers — always available if their binary is, but at
+            // config-merge time we treat them as "potentially available"
+            available.add(provider);
+            continue;
+        }
+        if (keys.some((k) => (env[k] ?? '').trim().length > 0)) {
+            available.add(provider);
+        }
+    }
+    return available;
+}
+/**
+ * Load the project-level router config from disk. Returns the parsed
+ * partial config, or {} if the file doesn't exist or is unreadable.
+ * Malformed JSON throws — we don't silently corrupt user config.
+ */
+export function loadRouterConfigFile(projectRoot) {
+    const filePath = getRouterConfigPath(projectRoot);
+    if (!fs.existsSync(filePath)) {
+        return {};
+    }
+    const raw = fs.readFileSync(filePath, 'utf8');
+    if (!raw.trim()) {
+        return {};
+    }
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== 'object' || parsed === null) {
+        throw new Error(`Invalid ${ROUTER_CONFIG_FILENAME}: expected object, got ${typeof parsed}`);
+    }
+    return parsed;
+}
+/**
+ * Save the project-level router config to disk. Creates the .agentic-qe
+ * directory if missing. Writes atomically via a temp-file + rename so a
+ * crashed write can't leave a half-written config behind.
+ *
+ * IMPORTANT: this file is project-local and may end up checked into the
+ * repo. Callers MUST NOT pass API keys in `config.providers[*].apiKey`
+ * — keys belong in env vars. We strip apiKey fields defensively.
+ */
+export function saveRouterConfigFile(config, projectRoot) {
+    const filePath = getRouterConfigPath(projectRoot);
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const sanitized = stripApiKeys(config);
+    const json = JSON.stringify(sanitized, null, 2) + '\n';
+    const tmp = filePath + '.tmp-' + process.pid;
+    fs.writeFileSync(tmp, json, { encoding: 'utf8', mode: 0o600 });
+    fs.renameSync(tmp, filePath);
+}
+/**
+ * Strip apiKey fields from provider configs to prevent accidental
+ * commits of secrets. Returns a deep clone — input is untouched.
+ *
+ * Emits a console warning when any apiKey is stripped, so silent
+ * strips don't surprise callers. The kernel/CLI consume from env
+ * vars (ANTHROPIC_API_KEY, GEMINI_API_KEY, GOOGLE_API_KEY, etc.),
+ * never from disk config — see config-store doc header for the
+ * precedence rule.
+ */
+function stripApiKeys(config) {
+    if (!config.providers) {
+        return JSON.parse(JSON.stringify(config));
+    }
+    const cloned = JSON.parse(JSON.stringify(config));
+    let strippedProviders = [];
+    if (cloned.providers) {
+        for (const provider of Object.keys(cloned.providers)) {
+            const entry = cloned.providers[provider];
+            if (entry && 'apiKey' in entry && entry.apiKey) {
+                delete entry.apiKey;
+                strippedProviders.push(provider);
+            }
+        }
+    }
+    if (strippedProviders.length > 0) {
+        // eslint-disable-next-line no-console
+        console.warn(`[router-config] Refused to persist apiKey for: ${strippedProviders.join(', ')}. ` +
+            `API keys belong in environment variables (e.g. ANTHROPIC_API_KEY, GEMINI_API_KEY, ` +
+            `OPENAI_API_KEY, OPENROUTER_API_KEY), NOT in .agentic-qe/llm-config.json which may ` +
+            `be checked into source control.`);
+    }
+    return cloned;
+}
+/**
+ * Merge a partial config onto a base. Provider entries are shallow-merged
+ * (so a partial provider override doesn't wipe the default model). The
+ * top-level scalars use last-wins.
+ */
+export function mergeRouterConfig(base, override) {
+    const merged = {
+        ...base,
+        ...override,
+        providers: { ...(base.providers ?? {}) },
+    };
+    if (override.providers) {
+        for (const [provider, cfg] of Object.entries(override.providers)) {
+            if (!cfg)
+                continue;
+            const key = provider;
+            merged.providers[key] = {
+                ...(base.providers?.[key] ?? {}),
+                ...cfg,
+            };
+        }
+    }
+    return merged;
+}
+/**
+ * Apply env-detection on top of a merged config: providers whose API
+ * keys are present in env are force-enabled (so a user who sets
+ * GOOGLE_API_KEY doesn't also have to remember to flip gemini.enabled
+ * to true). Providers without keys are left at their existing setting.
+ *
+ * COUNTERINTUITIVE: env presence OVERRIDES an explicit `enabled: false`
+ * on disk. The reasoning: env is more recent / more authoritative than
+ * a stale checked-in config file, and users who set an API key in env
+ * usually intend to use the provider. To truly disable a provider that
+ * has a key in env, either unset the env key OR set the env-only
+ * kill-switch `AQE_LLM_ROUTER_DISABLED=1` (which disables the entire
+ * router). This precedence is documented in ADR-043's addendum.
+ */
+export function applyEnvProviderDetection(config, env = process.env) {
+    const available = detectAvailableProvidersFromEnv(env);
+    const merged = {
+        ...config,
+        providers: { ...(config.providers ?? {}) },
+    };
+    for (const provider of available) {
+        const keys = PROVIDER_ENV_KEYS[provider];
+        if (keys.length === 0)
+            continue; // local provider, leave default
+        const current = merged.providers[provider] ?? { enabled: false };
+        if (!current.enabled) {
+            merged.providers[provider] = { ...current, enabled: true };
+        }
+    }
+    return merged;
+}
+/**
+ * The full load path: defaults <- disk <- env detection <- override.
+ * This is what the kernel and CLI both call. Returns a fully-resolved
+ * RouterConfig ready to hand to HybridRouter.
+ */
+export function loadRouterConfig(options = {}) {
+    const onDisk = loadRouterConfigFile(options.projectRoot);
+    const merged = mergeRouterConfig(DEFAULT_ROUTER_CONFIG, onDisk);
+    const withEnv = applyEnvProviderDetection(merged, options.env);
+    return options.override ? mergeRouterConfig(withEnv, options.override) : withEnv;
+}
+/**
+ * Quick check used by the kernel to decide whether to construct a
+ * router at all. Returns true if at least one non-local provider has
+ * a key in env, OR the disk config explicitly enables a provider.
+ */
+export function shouldEnableRouter(options = {}) {
+    const env = options.env ?? process.env;
+    for (const provider of ALL_PROVIDER_TYPES) {
+        const keys = PROVIDER_ENV_KEYS[provider];
+        if (keys.length === 0)
+            continue;
+        if (keys.some((k) => (env[k] ?? '').trim().length > 0)) {
+            return true;
+        }
+    }
+    // No env keys — fall back to disk config.
+    const onDisk = loadRouterConfigFile(options.projectRoot);
+    if (onDisk.providers) {
+        for (const cfg of Object.values(onDisk.providers)) {
+            if (cfg?.enabled)
+                return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=config-store.js.map

package/dist/shared/llm/router/hybrid-router.js

@@ -443,16 +443,31 @@ export class HybridRouter {
         const executionOrder = [
             { provider: decision.providerType, model: decision.providerModelId },
         ];
-        // Add fallback chain entries
+        // ADR-043 wiring fix: always include the user's defaultProvider as
+        // an implicit fallback. Without this, a request that matches a rule
+        // routing to provider X (e.g. small-requests-haiku → claude) but
+        // where X fails at API time has no way to recover for users who
+        // only have a non-X provider configured. This was a real bug
+        // surfaced by the rule-based E2E test in
+        // tests/e2e/llm-router-real-providers.test.ts.
+        const defaultProviderType = this.config.defaultProvider;
+        if (defaultProviderType && defaultProviderType !== decision.providerType) {
+            executionOrder.push({
+                provider: defaultProviderType,
+                model: this.config.defaultModel,
+            });
+        }
+        // Add explicit fallback chain entries. Previously this hardcoded
+        // ['claude', 'openai', 'ollama'] as "base providers" — but
+        // LLMProviderType includes 7 providers (claude/openai/ollama plus
+        // openrouter/gemini/azure-openai/bedrock from ADR-043) and
+        // ProviderManager.createProvider() builds all of them. The narrower
+        // list silently excluded users' actual fallback providers.
         for (const entry of fallbackChain.entries) {
             if (!entry.enabled)
                 continue;
             if (entry.provider === decision.providerType)
                 continue;
-            // Only include providers that exist in the base system
-            const baseProviders = ['claude', 'openai', 'ollama'];
-            if (!baseProviders.includes(entry.provider))
-                continue;
             for (const model of entry.models) {
                 executionOrder.push({ provider: entry.provider, model });
             }
@@ -529,12 +544,19 @@ export class HybridRouter {
                         this.routerMetrics.recordFallback(providerType, nextProvider.provider, lastError.message, params.agentType);
                     }
                 }
-                // Check if error is retryable
-                if (isLLMError(error) && !error.retryable) {
-                    throw error;
-                }
-                // Delay before retry
-                if (attempts < fallbackBehavior.maxAttempts) {
+                // ADR-043 wiring fix: a non-retryable error from ONE provider
+                // (e.g. Claude returning "invalid x-api-key") tells us only that
+                // re-trying Claude is pointless — it does NOT tell us whether
+                // the NEXT provider in the fallback chain (e.g. Gemini) will
+                // work. Previously this `throw` short-circuited the fallback
+                // loop, defeating the whole point of having a fallback chain
+                // for users with multiple providers configured.
+                //
+                // New behavior: a non-retryable error skips the inter-attempt
+                // delay (because no need to wait) but DOES continue to the next
+                // entry in executionOrder. Only retryable errors get the delay.
+                const nonRetryable = isLLMError(error) && !error.retryable;
+                if (!nonRetryable && attempts < fallbackBehavior.maxAttempts) {
                     await this.delay(fallbackBehavior.delayMs);
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-qe",
-  "version": "3.9.36",
+  "version": "3.10.1",
   "description": "Agentic Quality Engineering V3 - Domain-Driven Design Architecture with 13 Bounded Contexts, O(log n) coverage analysis, ReasoningBank learning, 60 specialized QE agents, mathematical Coherence verification, deep Claude Flow integration",
   "type": "module",
   "main": "./dist/index.js",

package/dist/cli/chunks/adapter-MISKG4JY.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.9.36");process.exit(0)}
-import{a,b,c}from"./chunk-CLATNP57.js";import"./chunk-AH3UC4IV.js";import"./chunk-W2DF6FNE.js";import"./chunk-HOZNVDFF.js";import"./chunk-O4C3JEOR.js";import"./chunk-SCBWRKPE.js";export{a as AgentBoosterAdapter,b as createAgentBoosterAdapter,c as createAgentBoosterAdapterSync};

package/dist/cli/chunks/aqe-learning-engine-NDLBNM6C.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.9.36");process.exit(0)}
-import{a,b,c,d,e,f}from"./chunk-P4VQTIJE.js";import"./chunk-TU2PSEDW.js";import"./chunk-OO2JHVMS.js";import"./chunk-SJ3SHZUC.js";import"./chunk-MJJAHA2T.js";import"./chunk-C2JK5O55.js";import"./chunk-TK7TGVVQ.js";import"./chunk-BUVY7IGM.js";import"./chunk-4R3WXD4U.js";import"./chunk-LIE24NRL.js";import"./chunk-AJ2VFSLX.js";import"./chunk-L3JJ52N6.js";import"./chunk-MFPVS2KP.js";import"./chunk-USLHYNYG.js";import"./chunk-5MSZREOD.js";import"./chunk-QAGAEAKM.js";import"./chunk-HOZNVDFF.js";import"./chunk-5SYH5QMQ.js";import"./chunk-ZYPSXPQ5.js";import"./chunk-VENEJ3UI.js";import"./chunk-QMUTKI34.js";import"./chunk-O4C3JEOR.js";import"./chunk-NKA3X6VT.js";import"./chunk-TXSVZYFA.js";import"./chunk-RCU5L7FF.js";import"./chunk-Y4ERDIPP.js";import"./chunk-3CIQ6CQ4.js";import"./chunk-IF4ZZ2HD.js";import"./chunk-KI6RXKP4.js";import"./chunk-DTJHO3WI.js";import"./chunk-X6UGFKHW.js";import"./chunk-ZBY4HSHR.js";import"./chunk-SCBWRKPE.js";export{b as AQELearningEngine,a as DEFAULT_ENGINE_CONFIG,c as DEFAULT_META_LEARNING_CONFIG,d as MetaLearningEngine,e as createAQELearningEngine,f as createDefaultLearningEngine};

package/dist/cli/chunks/base-OMDJAHGF.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.9.36");process.exit(0)}
-import{a,b,c,d,e,f}from"./chunk-JD3VV2BD.js";import"./chunk-QH7K2UPP.js";import"./chunk-5MSZREOD.js";import"./chunk-QAGAEAKM.js";import"./chunk-HOZNVDFF.js";import"./chunk-ZYPSXPQ5.js";import"./chunk-VENEJ3UI.js";import"./chunk-O4C3JEOR.js";import"./chunk-NKA3X6VT.js";import"./chunk-TXSVZYFA.js";import"./chunk-RCU5L7FF.js";import"./chunk-Y4ERDIPP.js";import"./chunk-3CIQ6CQ4.js";import"./chunk-IF4ZZ2HD.js";import"./chunk-KI6RXKP4.js";import"./chunk-DTJHO3WI.js";import"./chunk-X6UGFKHW.js";import"./chunk-ZBY4HSHR.js";import"./chunk-SCBWRKPE.js";export{f as MCPToolBase,e as defaultToolLogger,d as getMemoryBackend,b as getSharedMemoryBackend,a as registerRvfResetFn,c as resetSharedMemoryBackend};

package/dist/cli/chunks/browser-workflow-XUG5Z5CJ.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.9.36");process.exit(0)}
-import{a}from"./chunk-BI54GWTK.js";import"./chunk-JD3VV2BD.js";import"./chunk-QH7K2UPP.js";import"./chunk-5MSZREOD.js";import"./chunk-QAGAEAKM.js";import"./chunk-HOZNVDFF.js";import"./chunk-ZYPSXPQ5.js";import"./chunk-VENEJ3UI.js";import"./chunk-O4C3JEOR.js";import"./chunk-NKA3X6VT.js";import"./chunk-TXSVZYFA.js";import"./chunk-RCU5L7FF.js";import"./chunk-Y4ERDIPP.js";import"./chunk-3CIQ6CQ4.js";import"./chunk-IF4ZZ2HD.js";import"./chunk-KI6RXKP4.js";import"./chunk-DTJHO3WI.js";import"./chunk-X6UGFKHW.js";import"./chunk-ZBY4HSHR.js";import"./chunk-SCBWRKPE.js";export{a as BrowserWorkflowTool};

package/dist/cli/chunks/chunk-JD3VV2BD.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.9.36");process.exit(0)}
-import{a as M}from"./chunk-QH7K2UPP.js";import{f as y,o as T}from"./chunk-5MSZREOD.js";import{a as p,c as S}from"./chunk-O4C3JEOR.js";import{i as b}from"./chunk-NKA3X6VT.js";T();S();import*as c from"path";import*as d from"fs";var m=null,u=null,l=null;function R(o){l=o}async function P(){return m||u||(u=(async()=>{let o=y(),e=c.join(o,".agentic-qe");d.existsSync(e)||d.mkdirSync(e,{recursive:!0});let r=new M({sqlite:{path:c.join(e,"memory.db"),walMode:!0,poolSize:3,busyTimeout:5e3},enableFallback:!0,defaultNamespace:"mcp-tools"});return await r.initialize(),m=r,r})(),u)}function $(){if(l)try{l()}catch{}m&&(m.dispose().catch(()=>{}),m=null),u=null}async function D(o){return o?.memory?o.memory:P()}var C={info:(o,e)=>console.log(`[MCP-TOOL] ${o}`,e||""),warn:(o,e)=>console.warn(`[MCP-TOOL] \u26A0\uFE0F ${o}`,e||""),error:(o,e)=>console.error(`[MCP-TOOL] \u274C ${o}`,e||"")},h=class{logger=C;currentDataSource="real";setLogger(e){this.logger=e}markAsDemoData(e,r){this.currentDataSource=e.demoMode?"demo":"fallback",this.logger.warn(`${this.config.name} returning ${this.currentDataSource} data`,{reason:r,requestId:e.requestId,demoMode:e.demoMode})}markAsRealData(){this.currentDataSource="real"}isDemoMode(e){return e.demoMode===!0}validate(e){let r=[];if(typeof e!="object"||e===null)return{valid:!1,errors:["Parameters must be an object"]};let t=e,{properties:a,required:n}=this.config.schema;if(n)for(let i of n)i in t||r.push(`Missing required field: ${i}`);for(let[i,s]of Object.entries(t)){let g=a[i];if(!g)continue;let f=this.validateType(i,s,g);f&&r.push(f)}return{valid:r.length===0,errors:r}}validateType(e,r,t){if(r==null)return null;let a=Array.isArray(r)?"array":typeof r;if(t.type==="array"&&!Array.isArray(r))return`${e} must be an array`;if(t.type!=="array"&&a!==t.type)return`${e} must be of type ${t.type}, got ${a}`;if(t.enum&&!t.enum.includes(r))return`${e} must be one of: ${t.enum.join(", ")}`;if(t.type==="number"){let n=r;if(t.minimum!==void 0&&n<t.minimum)return`${e} must be >= ${t.minimum}`;if(t.maximum!==void 0&&n>t.maximum)return`${e} must be <= ${t.maximum}`}if(t.type==="string"){let n=r;if(t.minLength!==void 0&&n.length<t.minLength)return`${e} must be at least ${t.minLength} characters`;if(t.maxLength!==void 0&&n.length>t.maxLength)return`${e} must be at most ${t.maxLength} characters`}return null}async invoke(e,r={}){let t=Date.now(),a=b();this.currentDataSource="real";let n=this.validate(e);if(!n.valid)return{success:!1,error:`Validation failed: ${n.errors.join("; ")}`,metadata:this.createMetadata(t,a)};let i={requestId:a,startTime:t,streaming:r.streaming,onStream:r.onStream,abortSignal:r.abortSignal,demoMode:r.demoMode};try{let s=await this.execute(e,i);return{...s,metadata:{...s.metadata,...this.createMetadata(t,a)}}}catch(s){return{success:!1,error:p(s),metadata:this.createMetadata(t,a)}}}createMetadata(e,r){return{executionTime:Date.now()-e,timestamp:new Date().toISOString(),requestId:r,domain:this.config.domain,toolName:this.config.name,dataSource:this.currentDataSource}}emitStream(e,r){e.streaming&&e.onStream&&e.onStream(r)}isAborted(e){return e.abortSignal?.aborted??!1}get name(){return this.config.name}get description(){return this.config.description}get domain(){return this.config.domain}getSchema(){return this.config.schema}get timeout(){return this.config.timeout??6e4}get supportsStreaming(){return this.config.streaming??!1}resetInstanceCache(){}};export{R as a,P as b,$ as c,D as d,C as e,h as f};

package/dist/cli/chunks/chunk-USLHYNYG.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.9.36");process.exit(0)}
-import{a as F,c as D}from"./chunk-O4C3JEOR.js";import{d as $}from"./chunk-KI6RXKP4.js";$();D();var b=null,l=null,d=null,g=!1,f="",h={modelName:"Xenova/all-MiniLM-L6-v2",quantized:!0,enableCache:!0,maxCacheSize:1e4},o=new Map,P=36e5;function I(t){let e=t.trim();return!!(e.startsWith("{")&&/["']metrics["']/.test(e)||e.startsWith("[")&&e.endsWith("]")&&e.length>50||(e.match(/[a-zA-Z]/g)||[]).length/Math.max(e.length,1)<.3&&e.length>20)}async function A(t={}){if(g)throw new Error(`Transformer initialization previously failed: ${f}`);if(d)return d;let e={...h,...t};return d=(async()=>{try{b=(await import("./transformers-5CWLXT2M.js")).pipeline,console.log(`[RealEmbeddings] Loading model: ${e.modelName}`);let a=performance.now();l=await b("feature-extraction",e.modelName,{quantized:e.quantized});let s=performance.now()-a;console.log(`[RealEmbeddings] Model loaded in ${s.toFixed(0)}ms`)}catch(r){throw g=!0,f=F(r),new Error(`Failed to initialize transformer model: ${f}`)}})(),d}async function q(t,e={}){let r={...h,...e};if(I(t))return new Array(N()).fill(0);if(r.enableCache){let i=o.get(t);if(i&&Date.now()-i.timestamp<P)return i.embedding}if(l||await A(e),!l)throw new Error("Embedding model failed to initialize");let a=performance.now(),s=await l(t,{pooling:"mean",normalize:!0}),m=Array.from(s.data),n=performance.now()-a;if(n>500&&console.warn(`[RealEmbeddings] Slow embedding computation: ${n.toFixed(1)}ms for "${t.slice(0,50)}..."`),r.enableCache){if(o.size>=r.maxCacheSize){let i=o.keys().next().value;i&&o.delete(i)}o.set(t,{embedding:m,timestamp:Date.now()})}return m}async function B(t,e={}){let r={...h,...e},a=[],s=[],m=new Array(t.length).fill(null);if(r.enableCache)for(let n=0;n<t.length;n++){let i=o.get(t[n]);i&&Date.now()-i.timestamp<P?m[n]=i.embedding:(a.push(t[n]),s.push(n))}else{a.push(...t);for(let n=0;n<t.length;n++)s.push(n)}if(a.length>0){if(l||await A(e),!l)throw new Error("Embedding model failed to initialize");let n=performance.now(),i=32;for(let c=0;c<a.length;c+=i){let M=Math.min(c+i,a.length),p=a.slice(c,M),E=await l(p,{pooling:"mean",normalize:!0}),w=E.dims||[p.length,384],R=w[0],C=w[1];for(let u=0;u<R;u++){let z=u*C,x=Array.from(E.data.slice(z,z+C)),y=c+u,v=s[y];if(m[v]=x,r.enableCache){if(o.size>=r.maxCacheSize){let T=o.keys().next().value;T&&o.delete(T)}o.set(a[y],{embedding:x,timestamp:Date.now()})}}}let S=performance.now()-n;console.log(`[RealEmbeddings] Batch computed ${a.length} embeddings in ${S.toFixed(0)}ms`)}return m.filter(n=>n!==null)}function O(){o.clear(),console.log("[RealEmbeddings] Cache cleared")}function W(){return{size:o.size,hitRate:0}}function k(){return!g&&l!==null}function N(){return 384}function G(){b=null,l=null,d=null,g=!1,f="",o.clear()}export{h as a,q as b,B as c,O as d,W as e,k as f,N as g,G as h};

package/dist/cli/chunks/chunk-ZYPSXPQ5.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.9.36");process.exit(0)}
-import{a as e,b as g,e as r}from"./chunk-VENEJ3UI.js";import{c as o}from"./chunk-SCBWRKPE.js";var L=o(()=>{"use strict";e();g();r()});export{L as a};

package/dist/cli/chunks/client-VXJRAW3W.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.9.36");process.exit(0)}
-import{c as a,d as b,e as c}from"./chunk-YMB4YVFX.js";import"./chunk-RDXIRE2I.js";import"./chunk-O4C3JEOR.js";import"./chunk-SCBWRKPE.js";c();export{a as VibiumClientImpl,b as VibiumClientProvider};