@juspay/neurolink 9.41.0 → 9.42.0

package/dist/client/streamingClient.js

@@ -251,10 +251,12 @@ export class SSEClient {
      * Register event handler
      */
     on(event, callback) {
-        if (!this.eventHandlers.has(event)) {
-            this.eventHandlers.set(event, new Set());
+        let handlers = this.eventHandlers.get(event);
+        if (!handlers) {
+            handlers = new Set();
+            this.eventHandlers.set(event, handlers);
         }
-        this.eventHandlers.get(event).add(callback);
+        handlers.add(callback);
     }
     /**
      * Remove event handler
@@ -315,7 +317,11 @@ export class SSEClient {
             });
             while (!done && !error) {
                 if (events.length > 0) {
-                    yield events.shift();
+                    const nextEvent = events.shift();
+                    if (!nextEvent) {
+                        continue;
+                    }
+                    yield nextEvent;
                 }
                 else {
                     await new Promise((resolve) => {
@@ -325,7 +331,11 @@ export class SSEClient {
             }
             // Yield remaining events
             while (events.length > 0) {
-                yield events.shift();
+                const nextEvent = events.shift();
+                if (!nextEvent) {
+                    continue;
+                }
+                yield nextEvent;
             }
             if (error) {
                 throw error;
@@ -545,10 +555,12 @@ export class WebSocketStreamingClient {
      * Register event handler
      */
     on(event, callback) {
-        if (!this.eventHandlers.has(event)) {
-            this.eventHandlers.set(event, new Set());
+        let handlers = this.eventHandlers.get(event);
+        if (!handlers) {
+            handlers = new Set();
+            this.eventHandlers.set(event, handlers);
         }
-        this.eventHandlers.get(event).add(callback);
+        handlers.add(callback);
     }
     /**
      * Remove event handler
@@ -591,7 +603,11 @@ export class WebSocketStreamingClient {
         try {
             while (!disconnected) {
                 if (messageQueue.length > 0) {
-                    yield messageQueue.shift();
+                    const nextMessage = messageQueue.shift();
+                    if (nextMessage === undefined) {
+                        continue;
+                    }
+                    yield nextMessage;
                 }
                 else {
                     await new Promise((resolve) => {
@@ -601,7 +617,11 @@ export class WebSocketStreamingClient {
             }
             // Yield remaining messages
             while (messageQueue.length > 0) {
-                yield messageQueue.shift();
+                const nextMessage = messageQueue.shift();
+                if (nextMessage === undefined) {
+                    continue;
+                }
+                yield nextMessage;
             }
         }
         finally {

package/dist/core/modules/GenerationHandler.js

@@ -95,6 +95,7 @@ export class GenerationHandler {
                 };
             }
         }
+        const prepareStep = options.prepareStep;
         return await generateText({
             model,
             messages,
@@ -103,8 +104,8 @@ export class GenerationHandler {
             stopWhen: stepCountIs(options.maxSteps ?? DEFAULT_MAX_STEPS),
             ...(shouldUseTools &&
                 options.toolChoice && { toolChoice: options.toolChoice }),
-            ...(options.prepareStep && {
-                experimental_prepareStep: ((stepOptions) => options.prepareStep({
+            ...(prepareStep && {
+                experimental_prepareStep: ((stepOptions) => prepareStep({
                     ...stepOptions,
                     maxSteps: options.maxSteps ?? DEFAULT_MAX_STEPS,
                 })),

package/dist/core/redisConversationMemoryManager.js

@@ -16,6 +16,7 @@ import { runWithCurrentLangfuseContext } from "../services/server/ai/observabili
 import { logger } from "../utils/logger.js";
 import { deserializeConversation, getNormalizedConfig, getPooledRedisClient, getSessionKey, getUserSessionsKey, releasePooledRedisClient, scanKeys, serializeConversation, } from "../utils/redis.js";
 const redisTracer = tracers.redis;
+const REDIS_TIMEOUT_MS = 5000;
 /**
  * Redis-based implementation of the ConversationMemoryManager
  * Uses the same interface but stores data in Redis
@@ -130,13 +131,14 @@ export class RedisConversationMemoryManager {
         if (!this.redisClient) {
             return undefined;
         }
+        const redisClient = this.redisClient;
         return redisTracer.startActiveSpan("neurolink.memory.getSession", { kind: SpanKind.CLIENT, attributes: { "session.id": sessionId } }, async (span) => {
             if (userId) {
                 span.setAttribute("user.id", userId);
             }
             try {
                 const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
-                const conversationData = await this.redisClient.get(redisKey);
+                const conversationData = await withTimeout(redisClient.get(redisKey), REDIS_TIMEOUT_MS);
                 const conversation = deserializeConversation(conversationData || null);
                 if (!conversation) {
                     span.setAttribute("session.found", false);
@@ -630,6 +632,7 @@ export class RedisConversationMemoryManager {
             logger.warn("[RedisConversationMemoryManager] Redis client not available in buildContextMessages");
             return [];
         }
+        const redisClient = this.redisClient;
         // NLK-GAP-012: Add span for buildContext CRUD operation
         return redisTracer.startActiveSpan("neurolink.memory.buildContext", {
             kind: SpanKind.CLIENT,
@@ -645,7 +648,7 @@ export class RedisConversationMemoryManager {
                     method: "buildContextMessages",
                 });
                 const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
-                const conversationData = await this.redisClient.get(redisKey);
+                const conversationData = await withTimeout(redisClient.get(redisKey), REDIS_TIMEOUT_MS);
                 const conversation = deserializeConversation(conversationData || null);
                 if (!conversation) {
                     span.setAttribute("session.found", false);
@@ -1080,6 +1083,7 @@ User message: "${userMessage}"`;
         if (!this.redisClient) {
             return false;
         }
+        const redisClient = this.redisClient;
         // NLK-GAP-012: Add span for clearSession CRUD operation
         return redisTracer.startActiveSpan("neurolink.memory.clear", {
             kind: SpanKind.CLIENT,
@@ -1090,7 +1094,7 @@ User message: "${userMessage}"`;
         }, async (span) => {
             try {
                 const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
-                const result = await this.redisClient.del(redisKey);
+                const result = await withTimeout(redisClient.del(redisKey), REDIS_TIMEOUT_MS);
                 if (Number(result) > 0) {
                     // Remove session from user's session set
                     if (userId) {

package/dist/evaluation/BatchEvaluator.js

@@ -6,6 +6,9 @@ import { Evaluator } from "./index.js";
 import { createBatchEvaluationError, isRetryableEvaluationError, } from "./errors/EvaluationError.js";
 import { logger } from "../utils/logger.js";
 import { NeuroLinkFeatureError } from "../core/infrastructure/index.js";
+function hasEvaluationData(result) {
+    return result.success && result.data !== undefined;
+}
 /**
  * BatchEvaluator - Performs evaluation on multiple items in parallel.
  * Supports configurable concurrency, retry logic, and progress tracking.
@@ -201,7 +204,7 @@ export class BatchEvaluator {
             }
         }
         // Calculate summary statistics
-        const successfulResults = results.filter((r) => r.success && r.data);
+        const successfulResults = results.filter(hasEvaluationData);
         const scores = successfulResults.map((r) => r.data.overall);
         const passingScores = successfulResults.filter((r) => r.data.overall >=
             (autoEvalConfig.threshold || this.config.threshold || 7));

package/dist/evaluation/hooks/observabilityHooks.js

@@ -41,10 +41,12 @@ export class ObservabilityHooks {
      * Register an event handler
      */
     on(event, handler) {
-        if (!this._handlers.has(event)) {
-            this._handlers.set(event, new Set());
+        let handlers = this._handlers.get(event);
+        if (!handlers) {
+            handlers = new Set();
+            this._handlers.set(event, handlers);
         }
-        this._handlers.get(event).add(handler);
+        handlers.add(handler);
         // Return unsubscribe function
         return () => {
             this._handlers.get(event)?.delete(handler);

package/dist/evaluation/pipeline/evaluationPipeline.d.ts

@@ -12,9 +12,9 @@ export type PipelineExecutionOptions = {
     correlationId?: string;
     /** Custom timeout override */
     timeout?: number;
-    /** Skip specific scorers */
+    /** Skip specific scorers. Mutually exclusive with onlyScorers. */
     skipScorers?: string[];
-    /** Only run specific scorers */
+    /** Only run specific scorers. Mutually exclusive with skipScorers. */
     onlyScorers?: string[];
     /** Additional metadata to attach */
     metadata?: JsonObject;
@@ -59,6 +59,7 @@ export declare class EvaluationPipeline {
      * Execute the pipeline on input
      */
     execute(input: ScorerInput, options?: PipelineExecutionOptions): Promise<PipelineResult>;
+    private _validateExecutionOptions;
     /**
      * Get scorers to run based on options
      */

package/dist/evaluation/pipeline/evaluationPipeline.js

@@ -91,6 +91,7 @@ export class EvaluationPipeline {
         if (!this._initialized) {
             await this.initialize();
         }
+        this._validateExecutionOptions(options);
         const startTime = Date.now();
         const correlationId = options?.correlationId ?? `pipeline-${Date.now()}`;
         logger.debug(`Executing pipeline: ${this._config.name ?? "unnamed"}`, {
@@ -173,16 +174,25 @@ export class EvaluationPipeline {
             skippedScorers,
         };
     }
+    _validateExecutionOptions(options) {
+        const hasOnlyScorers = !!options?.onlyScorers && options.onlyScorers.length > 0;
+        const hasSkipScorers = !!options?.skipScorers && options.skipScorers.length > 0;
+        if (hasOnlyScorers && hasSkipScorers) {
+            throw new Error("Cannot specify both 'onlyScorers' and 'skipScorers' options");
+        }
+    }
     /**
      * Get scorers to run based on options
      */
     _getScorersToRun(options) {
         const allScorers = Array.from(this._scorers.entries());
-        if (options?.onlyScorers && options.onlyScorers.length > 0) {
-            return allScorers.filter(([id]) => options.onlyScorers.includes(id));
+        const onlyScorers = options?.onlyScorers;
+        const skipScorers = options?.skipScorers;
+        if (onlyScorers && onlyScorers.length > 0) {
+            return allScorers.filter(([id]) => onlyScorers.includes(id));
         }
-        if (options?.skipScorers && options.skipScorers.length > 0) {
-            return allScorers.filter(([id]) => !options.skipScorers.includes(id));
+        if (skipScorers && skipScorers.length > 0) {
+            return allScorers.filter(([id]) => !skipScorers.includes(id));
         }
         return allScorers;
     }
@@ -191,11 +201,13 @@ export class EvaluationPipeline {
      */
     _getSkippedScorers(options) {
         const allIds = Array.from(this._scorers.keys());
-        if (options?.onlyScorers && options.onlyScorers.length > 0) {
-            return allIds.filter((id) => !options.onlyScorers.includes(id));
+        const onlyScorers = options?.onlyScorers;
+        const skipScorers = options?.skipScorers;
+        if (onlyScorers && onlyScorers.length > 0) {
+            return allIds.filter((id) => !onlyScorers.includes(id));
         }
-        if (options?.skipScorers && options.skipScorers.length > 0) {
-            return options.skipScorers.filter((id) => allIds.includes(id));
+        if (skipScorers && skipScorers.length > 0) {
+            return skipScorers.filter((id) => allIds.includes(id));
         }
         return [];
     }

package/dist/evaluation/pipeline/strategies/batchStrategy.js

@@ -2,6 +2,9 @@
  * @file Batch Strategy
  * Batch processing for evaluation pipelines
  */
+function hasPipelineResult(result) {
+    return !result.error && result.result !== undefined;
+}
 /**
  * Default batch configuration
  */
@@ -66,7 +69,7 @@ export class BatchStrategy {
         }
         // Calculate summary
         const totalDuration = Date.now() - startTime;
-        const successfulResults = results.filter((r) => !r.error && r.result);
+        const successfulResults = results.filter(hasPipelineResult);
         const scores = successfulResults.map((r) => r.result.overallScore);
         const passed = successfulResults.filter((r) => r.result.passed);
         return {
@@ -192,7 +195,7 @@ export async function* streamBatchEvaluation(pipeline, inputs, config) {
             durations.push(result.duration);
             // If continueOnError is false and this result has an error, abort and return summary
             if (result.error && batchConfig.continueOnError === false) {
-                const successfulResults = results.filter((r) => !r.error && r.result);
+                const successfulResults = results.filter(hasPipelineResult);
                 const earlyScores = successfulResults.map((r) => r.result.overallScore);
                 const earlyPassed = successfulResults.filter((r) => r.result.passed);
                 return {
@@ -219,7 +222,7 @@ export async function* streamBatchEvaluation(pipeline, inputs, config) {
         }
     }
     // Return summary
-    const successfulResults = results.filter((r) => !r.error && r.result);
+    const successfulResults = results.filter(hasPipelineResult);
     const scores = successfulResults.map((r) => r.result.overallScore);
     const passed = successfulResults.filter((r) => r.result.passed);
     return {

package/dist/evaluation/pipeline/strategies/samplingStrategy.js

@@ -17,6 +17,12 @@ export const DEFAULT_SAMPLING_CONFIG = {
         maxRate: 1.0,
     },
 };
+const DEFAULT_ADAPTIVE_CONFIG = {
+    enabled: false,
+    qualityThreshold: 0.7,
+    minRate: 0.1,
+    maxRate: 1.0,
+};
 /**
  * Sampling strategy for evaluation
  */
@@ -27,9 +33,10 @@ export class SamplingStrategy {
     _maxRecentScores = 100;
     constructor(config = {}) {
         const clamp01 = (v) => Math.max(0, Math.min(1, v));
+        const defaultAdaptive = DEFAULT_SAMPLING_CONFIG.adaptive ?? DEFAULT_ADAPTIVE_CONFIG;
         const rawRate = config.rate ?? DEFAULT_SAMPLING_CONFIG.rate;
-        const rawMinRate = config.adaptive?.minRate ?? DEFAULT_SAMPLING_CONFIG.adaptive.minRate;
-        const rawMaxRate = config.adaptive?.maxRate ?? DEFAULT_SAMPLING_CONFIG.adaptive.maxRate;
+        const rawMinRate = config.adaptive?.minRate ?? defaultAdaptive.minRate;
+        const rawMaxRate = config.adaptive?.maxRate ?? defaultAdaptive.maxRate;
         const minRate = clamp01(Math.min(rawMinRate, rawMaxRate));
         const maxRate = clamp01(Math.max(rawMinRate, rawMaxRate));
         this._config = {
@@ -41,9 +48,8 @@ export class SamplingStrategy {
                 ...(config.alwaysEvaluate ?? {}),
             },
             adaptive: {
-                enabled: config.adaptive?.enabled ?? DEFAULT_SAMPLING_CONFIG.adaptive.enabled,
-                qualityThreshold: clamp01(config.adaptive?.qualityThreshold ??
-                    DEFAULT_SAMPLING_CONFIG.adaptive.qualityThreshold),
+                enabled: config.adaptive?.enabled ?? defaultAdaptive.enabled,
+                qualityThreshold: clamp01(config.adaptive?.qualityThreshold ?? defaultAdaptive.qualityThreshold),
                 minRate,
                 maxRate,
             },
@@ -156,9 +162,12 @@ export class SamplingStrategy {
      */
     configure(config) {
         const clamp01 = (v) => Math.max(0, Math.min(1, v));
+        const currentAdaptive = this._config.adaptive ??
+            DEFAULT_SAMPLING_CONFIG.adaptive ??
+            DEFAULT_ADAPTIVE_CONFIG;
         const rawRate = config.rate ?? this._config.rate;
-        const rawMinRate = config.adaptive?.minRate ?? this._config.adaptive.minRate;
-        const rawMaxRate = config.adaptive?.maxRate ?? this._config.adaptive.maxRate;
+        const rawMinRate = config.adaptive?.minRate ?? currentAdaptive.minRate;
+        const rawMaxRate = config.adaptive?.maxRate ?? currentAdaptive.maxRate;
         const minRate = clamp01(Math.min(rawMinRate, rawMaxRate));
         const maxRate = clamp01(Math.max(rawMinRate, rawMaxRate));
         this._config = {
@@ -170,9 +179,8 @@ export class SamplingStrategy {
                 ...(config.alwaysEvaluate ?? {}),
             },
             adaptive: {
-                enabled: config.adaptive?.enabled ?? this._config.adaptive.enabled,
-                qualityThreshold: clamp01(config.adaptive?.qualityThreshold ??
-                    this._config.adaptive.qualityThreshold),
+                enabled: config.adaptive?.enabled ?? currentAdaptive.enabled,
+                qualityThreshold: clamp01(config.adaptive?.qualityThreshold ?? currentAdaptive.qualityThreshold),
                 minRate,
                 maxRate,
             },

package/dist/lib/auth/anthropicOAuth.d.ts

@@ -43,13 +43,28 @@ export declare const DEFAULT_SCOPES: readonly string[];
 /**
  * User-Agent string to spoof Claude CLI
  */
-export declare const CLAUDE_CLI_USER_AGENT = "claude-cli/2.1.2 (external, cli)";
+export declare const CLAUDE_CODE_VERSION = "2.1.87.6d6";
+export declare const CLAUDE_CODE_ENTRYPOINT = "sdk-cli";
+export declare const CLAUDE_CLI_USER_AGENT = "claude-cli/2.1.87 (external, sdk-cli)";
+export type ClaudeCodeIdentity = {
+    deviceId: string;
+    accountUuid: string;
+    sessionId: string;
+    metadataUserId: string;
+};
+export declare function parseClaudeCodeUserId(userId: unknown): ClaudeCodeIdentity | null;
+export declare function getOrCreateClaudeCodeIdentity(seed: string, options?: {
+    existingUserId?: unknown;
+    preferredSessionId?: string;
+}): ClaudeCodeIdentity;
+export declare function purgeExpiredClaudeCodeIdentities(now?: number): number;
+export declare function buildStableClaudeCodeBillingHeader(originalText?: string): string;
 /**
  * Required beta headers for OAuth API requests.
  * The "oauth-2025-04-20" header is CRITICAL for OAuth authentication.
- * The "interleaved-thinking-2025-05-14" enables extended thinking.
  */
-export declare const OAUTH_BETA_HEADERS = "oauth-2025-04-20,interleaved-thinking-2025-05-14";
+export declare const OAUTH_BETA_HEADERS = "oauth-2025-04-20";
+export declare const CLAUDE_CODE_OAUTH_BETAS: readonly ["oauth-2025-04-20", "claude-code-20250219", "context-management-2025-06-27", "prompt-caching-scope-2026-01-05", "advanced-tool-use-2025-11-20", "effort-2025-11-24"];
 /**
  * Tool name prefix required for OAuth API requests
  */

package/dist/lib/auth/anthropicOAuth.js

@@ -14,7 +14,7 @@
  *
  * @module auth/anthropicOAuth
  */
-import { createHash, randomBytes } from "crypto";
+import { createHash, createHmac, randomBytes, randomUUID } from "crypto";
 import { createServer, IncomingMessage, ServerResponse } from "http";
 import { OAuthError, OAuthConfigurationError, OAuthTokenExchangeError, OAuthTokenRefreshError, OAuthTokenRevocationError, OAuthCallbackServerError, } from "../types/errors.js";
 import { logger } from "../utils/logger.js";
@@ -73,13 +73,146 @@ export const DEFAULT_SCOPES = [
 /**
  * User-Agent string to spoof Claude CLI
  */
-export const CLAUDE_CLI_USER_AGENT = "claude-cli/2.1.2 (external, cli)";
+export const CLAUDE_CODE_VERSION = "2.1.87.6d6";
+export const CLAUDE_CODE_ENTRYPOINT = "sdk-cli";
+export const CLAUDE_CLI_USER_AGENT = "claude-cli/2.1.87 (external, sdk-cli)";
+const CLAUDE_CODE_IDENTITY_TTL_MS = 3_600_000;
+const CLAUDE_CODE_IDENTITY_NAMESPACE = "neurolink-claude-code-identity-v1";
+const claudeCodeIdentityCache = new Map();
+function stableIdentityDigest(input) {
+    // These identifiers are deterministic pseudonyms for Claude Code metadata,
+    // not password hashes or authentication secrets.
+    return createHmac("sha256", CLAUDE_CODE_IDENTITY_NAMESPACE)
+        .update(input)
+        .digest("hex");
+}
+function hexToUuid(hex) {
+    const trimmed = hex.replace(/-/g, "").slice(0, 32).padEnd(32, "0");
+    return `${trimmed.slice(0, 8)}-${trimmed.slice(8, 12)}-${trimmed.slice(12, 16)}-${trimmed.slice(16, 20)}-${trimmed.slice(20, 32)}`;
+}
+function isUuid(value) {
+    return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
+}
+function buildMetadataUserId(identity) {
+    return JSON.stringify({
+        device_id: identity.deviceId,
+        account_uuid: identity.accountUuid,
+        session_id: identity.sessionId,
+    });
+}
+export function parseClaudeCodeUserId(userId) {
+    if (typeof userId !== "string") {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(userId);
+        if (typeof parsed.device_id !== "string" ||
+            !/^[0-9a-f]{64}$/i.test(parsed.device_id) ||
+            typeof parsed.account_uuid !== "string" ||
+            !isUuid(parsed.account_uuid) ||
+            typeof parsed.session_id !== "string" ||
+            !isUuid(parsed.session_id)) {
+            return null;
+        }
+        return {
+            deviceId: parsed.device_id,
+            accountUuid: parsed.account_uuid,
+            sessionId: parsed.session_id,
+            metadataUserId: buildMetadataUserId({
+                deviceId: parsed.device_id,
+                accountUuid: parsed.account_uuid,
+                sessionId: parsed.session_id,
+            }),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function getOrCreateClaudeCodeIdentity(seed, options) {
+    const parsedExisting = parseClaudeCodeUserId(options?.existingUserId);
+    if (parsedExisting) {
+        if (options?.preferredSessionId && isUuid(options.preferredSessionId)) {
+            return {
+                deviceId: parsedExisting.deviceId,
+                accountUuid: parsedExisting.accountUuid,
+                sessionId: options.preferredSessionId,
+                metadataUserId: buildMetadataUserId({
+                    deviceId: parsedExisting.deviceId,
+                    accountUuid: parsedExisting.accountUuid,
+                    sessionId: options.preferredSessionId,
+                }),
+            };
+        }
+        return parsedExisting;
+    }
+    const now = Date.now();
+    const cacheKey = seed || "default";
+    const cached = claudeCodeIdentityCache.get(cacheKey);
+    if (cached && cached.expiresAt > now) {
+        if (options?.preferredSessionId && isUuid(options.preferredSessionId)) {
+            return {
+                deviceId: cached.deviceId,
+                accountUuid: cached.accountUuid,
+                sessionId: options.preferredSessionId,
+                metadataUserId: buildMetadataUserId({
+                    deviceId: cached.deviceId,
+                    accountUuid: cached.accountUuid,
+                    sessionId: options.preferredSessionId,
+                }),
+            };
+        }
+        return cached;
+    }
+    const deviceId = stableIdentityDigest(`${cacheKey}:device`);
+    const accountUuid = hexToUuid(stableIdentityDigest(`${cacheKey}:account`));
+    const sessionId = options?.preferredSessionId && isUuid(options.preferredSessionId)
+        ? options.preferredSessionId
+        : randomUUID();
+    const identity = {
+        deviceId,
+        accountUuid,
+        sessionId,
+        metadataUserId: buildMetadataUserId({
+            deviceId,
+            accountUuid,
+            sessionId,
+        }),
+        expiresAt: now + CLAUDE_CODE_IDENTITY_TTL_MS,
+    };
+    claudeCodeIdentityCache.set(cacheKey, identity);
+    return identity;
+}
+export function purgeExpiredClaudeCodeIdentities(now = Date.now()) {
+    let removed = 0;
+    for (const [cacheKey, identity] of claudeCodeIdentityCache.entries()) {
+        if (identity.expiresAt <= now) {
+            claudeCodeIdentityCache.delete(cacheKey);
+            removed += 1;
+        }
+    }
+    return removed;
+}
+export function buildStableClaudeCodeBillingHeader(originalText) {
+    const version = originalText?.match(/cc_version=([^;]+)/)?.[1]?.trim() ||
+        CLAUDE_CODE_VERSION;
+    const entrypoint = originalText?.match(/cc_entrypoint=([^;]+)/)?.[1]?.trim() ||
+        CLAUDE_CODE_ENTRYPOINT;
+    return `x-anthropic-billing-header: cc_version=${version}; cc_entrypoint=${entrypoint}; cch=00000;`;
+}
 /**
  * Required beta headers for OAuth API requests.
  * The "oauth-2025-04-20" header is CRITICAL for OAuth authentication.
- * The "interleaved-thinking-2025-05-14" enables extended thinking.
  */
-export const OAUTH_BETA_HEADERS = "oauth-2025-04-20,interleaved-thinking-2025-05-14";
+export const OAUTH_BETA_HEADERS = "oauth-2025-04-20";
+export const CLAUDE_CODE_OAUTH_BETAS = [
+    "oauth-2025-04-20",
+    "claude-code-20250219",
+    "context-management-2025-06-27",
+    "prompt-caching-scope-2026-01-05",
+    "advanced-tool-use-2025-11-20",
+    "effort-2025-11-24",
+];
 /**
  * Tool name prefix required for OAuth API requests
  */

package/dist/lib/auth/providers/firebase.js

@@ -60,8 +60,12 @@ export class FirebaseAuthProvider extends BaseAuthProvider {
             await this.initialize();
         }
         try {
+            const jwks = this.jwks;
+            if (!jwks) {
+                throw AuthError.create("PROVIDER_INIT_FAILED", "Firebase JWKS was not initialized", { details: { provider: "firebase" } });
+            }
             // Verify the token using Google's public keys
-            const { payload } = await jose.jwtVerify(token, this.jwks, {
+            const { payload } = await jose.jwtVerify(token, jwks, {
                 issuer: `https://securetoken.google.com/${this.projectId}`,
                 audience: this.projectId,
             });

package/dist/lib/auth/providers/jwt.js

@@ -92,6 +92,10 @@ export class JWTProvider extends BaseAuthProvider {
             await this.initialize();
         }
         try {
+            const keyObject = this.keyObject;
+            if (!keyObject) {
+                throw AuthError.create("PROVIDER_INIT_FAILED", "JWT verification key was not initialized", { details: { provider: "jwt" } });
+            }
             const verifyOptions = {};
             if (this.algorithms.length > 0) {
                 verifyOptions.algorithms = this
@@ -103,7 +107,7 @@ export class JWTProvider extends BaseAuthProvider {
             if (this.audience) {
                 verifyOptions.audience = this.audience;
             }
-            const { payload } = await jose.jwtVerify(token, this.keyObject, verifyOptions);
+            const { payload } = await jose.jwtVerify(token, keyObject, verifyOptions);
             // Reject tokens without a non-empty sub claim
             if (!payload.sub) {
                 return {

package/dist/lib/auth/providers/workos.js

@@ -65,8 +65,12 @@ export class WorkOSProvider extends BaseAuthProvider {
             await this.initialize();
         }
         try {
+            const jwks = this.jwks;
+            if (!jwks) {
+                throw AuthError.create("PROVIDER_INIT_FAILED", "WorkOS JWKS was not initialized", { details: { provider: "workos" } });
+            }
             // Verify the JWT
-            const { payload } = await jose.jwtVerify(token, this.jwks, {
+            const { payload } = await jose.jwtVerify(token, jwks, {
                 audience: this.clientId,
             });
             // Enforce organizationId if configured

package/dist/lib/auth/sessionManager.d.ts

@@ -46,7 +46,7 @@ export declare class MemorySessionStorage implements SessionManagerStorage {
  * Redis session storage
  *
  * Distributed session storage using Redis. Suitable for multi-instance
- * deployments. Requires ioredis or similar Redis client.
+ * deployments. Requires the "redis" (node-redis) package.
  *
  * Note: Redis client must be provided or configured via environment.
  */