npm - graphlit-client - Versions diffs - 1.0.20260402001 → 1.0.20260403001 - Mend

graphlit-client 1.0.20260402001 → 1.0.20260403001

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/dist/client.js CHANGED Viewed

@@ -200,6 +200,8 @@ catch (e) {
     }
 }
 const DEFAULT_MAX_TOOL_ROUNDS = 100;
+/** Maximum number of tool calls to execute concurrently within a single streaming round. */
+const DEFAULT_MAX_PARALLEL_TOOL_CALLS = 4;
 /** Maximum number of retries for transient provider errors (5xx, network, overloaded). */
 const DEFAULT_PROVIDER_RETRIES = 3;
 /** Base delay in ms for exponential backoff between provider retries. */
@@ -5873,7 +5875,7 @@ class Graphlit {
         });
         // Complete the conversation and get token count
         let finalTokens;
-        const trimmedMessage = loopResult.fullMessage?.trim();
+        const trimmedMessage = loopResult.finalAssistantMessage;
         if (trimmedMessage) {
             // Calculate metrics for completeConversation
             const completionTime = uiAdapter.getCompletionTime();
@@ -5930,6 +5932,7 @@ class Graphlit {
         let messages = config.messages;
         let currentRound = 0;
         let fullMessage = "";
+        let finalAssistantMessage = "";
         const contextActions = [];
         const toolCallNames = [];
         const errors = [];
@@ -6285,6 +6288,9 @@ class Graphlit {
             }
             // Update the full message and capture reasoning for persistence
             fullMessage = roundMessage;
+            if (roundMessage.trim()) {
+                finalAssistantMessage = roundMessage.trim();
+            }
             lastRoundReasoning = roundReasoning;
             // Check abort after streaming completes, before starting tool execution
             if (abortSignal?.aborted) {
@@ -6330,8 +6336,8 @@ class Graphlit {
                         roundToolCalls.reduce((sum, tc) => sum + estimateTokens(tc.arguments), 0);
                     budgetTracker.addMessage("", assistantTokens);
                 }
-                // Execute tools and add responses
-                for (const toolCall of roundToolCalls) {
+                const toolExecutionResults = new Array(roundToolCalls.length);
+                const executeStreamingToolCall = async (toolCall, index) => {
                     if (abortSignal?.aborted) {
                         throw new Error("Operation aborted");
                     }
@@ -6359,20 +6365,21 @@ class Graphlit {
                             },
                             error: errorMessage,
                         });
-                        const errorToolMessage = {
-                            __typename: "ConversationMessage",
-                            role: Types.ConversationRoleTypes.Tool,
-                            message: `Error: ${errorMessage}`,
-                            toolCallId: toolCall.id,
-                            timestamp: terminalAt,
-                            toolCallResponse: toolCall.name,
+                        const errorText = `Error: ${errorMessage}`;
+                        toolExecutionResults[index] = {
+                            index,
+                            toolMessage: {
+                                __typename: "ConversationMessage",
+                                role: Types.ConversationRoleTypes.Tool,
+                                message: errorText,
+                                toolCallId: toolCall.id,
+                                timestamp: terminalAt,
+                                toolCallResponse: toolCall.name,
+                            },
+                            budgetText: errorText,
+                            errorEntry: `${toolCall.name}: ${errorMessage}`,
                         };
-                        messages.push(errorToolMessage);
-                        errors.push(`${toolCall.name}: ${errorMessage}`);
-                        if (budgetTracker) {
-                            budgetTracker.addMessage(errorToolMessage.message || "");
-                        }
-                        continue;
+                        return;
                     }
                     try {
                         let args;
@@ -6453,20 +6460,21 @@ class Graphlit {
                                     },
                                     error: parseErrorText,
                                 });
-                                const errorToolMessage = {
-                                    __typename: "ConversationMessage",
-                                    role: Types.ConversationRoleTypes.Tool,
-                                    message: `Error: ${parseErrorText}`,
-                                    toolCallId: toolCall.id,
-                                    timestamp: terminalAt,
-                                    toolCallResponse: toolCall.name,
+                                const errorText = `Error: ${parseErrorText}`;
+                                toolExecutionResults[index] = {
+                                    index,
+                                    toolMessage: {
+                                        __typename: "ConversationMessage",
+                                        role: Types.ConversationRoleTypes.Tool,
+                                        message: errorText,
+                                        toolCallId: toolCall.id,
+                                        timestamp: terminalAt,
+                                        toolCallResponse: toolCall.name,
+                                    },
+                                    budgetText: errorText,
+                                    errorEntry: parseErrorText,
                                 };
-                                messages.push(errorToolMessage);
-                                errors.push(parseErrorText);
-                                if (budgetTracker) {
-                                    budgetTracker.addMessage(errorToolMessage.message || "");
-                                }
-                                continue;
+                                return;
                             }
                         }
                         const executionStartMs = Date.now();
@@ -6504,44 +6512,36 @@ class Graphlit {
                         });
                         const rawResult = typeof result === "string" ? result : JSON.stringify(result);
                         const truncatedResult = truncateToolResult(rawResult, toolResultTokenLimit, toolCall.name);
+                        let contextAction;
                         if (truncatedResult.length < rawResult.length) {
-                            const action = {
+                            contextAction = {
                                 type: "truncated_tool_result",
                                 toolName: toolCall.name,
                                 originalTokens: estimateTokens(rawResult),
                                 truncatedTokens: estimateTokens(truncatedResult),
                             };
-                            contextActions.push(action);
-                            if (budgetTracker) {
-                                uiAdapter.handleEvent({
-                                    type: "context_management",
-                                    action,
-                                    usage: budgetTracker.getUsageSnapshot(),
-                                    timestamp: new Date(),
-                                });
-                            }
                             if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                                 console.log(`📊 [Context Management] Truncated tool result for ${toolCall.name}: ` +
                                     `${estimateTokens(rawResult)} → ${estimateTokens(truncatedResult)} tokens`);
                             }
                         }
-                        const toolMessage = {
-                            __typename: "ConversationMessage",
-                            role: Types.ConversationRoleTypes.Tool,
-                            message: truncatedResult,
-                            toolCallId: toolCall.id,
-                            timestamp: new Date().toISOString(),
-                            toolCallResponse: toolCall.name,
+                        toolExecutionResults[index] = {
+                            index,
+                            toolMessage: {
+                                __typename: "ConversationMessage",
+                                role: Types.ConversationRoleTypes.Tool,
+                                message: truncatedResult,
+                                toolCallId: toolCall.id,
+                                timestamp: new Date().toISOString(),
+                                toolCallResponse: toolCall.name,
+                            },
+                            budgetText: truncatedResult,
+                            contextAction,
                         };
-                        messages.push(toolMessage);
-                        if (budgetTracker) {
-                            budgetTracker.addMessage(truncatedResult);
-                        }
                     }
                     catch (error) {
                         const errorMessage = error instanceof Error ? error.message : "Unknown error";
                         console.error(`Tool execution error for ${toolCall.name}:`, error);
-                        errors.push(`${toolCall.name}: ${errorMessage}`);
                         const completedAt = nowIsoString();
                         if (!toolCall.startedAt) {
                             toolCall.startedAt = completedAt;
@@ -6567,19 +6567,58 @@ class Graphlit {
                             error: errorMessage,
                         });
                         const errorText = `Error: ${errorMessage}`;
-                        const errorToolMessage = {
-                            __typename: "ConversationMessage",
-                            role: Types.ConversationRoleTypes.Tool,
-                            message: errorText,
-                            toolCallId: toolCall.id,
-                            timestamp: new Date().toISOString(),
-                            toolCallResponse: toolCall.name,
+                        toolExecutionResults[index] = {
+                            index,
+                            toolMessage: {
+                                __typename: "ConversationMessage",
+                                role: Types.ConversationRoleTypes.Tool,
+                                message: errorText,
+                                toolCallId: toolCall.id,
+                                timestamp: new Date().toISOString(),
+                                toolCallResponse: toolCall.name,
+                            },
+                            budgetText: errorText,
+                            errorEntry: `${toolCall.name}: ${errorMessage}`,
                         };
-                        messages.push(errorToolMessage);
+                    }
+                };
+                const workerCount = Math.min(DEFAULT_MAX_PARALLEL_TOOL_CALLS, roundToolCalls.length);
+                let nextToolIndex = 0;
+                await Promise.all(Array.from({ length: workerCount }, async () => {
+                    while (true) {
+                        if (abortSignal?.aborted) {
+                            throw new Error("Operation aborted");
+                        }
+                        const currentIndex = nextToolIndex;
+                        nextToolIndex += 1;
+                        if (currentIndex >= roundToolCalls.length) {
+                            break;
+                        }
+                        await executeStreamingToolCall(roundToolCalls[currentIndex], currentIndex);
+                    }
+                }));
+                for (const executionResult of toolExecutionResults) {
+                    if (!executionResult) {
+                        continue;
+                    }
+                    if (executionResult.contextAction) {
+                        contextActions.push(executionResult.contextAction);
                         if (budgetTracker) {
-                            budgetTracker.addMessage(errorText);
+                            uiAdapter.handleEvent({
+                                type: "context_management",
+                                action: executionResult.contextAction,
+                                usage: budgetTracker.getUsageSnapshot(),
+                                timestamp: new Date(),
+                            });
                         }
                     }
+                    messages.push(executionResult.toolMessage);
+                    if (executionResult.errorEntry) {
+                        errors.push(executionResult.errorEntry);
+                    }
+                    if (budgetTracker) {
+                        budgetTracker.addMessage(executionResult.budgetText);
+                    }
                 }
             }
             // Emit context window usage after each tool round
@@ -6628,6 +6667,7 @@ class Graphlit {
         });
         return {
             fullMessage,
+            finalAssistantMessage,
             toolCallCount: totalToolCallCount,
             toolCallNames,
             errors,
@@ -7012,7 +7052,7 @@ class Graphlit {
                     uiAdapter.dispose();
                 }
                 // 8. Complete conversation (persist turn)
-                const trimmedMessage = loopResult.fullMessage?.trim();
+                const trimmedMessage = loopResult.finalAssistantMessage;
                 if (trimmedMessage) {
                     const completionTime = uiAdapter.getCompletionTime();
                     const ttft = uiAdapter.getTTFT();
@@ -7068,7 +7108,7 @@ class Graphlit {
                 };
                 turnResults.push(turnResult);
                 totalToolCalls += loopResult.toolCallCount;
-                finalMessage = loopResult.fullMessage;
+                finalMessage = loopResult.finalAssistantMessage || loopResult.fullMessage;
                 lastContextWindow = loopResult.contextWindow;
                 // 10. Notify callback
                 options?.onTurnComplete?.(turnResult);

package/dist/types/agent.d.ts CHANGED Viewed

@@ -208,6 +208,7 @@ export interface StreamingLoopConfig {
 /** Result returned from executeStreamingLoop. */
 export interface StreamingLoopResult {
     fullMessage: string;
+    finalAssistantMessage: string;
     toolCallCount: number;
     toolCallNames: string[];
     errors: string[];

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "graphlit-client",
-  "version": "1.0.20260402001",
+  "version": "1.0.20260403001",
   "description": "Graphlit API Client for TypeScript",
   "type": "module",
   "main": "./dist/client.js",