graphlit-client 1.0.20260626003 → 1.0.20260626005

package/dist/client.js

@@ -8,10 +8,20 @@ import { attachPartialErrors } from "./partial-errors.js";
 import * as Types from "./generated/graphql-types.js";
 import * as Documents from "./generated/graphql-documents.js";
 import { getServiceType, getModelName, getModelEnum, isAnthropicAdaptiveThinkingOnlyModel, isOpenAIResponsesEligibleModel, } from "./model-mapping.js";
+class StreamingLoopPartialError extends Error {
+    originalError;
+    partialResult;
+    constructor(error, partialResult) {
+        super(error instanceof Error ? error.message : String(error));
+        this.name = "StreamingLoopPartialError";
+        this.originalError = error;
+        this.partialResult = partialResult;
+    }
+}
 import { StuckDetector } from "./helpers/stuck-detector.js";
 import { TurnEvaluator } from "./helpers/turn-evaluator.js";
 import { TokenBudgetTracker, truncateToolResult, windowToolRounds, estimateTokens, DEFAULT_CONTEXT_STRATEGY, } from "./helpers/context-management.js";
-import { assertRequiredToolChoiceConfig, deriveProviderToolChoicePolicy, normalizeToolVisibilityResult, toAnthropicToolChoice, toGoogleToolConfig, toOpenAIChatToolChoice, toOpenAIResponsesToolChoice, validateRequiredToolChoice, } from "./helpers/tool-visibility.js";
+import { assertRequiredToolChoiceConfig, deriveProviderToolChoicePolicy, normalizeToolVisibilityResult, RequiredToolChoiceError, toAnthropicToolChoice, toGoogleToolConfig, toOpenAIChatToolChoice, toOpenAIResponsesToolChoice, validateRequiredToolChoice, } from "./helpers/tool-visibility.js";
 import { isRetryableGraphQLTransportError, ProviderError, } from "./types/internal.js";
 import { UIEventAdapter } from "./streaming/ui-event-adapter.js";
 import { formatMessagesForOpenAI, formatMessagesForOpenAIResponsesInitialRound, extractInstructionsForOpenAIResponses, extractSystemInstructionParts, buildResponsesFunctionCallOutputItems, formatToolsForOpenAIResponses, formatMessagesForAnthropic, formatMessagesForGoogle, formatMessagesForMistral, formatMessagesForBedrock, } from "./streaming/llm-formatters.js";
@@ -133,6 +143,15 @@ function normalizeToolCallForExecution(toolCall) {
         firstStatusAt: toolCall.firstStatusAt ?? undefined,
     };
 }
+function cloneOpenAIResponsesInvocationState(state) {
+    if (!state)
+        return undefined;
+    return {
+        instructions: state.instructions,
+        initialInput: [...state.initialInput],
+        continuationItems: [...state.continuationItems],
+    };
+}
 // Default eligible OpenAI GPT-5.4+ models to Responses. Explicit
 // `useResponsesApi: false` still forces legacy Chat Completions.
 const OPENAI_RESPONSES_AUTO_ROUTING_ENABLED = true;
@@ -6357,33 +6376,55 @@ class Graphlit {
                 DEFAULT_CONTEXT_STRATEGY.rebudgetThreshold,
         };
         // Run the streaming loop
-        const loopResult = await this.executeStreamingLoop({
-            conversationId,
-            specification,
-            messages,
-            tools,
-            toolHandlers,
-            uiAdapter,
-            budgetTracker,
-            contextStrategy: mergedStrategy,
-            maxRounds,
-            abortSignal,
-            useResponsesApi,
-            correlationId,
-            persona,
-            mimeType,
-            data,
-            additionalSystemInstructions,
-            fallbackSpecifications,
-            resolveTools,
-            turnNumber: 0,
-            initialToolCallCount: 0,
-            initialPreviousToolCallNames: [],
-        });
+        let loopResult;
+        let loopOriginalError;
+        let loopErrorMessage;
+        try {
+            loopResult = await this.executeStreamingLoop({
+                conversationId,
+                specification,
+                messages,
+                tools,
+                toolHandlers,
+                uiAdapter,
+                budgetTracker,
+                contextStrategy: mergedStrategy,
+                maxRounds,
+                abortSignal,
+                useResponsesApi,
+                correlationId,
+                persona,
+                mimeType,
+                data,
+                additionalSystemInstructions,
+                fallbackSpecifications,
+                resolveTools,
+                turnNumber: 0,
+                initialToolCallCount: 0,
+                initialPreviousToolCallNames: [],
+            });
+        }
+        catch (loopError) {
+            if (loopError instanceof StreamingLoopPartialError) {
+                loopResult = loopError.partialResult;
+                loopOriginalError = loopError.originalError;
+                loopErrorMessage =
+                    loopError.originalError instanceof Error
+                        ? loopError.originalError.message
+                        : String(loopError.originalError);
+            }
+            else {
+                throw loopError;
+            }
+        }
         // Complete the conversation and get token count
         let finalTokens;
         const trimmedMessage = loopResult.finalAssistantMessage;
-        if (trimmedMessage) {
+        const shouldPersistTurn = trimmedMessage ||
+            (loopErrorMessage && loopResult.intermediateMessages.length > 0);
+        if (shouldPersistTurn) {
+            const completionMessage = trimmedMessage ||
+                `Agent run failed after partial tool execution: ${loopErrorMessage ?? "Unknown error"}`;
             // Calculate metrics for completeConversation
             const completionTime = uiAdapter.getCompletionTime();
             const ttft = uiAdapter.getTTFT();
@@ -6402,11 +6443,13 @@ class Graphlit {
                 : undefined;
             const finalInputMessage = finalMessageInputs?.[finalMessageInputs.length - 1];
             const finalMessageAlreadyIncluded = finalInputMessage?.role === Types.ConversationRoleTypes.Assistant &&
-                finalInputMessage.message?.trim() === trimmedMessage;
-            if (loopResult.lastRoundReasoning && !finalMessageAlreadyIncluded) {
+                finalInputMessage.message?.trim() === completionMessage;
+            if (trimmedMessage &&
+                loopResult.lastRoundReasoning &&
+                !finalMessageAlreadyIncluded) {
                 const completionInput = {
                     role: Types.ConversationRoleTypes.Assistant,
-                    message: trimmedMessage,
+                    message: completionMessage,
                     timestamp: new Date().toISOString(),
                     thinkingContent: loopResult.lastRoundReasoning.content,
                 };
@@ -6416,13 +6459,16 @@ class Graphlit {
                 }
                 finalMessageInputs = [...(finalMessageInputs || []), completionInput];
             }
-            const completeResponse = await this.completeConversation(trimmedMessage, conversationId, millisecondsToTimeSpan(completionTime), millisecondsToTimeSpan(ttft), throughput, collectedArtifacts.length > 0 ? collectedArtifacts : undefined, finalMessageInputs, correlationId);
+            const completeResponse = await this.completeConversation(completionMessage, conversationId, millisecondsToTimeSpan(completionTime), millisecondsToTimeSpan(ttft), throughput, collectedArtifacts.length > 0 ? collectedArtifacts : undefined, finalMessageInputs, correlationId);
             finalTokens =
                 completeResponse.completeConversation?.message?.tokens ?? undefined;
             if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                 console.log(`📊 [completeConversation] Tokens used: ${finalTokens || "unknown"}`);
             }
         }
+        if (loopOriginalError) {
+            throw loopOriginalError;
+        }
         if (loopResult.usage) {
             uiAdapter.setUsageData(loopResult.usage);
         }
@@ -6479,6 +6525,59 @@ class Graphlit {
         let openAIResponsesState;
         let openAIResponsesPendingToolMessages = [];
         let visibleToolsForCurrentRound = tools;
+        const buildIntermediateMessageInputs = () => persistedIntermediateMessages.map((msg) => {
+            const input = {
+                role: msg.role,
+                message: msg.message,
+                timestamp: msg.timestamp,
+            };
+            if (msg.toolCallId)
+                input.toolCallId = msg.toolCallId;
+            if (msg.toolCalls) {
+                input.toolCalls = msg.toolCalls
+                    .filter((tc) => tc !== null)
+                    .map((tc) => ({
+                    id: tc.id,
+                    name: tc.name,
+                    arguments: tc.arguments,
+                    startedAt: tc.startedAt,
+                    completedAt: tc.completedAt,
+                    durationMs: tc.durationMs,
+                    status: tc.status,
+                    failedAt: tc.failedAt,
+                    firstStatusAt: tc.firstStatusAt,
+                }));
+            }
+            if (msg.thinkingContent) {
+                input.thinkingContent = msg.thinkingContent;
+                if (msg.thinkingSignature) {
+                    input.thinkingSignature = msg.thinkingSignature;
+                }
+            }
+            return input;
+        });
+        const buildLoopResult = () => ({
+            fullMessage,
+            finalAssistantMessage,
+            toolCallCount: totalToolCallCount,
+            toolCallNames,
+            errors,
+            contextWindow: budgetTracker?.getUsageSnapshot(),
+            contextActions,
+            reasoning: lastRoundReasoning,
+            intermediateMessages: buildIntermediateMessageInputs(),
+            lastRoundReasoning,
+            usedSpecification: specification,
+            usage: (accumulatedUsage.rounds?.length ?? 0) > 0
+                ? accumulatedUsage
+                : undefined,
+        });
+        const throwWithPartialResult = (error) => {
+            if (persistedIntermediateMessages.length > 0) {
+                throw new StreamingLoopPartialError(error, buildLoopResult());
+            }
+            throw error;
+        };
         const selectNextStreamingSpecification = (reason) => {
             for (let candidateIndex = currentSpecificationIndex + 1; candidateIndex < streamingSpecifications.length; candidateIndex++) {
                 const candidate = streamingSpecifications[candidateIndex];
@@ -6588,6 +6687,7 @@ class Graphlit {
                 roundMessage = "";
                 roundReasoning = undefined;
                 roundUsage = undefined;
+                const preAttemptOpenAIResponsesState = cloneOpenAIResponsesInvocationState(openAIResponsesState);
                 try {
                     if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
                         console.log(`\n🔀 [Streaming Decision] Service: ${serviceType}, Round: ${currentRound}${providerAttempt > 0 ? `, Retry: ${providerAttempt}` : ""}`);
@@ -6611,10 +6711,7 @@ class Graphlit {
                             if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING_MESSAGES) {
                                 console.log(`🔍 [OpenAI Responses] Sending ${openAIResponsesState.initialInput.length} initial items and ${openAIResponsesState.continuationItems.length} continuation items`);
                             }
-                            const responsesResult = await this.streamWithOpenAIResponses(specification, messages, openAIResponsesPendingToolMessages, visibleToolsForCurrentRound, uiAdapter, abortSignal, openAIResponsesState, toOpenAIResponsesToolChoice(providerToolChoicePolicy) ??
-                                (currentRound === 0 && visibleToolsForCurrentRound?.length
-                                    ? "required"
-                                    : undefined));
+                            const responsesResult = await this.streamWithOpenAIResponses(specification, messages, openAIResponsesPendingToolMessages, visibleToolsForCurrentRound, uiAdapter, abortSignal, openAIResponsesState, toOpenAIResponsesToolChoice(providerToolChoicePolicy));
                             roundMessage = responsesResult.message;
                             toolCalls = responsesResult.toolCalls;
                             openAIResponsesState = responsesResult.state;
@@ -6891,6 +6988,17 @@ class Graphlit {
                 catch (retryError) {
                     if (abortSignal?.aborted)
                         throw retryError;
+                    if (retryError instanceof RequiredToolChoiceError) {
+                        if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                            console.log(`\n🔁 [Required Tool] ${retryError.message} Re-asking round ${currentRound} with the same visibility policy (attempt ${providerAttempt + 1}/${DEFAULT_PROVIDER_RETRIES + 1}).`);
+                        }
+                        uiAdapter.resetForRetry(preRoundMessage);
+                        openAIResponsesState = cloneOpenAIResponsesInvocationState(preAttemptOpenAIResponsesState);
+                        if (providerAttempt >= DEFAULT_PROVIDER_RETRIES) {
+                            throwWithPartialResult(retryError);
+                        }
+                        continue;
+                    }
                     const isRetryable = retryError instanceof ProviderError && retryError.retryable;
                     if (isRetryable &&
                         providerAttempt >= DEFAULT_PROVIDER_RETRIES &&
@@ -6900,17 +7008,19 @@ class Graphlit {
                         continue;
                     }
                     if (!isRetryable || providerAttempt >= DEFAULT_PROVIDER_RETRIES) {
-                        throw retryError;
+                        throwWithPartialResult(retryError);
                     }
                     // Exponential backoff with jitter
                     const delay = Math.min(PROVIDER_RETRY_BASE_DELAY_MS * Math.pow(2, providerAttempt), PROVIDER_RETRY_MAX_DELAY_MS);
                     const jitter = Math.random() * delay * 0.1;
                     const totalDelay = Math.round(delay + jitter);
+                    const providerError = retryError;
                     if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
-                        console.log(`\n🔄 [Retry] ${retryError.provider} error (attempt ${providerAttempt + 1}/${DEFAULT_PROVIDER_RETRIES}): ${retryError.message}. Retrying in ${totalDelay}ms...`);
+                        console.log(`\n🔄 [Retry] ${providerError.provider} error (attempt ${providerAttempt + 1}/${DEFAULT_PROVIDER_RETRIES}): ${providerError.message}. Retrying in ${totalDelay}ms...`);
                     }
                     // Reset adapter to pre-round state so partial tokens are cleared
                     uiAdapter.resetForRetry(preRoundMessage);
+                    openAIResponsesState = cloneOpenAIResponsesInvocationState(preAttemptOpenAIResponsesState);
                     await new Promise((resolve) => setTimeout(resolve, totalDelay));
                 }
             } // end retry for-loop
@@ -7297,55 +7407,7 @@ class Graphlit {
             }
             currentRound++;
         }
-        // Build intermediate messages for completeConversation
-        const intermediateMessages = persistedIntermediateMessages;
-        const messageInputs = intermediateMessages.map((msg, idx) => {
-            const input = {
-                role: msg.role,
-                message: msg.message,
-                timestamp: msg.timestamp,
-            };
-            if (msg.toolCallId)
-                input.toolCallId = msg.toolCallId;
-            if (msg.toolCalls) {
-                input.toolCalls = msg.toolCalls
-                    .filter((tc) => tc !== null)
-                    .map((tc) => ({
-                    id: tc.id,
-                    name: tc.name,
-                    arguments: tc.arguments,
-                    startedAt: tc.startedAt,
-                    completedAt: tc.completedAt,
-                    durationMs: tc.durationMs,
-                    status: tc.status,
-                    failedAt: tc.failedAt,
-                    firstStatusAt: tc.firstStatusAt,
-                }));
-            }
-            if (msg.thinkingContent) {
-                input.thinkingContent = msg.thinkingContent;
-                if (msg.thinkingSignature) {
-                    input.thinkingSignature = msg.thinkingSignature;
-                }
-            }
-            return input;
-        });
-        return {
-            fullMessage,
-            finalAssistantMessage,
-            toolCallCount: totalToolCallCount,
-            toolCallNames,
-            errors,
-            contextWindow: budgetTracker?.getUsageSnapshot(),
-            contextActions,
-            reasoning: lastRoundReasoning,
-            intermediateMessages: messageInputs,
-            lastRoundReasoning,
-            usedSpecification: specification,
-            usage: (accumulatedUsage.rounds?.length ?? 0) > 0
-                ? accumulatedUsage
-                : undefined,
-        };
+        return buildLoopResult();
     }
     // ────────────────────────────────────────────────────────────────────────────
     // runAgent — multi-turn agent harness
@@ -7770,6 +7832,7 @@ class Graphlit {
                 // 7. Execute streaming loop for this turn
                 const turnStart = Date.now();
                 let loopResult;
+                let loopErrorMessage;
                 try {
                     loopResult = await this.executeStreamingLoop({
                         conversationId,
@@ -7793,6 +7856,18 @@ class Graphlit {
                         initialPreviousToolCallNames: turnResults.flatMap((t) => t.toolCalls),
                     });
                 }
+                catch (loopError) {
+                    if (loopError instanceof StreamingLoopPartialError) {
+                        loopResult = loopError.partialResult;
+                        loopErrorMessage =
+                            loopError.originalError instanceof Error
+                                ? loopError.originalError.message
+                                : String(loopError.originalError);
+                    }
+                    else {
+                        throw loopError;
+                    }
+                }
                 finally {
                     uiAdapter.dispose();
                 }
@@ -7805,8 +7880,12 @@ class Graphlit {
                 const taskCompleteThisTurn = this.detectTaskCompleteInMessages(loopResult.intermediateMessages);
                 const terminalTextThisTurn = this.detectTerminalTextCompletion(loopResult, options?.completionMode);
                 const trimmedMessage = loopResult.finalAssistantMessage;
+                const shouldPersistTurn = trimmedMessage ||
+                    (loopErrorMessage && loopResult.intermediateMessages.length > 0);
                 // 8b. Complete conversation (persist turn)
-                if (trimmedMessage) {
+                if (shouldPersistTurn) {
+                    const completionMessage = trimmedMessage ||
+                        `Agent run failed after partial tool execution: ${loopErrorMessage ?? "Unknown error"}`;
                     const completionTime = uiAdapter.getCompletionTime();
                     const ttft = uiAdapter.getTTFT();
                     const throughput = uiAdapter.getThroughput();
@@ -7830,11 +7909,13 @@ class Graphlit {
                     }
                     const finalInputMessage = turnMessageInputs?.[turnMessageInputs.length - 1];
                     const finalMessageAlreadyIncluded = finalInputMessage?.role === Types.ConversationRoleTypes.Assistant &&
-                        finalInputMessage.message?.trim() === trimmedMessage;
-                    if (loopResult.lastRoundReasoning && !finalMessageAlreadyIncluded) {
+                        finalInputMessage.message?.trim() === completionMessage;
+                    if (trimmedMessage &&
+                        loopResult.lastRoundReasoning &&
+                        !finalMessageAlreadyIncluded) {
                         const completionInput = {
                             role: Types.ConversationRoleTypes.Assistant,
-                            message: trimmedMessage,
+                            message: completionMessage,
                             timestamp: new Date().toISOString(),
                             thinkingContent: loopResult.lastRoundReasoning.content,
                         };
@@ -7844,7 +7925,7 @@ class Graphlit {
                         }
                         turnMessageInputs = [...(turnMessageInputs || []), completionInput];
                     }
-                    await this.completeConversation(trimmedMessage, conversationId, millisecondsToTimeSpan(completionTime), millisecondsToTimeSpan(ttft), throughput, undefined, turnMessageInputs, options?.correlationId);
+                    await this.completeConversation(completionMessage, conversationId, millisecondsToTimeSpan(completionTime), millisecondsToTimeSpan(ttft), throughput, undefined, turnMessageInputs, options?.correlationId);
                     // Emit completion event
                     uiAdapter.handleEvent({
                         type: "complete",
@@ -7854,6 +7935,10 @@ class Graphlit {
                 // 9. Build TurnResult
                 const turnDuration = Date.now() - turnStart;
                 const turnToolNames = [...new Set(loopResult.toolCallNames)].sort();
+                const turnErrors = [
+                    ...loopResult.errors,
+                    ...(loopErrorMessage ? [loopErrorMessage] : []),
+                ];
                 const turnResult = {
                     turnNumber: turn,
                     prompt: currentPrompt,
@@ -7871,7 +7956,7 @@ class Graphlit {
                     contextActions: loopResult.contextActions.length > 0
                         ? loopResult.contextActions
                         : undefined,
-                    errors: loopResult.errors.length > 0 ? loopResult.errors : undefined,
+                    errors: turnErrors.length > 0 ? turnErrors : undefined,
                     usage: lastTurnUsage,
                 };
                 // Reset per-turn usage for next turn
@@ -7884,6 +7969,11 @@ class Graphlit {
                 // 10. Notify callback
                 options?.onTurnComplete?.(turnResult);
                 // 11. Evaluate turn
+                if (loopErrorMessage) {
+                    status = "error";
+                    errorMessage = loopErrorMessage;
+                    break;
+                }
                 // a. Terminal completion reached?
                 if (turnResult.completionReason) {
                     status = "completed";

package/dist/streaming/providers.js

@@ -545,7 +545,12 @@ onEvent, onComplete, abortSignal, thinkingConfig, toolChoice) {
                 ...streamConfig.tools[streamConfig.tools.length - 1],
                 cache_control: { type: "ephemeral" },
             };
-            if (toolChoice) {
+            if (toolChoice && thinkingConfig) {
+                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                    console.log("🧠 [Anthropic] Skipping native tool_choice because thinking is enabled; required tool policy will be validated after the response.");
+                }
+            }
+            else if (toolChoice) {
                 streamConfig.tool_choice = toolChoice;
             }
         }

package/package.json

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