graphlit-client 1.0.20250625001 → 1.0.20250627001

package/dist/client.js

@@ -8,7 +8,7 @@ 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, formatMessagesForCohere, formatMessagesForMistral, formatMessagesForBedrock, } from "./streaming/llm-formatters.js";
+import { formatMessagesForOpenAI, formatMessagesForAnthropic, formatMessagesForGoogle, 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
@@ -20,6 +20,7 @@ let Anthropic;
 let GoogleGenerativeAI;
 let Groq;
 let CohereClient;
+let CohereClientV2;
 let Mistral;
 let BedrockRuntimeClient;
 try {
@@ -74,6 +75,7 @@ catch (e) {
 }
 try {
     CohereClient = optionalRequire("cohere-ai").CohereClient;
+    CohereClientV2 = optionalRequire("cohere-ai").CohereClientV2;
     if (process.env.DEBUG_GRAPHLIT_SDK_INITIALIZATION) {
         console.log("[SDK Loading] Cohere SDK loaded successfully");
     }
@@ -1026,6 +1028,108 @@ class Graphlit {
     async queryModels(filter) {
         return this.queryAndCheckError(Documents.QueryModels, { filter: filter });
     }
+    async createConnector(connector) {
+        return this.mutateAndCheckError(Documents.CreateConnector, { connector: connector });
+    }
+    async updateConnector(connector) {
+        return this.mutateAndCheckError(Documents.UpdateConnector, { connector: connector });
+    }
+    /*
+    public async upsertConnector(
+      connector: Types.ConnectorInput
+    ): Promise<Types.UpsertConnectorMutation> {
+      return this.mutateAndCheckError<
+        Types.UpsertConnectorMutation,
+        { connector: Types.ConnectorInput }
+      >(Documents.UpsertConnector, { connector: connector });
+    }
+    */
+    async deleteConnector(id) {
+        return this.mutateAndCheckError(Documents.DeleteConnector, { id: id });
+    }
+    /*
+    public async deleteConnectors(
+      ids: string[],
+      isSynchronous?: boolean
+    ): Promise<Types.DeleteConnectorsMutation> {
+      return this.mutateAndCheckError<
+        Types.DeleteConnectorsMutation,
+        { ids: string[]; isSynchronous?: boolean }
+      >(Documents.DeleteConnectors, { ids: ids, isSynchronous: isSynchronous });
+    }
+  
+    public async deleteAllConnectors(
+      filter?: Types.ConnectorFilter,
+      isSynchronous?: boolean,
+      correlationId?: string
+    ): Promise<Types.DeleteAllConnectorsMutation> {
+      return this.mutateAndCheckError<
+        Types.DeleteAllConnectorsMutation,
+        {
+          filter?: Types.ConnectorFilter;
+          isSynchronous?: boolean;
+          correlationId?: string;
+        }
+      >(Documents.DeleteAllConnectors, {
+        filter: filter,
+        isSynchronous: isSynchronous,
+        correlationId: correlationId,
+      });
+    }
+    */
+    async getConnector(id) {
+        return this.queryAndCheckError(Documents.GetConnector, { id: id });
+    }
+    async queryConnectors(filter) {
+        return this.queryAndCheckError(Documents.QueryConnectors, { filter: filter });
+    }
+    async countConnectors(filter) {
+        return this.queryAndCheckError(Documents.CountConnectors, { filter: filter });
+    }
+    /*
+    public async connectorExists(
+      filter?: Types.ConnectorFilter
+    ): Promise<Types.ConnectorExistsQuery> {
+      return this.queryAndCheckError<
+        Types.QueryConnectorsQuery,
+        { filter?: Types.ConnectorFilter }
+      >(Documents.ConnectorExists, { filter: filter });
+    }
+    */
+    async createView(view) {
+        return this.mutateAndCheckError(Documents.CreateView, { view: view });
+    }
+    async updateView(view) {
+        return this.mutateAndCheckError(Documents.UpdateView, { view: view });
+    }
+    async upsertView(view) {
+        return this.mutateAndCheckError(Documents.UpsertView, { view: view });
+    }
+    async deleteView(id) {
+        return this.mutateAndCheckError(Documents.DeleteView, { id: id });
+    }
+    async deleteViews(ids, isSynchronous) {
+        return this.mutateAndCheckError(Documents.DeleteViews, { ids: ids, isSynchronous: isSynchronous });
+    }
+    async deleteAllViews(filter, isSynchronous, correlationId) {
+        return this.mutateAndCheckError(Documents.DeleteAllViews, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
+        });
+    }
+    async getView(id) {
+        return this.queryAndCheckError(Documents.GetView, { id: id });
+    }
+    async queryViews(filter) {
+        return this.queryAndCheckError(Documents.QueryViews, { filter: filter });
+    }
+    async countViews(filter) {
+        return this.queryAndCheckError(Documents.CountViews, { filter: filter });
+    }
+    async viewExists(filter) {
+        return this.queryAndCheckError(Documents.ViewExists, { filter: filter });
+    }
     async createWorkflow(workflow) {
         return this.mutateAndCheckError(Documents.CreateWorkflow, { workflow: workflow });
     }
@@ -1649,7 +1753,7 @@ class Graphlit {
      * @param specification - Optional specification to check compatibility
      * @returns true if streaming is available, false otherwise
      */
-    supportsStreaming(specification) {
+    supportsStreaming(specification, tools) {
         // If we have a full specification, check its service type
         if (specification) {
             const serviceType = specification.serviceType;
@@ -1677,12 +1781,26 @@ class Graphlit {
                 case Types.ModelServiceTypes.Cerebras:
                     return OpenAI !== undefined || this.cerebrasClient !== undefined;
                 case Types.ModelServiceTypes.Cohere:
-                    return CohereClient !== undefined || this.cohereClient !== undefined;
+                    return (CohereClient !== undefined ||
+                        CohereClientV2 !== undefined ||
+                        this.cohereClient !== undefined);
                 case Types.ModelServiceTypes.Mistral:
                     return Mistral !== undefined || this.mistralClient !== undefined;
                 case Types.ModelServiceTypes.Bedrock:
-                    return (BedrockRuntimeClient !== undefined ||
-                        this.bedrockClient !== undefined);
+                    const hasBedrockClient = BedrockRuntimeClient !== undefined ||
+                        this.bedrockClient !== undefined;
+                    // Bedrock Llama models don't support tools in streaming mode
+                    if (hasBedrockClient && tools && tools.length > 0) {
+                        const bedrockModel = specification.bedrock?.model;
+                        if (bedrockModel === Types.BedrockModels.Llama_4Maverick_17B ||
+                            bedrockModel === Types.BedrockModels.Llama_4Scout_17B) {
+                            if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                                console.log(`⚠️ [supportsStreaming] Bedrock Llama model ${bedrockModel} does not support tools in streaming mode - will fallback to non-streaming`);
+                            }
+                            return false; // Force fallback to promptAgent for tool support
+                        }
+                    }
+                    return hasBedrockClient;
                 case Types.ModelServiceTypes.Deepseek:
                     return OpenAI !== undefined || this.deepseekClient !== undefined;
                 default:
@@ -1696,7 +1814,9 @@ class Graphlit {
         const hasGoogle = GoogleGenerativeAI !== undefined || this.googleClient !== undefined;
         const hasGroq = Groq !== undefined || this.groqClient !== undefined;
         const hasCerebras = OpenAI !== undefined || this.cerebrasClient !== undefined;
-        const hasCohere = CohereClient !== undefined || this.cohereClient !== undefined;
+        const hasCohere = CohereClient !== undefined ||
+            CohereClientV2 !== undefined ||
+            this.cohereClient !== undefined;
         const hasMistral = Mistral !== undefined || this.mistralClient !== undefined;
         const hasBedrock = BedrockRuntimeClient !== undefined || this.bedrockClient !== undefined;
         return (hasOpenAI ||
@@ -1914,7 +2034,7 @@ class Graphlit {
                 }
             }
             // Check streaming support - fallback to promptAgent if not supported
-            if (fullSpec && !this.supportsStreaming(fullSpec)) {
+            if (fullSpec && !this.supportsStreaming(fullSpec, tools)) {
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log("\n⚠️ [streamAgent] Streaming not supported, falling back to promptAgent with same conversation");
                 }
@@ -1929,6 +2049,31 @@ class Graphlit {
                     conversationId: actualConversationId,
                     timestamp: new Date(),
                 });
+                // Debug logging for fallback
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`📊 [streamAgent fallback] promptAgent result:`, {
+                        hasMessage: !!promptResult.message,
+                        messageLength: promptResult.message?.length,
+                        toolCallsCount: promptResult.toolCalls?.length || 0,
+                        toolResultsCount: promptResult.toolResults?.length || 0,
+                        toolCalls: promptResult.toolCalls,
+                        toolResults: promptResult.toolResults?.map((tr) => ({
+                            name: tr.name,
+                            hasResult: !!tr.result,
+                            hasError: !!tr.error,
+                        })),
+                    });
+                }
+                // Emit tool events if there were tool calls
+                if (promptResult.toolCalls && promptResult.toolCalls.length > 0) {
+                    for (const toolCall of promptResult.toolCalls) {
+                        onEvent({
+                            type: "tool_update",
+                            toolCall: toolCall,
+                            status: "completed",
+                        });
+                    }
+                }
                 // Emit the final message as a single update (simulating streaming)
                 onEvent({
                     type: "message_update",
@@ -1937,7 +2082,7 @@ class Graphlit {
                         message: promptResult.message,
                         role: Types.ConversationRoleTypes.Assistant,
                         timestamp: new Date().toISOString(),
-                        toolCalls: [],
+                        toolCalls: promptResult.toolCalls || [],
                     },
                     isStreaming: false,
                 });
@@ -1949,7 +2094,7 @@ class Graphlit {
                         message: promptResult.message,
                         role: Types.ConversationRoleTypes.Assistant,
                         timestamp: new Date().toISOString(),
-                        toolCalls: [],
+                        toolCalls: promptResult.toolCalls || [],
                     },
                 });
                 return; // Exit early after successful fallback
@@ -2132,7 +2277,7 @@ class Graphlit {
                 await this.streamWithOpenAI(specification, openaiMessages, tools, uiAdapter, (message, calls) => {
                     roundMessage = message;
                     toolCalls = calls;
-                });
+                }, abortSignal);
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`\n🏁 [Streaming] OpenAI native streaming completed (Round ${currentRound})`);
                 }
@@ -2149,7 +2294,7 @@ class Graphlit {
                 await this.streamWithAnthropic(specification, anthropicMessages, system, tools, uiAdapter, (message, calls) => {
                     roundMessage = message;
                     toolCalls = calls;
-                });
+                }, abortSignal);
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`\n🏁 [Streaming] Anthropic native streaming completed (Round ${currentRound})`);
                 }
@@ -2168,7 +2313,7 @@ class Graphlit {
                 tools, uiAdapter, (message, calls) => {
                     roundMessage = message;
                     toolCalls = calls;
-                });
+                }, abortSignal);
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`\n🏁 [Streaming] Google native streaming completed (Round ${currentRound})`);
                 }
@@ -2185,7 +2330,7 @@ class Graphlit {
                 await this.streamWithGroq(specification, groqMessages, tools, uiAdapter, (message, calls) => {
                     roundMessage = message;
                     toolCalls = calls;
-                });
+                }, abortSignal);
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`\n🏁 [Streaming] Groq native streaming completed (Round ${currentRound})`);
                 }
@@ -2202,24 +2347,24 @@ class Graphlit {
                 await this.streamWithCerebras(specification, cerebrasMessages, tools, uiAdapter, (message, calls) => {
                     roundMessage = message;
                     toolCalls = calls;
-                });
+                }, abortSignal);
                 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)) {
+                (CohereClient || CohereClientV2 || this.cohereClient)) {
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`\n✅ [Streaming] Using Cohere native streaming (Round ${currentRound})`);
                 }
-                const cohereMessages = formatMessagesForCohere(messages);
+                // V2 API uses raw messages, not formatted
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING_MESSAGES) {
-                    console.log(`🔍 [Cohere] Sending ${cohereMessages.length} messages to LLM: ${JSON.stringify(cohereMessages)}`);
+                    console.log(`🔍 [Cohere] Sending ${messages.length} messages to LLM`);
                 }
-                await this.streamWithCohere(specification, cohereMessages, tools, uiAdapter, (message, calls) => {
+                await this.streamWithCohere(specification, messages, tools, uiAdapter, (message, calls) => {
                     roundMessage = message;
                     toolCalls = calls;
-                });
+                }, abortSignal);
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`\n🏁 [Streaming] Cohere native streaming completed (Round ${currentRound})`);
                 }
@@ -2230,13 +2375,26 @@ class Graphlit {
                     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)}`);
+                // ALWAYS log when there's a tool-related issue for debugging
+                const hasToolCalls = mistralMessages.some((m) => m.tool_calls?.length > 0);
+                const hasToolResponses = mistralMessages.some((m) => m.role === "tool");
+                if (hasToolCalls ||
+                    hasToolResponses ||
+                    process.env.DEBUG_GRAPHLIT_SDK_STREAMING_MESSAGES) {
+                    console.log(`🔍 [Mistral] Sending ${mistralMessages.length} messages to LLM:`);
+                    console.log(JSON.stringify(mistralMessages, null, 2));
+                    // Count tool calls and responses
+                    const toolCallCount = mistralMessages.reduce((count, m) => count + (m.tool_calls?.length || 0), 0);
+                    const toolResponseCount = mistralMessages.filter((m) => m.role === "tool").length;
+                    console.log(`🔍 [Mistral] Tool calls: ${toolCallCount}, Tool responses: ${toolResponseCount}`);
+                    if (toolResponseCount > 0) {
+                        console.log(`🔍 [Mistral] IMPORTANT: We have tool responses, should we still pass tools?`);
+                    }
                 }
                 await this.streamWithMistral(specification, mistralMessages, tools, uiAdapter, (message, calls) => {
                     roundMessage = message;
                     toolCalls = calls;
-                });
+                }, abortSignal);
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`\n🏁 [Streaming] Mistral native streaming completed (Round ${currentRound})`);
                 }
@@ -2253,7 +2411,7 @@ class Graphlit {
                 await this.streamWithBedrock(specification, bedrockMessages, system, tools, uiAdapter, (message, calls) => {
                     roundMessage = message;
                     toolCalls = calls;
-                });
+                }, abortSignal);
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`\n🏁 [Streaming] Bedrock native streaming completed (Round ${currentRound})`);
                 }
@@ -2270,7 +2428,7 @@ class Graphlit {
                 await this.streamWithDeepseek(specification, deepseekMessages, tools, uiAdapter, (message, calls) => {
                     roundMessage = message;
                     toolCalls = calls;
-                });
+                }, abortSignal);
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`\n🏁 [Streaming] Deepseek native streaming completed (Round ${currentRound})`);
                 }
@@ -2408,13 +2566,16 @@ class Graphlit {
                             result: result,
                         });
                         // Add tool response to messages
-                        messages.push({
+                        const toolMessage = {
                             __typename: "ConversationMessage",
                             role: Types.ConversationRoleTypes.Tool,
                             message: typeof result === "string" ? result : JSON.stringify(result),
                             toolCallId: toolCall.id,
                             timestamp: new Date().toISOString(),
-                        });
+                        };
+                        // Add tool name for Mistral compatibility
+                        toolMessage.toolName = toolCall.name;
+                        messages.push(toolMessage);
                     }
                     catch (error) {
                         const errorMessage = error instanceof Error ? error.message : "Unknown error";
@@ -2430,13 +2591,16 @@ class Graphlit {
                             error: errorMessage,
                         });
                         // Add error response
-                        messages.push({
+                        const errorToolMessage = {
                             __typename: "ConversationMessage",
                             role: Types.ConversationRoleTypes.Tool,
                             message: `Error: ${errorMessage}`,
                             toolCallId: toolCall.id,
                             timestamp: new Date().toISOString(),
-                        });
+                        };
+                        // Add tool name for Mistral compatibility
+                        errorToolMessage.toolName = toolCall.name;
+                        messages.push(errorToolMessage);
                     }
                 }
             }
@@ -2450,7 +2614,14 @@ class Graphlit {
             const completionTime = uiAdapter.getCompletionTime(); // Total time in milliseconds
             const ttft = uiAdapter.getTTFT(); // Time to first token in milliseconds
             const throughput = uiAdapter.getThroughput(); // Tokens per second
-            const completeResponse = await this.completeConversation(trimmedMessage, conversationId, completionTime, ttft, throughput, correlationId);
+            // Convert milliseconds to ISO 8601 duration format (e.g., "PT1.5S")
+            const millisecondsToTimeSpan = (ms) => {
+                if (ms === undefined)
+                    return undefined;
+                const seconds = ms / 1000;
+                return `PT${seconds}S`;
+            };
+            const completeResponse = await this.completeConversation(trimmedMessage, conversationId, millisecondsToTimeSpan(completionTime), millisecondsToTimeSpan(ttft), throughput, correlationId);
             // Extract token count from the response
             finalTokens =
                 completeResponse.completeConversation?.message?.tokens ?? undefined;
@@ -2604,7 +2775,7 @@ class Graphlit {
     /**
      * Stream with OpenAI client
      */
-    async streamWithOpenAI(specification, messages, tools, uiAdapter, onComplete) {
+    async streamWithOpenAI(specification, messages, tools, uiAdapter, onComplete, abortSignal) {
         // Check if we have either the OpenAI module or a provided client
         if (!OpenAI && !this.openaiClient) {
             throw new Error("OpenAI client not available");
@@ -2621,12 +2792,12 @@ class Graphlit {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🚀 [Graphlit SDK] Routing to OpenAI streaming provider | Spec: ${specification.name} (${specification.id}) | Messages: ${messages.length} | Tools: ${tools?.length || 0}`);
         }
-        await streamWithOpenAI(specification, messages, tools, openaiClient, (event) => uiAdapter.handleEvent(event), onComplete);
+        await streamWithOpenAI(specification, messages, tools, openaiClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal);
     }
     /**
      * Stream with Anthropic client
      */
-    async streamWithAnthropic(specification, messages, systemPrompt, tools, uiAdapter, onComplete) {
+    async streamWithAnthropic(specification, messages, systemPrompt, tools, uiAdapter, onComplete, abortSignal) {
         // Check if we have either the Anthropic module or a provided client
         if (!Anthropic && !this.anthropicClient) {
             throw new Error("Anthropic client not available");
@@ -2643,12 +2814,43 @@ class Graphlit {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🚀 [Graphlit SDK] Routing to Anthropic streaming provider | Spec: ${specification.name} (${specification.id}) | Messages: ${messages.length} | Tools: ${tools?.length || 0} | SystemPrompt: ${systemPrompt ? "Yes" : "No"}`);
         }
-        await streamWithAnthropic(specification, messages, systemPrompt, tools, anthropicClient, (event) => uiAdapter.handleEvent(event), onComplete);
+        // Get thinking configuration from specification
+        const thinkingConfig = this.getThinkingConfig(specification);
+        if (thinkingConfig && process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🧠 [Graphlit SDK] Anthropic thinking enabled | Budget: ${thinkingConfig.budget_tokens} tokens`);
+        }
+        await streamWithAnthropic(specification, messages, systemPrompt, tools, anthropicClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal, thinkingConfig);
+    }
+    /**
+     * Extract thinking configuration from specification
+     */
+    getThinkingConfig(specification) {
+        // Check Anthropic specifications
+        if (specification.serviceType === Types.ModelServiceTypes.Anthropic) {
+            const anthropic = specification.anthropic;
+            if (anthropic?.enableThinking) {
+                return {
+                    type: "enabled",
+                    budget_tokens: anthropic.thinkingTokenLimit || 10000,
+                };
+            }
+        }
+        // Check Google specifications (also supports thinking)
+        if (specification.serviceType === Types.ModelServiceTypes.Google) {
+            const google = specification.google;
+            if (google?.enableThinking) {
+                return {
+                    type: "enabled",
+                    budget_tokens: google.thinkingTokenLimit || 10000,
+                };
+            }
+        }
+        return undefined;
     }
     /**
      * Stream with Google client
      */
-    async streamWithGoogle(specification, messages, systemPrompt, tools, uiAdapter, onComplete) {
+    async streamWithGoogle(specification, messages, systemPrompt, tools, uiAdapter, onComplete, abortSignal) {
         // Check if we have either the Google module or a provided client
         if (!GoogleGenerativeAI && !this.googleClient) {
             throw new Error("Google GenerativeAI client not available");
@@ -2663,12 +2865,12 @@ class Graphlit {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🚀 [Graphlit SDK] Routing to Google streaming provider | Spec: ${specification.name} (${specification.id}) | Messages: ${messages.length} | Tools: ${tools?.length || 0} | SystemPrompt: ${systemPrompt ? "Yes" : "No"}`);
         }
-        await streamWithGoogle(specification, messages, systemPrompt, tools, googleClient, (event) => uiAdapter.handleEvent(event), onComplete);
+        await streamWithGoogle(specification, messages, systemPrompt, tools, googleClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal);
     }
     /**
      * Stream with Groq client (OpenAI-compatible)
      */
-    async streamWithGroq(specification, messages, tools, uiAdapter, onComplete) {
+    async streamWithGroq(specification, messages, tools, uiAdapter, onComplete, abortSignal) {
         // Check if we have either the Groq module or a provided client
         if (!Groq && !this.groqClient) {
             throw new Error("Groq client not available");
@@ -2683,12 +2885,12 @@ class Graphlit {
         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);
+        await streamWithGroq(specification, messages, tools, groqClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal);
     }
     /**
      * Stream with Cerebras client (OpenAI-compatible)
      */
-    async streamWithCerebras(specification, messages, tools, uiAdapter, onComplete) {
+    async streamWithCerebras(specification, messages, tools, uiAdapter, onComplete, abortSignal) {
         // Check if we have either the OpenAI module or a provided client
         if (!OpenAI && !this.cerebrasClient) {
             throw new Error("Cerebras client not available");
@@ -2706,32 +2908,34 @@ class Graphlit {
         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);
+        await streamWithCerebras(specification, messages, tools, cerebrasClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal);
     }
     /**
      * Stream with Cohere client
      */
-    async streamWithCohere(specification, messages, tools, uiAdapter, onComplete) {
+    async streamWithCohere(specification, messages, tools, uiAdapter, onComplete, abortSignal) {
         // Check if we have either the Cohere module or a provided client
-        if (!CohereClient && !this.cohereClient) {
+        if (!CohereClient && !CohereClientV2 && !this.cohereClient) {
             throw new Error("Cohere client not available");
         }
-        // Use provided client or create a new one
+        // Use provided client or create a new one - prefer v2
         const cohereClient = this.cohereClient ||
-            (CohereClient
-                ? new CohereClient({ token: process.env.COHERE_API_KEY || "" })
-                : (() => {
-                    throw new Error("Cohere module not available");
-                })());
+            (CohereClientV2
+                ? new CohereClientV2({ token: process.env.COHERE_API_KEY || "" })
+                : 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);
+        await streamWithCohere(specification, messages, tools, cohereClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal);
     }
     /**
      * Stream with Mistral client
      */
-    async streamWithMistral(specification, messages, tools, uiAdapter, onComplete) {
+    async streamWithMistral(specification, messages, tools, uiAdapter, onComplete, abortSignal) {
         // Check if we have either the Mistral module or a provided client
         if (!Mistral && !this.mistralClient) {
             throw new Error("Mistral client not available");
@@ -2739,19 +2943,25 @@ class Graphlit {
         // Use provided client or create a new one
         const mistralClient = this.mistralClient ||
             (Mistral
-                ? new Mistral({ apiKey: process.env.MISTRAL_API_KEY || "" })
+                ? (() => {
+                    const apiKey = process.env.MISTRAL_API_KEY;
+                    if (!apiKey) {
+                        throw new Error("MISTRAL_API_KEY environment variable is required for Mistral streaming");
+                    }
+                    return new Mistral({ apiKey });
+                })()
                 : (() => {
                     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);
+        await streamWithMistral(specification, messages, tools, mistralClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal);
     }
     /**
      * Stream with Bedrock client
      */
-    async streamWithBedrock(specification, messages, systemPrompt, tools, uiAdapter, onComplete) {
+    async streamWithBedrock(specification, messages, systemPrompt, tools, uiAdapter, onComplete, abortSignal) {
         // Check if we have either the Bedrock module or a provided client
         if (!BedrockRuntimeClient && !this.bedrockClient) {
             throw new Error("Bedrock client not available");
@@ -2768,12 +2978,12 @@ class Graphlit {
         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);
+        await streamWithBedrock(specification, messages, systemPrompt, tools, bedrockClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal);
     }
     /**
      * Stream with Deepseek client
      */
-    async streamWithDeepseek(specification, messages, tools, uiAdapter, onComplete) {
+    async streamWithDeepseek(specification, messages, tools, uiAdapter, onComplete, abortSignal) {
         // 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)");
@@ -2792,7 +3002,7 @@ class Graphlit {
         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);
+        await streamWithDeepseek(specification, messages, tools, deepseekClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal);
     }
     // Helper method to execute tools for promptAgent
     async executeToolsForPromptAgent(toolCalls, toolHandlers, allToolCalls, signal) {

package/dist/generated/graphql-documents.d.ts

@@ -27,6 +27,12 @@ export declare const GetCollection: import("graphql").DocumentNode;
 export declare const QueryCollections: import("graphql").DocumentNode;
 export declare const RemoveContentsFromCollection: import("graphql").DocumentNode;
 export declare const UpdateCollection: import("graphql").DocumentNode;
+export declare const CountConnectors: import("graphql").DocumentNode;
+export declare const CreateConnector: import("graphql").DocumentNode;
+export declare const DeleteConnector: import("graphql").DocumentNode;
+export declare const GetConnector: import("graphql").DocumentNode;
+export declare const QueryConnectors: import("graphql").DocumentNode;
+export declare const UpdateConnector: import("graphql").DocumentNode;
 export declare const CountContents: import("graphql").DocumentNode;
 export declare const DeleteAllContents: import("graphql").DocumentNode;
 export declare const DeleteContent: import("graphql").DocumentNode;
@@ -293,6 +299,16 @@ export declare const GetUser: import("graphql").DocumentNode;
 export declare const GetUserByIdentifier: import("graphql").DocumentNode;
 export declare const QueryUsers: import("graphql").DocumentNode;
 export declare const UpdateUser: import("graphql").DocumentNode;
+export declare const CountViews: import("graphql").DocumentNode;
+export declare const CreateView: import("graphql").DocumentNode;
+export declare const DeleteAllViews: import("graphql").DocumentNode;
+export declare const DeleteView: import("graphql").DocumentNode;
+export declare const DeleteViews: import("graphql").DocumentNode;
+export declare const GetView: import("graphql").DocumentNode;
+export declare const QueryViews: import("graphql").DocumentNode;
+export declare const UpdateView: import("graphql").DocumentNode;
+export declare const UpsertView: import("graphql").DocumentNode;
+export declare const ViewExists: import("graphql").DocumentNode;
 export declare const CountWorkflows: import("graphql").DocumentNode;
 export declare const CreateWorkflow: import("graphql").DocumentNode;
 export declare const DeleteAllWorkflows: import("graphql").DocumentNode;