@juspay/neurolink 10.10.5 → 10.10.7

package/dist/lib/core/conversationMemoryManager.js

@@ -392,6 +392,77 @@ export class ConversationMemoryManager {
         session.lastCountedAt = undefined;
         session.lastActivity = Date.now();
     }
+    /**
+     * Persist a step's tool calls and results as `tool_call` / `tool_result`
+     * messages, mirroring the Redis manager.
+     *
+     * Parity fix: this used to exist only on the Redis backend, so an in-memory
+     * session never turned tool activity into messages and every downstream path
+     * that reasons about tool batches (compaction, pruning, pair repair) saw a
+     * different history shape depending on `STORAGE_TYPE`.
+     *
+     * Calls are written before results — the same order the Redis flush uses —
+     * and `toolCallId` is carried on BOTH sides so `repairToolPairs` can match by
+     * id rather than adjacency (a parallel batch has no positional pairing).
+     */
+    async storeToolExecution(sessionId, userId, toolCalls, toolResults, currentTime) {
+        await this.ensureInitialized();
+        let session = this.sessions.get(sessionId);
+        if (!session) {
+            session = this.createNewSession(sessionId, userId);
+            this.sessions.set(sessionId, session);
+            this.enforceSessionLimit();
+        }
+        const timestamp = (currentTime ?? new Date()).toISOString();
+        const toolNameById = new Map();
+        for (const toolCall of toolCalls ?? []) {
+            const toolCallId = toolCall.toolCallId ?? "";
+            const toolName = toolCall.toolName ?? "unknown";
+            if (toolCallId) {
+                toolNameById.set(toolCallId, toolName);
+            }
+            session.messages.push({
+                id: randomUUID(),
+                role: "tool_call",
+                content: "", // Tool calls carry their payload in `args`, not content.
+                tool: toolName,
+                ...(toolCallId ? { toolCallId } : {}),
+                args: (toolCall.args ?? {}),
+                timestamp,
+            });
+        }
+        for (const toolResult of toolResults ?? []) {
+            const toolCallId = toolResult.toolCallId ?? "";
+            const toolName = (toolCallId ? toolNameById.get(toolCallId) : undefined) ??
+                String(toolResult.toolName ?? "unknown");
+            const rawOutput = "output" in toolResult ? toolResult.output : toolResult.result;
+            let content;
+            if (typeof rawOutput === "string") {
+                content = rawOutput;
+            }
+            else {
+                try {
+                    content = JSON.stringify(rawOutput ?? null) ?? "null";
+                }
+                catch (error) {
+                    content = `[Serialization failed: ${error instanceof Error ? error.message : String(error)}]`;
+                }
+            }
+            session.messages.push({
+                id: randomUUID(),
+                role: "tool_result",
+                content,
+                tool: toolName,
+                ...(toolCallId ? { toolCallId } : {}),
+                result: {
+                    success: !toolResult.error,
+                    ...(toolResult.error ? { error: String(toolResult.error) } : {}),
+                },
+                timestamp,
+            });
+        }
+        session.lastActivity = Date.now();
+    }
     /** Close/shutdown — no-op for in-memory manager (no external connections to release) */
     async close() {
         // In-memory manager has nothing to close

package/dist/lib/core/redisConversationMemoryManager.d.ts

@@ -93,6 +93,33 @@ export declare class RedisConversationMemoryManager implements IConversationMemo
      * Check if summarization is needed based on token count
      */
     private checkAndSummarize;
+    /**
+     * True only for keys holding a conversation BLOB — the sole key type these
+     * scan-then-GET paths may read.
+     *
+     * `${keyPrefix}*` also matches the companion message LISTs and, when a
+     * custom key prefix does not end in `conversation:`, the user-index SETs
+     * (whose derived prefix then collapses onto `keyPrefix`). `GET` against
+     * either raises WRONGTYPE, and counting them would inflate session totals.
+     */
+    private isConversationBlobKey;
+    /**
+     * Hydrate a deserialized blob's messages from the companion LIST when the
+     * session uses split storage. Legacy blobs (messages inline) pass through
+     * untouched — that is what makes the migration backward compatible.
+     */
+    private hydrateMessages;
+    /** Message count without materializing them — LLEN for split sessions. */
+    private countMessages;
+    /** Load a session, messages included, regardless of storage format. */
+    private loadConversation;
+    /**
+     * Persist a conversation, splitting messages into the companion LIST.
+     * `appendFrom` appends only messages from that index onward (the per-turn
+     * fast path); omit it to rewrite the LIST wholesale, which is also how a
+     * legacy blob gets converted.
+     */
+    private persistConversation;
     /**
      * Build context messages for AI prompt injection (TOKEN-BASED)
      * Returns messages from pointer onwards (or all if no pointer)

package/dist/lib/core/redisConversationMemoryManager.js

@@ -15,7 +15,7 @@ import { withTimeout } from "../utils/errorHandling.js";
 import { buildContextFromPointer, getEffectiveTokenThreshold, } from "../utils/conversationMemory.js";
 import { runWithCurrentLangfuseContext } from "../services/server/ai/observability/instrumentation.js";
 import { logger } from "../utils/logger.js";
-import { createRedisClient, deserializeConversation, getNormalizedConfig, getPooledRedisClient, getSessionKey, getUserSessionsKey, releasePooledRedisClient, scanKeys, serializeConversation, } from "../utils/redis.js";
+import { createRedisClient, deserializeConversation, encodeStoredMessages, getSessionMessagesKey, MESSAGES_KEY_SUFFIX, isSessionMessagesKey, parseStoredMessages, serializeConversationMetadata, usesSplitMessageStorage, getNormalizedConfig, getPooledRedisClient, getSessionKey, getUserSessionsKey, releasePooledRedisClient, scanKeys, serializeConversation, } from "../utils/redis.js";
 const redisTracer = tracers.redis;
 const REDIS_TIMEOUT_MS = 5000;
 /**
@@ -140,7 +140,7 @@ export class RedisConversationMemoryManager {
             try {
                 const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
                 const conversationData = await withTimeout(redisClient.get(redisKey), REDIS_TIMEOUT_MS);
-                const conversation = deserializeConversation(conversationData || null);
+                const conversation = await this.hydrateMessages(deserializeConversation(conversationData || null), redisKey);
                 if (!conversation) {
                     span.setAttribute("session.found", false);
                     return undefined;
@@ -221,7 +221,7 @@ export class RedisConversationMemoryManager {
             }
             const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
             const conversationData = await this.redisClient.get(redisKey);
-            return deserializeConversation(conversationData || null);
+            return this.hydrateMessages(deserializeConversation(conversationData || null), redisKey);
         }
         catch (error) {
             logger.error("[RedisConversationMemoryManager] Failed to get raw session", {
@@ -391,7 +391,13 @@ export class RedisConversationMemoryManager {
                 }
                 const redisKey = getSessionKey(this.redisConfig, options.sessionId, options.userId);
                 const conversationData = await this.redisClient.get(redisKey);
-                let conversation = deserializeConversation(conversationData);
+                let conversation = await this.hydrateMessages(deserializeConversation(conversationData), redisKey);
+                // Split-storage bookkeeping: whether this session already keeps its
+                // messages in the companion LIST, and how many it held before this
+                // turn — so only the new ones are appended rather than rewriting the
+                // whole conversation on every turn.
+                const wasSplitStorage = usesSplitMessageStorage(conversation);
+                const messageCountBeforeTurn = conversation?.messages.length ?? 0;
                 const currentTime = new Date().toISOString();
                 const normalizedUserId = options.userId || "randomUser";
                 if (!conversation) {
@@ -486,6 +492,16 @@ export class RedisConversationMemoryManager {
                 const shouldSummarize = options.enableSummarization !== undefined
                     ? options.enableSummarization
                     : this.config.enableSummarization;
+                // Append-only: push just this turn's messages and persist a SMALL
+                // metadata blob. A session not yet using split storage (new, or a
+                // legacy blob) is converted once here, then every later turn appends.
+                await this.persistConversation(conversation, options.sessionId, options.userId, wasSplitStorage ? messageCountBeforeTurn : undefined);
+                // Scheduled AFTER the write, never before it. On the single turn that
+                // converts a legacy session, `checkAndSummarize` re-reads the blob and
+                // writes it back; observing the pre-conversion blob would make it
+                // re-serialize the record WITHOUT the split marker, so a later SET
+                // would strip the marker while the companion LIST already held the
+                // messages — the next read would then serve the stale inline copy.
                 if (shouldSummarize) {
                     const normalizedUserId = options.userId || "randomUser";
                     const summarizationKey = `${options.sessionId}:${normalizedUserId}`;
@@ -514,10 +530,8 @@ export class RedisConversationMemoryManager {
                         });
                     }
                 }
-                const serializedData = serializeConversation(conversation);
-                await this.redisClient.set(redisKey, serializedData);
                 // Log turn storage metadata for observability
-                const blobSizeBytes = Buffer.byteLength(serializedData, "utf8");
+                const blobSizeBytes = Buffer.byteLength(serializeConversationMetadata(conversation), "utf8");
                 logger.info("[ConversationMemory] Turn stored", {
                     requestId: options.requestId,
                     sessionId: options.sessionId,
@@ -611,7 +625,14 @@ export class RedisConversationMemoryManager {
                                 conversation.summarizedMessage;
                             latestConversation.lastTokenCount = conversation.lastTokenCount;
                             latestConversation.lastCountedAt = conversation.lastCountedAt;
-                            const freshSerialized = serializeConversation(latestConversation);
+                            // Only summarization metadata changed, so the companion LIST is
+                            // left alone. Critical: this re-read was NOT hydrated, so for a
+                            // split session `messages` is empty — writing it with
+                            // serializeConversation would drop the marker and make the record
+                            // look like a legacy blob with zero messages (silent data loss).
+                            const freshSerialized = usesSplitMessageStorage(latestConversation)
+                                ? serializeConversationMetadata(latestConversation)
+                                : serializeConversation(latestConversation);
                             await this.redisClient.set(redisKey, freshSerialized);
                             if (this.redisConfig.ttl > 0) {
                                 await this.redisClient.expire(redisKey, this.redisConfig.ttl);
@@ -631,6 +652,95 @@ export class RedisConversationMemoryManager {
             this.summarizationInProgress.delete(summarizationKey);
         }
     }
+    /**
+     * True only for keys holding a conversation BLOB — the sole key type these
+     * scan-then-GET paths may read.
+     *
+     * `${keyPrefix}*` also matches the companion message LISTs and, when a
+     * custom key prefix does not end in `conversation:`, the user-index SETs
+     * (whose derived prefix then collapses onto `keyPrefix`). `GET` against
+     * either raises WRONGTYPE, and counting them would inflate session totals.
+     */
+    isConversationBlobKey(key) {
+        return (!isSessionMessagesKey(key) &&
+            !key.endsWith(":sessions") &&
+            !key.startsWith(this.redisConfig.userSessionsKeyPrefix));
+    }
+    /**
+     * Hydrate a deserialized blob's messages from the companion LIST when the
+     * session uses split storage. Legacy blobs (messages inline) pass through
+     * untouched — that is what makes the migration backward compatible.
+     */
+    async hydrateMessages(conversation, redisKey) {
+        if (!conversation || !usesSplitMessageStorage(conversation)) {
+            return conversation;
+        }
+        if (!this.redisClient) {
+            return conversation;
+        }
+        // `getSession` and `buildContextMessages` guard their own GET with
+        // `withTimeout`; both now also depend on this read, so leaving it unguarded
+        // would let a hung LIST read block the request thread anyway.
+        const entries = await withTimeout(this.redisClient.lRange(`${redisKey}${MESSAGES_KEY_SUFFIX}`, 0, -1), REDIS_TIMEOUT_MS);
+        // `lRange` is typed `(string | Buffer)[]` — the client returns Buffers when
+        // a connection is opened in binary mode. Normalize rather than assert, so
+        // a binary-mode client reads its history instead of throwing on parse.
+        conversation.messages = parseStoredMessages(entries.map((entry) => entry.toString()));
+        return conversation;
+    }
+    /** Message count without materializing them — LLEN for split sessions. */
+    async countMessages(conversation, redisKey) {
+        if (!usesSplitMessageStorage(conversation) || !this.redisClient) {
+            return conversation.messages.length;
+        }
+        // `lLen` is typed `number | \`${number}\`` (RESP3 can deliver it as a
+        // string), and callers add it to numbers — coerce so the count never
+        // concatenates instead of summing.
+        return Number(await withTimeout(this.redisClient.lLen(`${redisKey}${MESSAGES_KEY_SUFFIX}`), REDIS_TIMEOUT_MS));
+    }
+    /** Load a session, messages included, regardless of storage format. */
+    async loadConversation(sessionId, userId) {
+        if (!this.redisClient) {
+            return null;
+        }
+        const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
+        return this.hydrateMessages(deserializeConversation(await this.redisClient.get(redisKey)), redisKey);
+    }
+    /**
+     * Persist a conversation, splitting messages into the companion LIST.
+     * `appendFrom` appends only messages from that index onward (the per-turn
+     * fast path); omit it to rewrite the LIST wholesale, which is also how a
+     * legacy blob gets converted.
+     */
+    async persistConversation(conversation, sessionId, userId, appendFrom) {
+        if (!this.redisClient) {
+            return;
+        }
+        const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
+        const messagesKey = getSessionMessagesKey(this.redisConfig, sessionId, userId);
+        // One MULTI, not four to six independent commands. The replace path is a
+        // DEL followed by an RPUSH, and on the legacy-conversion path the inline
+        // blob is the only copy of the history until the SET lands — so a failure
+        // between any two of them leaves the session either empty or unrecoverable.
+        // Grouping them also collapses the round trips, which is the point of the
+        // append-only layout.
+        const tx = this.redisClient.multi();
+        if (appendFrom === undefined) {
+            tx.del(messagesKey);
+        }
+        const toPush = appendFrom === undefined
+            ? conversation.messages
+            : conversation.messages.slice(appendFrom);
+        if (toPush.length > 0) {
+            tx.rPush(messagesKey, encodeStoredMessages(toPush));
+        }
+        tx.set(redisKey, serializeConversationMetadata(conversation));
+        if (this.redisConfig.ttl > 0) {
+            tx.expire(redisKey, this.redisConfig.ttl);
+            tx.expire(messagesKey, this.redisConfig.ttl);
+        }
+        await withTimeout(tx.exec(), REDIS_TIMEOUT_MS);
+    }
     /**
      * Build context messages for AI prompt injection (TOKEN-BASED)
      * Returns messages from pointer onwards (or all if no pointer)
@@ -664,7 +774,7 @@ export class RedisConversationMemoryManager {
                 });
                 const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
                 const conversationData = await withTimeout(redisClient.get(redisKey), REDIS_TIMEOUT_MS);
-                const conversation = deserializeConversation(conversationData || null);
+                const conversation = await this.hydrateMessages(deserializeConversation(conversationData || null), redisKey);
                 logger.debug("[RedisConversationMemoryManager] Retrieved conversation for context building", {
                     sessionId,
                     userId,
@@ -895,7 +1005,7 @@ export class RedisConversationMemoryManager {
                 return null;
             }
             // Deserialize the complete conversation object
-            const conversation = deserializeConversation(conversationData);
+            const conversation = await this.hydrateMessages(deserializeConversation(conversationData), sessionKey);
             if (!conversation) {
                 logger.debug("[RedisConversationMemoryManager] Failed to deserialize conversation data", {
                     userId,
@@ -1014,7 +1124,7 @@ User message: "${userMessage}"`;
         try {
             const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
             const conversationData = await this.redisClient.get(redisKey);
-            const conversation = deserializeConversation(conversationData || null);
+            const conversation = await this.hydrateMessages(deserializeConversation(conversationData || null), redisKey);
             return conversation?.messages ?? [];
         }
         catch (error) {
@@ -1050,11 +1160,8 @@ User message: "${userMessage}"`;
             conversation.summarizedMessage = undefined;
             conversation.lastTokenCount = undefined;
             conversation.lastCountedAt = undefined;
-            const serializedData = serializeConversation(conversation);
-            await this.redisClient.set(redisKey, serializedData);
-            if (this.redisConfig.ttl > 0) {
-                await this.redisClient.expire(redisKey, this.redisConfig.ttl);
-            }
+            // Wholesale replacement: rewrite the LIST rather than appending.
+            await this.persistConversation(conversation, sessionId, userId);
             logger.debug("[RedisConversationMemoryManager] Session messages replaced", {
                 sessionId,
                 userId,
@@ -1097,11 +1204,16 @@ User message: "${userMessage}"`;
             pattern,
             keyCount: keys.length,
         });
+        // Companion message LISTs share the session key prefix, so the SCAN above
+        // returns them too. GET on a LIST raises WRONGTYPE, and counting them as
+        // sessions would double `totalSessions` — filter them out exactly as the
+        // session listing already skips `:sessions` index keys.
+        const sessionKeys = keys.filter((key) => this.isConversationBlobKey(key));
         // Count messages in each session
         let totalTurns = 0;
-        for (const key of keys) {
+        for (const key of sessionKeys) {
             const conversationData = await this.redisClient.get(key);
-            const conversation = deserializeConversation(conversationData);
+            const conversation = await this.hydrateMessages(deserializeConversation(conversationData), key);
             if (conversation?.messages) {
                 // Pinned skill messages are extra rows inside a turn — exclude them
                 // so a skill-activating turn still counts as one turn.
@@ -1110,7 +1222,7 @@ User message: "${userMessage}"`;
             }
         }
         return {
-            totalSessions: keys.length,
+            totalSessions: sessionKeys.length,
             totalTurns,
         };
     }
@@ -1133,7 +1245,9 @@ User message: "${userMessage}"`;
         }, async (span) => {
             try {
                 const redisKey = getSessionKey(this.redisConfig, sessionId, userId);
-                const result = await withTimeout(redisClient.del(redisKey), REDIS_TIMEOUT_MS);
+                // Delete the companion message LIST as well: leaving it behind would
+                // leak the messages and let a re-created session inherit them.
+                const result = await withTimeout(redisClient.del([redisKey, `${redisKey}${MESSAGES_KEY_SUFFIX}`]), REDIS_TIMEOUT_MS);
                 if (Number(result) > 0) {
                     // Remove session from user's session set
                     if (userId) {
@@ -1307,8 +1421,9 @@ User message: "${userMessage}"`;
             // List all sessions across all users by scanning Redis keys
             const keys = await scanKeys(this.redisClient, `${this.redisConfig.keyPrefix}*`);
             for (const key of keys) {
-                // Skip user session index keys (they end with :sessions)
-                if (key.endsWith(":sessions")) {
+                // Skip user session index keys (they end with :sessions) and the
+                // companion message LISTs — GET on a LIST raises WRONGTYPE.
+                if (!this.isConversationBlobKey(key)) {
                     continue;
                 }
                 const raw = await this.redisClient.get(key);
@@ -1325,7 +1440,9 @@ User message: "${userMessage}"`;
                     createdAt: session.createdAt,
                     updatedAt: session.updatedAt,
                     userId: session.userId,
-                    messageCount: session.messages.length,
+                    // LLEN for split sessions: the blob's inline array is empty here
+                    // because this branch reads the raw key without hydrating.
+                    messageCount: await this.countMessages(session, key),
                     lastActive: this.formatTimeAgo(now - new Date(session.updatedAt).getTime()),
                 });
             }
@@ -1571,8 +1688,12 @@ User message: "${userMessage}"`;
                 logger.debug("[RedisConversationMemoryManager] Added new agentic loop report", { sessionId, reportId: report.reportId });
             }
             conversation.updatedAt = new Date().toISOString();
-            // Write back to Redis
-            const serializedData = serializeConversation(conversation);
+            // Write back to Redis. Metadata-only change, so the companion LIST is
+            // untouched — but the split marker must survive (see the summarization
+            // writeback above for why dropping it loses messages).
+            const serializedData = usesSplitMessageStorage(conversation)
+                ? serializeConversationMetadata(conversation)
+                : serializeConversation(conversation);
             await withTimeout(this.redisClient.set(redisKey, serializedData), 5000);
             if (this.redisConfig.ttl > 0) {
                 await withTimeout(this.redisClient.expire(redisKey, this.redisConfig.ttl), 5000);

package/dist/lib/neurolink.d.ts

@@ -1787,8 +1787,14 @@ export declare class NeuroLink {
         [key: string]: unknown;
     }>, currentTime?: Date): Promise<void>;
     /**
-     * Check if tool execution storage is available
-     * @returns boolean indicating if Redis storage is configured and available
+     * Check if tool execution storage is available.
+     *
+     * Now capability-based rather than Redis-specific: any configured memory
+     * backend implementing `storeToolExecution` qualifies. The old check
+     * required `STORAGE_TYPE === "redis"` AND a Redis manager by class name, so
+     * in-memory sessions reported false and silently skipped tool persistence.
+     *
+     * @returns whether the active memory backend can persist tool executions
      */
     isToolExecutionStorageAvailable(): boolean;
     /**

package/dist/lib/neurolink.js

@@ -11129,11 +11129,16 @@ Current user's request: ${currentInput}`;
             });
             return;
         }
-        // Type guard to ensure it's Redis conversation memory manager
-        const redisMemory = this
-            .conversationMemory;
+        // Any backend that implements storeToolExecution — no longer a Redis cast.
+        // The in-memory manager implements it too, so tool activity becomes
+        // tool_call/tool_result messages regardless of STORAGE_TYPE.
+        const memory = this.conversationMemory;
+        if (!memory?.storeToolExecution) {
+            logger.debug("Tool execution storage not supported by this memory backend");
+            return;
+        }
         try {
-            await redisMemory.storeToolExecution(sessionId, userId, toolCalls, toolResults, currentTime);
+            await memory.storeToolExecution(sessionId, userId, toolCalls, toolResults, currentTime);
         }
         catch (error) {
             logger.warn("Failed to store tool executions", {
@@ -11145,15 +11150,17 @@ Current user's request: ${currentInput}`;
         }
     }
     /**
-     * Check if tool execution storage is available
-     * @returns boolean indicating if Redis storage is configured and available
+     * Check if tool execution storage is available.
+     *
+     * Now capability-based rather than Redis-specific: any configured memory
+     * backend implementing `storeToolExecution` qualifies. The old check
+     * required `STORAGE_TYPE === "redis"` AND a Redis manager by class name, so
+     * in-memory sessions reported false and silently skipped tool persistence.
+     *
+     * @returns whether the active memory backend can persist tool executions
      */
     isToolExecutionStorageAvailable() {
-        const isRedisStorage = process.env.STORAGE_TYPE === "redis";
-        const hasRedisConversationMemory = this.conversationMemory &&
-            this.conversationMemory.constructor.name ===
-                "RedisConversationMemoryManager";
-        return !!(isRedisStorage && hasRedisConversationMemory);
+        return typeof this.conversationMemory?.storeToolExecution === "function";
     }
     /**
      * Get the raw messages array for a session.

package/dist/lib/providers/googleAiStudio/client.d.ts

@@ -2,37 +2,6 @@ import { type AIProviderName } from "../../constants/enums.js";
 import { BaseProvider } from "../../core/baseProvider.js";
 import type { ZodUnknownSchema, EnhancedGenerateResult, TextGenerationOptions, StreamOptions, StreamResult } from "../../types/index.js";
 import type { LanguageModel, Schema } from "../../types/index.js";
-/**
- * Google AI Studio provider implementation using BaseProvider
- * Migrated from original GoogleAIStudio class to new factory pattern
- *
- * @important Structured Output Limitation
- * Google Gemini models cannot combine function calling (tools) with structured
- * output (JSON schema). When using schemas with output.format: "json", you MUST
- * set disableTools: true.
- *
- * Error without disableTools:
- * "Function calling with a response mime type: 'application/json' is unsupported"
- *
- * This is a Google API limitation documented at:
- * https://ai.google.dev/gemini-api/docs/function-calling
- *
- * @example
- * ```typescript
- * // ✅ Correct usage with schemas
- * const provider = new GoogleAIStudioProvider("gemini-2.5-flash");
- * const result = await provider.generate({
- *   input: { text: "Analyze data" },
- *   schema: MySchema,
- *   output: { format: "json" },
- *   disableTools: true  // Required
- * });
- * ```
- *
- * @note Gemini 3 Pro Preview (November 2025) will support combining tools + schemas
- * @note "Too many states for serving" errors can occur with complex schemas + tools.
- *       Solution: Simplify schema or use disableTools: true
- */
 export declare class GoogleAIStudioProvider extends BaseProvider {
     private credentials?;
     constructor(modelName?: string, sdk?: unknown, credentials?: {