@juspay/neurolink 8.28.0 → 8.30.0

package/dist/types/externalMcp.js

@@ -4,4 +4,3 @@
  * Following MCP 2024-11-05 specification
  */
 export {};
-// Note: In Phase 2, these interfaces will be consolidated into MCPServerInfo

package/dist/types/generateTypes.d.ts

@@ -385,11 +385,26 @@ export type FactoryEnhancedProvider = EnhancedProvider & {
 };
 /**
  * Text generation options type (consolidated from core types)
+ * Extended to support video generation mode
  */
 export type TextGenerationOptions = {
     prompt?: string;
+    /**
+     * Alternative input format for multimodal SDK operations.
+     *
+     * NOTE: This field is only used by the higher-level `generate()` API
+     * (NeuroLink.generate, BaseProvider.generate). Legacy `generateText()`
+     * callers must still use the `prompt` field directly.
+     *
+     * Supports text, images, and other multimodal inputs.
+     */
     input?: {
         text: string;
+        /**
+         * Images to include in the request.
+         * For video generation, the first image is used as the source frame.
+         */
+        images?: Array<Buffer | string | import("./content.js").ImageWithAltText>;
     };
     provider?: AIProviderName;
     model?: string;
@@ -398,8 +413,29 @@ export type TextGenerationOptions = {
     maxTokens?: number;
     systemPrompt?: string;
     schema?: ZodUnknownSchema | Schema<unknown>;
+    /**
+     * Output configuration options
+     *
+     * @example Video generation
+     * ```typescript
+     * output: {
+     *   mode: "video",
+     *   video: { resolution: "1080p", length: 8 }
+     * }
+     * ```
+     */
     output?: {
         format?: "text" | "structured" | "json";
+        /**
+         * Output mode - determines the type of content generated
+         * - "text": Standard text generation (default)
+         * - "video": Video generation using models like Veo 3.1
+         */
+        mode?: "text" | "video";
+        /**
+         * Video generation configuration (used when mode is "video")
+         */
+        video?: VideoOutputOptions;
     };
     tools?: Record<string, Tool>;
     timeout?: number | string;
@@ -570,6 +606,7 @@ export type TextGenerationResult = {
     analytics?: AnalyticsData;
     evaluation?: EvaluationData;
     audio?: TTSResult;
+    video?: VideoGenerationResult;
 };
 /**
  * Enhanced result type with optional analytics/evaluation

package/dist/types/hitlTypes.d.ts

@@ -194,3 +194,41 @@ export type HITLStatistics = {
     /** Number of timed out requests */
     timedOutRequests: number;
 };
+/**
+ * HITLManager type
+ * Defines the public contract for HITL manager implementations.
+ * Used for type annotations when referencing HITLManager instances.
+ */
+export type HITLManager = {
+    /** Check if HITL is currently enabled */
+    isEnabled(): boolean;
+    /** Check if a tool requires confirmation based on configuration */
+    requiresConfirmation(toolName: string, args?: unknown): boolean;
+    /** Request confirmation for a tool execution */
+    requestConfirmation(toolName: string, arguments_: unknown, context?: {
+        serverId?: string;
+        sessionId?: string;
+        userId?: string;
+    }): Promise<ConfirmationResult>;
+    /** Process user response to confirmation request */
+    processUserResponse(confirmationId: string, response: {
+        approved: boolean;
+        reason?: string;
+        modifiedArguments?: unknown;
+        responseTime?: number;
+        userId?: string;
+    }): void;
+    /** Get current HITL usage statistics */
+    getStatistics(): HITLStatistics;
+    /** Get current configuration */
+    getConfig(): HITLConfig;
+    /** Update configuration dynamically */
+    updateConfig(newConfig: Partial<HITLConfig>): void;
+    /** Clean up resources and reject pending confirmations */
+    cleanup(): void;
+    /** Get count of pending confirmations */
+    getPendingCount(): number;
+    /** EventEmitter methods for HITL events */
+    on(event: string, listener: (...args: unknown[]) => void): HITLManager;
+    emit(event: string, ...args: unknown[]): boolean;
+};

package/dist/types/index.d.ts

@@ -9,20 +9,17 @@ export * from "./providers.js";
 export * from "./cli.js";
 export * from "./taskClassificationTypes.js";
 export type { NeuroLinkConfig, PerformanceConfig, CacheConfig, FallbackConfig, RetryConfig, AnalyticsConfig, ToolConfig, BackupInfo, BackupMetadata, ConfigValidationResult, ConfigUpdateOptions, } from "./configTypes.js";
-export type { Unknown, UnknownRecord, UnknownArray, JsonValue, JsonObject, JsonArray, ErrorInfo, Result, FunctionParameters, } from "./common.js";
-export type { ToolArgs, ToolContext, ToolResult, ToolDefinition, SimpleTool, AvailableTool, ToolInfo, ToolExecution, ToolExecutionResult, ValidationResult, ExecutionContext, CacheOptions, FallbackOptions, } from "./tools.js";
-export type { AISDKModel, ProviderError, AIModelProviderConfig, OpenRouterConfig, OpenRouterModelInfo, OpenRouterModelsResponse, OpenRouterProviderCache, } from "./providers.js";
-export type { BaseCommandArgs, GenerateCommandArgs, MCPCommandArgs, ModelsCommandArgs, CommandResult, GenerateResult, StreamChunk, } from "./cli.js";
-export type { TaskType, TaskClassification, ClassificationScores, ClassificationStats, ClassificationValidation, } from "./taskClassificationTypes.js";
-export type { MCPTransportType, MCPServerConnectionStatus, MCPServerCategory, MCPServerStatus, MCPDiscoveredServer, MCPConnectedServer, MCPToolInfo, MCPExecutableTool, MCPServerMetadata, MCPToolMetadata, MCPServerRegistryEntry, NeuroLinkMCPTool, NeuroLinkMCPServer, NeuroLinkExecutionContext, MCPServerConfig, DiscoveredMcp, McpMetadata, ToolDiscoveryResult, ExternalToolExecutionOptions, ToolValidationResult, ToolRegistryEvents, CircuitBreakerState, CircuitBreakerConfig, CircuitBreakerStats, CircuitBreakerEvents, McpRegistry, MCPClientResult, FlexibleValidationResult, } from "./mcpTypes.js";
+export type { MCPTransportType, MCPServerConnectionStatus, MCPServerCategory, MCPServerStatus, MCPDiscoveredServer, MCPConnectedServer, MCPToolInfo, MCPExecutableTool, MCPServerMetadata, MCPToolMetadata, MCPServerRegistryEntry, NeuroLinkMCPTool, NeuroLinkMCPServer, NeuroLinkExecutionContext, MCPServerConfig, DiscoveredMcp, McpMetadata, ToolDiscoveryResult, ExternalToolExecutionOptions, ToolValidationResult, ToolRegistryEvents, CircuitBreakerState, CircuitBreakerConfig, CircuitBreakerStats, CircuitBreakerEvents, McpRegistry, MCPClientResult, FlexibleValidationResult, OAuthTokens, TokenStorage, MCPOAuthConfig, OAuthClientInformation, AuthorizationUrlResult, TokenExchangeRequest, TokenBucketRateLimitConfig, RateLimitConfig, HTTPRetryConfig, } from "./mcpTypes.js";
 export type { ExternalMCPServerInstance, ExternalMCPServerStatus, ExternalMCPToolInfo, ExternalMCPServerHealth, ExternalMCPConfigValidation, ExternalMCPOperationResult, ExternalMCPToolContext, ExternalMCPToolResult, ExternalMCPServerEvents, ExternalMCPManagerConfig, } from "./externalMcp.js";
 export type { ModelCapability, ModelUseCase, ModelFilter, ModelResolutionContext, ModelStats, ModelPricing, } from "./providers.js";
 export type { DomainType, DomainConfig, DomainTemplate, DomainConfigOptions, DomainEvaluationCriteria, DomainValidationRule, } from "./domainTypes.js";
-export * from "./generateTypes.js";
+export type { GenerateOptions, GenerateResult as GenerateApiResult, // Renamed to avoid conflict with cli.js GenerateResult
+UnifiedGenerationOptions, EnhancedProvider, FactoryEnhancedProvider, TextGenerationOptions, TextGenerationResult, EnhancedGenerateResult, } from "./generateTypes.js";
 export type { StreamingProgressData, StreamingMetadata, ProgressCallback, ToolCall as StreamToolCall, // Renamed to avoid conflict with tools.js ToolCall
 ToolResult as StreamToolResult, // Renamed to avoid conflict with tools.js ToolResult
 ToolCallResults, ToolCalls, StreamOptions, StreamingOptions, StreamResult, EnhancedStreamProvider, } from "./streamTypes.js";
-export * from "./analytics.js";
+export type { TokenUsage, ErrorInfo as AnalyticsErrorInfo, // Renamed to avoid conflict with common.js ErrorInfo
+AnalyticsData, StreamAnalyticsData, PerformanceMetrics, } from "./analytics.js";
 export * from "./evaluation.js";
 export * from "./modelTypes.js";
 export * from "./serviceTypes.js";
@@ -33,3 +30,4 @@ export * from "./middlewareTypes.js";
 export * from "./fileTypes.js";
 export * from "./content.js";
 export * from "./ttsTypes.js";
+export * from "./hitlTypes.js";

package/dist/types/index.js

@@ -13,10 +13,6 @@ export * from "./providers.js";
 export * from "./cli.js";
 // Task classification types
 export * from "./taskClassificationTypes.js";
-// Generate types - NEW
-export * from "./generateTypes.js";
-// Analytics types - NEW
-export * from "./analytics.js";
 // Evaluation types - NEW
 export * from "./evaluation.js";
 // Model types - NEW
@@ -26,6 +22,8 @@ export * from "./serviceTypes.js";
 // Evaluation provider types - NEW
 export * from "./evaluationProviders.js";
 // SDK Types - Core types for external developers
+// Note: sdkTypes.ts uses selective re-exports internally, so we use wildcard here
+// The conflicts were from generateTypes and analytics which are now handled above
 export * from "./sdkTypes.js";
 // Utilities Types - Utility module types (selective export to avoid conflicts)
 export * from "./utilities.js";
@@ -37,3 +35,5 @@ export * from "./fileTypes.js";
 export * from "./content.js";
 // TTS (Text-to-Speech) types
 export * from "./ttsTypes.js";
+// HITL (Human-in-the-Loop) types
+export * from "./hitlTypes.js";

package/dist/types/mcpTypes.d.ts

@@ -3,14 +3,14 @@
  * Enables various integrations to register tools directly
  */
 import type { JsonValue, JsonObject } from "./common.js";
-import type { ExecutionContext, ToolInfo } from "./tools.js";
+import type { ExecutionContext, ToolInfo, ToolResult } from "./tools.js";
 /**
  * In-memory MCP server configuration
  */
 /**
  * MCP Transport Types - Maximally Reusable
  */
-export type MCPTransportType = "stdio" | "sse" | "websocket" | "ws" | "tcp" | "unix";
+export type MCPTransportType = "stdio" | "sse" | "websocket" | "http" | "ws" | "tcp" | "unix";
 /**
  * MCP Server Connection Status - Individual server status
  */
@@ -44,6 +44,9 @@ export type MCPServerInfo = {
     args?: string[];
     env?: Record<string, string>;
     url?: string;
+    headers?: Record<string, string>;
+    /** HTTP transport-specific options */
+    httpOptions?: MCPHTTPTransportOptions;
     timeout?: number;
     retries?: number;
     error?: string;
@@ -51,7 +54,53 @@ export type MCPServerInfo = {
     cwd?: string;
     autoRestart?: boolean;
     healthCheckInterval?: number;
+    /** Retry configuration for HTTP transport */
+    retryConfig?: {
+        maxAttempts?: number;
+        initialDelay?: number;
+        maxDelay?: number;
+        backoffMultiplier?: number;
+    };
+    /** Rate limiting configuration for HTTP transport */
+    rateLimiting?: {
+        /** Maximum requests per minute (default: 60) */
+        requestsPerMinute?: number;
+        /** Maximum requests per hour (optional) */
+        requestsPerHour?: number;
+        /** Maximum burst size for token bucket (default: 10) */
+        maxBurst?: number;
+        /** Use token bucket algorithm (default: true) */
+        useTokenBucket?: boolean;
+    };
     blockedTools?: string[];
+    /** Authentication configuration for HTTP/SSE/WebSocket transports */
+    auth?: {
+        /** Authentication type */
+        type: "oauth2" | "bearer" | "api-key";
+        /** OAuth 2.1 configuration */
+        oauth?: {
+            /** OAuth client ID */
+            clientId: string;
+            /** OAuth client secret (optional for public clients with PKCE) */
+            clientSecret?: string;
+            /** Authorization endpoint URL */
+            authorizationUrl: string;
+            /** Token endpoint URL */
+            tokenUrl: string;
+            /** Redirect URI for OAuth callback */
+            redirectUrl: string;
+            /** OAuth scope (space-separated) */
+            scope?: string;
+            /** Enable PKCE (Proof Key for Code Exchange) - recommended for OAuth 2.1 */
+            usePKCE?: boolean;
+        };
+        /** Bearer token for simple token authentication */
+        token?: string;
+        /** API key for API key authentication */
+        apiKey?: string;
+        /** Header name for API key (default: "X-API-Key") */
+        apiKeyHeader?: string;
+    };
     metadata?: {
         uptime?: number;
         toolCount?: number;
@@ -63,6 +112,19 @@ export type MCPServerInfo = {
         [key: string]: unknown;
     };
 };
+/**
+ * HTTP Transport Options for fine-grained control
+ */
+export type MCPHTTPTransportOptions = {
+    /** Connection timeout in milliseconds (default: 30000) */
+    connectionTimeout?: number;
+    /** Request timeout in milliseconds (default: 60000) */
+    requestTimeout?: number;
+    /** Idle timeout for connection pool (default: 120000) */
+    idleTimeout?: number;
+    /** Keep-alive timeout (default: 30000) */
+    keepAliveTimeout?: number;
+};
 /**
  * MCP Server Status for CLI Operations - High Reusability
  */
@@ -227,31 +289,7 @@ export type NeuroLinkExecutionContext = {
     metadata?: Record<string, unknown>;
     [key: string]: unknown;
 };
-/**
- * Tool execution result - Standardized result format
- */
-export type ToolResult = {
-    success: boolean;
-    data?: unknown;
-    error?: string | Error;
-    usage?: {
-        tokens?: number;
-        cost?: number;
-        provider?: string;
-        model?: string;
-        executionTime?: number;
-    };
-    metadata?: {
-        toolName?: string;
-        serverId?: string;
-        serverTitle?: string;
-        sessionId?: string;
-        timestamp?: number;
-        executionTime?: number;
-        executionId?: string;
-        [key: string]: unknown;
-    };
-};
+export type { ToolResult } from "./tools.js";
 /**
  * Unified MCP Registry type
  */
@@ -577,3 +615,173 @@ export type FlexibleValidationResult = {
         schema?: string;
     };
 };
+/**
+ * OAuth tokens structure for MCP HTTP transport authentication
+ */
+export type OAuthTokens = {
+    /** Access token for API authentication */
+    accessToken: string;
+    /** Refresh token for obtaining new access tokens */
+    refreshToken?: string;
+    /** Token expiration timestamp (Unix epoch in milliseconds) */
+    expiresAt?: number;
+    /** Token type (typically "Bearer") */
+    tokenType: string;
+    /** OAuth scope granted */
+    scope?: string;
+};
+/**
+ * Token storage type for OAuth 2.1 authentication
+ * Implementations can use in-memory, file-based, or external storage
+ */
+export type TokenStorage = {
+    /**
+     * Get stored tokens for a server
+     * @param serverId - Unique identifier for the MCP server
+     * @returns Stored tokens or null if not found
+     */
+    getTokens(serverId: string): Promise<OAuthTokens | null>;
+    /**
+     * Save tokens for a server
+     * @param serverId - Unique identifier for the MCP server
+     * @param tokens - OAuth tokens to store
+     */
+    saveTokens(serverId: string, tokens: OAuthTokens): Promise<void>;
+    /**
+     * Delete stored tokens for a server
+     * @param serverId - Unique identifier for the MCP server
+     */
+    deleteTokens(serverId: string): Promise<void>;
+    /**
+     * Check if tokens exist for a server
+     * @param serverId - Unique identifier for the MCP server
+     * @returns True if tokens exist
+     */
+    hasTokens?(serverId: string): Promise<boolean>;
+    /**
+     * Clear all stored tokens
+     */
+    clearAll?(): Promise<void>;
+};
+/**
+ * OAuth 2.1 configuration for MCP servers
+ */
+export type MCPOAuthConfig = {
+    /** OAuth client ID */
+    clientId: string;
+    /** OAuth client secret (optional for public clients with PKCE) */
+    clientSecret?: string;
+    /** Authorization endpoint URL */
+    authorizationUrl: string;
+    /** Token endpoint URL */
+    tokenUrl: string;
+    /** Redirect URI for OAuth callback */
+    redirectUrl: string;
+    /** OAuth scope (space-separated) */
+    scope?: string;
+    /** Enable PKCE (Proof Key for Code Exchange) - recommended for OAuth 2.1 */
+    usePKCE?: boolean;
+    /** Additional authorization parameters */
+    additionalParams?: Record<string, string>;
+};
+/**
+ * OAuth client information returned to MCP SDK
+ */
+export type OAuthClientInformation = {
+    clientId: string;
+    clientSecret?: string;
+    redirectUri: string;
+};
+/**
+ * Authorization URL result from OAuth flow
+ */
+export type AuthorizationUrlResult = {
+    url: string;
+    state: string;
+    codeVerifier?: string;
+};
+/**
+ * Token exchange request for OAuth code exchange
+ */
+export type TokenExchangeRequest = {
+    code: string;
+    state: string;
+    codeVerifier?: string;
+};
+/**
+ * Token bucket rate limit configuration options for HTTP transport
+ */
+export type TokenBucketRateLimitConfig = {
+    /** Maximum requests per window */
+    requestsPerWindow: number;
+    /** Window size in milliseconds (default: 60000 = 1 minute) */
+    windowMs: number;
+    /** Use token bucket algorithm (default: true) */
+    useTokenBucket: boolean;
+    /** Token refill rate (tokens per second, for token bucket) */
+    refillRate: number;
+    /** Maximum burst size (for token bucket) */
+    maxBurst: number;
+};
+/** @deprecated Use TokenBucketRateLimitConfig instead */
+export type RateLimitConfig = TokenBucketRateLimitConfig;
+/**
+ * HTTP retry configuration for MCP transport
+ */
+export type HTTPRetryConfig = {
+    /** Maximum retry attempts (default: 3) */
+    maxAttempts: number;
+    /** Initial delay in ms (default: 1000) */
+    initialDelay: number;
+    /** Maximum delay in ms (default: 30000) */
+    maxDelay: number;
+    /** Backoff multiplier (default: 2) */
+    backoffMultiplier: number;
+    /** HTTP status codes that trigger retry */
+    retryableStatusCodes: number[];
+};
+/**
+ * PKCE (Proof Key for Code Exchange) challenge data for OAuth 2.1 authentication
+ * Used internally by OAuth client providers to generate and store PKCE parameters
+ */
+export type PKCEChallenge = {
+    /** Random code verifier string (43-128 characters, URL-safe) */
+    codeVerifier: string;
+    /** SHA-256 hash of code verifier, base64url encoded */
+    codeChallenge: string;
+    /** Challenge method - always "S256" per OAuth 2.1 specification */
+    codeChallengeMethod: "S256";
+};
+/**
+ * Rate limiter statistics for monitoring and debugging HTTP transport rate limiting
+ * Provides insight into token bucket state and queue status
+ */
+export type RateLimiterStats = {
+    /** Current number of available tokens */
+    tokens: number;
+    /** Maximum burst size (token capacity) */
+    maxBurst: number;
+    /** Token refill rate (tokens per second) */
+    refillRate: number;
+    /** Number of requests waiting in queue */
+    queueLength: number;
+    /** Timestamp of last token refill */
+    lastRefill: Date;
+};
+/**
+ * Token response from OAuth server
+ * Standard OAuth 2.0/2.1 token endpoint response structure
+ * Used internally by NeuroLinkOAuthProvider for token exchange and refresh
+ */
+export type TokenResponse = {
+    /** Access token for API authentication */
+    access_token: string;
+    /** Refresh token for obtaining new access tokens (optional) */
+    refresh_token?: string;
+    /** Token lifetime in seconds (optional) */
+    expires_in?: number;
+    /** Token type (typically "Bearer") */
+    token_type: string;
+    /** OAuth scope granted (optional, space-separated) */
+    scope?: string;
+};

package/dist/types/providers.d.ts

@@ -1043,54 +1043,54 @@ export type ProviderHealthCheckOptions = {
  * Amazon Bedrock specific types
  */
 export declare namespace BedrockTypes {
-    interface Client {
+    type Client = {
         send(command: unknown): Promise<unknown>;
         config: {
             region?: string;
             credentials?: unknown;
         };
-    }
-    interface InvokeModelCommand {
+    };
+    type InvokeModelCommand = {
         input: {
             modelId: string;
             body: string;
             contentType?: string;
         };
-    }
+    };
 }
 /**
  * Mistral specific types
  */
 export declare namespace MistralTypes {
-    interface Client {
+    type Client = {
         chat?: {
             complete?: (options: unknown) => Promise<unknown>;
             stream?: (options: unknown) => AsyncIterable<unknown>;
         };
-    }
+    };
 }
 /**
  * OpenTelemetry specific types (for telemetry service)
  */
 export declare namespace TelemetryTypes {
-    interface Meter {
+    type Meter = {
         createCounter(name: string, options?: unknown): Counter;
         createHistogram(name: string, options?: unknown): Histogram;
-    }
-    interface Tracer {
+    };
+    type Tracer = {
         startSpan(name: string, options?: unknown): Span;
-    }
-    interface Counter {
+    };
+    type Counter = {
         add(value: number, attributes?: UnknownRecord): void;
-    }
-    interface Histogram {
+    };
+    type Histogram = {
         record(value: number, attributes?: UnknownRecord): void;
-    }
-    interface Span {
+    };
+    type Span = {
         end(): void;
         setStatus(status: unknown): void;
         recordException(exception: unknown): void;
-    }
+    };
 }
 /**
  * OpenRouter provider configuration

package/dist/types/sdkTypes.d.ts

@@ -10,9 +10,9 @@ ToolResult as StreamToolResult, // Note: Renamed in main index to avoid conflict
 ToolCallResults, ToolCalls, StreamOptions, StreamingOptions, EnhancedStreamProvider, StreamTextResult, AISDKUsage, StreamAnalyticsCollector, ResponseMetadata, AudioInputSpec, AudioChunk, PCMEncoding, } from "./streamTypes.js";
 export type { TypedEventEmitter, NeuroLinkEvents, StreamEvent, AsyncFunction, SyncFunction, AnyFunction, } from "./common.js";
 export type { NeuroLinkConfig, ProviderConfig, PerformanceConfig, CacheConfig, FallbackConfig, RetryConfig, AnalyticsConfig, ToolConfig, BackupInfo, BackupMetadata, ConfigValidationResult, ConfigUpdateOptions, } from "./configTypes.js";
-export type { ToolArgs, ToolContext, ToolResult, ToolDefinition, SimpleTool, AvailableTool, ToolExecution, BaseToolArgs, ToolExecutionEvent, ToolExecutionSummary, ToolExecutionContext, ToolExecutionMetadata, ToolParameterSchema, ZodUnknownSchema, ZodAnySchema, ZodObjectSchema, ZodStringSchema, } from "./tools.js";
 export type { AISDKModel, ProviderError, AIModelProviderConfig, ProviderName, ModelCapability, ModelUseCase, ModelFilter, ModelResolutionContext, ModelStats, ModelPricing, ProviderCapabilities, } from "./providers.js";
-export type { GenerateOptions, GenerateResult, UnifiedGenerationOptions, EnhancedProvider, FactoryEnhancedProvider, TextGenerationOptions, TextGenerationResult, EnhancedGenerateResult, } from "./generateTypes.js";
+export type { GenerateOptions, GenerateResult as GenerateApiResult, // Renamed to avoid conflict with cli.js GenerateResult
+UnifiedGenerationOptions, EnhancedProvider, FactoryEnhancedProvider, TextGenerationOptions, TextGenerationResult, EnhancedGenerateResult, } from "./generateTypes.js";
 export type { TokenUsage, AnalyticsData } from "./analytics.js";
 export type { TextContent, ImageContent, Content, VisionCapability, ProviderImageFormat, ProcessedImage, MultimodalMessage, ProviderMultimodalPayload, } from "./content.js";
 export type { MCPTransportType, MCPServerConnectionStatus, MCPServerCategory, MCPServerStatus, MCPDiscoveredServer, MCPConnectedServer, MCPToolInfo, MCPExecutableTool, MCPServerMetadata, MCPToolMetadata, MCPServerRegistryEntry, } from "./mcpTypes.js";

package/dist/types/tools.d.ts

@@ -146,6 +146,32 @@ export type ToolContext = {
     aiProvider?: string;
     metadata?: ToolExecutionMetadata;
 };
+/**
+ * SDK-specific tool context with additional fields for SDK usage
+ * Extends the base ToolContext with session management, provider info, and logging
+ */
+export type SDKToolContext = ToolContext & {
+    /**
+     * Current session ID (required for SDK context)
+     */
+    sessionId: string;
+    /**
+     * AI provider being used
+     */
+    provider?: string;
+    /**
+     * Model being used
+     */
+    model?: string;
+    /**
+     * Call another tool
+     */
+    callTool?: (name: string, params: ToolArgs) => Promise<ToolResult>;
+    /**
+     * Logger instance
+     */
+    logger: import("./utilities.js").Logger;
+};
 /**
  * Tool execution result metadata
  */
@@ -156,14 +182,27 @@ export type ToolResultMetadata = {
     source?: string;
     version?: string;
     serverId?: string;
+    sessionId?: string;
+    blocked?: boolean;
+    [key: string]: JsonValue | undefined;
+};
+/**
+ * Tool result usage information
+ */
+export type ToolResultUsage = {
+    executionTime?: number;
+    tokensUsed?: number;
+    cost?: number;
+    [key: string]: JsonValue | undefined;
 };
 /**
  * Tool execution result
  */
-export type ToolResult<T = JsonValue> = Result<T, ErrorInfo> & {
+export type ToolResult<T = JsonValue | unknown> = Result<T, ErrorInfo | string> & {
     success: boolean;
-    data?: T;
-    error?: ErrorInfo;
+    data?: T | null;
+    error?: ErrorInfo | string;
+    usage?: ToolResultUsage;
     metadata?: ToolResultMetadata;
 };
 /**

package/dist/types/utilities.d.ts

@@ -65,6 +65,25 @@ export type LogEntry = {
     /** Optional additional data associated with the log entry (objects, arrays, etc.) */
     data?: unknown;
 };
+/**
+ * Logger interface matching the logger object shape
+ * Used for SDK tool contexts and other components that need a logger
+ */
+export type Logger = {
+    debug: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    always: (...args: unknown[]) => void;
+    table: (data: unknown) => void;
+    setLogLevel: (level: LogLevel) => void;
+    getLogs: (level?: LogLevel) => LogEntry[];
+    clearLogs: () => void;
+    setEventEmitter: (emitter: {
+        emit: (event: string, ...args: unknown[]) => boolean;
+    }) => void;
+    clearEventEmitter: () => void;
+};
 export type StructuredError = {
     code: string;
     message: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "8.28.0",
+  "version": "8.30.0",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 13 providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
     "name": "Juspay Technologies",
@@ -187,6 +187,7 @@
     "dotenv": "^16.6.1",
     "exceljs": "^4.4.0",
     "inquirer": "^9.3.7",
+    "google-auth-library": "^9.1.0",
     "json-schema-to-zod": "^2.6.1",
     "mammoth": "^1.11.0",
     "mathjs": "^14.7.0",