@juspay/neurolink 9.56.1 → 9.57.0

package/dist/cli/factories/commandFactory.js

@@ -1858,7 +1858,17 @@ export class CLICommandFactory {
             // Initialize SDK and session
             const sdk = globalSession.getOrCreateNeuroLink();
             const sessionVariables = globalSession.getSessionVariables();
-            const enhancedOptions = { ...options, ...sessionVariables };
+            const enhancedOptions = {
+                ...options,
+                ...sessionVariables,
+                // enabledToolNames must be string[] for the SDK — normalize from CSV string
+                ...(typeof sessionVariables.enabledToolNames === "string" && {
+                    enabledToolNames: sessionVariables.enabledToolNames
+                        .split(",")
+                        .map((t) => t.trim())
+                        .filter(Boolean),
+                }),
+            };
             const sessionId = globalSession.getCurrentSessionId();
             const context = sessionId
                 ? { ...options.context, sessionId }
@@ -1879,8 +1889,7 @@ export class CLICommandFactory {
             // Build multimodal input and output configuration
             const generateInput = CLICommandFactory.buildGenerateMultimodalInput(inputText, argv);
             const outputConfig = CLICommandFactory.buildGenerateOutputConfig(isVideoMode, isPPTMode, enhancedOptions);
-            // Execute generation
-            const result = await sdk.generate({
+            const runGenerate = () => sdk.generate({
                 input: generateInput,
                 csvOptions: {
                     maxRows: argv.csvMaxRows,
@@ -1902,6 +1911,7 @@ export class CLICommandFactory {
                     ? enhancedOptions.timeout * 1000
                     : undefined,
                 disableTools: enhancedOptions.disableTools,
+                enabledToolNames: enhancedOptions.enabledToolNames,
                 enableAnalytics: enhancedOptions.enableAnalytics,
                 enableEvaluation: enhancedOptions.enableEvaluation,
                 evaluationDomain: enhancedOptions.evaluationDomain,
@@ -1932,8 +1942,7 @@ export class CLICommandFactory {
                         enabled: true,
                         useAiResponse: true,
                         voice: enhancedOptions.ttsVoice,
-                        format: enhancedOptions.ttsFormat ||
-                            undefined,
+                        format: enhancedOptions.ttsFormat || undefined,
                         speed: enhancedOptions.ttsSpeed,
                         quality: enhancedOptions.ttsQuality,
                         output: enhancedOptions.ttsOutput,
@@ -1941,6 +1950,7 @@ export class CLICommandFactory {
                     }
                     : undefined,
             });
+            const result = await runGenerate();
             // Handle successful result
             await CLICommandFactory.handleGenerateSuccess(result, options, isVideoMode, isPPTMode, spinner);
         }
@@ -2070,7 +2080,7 @@ export class CLICommandFactory {
         const pdfFiles = CLICommandFactory.processCliPDFFiles(argv.pdf);
         const videoFiles = CLICommandFactory.processCliVideoFiles(argv.video);
         const files = CLICommandFactory.processCliFiles(argv.file);
-        const stream = await sdk.stream({
+        const runStream = () => sdk.stream({
             input: {
                 text: inputText,
                 ...(imageBuffers && { images: imageBuffers }),
@@ -2098,6 +2108,7 @@ export class CLICommandFactory {
                 ? enhancedOptions.timeout * 1000
                 : undefined,
             disableTools: enhancedOptions.disableTools,
+            enabledToolNames: enhancedOptions.enabledToolNames,
             enableAnalytics: enhancedOptions.enableAnalytics,
             enableEvaluation: enhancedOptions.enableEvaluation,
             evaluationDomain: enhancedOptions.evaluationDomain,
@@ -2137,6 +2148,7 @@ export class CLICommandFactory {
                 }
                 : undefined,
         });
+        const stream = await runStream();
         const streamResult = await CLICommandFactory.processStreamWithTimeout(stream, options);
         await CLICommandFactory.displayStreamResults(stream, streamResult.content, options);
         // Handle image output from stream (image models emit image events)
@@ -2489,7 +2501,17 @@ export class CLICommandFactory {
             const results = [];
             const sdk = globalSession.getOrCreateNeuroLink();
             const sessionVariables = globalSession.getSessionVariables();
-            const enhancedOptions = { ...options, ...sessionVariables };
+            const enhancedOptions = {
+                ...options,
+                ...sessionVariables,
+                // enabledToolNames must be string[] for the SDK — normalize from CSV string
+                ...(typeof sessionVariables.enabledToolNames === "string" && {
+                    enabledToolNames: sessionVariables.enabledToolNames
+                        .split(",")
+                        .map((t) => t.trim())
+                        .filter(Boolean),
+                }),
+            };
             const sessionId = globalSession.getCurrentSessionId();
             for (let i = 0; i < prompts.length; i++) {
                 if (spinner) {
@@ -2525,7 +2547,7 @@ export class CLICommandFactory {
                     const context = sessionId
                         ? { ...contextMetadata, sessionId }
                         : contextMetadata;
-                    const result = await sdk.generate({
+                    const runBatchGenerate = () => sdk.generate({
                         input: { text: inputText },
                         provider: enhancedOptions.provider,
                         model: enhancedOptions.model,
@@ -2536,6 +2558,7 @@ export class CLICommandFactory {
                             ? enhancedOptions.timeout * 1000
                             : undefined,
                         disableTools: enhancedOptions.disableTools,
+                        enabledToolNames: enhancedOptions.enabledToolNames,
                         evaluationDomain: enhancedOptions.evaluationDomain,
                         toolUsageContext: enhancedOptions.toolUsageContext,
                         context: context,
@@ -2547,6 +2570,7 @@ export class CLICommandFactory {
                             }
                             : undefined,
                     });
+                    const result = await runBatchGenerate();
                     results.push({ prompt: prompts[i], response: result.content });
                     if (spinner) {
                         spinner.render();

package/dist/cli/loop/optionsSchema.js

@@ -41,6 +41,10 @@ export const textGenerationOptionsSchema = {
         type: "boolean",
         description: "Disable all tool usage for the AI.",
     },
+    enabledToolNames: {
+        type: "string",
+        description: 'Comma-separated list of tool names to enable (e.g., "read,write,search").',
+    },
     maxSteps: {
         type: "number",
         description: "Maximum number of tool execution steps.",

package/dist/cli/parser.js

@@ -1,11 +1,11 @@
+import chalk from "chalk";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-import chalk from "chalk";
 import packageJson from "../../package.json" with { type: "json" };
-import { CLICommandFactory } from "./factories/commandFactory.js";
 import { globalSession } from "../lib/session/globalSessionState.js";
-import { handleError } from "./errorHandler.js";
 import { logger } from "../lib/utils/logger.js";
+import { handleError } from "./errorHandler.js";
+import { CLICommandFactory } from "./factories/commandFactory.js";
 import { SetupCommandFactory } from "./factories/setupCommandFactory.js";
 import { AuthCommandFactory } from "./factories/authCommandFactory.js";
 import { ServerCommandFactory } from "./commands/server.js";

package/dist/dynamic/dynamicResolver.d.ts

@@ -0,0 +1,282 @@
+/**
+ * Dynamic Argument Resolution Utilities
+ *
+ * Provides utilities for resolving dynamic arguments to their actual values,
+ * with support for caching, memoization, fallbacks, and conditional resolution.
+ *
+ * @module dynamic/dynamicResolver
+ */
+import type { DynamicArgument, DynamicResolutionContext, ResolutionOptions, ResolutionResult, DynamicConfig, ResolvedConfig } from "../types/index.js";
+/**
+ * Resolution cache for dynamic arguments
+ */
+declare class ResolutionCache {
+    private cache;
+    private cleanupInterval;
+    constructor(cleanupIntervalMs?: number);
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, value: T, ttl: number): void;
+    delete(key: string): boolean;
+    clear(): void;
+    size(): number;
+    private startCleanup;
+    destroy(): void;
+}
+declare const globalCache: ResolutionCache;
+/**
+ * Resolve a dynamic argument to its actual value
+ *
+ * @template T - The expected resolved type
+ * @param argument - The dynamic argument to resolve
+ * @param context - Resolution context (optional for static values)
+ * @param options - Resolution options
+ * @returns Resolution result with value and metadata
+ *
+ * @example Resolve static value
+ * ```typescript
+ * const result = await resolveDynamicArgument("gpt-4o");
+ * console.log(result.value); // "gpt-4o"
+ * console.log(result.resolutionType); // "static"
+ * ```
+ *
+ * @example Resolve context-aware function
+ * ```typescript
+ * const modelSelector = ({ requestContext }) =>
+ *   requestContext.tenant?.plan === "enterprise" ? "claude-3-opus" : "claude-3-sonnet";
+ *
+ * const result = await resolveDynamicArgument(modelSelector, {
+ *   requestContext: { requestId: "123", tenant: { id: "t1", plan: "enterprise" } }
+ * });
+ * console.log(result.value); // "claude-3-opus"
+ * ```
+ */
+export declare function resolveDynamicArgument<T>(argument: DynamicArgument<T>, context?: DynamicResolutionContext, options?: ResolutionOptions): Promise<ResolutionResult<T>>;
+/**
+ * Resolve multiple dynamic arguments in parallel
+ *
+ * @example
+ * ```typescript
+ * const [model, temperature] = await resolveDynamicArguments(
+ *   [
+ *     ({ requestContext }) => requestContext.user?.preferences?.preferredModel || "gpt-4o",
+ *     0.7,
+ *   ],
+ *   context
+ * );
+ * ```
+ */
+export declare function resolveDynamicArguments<T extends readonly unknown[]>(arguments_: {
+    [K in keyof T]: DynamicArgument<T[K]>;
+}, context?: DynamicResolutionContext, options?: ResolutionOptions): Promise<{
+    [K in keyof T]: T[K];
+}>;
+/**
+ * Resolve all properties of a dynamic configuration object
+ *
+ * @example
+ * ```typescript
+ * const dynamicConfig = {
+ *   model: ({ requestContext }) => requestContext.tenant?.settings?.defaultModel || "gpt-4o",
+ *   temperature: 0.7,
+ *   maxTokens: async () => (await fetchConfig()).maxTokens,
+ * };
+ *
+ * const resolved = await resolveDynamicConfig(dynamicConfig, context);
+ * // resolved.model, resolved.temperature, resolved.maxTokens are all resolved values
+ * ```
+ */
+export declare function resolveDynamicConfig<T extends Record<string, unknown>>(config: DynamicConfig<T>, context?: DynamicResolutionContext, options?: ResolutionOptions): Promise<ResolvedConfig<T>>;
+/**
+ * Create a memoized dynamic argument that caches its result
+ *
+ * @example
+ * ```typescript
+ * const expensiveModelSelector = memoizeDynamicArgument(
+ *   async ({ requestContext }) => {
+ *     const config = await fetchTenantConfig(requestContext.tenant?.id);
+ *     return config.preferredModel;
+ *   },
+ *   { cacheTtl: 300000 } // Cache for 5 minutes
+ * );
+ * ```
+ */
+export declare function memoizeDynamicArgument<T>(argument: DynamicArgument<T>, options?: {
+    cacheTtl?: number;
+    cacheKey?: string;
+}): DynamicArgument<T>;
+/**
+ * Create a dynamic argument with fallback chain
+ *
+ * @example
+ * ```typescript
+ * const modelWithFallback = withFallback(
+ *   ({ requestContext }) => requestContext.user?.preferences?.preferredModel,
+ *   ({ requestContext }) => requestContext.tenant?.settings?.defaultModel,
+ *   "gpt-4o" // Final static fallback
+ * );
+ * ```
+ */
+export declare function withFallback<T>(...arguments_: DynamicArgument<T | undefined | null>[]): DynamicArgument<T>;
+/**
+ * Create a conditional dynamic argument
+ *
+ * @example
+ * ```typescript
+ * const conditionalModel = conditional(
+ *   ({ requestContext }) => requestContext.tenant?.plan === "enterprise",
+ *   "claude-3-opus",   // If true
+ *   "claude-3-sonnet"  // If false
+ * );
+ * ```
+ */
+export declare function conditional<T>(condition: DynamicArgument<boolean>, ifTrue: DynamicArgument<T>, ifFalse: DynamicArgument<T>): DynamicArgument<T>;
+/**
+ * Create a mapped dynamic argument that transforms the result
+ *
+ * @example
+ * ```typescript
+ * const upperCaseModel = mapDynamicArgument(
+ *   ({ requestContext }) => requestContext.user?.preferences?.preferredModel,
+ *   (model) => model?.toUpperCase()
+ * );
+ * ```
+ */
+export declare function mapDynamicArgument<T, U>(argument: DynamicArgument<T>, transform: (value: T) => U | Promise<U>): DynamicArgument<U>;
+/**
+ * Create a dynamic argument that combines multiple arguments
+ *
+ * @example
+ * ```typescript
+ * const combinedConfig = combineDynamicArguments(
+ *   [
+ *     ({ requestContext }) => requestContext.user?.preferences?.preferredModel,
+ *     ({ requestContext }) => requestContext.tenant?.settings?.defaultTemperature,
+ *   ],
+ *   ([model, temperature]) => ({ model: model || "gpt-4o", temperature: temperature || 0.7 })
+ * );
+ * ```
+ */
+export declare function combineDynamicArguments<T extends readonly unknown[], U>(arguments_: {
+    [K in keyof T]: DynamicArgument<T[K]>;
+}, combiner: (values: T) => U | Promise<U>): DynamicArgument<U>;
+/**
+ * Check if a value contains any dynamic arguments (is a function)
+ */
+export declare function hasDynamicArgument<T>(value: DynamicArgument<T>): boolean;
+/**
+ * Check if an object has any dynamic properties
+ */
+export declare function hasDynamicProperties<T extends Record<string, unknown>>(config: DynamicConfig<T>): boolean;
+/**
+ * Clear the global resolution cache
+ */
+export declare function clearResolutionCache(): void;
+/**
+ * Get resolution cache statistics
+ */
+export declare function getResolutionCacheStats(): {
+    size: number;
+};
+/**
+ * Destroy the resolver (cleanup intervals, etc.)
+ */
+export declare function destroyResolver(): void;
+/**
+ * Interpolate environment variables in a string
+ *
+ * Supports syntax:
+ * - ${VAR} - Simple substitution
+ * - ${VAR:-default} - Use default if VAR is unset or empty
+ * - ${VAR:+replacement} - Use replacement if VAR is set and non-empty
+ *
+ * @example
+ * ```typescript
+ * interpolateEnvVars("Model: ${DEFAULT_MODEL:-gpt-4o}");
+ * // Returns "Model: gpt-4o" if DEFAULT_MODEL is not set
+ *
+ * interpolateEnvVars("API Key: ${OPENAI_API_KEY}");
+ * // Returns "API Key: sk-xxx..." if OPENAI_API_KEY is set
+ *
+ * interpolateEnvVars("Debug: ${DEBUG:+enabled}");
+ * // Returns "Debug: enabled" if DEBUG is set, "Debug: " otherwise
+ * ```
+ */
+export declare function interpolateEnvVars(input: string, customEnv?: Record<string, string | undefined>): string;
+/**
+ * Create a dynamic argument that interpolates environment variables
+ *
+ * @example
+ * ```typescript
+ * const model = fromEnv("${PREFERRED_MODEL:-gpt-4o}");
+ * // Resolves to value of PREFERRED_MODEL or "gpt-4o" as fallback
+ * ```
+ */
+export declare function fromEnv(template: string): DynamicArgument<string>;
+/**
+ * Create a dynamic argument from a single environment variable
+ *
+ * @example
+ * ```typescript
+ * const apiKey = envVar("OPENAI_API_KEY");
+ * // Resolves to value of OPENAI_API_KEY or undefined
+ *
+ * const model = envVar("DEFAULT_MODEL", "gpt-4o");
+ * // Resolves to DEFAULT_MODEL value or "gpt-4o" as default
+ * ```
+ */
+export declare function envVar<T extends string = string>(name: string, defaultValue?: T): DynamicArgument<T | undefined>;
+/**
+ * Create a dynamic argument that selects from environment-based configurations
+ *
+ * @example
+ * ```typescript
+ * const model = envSwitch("NODE_ENV", {
+ *   development: "gpt-4o-mini",
+ *   production: "gpt-4o",
+ *   test: "gpt-3.5-turbo",
+ * }, "gpt-4o-mini");
+ * ```
+ */
+export declare function envSwitch<T>(envVarName: string, options: Record<string, T>, defaultValue: T): DynamicArgument<T>;
+/**
+ * Create a dynamic argument that parses a JSON value from an environment variable
+ *
+ * @example
+ * ```typescript
+ * // If RATE_LIMITS='{"requestsPerMinute": 100, "tokensPerDay": 50000}'
+ * const rateLimits = envJson<RateLimits>("RATE_LIMITS", { requestsPerMinute: 10 });
+ * ```
+ */
+export declare function envJson<T>(name: string, defaultValue?: T): DynamicArgument<T | undefined>;
+/**
+ * Create a dynamic argument that reads a number from an environment variable
+ *
+ * @example
+ * ```typescript
+ * const maxTokens = envNumber("MAX_TOKENS", 1000);
+ * const temperature = envNumber("TEMPERATURE", 0.7);
+ * ```
+ */
+export declare function envNumber(name: string, defaultValue?: number): DynamicArgument<number | undefined>;
+/**
+ * Create a dynamic argument that reads a boolean from an environment variable
+ *
+ * @example
+ * ```typescript
+ * const enableDebug = envBoolean("DEBUG", false);
+ * const enableTools = envBoolean("ENABLE_TOOLS", true);
+ * ```
+ */
+export declare function envBoolean(name: string, defaultValue?: boolean): DynamicArgument<boolean | undefined>;
+/**
+ * Create a dynamic argument that reads a comma-separated list from an environment variable
+ *
+ * @example
+ * ```typescript
+ * // If ALLOWED_PROVIDERS='openai,anthropic,vertex'
+ * const providers = envList("ALLOWED_PROVIDERS", ["openai"]);
+ * // Returns ["openai", "anthropic", "vertex"]
+ * ```
+ */
+export declare function envList(name: string, defaultValue?: string[], separator?: string): DynamicArgument<string[] | undefined>;
+export { globalCache as resolutionCache };