@juspay/neurolink 9.30.0 → 9.31.0

package/dist/server/routes/healthRoutes.js

@@ -119,7 +119,8 @@ export function createHealthRoutes(basePath = "/api") {
                         available: !!memory,
                         type: memory?.constructor.name || "none",
                     };
-                    return {
+                    // Build the base health response
+                    const healthResponse = {
                         status: "ok",
                         timestamp: new Date().toISOString(),
                         uptime: process.uptime() * 1000,
@@ -147,6 +148,22 @@ export function createHealthRoutes(basePath = "/api") {
                             servers: externalServers,
                         },
                     };
+                    // Add proxy account pool status when proxy mode is active
+                    if (ctx.metadata?.accountPool) {
+                        const pool = ctx.metadata.accountPool;
+                        const allAccounts = pool.getAllAccounts();
+                        const statusCounts = {};
+                        for (const a of allAccounts) {
+                            statusCounts[a.status] = (statusCounts[a.status] || 0) + 1;
+                        }
+                        healthResponse.proxy = {
+                            totalAccounts: allAccounts.length,
+                            statusDistribution: statusCounts,
+                            healthyCount: pool.getHealthyCount(),
+                            strategy: pool.getStrategy(),
+                        };
+                    }
+                    return healthResponse;
                 },
                 description: "Detailed health information",
                 tags: ["health"],

package/dist/server/routes/index.d.ts

@@ -4,6 +4,7 @@
  */
 import type { RouteDefinition, RouteGroup } from "../types.js";
 export { createAgentRoutes } from "./agentRoutes.js";
+export { createClaudeProxyRoutes } from "./claudeProxyRoutes.js";
 export { createHealthRoutes } from "./healthRoutes.js";
 export { createMCPRoutes } from "./mcpRoutes.js";
 export { createMemoryRoutes } from "./memoryRoutes.js";
@@ -27,6 +28,12 @@ export type CreateRoutesOptions = {
      * default endpoint definitions.
      */
     getRoutes?: () => RouteDefinition[];
+    /**
+     * Enable or disable the Claude-compatible proxy routes.
+     * When true, registers /v1/messages, /v1/models, and /v1/messages/count_tokens
+     * endpoints that accept Anthropic API format requests.
+     */
+    claudeProxy?: boolean;
 };
 /**
  * Create all standard routes

package/dist/server/routes/index.js

@@ -3,6 +3,8 @@
  * Pre-built route definitions for common NeuroLink endpoints
  */
 import { createAgentRoutes } from "./agentRoutes.js";
+import { createClaudeProxyRoutes } from "./claudeProxyRoutes.js";
+// ClaudeProxyDeps removed
 import { createHealthRoutes } from "./healthRoutes.js";
 import { createMCPRoutes } from "./mcpRoutes.js";
 import { createMemoryRoutes } from "./memoryRoutes.js";
@@ -10,6 +12,8 @@ import { createOpenApiRoutes } from "./openApiRoutes.js";
 import { createToolRoutes } from "./toolRoutes.js";
 // Re-export route builders from individual files
 export { createAgentRoutes } from "./agentRoutes.js";
+export { createClaudeProxyRoutes } from "./claudeProxyRoutes.js";
+// ClaudeProxyDeps removed
 export { createHealthRoutes } from "./healthRoutes.js";
 export { createMCPRoutes } from "./mcpRoutes.js";
 export { createMemoryRoutes } from "./memoryRoutes.js";
@@ -31,6 +35,10 @@ export function createAllRoutes(basePath = "/api", options) {
     if (options?.enableSwagger) {
         routes.push(createOpenApiRoutes(basePath, options.getRoutes));
     }
+    // Conditionally add Claude-compatible proxy routes
+    if (options?.claudeProxy) {
+        routes.push(createClaudeProxyRoutes(undefined, basePath));
+    }
     return routes;
 }
 /**

package/dist/server/streaming/dataStream.d.ts

@@ -4,6 +4,7 @@
  * Compatible with AI SDK's data stream format
  */
 import type { DataStreamWriter } from "../types.js";
+import type { CloseHandler } from "../../types/index.js";
 /**
  * Data stream event types
  */
@@ -259,10 +260,6 @@ export type SSEEventOptions = {
  * ```
  */
 export declare function formatSSEEvent(options: SSEEventOptions): string;
-/**
- * Close handler type
- */
-type CloseHandler = () => void;
 /**
  * Base class for data stream writers
  * Provides common functionality for streaming data
@@ -341,4 +338,3 @@ export declare class WebStreamWriter extends BaseDataStreamWriter {
     writeEvent(eventType: string, data: unknown): void;
     protected doClose(): void;
 }
-export {};

package/dist/server/streaming/dataStream.js

@@ -341,6 +341,9 @@ export function formatSSEEvent(options) {
     }
     return lines.join("\n") + "\n\n";
 }
+// ============================================
+// WebStreamWriter (Legacy Compatibility)
+// ============================================
 /**
  * Base class for data stream writers
  * Provides common functionality for streaming data

package/dist/server/utils/validation.d.ts

@@ -7,59 +7,21 @@ import { z } from "zod";
  * Agent execute request schema
  */
 export declare const AgentExecuteRequestSchema: z.ZodObject<{
-    input: z.ZodUnion<[z.ZodString, z.ZodObject<{
+    input: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         text: z.ZodString;
-        images: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        text: string;
-        images?: string[] | undefined;
-        files?: string[] | undefined;
-    }, {
-        text: string;
-        images?: string[] | undefined;
-        files?: string[] | undefined;
-    }>]>;
+        images: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        files: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>]>;
     provider: z.ZodOptional<z.ZodString>;
     model: z.ZodOptional<z.ZodString>;
     systemPrompt: z.ZodOptional<z.ZodString>;
     temperature: z.ZodOptional<z.ZodNumber>;
     maxTokens: z.ZodOptional<z.ZodNumber>;
-    tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
     stream: z.ZodOptional<z.ZodBoolean>;
     sessionId: z.ZodOptional<z.ZodString>;
     userId: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    input: string | {
-        text: string;
-        images?: string[] | undefined;
-        files?: string[] | undefined;
-    };
-    provider?: string | undefined;
-    model?: string | undefined;
-    userId?: string | undefined;
-    stream?: boolean | undefined;
-    sessionId?: string | undefined;
-    maxTokens?: number | undefined;
-    systemPrompt?: string | undefined;
-    temperature?: number | undefined;
-    tools?: string[] | undefined;
-}, {
-    input: string | {
-        text: string;
-        images?: string[] | undefined;
-        files?: string[] | undefined;
-    };
-    provider?: string | undefined;
-    model?: string | undefined;
-    userId?: string | undefined;
-    stream?: boolean | undefined;
-    sessionId?: string | undefined;
-    maxTokens?: number | undefined;
-    systemPrompt?: string | undefined;
-    temperature?: number | undefined;
-    tools?: string[] | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Tool execute request schema
  */
@@ -68,17 +30,7 @@ export declare const ToolExecuteRequestSchema: z.ZodObject<{
     arguments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     sessionId: z.ZodOptional<z.ZodString>;
     userId: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    arguments: Record<string, unknown>;
-    userId?: string | undefined;
-    sessionId?: string | undefined;
-}, {
-    name: string;
-    userId?: string | undefined;
-    sessionId?: string | undefined;
-    arguments?: Record<string, unknown> | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Tool arguments schema (for direct tool execution)
  */
@@ -88,86 +40,48 @@ export declare const ToolArgumentsSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>
  */
 export declare const SessionIdParamSchema: z.ZodObject<{
     sessionId: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    sessionId: string;
-}, {
-    sessionId: string;
-}>;
+}, z.core.$strip>;
 /**
  * MCP server name parameter schema
  */
 export declare const ServerNameParamSchema: z.ZodObject<{
     name: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-}, {
-    name: string;
-}>;
+}, z.core.$strip>;
 /**
  * Tool name parameter schema
  */
 export declare const ToolNameParamSchema: z.ZodObject<{
     name: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-}, {
-    name: string;
-}>;
+}, z.core.$strip>;
 /**
  * Tool search query schema
  */
 export declare const ToolSearchQuerySchema: z.ZodObject<{
     q: z.ZodOptional<z.ZodString>;
     source: z.ZodOptional<z.ZodString>;
-    limit: z.ZodOptional<z.ZodPipeline<z.ZodEffects<z.ZodString, number, string>, z.ZodNumber>>;
-}, "strip", z.ZodTypeAny, {
-    source?: string | undefined;
-    limit?: number | undefined;
-    q?: string | undefined;
-}, {
-    source?: string | undefined;
-    limit?: string | undefined;
-    q?: string | undefined;
-}>;
+    limit: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
+}, z.core.$strip>;
 /**
  * Generic ID parameter schema (for session endpoints using :id)
  */
 export declare const IdParamSchema: z.ZodObject<{
     id: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-}, {
-    id: string;
-}>;
+}, z.core.$strip>;
 /**
  * Sessions list query schema (with optional pagination and filtering)
  */
 export declare const SessionsListQuerySchema: z.ZodObject<{
     userId: z.ZodOptional<z.ZodString>;
-    limit: z.ZodOptional<z.ZodPipeline<z.ZodEffects<z.ZodString, number, string>, z.ZodNumber>>;
-    offset: z.ZodOptional<z.ZodPipeline<z.ZodEffects<z.ZodString, number, string>, z.ZodNumber>>;
-}, "strip", z.ZodTypeAny, {
-    userId?: string | undefined;
-    offset?: number | undefined;
-    limit?: number | undefined;
-}, {
-    userId?: string | undefined;
-    offset?: string | undefined;
-    limit?: string | undefined;
-}>;
+    limit: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
+    offset: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
+}, z.core.$strip>;
 /**
  * Session messages query schema (for pagination)
  */
 export declare const SessionMessagesQuerySchema: z.ZodObject<{
-    limit: z.ZodOptional<z.ZodPipeline<z.ZodEffects<z.ZodString, number, string>, z.ZodNumber>>;
-    offset: z.ZodOptional<z.ZodPipeline<z.ZodEffects<z.ZodString, number, string>, z.ZodNumber>>;
-}, "strip", z.ZodTypeAny, {
-    offset?: number | undefined;
-    limit?: number | undefined;
-}, {
-    offset?: string | undefined;
-    limit?: string | undefined;
-}>;
+    limit: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
+    offset: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>, z.ZodNumber>>;
+}, z.core.$strip>;
 /**
  * Embed request schema (single text)
  */
@@ -175,31 +89,15 @@ export declare const EmbedRequestSchema: z.ZodObject<{
     text: z.ZodString;
     provider: z.ZodOptional<z.ZodString>;
     model: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    text: string;
-    provider?: string | undefined;
-    model?: string | undefined;
-}, {
-    text: string;
-    provider?: string | undefined;
-    model?: string | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Embed many request schema (batch texts)
  */
 export declare const EmbedManyRequestSchema: z.ZodObject<{
-    texts: z.ZodArray<z.ZodString, "many">;
+    texts: z.ZodArray<z.ZodString>;
     provider: z.ZodOptional<z.ZodString>;
     model: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    texts: string[];
-    provider?: string | undefined;
-    model?: string | undefined;
-}, {
-    texts: string[];
-    provider?: string | undefined;
-    model?: string | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Standardized error response format
  */
@@ -229,9 +127,11 @@ export declare function createErrorResponse(code: string, message: string, detai
 export type ValidationResult<T> = {
     success: true;
     data: T;
+    error?: undefined;
 } | {
     success: false;
     error: ErrorResponse;
+    data?: undefined;
 };
 /**
  * Validate request body against a Zod schema

package/dist/server/utils/validation.js

@@ -33,14 +33,14 @@ export const AgentExecuteRequestSchema = z.object({
  */
 export const ToolExecuteRequestSchema = z.object({
     name: z.string().min(1, "Tool name is required"),
-    arguments: z.record(z.unknown()).default({}),
+    arguments: z.record(z.string(), z.unknown()).default({}),
     sessionId: z.string().optional(),
     userId: z.string().optional(),
 });
 /**
  * Tool arguments schema (for direct tool execution)
  */
-export const ToolArgumentsSchema = z.record(z.unknown());
+export const ToolArgumentsSchema = z.record(z.string(), z.unknown());
 /**
  * Memory session ID parameter schema
  */

package/dist/services/server/ai/observability/instrumentation.js

@@ -381,12 +381,14 @@ export function initializeOpenTelemetry(config) {
             currentConfig = config;
             isCredentialsValid = true;
             // Create span processor for external provider mode
+            // shouldExportSpan: export all spans (v5 default filters to gen_ai spans only)
             langfuseProcessor = new LangfuseSpanProcessor({
                 publicKey: config.publicKey,
                 secretKey: config.secretKey,
                 baseUrl: config.baseUrl || "https://cloud.langfuse.com",
                 environment: config.environment || "dev",
                 release: config.release || "v1.0.0",
+                shouldExportSpan: () => true,
             });
             usingExternalProvider = true;
             isInitialized = true;
@@ -471,12 +473,14 @@ export function initializeOpenTelemetry(config) {
         currentConfig = config;
         isCredentialsValid = true;
         // Step 1: Create LangfuseSpanProcessor for standalone mode
+        // shouldExportSpan: export all spans (v5 default filters to gen_ai spans only)
         langfuseProcessor = new LangfuseSpanProcessor({
             publicKey: config.publicKey,
             secretKey: config.secretKey,
             baseUrl: config.baseUrl || "https://cloud.langfuse.com",
             environment: config.environment || "dev",
             release: config.release || "v1.0.0",
+            shouldExportSpan: () => true,
         });
         logger.debug(`${LOG_PREFIX} Created LangfuseSpanProcessor`, {
             baseUrl: config.baseUrl || "https://cloud.langfuse.com",

package/dist/telemetry/attributes.d.ts

@@ -44,6 +44,44 @@ export declare const ATTR: {
     readonly MSG_HAS_SYSTEM_PROMPT: "message.has_system_prompt";
     readonly MSG_TOTAL_CONTENT_LENGTH: "message.total_content_length";
     readonly MSG_IS_MULTIMODAL: "message.is_multimodal";
+    readonly FILE_NAME: "file.name";
+    readonly FILE_MIMETYPE: "file.mimetype";
+    readonly FILE_SIZE_BYTES: "file.size_bytes";
+    readonly FILE_CATEGORY: "file.category";
+    readonly FILE_OUTPUT_LENGTH: "file.output_length";
+    readonly FILE_SUCCESS: "file.success";
+    readonly FILE_PROCESSOR_USED: "file.processor_used";
+    readonly FILE_CONFIDENCE: "file.detection_confidence";
+    readonly FILE_HAS_IMAGES: "file.has_images";
+    readonly FILE_IMAGE_COUNT: "file.image_count";
+    readonly FILE_ERROR: "file.error";
+    readonly FILE_SKIPPED_REASON: "file.skipped_reason";
+    readonly FILE_TOTAL_COUNT: "file.total_count";
+    readonly FILE_INCLUDED_COUNT: "file.included_count";
+    readonly FILE_CONTENT_TYPE: "file.content_type";
+    readonly VIDEO_DURATION_SEC: "video.duration_sec";
+    readonly VIDEO_WIDTH: "video.width";
+    readonly VIDEO_HEIGHT: "video.height";
+    readonly VIDEO_CODEC: "video.codec";
+    readonly VIDEO_AUDIO_CODEC: "video.audio_codec";
+    readonly VIDEO_FORMAT: "video.format";
+    readonly VIDEO_BITRATE: "video.bitrate";
+    readonly VIDEO_KEYFRAMES_EXTRACTED: "video.keyframes_extracted";
+    readonly VIDEO_TARGET_FRAMES: "video.target_frames";
+    readonly VIDEO_INTERVAL_SEC: "video.interval_sec";
+    readonly VIDEO_FRAME_QUALITY: "video.frame_quality";
+    readonly VIDEO_FRAME_RESIZE_PX: "video.frame_resize_px";
+    readonly VIDEO_FRAMES_RESIZED: "video.frames_resized";
+    readonly VIDEO_TOTAL_FRAME_BYTES: "video.total_frame_bytes";
+    readonly VIDEO_HAS_SUBTITLES: "video.has_subtitles";
+    readonly VIDEO_SUBTITLE_LENGTH: "video.subtitle_length";
+    readonly VIDEO_TEXT_CONTENT_LENGTH: "video.text_content_length";
+    readonly VIDEO_HAS_METADATA: "video.has_metadata";
+    readonly VIDEO_HAS_KEYFRAMES: "video.has_keyframes";
+    readonly VIDEO_TEMP_PATH: "video.temp_path";
+    readonly VIDEO_BYTES_WRITTEN: "video.bytes_written";
+    readonly VIDEO_WRITE_DURATION_MS: "video.write_duration_ms";
+    readonly VIDEO_STEP: "video.step";
     readonly CONTEXT_STAGE: "context.compaction_stage";
     readonly CONTEXT_TOKENS_BEFORE: "context.tokens_before";
     readonly CONTEXT_TOKENS_AFTER: "context.tokens_after";

package/dist/telemetry/attributes.js

@@ -50,6 +50,46 @@ export const ATTR = {
     MSG_HAS_SYSTEM_PROMPT: "message.has_system_prompt",
     MSG_TOTAL_CONTENT_LENGTH: "message.total_content_length",
     MSG_IS_MULTIMODAL: "message.is_multimodal",
+    // File processing
+    FILE_NAME: "file.name",
+    FILE_MIMETYPE: "file.mimetype",
+    FILE_SIZE_BYTES: "file.size_bytes",
+    FILE_CATEGORY: "file.category",
+    FILE_OUTPUT_LENGTH: "file.output_length",
+    FILE_SUCCESS: "file.success",
+    FILE_PROCESSOR_USED: "file.processor_used",
+    FILE_CONFIDENCE: "file.detection_confidence",
+    FILE_HAS_IMAGES: "file.has_images",
+    FILE_IMAGE_COUNT: "file.image_count",
+    FILE_ERROR: "file.error",
+    FILE_SKIPPED_REASON: "file.skipped_reason",
+    FILE_TOTAL_COUNT: "file.total_count",
+    FILE_INCLUDED_COUNT: "file.included_count",
+    FILE_CONTENT_TYPE: "file.content_type",
+    // Video processing
+    VIDEO_DURATION_SEC: "video.duration_sec",
+    VIDEO_WIDTH: "video.width",
+    VIDEO_HEIGHT: "video.height",
+    VIDEO_CODEC: "video.codec",
+    VIDEO_AUDIO_CODEC: "video.audio_codec",
+    VIDEO_FORMAT: "video.format",
+    VIDEO_BITRATE: "video.bitrate",
+    VIDEO_KEYFRAMES_EXTRACTED: "video.keyframes_extracted",
+    VIDEO_TARGET_FRAMES: "video.target_frames",
+    VIDEO_INTERVAL_SEC: "video.interval_sec",
+    VIDEO_FRAME_QUALITY: "video.frame_quality",
+    VIDEO_FRAME_RESIZE_PX: "video.frame_resize_px",
+    VIDEO_FRAMES_RESIZED: "video.frames_resized",
+    VIDEO_TOTAL_FRAME_BYTES: "video.total_frame_bytes",
+    VIDEO_HAS_SUBTITLES: "video.has_subtitles",
+    VIDEO_SUBTITLE_LENGTH: "video.subtitle_length",
+    VIDEO_TEXT_CONTENT_LENGTH: "video.text_content_length",
+    VIDEO_HAS_METADATA: "video.has_metadata",
+    VIDEO_HAS_KEYFRAMES: "video.has_keyframes",
+    VIDEO_TEMP_PATH: "video.temp_path",
+    VIDEO_BYTES_WRITTEN: "video.bytes_written",
+    VIDEO_WRITE_DURATION_MS: "video.write_duration_ms",
+    VIDEO_STEP: "video.step",
     // Context
     CONTEXT_STAGE: "context.compaction_stage",
     CONTEXT_TOKENS_BEFORE: "context.tokens_before",

package/dist/telemetry/tracers.d.ts

@@ -12,4 +12,5 @@ export declare const tracers: {
     readonly context: import("@opentelemetry/api").Tracer;
     readonly middleware: import("@opentelemetry/api").Tracer;
     readonly processor: import("@opentelemetry/api").Tracer;
+    readonly file: import("@opentelemetry/api").Tracer;
 };

package/dist/telemetry/tracers.js

@@ -13,4 +13,5 @@ export const tracers = {
     context: trace.getTracer("neurolink.context"),
     middleware: trace.getTracer("neurolink.middleware"),
     processor: trace.getTracer("neurolink.processor"),
+    file: trace.getTracer("neurolink.file"),
 };

package/dist/types/authTypes.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Auth-related type definitions for NeuroLink
+ *
+ * Canonical location for OAuth token storage types and token refresher contracts.
+ * All auth type imports should reference this module (or the barrel re-export
+ * via src/lib/types/index.ts).
+ */
+/**
+ * OAuth tokens structure for storage.
+ * Stricter version of OAuthTokens with required fields for persistent storage.
+ */
+export type StoredOAuthTokens = {
+    /** The access token for API authentication */
+    accessToken: string;
+    /** The refresh token for obtaining new access tokens (optional for some OAuth flows) */
+    refreshToken?: string;
+    /** Unix timestamp (ms) when the access token expires */
+    expiresAt: number;
+    /** Token type, typically "Bearer" */
+    tokenType: string;
+    /** Optional OAuth scopes granted */
+    scope?: string;
+};
+/**
+ * Token refresher function type.
+ * Takes a refresh token and returns new tokens.
+ */
+export type TokenRefresher = (refreshToken: string) => Promise<StoredOAuthTokens>;
+/**
+ * Internal storage format for multi-provider tokens
+ */
+export type TokenStorageData = {
+    /** Version of the storage format */
+    version: string;
+    /** Last modified timestamp */
+    lastModified: number;
+    /** Tokens indexed by provider name */
+    providers: Record<string, StoredProviderTokens>;
+};
+/**
+ * Per-provider token storage structure
+ */
+export type StoredProviderTokens = {
+    /** The stored tokens */
+    tokens: StoredOAuthTokens;
+    /** When the tokens were stored */
+    createdAt: number;
+    /** When the tokens were last accessed */
+    lastAccessed: number;
+    /** Whether this provider's tokens are permanently disabled */
+    disabled?: boolean;
+    /** When the tokens were disabled (Unix ms) */
+    disabledAt?: number;
+    /** Reason the tokens were disabled (e.g., "refresh_failed") */
+    disabledReason?: string;
+};

package/dist/types/authTypes.js

@@ -0,0 +1,8 @@
+/**
+ * Auth-related type definitions for NeuroLink
+ *
+ * Canonical location for OAuth token storage types and token refresher contracts.
+ * All auth type imports should reference this module (or the barrel re-export
+ * via src/lib/types/index.ts).
+ */
+export {};

package/dist/types/circuitBreakerErrors.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Circuit Breaker Error Classes
+ * Shared error types for circuit breaker implementations across the codebase.
+ * Lives in types/ to avoid circular dependencies between utils/ and mcp/.
+ */
+import type { CircuitBreakerState } from "./mcpTypes.js";
+/**
+ * Typed error thrown when a circuit breaker is open or half-open call limit is reached.
+ * Contains structured metadata so callers can build actionable error messages
+ * for AI models and downstream consumers.
+ */
+export declare class CircuitBreakerOpenError extends Error {
+    /** The circuit breaker name (e.g., "tool-execution-bitbucket-server-add_comment") */
+    readonly breakerName: string;
+    /** ISO timestamp when the circuit breaker will transition to half-open and allow a retry */
+    readonly retryAfter: string;
+    /** Milliseconds until the circuit breaker will allow a retry */
+    readonly retryAfterMs: number;
+    /** Current circuit breaker state ("open" or "half-open") */
+    readonly breakerState: CircuitBreakerState;
+    /** Number of failures that caused the circuit to open */
+    readonly failureCount: number;
+    constructor(options: {
+        breakerName: string;
+        retryAfter: Date;
+        retryAfterMs: number;
+        breakerState: CircuitBreakerState;
+        failureCount: number;
+    });
+}

package/dist/types/circuitBreakerErrors.js

@@ -0,0 +1,34 @@
+/**
+ * Circuit Breaker Error Classes
+ * Shared error types for circuit breaker implementations across the codebase.
+ * Lives in types/ to avoid circular dependencies between utils/ and mcp/.
+ */
+/**
+ * Typed error thrown when a circuit breaker is open or half-open call limit is reached.
+ * Contains structured metadata so callers can build actionable error messages
+ * for AI models and downstream consumers.
+ */
+export class CircuitBreakerOpenError extends Error {
+    /** The circuit breaker name (e.g., "tool-execution-bitbucket-server-add_comment") */
+    breakerName;
+    /** ISO timestamp when the circuit breaker will transition to half-open and allow a retry */
+    retryAfter;
+    /** Milliseconds until the circuit breaker will allow a retry */
+    retryAfterMs;
+    /** Current circuit breaker state ("open" or "half-open") */
+    breakerState;
+    /** Number of failures that caused the circuit to open */
+    failureCount;
+    constructor(options) {
+        const retryAfterStr = options.retryAfter.toISOString();
+        super(`Circuit breaker '${options.breakerName}' is ${options.breakerState}. ` +
+            `Tool temporarily unavailable after ${options.failureCount} failures. ` +
+            `Retry after: ${retryAfterStr} (${Math.ceil(options.retryAfterMs / 1000)}s).`);
+        this.name = "CircuitBreakerOpenError";
+        this.breakerName = options.breakerName;
+        this.retryAfter = retryAfterStr;
+        this.retryAfterMs = options.retryAfterMs;
+        this.breakerState = options.breakerState;
+        this.failureCount = options.failureCount;
+    }
+}