@st-gr/sail-proxy 0.9.3 → 0.9.4

package/bundled/gateway/services/gateway/src/services/betaFlagQuarantine.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQuarantinedFlags = getQuarantinedFlags;
+exports.quarantineFlags = quarantineFlags;
+exports.clearQuarantine = clearQuarantine;
+exports.isInvalidBetaFlagError = isInvalidBetaFlagError;
+exports.resolveRejectedFlags = resolveRejectedFlags;
+exports.recordBetaFlagRejection = recordBetaFlagRejection;
+/**
+ * In-memory quarantine for anthropic_beta flags rejected by SAP AI Core.
+ *
+ * When SAP (AWS Bedrock behind it) rejects a request with HTTP 400
+ * "invalid beta flag", the flags that were sent are quarantined for that
+ * model so subsequent requests omit them and succeed. Keyed by modelId
+ * because Bedrock's flag acceptance differs per model version.
+ *
+ * Process-local and reset on restart — a self-healing stopgap, not
+ * configuration. Entries also auto-expire after 30 minutes so a
+ * false-positive detection can't silently degrade capabilities forever.
+ * Operators should promote quarantined flags to
+ * anthropic.excluded_beta_headers (admin UI, hot-reloaded) permanently.
+ */
+const logger_1 = require("@libs/logger");
+const logger = (0, logger_1.getDefaultLogger)();
+// False positives happen: an unrelated 400 whose body merely mentions
+// "anthropic_beta" would otherwise quarantine valid flags forever (until
+// pod restart), silently degrading capabilities like the 1M context window.
+// A 30-minute TTL bounds the blast radius of any single misdetection. The
+// permanent mechanism for genuinely unsupported flags is the config
+// denylist (anthropic.excluded_beta_headers), not this in-memory cache.
+const QUARANTINE_TTL_MS = 30 * 60 * 1000;
+const quarantinedByModel = new Map();
+function getQuarantinedFlags(modelId) {
+    const flags = quarantinedByModel.get(modelId);
+    if (!flags) {
+        return [];
+    }
+    const now = Date.now();
+    const live = [];
+    for (const [flag, quarantinedAt] of flags) {
+        if (now - quarantinedAt >= QUARANTINE_TTL_MS) {
+            flags.delete(flag);
+        }
+        else {
+            live.push(flag);
+        }
+    }
+    if (flags.size === 0) {
+        quarantinedByModel.delete(modelId);
+    }
+    return live;
+}
+function quarantineFlags(modelId, flags) {
+    if (flags.length === 0) {
+        return;
+    }
+    const now = Date.now();
+    const map = quarantinedByModel.get(modelId) ?? new Map();
+    for (const flag of flags) {
+        map.set(flag, now);
+    }
+    quarantinedByModel.set(modelId, map);
+}
+function clearQuarantine() {
+    quarantinedByModel.clear();
+}
+function serializeErrorData(errorData) {
+    if (typeof errorData === 'string') {
+        return errorData;
+    }
+    try {
+        return JSON.stringify(errorData) ?? '';
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Whether an upstream error response is a beta-flag rejection.
+ */
+function isInvalidBetaFlagError(status, errorData) {
+    if (status !== 400) {
+        return false;
+    }
+    return /invalid beta flag|anthropic[-_]beta/i.test(serializeErrorData(errorData));
+}
+/**
+ * Flags to quarantine: those explicitly named in the error body when present
+ * (first-party-style errors name them), else all flags that were sent
+ * (Bedrock's bare "invalid beta flag" names none).
+ */
+function resolveRejectedFlags(errorData, sentFlags) {
+    if (sentFlags.length === 0) {
+        return [];
+    }
+    const serialized = serializeErrorData(errorData);
+    const named = sentFlags.filter(flag => serialized.includes(flag));
+    return named.length > 0 ? named : [...sentFlags];
+}
+/**
+ * Record a beta-flag rejection so subsequent requests for this model omit
+ * the offending flags. Returns the quarantined flags.
+ */
+function recordBetaFlagRejection(modelId, errorData, sentFlags) {
+    const rejected = resolveRejectedFlags(errorData, sentFlags);
+    quarantineFlags(modelId, rejected);
+    logger.warn('BetaFlagQuarantine', `Quarantined ${rejected.length} beta flag(s) for model ${modelId} after upstream 400: ${rejected.join(', ')}. ` +
+        `Subsequent requests omit them (in-memory, resets on restart or after 30 minutes). ` +
+        `Add them to anthropic.excluded_beta_headers via the admin UI to make this permanent.`);
+    return rejected;
+}

package/bundled/gateway/services/gateway/src/services/configService.d.ts

@@ -111,6 +111,13 @@ export declare const getAnthropicBedrockVersion: () => string;
  * @returns Array of beta header values to filter out
  */
 export declare const getExcludedBetaHeaders: () => string[];
+/**
+ * Get supported (allowlisted) beta headers for Anthropic requests to SAP AI Core.
+ * When non-empty, only these beta flags are forwarded; the excluded_beta_headers
+ * denylist is still applied on top. Empty/absent means no allowlist filtering.
+ * @returns Array of allowlisted beta header values
+ */
+export declare const getSupportedBetaHeaders: () => string[];
 export declare const getOpenAIDeploymentApiVersion: () => string | undefined;
 /**
  * Get all provider configurations
@@ -201,6 +208,7 @@ declare const _default: {
     shouldEmulateStreaming: (provider: string, modelName: string) => boolean;
     getAnthropicBedrockVersion: () => string;
     getExcludedBetaHeaders: () => string[];
+    getSupportedBetaHeaders: () => string[];
     getOpenAIDeploymentApiVersion: () => string | undefined;
     getAllProviderConfigs: () => ApiConfig;
     getModelListChanges: () => ModelListChanges;

package/bundled/gateway/services/gateway/src/services/configService.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAccessToken = exports.getDeploymentIdCacheStatus = exports.clearDeploymentIdCache = exports.getDeploymentId = exports.getSAPAICoreConfig = exports.getHookConfig = exports.get = exports.getTimeout = exports.getCachePricingForModel = exports.getModelListChanges = exports.getAllProviderConfigs = exports.getOpenAIDeploymentApiVersion = exports.getExcludedBetaHeaders = exports.getAnthropicBedrockVersion = exports.shouldEmulateStreaming = exports.getOriginalModel = exports.getSubstitutedModel = exports.patchConfig = exports.updateConfig = exports.getConfigAsync = exports.getConfig = exports.isConfigurationReady = exports.onConfigurationReady = exports.publishModelList = void 0;
+exports.getAccessToken = exports.getDeploymentIdCacheStatus = exports.clearDeploymentIdCache = exports.getDeploymentId = exports.getSAPAICoreConfig = exports.getHookConfig = exports.get = exports.getTimeout = exports.getCachePricingForModel = exports.getModelListChanges = exports.getAllProviderConfigs = exports.getOpenAIDeploymentApiVersion = exports.getSupportedBetaHeaders = exports.getExcludedBetaHeaders = exports.getAnthropicBedrockVersion = exports.shouldEmulateStreaming = exports.getOriginalModel = exports.getSubstitutedModel = exports.patchConfig = exports.updateConfig = exports.getConfigAsync = exports.getConfig = exports.isConfigurationReady = exports.onConfigurationReady = exports.publishModelList = void 0;
 /**
  * Service to manage API provider configurations including model substitutions and streaming emulation
  */
@@ -48,6 +48,7 @@ const pluginLoader_1 = __importDefault(require("./pluginLoader"));
 const logger_1 = require("@libs/logger");
 const logger = (0, logger_1.getDefaultLogger)();
 const unifiedAuthConfig_1 = require("../config/unifiedAuthConfig");
+const pluginCacheSelector_1 = require("../utils/pluginCacheSelector");
 // Default configuration path
 const CONFIG_FILE_PATH = process.env.CONFIG_FILE_PATH || path.join(process.cwd(), 'api_config.json');
 // Backup configuration
@@ -66,7 +67,11 @@ let valkeySubscriber = null;
 let valkeyPublisher = null;
 let valkeyInitialized = false;
 // Event channels
-const CONFIG_CHANGE_CHANNEL = 'sap-llm-gateway:config-changed';
+// Env-overridable so integration tests can isolate a spawned gateway on a
+// test-scoped channel instead of broadcasting on the production channel (a
+// test publishing here once wiped the live gateway's config mid-session —
+// Valkey pub/sub channels are global, they are NOT scoped by database index).
+const CONFIG_CHANGE_CHANNEL = process.env.CONFIG_CHANGE_CHANNEL || 'sap-llm-gateway:config-changed';
 const MODEL_LIST_CHANNEL = 'sap-llm-gateway:model-list-updated';
 const STARTUP_READY_CHANNEL = 'sap-llm-gateway:service-ready';
 // Startup coordination
@@ -389,6 +394,37 @@ const requestInitialConfiguration = async () => {
         logger.warn('ConfigService', `Failed to request initial configuration: ${error.message}`);
     }
 };
+/**
+ * Reload plugin modules on a configuration change.
+ *
+ * Evicts ONLY the plugins subtree from require.cache (plugin entry files plus
+ * their plugin-internal helper modules, e.g. plugins/pseudonymization/*), then
+ * lets pluginLoader rebuild the registry. Gateway SERVICE modules are never
+ * evicted: doing so caused split-brain state — Express handlers registered at
+ * startup kept referencing the old module instances while later require()
+ * calls created fresh ones with empty caches, and the two worlds disagreed
+ * (observed as model substitution silently failing after a config-activation
+ * event until a manual restart). Service code changes are picked up by nodemon
+ * (dev) or a deploy restart (prod), never by config pushes.
+ */
+const reloadPluginModules = () => {
+    try {
+        const pluginsDirPrefix = path.join(__dirname, '..', 'plugins');
+        const keys = (0, pluginCacheSelector_1.selectPluginCacheKeysToClear)(Object.keys(require.cache), pluginsDirPrefix);
+        for (const key of keys) {
+            delete require.cache[key];
+        }
+        if (keys.length > 0) {
+            logger.info('ConfigService', `Cleared require cache for ${keys.length} plugin modules`);
+        }
+        const pluginLoader = require('./pluginLoader');
+        pluginLoader.reloadAll('./src/plugins');
+        logger.info('ConfigService', 'Plugins reloaded successfully');
+    }
+    catch (pluginError) {
+        logger.error('ConfigService', `Error reloading plugins: ${pluginError.message}`);
+    }
+};
 /**
  * Trigger configuration reload mechanisms (plugins, model service cache, etc.)
  */
@@ -399,32 +435,8 @@ const triggerConfigurationReload = async () => {
             logger.reinitialize();
             logger.info('ConfigService', 'Logger reinitialized with updated configuration');
         }
-        // Reload plugins and all gateway service modules to pick up code changes on disk
-        try {
-            // Clear require cache for all gateway modules so updated code on disk is loaded.
-            // This enables hot-reload of service files during config push without a full process restart.
-            // Exclude configService itself — it owns startup coordination state (configurationReceived,
-            // isWaitingForAdminEvents, startupRequestSent, cachedConfig) that must survive reloads.
-            const gatewayDistPrefix = path.join(__dirname, '..').replace(/\\/g, '/');
-            const ownModulePath = __filename.replace(/\\/g, '/');
-            let cleared = 0;
-            for (const key of Object.keys(require.cache)) {
-                const normalizedKey = key.replace(/\\/g, '/');
-                if (normalizedKey.startsWith(gatewayDistPrefix) && !normalizedKey.includes('node_modules') && normalizedKey !== ownModulePath) {
-                    delete require.cache[key];
-                    cleared++;
-                }
-            }
-            if (cleared > 0) {
-                logger.info('ConfigService', `Cleared require cache for ${cleared} gateway modules`);
-            }
-            const pluginLoader = require('./pluginLoader');
-            pluginLoader.reloadAll('./src/plugins');
-            logger.info('ConfigService', 'Plugins reloaded successfully');
-        }
-        catch (pluginError) {
-            logger.error('ConfigService', `Error reloading plugins: ${pluginError.message}`);
-        }
+        // Reload PLUGIN modules to pick up plugin code/config changes.
+        reloadPluginModules();
         // Clear model service caches to force reapplication of config
         try {
             const modelService = require('./modelService').default;
@@ -789,31 +801,9 @@ const updateConfig = (newConfig) => {
             logger.reinitialize();
             logger.info('ConfigService', 'Logger reinitialized with updated configuration');
         }
-        // Reload plugins and all gateway service modules to pick up code changes on disk
-        try {
-            // Clear require cache for all gateway modules so updated code on disk is loaded.
-            // This enables hot-reload of service files during config push without a full process restart.
-            // Exclude configService itself — it owns startup coordination state that must survive reloads.
-            const gatewayDistPrefix = path.join(__dirname, '..').replace(/\\/g, '/');
-            const ownModulePath = __filename.replace(/\\/g, '/');
-            let cleared = 0;
-            for (const key of Object.keys(require.cache)) {
-                const normalizedKey = key.replace(/\\/g, '/');
-                if (normalizedKey.startsWith(gatewayDistPrefix) && !normalizedKey.includes('node_modules') && normalizedKey !== ownModulePath) {
-                    delete require.cache[key];
-                    cleared++;
-                }
-            }
-            if (cleared > 0) {
-                logger.info('ConfigService', `Cleared require cache for ${cleared} gateway modules`);
-            }
-            const pluginLoader = require('./pluginLoader');
-            pluginLoader.reloadAll('./src/plugins');
-            logger.info('ConfigService', 'Plugins reloaded successfully');
-        }
-        catch (pluginError) {
-            logger.error('ConfigService', `Error reloading plugins: ${pluginError.message}`);
-        }
+        // Reload PLUGIN modules to pick up plugin code/config changes (services are
+        // never evicted — see reloadPluginModules for the split-brain rationale).
+        reloadPluginModules();
         // Clear model service caches to force reapplication of config
         try {
             const modelService = require('./modelService').default;
@@ -973,6 +963,23 @@ const getExcludedBetaHeaders = () => {
     }
 };
 exports.getExcludedBetaHeaders = getExcludedBetaHeaders;
+/**
+ * Get supported (allowlisted) beta headers for Anthropic requests to SAP AI Core.
+ * When non-empty, only these beta flags are forwarded; the excluded_beta_headers
+ * denylist is still applied on top. Empty/absent means no allowlist filtering.
+ * @returns Array of allowlisted beta header values
+ */
+const getSupportedBetaHeaders = () => {
+    try {
+        const config = (0, exports.getConfig)();
+        return config?.api_config?.anthropic?.supported_beta_headers || [];
+    }
+    catch (error) {
+        logger.error('ConfigService', `Error getting supported beta headers: ${error.message}`);
+        return [];
+    }
+};
+exports.getSupportedBetaHeaders = getSupportedBetaHeaders;
 const getOpenAIDeploymentApiVersion = () => {
     try {
         const config = (0, exports.getConfig)();
@@ -1284,6 +1291,7 @@ exports.default = {
     shouldEmulateStreaming: exports.shouldEmulateStreaming,
     getAnthropicBedrockVersion: exports.getAnthropicBedrockVersion,
     getExcludedBetaHeaders: exports.getExcludedBetaHeaders,
+    getSupportedBetaHeaders: exports.getSupportedBetaHeaders,
     getOpenAIDeploymentApiVersion: exports.getOpenAIDeploymentApiVersion,
     getAllProviderConfigs: exports.getAllProviderConfigs,
     getModelListChanges: exports.getModelListChanges,

package/bundled/gateway/services/gateway/src/utils/bedrockStreamParser.d.ts

@@ -32,6 +32,15 @@ declare class BedrockStreamParser {
      * Helper to create a content_block_start event
      */
     private createContentBlockStartEvent;
+    /**
+     * Emit an event that is already in Anthropic Messages streaming format with
+     * proper `event: <type>` SSE framing. Records upstream message id and terminal
+     * usage metrics into streamState so downstream bookkeeping (usage tracking,
+     * end-of-stream finalization) stays consistent. Passthrough events never feed
+     * the tool-fragment reconstruction buffers — those exist only for Bedrock
+     * camelCase envelope streams.
+     */
+    private emitAnthropicPassthroughEvent;
     /**
      * Handle end of stream
      */

package/bundled/gateway/services/gateway/src/utils/bedrockStreamParser.js

@@ -37,6 +37,19 @@ const eventsource_parser_1 = require("eventsource-parser");
 const sseWriter = __importStar(require("./sseWriter"));
 const logger_1 = require("@libs/logger");
 const logger = (0, logger_1.getDefaultLogger)();
+// Anthropic Messages streaming event types. SAP native invoke-with-response-stream
+// for deployed Anthropic models emits events ALREADY in this format — they must be
+// passed through with proper `event: <type>` SSE framing, not transformed.
+const ANTHROPIC_STREAM_EVENTS = new Set([
+    'message_start',
+    'content_block_start',
+    'content_block_delta',
+    'content_block_stop',
+    'message_delta',
+    'message_stop',
+    'ping',
+    'error',
+]);
 /**
  * Handles streaming responses from AWS Bedrock, properly parsing SSE events and processing JSON fragments
  */
@@ -61,7 +74,8 @@ class BedrockStreamParser {
             finalFirstByteLatency: null,
             // Tool fragment buffering state
             toolFragmentBuffers: new Map(), // Map of contentBlockIndex -> array of fragments
-            processedFragmentCount: 0
+            processedFragmentCount: 0,
+            terminalMessageStopEmitted: false
         };
         // Create our event source parser with the correct v3.0.2 API
         this.parser = (0, eventsource_parser_1.createParser)({
@@ -103,6 +117,10 @@ class BedrockStreamParser {
                 return;
             }
             // Check if this is an SSE data chunk
+            // TODO: this heuristic misroutes network chunks that split an SSE event mid-JSON
+            // (a fragment not starting with 'data:'/'event:' is treated as direct data and can
+            // emit corrupted events). parser.feed() below already reassembles across chunk
+            // boundaries — partial SSE fragments should be fed to it rather than handleData.
             const isSseFormat = chunkStr.startsWith('data:') ||
                 chunkStr.includes('\ndata:') ||
                 chunkStr.includes('event:') ||
@@ -277,6 +295,17 @@ class BedrockStreamParser {
                     return;
                 }
             }
+            // Already-Anthropic events (SAP native streams for deployed Anthropic models)
+            // must be passed through with proper `event: <type>` SSE framing.
+            // transformBedrockEvent only understands the Bedrock camelCase envelope, so
+            // until this branch existed these all fell through to the raw `data:`-only
+            // fallback below — SSE without `event:` headers, which claude-cli >= 2.1.215
+            // cannot parse (perceived as a lost connection / ECONNRESET on every stream).
+            if (typeof bedrockEvent.type === 'string'
+                && ANTHROPIC_STREAM_EVENTS.has(bedrockEvent.type)) {
+                this.emitAnthropicPassthroughEvent(bedrockEvent);
+                return;
+            }
             // Transform the event
             const events = this.transformBedrockEvent(bedrockEvent);
             if (events && events.length > 0) {
@@ -338,14 +367,51 @@ class BedrockStreamParser {
             this.streamState.emittedToolUseContentStartIndices.add(index);
         }
     }
+    /**
+     * Emit an event that is already in Anthropic Messages streaming format with
+     * proper `event: <type>` SSE framing. Records upstream message id and terminal
+     * usage metrics into streamState so downstream bookkeeping (usage tracking,
+     * end-of-stream finalization) stays consistent. Passthrough events never feed
+     * the tool-fragment reconstruction buffers — those exist only for Bedrock
+     * camelCase envelope streams.
+     */
+    emitAnthropicPassthroughEvent(event) {
+        if (!this.res || this.res.writableEnded)
+            return;
+        // Adopt the upstream message id so later fallback paths never mint a second
+        // message_start for a stream that already has one.
+        if (event.type === 'message_start' && event.message?.id && !this.streamState.messageId) {
+            this.streamState.messageId = event.message.id;
+        }
+        if (event.type === 'message_stop') {
+            const metrics = event['amazon-bedrock-invocationMetrics'];
+            if (metrics) {
+                this.streamState.finalInputTokens = metrics.inputTokenCount || 0;
+                this.streamState.finalOutputTokens = metrics.outputTokenCount || 0;
+                this.streamState.finalCacheCreationTokens = metrics.cacheWriteInputTokenCount || 0;
+                this.streamState.finalCacheReadTokens = metrics.cacheReadInputTokenCount || 0;
+                this.streamState.finalLatencyMs = metrics.invocationLatency || 0;
+                this.streamState.finalFirstByteLatency = metrics.firstByteLatency || 0;
+                if (this.outputFormat === 'anthropic') {
+                    // Anthropic clients get a clean message_stop; the metrics live in streamState.
+                    const { ['amazon-bedrock-invocationMetrics']: _metrics, ...clean } = event;
+                    event = clean;
+                }
+            }
+            this.streamState.terminalMessageStopEmitted = true;
+        }
+        logger.debug('BedrockStreamParser', `Passthrough Anthropic event: ${event.type}`);
+        sseWriter.writeEventStream(this.res, event.type, JSON.stringify(event));
+    }
     /**
      * Handle end of stream
      */
     handleDone() {
         // Process any remaining tool fragments in buffers
         this.processAllToolFragmentBuffers();
-        // Send final message_stop if needed
-        if (this.streamState.messageId && this.res && !this.res.writableEnded) {
+        // Send final message_stop if needed (never after a passthrough already sent one)
+        if (this.streamState.messageId && !this.streamState.terminalMessageStopEmitted
+            && this.res && !this.res.writableEnded) {
             if (this.outputFormat === 'anthropic') {
                 // Anthropic format: clean message_stop without Bedrock-specific metrics
                 sseWriter.writeEventStream(this.res, 'message_stop', JSON.stringify({

package/bundled/gateway/services/gateway/src/utils/betaFeatureFilter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Pure helpers for assembling and filtering anthropic_beta feature flags
+ * before forwarding requests to SAP AI Core Bedrock deployments.
+ *
+ * Filtering semantics:
+ * 1. Allowlist (supported): when non-empty, only listed flags survive.
+ *    An empty/absent allowlist means "no allowlist filtering" (legacy behavior).
+ * 2. Denylist (excluded): always applied on top of the allowlist result.
+ *
+ * @see api_config.json - anthropic.supported_beta_headers / anthropic.excluded_beta_headers
+ */
+export interface BetaFilterOptions {
+    /** Allowlist from api_config.anthropic.supported_beta_headers; [] disables allowlist filtering */
+    supported: string[];
+    /** Denylist from api_config.anthropic.excluded_beta_headers */
+    excluded: string[];
+}
+/**
+ * Parse the raw anthropic-beta header value into a clean array of flags.
+ * Accepts a comma-separated string, an array of values (each possibly
+ * comma-separated), or undefined.
+ */
+export declare function parseAnthropicBetaHeader(headerValue: string | string[] | undefined): string[];
+/**
+ * Merge multiple flag lists, preserving first-seen order and deduplicating.
+ */
+export declare function mergeBetaFeatures(...lists: string[][]): string[];
+/**
+ * Apply allowlist-then-denylist filtering to a list of beta flags.
+ */
+export declare function filterBetaFeatures(features: string[], options: BetaFilterOptions): string[];

package/bundled/gateway/services/gateway/src/utils/betaFeatureFilter.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Pure helpers for assembling and filtering anthropic_beta feature flags
+ * before forwarding requests to SAP AI Core Bedrock deployments.
+ *
+ * Filtering semantics:
+ * 1. Allowlist (supported): when non-empty, only listed flags survive.
+ *    An empty/absent allowlist means "no allowlist filtering" (legacy behavior).
+ * 2. Denylist (excluded): always applied on top of the allowlist result.
+ *
+ * @see api_config.json - anthropic.supported_beta_headers / anthropic.excluded_beta_headers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAnthropicBetaHeader = parseAnthropicBetaHeader;
+exports.mergeBetaFeatures = mergeBetaFeatures;
+exports.filterBetaFeatures = filterBetaFeatures;
+/**
+ * Parse the raw anthropic-beta header value into a clean array of flags.
+ * Accepts a comma-separated string, an array of values (each possibly
+ * comma-separated), or undefined.
+ */
+function parseAnthropicBetaHeader(headerValue) {
+    if (!headerValue) {
+        return [];
+    }
+    const rawValues = Array.isArray(headerValue) ? headerValue : [headerValue];
+    return rawValues
+        .flatMap(value => String(value).split(','))
+        .map(flag => flag.trim())
+        .filter(Boolean);
+}
+/**
+ * Merge multiple flag lists, preserving first-seen order and deduplicating.
+ */
+function mergeBetaFeatures(...lists) {
+    const merged = [];
+    for (const list of lists) {
+        for (const flag of list) {
+            if (!merged.includes(flag)) {
+                merged.push(flag);
+            }
+        }
+    }
+    return merged;
+}
+/**
+ * Apply allowlist-then-denylist filtering to a list of beta flags.
+ */
+function filterBetaFeatures(features, options) {
+    let result = features;
+    if (options.supported.length > 0) {
+        result = result.filter(flag => options.supported.includes(flag));
+    }
+    if (options.excluded.length > 0) {
+        result = result.filter(flag => !options.excluded.includes(flag));
+    }
+    return result;
+}

package/bundled/gateway/services/gateway/src/utils/payloadLogger.d.ts

@@ -1,2 +1,8 @@
 import { Request, Response } from 'express';
+/**
+ * Whether payload logging is currently enabled. Re-reads the dynamic config
+ * on every call (with the PAYLOAD_LOGGING_ENABLED env override applied), so
+ * an api_config.json change takes effect on the next request — no restart.
+ */
+export declare const isPayloadLoggingEnabled: () => boolean;
 export declare const savePayload: (requestId: string | number, stage: string, data: any, req?: Request, res?: Response) => void;

package/bundled/gateway/services/gateway/src/utils/payloadLogger.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.savePayload = void 0;
+exports.savePayload = exports.isPayloadLoggingEnabled = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const logger_1 = require("@libs/logger");
@@ -131,19 +131,23 @@ function ensureLogDirExists() {
     }
     return { success: true, logDir };
 }
+/**
+ * Whether payload logging is currently enabled. Re-reads the dynamic config
+ * on every call (with the PAYLOAD_LOGGING_ENABLED env override applied), so
+ * an api_config.json change takes effect on the next request — no restart.
+ */
+const isPayloadLoggingEnabled = () => {
+    return getLoggingConfig().payloadLoggingEnabled;
+};
+exports.isPayloadLoggingEnabled = isPayloadLoggingEnabled;
 // Enhanced payload logger with headers and HTTP method support
 const savePayload = (requestId, stage, data, req, res) => {
-    const currentDebugEnv = process.env.DEBUG;
     const { payloadLoggingEnabled } = getLoggingConfig();
     // Skip debug logging for disabled payload logging to avoid log noise at INFO level
     if (!payloadLoggingEnabled) {
         return;
     }
-    logger.debug('PayloadLogger', `Enhanced save called for requestId: ${requestId}, stage: ${stage}, DEBUG_ENV: '${currentDebugEnv}', PAYLOAD_LOGGING_ENABLED: ${payloadLoggingEnabled}`);
-    if (currentDebugEnv !== 'true') {
-        logger.debug('PayloadLogger', `Skipping enhanced save, process.env.DEBUG is not the string 'true'.`);
-        return;
-    }
+    logger.debug('PayloadLogger', `Enhanced save called for requestId: ${requestId}, stage: ${stage}, PAYLOAD_LOGGING_ENABLED: ${payloadLoggingEnabled}`);
     if (!requestId) {
         logger.debug('PayloadLogger', `Skipping enhanced save, no requestId provided.`);
         return;

package/bundled/gateway/services/gateway/src/utils/pluginCacheSelector.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Select which require.cache keys may be evicted on a configuration reload.
+ *
+ * ONLY modules under the plugins directory are eligible. Evicting gateway
+ * SERVICE modules on a config push causes split-brain state: Express handlers
+ * registered at startup keep referencing the old module instances, while any
+ * later require() creates fresh instances with empty caches — the two worlds
+ * then disagree (observed as model substitution silently failing after a
+ * config-activation event until a manual restart). Service code changes are
+ * picked up by nodemon (dev) or a deploy restart (prod), never by config
+ * pushes. Plugin ENTRY files are cache-cleared by pluginLoader itself; this
+ * selector additionally covers plugin-internal helper modules (e.g.
+ * plugins/pseudonymization/*.ts) that plugin entries import.
+ */
+export declare function selectPluginCacheKeysToClear(cacheKeys: string[], pluginsDirPrefix: string): string[];

package/bundled/gateway/services/gateway/src/utils/pluginCacheSelector.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectPluginCacheKeysToClear = selectPluginCacheKeysToClear;
+/**
+ * Select which require.cache keys may be evicted on a configuration reload.
+ *
+ * ONLY modules under the plugins directory are eligible. Evicting gateway
+ * SERVICE modules on a config push causes split-brain state: Express handlers
+ * registered at startup keep referencing the old module instances, while any
+ * later require() creates fresh instances with empty caches — the two worlds
+ * then disagree (observed as model substitution silently failing after a
+ * config-activation event until a manual restart). Service code changes are
+ * picked up by nodemon (dev) or a deploy restart (prod), never by config
+ * pushes. Plugin ENTRY files are cache-cleared by pluginLoader itself; this
+ * selector additionally covers plugin-internal helper modules (e.g.
+ * plugins/pseudonymization/*.ts) that plugin entries import.
+ */
+function selectPluginCacheKeysToClear(cacheKeys, pluginsDirPrefix) {
+    const prefix = pluginsDirPrefix.replace(/\\/g, '/').replace(/\/+$/, '') + '/';
+    return cacheKeys.filter(key => {
+        const normalized = key.replace(/\\/g, '/');
+        return normalized.startsWith(prefix) && !normalized.includes('node_modules');
+    });
+}

package/bundled/gateway/services/gateway/src/utils/sseWriter.js

@@ -176,8 +176,10 @@ const writePing = (res) => {
         }
         // Write a comment as ping (standard SSE practice)
         res.write(': ping\n\n');
-        // Also write a data event for clients that might not properly handle comments
-        res.write('data: {"type":"ping"}\n\n');
+        // Also write a ping event for clients that might not properly handle comments.
+        // Framed with `event: ping` like Anthropic's wire format — strict SSE parsers
+        // (claude-cli >= 2.1.215) require the event: field on every data block.
+        res.write('event: ping\ndata: {"type":"ping"}\n\n');
     }
     catch (writeError) {
         logger.error('SSEWriter', 'Error writing ping to client:', writeError);

package/bundled/gateway/services/gateway/src/utils/upstreamErrorBody.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Read an upstream (axios) error body that may be a stream.
+ *
+ * Streaming requests use `responseType: 'stream'`, so on an error status axios
+ * delivers `error.response.data` as a Readable stream — logging it directly
+ * prints an unusable stream object, and body-matching logic (e.g. the beta-flag
+ * quarantine) sees nothing. Drain up to a small cap with a short timeout and
+ * parse JSON when possible; non-stream bodies are returned unchanged.
+ */
+export declare function readUpstreamErrorBody(response: any): Promise<any>;