@juspay/neurolink 9.56.2 → 9.57.0

package/dist/neurolink.d.ts

@@ -5,11 +5,12 @@
  * Enhanced AI provider system with natural MCP tool access.
  * Uses real MCP infrastructure for tool discovery and execution.
  */
-import type { CompactionConfig, CompactionResult, SpanData, ObservabilityConfig, MetricsSummary, MCPToolAnnotations, TraceView, AuthenticatedContext, MastraAuthProvider, JsonObject, NeuroLinkEvents, TypedEventEmitter, MCPEnhancementsConfig, NeuroLinkAuthConfig, NeurolinkConstructorConfig, ChatMessage, ExternalMCPOperationResult, ExternalMCPServerInstance, ExternalMCPToolInfo, GenerateOptions, GenerateResult, ProviderStatus, TextGenerationOptions, TextGenerationResult, MCPExecutableTool, MCPServerInfo, MCPStatus, StreamOptions, StreamResult, ToolExecutionContext, ToolExecutionSummary, ToolInfo, ToolRegistrationOptions, BatchOperationResult } from "./types/index.js";
+import type { CompactionConfig, CompactionResult, SpanData, ObservabilityConfig, MetricsSummary, MCPToolAnnotations, TraceView, AuthenticatedContext, AuthProvider, JsonObject, NeuroLinkEvents, TypedEventEmitter, MCPEnhancementsConfig, NeuroLinkAuthConfig, NeurolinkConstructorConfig, ChatMessage, ExternalMCPOperationResult, ExternalMCPServerInstance, ExternalMCPToolInfo, GenerateOptions, GenerateResult, ProviderStatus, TextGenerationOptions, TextGenerationResult, MCPExecutableTool, MCPServerInfo, MCPStatus, StreamOptions, StreamResult, ToolExecutionContext, ToolExecutionSummary, ToolInfo, ToolRegistrationOptions, BatchOperationResult } from "./types/index.js";
 import { ConversationMemoryManager } from "./core/conversationMemoryManager.js";
 import type { RedisConversationMemoryManager } from "./core/redisConversationMemoryManager.js";
 import { ExternalServerManager } from "./mcp/externalServerManager.js";
 import { MCPToolRegistry } from "./mcp/toolRegistry.js";
+import type { DynamicOptions } from "./types/index.js";
 import { TaskManager } from "./tasks/taskManager.js";
 export declare class NeuroLink {
     private mcpInitialized;
@@ -539,7 +540,7 @@ export declare class NeuroLink {
      * @see {@link stream} for streaming generation
      * @since 1.0.0
      */
-    generate(optionsOrPrompt: GenerateOptions | string): Promise<GenerateResult>;
+    generate(optionsOrPrompt: GenerateOptions | DynamicOptions | string): Promise<GenerateResult>;
     private executeGenerateWithMetricsContext;
     private executeGenerateRequest;
     private prepareGenerateRequest;
@@ -695,7 +696,7 @@ export declare class NeuroLink {
      * @throws {Error} When all providers fail to generate content
      * @throws {Error} When conversation memory operations fail (if enabled)
      */
-    stream(options: StreamOptions): Promise<StreamResult>;
+    stream(options: StreamOptions | DynamicOptions): Promise<StreamResult>;
     private executeStreamRequest;
     private validateStreamRequestOptions;
     private maybeHandleWorkflowStreamRequest;
@@ -1959,7 +1960,7 @@ export declare class NeuroLink {
     /**
      * Get the currently configured authentication provider
      */
-    getAuthProvider(): MastraAuthProvider | undefined;
+    getAuthProvider(): AuthProvider | undefined;
     /**
      * Lazily initialize the auth provider from pendingAuthConfig.
      * Called on first use (generate/stream with auth token) to avoid
@@ -1993,6 +1994,13 @@ export declare class NeuroLink {
      * @returns The ExternalServerManager instance
      */
     getExternalServerManager(): ExternalServerManager;
+    private buildResolutionContext;
+    /**
+     * Resolve dynamic arguments in GenerateOptions, mutating the options in place.
+     * Only resolves fields that are functions; static values pass through unchanged.
+     */
+    private resolveDynamicOptions;
+    private resolveDynamicFields;
 }
 export declare const neurolink: NeuroLink;
 export default neurolink;

package/dist/neurolink.js

@@ -47,6 +47,8 @@ import { ToolRouter } from "./mcp/routing/index.js";
 import { directToolsServer } from "./mcp/servers/agent/directToolsServer.js";
 import { inferAnnotations, isSafeToRetry } from "./mcp/toolAnnotations.js";
 import { MCPToolRegistry } from "./mcp/toolRegistry.js";
+// Dynamic argument resolution imports
+import { resolveDynamicArgument } from "./dynamic/dynamicResolver.js";
 import { initializeHippocampus } from "./memory/hippocampusInitializer.js";
 import { createMemoryRetrievalTools } from "./memory/memoryRetrievalTools.js";
 import { getMetricsAggregator, MetricsAggregator, } from "./observability/metricsAggregator.js";
@@ -2658,8 +2660,10 @@ Current user's request: ${currentInput}`;
         return metricsTraceContextStorage.run(this.createMetricsTraceContext(), () => this.executeGenerateRequest(optionsOrPrompt, generateSpan));
     }
     async executeGenerateRequest(optionsOrPrompt, generateSpan) {
+        let resolvedOptions;
         try {
             const { options, originalPrompt } = await this.prepareGenerateRequest(optionsOrPrompt, generateSpan);
+            resolvedOptions = options;
             const earlyResult = await this.maybeHandleEarlyGenerateResult(options, generateSpan);
             if (earlyResult) {
                 generateSpan.setStatus({ code: SpanStatusCode.OK });
@@ -2680,7 +2684,7 @@ Current user's request: ${currentInput}`;
                 generateSpan.setAttribute("neurolink.context.estimated_tokens", error.estimatedTokens);
                 generateSpan.setAttribute("neurolink.context.available_tokens", error.availableTokens);
             }
-            this.emitGenerateErrorEvent(optionsOrPrompt, error);
+            this.emitGenerateErrorEvent((resolvedOptions ?? optionsOrPrompt), error);
             throw error;
         }
         finally {
@@ -2693,6 +2697,8 @@ Current user's request: ${currentInput}`;
         const options = typeof optionsOrPrompt === "string"
             ? { input: { text: optionsOrPrompt } }
             : { ...optionsOrPrompt };
+        // Dynamic argument resolution — resolve any function-valued options before downstream use
+        await this.resolveDynamicOptions(options);
         options.model = resolveModel(options.model, this.modelAliasConfig);
         this._disableToolCacheForCurrentRequest = !!options.disableToolCache;
         generateSpan.setAttribute("neurolink.provider", options.provider || "default");
@@ -2839,6 +2845,7 @@ Current user's request: ${currentInput}`;
             maxSteps: options.maxSteps,
             toolChoice: options.toolChoice,
             prepareStep: options.prepareStep,
+            enabledToolNames: options.enabledToolNames,
             enableAnalytics: options.enableAnalytics,
             enableEvaluation: options.enableEvaluation,
             context: options.context,
@@ -4331,13 +4338,18 @@ Current user's request: ${currentInput}`;
      * Used to filter the tool list before building the system prompt.
      */
     applyToolInfoFiltering(tools, options) {
-        if ((!options.toolFilter || options.toolFilter.length === 0) &&
+        // enabledToolNames is an additional whitelist — merged into toolFilter
+        const whitelist = [
+            ...(options.toolFilter ?? []),
+            ...(options.enabledToolNames ?? []),
+        ];
+        if (whitelist.length === 0 &&
             (!options.excludeTools || options.excludeTools.length === 0)) {
             return tools;
         }
         let filtered = tools;
-        if (options.toolFilter && options.toolFilter.length > 0) {
-            const allowSet = new Set(options.toolFilter);
+        if (whitelist.length > 0) {
+            const allowSet = new Set(whitelist);
             filtered = filtered.filter((t) => allowSet.has(t.name));
         }
         if (options.excludeTools && options.excludeTools.length > 0) {
@@ -4493,12 +4505,16 @@ Current user's request: ${currentInput}`;
             disableTools: options.disableTools,
             enableAnalytics: options.enableAnalytics,
             enableEvaluation: options.enableEvaluation,
-            contextKeys: options.context ? Object.keys(options.context) : [],
+            contextKeys: options.context
+                ? Object.keys(options.context ?? {})
+                : [],
             optionKeys: Object.keys(options),
         });
         return metricsTraceContextStorage.run(this.createMetricsTraceContext(), () => this.executeStreamRequest({ ...options }));
     }
     async executeStreamRequest(options) {
+        // Dynamic argument resolution — resolve any function-valued options before downstream use
+        await this.resolveDynamicOptions(options);
         const streamSpan = tracers.sdk.startSpan("neurolink.stream", {
             kind: SpanKind.INTERNAL,
             attributes: {
@@ -8974,7 +8990,7 @@ Current user's request: ${currentInput}`;
     async initializeAuthProviderFromConfig(config) {
         let provider;
         let providerType;
-        // Duck-type check: direct MastraAuthProvider instance
+        // Duck-type check: direct AuthProvider instance
         if ("authenticateToken" in config &&
             typeof config.authenticateToken === "function") {
             provider = config;
@@ -9075,6 +9091,63 @@ Current user's request: ${currentInput}`;
     getExternalServerManager() {
         return this.externalServerManager;
     }
+    // ==========================================================================
+    // Dynamic Argument Resolution
+    // ==========================================================================
+    buildResolutionContext(signal, inlineContext) {
+        return {
+            requestContext: inlineContext || {},
+            signal,
+        };
+    }
+    /**
+     * Resolve dynamic arguments in GenerateOptions, mutating the options in place.
+     * Only resolves fields that are functions; static values pass through unchanged.
+     */
+    async resolveDynamicOptions(options) {
+        const dynamicFields = [
+            "model",
+            "provider",
+            "temperature",
+            "maxTokens",
+            "systemPrompt",
+            "timeout",
+            "thinkingLevel",
+            "disableTools",
+            "enableAnalytics",
+            "enableEvaluation",
+        ];
+        const hasDynamic = dynamicFields.some((f) => typeof options[f] === "function") ||
+            typeof options.tools === "function";
+        if (!hasDynamic) {
+            return;
+        }
+        const inlineCtx = options.dynamicContext;
+        await this.resolveDynamicFields(options, dynamicFields, inlineCtx);
+    }
+    async resolveDynamicFields(options, dynamicFields, inlineContext) {
+        const resolutionContext = this.buildResolutionContext(options.abortSignal, inlineContext);
+        logger.debug("[NeuroLink] Resolving dynamic arguments");
+        await Promise.all(dynamicFields.map(async (field) => {
+            if (typeof options[field] === "function") {
+                const result = await resolveDynamicArgument(options[field], resolutionContext);
+                options[field] = result.value;
+                logger.debug(`[NeuroLink] Resolved dynamic ${field}: ${result.resolutionType}`);
+            }
+        }));
+        // Handle dynamic tools → enabledToolNames mapping.
+        // Per DynamicOptions.tools: DynamicArgument<string[]>, the resolver
+        // must return an array of tool names. Anything else is a contract
+        // violation — fail fast rather than silently disabling tooling.
+        if (typeof options.tools === "function") {
+            const result = await resolveDynamicArgument(options.tools, resolutionContext);
+            if (!Array.isArray(result.value)) {
+                throw new TypeError(`Dynamic tools resolver must return string[] (tool names), got ${typeof result.value === "object" ? "object" : typeof result.value}`);
+            }
+            options.enabledToolNames = result.value;
+            delete options.tools;
+        }
+    }
 }
 // Create default instance
 export const neurolink = new NeuroLink();

package/dist/observability/exporters/baseExporter.d.ts

@@ -1,6 +1,6 @@
 /**
  * Abstract base class for all observability exporters
- * Follows NeuroLink's factory pattern and Mastra's unified exporter interface
+ * Follows NeuroLink's factory pattern with a unified exporter interface
  */
 import type { ExporterConfig, ExporterHealthStatus, ExportResult, SpanData } from "../../types/index.js";
 /**

package/dist/observability/exporters/baseExporter.js

@@ -1,6 +1,6 @@
 /**
  * Abstract base class for all observability exporters
- * Follows NeuroLink's factory pattern and Mastra's unified exporter interface
+ * Follows NeuroLink's factory pattern with a unified exporter interface
  */
 import { logger } from "../../utils/logger.js";
 /**

package/dist/types/auth.d.ts

@@ -490,7 +490,7 @@ export type PermissionDefinition = {
  */
 export type AuthMiddlewareOptions = {
     /** Auth provider instance */
-    provider: MastraAuthProvider;
+    provider: AuthProvider;
     /** Routes to exclude from authentication */
     excludePaths?: string[];
     /** Whether auth is optional (continue if no token) */
@@ -729,7 +729,7 @@ export type CustomAuthConfig = {
     createSession?: (user: AuthUser, context?: AuthRequestContext) => Promise<AuthSession>;
 };
 /**
- * Configuration for MastraAuthProvider.
+ * Configuration for AuthProvider.
  *
  * Discriminated union of base + each provider-specific config so that
  * provider factories receive the properly typed config without requiring
@@ -819,7 +819,7 @@ export type AuthEventHandler = (event: AuthEventData) => void | Promise<void>;
 /**
  * Auth provider factory function type
  */
-export type AuthProviderFactoryFn = (config: AuthProviderConfig) => Promise<MastraAuthProvider>;
+export type AuthProviderFactoryFn = (config: AuthProviderConfig) => Promise<AuthProvider>;
 /**
  * Auth health check result
  */
@@ -973,7 +973,7 @@ export type AuthLifecycle = {
  * Composed from focused sub-types so consumers can depend on only the
  * slice they need (e.g. `AuthTokenValidator` for token-only middleware).
  *
- * Implements Mastra-style auth provider pattern with unified methods for:
+ * Unified auth provider interface covering:
  * - Token validation  (AuthTokenValidator)
  * - User authorization (AuthUserAuthorizer)
  * - Session management (AuthSessionManager)
@@ -981,7 +981,7 @@ export type AuthLifecycle = {
  * - User management    (AuthUserManager)
  * - Lifecycle          (AuthLifecycle)
  */
-export type MastraAuthProvider = AuthTokenValidator & AuthUserAuthorizer & AuthSessionManager & AuthRequestHandler & AuthUserManager & AuthLifecycle & {
+export type AuthProvider = AuthTokenValidator & AuthUserAuthorizer & AuthSessionManager & AuthRequestHandler & AuthUserManager & AuthLifecycle & {
     /** Provider type identifier */
     readonly type: AuthProviderType;
     /** Provider configuration */
@@ -1019,7 +1019,7 @@ export type AuthJWKSCacheEntry = {
     expiresAt: number;
 };
 /** Async constructor for an auth provider given its config. */
-export type AuthProviderConstructor = (config: AuthProviderConfig) => Promise<MastraAuthProvider>;
+export type AuthProviderConstructor = (config: AuthProviderConfig) => Promise<AuthProvider>;
 /** Registration row for an auth provider in AuthProviderFactory. */
 export type AuthProviderRegistration = {
     factory: AuthProviderConstructor;

package/dist/types/config.d.ts

@@ -7,7 +7,7 @@ import type { TaskManagerConfig } from "./task.js";
 import type { HITLConfig } from "../types/hitl.js";
 import type { ConversationMemoryConfig } from "./conversation.js";
 import type { ObservabilityConfig } from "./observability.js";
-import type { MastraAuthProvider, AuthProviderType, AuthProviderConfig, Auth0Config, ClerkConfig, FirebaseConfig, SupabaseConfig, WorkOSConfig, BetterAuthConfig, JWTConfig, OAuth2Config, CognitoConfig, KeycloakConfig, AuthenticatedContext } from "./auth.js";
+import type { AuthProvider, AuthProviderType, AuthProviderConfig, Auth0Config, ClerkConfig, FirebaseConfig, SupabaseConfig, WorkOSConfig, BetterAuthConfig, JWTConfig, OAuth2Config, CognitoConfig, KeycloakConfig, AuthenticatedContext } from "./auth.js";
 import type { NeurolinkCredentials } from "./providers.js";
 /**
  * Main NeuroLink configuration type
@@ -130,8 +130,8 @@ export type MCPEnhancementsConfig = {
 /**
  * Authentication configuration for NeuroLink SDK
  */
-export type NeuroLinkAuthConfig = MastraAuthProvider | {
-    provider: MastraAuthProvider;
+export type NeuroLinkAuthConfig = AuthProvider | {
+    provider: AuthProvider;
 } | {
     type: "auth0";
     config: Auth0Config;
@@ -169,7 +169,7 @@ export type NeuroLinkAuthConfig = MastraAuthProvider | {
 /**
  * Re-export auth types for convenience
  */
-export type { MastraAuthProvider, AuthProviderType, AuthProviderConfig, AuthenticatedContext, };
+export type { AuthProvider, AuthProviderType, AuthProviderConfig, AuthenticatedContext, };
 /**
  * Provider-specific configuration
  */

package/dist/types/dynamic.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Dynamic Arguments Type Definitions
+ *
+ * Pass functions instead of static values to generate() and stream().
+ * Functions are resolved at runtime before provider dispatch.
+ *
+ * @module types/dynamic
+ */
+import type { AIProviderName } from "../constants/enums.js";
+/**
+ * Context passed to context-aware dynamic argument functions.
+ * `requestContext` is whatever the consumer passed as `dynamicContext` —
+ * NeuroLink does not prescribe its shape.
+ */
+export type DynamicResolutionContext = {
+    /** Consumer-provided context (any shape) */
+    requestContext: Record<string, unknown>;
+    /** Abort signal for cancellation */
+    signal?: AbortSignal;
+};
+/**
+ * A value that can be static, a function, or a context-aware function.
+ *
+ * @example
+ * ```typescript
+ * // Static
+ * model: "gpt-4o"
+ *
+ * // Function
+ * model: () => process.env.MODEL || "gpt-4o"
+ *
+ * // Context-aware
+ * model: (ctx) => ctx.requestContext.plan === "enterprise" ? "gpt-4o" : "gpt-4o-mini"
+ * ```
+ */
+export type DynamicArgument<T> = T | (() => T) | (() => Promise<T>) | ((context: DynamicResolutionContext) => T) | ((context: DynamicResolutionContext) => Promise<T>);
+/**
+ * Dynamic options for generate() and stream() — pass functions
+ * instead of static values for context-aware resolution.
+ */
+export type DynamicOptions = {
+    model?: DynamicArgument<string>;
+    provider?: DynamicArgument<AIProviderName | string>;
+    temperature?: DynamicArgument<number>;
+    maxTokens?: DynamicArgument<number>;
+    systemPrompt?: DynamicArgument<string>;
+    /**
+     * Resolves to a `string[]` of tool names to enable.
+     * The resolved array is merged into `enabledToolNames` (and from there
+     * into `toolFilter`) — it does NOT replace `GenerateOptions.tools`,
+     * which is a `Record<string, Tool>` map of tool definitions.
+     */
+    tools?: DynamicArgument<string[]>;
+    timeout?: DynamicArgument<number>;
+    thinkingLevel?: DynamicArgument<"minimal" | "low" | "medium" | "high">;
+    disableTools?: DynamicArgument<boolean>;
+    enableAnalytics?: DynamicArgument<boolean>;
+    enableEvaluation?: DynamicArgument<boolean>;
+    input: {
+        text: string;
+        images?: Array<Buffer | string>;
+        files?: Array<Buffer | string>;
+    };
+    /**
+     * Context passed to dynamic resolver functions — any shape you want.
+     *
+     * This is intentionally separate from `GenerateOptions.context` (which is
+     * for telemetry/tracing metadata). If your resolvers need values from
+     * telemetry context (sessionId, userId, etc.), pass them here as well.
+     */
+    dynamicContext?: Record<string, unknown>;
+};
+export type ResolutionOptions = {
+    timeout?: number;
+    cache?: boolean;
+    cacheKey?: string;
+    cacheTtl?: number;
+    defaultValue?: unknown;
+    throwOnError?: boolean;
+};
+export type ResolutionResult<T> = {
+    value: T;
+    fromCache: boolean;
+    resolutionTime: number;
+    resolutionType: "static" | "sync-function" | "async-function" | "context-aware";
+};
+export type DynamicConfig<T> = {
+    [K in keyof T]: DynamicArgument<T[K]>;
+};
+export type ResolvedConfig<T> = {
+    [K in keyof T]: T[K] extends DynamicArgument<infer U> ? U : T[K];
+};
+export type DynamicCacheEntry<T> = {
+    value: T;
+    resolvedAt: number;
+    expiresAt: number;
+    key: string;
+};

package/dist/types/dynamic.js

@@ -0,0 +1,9 @@
+/**
+ * Dynamic Arguments Type Definitions
+ *
+ * Pass functions instead of static values to generate() and stream().
+ * Functions are resolved at runtime before provider dispatch.
+ *
+ * @module types/dynamic
+ */
+export {};

package/dist/types/generate.d.ts

@@ -230,6 +230,20 @@ export type GenerateOptions = {
      */
     schema?: ValidationSchema;
     tools?: Record<string, Tool>;
+    /**
+     * Filter available tools by name.
+     * Only tools with names in this array will be made available.
+     * Used by dynamic arguments to dynamically select which tools to enable.
+     *
+     * @example
+     * ```typescript
+     * await neurolink.generate({
+     *   input: { text: "Search for information" },
+     *   enabledToolNames: ["websearchGrounding", "readFile"]
+     * });
+     * ```
+     */
+    enabledToolNames?: string[];
     timeout?: number | string;
     /** AbortSignal for external cancellation of the AI call */
     abortSignal?: AbortSignal;
@@ -738,6 +752,21 @@ export type TextGenerationOptions = {
         director?: DirectorModeOptions;
     };
     tools?: Record<string, Tool>;
+    /**
+     * Filter available tools by name.
+     * Only tools with names in this array will be made available.
+     * Used by dynamic arguments to dynamically select which tools to enable.
+     * Merged into `toolFilter` before tool filtering runs.
+     *
+     * @example
+     * ```typescript
+     * await neurolink.generate({
+     *   input: { text: "Search for information" },
+     *   enabledToolNames: ["websearchGrounding", "readFile"]
+     * });
+     * ```
+     */
+    enabledToolNames?: string[];
     timeout?: number | string;
     /** AbortSignal for external cancellation of the AI call */
     abortSignal?: AbortSignal;

package/dist/types/index.d.ts

@@ -56,3 +56,4 @@ export * from "./exporter.js";
 export * from "./span.js";
 export * from "./imageGen.js";
 export * from "./elicitation.js";
+export * from "./dynamic.js";

package/dist/types/index.js

@@ -58,3 +58,5 @@ export * from "./exporter.js";
 export * from "./span.js";
 export * from "./imageGen.js";
 export * from "./elicitation.js";
+// Dynamic Arguments types
+export * from "./dynamic.js";

package/dist/types/scorer.d.ts

@@ -1,6 +1,6 @@
 /**
  * @file Scorer type definitions for NeuroLink evaluation system
- * Mastra-style modular scorer interfaces and types
+ * Modular scorer interfaces and types
  */
 import type { JsonObject } from "./common.js";
 import type { EnhancedEvaluationContext } from "./evaluation.js";

package/dist/types/scorer.js

@@ -1,5 +1,5 @@
 /**
  * @file Scorer type definitions for NeuroLink evaluation system
- * Mastra-style modular scorer interfaces and types
+ * Modular scorer interfaces and types
  */
 export {};

package/dist/types/span.d.ts

@@ -4,7 +4,7 @@
  */
 /**
  * Span types for AI operations
- * Following Mastra's span categorization and OTel GenAI conventions
+ * Following OTel GenAI conventions for span categorization
  */
 export declare enum SpanType {
     /** Agent execution run (reserved for future multi-agent support) */

package/dist/types/span.js

@@ -4,7 +4,7 @@
  */
 /**
  * Span types for AI operations
- * Following Mastra's span categorization and OTel GenAI conventions
+ * Following OTel GenAI conventions for span categorization
  */
 export var SpanType;
 (function (SpanType) {

package/dist/types/stream.d.ts

@@ -330,6 +330,12 @@ export type StreamOptions = {
     } | undefined>;
     /** Include only these tools by name (whitelist). If set, only matching tools are available. */
     toolFilter?: string[];
+    /**
+     * Filter available tools by name.
+     * Used by dynamic arguments to dynamically select which tools to enable.
+     * Merged into `toolFilter` before tool filtering runs.
+     */
+    enabledToolNames?: string[];
     /** Exclude these tools by name (blacklist). Applied after toolFilter. */
     excludeTools?: string[];
     /** Disable tool result caching for this request (overrides global mcp.cache.enabled) */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.56.2",
+  "version": "9.57.0",
   "packageManager": "pnpm@10.15.1",
   "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": {