graphlit-client 1.0.20260217003 → 1.0.20260217004

package/dist/client.d.ts

@@ -51,6 +51,7 @@ declare class Graphlit {
     private bedrockClient?;
     private deepseekClient?;
     private xaiClient?;
+    private readonly conversationQueues;
     constructor(organizationIdOrOptions?: string | GraphlitClientOptions, environmentId?: string, jwtSecret?: string, ownerId?: string, userId?: string, apiUri?: string);
     /**
      * Initialize the Apollo client without regenerating the token.
@@ -2525,6 +2526,12 @@ declare class Graphlit {
      */
     promptAgent(prompt: string, conversationId?: string, specification?: Types.EntityReferenceInput, tools?: Types.ToolDefinitionInput[], toolHandlers?: Record<string, ToolHandler>, options?: AgentOptions, mimeType?: string, data?: string, // base64 encoded
     contentFilter?: Types.ContentCriteriaInput, augmentedFilter?: Types.ContentCriteriaInput, correlationId?: string, persona?: Types.EntityReferenceInput): Promise<AgentResult>;
+    /**
+     * Serializes async work per conversation ID to prevent concurrent formatConversation /
+     * completeConversation calls from racing each other. Each call chains after the previous
+     * one for the same conversation, so messages are always processed in order.
+     */
+    private enqueueForConversation;
     /**
      * Execute an agent with streaming response
      * @param prompt - The user prompt

package/dist/client.js

@@ -155,6 +155,9 @@ class Graphlit {
     bedrockClient;
     deepseekClient;
     xaiClient;
+    // Serializes streamAgent calls per conversation to prevent race conditions
+    // when a user sends a second message before the first response completes.
+    conversationQueues = new Map();
     constructor(organizationIdOrOptions, environmentId, jwtSecret, ownerId, userId, apiUri) {
         // Handle both old constructor signature and new options object
         let options;
@@ -4686,6 +4689,29 @@ class Graphlit {
             clearTimeout(timeoutId);
         }
     }
+    /**
+     * Serializes async work per conversation ID to prevent concurrent formatConversation /
+     * completeConversation calls from racing each other. Each call chains after the previous
+     * one for the same conversation, so messages are always processed in order.
+     */
+    enqueueForConversation(conversationId, work, abortSignal) {
+        const previous = this.conversationQueues.get(conversationId) ?? Promise.resolve();
+        // Swallow errors from the previous call so a failed message doesn't
+        // permanently block the queue for this conversation.
+        // Check the abort signal before starting work so ESC while queued is instant.
+        const next = previous.catch(() => { }).then(() => {
+            if (abortSignal?.aborted)
+                throw new Error("Operation aborted");
+            return work();
+        });
+        this.conversationQueues.set(conversationId, next);
+        next.finally(() => {
+            if (this.conversationQueues.get(conversationId) === next) {
+                this.conversationQueues.delete(conversationId);
+            }
+        });
+        return next;
+    }
     /**
      * Execute an agent with streaming response
      * @param prompt - The user prompt
@@ -4744,107 +4770,130 @@ class Graphlit {
                     throw new Error("Failed to create conversation");
                 }
             }
-            // Check streaming support - fallback to promptAgent if not supported
-            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");
-                }
-                // Fallback to promptAgent using the same conversation and parameters
-                const promptResult = await this.promptAgent(prompt, actualConversationId, // Preserve conversation
-                specification, tools, toolHandlers, {
-                    maxToolRounds: maxRounds,
-                }, mimeType, data, contentFilter, augmentedFilter, correlationId, persona);
-                // Convert promptAgent result to streaming events
+            // Serialize execution per-conversation: if the user sends a second message
+            // before the first response completes, queue it so formatConversation /
+            // completeConversation calls never interleave on the same conversation.
+            if (this.conversationQueues.has(actualConversationId)) {
                 onEvent({
-                    type: "conversation_started",
+                    type: "conversation_queued",
                     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,
-                        })),
+            }
+            await this.enqueueForConversation(actualConversationId, async () => {
+                // Check streaming support - fallback to promptAgent if not supported
+                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");
+                    }
+                    // Fallback to promptAgent using the same conversation and parameters
+                    const promptResult = await this.promptAgent(prompt, actualConversationId, // Preserve conversation
+                    specification, tools, toolHandlers, {
+                        maxToolRounds: maxRounds,
+                    }, mimeType, data, contentFilter, augmentedFilter, correlationId, persona);
+                    // Convert promptAgent result to streaming events
+                    onEvent({
+                        type: "conversation_started",
+                        conversationId: actualConversationId,
+                        timestamp: new Date(),
                     });
-                }
-                // 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",
+                    // 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",
+                        message: {
+                            __typename: "ConversationMessage",
+                            message: promptResult.message,
+                            role: Types.ConversationRoleTypes.Assistant,
+                            timestamp: new Date().toISOString(),
+                            toolCalls: promptResult.toolCalls || [],
+                        },
+                        isStreaming: false,
+                    });
+                    // Emit completion event
+                    onEvent({
+                        type: "conversation_completed",
+                        message: {
+                            __typename: "ConversationMessage",
+                            message: promptResult.message,
+                            role: Types.ConversationRoleTypes.Assistant,
+                            timestamp: new Date().toISOString(),
+                            toolCalls: promptResult.toolCalls || [],
+                        },
+                    });
+                    return; // Exit early after successful fallback
                 }
-                // Emit the final message as a single update (simulating streaming)
-                onEvent({
-                    type: "message_update",
-                    message: {
-                        __typename: "ConversationMessage",
-                        message: promptResult.message,
-                        role: Types.ConversationRoleTypes.Assistant,
-                        timestamp: new Date().toISOString(),
-                        toolCalls: promptResult.toolCalls || [],
-                    },
-                    isStreaming: false,
-                });
-                // Emit completion event
-                onEvent({
-                    type: "conversation_completed",
-                    message: {
-                        __typename: "ConversationMessage",
-                        message: promptResult.message,
-                        role: Types.ConversationRoleTypes.Assistant,
-                        timestamp: new Date().toISOString(),
-                        toolCalls: promptResult.toolCalls || [],
-                    },
+                // Create UI event adapter with model information
+                const modelName = fullSpec ? getModelName(fullSpec) : undefined;
+                const modelEnum = fullSpec ? getModelEnum(fullSpec) : undefined;
+                const serviceType = fullSpec ? getServiceType(fullSpec) : undefined;
+                uiAdapter = new UIEventAdapter(onEvent, actualConversationId, {
+                    smoothingEnabled: options?.smoothingEnabled ?? true,
+                    chunkingStrategy: options?.chunkingStrategy ?? "word",
+                    smoothingDelay: options?.smoothingDelay ?? 30,
+                    model: modelEnum,
+                    modelName: modelName,
+                    modelService: serviceType,
                 });
-                return; // Exit early after successful fallback
-            }
-            // Create UI event adapter with model information
-            const modelName = fullSpec ? getModelName(fullSpec) : undefined;
-            const modelEnum = fullSpec ? getModelEnum(fullSpec) : undefined;
-            const serviceType = fullSpec ? getServiceType(fullSpec) : undefined;
-            uiAdapter = new UIEventAdapter(onEvent, actualConversationId, {
-                smoothingEnabled: options?.smoothingEnabled ?? true,
-                chunkingStrategy: options?.chunkingStrategy ?? "word",
-                smoothingDelay: options?.smoothingDelay ?? 30,
-                model: modelEnum,
-                modelName: modelName,
-                modelService: serviceType,
-            });
-            // Start the streaming conversation
-            await this.executeStreamingAgent(prompt, actualConversationId, fullSpec, tools, toolHandlers, uiAdapter, maxRounds, abortSignal, mimeType, data, correlationId, persona);
+                // Start the streaming conversation
+                await this.executeStreamingAgent(prompt, actualConversationId, fullSpec, tools, toolHandlers, uiAdapter, maxRounds, abortSignal, mimeType, data, correlationId, persona);
+            }, abortSignal);
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : "Streaming failed";
-            if (uiAdapter) {
-                uiAdapter.handleEvent({
-                    type: "error",
-                    error: errorMessage,
-                });
-            }
-            else {
-                // Fallback error event
+            const isAbortError = (error instanceof Error && error.message === "Operation aborted") ||
+                (error instanceof DOMException && error.name === "AbortError");
+            if (isAbortError) {
                 onEvent({
-                    type: "error",
-                    error: {
-                        message: errorMessage,
-                        recoverable: false,
-                    },
+                    type: "conversation_cancelled",
                     conversationId: conversationId || "",
                     timestamp: new Date(),
                 });
             }
+            else {
+                const errorMessage = error instanceof Error ? error.message : "Streaming failed";
+                if (uiAdapter) {
+                    uiAdapter.handleEvent({
+                        type: "error",
+                        error: errorMessage,
+                    });
+                }
+                else {
+                    // Fallback error event
+                    onEvent({
+                        type: "error",
+                        error: {
+                            message: errorMessage,
+                            recoverable: false,
+                        },
+                        conversationId: conversationId || "",
+                        timestamp: new Date(),
+                    });
+                }
+            }
             throw error;
         }
         finally {

package/dist/types/ui-events.d.ts

@@ -35,6 +35,14 @@ export type AgentStreamEvent = {
     conversationId: string;
     timestamp: Date;
     model?: string;
+} | {
+    type: "conversation_queued";
+    conversationId: string;
+    timestamp: Date;
+} | {
+    type: "conversation_cancelled";
+    conversationId: string;
+    timestamp: Date;
 } | ContextWindowEvent | {
     type: "message_update";
     message: StreamingConversationMessage;

package/package.json

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