graphlit-client 1.0.20250613008 → 1.0.20250615001

package/dist/client.js

@@ -1,13 +1,15 @@
 import jwt from "jsonwebtoken";
 // Apollo core (React-free) - ESM import
 import { ApolloClient, InMemoryCache, createHttpLink, ApolloLink, ApolloError, } from "@apollo/client/core/index.js";
+// Apollo retry link for resilient error handling
+import { RetryLink } from "@apollo/client/link/retry/index.js";
 import * as Types from "./generated/graphql-types.js";
 import * as Documents from "./generated/graphql-documents.js";
 import * as dotenv from "dotenv";
 import { getServiceType, getModelName } from "./model-mapping.js";
 import { UIEventAdapter } from "./streaming/ui-event-adapter.js";
-import { formatMessagesForOpenAI, formatMessagesForAnthropic, formatMessagesForGoogle, } from "./streaming/llm-formatters.js";
-import { streamWithOpenAI, streamWithAnthropic, streamWithGoogle, } from "./streaming/providers.js";
+import { formatMessagesForOpenAI, formatMessagesForAnthropic, formatMessagesForGoogle, formatMessagesForCohere, formatMessagesForMistral, formatMessagesForBedrock, } from "./streaming/llm-formatters.js";
+import { streamWithOpenAI, streamWithAnthropic, streamWithGoogle, streamWithGroq, streamWithCerebras, streamWithCohere, streamWithMistral, streamWithBedrock, streamWithDeepseek, } from "./streaming/providers.js";
 // Optional imports for streaming LLM clients
 // These are peer dependencies and may not be installed
 // We need to use createRequire for optional dependencies to avoid build errors
@@ -16,6 +18,10 @@ const optionalRequire = createRequire(import.meta.url);
 let OpenAI;
 let Anthropic;
 let GoogleGenerativeAI;
+let Groq;
+let CohereClient;
+let Mistral;
+let BedrockRuntimeClient;
 try {
     OpenAI = optionalRequire("openai").default || optionalRequire("openai");
     if (process.env.DEBUG_GRAPHLIT_SDK_INITIALIZATION) {
@@ -54,6 +60,54 @@ catch (e) {
         console.log("[SDK Loading] Google Generative AI SDK not found:", e.message);
     }
 }
+try {
+    Groq = optionalRequire("groq-sdk").default || optionalRequire("groq-sdk");
+    if (process.env.DEBUG_GRAPHLIT_SDK_INITIALIZATION) {
+        console.log("[SDK Loading] Groq SDK loaded successfully");
+    }
+}
+catch (e) {
+    // Groq SDK not installed
+    if (process.env.DEBUG_GRAPHLIT_SDK_INITIALIZATION) {
+        console.log("[SDK Loading] Groq SDK not found:", e.message);
+    }
+}
+try {
+    CohereClient = optionalRequire("cohere-ai").CohereClient;
+    if (process.env.DEBUG_GRAPHLIT_SDK_INITIALIZATION) {
+        console.log("[SDK Loading] Cohere SDK loaded successfully");
+    }
+}
+catch (e) {
+    // Cohere SDK not installed
+    if (process.env.DEBUG_GRAPHLIT_SDK_INITIALIZATION) {
+        console.log("[SDK Loading] Cohere SDK not found:", e.message);
+    }
+}
+try {
+    Mistral = optionalRequire("@mistralai/mistralai").Mistral;
+    if (process.env.DEBUG_GRAPHLIT_SDK_INITIALIZATION) {
+        console.log("[SDK Loading] Mistral SDK loaded successfully");
+    }
+}
+catch (e) {
+    // Mistral SDK not installed
+    if (process.env.DEBUG_GRAPHLIT_SDK_INITIALIZATION) {
+        console.log("[SDK Loading] Mistral SDK not found:", e.message);
+    }
+}
+try {
+    BedrockRuntimeClient = optionalRequire("@aws-sdk/client-bedrock-runtime").BedrockRuntimeClient;
+    if (process.env.DEBUG_GRAPHLIT_SDK_INITIALIZATION) {
+        console.log("[SDK Loading] Bedrock SDK loaded successfully");
+    }
+}
+catch (e) {
+    // Bedrock SDK not installed
+    if (process.env.DEBUG_GRAPHLIT_SDK_INITIALIZATION) {
+        console.log("[SDK Loading] Bedrock SDK not found:", e.message);
+    }
+}
 const DEFAULT_MAX_TOOL_ROUNDS = 1000;
 // Define the Graphlit class
 class Graphlit {
@@ -65,13 +119,37 @@ class Graphlit {
     ownerId;
     userId;
     jwtSecret;
+    retryConfig;
     // Streaming client instances (optional - can be provided by user)
     openaiClient;
     anthropicClient;
     googleClient;
-    constructor(organizationId, environmentId, jwtSecret, ownerId, userId, apiUri) {
+    groqClient;
+    cerebrasClient;
+    cohereClient;
+    mistralClient;
+    bedrockClient;
+    deepseekClient;
+    constructor(organizationIdOrOptions, environmentId, jwtSecret, ownerId, userId, apiUri) {
+        // Handle both old constructor signature and new options object
+        let options;
+        if (typeof organizationIdOrOptions === 'object' && organizationIdOrOptions !== null) {
+            // New constructor with options object
+            options = organizationIdOrOptions;
+        }
+        else {
+            // Legacy constructor with individual parameters
+            options = {
+                organizationId: organizationIdOrOptions,
+                environmentId,
+                jwtSecret,
+                ownerId,
+                userId,
+                apiUri
+            };
+        }
         this.apiUri =
-            apiUri ||
+            options.apiUri ||
                 (typeof process !== "undefined"
                     ? process.env.GRAPHLIT_API_URL
                     : undefined) ||
@@ -79,21 +157,30 @@ class Graphlit {
         if (typeof process !== "undefined") {
             dotenv.config();
             this.organizationId =
-                organizationId || process.env.GRAPHLIT_ORGANIZATION_ID;
-            this.environmentId = environmentId || process.env.GRAPHLIT_ENVIRONMENT_ID;
-            this.jwtSecret = jwtSecret || process.env.GRAPHLIT_JWT_SECRET;
+                options.organizationId || process.env.GRAPHLIT_ORGANIZATION_ID;
+            this.environmentId = options.environmentId || process.env.GRAPHLIT_ENVIRONMENT_ID;
+            this.jwtSecret = options.jwtSecret || process.env.GRAPHLIT_JWT_SECRET;
             // optional: for multi-tenant support
-            this.ownerId = ownerId || process.env.GRAPHLIT_OWNER_ID;
-            this.userId = userId || process.env.GRAPHLIT_USER_ID;
+            this.ownerId = options.ownerId || process.env.GRAPHLIT_OWNER_ID;
+            this.userId = options.userId || process.env.GRAPHLIT_USER_ID;
         }
         else {
-            this.organizationId = organizationId;
-            this.environmentId = environmentId;
-            this.jwtSecret = jwtSecret;
+            this.organizationId = options.organizationId;
+            this.environmentId = options.environmentId;
+            this.jwtSecret = options.jwtSecret;
             // optional: for multi-tenant support
-            this.ownerId = ownerId;
-            this.userId = userId;
+            this.ownerId = options.ownerId;
+            this.userId = options.userId;
         }
+        // Set default retry configuration
+        this.retryConfig = {
+            maxAttempts: 5,
+            initialDelay: 300,
+            maxDelay: 30000,
+            retryableStatusCodes: [429, 502, 503, 504],
+            jitter: true,
+            ...options.retryConfig
+        };
         if (!this.organizationId) {
             throw new Error("Graphlit organization identifier is required.");
         }
@@ -111,6 +198,42 @@ class Graphlit {
         const httpLink = createHttpLink({
             uri: this.apiUri,
         });
+        // Create retry link with configuration
+        const retryLink = new RetryLink({
+            delay: {
+                initial: this.retryConfig.initialDelay || 300,
+                max: this.retryConfig.maxDelay || 30000,
+                jitter: this.retryConfig.jitter !== false,
+            },
+            attempts: {
+                max: this.retryConfig.maxAttempts || 5,
+                retryIf: (error, _operation) => {
+                    // Check if we should retry this error
+                    if (!error)
+                        return false;
+                    // Check for network errors
+                    const hasNetworkError = !!error.networkError;
+                    if (!hasNetworkError)
+                        return false;
+                    // Get status code from different possible locations
+                    const statusCode = error.networkError?.statusCode ||
+                        error.networkError?.response?.status ||
+                        error.statusCode;
+                    // Check if status code is retryable
+                    if (statusCode && this.retryConfig.retryableStatusCodes) {
+                        const shouldRetry = this.retryConfig.retryableStatusCodes.includes(statusCode);
+                        // Call onRetry callback if provided
+                        if (shouldRetry && this.retryConfig.onRetry && _operation.getContext().retryCount !== undefined) {
+                            const attempt = _operation.getContext().retryCount + 1;
+                            this.retryConfig.onRetry(attempt, error, _operation);
+                        }
+                        return shouldRetry;
+                    }
+                    // Default: retry on network errors without specific status codes
+                    return true;
+                },
+            },
+        });
         const authLink = new ApolloLink((operation, forward) => {
             operation.setContext({
                 headers: {
@@ -119,8 +242,9 @@ class Graphlit {
             });
             return forward(operation);
         });
+        // Chain links: retry -> auth -> http
         this.client = new ApolloClient({
-            link: authLink.concat(httpLink),
+            link: ApolloLink.from([retryLink, authLink, httpLink]),
             cache: new InMemoryCache(),
             defaultOptions: {
                 watchQuery: {
@@ -159,6 +283,60 @@ class Graphlit {
     setGoogleClient(client) {
         this.googleClient = client;
     }
+    /**
+     * Set a custom Groq client instance for streaming
+     * @param client - Groq client instance (e.g., new Groq({ apiKey: "..." }))
+     */
+    setGroqClient(client) {
+        this.groqClient = client;
+    }
+    /**
+     * Set a custom Cerebras client instance for streaming (OpenAI-compatible)
+     * @param client - OpenAI client instance configured for Cerebras (e.g., new OpenAI({ apiKey: "...", baseURL: "https://api.cerebras.ai/v1" }))
+     */
+    setCerebrasClient(client) {
+        this.cerebrasClient = client;
+    }
+    /**
+     * Set a custom Cohere client instance for streaming
+     * @param client - Cohere client instance (e.g., new CohereClient({ token: "..." }))
+     */
+    setCohereClient(client) {
+        this.cohereClient = client;
+    }
+    /**
+     * Set a custom Mistral client instance for streaming
+     * @param client - Mistral client instance (e.g., new Mistral({ apiKey: "..." }))
+     */
+    setMistralClient(client) {
+        this.mistralClient = client;
+    }
+    /**
+     * Set a custom Bedrock client instance for streaming
+     * @param client - BedrockRuntimeClient instance (e.g., new BedrockRuntimeClient({ region: "us-east-2" }))
+     */
+    setBedrockClient(client) {
+        this.bedrockClient = client;
+    }
+    /**
+     * Set a custom Deepseek client instance for streaming
+     * @param client - OpenAI client instance configured for Deepseek (e.g., new OpenAI({ baseURL: "https://api.deepseek.com", apiKey: "..." }))
+     */
+    setDeepseekClient(client) {
+        this.deepseekClient = client;
+    }
+    /**
+     * Update retry configuration and refresh the Apollo client
+     * @param retryConfig - New retry configuration
+     */
+    setRetryConfig(retryConfig) {
+        this.retryConfig = {
+            ...this.retryConfig,
+            ...retryConfig
+        };
+        // Refresh client to apply new retry configuration
+        this.refreshClient();
+    }
     generateToken() {
         if (!this.jwtSecret) {
             throw new Error("Graphlit environment JWT secret is required.");
@@ -1438,6 +1616,19 @@ class Graphlit {
                     return Anthropic !== undefined || this.anthropicClient !== undefined;
                 case Types.ModelServiceTypes.Google:
                     return (GoogleGenerativeAI !== undefined || this.googleClient !== undefined);
+                case Types.ModelServiceTypes.Groq:
+                    return Groq !== undefined || this.groqClient !== undefined;
+                case Types.ModelServiceTypes.Cerebras:
+                    return OpenAI !== undefined || this.cerebrasClient !== undefined;
+                case Types.ModelServiceTypes.Cohere:
+                    return CohereClient !== undefined || this.cohereClient !== undefined;
+                case Types.ModelServiceTypes.Mistral:
+                    return Mistral !== undefined || this.mistralClient !== undefined;
+                case Types.ModelServiceTypes.Bedrock:
+                    return (BedrockRuntimeClient !== undefined ||
+                        this.bedrockClient !== undefined);
+                case Types.ModelServiceTypes.Deepseek:
+                    return OpenAI !== undefined || this.deepseekClient !== undefined;
                 default:
                     return false;
             }
@@ -1447,7 +1638,19 @@ class Graphlit {
         const hasOpenAI = OpenAI !== undefined || this.openaiClient !== undefined;
         const hasAnthropic = Anthropic !== undefined || this.anthropicClient !== undefined;
         const hasGoogle = GoogleGenerativeAI !== undefined || this.googleClient !== undefined;
-        return hasOpenAI || hasAnthropic || hasGoogle;
+        const hasGroq = Groq !== undefined || this.groqClient !== undefined;
+        const hasCerebras = OpenAI !== undefined || this.cerebrasClient !== undefined;
+        const hasCohere = CohereClient !== undefined || this.cohereClient !== undefined;
+        const hasMistral = Mistral !== undefined || this.mistralClient !== undefined;
+        const hasBedrock = BedrockRuntimeClient !== undefined || this.bedrockClient !== undefined;
+        return (hasOpenAI ||
+            hasAnthropic ||
+            hasGoogle ||
+            hasGroq ||
+            hasCerebras ||
+            hasCohere ||
+            hasMistral ||
+            hasBedrock);
     }
     /**
      * Execute an agent with non-streaming response
@@ -1499,13 +1702,17 @@ class Graphlit {
             // 3. Tool calling loop
             const allToolCalls = [];
             let rounds = 0;
-            let totalTokens = 0;
+            let totalTokens = currentMessage?.tokens || 0;
+            const toolStartTime = Date.now();
+            let toolTime = 0;
             while (currentMessage.toolCalls?.length &&
                 rounds < maxRounds &&
                 !abortController.signal.aborted) {
                 rounds++;
                 // Execute tools
+                const toolExecStart = Date.now();
                 const toolResults = await this.executeToolsForPromptAgent(currentMessage.toolCalls.filter((tc) => tc !== null), toolHandlers || {}, allToolCalls, abortController.signal);
+                toolTime += Date.now() - toolExecStart;
                 if (abortController.signal.aborted) {
                     throw new Error("Operation timed out");
                 }
@@ -1519,9 +1726,35 @@ class Graphlit {
                     totalTokens += continueResponse.continueConversation.message.tokens;
                 }
             }
+            // Calculate metrics
+            const totalTime = Date.now() - startTime;
+            const llmTime = totalTime - toolTime;
+            const metrics = {
+                totalTime,
+                llmTime,
+                toolTime,
+                toolExecutions: allToolCalls.length,
+                rounds,
+            };
+            // Build usage info if we have token data
+            const usage = totalTokens > 0
+                ? {
+                    promptTokens: 0, // We don't have this breakdown from the API
+                    completionTokens: totalTokens,
+                    totalTokens: totalTokens,
+                    model: currentMessage?.model || undefined,
+                }
+                : undefined;
             return {
                 message: currentMessage?.message || "",
                 conversationId: actualConversationId,
+                conversationMessage: currentMessage
+                    ? currentMessage
+                    : undefined,
+                toolCalls: currentMessage?.toolCalls?.filter((tc) => tc !== null),
+                toolResults: allToolCalls,
+                metrics,
+                usage,
             };
         }
         catch (error) {
@@ -1536,6 +1769,14 @@ class Graphlit {
                     recoverable: isTimeout || error.code === "RATE_LIMIT",
                     details: error.response?.data,
                 },
+                // Include partial metrics if available
+                metrics: {
+                    totalTime: Date.now() - startTime,
+                    llmTime: 0,
+                    toolTime: 0,
+                    toolExecutions: 0,
+                    rounds: 0,
+                },
             };
         }
         finally {
@@ -1573,6 +1814,17 @@ class Graphlit {
                 ? (await this.getSpecification(specification.id))
                     .specification
                 : undefined;
+            if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING && fullSpec) {
+                console.log(`🔍 [streamAgent] Retrieved full specification:`, {
+                    id: fullSpec.id,
+                    name: fullSpec.name,
+                    serviceType: fullSpec.serviceType,
+                    hasDeepseek: !!fullSpec.deepseek,
+                    deepseekModel: fullSpec.deepseek?.model,
+                    deepseekModelName: fullSpec.deepseek?.modelName,
+                    deepseekTemperature: fullSpec.deepseek?.temperature,
+                });
+            }
             // Ensure conversation exists first (before streaming check)
             let actualConversationId = conversationId;
             if (!actualConversationId) {
@@ -1689,7 +1941,7 @@ class Graphlit {
         if (!formattedMessage?.message) {
             throw new Error("Failed to format conversation");
         }
-        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING_FORMAT) {
             console.log("\n📋 [formatConversation] Full response:", JSON.stringify(formatResponse, null, 2));
             console.log("\n📋 [formatConversation] Response - current message:", formattedMessage.message);
             console.log(`📋 [formatConversation] Conversation history: ${conversationHistory?.length || 0} messages`);
@@ -1830,6 +2082,108 @@ class Graphlit {
                     console.log(`\n🏁 [Streaming] Google native streaming completed (Round ${currentRound})`);
                 }
             }
+            else if (serviceType === Types.ModelServiceTypes.Groq &&
+                (Groq || this.groqClient)) {
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`\n✅ [Streaming] Using Groq native streaming (Round ${currentRound})`);
+                }
+                const groqMessages = formatMessagesForOpenAI(messages); // Groq uses OpenAI format
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING_MESSAGES) {
+                    console.log(`🔍 [Groq] Sending ${groqMessages.length} messages to LLM: ${JSON.stringify(groqMessages)}`);
+                }
+                await this.streamWithGroq(specification, groqMessages, tools, uiAdapter, (message, calls) => {
+                    roundMessage = message;
+                    toolCalls = calls;
+                });
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`\n🏁 [Streaming] Groq native streaming completed (Round ${currentRound})`);
+                }
+            }
+            else if (serviceType === Types.ModelServiceTypes.Cerebras &&
+                (OpenAI || this.cerebrasClient)) {
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`\n✅ [Streaming] Using Cerebras native streaming (Round ${currentRound})`);
+                }
+                const cerebrasMessages = formatMessagesForOpenAI(messages); // Cerebras uses OpenAI format
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING_MESSAGES) {
+                    console.log(`🔍 [Cerebras] Sending ${cerebrasMessages.length} messages to LLM: ${JSON.stringify(cerebrasMessages)}`);
+                }
+                await this.streamWithCerebras(specification, cerebrasMessages, tools, uiAdapter, (message, calls) => {
+                    roundMessage = message;
+                    toolCalls = calls;
+                });
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`\n🏁 [Streaming] Cerebras native streaming completed (Round ${currentRound})`);
+                }
+            }
+            else if (serviceType === Types.ModelServiceTypes.Cohere &&
+                (CohereClient || this.cohereClient)) {
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`\n✅ [Streaming] Using Cohere native streaming (Round ${currentRound})`);
+                }
+                const cohereMessages = formatMessagesForCohere(messages);
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING_MESSAGES) {
+                    console.log(`🔍 [Cohere] Sending ${cohereMessages.length} messages to LLM: ${JSON.stringify(cohereMessages)}`);
+                }
+                await this.streamWithCohere(specification, cohereMessages, tools, uiAdapter, (message, calls) => {
+                    roundMessage = message;
+                    toolCalls = calls;
+                });
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`\n🏁 [Streaming] Cohere native streaming completed (Round ${currentRound})`);
+                }
+            }
+            else if (serviceType === Types.ModelServiceTypes.Mistral &&
+                (Mistral || this.mistralClient)) {
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`\n✅ [Streaming] Using Mistral native streaming (Round ${currentRound})`);
+                }
+                const mistralMessages = formatMessagesForMistral(messages);
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING_MESSAGES) {
+                    console.log(`🔍 [Mistral] Sending ${mistralMessages.length} messages to LLM: ${JSON.stringify(mistralMessages)}`);
+                }
+                await this.streamWithMistral(specification, mistralMessages, tools, uiAdapter, (message, calls) => {
+                    roundMessage = message;
+                    toolCalls = calls;
+                });
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`\n🏁 [Streaming] Mistral native streaming completed (Round ${currentRound})`);
+                }
+            }
+            else if (serviceType === Types.ModelServiceTypes.Bedrock &&
+                (BedrockRuntimeClient || this.bedrockClient)) {
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`\n✅ [Streaming] Using Bedrock native streaming (Round ${currentRound})`);
+                }
+                const { system, messages: bedrockMessages } = formatMessagesForBedrock(messages);
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING_MESSAGES) {
+                    console.log(`🔍 [Bedrock] Sending ${bedrockMessages.length} messages to LLM (system: ${system ? "yes" : "no"}): ${JSON.stringify(bedrockMessages)}`);
+                }
+                await this.streamWithBedrock(specification, bedrockMessages, system, tools, uiAdapter, (message, calls) => {
+                    roundMessage = message;
+                    toolCalls = calls;
+                });
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`\n🏁 [Streaming] Bedrock native streaming completed (Round ${currentRound})`);
+                }
+            }
+            else if (serviceType === Types.ModelServiceTypes.Deepseek &&
+                (OpenAI || this.deepseekClient)) {
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`\n✅ [Streaming] Using Deepseek native streaming (Round ${currentRound})`);
+                }
+                const deepseekMessages = formatMessagesForOpenAI(messages); // Deepseek uses OpenAI format
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING_MESSAGES) {
+                    console.log(`🔍 [Deepseek] Sending ${deepseekMessages.length} messages to LLM: ${JSON.stringify(deepseekMessages)}`);
+                }
+                await this.streamWithDeepseek(specification, deepseekMessages, tools, uiAdapter, (message, calls) => {
+                    roundMessage = message;
+                    toolCalls = calls;
+                });
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`\n🏁 [Streaming] Deepseek native streaming completed (Round ${currentRound})`);
+                }
+            }
             else {
                 // Fallback to non-streaming
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
@@ -2215,6 +2569,135 @@ class Graphlit {
         }
         await streamWithGoogle(specification, messages, systemPrompt, tools, googleClient, (event) => uiAdapter.handleEvent(event), onComplete);
     }
+    /**
+     * Stream with Groq client (OpenAI-compatible)
+     */
+    async streamWithGroq(specification, messages, tools, uiAdapter, onComplete) {
+        // Check if we have either the Groq module or a provided client
+        if (!Groq && !this.groqClient) {
+            throw new Error("Groq client not available");
+        }
+        // Use provided client or create a new one
+        const groqClient = this.groqClient ||
+            (Groq
+                ? new Groq({ apiKey: process.env.GROQ_API_KEY || "" })
+                : (() => {
+                    throw new Error("Groq module not available");
+                })());
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🚀 [Graphlit SDK] Routing to Groq streaming provider | Spec: ${specification.name} (${specification.id}) | Messages: ${messages.length} | Tools: ${tools?.length || 0}`);
+        }
+        await streamWithGroq(specification, messages, tools, groqClient, (event) => uiAdapter.handleEvent(event), onComplete);
+    }
+    /**
+     * Stream with Cerebras client (OpenAI-compatible)
+     */
+    async streamWithCerebras(specification, messages, tools, uiAdapter, onComplete) {
+        // Check if we have either the OpenAI module or a provided client
+        if (!OpenAI && !this.cerebrasClient) {
+            throw new Error("Cerebras client not available");
+        }
+        // Use provided client or create a new one configured for Cerebras
+        const cerebrasClient = this.cerebrasClient ||
+            (OpenAI
+                ? new OpenAI({
+                    apiKey: process.env.CEREBRAS_API_KEY || "",
+                    baseURL: "https://api.cerebras.ai/v1",
+                })
+                : (() => {
+                    throw new Error("OpenAI module not available for Cerebras");
+                })());
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🚀 [Graphlit SDK] Routing to Cerebras streaming provider | Spec: ${specification.name} (${specification.id}) | Messages: ${messages.length} | Tools: ${tools?.length || 0}`);
+        }
+        await streamWithCerebras(specification, messages, tools, cerebrasClient, (event) => uiAdapter.handleEvent(event), onComplete);
+    }
+    /**
+     * Stream with Cohere client
+     */
+    async streamWithCohere(specification, messages, tools, uiAdapter, onComplete) {
+        // Check if we have either the Cohere module or a provided client
+        if (!CohereClient && !this.cohereClient) {
+            throw new Error("Cohere client not available");
+        }
+        // Use provided client or create a new one
+        const cohereClient = this.cohereClient ||
+            (CohereClient
+                ? new CohereClient({ token: process.env.COHERE_API_KEY || "" })
+                : (() => {
+                    throw new Error("Cohere module not available");
+                })());
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🚀 [Graphlit SDK] Routing to Cohere streaming provider | Spec: ${specification.name} (${specification.id}) | Messages: ${messages.length} | Tools: ${tools?.length || 0}`);
+        }
+        await streamWithCohere(specification, messages, tools, cohereClient, (event) => uiAdapter.handleEvent(event), onComplete);
+    }
+    /**
+     * Stream with Mistral client
+     */
+    async streamWithMistral(specification, messages, tools, uiAdapter, onComplete) {
+        // Check if we have either the Mistral module or a provided client
+        if (!Mistral && !this.mistralClient) {
+            throw new Error("Mistral client not available");
+        }
+        // Use provided client or create a new one
+        const mistralClient = this.mistralClient ||
+            (Mistral
+                ? new Mistral({ apiKey: process.env.MISTRAL_API_KEY || "" })
+                : (() => {
+                    throw new Error("Mistral module not available");
+                })());
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🚀 [Graphlit SDK] Routing to Mistral streaming provider | Spec: ${specification.name} (${specification.id}) | Messages: ${messages.length} | Tools: ${tools?.length || 0}`);
+        }
+        await streamWithMistral(specification, messages, tools, mistralClient, (event) => uiAdapter.handleEvent(event), onComplete);
+    }
+    /**
+     * Stream with Bedrock client
+     */
+    async streamWithBedrock(specification, messages, systemPrompt, tools, uiAdapter, onComplete) {
+        // Check if we have either the Bedrock module or a provided client
+        if (!BedrockRuntimeClient && !this.bedrockClient) {
+            throw new Error("Bedrock client not available");
+        }
+        // Use provided client or create a new one
+        const bedrockClient = this.bedrockClient ||
+            (BedrockRuntimeClient
+                ? new BedrockRuntimeClient({
+                    region: process.env.AWS_REGION || "us-east-2",
+                })
+                : (() => {
+                    throw new Error("Bedrock module not available");
+                })());
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🚀 [Graphlit SDK] Routing to Bedrock streaming provider | Spec: ${specification.name} (${specification.id}) | Messages: ${messages.length} | Tools: ${tools?.length || 0} | SystemPrompt: ${systemPrompt ? "Yes" : "No"}`);
+        }
+        await streamWithBedrock(specification, messages, systemPrompt, tools, bedrockClient, (event) => uiAdapter.handleEvent(event), onComplete);
+    }
+    /**
+     * Stream with Deepseek client
+     */
+    async streamWithDeepseek(specification, messages, tools, uiAdapter, onComplete) {
+        // Check if we have either the OpenAI module or a provided Deepseek client
+        if (!OpenAI && !this.deepseekClient) {
+            throw new Error("Deepseek client not available (requires OpenAI SDK)");
+        }
+        // Use provided client or create a new one with Deepseek base URL
+        const deepseekClient = this.deepseekClient ||
+            (OpenAI
+                ? new OpenAI({
+                    baseURL: "https://api.deepseek.com",
+                    apiKey: process.env.DEEPSEEK_API_KEY || "",
+                })
+                : null);
+        if (!deepseekClient) {
+            throw new Error("Failed to create Deepseek client");
+        }
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🚀 [Graphlit SDK] Routing to Deepseek streaming provider | Spec: ${specification.name} (${specification.id}) | Messages: ${messages.length} | Tools: ${tools?.length || 0}`);
+        }
+        await streamWithDeepseek(specification, messages, tools, deepseekClient, (event) => uiAdapter.handleEvent(event), onComplete);
+    }
     // Helper method to execute tools for promptAgent
     async executeToolsForPromptAgent(toolCalls, toolHandlers, allToolCalls, signal) {
         const responses = [];