@juspay/neurolink 9.54.3 → 9.54.5

package/dist/client/reactHooks.tsx

@@ -28,7 +28,7 @@ import type { ReactNode } from "react";
 
 import type {
   ClientConfig,
-  ApiError,
+  ClientApiError,
   NeuroLinkProviderProps,
   UseChatOptions,
   UseChatReturn,
@@ -43,21 +43,20 @@ import type {
   UseToolsOptions,
   UseToolsReturn,
   ClientChatMessage as ChatMessage,
-  AgentExecuteOptions,
-  AgentExecuteResult,
-  WorkflowExecuteOptions,
-  WorkflowExecuteResult,
-  StreamCallbacks,
+  ClientAgentExecuteOptions,
+  ClientAgentExecuteResult,
+  ClientWorkflowExecuteOptions,
+  ClientWorkflowExecuteResult,
+  ClientStreamCallbacks,
   ClientStreamEvent as StreamEvent,
-  ToolInfo,
+  ClientToolInfo,
   SpeechRecognitionInternal,
   SpeechRecognitionEventInternal,
   SpeechRecognitionErrorEventInternal,
-} from "../types/clientTypes.js";
+  UnknownRecord,
+  StreamToolCall,
+} from "../types/index.js";
 import { NeuroLinkClient, createClient } from "./httpClient.js";
-import type { UnknownRecord } from "../types/common.js";
-import type { ToolCall } from "../types/streamTypes.js";
-
 // =============================================================================
 // Context and Provider
 // =============================================================================
@@ -185,8 +184,8 @@ export function useChat(options: UseChatOptions = {}): UseChatReturn {
   const [messages, setMessages] = useState<ChatMessage[]>(initialMessages);
   const [input, setInput] = useState("");
   const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState<ApiError | null>(null);
-  const [toolCalls, setToolCalls] = useState<ToolCall[]>([]);
+  const [error, setError] = useState<ClientApiError | null>(null);
+  const [toolCalls, setToolCalls] = useState<StreamToolCall[]>([]);
 
   const abortControllerRef = useRef<AbortController | null>(null);
   const sessionIdRef = useRef<string | undefined>(initialSessionId);
@@ -226,7 +225,7 @@ export function useChat(options: UseChatOptions = {}): UseChatReturn {
       abortControllerRef.current = new AbortController();
 
       const assistantId = generateId();
-      const currentToolCalls: ToolCall[] = [];
+      const currentToolCalls: StreamToolCall[] = [];
       let assistantContent = "";
 
       // Add placeholder for assistant message
@@ -330,7 +329,7 @@ export function useChat(options: UseChatOptions = {}): UseChatReturn {
         if ((err as Error).name === "AbortError") {
           return null;
         }
-        const apiError = err as ApiError;
+        const apiError = err as ClientApiError;
         setError(apiError);
         onError?.(apiError);
         return null;
@@ -482,8 +481,8 @@ export function useAgent(options: UseAgentOptions): UseAgentReturn {
   );
   const [isLoading, setIsLoading] = useState(false);
   const [isStreaming, setIsStreaming] = useState(false);
-  const [result, setResult] = useState<AgentExecuteResult | null>(null);
-  const [error, setError] = useState<ApiError | null>(null);
+  const [result, setResult] = useState<ClientAgentExecuteResult | null>(null);
+  const [error, setError] = useState<ClientApiError | null>(null);
 
   const abortControllerRef = useRef<AbortController | null>(null);
   const hasAutoExecuted = useRef(false);
@@ -500,8 +499,8 @@ export function useAgent(options: UseAgentOptions): UseAgentReturn {
   const execute = useCallback(
     async (
       input: string,
-      executeOptions?: Partial<AgentExecuteOptions>,
-    ): Promise<AgentExecuteResult> => {
+      executeOptions?: Partial<ClientAgentExecuteOptions>,
+    ): Promise<ClientAgentExecuteResult> => {
       setIsLoading(true);
       setError(null);
 
@@ -525,7 +524,7 @@ export function useAgent(options: UseAgentOptions): UseAgentReturn {
 
         return agentResult;
       } catch (err) {
-        const apiError = err as ApiError;
+        const apiError = err as ClientApiError;
         setError(apiError);
         onError?.(apiError);
         throw err;
@@ -541,7 +540,7 @@ export function useAgent(options: UseAgentOptions): UseAgentReturn {
    * Stream agent execution
    */
   const stream = useCallback(
-    async (input: string, callbacks?: StreamCallbacks): Promise<void> => {
+    async (input: string, callbacks?: ClientStreamCallbacks): Promise<void> => {
       setIsStreaming(true);
       setIsLoading(true);
       setError(null);
@@ -575,7 +574,7 @@ export function useAgent(options: UseAgentOptions): UseAgentReturn {
           { signal: abortControllerRef.current.signal },
         );
       } catch (err) {
-        const apiError = err as ApiError;
+        const apiError = err as ClientApiError;
         setError(apiError);
         onError?.(apiError);
       } finally {
@@ -674,12 +673,14 @@ export function useWorkflow(options: UseWorkflowOptions): UseWorkflowReturn {
 
   const client = useNeuroLinkClient();
   const [runId, setRunId] = useState<string | null>(null);
-  const [status, setStatus] = useState<WorkflowExecuteResult["status"] | null>(
+  const [status, setStatus] = useState<
+    ClientWorkflowExecuteResult["status"] | null
+  >(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [result, setResult] = useState<ClientWorkflowExecuteResult | null>(
     null,
   );
-  const [isLoading, setIsLoading] = useState(false);
-  const [result, setResult] = useState<WorkflowExecuteResult | null>(null);
-  const [error, setError] = useState<ApiError | null>(null);
+  const [error, setError] = useState<ClientApiError | null>(null);
 
   const pollIntervalRef = useRef<ReturnType<typeof setInterval> | null>(null);
   const previousStepsRef = useRef<Set<string>>(new Set());
@@ -741,7 +742,7 @@ export function useWorkflow(options: UseWorkflowOptions): UseWorkflowReturn {
       } catch (err) {
         stopPolling();
         setIsLoading(false);
-        const apiError = err as ApiError;
+        const apiError = err as ClientApiError;
         setError(apiError);
         onError?.(apiError);
       }
@@ -769,8 +770,8 @@ export function useWorkflow(options: UseWorkflowOptions): UseWorkflowReturn {
   const execute = useCallback(
     async (
       input: UnknownRecord,
-      executeOptions?: Partial<WorkflowExecuteOptions>,
-    ): Promise<WorkflowExecuteResult> => {
+      executeOptions?: Partial<ClientWorkflowExecuteOptions>,
+    ): Promise<ClientWorkflowExecuteResult> => {
       setIsLoading(true);
       setError(null);
       setStatus(null);
@@ -806,7 +807,7 @@ export function useWorkflow(options: UseWorkflowOptions): UseWorkflowReturn {
         return workflowResult;
       } catch (err) {
         setIsLoading(false);
-        const apiError = err as ApiError;
+        const apiError = err as ClientApiError;
         setError(apiError);
         onError?.(apiError);
         throw err;
@@ -822,7 +823,7 @@ export function useWorkflow(options: UseWorkflowOptions): UseWorkflowReturn {
     async (
       resumeToken: string,
       resumeData?: UnknownRecord,
-    ): Promise<WorkflowExecuteResult> => {
+    ): Promise<ClientWorkflowExecuteResult> => {
       setIsLoading(true);
       setError(null);
 
@@ -849,7 +850,7 @@ export function useWorkflow(options: UseWorkflowOptions): UseWorkflowReturn {
         return workflowResult;
       } catch (err) {
         setIsLoading(false);
-        const apiError = err as ApiError;
+        const apiError = err as ClientApiError;
         setError(apiError);
         onError?.(apiError);
         throw err;
@@ -862,7 +863,7 @@ export function useWorkflow(options: UseWorkflowOptions): UseWorkflowReturn {
    * Get workflow status
    */
   const getStatus = useCallback(
-    async (statusRunId: string): Promise<WorkflowExecuteResult> => {
+    async (statusRunId: string): Promise<ClientWorkflowExecuteResult> => {
       const response = await client.getWorkflowStatus(workflowId, statusRunId);
       return response.data;
     },
@@ -969,7 +970,7 @@ export function useVoice(options: UseVoiceOptions = {}): UseVoiceReturn {
   const [isProcessing, setIsProcessing] = useState(false);
   const [transcript, setTranscript] = useState("");
   const [response, setResponse] = useState<string | null>(null);
-  const [error, setError] = useState<ApiError | null>(null);
+  const [error, setError] = useState<ClientApiError | null>(null);
 
   const recognitionRef = useRef<SpeechRecognitionInternal | null>(null);
   const synthesisRef = useRef<SpeechSynthesisUtterance | null>(null);
@@ -1025,7 +1026,7 @@ export function useVoice(options: UseVoiceOptions = {}): UseVoiceReturn {
     };
 
     recognition.onerror = (event: SpeechRecognitionErrorEventInternal) => {
-      const apiError: ApiError = {
+      const apiError: ClientApiError = {
         code: "SPEECH_RECOGNITION_ERROR",
         message: event.error,
         status: 500,
@@ -1103,7 +1104,7 @@ export function useVoice(options: UseVoiceOptions = {}): UseVoiceReturn {
 
             utterance.onerror = (event) => {
               setIsSpeaking(false);
-              const apiError: ApiError = {
+              const apiError: ClientApiError = {
                 code: "SPEECH_SYNTHESIS_ERROR",
                 message: event.error,
                 status: 500,
@@ -1119,7 +1120,7 @@ export function useVoice(options: UseVoiceOptions = {}): UseVoiceReturn {
         }
       } catch (err) {
         setIsSpeaking(false);
-        const apiError: ApiError = {
+        const apiError: ClientApiError = {
           code: "TTS_ERROR",
           message: (err as Error).message,
           status: 500,
@@ -1173,7 +1174,7 @@ export function useVoice(options: UseVoiceOptions = {}): UseVoiceReturn {
 
         return responseText;
       } catch (err) {
-        const apiError = err as ApiError;
+        const apiError = err as ClientApiError;
         setError(apiError);
         onError?.(apiError);
         throw err;
@@ -1242,7 +1243,7 @@ export function useStream(options: UseStreamOptions = {}): UseStreamReturn {
   const [text, setText] = useState("");
   const [events, setEvents] = useState<StreamEvent[]>([]);
   const [isStreaming, setIsStreaming] = useState(false);
-  const [error, setError] = useState<ApiError | null>(null);
+  const [error, setError] = useState<ClientApiError | null>(null);
 
   const abortControllerRef = useRef<AbortController | null>(null);
 
@@ -1327,7 +1328,7 @@ export function useStream(options: UseStreamOptions = {}): UseStreamReturn {
         if ((err as Error).name === "AbortError") {
           return;
         }
-        const apiError = err as ApiError;
+        const apiError = err as ClientApiError;
         setError(apiError);
         callbacks?.onError?.(apiError);
       } finally {
@@ -1397,9 +1398,9 @@ export function useTools(options: UseToolsOptions = {}): UseToolsReturn {
   const { category, serverId, refreshInterval } = options;
 
   const client = useNeuroLinkClient();
-  const [tools, setTools] = useState<ToolInfo[]>([]);
+  const [tools, setTools] = useState<ClientToolInfo[]>([]);
   const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState<ApiError | null>(null);
+  const [error, setError] = useState<ClientApiError | null>(null);
 
   /**
    * Refresh tool list
@@ -1412,7 +1413,7 @@ export function useTools(options: UseToolsOptions = {}): UseToolsReturn {
       const response = await client.listTools({ category, serverId });
       setTools(response.data);
     } catch (err) {
-      const apiError = err as ApiError;
+      const apiError = err as ClientApiError;
       setError(apiError);
     } finally {
       setIsLoading(false);
@@ -1453,27 +1454,6 @@ export function useTools(options: UseToolsOptions = {}): UseToolsReturn {
   };
 }
 
-// =============================================================================
-// Type Exports
-// =============================================================================
-
-export type {
-  NeuroLinkProviderProps,
-  UseChatOptions,
-  UseChatReturn,
-  UseAgentOptions,
-  UseAgentReturn,
-  UseWorkflowOptions,
-  UseWorkflowReturn,
-  UseVoiceOptions,
-  UseVoiceReturn,
-  UseStreamOptions,
-  UseStreamReturn,
-  UseToolsOptions,
-  UseToolsReturn,
-  ChatMessage,
-};
-
 // Type augmentation for SpeechRecognition (browser APIs)
 declare global {
   interface Window {

package/dist/client/sseClient.d.ts

@@ -7,48 +7,7 @@
  *
  * @module @neurolink/client/sseClient
  */
-import type { ClientConfig, StreamCallbacks, ClientStreamEvent as StreamEvent, ClientStreamResult as StreamResult, ApiError } from "../types/clientTypes.js";
-/**
- * SSE connection state
- */
-export type SSEState = "connecting" | "connected" | "disconnected" | "error";
-/**
- * SSE client configuration
- */
-export type SSEConfig = ClientConfig & {
-    /** Auto-reconnect on disconnect (default: true) */
-    autoReconnect?: boolean;
-    /** Maximum reconnection attempts (default: 5) */
-    maxReconnectAttempts?: number;
-    /** Initial reconnection delay in ms (default: 1000) */
-    reconnectDelay?: number;
-    /** Maximum reconnection delay in ms (default: 30000) */
-    maxReconnectDelay?: number;
-    /** Use native EventSource when available (default: false for more control) */
-    useNativeEventSource?: boolean;
-};
-/**
- * SSE request options
- */
-export type SSERequestOptions = {
-    /** Request body */
-    body?: unknown;
-    /** Additional headers */
-    headers?: Record<string, string>;
-    /** Abort signal */
-    signal?: AbortSignal;
-};
-/**
- * SSE event handlers
- */
-export type SSEEventHandlers = {
-    onOpen?: () => void;
-    onClose?: () => void;
-    onError?: (error: Error) => void;
-    onEvent?: (event: StreamEvent) => void;
-    onReconnect?: (attempt: number) => void;
-    onStateChange?: (state: SSEState) => void;
-};
+import type { ClientStreamCallbacks, ClientStreamEvent as StreamEvent, ClientStreamResult as StreamResult, ClientApiError, SSEConfig, SSEEventHandlers, SSERequestOptions, SSEState } from "../types/index.js";
 /**
  * SSE streaming client for NeuroLink
  *
@@ -89,7 +48,7 @@ export declare class NeuroLinkSSE {
     /**
      * Stream from an endpoint using SSE
      */
-    stream(path: string, options?: SSERequestOptions, callbacks?: StreamCallbacks): Promise<void>;
+    stream(path: string, options?: SSERequestOptions, callbacks?: ClientStreamCallbacks): Promise<void>;
     /**
      * Abort the current stream
      */
@@ -107,7 +66,7 @@ export declare class NeuroLinkSSE {
         temperature?: number;
         maxTokens?: number;
         systemPrompt?: string;
-    } & StreamCallbacks): Promise<string>;
+    } & ClientStreamCallbacks): Promise<string>;
     /**
      * Stream a chat request
      */
@@ -117,11 +76,11 @@ export declare class NeuroLinkSSE {
     }>, options?: {
         agentId?: string;
         sessionId?: string;
-    } & StreamCallbacks): Promise<string>;
+    } & ClientStreamCallbacks): Promise<string>;
     /**
      * Stream an agent execution
      */
-    executeAgent(agentId: string, input: string, options?: StreamCallbacks): Promise<string>;
+    executeAgent(agentId: string, input: string, options?: ClientStreamCallbacks): Promise<string>;
     /**
      * Stream using the browser's native EventSource API (GET requests only).
      * Provides automatic reconnection handled by the browser and a simpler
@@ -153,4 +112,4 @@ export declare class NeuroLinkSSE {
  * ```
  */
 export declare function createSSEClient(config: SSEConfig): NeuroLinkSSE;
-export type { StreamCallbacks, StreamEvent, StreamResult, ApiError };
+export type { ClientStreamCallbacks, StreamEvent, StreamResult, ClientApiError, };

package/dist/client/streamingClient.d.ts

@@ -6,66 +6,7 @@
  *
  * @module @neurolink/client/streaming
  */
-import type { ClientStreamEvent as StreamEvent, StreamCallbacks, ClientStreamResult as StreamResult, ApiError, WebSocketOptions, WebSocketState, WebSocketMessageHandler } from "../types/clientTypes.js";
-import type { JsonObject, UnknownRecord } from "../types/common.js";
-import type { ToolCall, ToolResult } from "../types/streamTypes.js";
-/**
- * SSE connection options
- */
-export type SSEConnectionOptions = {
-    /** Request headers */
-    headers?: Record<string, string>;
-    /** Request credentials */
-    credentials?: RequestCredentials;
-    /** Reconnect on disconnect */
-    autoReconnect?: boolean;
-    /** Reconnect delay in milliseconds */
-    reconnectDelay?: number;
-    /** Maximum reconnect attempts */
-    maxReconnectAttempts?: number;
-    /** Signal for request cancellation */
-    signal?: AbortSignal;
-};
-/**
- * SSE connection state
- */
-export type SSEConnectionState = "connecting" | "connected" | "disconnected" | "reconnecting" | "error";
-/**
- * Streaming request options
- */
-export type StreamingRequestOptions = {
-    /** Input text or data */
-    input: {
-        text: string;
-    } & UnknownRecord;
-    /** Provider to use */
-    provider?: string;
-    /** Model to use */
-    model?: string;
-    /** Temperature */
-    temperature?: number;
-    /** Maximum tokens */
-    maxTokens?: number;
-    /** System prompt */
-    systemPrompt?: string;
-    /** Enable tools */
-    enableTools?: boolean;
-    /** Context data */
-    context?: UnknownRecord;
-};
-/**
- * Streaming event emitter interface
- */
-export type StreamingEventEmitter = {
-    on(event: "text", callback: (text: string) => void): void;
-    on(event: "tool-call", callback: (toolCall: ToolCall) => void): void;
-    on(event: "tool-result", callback: (toolResult: ToolResult) => void): void;
-    on(event: "error", callback: (error: ApiError) => void): void;
-    on(event: "done", callback: (result: StreamResult) => void): void;
-    on(event: "metadata", callback: (metadata: JsonObject) => void): void;
-    off(event: string, callback: (...args: unknown[]) => void): void;
-    emit(event: string, ...args: unknown[]): void;
-};
+import type { ClientStreamEvent as StreamEvent, ClientStreamCallbacks, ClientStreamResult as StreamResult, ClientWebSocketOptions, ClientWebSocketState, ClientWebSocketMessageHandler, SSEConnectionOptions, SSEConnectionState, StreamingClientConfig, StreamingRequestOptions } from "../types/index.js";
 /**
  * Server-Sent Events (SSE) Client
  *
@@ -185,7 +126,7 @@ export declare class WebSocketStreamingClient {
     private reconnectAttempts;
     private heartbeatInterval;
     private eventHandlers;
-    constructor(options: WebSocketOptions);
+    constructor(options: ClientWebSocketOptions);
     /**
      * Connect to WebSocket server
      */
@@ -221,11 +162,11 @@ export declare class WebSocketStreamingClient {
     /**
      * Register event handler
      */
-    on(event: string, callback: WebSocketMessageHandler): void;
+    on(event: string, callback: ClientWebSocketMessageHandler): void;
     /**
      * Remove event handler
      */
-    off(event: string, callback: WebSocketMessageHandler): void;
+    off(event: string, callback: ClientWebSocketMessageHandler): void;
     /**
      * Emit event
      */
@@ -233,27 +174,12 @@ export declare class WebSocketStreamingClient {
     /**
      * Get current connection state
      */
-    getState(): WebSocketState;
+    getState(): ClientWebSocketState;
     /**
      * Create async iterator for messages
      */
     messages(): AsyncGenerator<unknown, void, unknown>;
 }
-/**
- * Streaming client configuration
- */
-export type StreamingClientConfig = {
-    /** Base URL for the API */
-    baseUrl: string;
-    /** API key */
-    apiKey?: string;
-    /** Bearer token */
-    token?: string;
-    /** Default headers */
-    headers?: Record<string, string>;
-    /** Preferred transport: 'sse' or 'websocket' */
-    transport?: "sse" | "websocket";
-};
 /**
  * Streaming Client Factory
  *
@@ -293,12 +219,12 @@ export declare function createStreamingClient(config: StreamingClientConfig): {
     connect: () => Promise<void>;
     disconnect: () => void;
     stream: (options: StreamingRequestOptions & {
-        callbacks?: StreamCallbacks;
+        callbacks?: ClientStreamCallbacks;
     }) => Promise<StreamResult>;
     send: (data: unknown) => void;
-    on: (event: string, callback: WebSocketMessageHandler) => void;
-    off: (event: string, callback: WebSocketMessageHandler) => void;
-    getState: () => WebSocketState;
+    on: (event: string, callback: ClientWebSocketMessageHandler) => void;
+    off: (event: string, callback: ClientWebSocketMessageHandler) => void;
+    getState: () => ClientWebSocketState;
 };
 /**
  * Create an async iterable from streaming response

package/dist/client/streamingClient.js

@@ -9,6 +9,9 @@
 import { logger } from "../utils/logger.js";
 import { combineSignals, sleep } from "./httpClient.js";
 // =============================================================================
+// Types
+// =============================================================================
+// =============================================================================
 // SSE Client
 // =============================================================================
 /**
@@ -630,6 +633,9 @@ export class WebSocketStreamingClient {
         }
     }
 }
+// =============================================================================
+// Streaming Client Factory
+// =============================================================================
 /**
  * Streaming Client Factory
  *

package/dist/client/wsClient.d.ts

@@ -7,15 +7,7 @@
  *
  * @module @neurolink/client/wsClient
  */
-import type { StreamCallbacks, ClientStreamEvent as StreamEvent, ClientStreamResult as StreamResult, ApiError, WSClientState, WSClientConfig, WSClientMessage, WSClientEventHandlers } from "../types/clientTypes.js";
-/** @see WSClientState */
-export type WebSocketState = WSClientState;
-/** @see WSClientConfig */
-export type WebSocketConfig = WSClientConfig;
-/** @see WSClientMessage */
-export type WebSocketMessage = WSClientMessage;
-/** @see WSClientEventHandlers */
-export type WebSocketEventHandlers = WSClientEventHandlers;
+import type { ClientStreamCallbacks, ClientStreamEvent as StreamEvent, ClientStreamResult as StreamResult, ClientApiError, WebSocketEventHandlers, ClientClientWebSocketState, ClientWebSocketMessage, ClientWebSocketConfig } from "../types/index.js";
 /**
  * WebSocket streaming client for NeuroLink
  *
@@ -57,11 +49,11 @@ export declare class NeuroLinkWebSocket {
      * original configuration so that a subsequent connect() still honours it.
      */
     private disconnectRequested;
-    constructor(config: WebSocketConfig);
+    constructor(config: ClientWebSocketConfig);
     /**
      * Get current connection state
      */
-    getState(): WebSocketState;
+    getState(): ClientClientWebSocketState;
     /**
      * Check if connected
      */
@@ -80,11 +72,11 @@ export declare class NeuroLinkWebSocket {
     /**
      * Send a message through WebSocket
      */
-    send(message: WebSocketMessage): void;
+    send(message: ClientWebSocketMessage): void;
     /**
      * Subscribe to a channel with streaming callbacks
      */
-    subscribe(channel: string, callbacks: StreamCallbacks): void;
+    subscribe(channel: string, callbacks: ClientStreamCallbacks): void;
     /**
      * Unsubscribe from a channel
      */
@@ -94,7 +86,7 @@ export declare class NeuroLinkWebSocket {
      */
     stream(prompt: string, options?: {
         channel?: string;
-    } & StreamCallbacks): void;
+    } & ClientStreamCallbacks): void;
     private setupEventListeners;
     private handleMessage;
     private dispatchToCallbacks;
@@ -126,5 +118,5 @@ export declare class NeuroLinkWebSocket {
  * });
  * ```
  */
-export declare function createWebSocketClient(config: WebSocketConfig): NeuroLinkWebSocket;
-export type { StreamCallbacks, StreamEvent, StreamResult, ApiError };
+export declare function createWebSocketClient(config: ClientWebSocketConfig): NeuroLinkWebSocket;
+export type { ClientStreamCallbacks, StreamEvent, StreamResult, ClientApiError, };

package/dist/config/configManager.d.ts

@@ -2,7 +2,7 @@
  * NeuroLink Config Manager with Backup/Restore System
  * Industry standard configuration management with safety mechanisms
  */
-import type { NeuroLinkConfig, ProviderConfig, BackupInfo, ConfigValidationResult, ConfigUpdateOptions } from "../types/configTypes.js";
+import type { NeuroLinkConfig, ProviderRuntimeConfig, BackupInfo, ConfigValidationResult, ConfigUpdateOptions } from "../types/index.js";
 /**
  * Enhanced Config Manager with automatic backup/restore capabilities
  */
@@ -42,7 +42,7 @@ export declare class NeuroLinkConfigManager {
     /**
      * Update provider status
      */
-    updateProviderStatus(providerId: string, status: Partial<ProviderConfig>): Promise<void>;
+    updateProviderStatus(providerId: string, status: Partial<ProviderRuntimeConfig>): Promise<void>;
     /**
      * Validate configuration
      */

package/dist/config/configManager.js

@@ -6,7 +6,7 @@ import { promises as fs } from "fs";
 import { join } from "path";
 import { createHash } from "crypto";
 import { logger } from "../utils/logger.js";
-import { DEFAULT_CONFIG } from "../types/configTypes.js";
+import { DEFAULT_CONFIG } from "../types/index.js";
 const { readFile, writeFile, readdir, mkdir, unlink, access } = fs;
 /**
  * Enhanced Config Manager with automatic backup/restore capabilities

package/dist/config/conversationMemory.d.ts

@@ -2,7 +2,7 @@
  * Conversation Memory Configuration
  * Provides default values for conversation memory feature with environment variable support
  */
-import type { ConversationMemoryConfig } from "../types/conversation.js";
+import type { ConversationMemoryConfig } from "../types/index.js";
 /**
  * Default maximum number of turns per session
  * @deprecated Use tokenThreshold-based memory management instead.

package/dist/constants/index.d.ts

@@ -182,4 +182,3 @@ export declare const CONSTANTS_METADATA: {
 };
 export { AIProviderName, OpenRouterModels, BedrockModels, OpenAIModels, AzureOpenAIModels, VertexModels, GoogleAIModels, AnthropicModels, MistralModels, OllamaModels, LiteLLMModels, HuggingFaceModels, SageMakerModels, APIVersions, ErrorCategory, ErrorSeverity, AnthropicBetaFeature, TOKEN_EXPIRY_BUFFER_MS, } from "./enums.js";
 export { VIDEO_ERROR_CODES } from "./videoErrors.js";
-export type { ClaudeSubscriptionTier, AnthropicAuthMethod, } from "../types/subscriptionTypes.js";

package/dist/constants/index.js

@@ -205,3 +205,4 @@ AnthropicBetaFeature,
 TOKEN_EXPIRY_BUFFER_MS, } from "./enums.js";
 // ===== ERROR CODES =====
 export { VIDEO_ERROR_CODES } from "./videoErrors.js";
+// Re-export subscription types from canonical location for convenience

package/dist/context/budgetChecker.d.ts

@@ -6,8 +6,7 @@
  *
  * This runs BEFORE every LLM call to prevent context overflow.
  */
-import type { BudgetCheckResult, BudgetCheckParams } from "../types/contextTypes.js";
-export type { BudgetCheckResult, BudgetCheckParams, } from "../types/contextTypes.js";
+import type { BudgetCheckResult, BudgetCheckParams } from "../types/index.js";
 /**
  * Check whether a request fits within the model's context budget.
  *

package/dist/context/budgetChecker.js

@@ -8,8 +8,7 @@
  */
 import { getAvailableInputTokens } from "../constants/contextWindows.js";
 import { estimateMessagesTokens, estimateTokens, TOKENS_PER_MESSAGE, } from "../utils/tokenEstimation.js";
-import { SpanSerializer, SpanType, SpanStatus, } from "../observability/index.js";
-import { getMetricsAggregator } from "../observability/index.js";
+import { SpanSerializer, SpanType, SpanStatus, getMetricsAggregator, } from "../observability/index.js";
 /** Default compaction threshold (80% of available input) */
 const DEFAULT_COMPACTION_THRESHOLD = 0.8;
 /** Estimated tokens per tool definition */