graphlit-client 1.0.20250716002 → 1.0.20250716004

package/dist/client.d.ts

@@ -72,8 +72,8 @@ declare class Graphlit {
      */
     setGroqClient(client: any): void;
     /**
-     * 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" }))
+     * Set a custom Cerebras client instance for streaming
+     * @param client - Cerebras client instance (e.g., new Cerebras({ apiKey: "..." }))
      */
     setCerebrasClient(client: any): void;
     /**
@@ -493,7 +493,7 @@ declare class Graphlit {
      */
     private streamWithGroq;
     /**
-     * Stream with Cerebras client (OpenAI-compatible)
+     * Stream with Cerebras client (native SDK)
      */
     private streamWithCerebras;
     /**

package/dist/client.js

@@ -23,6 +23,7 @@ let CohereClient;
 let CohereClientV2;
 let Mistral;
 let BedrockRuntimeClient;
+let Cerebras;
 try {
     OpenAI = optionalRequire("openai").default || optionalRequire("openai");
     if (process.env.DEBUG_GRAPHLIT_SDK_INITIALIZATION) {
@@ -110,6 +111,20 @@ catch (e) {
         console.log("[SDK Loading] Bedrock SDK not found:", e.message);
     }
 }
+try {
+    Cerebras =
+        optionalRequire("@cerebras/cerebras_cloud_sdk").default ||
+            optionalRequire("@cerebras/cerebras_cloud_sdk");
+    if (process.env.DEBUG_GRAPHLIT_SDK_INITIALIZATION) {
+        console.log("[SDK Loading] Cerebras SDK loaded successfully");
+    }
+}
+catch (e) {
+    // Cerebras SDK not installed
+    if (process.env.DEBUG_GRAPHLIT_SDK_INITIALIZATION) {
+        console.log("[SDK Loading] Cerebras SDK not found:", e.message);
+    }
+}
 const DEFAULT_MAX_TOOL_ROUNDS = 1000;
 // Helper function to validate GUID format
 function isValidGuid(guid) {
@@ -319,8 +334,8 @@ class Graphlit {
         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" }))
+     * Set a custom Cerebras client instance for streaming
+     * @param client - Cerebras client instance (e.g., new Cerebras({ apiKey: "..." }))
      */
     setCerebrasClient(client) {
         this.cerebrasClient = client;
@@ -1831,7 +1846,7 @@ class Graphlit {
                 case Types.ModelServiceTypes.Groq:
                     return Groq !== undefined || this.groqClient !== undefined;
                 case Types.ModelServiceTypes.Cerebras:
-                    return OpenAI !== undefined || this.cerebrasClient !== undefined;
+                    return Cerebras !== undefined || this.cerebrasClient !== undefined;
                 case Types.ModelServiceTypes.Cohere:
                     return (CohereClient !== undefined ||
                         CohereClientV2 !== undefined ||
@@ -1867,7 +1882,7 @@ class Graphlit {
         const hasAnthropic = Anthropic !== undefined || this.anthropicClient !== undefined;
         const hasGoogle = GoogleGenerativeAI !== undefined || this.googleClient !== undefined;
         const hasGroq = Groq !== undefined || this.groqClient !== undefined;
-        const hasCerebras = OpenAI !== undefined || this.cerebrasClient !== undefined;
+        const hasCerebras = Cerebras !== undefined || this.cerebrasClient !== undefined;
         const hasCohere = CohereClient !== undefined ||
             CohereClientV2 !== undefined ||
             this.cohereClient !== undefined;
@@ -2406,7 +2421,7 @@ class Graphlit {
                 }
             }
             else if (serviceType === Types.ModelServiceTypes.Cerebras &&
-                (OpenAI || this.cerebrasClient)) {
+                (Cerebras || this.cerebrasClient)) {
                 if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                     console.log(`\n✅ [Streaming] Using Cerebras native streaming (Round ${currentRound})`);
                 }
@@ -2973,24 +2988,23 @@ class Graphlit {
         await streamWithGroq(specification, messages, tools, groqClient, (event) => uiAdapter.handleEvent(event), onComplete, abortSignal);
     }
     /**
-     * Stream with Cerebras client (OpenAI-compatible)
+     * Stream with Cerebras client (native SDK)
      */
     async streamWithCerebras(specification, messages, tools, uiAdapter, onComplete, abortSignal) {
-        // Check if we have either the OpenAI module or a provided client
-        if (!OpenAI && !this.cerebrasClient) {
+        // Check if we have either the Cerebras module or a provided client
+        if (!Cerebras && !this.cerebrasClient) {
             throw new Error("Cerebras client not available");
         }
-        // Use provided client or create a new one configured for Cerebras
+        // Use provided client or create a new one with Cerebras native SDK
         const cerebrasClient = this.cerebrasClient ||
-            (OpenAI
-                ? new OpenAI({
+            (Cerebras
+                ? new Cerebras({
                     apiKey: process.env.CEREBRAS_API_KEY || "",
-                    baseURL: "https://api.cerebras.ai/v1",
                     maxRetries: 3,
                     timeout: 60000, // 60 seconds
                 })
                 : (() => {
-                    throw new Error("OpenAI module not available for Cerebras");
+                    throw new Error("Cerebras module not available");
                 })());
         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}`);

package/dist/streaming/providers.d.ts

@@ -26,9 +26,9 @@ onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls:
 export declare function streamWithGroq(specification: Specification, messages: OpenAIMessage[], tools: ToolDefinitionInput[] | undefined, groqClient: any, // Groq client instance (OpenAI-compatible)
 onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
- * Stream with Cerebras SDK (OpenAI-compatible)
+ * Stream with Cerebras native SDK
  */
-export declare function streamWithCerebras(specification: Specification, messages: OpenAIMessage[], tools: ToolDefinitionInput[] | undefined, cerebrasClient: any, // OpenAI client instance configured for Cerebras
+export declare function streamWithCerebras(specification: Specification, messages: OpenAIMessage[], tools: ToolDefinitionInput[] | undefined, cerebrasClient: any, // Cerebras native client instance
 onEvent: (event: StreamEvent) => void, onComplete: (message: string, toolCalls: ConversationToolCall[], usage?: any) => void, abortSignal?: AbortSignal): Promise<void>;
 /**
  * Stream with Deepseek SDK (OpenAI-compatible)

package/dist/streaming/providers.js

@@ -1309,14 +1309,24 @@ onEvent, onComplete, abortSignal) {
     }
 }
 /**
- * Stream with Cerebras SDK (OpenAI-compatible)
+ * Stream with Cerebras native SDK
  */
-export async function streamWithCerebras(specification, messages, tools, cerebrasClient, // OpenAI client instance configured for Cerebras
+export async function streamWithCerebras(specification, messages, tools, cerebrasClient, // Cerebras native client instance
 onEvent, onComplete, abortSignal) {
+    let fullMessage = "";
+    let toolCalls = [];
+    let usageData = null;
+    // Performance metrics
+    const startTime = Date.now();
+    let firstTokenTime = 0;
+    let tokenCount = 0;
     try {
         const modelName = getModelName(specification);
+        if (!modelName) {
+            throw new Error(`No model name found for specification: ${specification.name} (service: ${specification.serviceType})`);
+        }
         // Cerebras has very limited tool support
-        let cerebrasTools = tools;
+        let cerebrasTools = undefined;
         let filteredMessages = messages;
         if (modelName) {
             const isQwen = modelName.toLowerCase().includes("qwen-3-32b");
@@ -1326,7 +1336,17 @@ onEvent, onComplete, abortSignal) {
                     if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                         console.log(`⚠️ [Cerebras] Disabling tools for ${modelName} - only qwen-3-32b supports tools`);
                     }
-                    cerebrasTools = undefined;
+                }
+                else {
+                    // Format tools for Cerebras
+                    cerebrasTools = tools.map((tool) => ({
+                        type: "function",
+                        function: {
+                            name: tool.name,
+                            description: tool.description,
+                            parameters: tool.schema ? JSON.parse(tool.schema) : {},
+                        },
+                    }));
                 }
             }
             // For non-qwen models, we need to filter out any assistant messages with tool_calls
@@ -1346,8 +1366,199 @@ onEvent, onComplete, abortSignal) {
                 });
             }
         }
-        // Cerebras uses the same API as OpenAI, so we can reuse the OpenAI streaming logic
-        return await streamWithOpenAI(specification, filteredMessages, cerebrasTools, cerebrasClient, onEvent, onComplete, abortSignal);
+        // Format messages for Cerebras API
+        const cerebrasMessages = filteredMessages.map((msg) => {
+            if (msg.role === "system") {
+                return { role: "system", content: msg.content || "" };
+            }
+            else if (msg.role === "user") {
+                return { role: "user", content: msg.content || "" };
+            }
+            else if (msg.role === "assistant") {
+                if (msg.tool_calls && msg.tool_calls.length > 0) {
+                    return {
+                        role: "assistant",
+                        content: msg.content || null,
+                        tool_calls: msg.tool_calls.map((tc) => ({
+                            id: tc.id,
+                            type: "function",
+                            function: {
+                                name: tc.function.name,
+                                arguments: tc.function.arguments,
+                            },
+                        })),
+                    };
+                }
+                return { role: "assistant", content: msg.content || "" };
+            }
+            else if (msg.role === "tool") {
+                return {
+                    role: "tool",
+                    content: msg.content || "",
+                    tool_call_id: msg.tool_call_id || "",
+                };
+            }
+            return msg;
+        });
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`🤖 [Cerebras] Model Config: Service=Cerebras | Model=${modelName} | Temperature=${specification.cerebras?.temperature} | MaxTokens=${specification.cerebras?.completionTokenLimit || "null"} | Tools=${cerebrasTools?.length || 0} | Spec="${specification.name}"`);
+        }
+        // Cerebras treats tool calling as structured outputs
+        // Their reasoning models don't support streaming with structured outputs
+        const hasTools = cerebrasTools && cerebrasTools.length > 0;
+        const streamConfig = {
+            model: modelName,
+            messages: cerebrasMessages,
+            stream: !hasTools, // Disable streaming when tools are present
+            temperature: specification.cerebras?.temperature,
+        };
+        // Only add max_tokens if it's defined
+        if (specification.cerebras?.completionTokenLimit) {
+            streamConfig.max_tokens = specification.cerebras.completionTokenLimit;
+        }
+        // Add tools if available
+        if (cerebrasTools) {
+            streamConfig.tools = cerebrasTools;
+        }
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`⏱️ [Cerebras] Starting LLM call at: ${new Date().toISOString()}`);
+            console.log(`📦 [Cerebras] Full request config:`, JSON.stringify(streamConfig, null, 2));
+        }
+        if (hasTools) {
+            // Non-streaming response when tools are present
+            if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                console.log(`🔧 [Cerebras] Using non-streaming mode due to tools`);
+            }
+            const response = await cerebrasClient.chat.completions.create(streamConfig);
+            // Process the complete response
+            if (response.choices && response.choices.length > 0) {
+                const choice = response.choices[0];
+                const message = choice.message;
+                // Handle content
+                if (message.content) {
+                    fullMessage = message.content;
+                    onEvent({ type: "token", token: message.content });
+                    onEvent({ type: "message", message: fullMessage });
+                }
+                // Handle tool calls
+                if (message.tool_calls && message.tool_calls.length > 0) {
+                    for (const toolCall of message.tool_calls) {
+                        const tc = {
+                            id: toolCall.id,
+                            name: toolCall.function.name,
+                            arguments: toolCall.function.arguments,
+                        };
+                        toolCalls.push(tc);
+                        // Emit tool events
+                        onEvent({
+                            type: "tool_call_start",
+                            toolCall: { id: tc.id, name: tc.name },
+                        });
+                        onEvent({
+                            type: "tool_call_parsed",
+                            toolCall: tc,
+                        });
+                    }
+                }
+            }
+            // Capture usage data
+            if (response.usage) {
+                usageData = {
+                    prompt_tokens: response.usage.prompt_tokens,
+                    completion_tokens: response.usage.completion_tokens,
+                    total_tokens: response.usage.total_tokens,
+                };
+            }
+            tokenCount = fullMessage.length; // Approximate for non-streaming
+        }
+        else {
+            // Streaming response when no tools
+            const stream = await cerebrasClient.chat.completions.create(streamConfig);
+            for await (const chunk of stream) {
+                // Handle abort signal
+                if (abortSignal?.aborted) {
+                    if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                        console.log(`🛑 [Cerebras] Stream aborted by user`);
+                    }
+                    break;
+                }
+                const currentTime = Date.now();
+                tokenCount++;
+                if (tokenCount === 1) {
+                    firstTokenTime = currentTime - startTime;
+                    if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                        console.log(`⚡ [Cerebras] First token received in ${firstTokenTime}ms`);
+                    }
+                }
+                // Process the chunk
+                if (chunk.choices && chunk.choices.length > 0) {
+                    const delta = chunk.choices[0].delta;
+                    // Handle content delta
+                    if (delta?.content) {
+                        fullMessage += delta.content;
+                        onEvent({ type: "token", token: delta.content });
+                    }
+                    // Handle tool calls (shouldn't happen in streaming mode but just in case)
+                    if (delta?.tool_calls) {
+                        for (const toolCall of delta.tool_calls) {
+                            const index = toolCall.index || 0;
+                            // Initialize tool call if needed
+                            if (!toolCalls[index]) {
+                                toolCalls[index] = {
+                                    id: toolCall.id || `tool_${Date.now()}_${index}`,
+                                    name: toolCall.function?.name || "",
+                                    arguments: "",
+                                };
+                                if (toolCall.function?.name) {
+                                    onEvent({
+                                        type: "tool_call_start",
+                                        toolCall: {
+                                            id: toolCalls[index].id,
+                                            name: toolCall.function.name,
+                                        },
+                                    });
+                                }
+                            }
+                            // Accumulate arguments
+                            if (toolCall.function?.arguments) {
+                                toolCalls[index].arguments += toolCall.function.arguments;
+                            }
+                        }
+                    }
+                    // Check for finish reason
+                    if (chunk.choices[0].finish_reason === "tool_calls" && toolCalls.length > 0) {
+                        // Emit tool_call_parsed events for completed tool calls
+                        for (const toolCall of toolCalls) {
+                            onEvent({
+                                type: "tool_call_parsed",
+                                toolCall: toolCall,
+                            });
+                        }
+                    }
+                }
+                // Capture usage data if available
+                if (chunk.usage) {
+                    usageData = {
+                        prompt_tokens: chunk.usage.prompt_tokens,
+                        completion_tokens: chunk.usage.completion_tokens,
+                        total_tokens: chunk.usage.total_tokens,
+                    };
+                }
+                // Emit current message
+                onEvent({
+                    type: "message",
+                    message: fullMessage,
+                });
+            }
+        }
+        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+            console.log(`✅ [Cerebras] Complete. Total tokens: ${tokenCount} | Message length: ${fullMessage.length}`);
+        }
+        onEvent({
+            type: "complete",
+            tokens: tokenCount,
+        });
+        onComplete(fullMessage, toolCalls, usageData);
     }
     catch (error) {
         // Handle Cerebras-specific 429 errors

package/dist/streaming/ui-event-adapter.d.ts

@@ -31,6 +31,8 @@ export declare class UIEventAdapter {
     private reasoningSignature?;
     private isInReasoning;
     private usageData?;
+    private hasToolCallsInProgress;
+    private hadToolCallsBeforeResume;
     constructor(onEvent: (event: AgentStreamEvent) => void, conversationId: string, options?: {
         smoothingEnabled?: boolean;
         chunkingStrategy?: ChunkingStrategy;

package/dist/streaming/ui-event-adapter.js

@@ -30,6 +30,8 @@ export class UIEventAdapter {
     reasoningSignature;
     isInReasoning = false;
     usageData;
+    hasToolCallsInProgress = false;
+    hadToolCallsBeforeResume = false;
     constructor(onEvent, conversationId, options = {}) {
         this.onEvent = onEvent;
         this.conversationId = conversationId;
@@ -99,6 +101,9 @@ export class UIEventAdapter {
         this.lastTokenTime = 0;
         this.tokenCount = 0;
         this.tokenDelays = [];
+        // Reset tool call tracking flags
+        this.hasToolCallsInProgress = false;
+        this.hadToolCallsBeforeResume = false;
         // Note: We only clear tool calls here if this is truly a new conversation start
         // For multi-round tool calling, handleStart is only called once at the beginning
         if (this.activeToolCalls.size > 0) {
@@ -124,6 +129,19 @@ export class UIEventAdapter {
         }
         this.lastTokenTime = now;
         this.tokenCount++;
+        // Check if we're resuming after tool calls and need to add newlines
+        if (this.hadToolCallsBeforeResume && this.hasToolCallsInProgress === false) {
+            // We had tool calls before and now we're receiving content again
+            // Add double newline to separate the content from tool results
+            if (this.currentMessage.length > 0 && !this.currentMessage.endsWith('\n\n')) {
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log(`📝 [UIEventAdapter] Adding newlines after tool calls before resuming content`);
+                }
+                this.currentMessage += '\n\n';
+            }
+            // Reset the flag now that we've added the newlines
+            this.hadToolCallsBeforeResume = false;
+        }
         if (this.chunkBuffer) {
             const chunks = this.chunkBuffer.addToken(token);
             // Add chunks to queue for all chunking modes (character, word, sentence)
@@ -155,6 +173,9 @@ export class UIEventAdapter {
             toolCall: conversationToolCall,
             status: "preparing",
         });
+        // Mark that we have tool calls in progress
+        this.hasToolCallsInProgress = true;
+        this.hadToolCallsBeforeResume = true;
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
             console.log(`🔧 [UIEventAdapter] Active tool calls after: ${this.activeToolCalls.size}`);
         }
@@ -219,6 +240,9 @@ export class UIEventAdapter {
                 toolCall: conversationToolCall,
                 status: "ready",
             });
+            // Mark that we have tool calls
+            this.hasToolCallsInProgress = true;
+            this.hadToolCallsBeforeResume = true;
             this.emitUIEvent({
                 type: "tool_update",
                 toolCall: conversationToolCall,
@@ -246,6 +270,21 @@ export class UIEventAdapter {
         else {
             console.warn(`🔧 [UIEventAdapter] Tool call complete for unknown tool ID: ${toolCall.id}`);
         }
+        // Check if all tool calls are complete
+        let allComplete = true;
+        for (const [, data] of this.activeToolCalls) {
+            if (data.status !== "completed" && data.status !== "failed") {
+                allComplete = false;
+                break;
+            }
+        }
+        if (allComplete && this.activeToolCalls.size > 0) {
+            // All tool calls are complete, mark that we're no longer processing tools
+            this.hasToolCallsInProgress = false;
+            if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                console.log(`🔧 [UIEventAdapter] All tool calls complete, ready to resume content streaming`);
+            }
+        }
     }
     handleComplete(tokens) {
         if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graphlit-client",
-  "version": "1.0.20250716002",
+  "version": "1.0.20250716004",
   "description": "Graphlit API Client for TypeScript",
   "type": "module",
   "main": "./dist/client.js",
@@ -28,11 +28,7 @@
     "format": "prettier --write .",
     "build": "tsc -p tsconfig.json",
     "prepublishOnly": "npm run build",
-    "test": "vitest",
-    "test:watch": "vitest --watch",
-    "test:coverage": "vitest --coverage",
-    "test:ui": "vitest --ui",
-    "test:streaming": "vitest --run src/tests/streaming"
+    "test": "vitest"
   },
   "keywords": [
     "Graphlit",
@@ -49,6 +45,7 @@
   "license": "MIT",
   "dependencies": {
     "@apollo/client": "^3.13.8",
+    "@cerebras/cerebras_cloud_sdk": "^1.35.0",
     "@graphql-codegen/cli": "^5.0.7",
     "@graphql-codegen/typescript": "^4.1.6",
     "@graphql-codegen/typescript-operations": "^4.6.1",