graphlit-client 1.0.20260420001 → 1.0.20260420002

package/dist/client.d.ts

@@ -3096,6 +3096,11 @@ declare class Graphlit {
      * Tool calls on assistant messages are extracted for stuck-pattern tracking.
      */
     private reconstructTurnResults;
+    /**
+     * Detect whether one tool call is a task_complete invocation, either
+     * directly or through a meta-executor such as execute_tool.
+     */
+    private isTaskCompleteToolCall;
     /**
      * Detect whether task_complete was invoked in a single list of tool calls.
      *
@@ -3119,32 +3124,6 @@ declare class Graphlit {
      * with `intermediateMessages` rather than a single tool-call list.
      */
     private detectTaskCompleteInMessages;
-    /**
-     * Extract the `final_message` argument from a task_complete invocation
-     * within a list of tool calls. Handles both direct invocation and
-     * meta-executor wrapping (mirrors `detectTaskComplete`).
-     *
-     * Returns undefined if task_complete was not called, the arg is missing,
-     * or the arg is not a non-empty string.
-     */
-    private extractTaskCompleteFinalMessage;
-    /**
-     * Scan a list of messages for a task_complete invocation's `final_message`
-     * arg. Convenience wrapper over `extractTaskCompleteFinalMessage`.
-     */
-    private extractTaskCompleteFinalMessageFromMessages;
-    /**
-     * Sanitize task_complete's `final_message` payload out of persisted
-     * intermediate messages. The tool call record (name, id, timing, ordering)
-     * is preserved as a completion marker, but its `final_message` arg is
-     * stripped because that content is already stored as the turn's assistant
-     * text via `completion`. Keeping the tool call without the payload yields
-     * the same storage win as full removal while preserving the trace.
-     *
-     * Handles both direct and meta-executor (`execute_tool({tool: ...})`)
-     * invocations, matching `detectTaskComplete`.
-     */
-    private sanitizeTaskCompletePayload;
     /**
      * Run LLM-as-judge quality assessment on a completed agent run.
      */

package/dist/client.js

@@ -3059,7 +3059,11 @@ class Graphlit {
      * @returns The result of the deletion.
      */
     async deleteAllSkills(filter, isSynchronous, correlationId) {
-        return this.mutateAndCheckError(Documents.DeleteAllSkills, { filter: filter, isSynchronous: isSynchronous, correlationId: correlationId });
+        return this.mutateAndCheckError(Documents.DeleteAllSkills, {
+            filter: filter,
+            isSynchronous: isSynchronous,
+            correlationId: correlationId,
+        });
     }
     /**
      * Enables a skill.
@@ -3111,7 +3115,10 @@ class Graphlit {
      * @returns The updated collections.
      */
     async addSkillsToCollections(skills, collections) {
-        return this.mutateAndCheckError(Documents.AddSkillsToCollections, { skills: skills, collections: collections });
+        return this.mutateAndCheckError(Documents.AddSkillsToCollections, {
+            skills: skills,
+            collections: collections,
+        });
     }
     /**
      * Removes skills from a collection.
@@ -3120,7 +3127,10 @@ class Graphlit {
      * @returns The updated collection.
      */
     async removeSkillsFromCollection(skills, collection) {
-        return this.mutateAndCheckError(Documents.RemoveSkillsFromCollection, { skills: skills, collection: collection });
+        return this.mutateAndCheckError(Documents.RemoveSkillsFromCollection, {
+            skills: skills,
+            collection: collection,
+        });
     }
     /**
      * Prompts multiple specifications and returns the best response.
@@ -5730,7 +5740,8 @@ class Graphlit {
                         });
                     }
                     // Emit tool events if there were tool calls
-                    if (promptResult.toolResults && promptResult.toolResults.length > 0) {
+                    if (promptResult.toolResults &&
+                        promptResult.toolResults.length > 0) {
                         for (const toolResult of promptResult.toolResults) {
                             const toolCall = buildConversationToolCallFromResult(toolResult);
                             onEvent({
@@ -6039,10 +6050,7 @@ class Graphlit {
                     completionInput.thinkingSignature =
                         loopResult.lastRoundReasoning.signature;
                 }
-                finalMessageInputs = [
-                    ...(finalMessageInputs || []),
-                    completionInput,
-                ];
+                finalMessageInputs = [...(finalMessageInputs || []), completionInput];
             }
             const completeResponse = await this.completeConversation(trimmedMessage, conversationId, millisecondsToTimeSpan(completionTime), millisecondsToTimeSpan(ttft), throughput, collectedArtifacts.length > 0 ? collectedArtifacts : undefined, finalMessageInputs, correlationId);
             finalTokens =
@@ -6063,7 +6071,7 @@ class Graphlit {
      * Shared between streamAgent (single turn) and runAgent (multi-turn harness).
      */
     async executeStreamingLoop(config) {
-        const { conversationId, specification, tools, toolHandlers, uiAdapter, budgetTracker, contextStrategy: { toolResultTokenLimit, toolRoundLimit, rebudgetThreshold }, maxRounds, abortSignal, useResponsesApi, mimeType, data, correlationId, persona, } = config;
+        const { conversationId, specification, tools, toolHandlers, uiAdapter, budgetTracker, contextStrategy: { toolResultTokenLimit, toolRoundLimit, rebudgetThreshold, }, maxRounds, abortSignal, useResponsesApi, mimeType, data, correlationId, persona, } = config;
         let messages = config.messages;
         let currentRound = 0;
         let fullMessage = "";
@@ -6176,7 +6184,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, tools, uiAdapter, abortSignal, openAIResponsesState, (currentRound === 0 && tools?.length) ? "required" : undefined);
+                            const responsesResult = await this.streamWithOpenAIResponses(specification, messages, openAIResponsesPendingToolMessages, tools, uiAdapter, abortSignal, openAIResponsesState, currentRound === 0 && tools?.length ? "required" : undefined);
                             roundMessage = responsesResult.message;
                             toolCalls = responsesResult.toolCalls;
                             openAIResponsesState = responsesResult.state;
@@ -6314,7 +6322,10 @@ class Graphlit {
                         }
                         const mistralMessages = formatMessagesForMistral(messages);
                         // ALWAYS log when there's a tool-related issue for debugging
-                        const hasToolCalls = mistralMessages.some((m) => "tool_calls" in m && Array.isArray(m.tool_calls) && m.tool_calls.length > 0);
+                        const hasToolCalls = mistralMessages.some((m) => "tool_calls" in m &&
+                            Array.isArray(m.tool_calls) &&
+                            m
+                                .tool_calls.length > 0);
                         const hasToolResponses = mistralMessages.some((m) => m.role === "tool");
                         // Count tool responses to determine if we should pass tools
                         const toolResponseCount = mistralMessages.filter((m) => m.role === "tool").length;
@@ -6325,7 +6336,8 @@ class Graphlit {
                             console.log(JSON.stringify(mistralMessages, null, 2));
                             // Count tool calls and responses
                             const toolCallCount = mistralMessages.reduce((count, m) => {
-                                const calls = m.tool_calls;
+                                const calls = m
+                                    .tool_calls;
                                 return count + (Array.isArray(calls) ? calls.length : 0);
                             }, 0);
                             console.log(`🔍 [Mistral] Tool calls: ${toolCallCount}, Tool responses: ${toolResponseCount}`);
@@ -6432,13 +6444,11 @@ class Graphlit {
                     if (abortSignal?.aborted)
                         throw retryError;
                     const isRetryable = retryError instanceof ProviderError && retryError.retryable;
-                    if (!isRetryable ||
-                        providerAttempt >= DEFAULT_PROVIDER_RETRIES) {
+                    if (!isRetryable || providerAttempt >= DEFAULT_PROVIDER_RETRIES) {
                         throw retryError;
                     }
                     // Exponential backoff with jitter
-                    const delay = Math.min(PROVIDER_RETRY_BASE_DELAY_MS *
-                        Math.pow(2, providerAttempt), PROVIDER_RETRY_MAX_DELAY_MS);
+                    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);
                     if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
@@ -6467,42 +6477,61 @@ class Graphlit {
             if (!toolCalls || toolCalls.length === 0) {
                 break;
             }
-            // Execute tools and prepare for next round
-            if (toolHandlers && toolCalls.length > 0) {
-                if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
-                    console.log(`\n🔧 [executeStreamingLoop] Round ${currentRound}: Processing ${toolCalls.length} tool calls`);
-                    toolCalls.forEach((tc, idx) => {
-                        console.log(`  ${idx + 1}. ${tc.name} (${tc.id}) - Args length: ${tc.arguments.length}`);
-                    });
+            if (process.env.DEBUG_GRAPHLIT_SDK_STREAMING) {
+                console.log(`\n🔧 [executeStreamingLoop] Round ${currentRound}: Processing ${toolCalls.length} tool calls`);
+                toolCalls.forEach((tc, idx) => {
+                    console.log(`  ${idx + 1}. ${tc.name} (${tc.id}) - Args length: ${tc.arguments.length}`);
+                });
+            }
+            // Add assistant message with tool calls to conversation. This is done
+            // before terminal task_complete detection so the outer runAgent loop can
+            // still observe the completion signal in intermediateMessages.
+            const roundToolCalls = toolCalls.map(normalizeToolCallForExecution);
+            const assistantMessage = {
+                __typename: "ConversationMessage",
+                role: Types.ConversationRoleTypes.Assistant,
+                message: roundMessage,
+                toolCalls: roundToolCalls,
+                timestamp: new Date().toISOString(),
+            };
+            if (roundReasoning) {
+                assistantMessage.thinkingContent = roundReasoning.content;
+                if (roundReasoning.signature) {
+                    assistantMessage.thinkingSignature = roundReasoning.signature;
                 }
-                // Add assistant message with tool calls to conversation
-                const roundToolCalls = toolCalls.map(normalizeToolCallForExecution);
-                const assistantMessage = {
-                    __typename: "ConversationMessage",
-                    role: Types.ConversationRoleTypes.Assistant,
-                    message: roundMessage,
-                    toolCalls: roundToolCalls,
-                    timestamp: new Date().toISOString(),
-                };
-                if (roundReasoning) {
-                    assistantMessage.thinkingContent = roundReasoning.content;
-                    if (roundReasoning.signature) {
-                        assistantMessage.thinkingSignature = roundReasoning.signature;
+                reasoningByMessageIndex.set(messages.length, roundReasoning);
+            }
+            messages.push(assistantMessage);
+            // Track tool names for stuck detection
+            for (const tc of roundToolCalls) {
+                toolCallNames.push(tc.name);
+            }
+            totalToolCallCount += roundToolCalls.length;
+            // Track assistant message in budget
+            if (budgetTracker) {
+                const assistantTokens = estimateTokens(roundMessage) +
+                    roundToolCalls.reduce((sum, tc) => sum + estimateTokens(tc.arguments), 0);
+                budgetTracker.addMessage("", assistantTokens);
+            }
+            // task_complete is terminal. Do not invoke its handler and feed an ack
+            // back to the model; that extra round can produce trailing filler which
+            // overwrites finalAssistantMessage.
+            if (this.detectTaskComplete(roundToolCalls)) {
+                const terminalAt = nowIsoString();
+                for (const toolCall of roundToolCalls) {
+                    if (this.isTaskCompleteToolCall(toolCall)) {
+                        toolCall.startedAt = toolCall.startedAt ?? terminalAt;
+                        toolCall.completedAt = toolCall.completedAt ?? terminalAt;
+                        toolCall.durationMs = toolCall.durationMs ?? 0;
+                        toolCall.firstStatusAt =
+                            toolCall.firstStatusAt ?? toolCall.startedAt;
+                        toolCall.status = Types.ToolExecutionStatus.Completed;
                     }
-                    reasoningByMessageIndex.set(messages.length, roundReasoning);
-                }
-                messages.push(assistantMessage);
-                // Track tool names for stuck detection
-                for (const tc of roundToolCalls) {
-                    toolCallNames.push(tc.name);
-                }
-                totalToolCallCount += roundToolCalls.length;
-                // Track assistant message in budget
-                if (budgetTracker) {
-                    const assistantTokens = estimateTokens(roundMessage) +
-                        roundToolCalls.reduce((sum, tc) => sum + estimateTokens(tc.arguments), 0);
-                    budgetTracker.addMessage("", assistantTokens);
                 }
+                break;
+            }
+            // Execute tools and prepare for next round
+            if (toolHandlers) {
                 const toolExecutionResults = new Array(roundToolCalls.length);
                 const executeStreamingToolCall = async (toolCall, index) => {
                     if (abortSignal?.aborted) {
@@ -6516,7 +6545,8 @@ class Graphlit {
                         toolCall.completedAt = terminalAt;
                         toolCall.durationMs = 0;
                         toolCall.failedAt = terminalAt;
-                        toolCall.firstStatusAt = toolCall.firstStatusAt ?? toolCall.startedAt;
+                        toolCall.firstStatusAt =
+                            toolCall.firstStatusAt ?? toolCall.startedAt;
                         toolCall.status = Types.ToolExecutionStatus.Failed;
                         uiAdapter.handleEvent({
                             type: "tool_call_complete",
@@ -6611,7 +6641,8 @@ class Graphlit {
                                 toolCall.completedAt = terminalAt;
                                 toolCall.durationMs = 0;
                                 toolCall.failedAt = terminalAt;
-                                toolCall.firstStatusAt = toolCall.firstStatusAt ?? toolCall.startedAt;
+                                toolCall.firstStatusAt =
+                                    toolCall.firstStatusAt ?? toolCall.startedAt;
                                 toolCall.status = Types.ToolExecutionStatus.Failed;
                                 uiAdapter.handleEvent({
                                     type: "tool_call_complete",
@@ -6647,7 +6678,8 @@ class Graphlit {
                         const executionStartMs = Date.now();
                         const executionStartedAt = new Date(executionStartMs).toISOString();
                         toolCall.startedAt = executionStartedAt;
-                        toolCall.firstStatusAt = toolCall.firstStatusAt ?? executionStartedAt;
+                        toolCall.firstStatusAt =
+                            toolCall.firstStatusAt ?? executionStartedAt;
                         uiAdapter.handleEvent({
                             type: "tool_call_executing",
                             toolCall: {
@@ -6717,7 +6749,8 @@ class Graphlit {
                         toolCall.durationMs = Math.max(0, new Date(completedAt).getTime() -
                             new Date(toolCall.startedAt).getTime());
                         toolCall.failedAt = completedAt;
-                        toolCall.firstStatusAt = toolCall.firstStatusAt ?? toolCall.startedAt;
+                        toolCall.firstStatusAt =
+                            toolCall.firstStatusAt ?? toolCall.startedAt;
                         toolCall.status = Types.ToolExecutionStatus.Failed;
                         uiAdapter.handleEvent({
                             type: "tool_call_complete",
@@ -6891,7 +6924,7 @@ class Graphlit {
         let lastTurnUsage;
         // Wrap onEvent to capture per-turn usage from conversation_completed events
         const wrappedOnEvent = (event) => {
-            if (event.type === 'conversation_completed' && event.usage) {
+            if (event.type === "conversation_completed" && event.usage) {
                 const u = event.usage;
                 lastTurnUsage = {
                     promptTokens: u.promptTokens || 0,
@@ -6960,7 +6993,8 @@ class Graphlit {
             }
             // Get full specification for streaming support check and complexity classification
             const fullSpec = agentSpec?.id
-                ? (await this.getSpecification(agentSpec.id)).specification
+                ? (await this.getSpecification(agentSpec.id))
+                    .specification
                 : undefined;
             // Initialize evaluator and stuck detector
             const evaluator = new TurnEvaluator({
@@ -6973,40 +7007,36 @@ class Graphlit {
             const stuckDetector = new StuckDetector();
             // Adaptive budget: classify task complexity via LLM
             if (fullSpec) {
-                const { multiplier } = await evaluator.classifyComplexity(prompt, (classPrompt, text, classTools) => this.extractText(classPrompt, text, classTools, undefined, undefined, options?.correlationId)
-                    .then((r) => r.extractText));
+                const { multiplier } = await evaluator.classifyComplexity(prompt, (classPrompt, text, classTools) => this.extractText(classPrompt, text, classTools, undefined, undefined, options?.correlationId).then((r) => r.extractText));
                 if (multiplier > 1.0) {
                     evaluator.adjustBudget(multiplier);
                 }
             }
             // Build tools list with task_complete prepended.
             //
-            // task_complete's optional `final_message` parameter is the explicit
-            // commitment of the agent's user-facing answer. When provided, it
-            // becomes the persisted assistant message for that turn AND the run's
-            // `finalMessage`, overriding any prose the model wrote around the call.
+            // task_complete is a bare completion signal — it takes no arguments.
+            // The agent's user-facing answer MUST be in its final assistant message
+            // (the `fullMessage` / `finalAssistantMessage` on the turn result); this
+            // tool only marks the run as done.
             //
-            // An earlier version used a `summary` field. The name encouraged
-            // truncated summarization — the model would stuff a short summary into
-            // the arg and emit useless prose like "answer delivered above". The
-            // field name `final_message` and description below are explicit: this
-            // IS the full answer, not a summary, and it replaces surrounding prose.
+            // The streaming loop treats task_complete as TERMINAL: when a round's
+            // tool calls include task_complete, the loop breaks immediately without
+            // invoking the handler or starting another round. That prevents the
+            // model from emitting trailing filler ("delivered above", "see the
+            // response") after the tool-call ack, which would otherwise overwrite
+            // the real answer in `finalAssistantMessage`.
             //
-            // If the model omits `final_message`, the SDK falls back to the last
-            // turn whose assistant text was substantive AND did not itself call
-            // task_complete — so a throwaway completion turn can't overwrite the
-            // real answer in a prior turn.
+            // Earlier versions had a `summary` field. That consistently caused the
+            // model to stuff its answer into the tool argument and then write a
+            // useless prose message ("answer delivered above") — the user would see
+            // the empty prose, not the answer. Removing the field eliminates the
+            // hiding place.
             const taskCompleteTool = {
                 name: "task_complete",
-                description: "Signal that you have completed the assigned task. Provide your complete, final user-facing answer as `final_message` — full prose, not a summary. That string becomes the assistant message the user sees; do not also emit the answer as plain text around this call. Calling this tool ends the run.",
+                description: "Signal that you have completed the assigned task. Your full answer must already be in your assistant message BEFORE calling this — that prose is what the user sees. This tool takes no arguments; it only ends the run.",
                 schema: JSON.stringify({
                     type: "object",
-                    properties: {
-                        final_message: {
-                            type: "string",
-                            description: "Your complete, final answer to the user as full prose. Replaces any assistant text written around this tool call.",
-                        },
-                    },
+                    properties: {},
                 }),
             };
             const allTools = [
@@ -7172,8 +7202,7 @@ class Graphlit {
                                     messageToAdd.toolCallResponse =
                                         historyMessage.toolCallResponse;
                                 if (historyMessage.thinkingContent)
-                                    messageToAdd.thinkingContent =
-                                        historyMessage.thinkingContent;
+                                    messageToAdd.thinkingContent = historyMessage.thinkingContent;
                                 if (historyMessage.thinkingSignature)
                                     messageToAdd.thinkingSignature =
                                         historyMessage.thinkingSignature;
@@ -7264,39 +7293,13 @@ class Graphlit {
                 finally {
                     uiAdapter.dispose();
                 }
-                // 8. Detect task_complete and extract its optional `final_message`
-                // arg BEFORE persistence. When provided, it replaces the turn's
-                // assistant prose as the canonical answer — see the task_complete
-                // tool schema above.
+                // 8. Detect task_complete before persistence. The streaming loop
+                // records the terminal assistant/tool-call round, but does not execute
+                // the completion handler or start a follow-up filler round.
                 const taskCompleteThisTurn = this.detectTaskCompleteInMessages(loopResult.intermediateMessages);
-                const taskCompleteFinalMessage = taskCompleteThisTurn
-                    ? this.extractTaskCompleteFinalMessageFromMessages(loopResult.intermediateMessages)
-                    : undefined;
-                // Resolve the assistant message to persist for this turn:
-                //   - task_complete({final_message}) → final_message (authoritative)
-                //   - task_complete() with no arg, prior substantive answer exists →
-                //     drop the turn's prose so throwaway text like "delivered above"
-                //     doesn't pollute chat history
-                //   - task_complete() with no arg, no prior answer → keep the prose
-                //     (single-shot completion case)
-                //   - normal turn → keep the prose
-                let assistantMessageToPersist;
-                if (taskCompleteThisTurn) {
-                    if (taskCompleteFinalMessage) {
-                        assistantMessageToPersist = taskCompleteFinalMessage;
-                    }
-                    else if (finalMessage) {
-                        assistantMessageToPersist = "";
-                    }
-                    else {
-                        assistantMessageToPersist = loopResult.finalAssistantMessage;
-                    }
-                }
-                else {
-                    assistantMessageToPersist = loopResult.finalAssistantMessage;
-                }
+                const trimmedMessage = loopResult.finalAssistantMessage;
                 // 8b. Complete conversation (persist turn)
-                if (assistantMessageToPersist) {
+                if (trimmedMessage) {
                     const completionTime = uiAdapter.getCompletionTime();
                     const ttft = uiAdapter.getTTFT();
                     const throughput = uiAdapter.getThroughput();
@@ -7305,20 +7308,13 @@ class Graphlit {
                             return undefined;
                         return `PT${ms / 1000}S`;
                     };
-                    // Sanitize task_complete's final_message arg before persistence —
-                    // the content is already saved as the turn's assistant text, so
-                    // keeping it in the tool-call arguments would double-store it.
-                    // The tool call record itself stays as a completion marker.
-                    const sanitizedIntermediates = taskCompleteThisTurn
-                        ? this.sanitizeTaskCompletePayload(loopResult.intermediateMessages)
-                        : loopResult.intermediateMessages;
-                    let turnMessageInputs = sanitizedIntermediates.length > 0
-                        ? sanitizedIntermediates
+                    let turnMessageInputs = loopResult.intermediateMessages.length > 0
+                        ? loopResult.intermediateMessages
                         : undefined;
                     if (loopResult.lastRoundReasoning) {
                         const completionInput = {
                             role: Types.ConversationRoleTypes.Assistant,
-                            message: assistantMessageToPersist,
+                            message: trimmedMessage,
                             timestamp: new Date().toISOString(),
                             thinkingContent: loopResult.lastRoundReasoning.content,
                         };
@@ -7326,12 +7322,9 @@ class Graphlit {
                             completionInput.thinkingSignature =
                                 loopResult.lastRoundReasoning.signature;
                         }
-                        turnMessageInputs = [
-                            ...(turnMessageInputs || []),
-                            completionInput,
-                        ];
+                        turnMessageInputs = [...(turnMessageInputs || []), completionInput];
                     }
-                    await this.completeConversation(assistantMessageToPersist, conversationId, millisecondsToTimeSpan(completionTime), millisecondsToTimeSpan(ttft), throughput, undefined, turnMessageInputs, options?.correlationId);
+                    await this.completeConversation(trimmedMessage, conversationId, millisecondsToTimeSpan(completionTime), millisecondsToTimeSpan(ttft), throughput, undefined, turnMessageInputs, options?.correlationId);
                     // Emit completion event
                     uiAdapter.handleEvent({
                         type: "complete",
@@ -7344,7 +7337,7 @@ class Graphlit {
                 const turnResult = {
                     turnNumber: turn,
                     prompt: currentPrompt,
-                    responseText: taskCompleteFinalMessage || loopResult.fullMessage,
+                    responseText: loopResult.fullMessage,
                     toolCalls: turnToolNames,
                     toolCallCount: loopResult.toolCallCount,
                     durationMs: turnDuration,
@@ -7360,25 +7353,8 @@ class Graphlit {
                 lastTurnUsage = undefined;
                 turnResults.push(turnResult);
                 totalToolCalls += loopResult.toolCallCount;
-                // Update finalMessage with priority:
-                //   - task_complete({final_message}) → authoritative
-                //   - task_complete() without arg → keep prior finalMessage (avoids
-                //     throwaway completion-turn prose overwriting a real answer)
-                //   - normal turn → this turn's assistant text
-                if (taskCompleteThisTurn) {
-                    if (taskCompleteFinalMessage) {
-                        finalMessage = taskCompleteFinalMessage;
-                    }
-                    else if (!finalMessage) {
-                        // No prior answer — this turn's prose is all we have
-                        finalMessage =
-                            loopResult.finalAssistantMessage || loopResult.fullMessage;
-                    }
-                }
-                else {
-                    finalMessage =
-                        loopResult.finalAssistantMessage || loopResult.fullMessage;
-                }
+                finalMessage =
+                    loopResult.finalAssistantMessage || loopResult.fullMessage;
                 lastContextWindow = loopResult.contextWindow;
                 // 10. Notify callback
                 options?.onTurnComplete?.(turnResult);
@@ -7463,8 +7439,7 @@ class Graphlit {
             }
             else {
                 status = "error";
-                errorMessage =
-                    error instanceof Error ? error.message : "Unknown error";
+                errorMessage = error instanceof Error ? error.message : "Unknown error";
             }
             return this.buildRunAgentResult({
                 agentId: resolvedAgentId,
@@ -7577,6 +7552,28 @@ class Graphlit {
         }
         return results;
     }
+    /**
+     * Detect whether one tool call is a task_complete invocation, either
+     * directly or through a meta-executor such as execute_tool.
+     */
+    isTaskCompleteToolCall(toolCall) {
+        if (!toolCall)
+            return false;
+        // Direct invocation
+        if (toolCall.name === "task_complete")
+            return true;
+        // Meta-executor wrapping (e.g. execute_tool({ tool: "task_complete", parameters: {...} }))
+        if (toolCall.arguments) {
+            try {
+                const args = JSON.parse(toolCall.arguments);
+                return args.tool === "task_complete";
+            }
+            catch {
+                // Not JSON — skip
+            }
+        }
+        return false;
+    }
     /**
      * Detect whether task_complete was invoked in a single list of tool calls.
      *
@@ -7597,22 +7594,8 @@ class Graphlit {
         if (!toolCalls)
             return false;
         for (const tc of toolCalls) {
-            if (!tc)
-                continue;
-            // Direct invocation
-            if (tc.name === "task_complete")
+            if (this.isTaskCompleteToolCall(tc))
                 return true;
-            // Meta-executor wrapping (e.g. execute_tool({ tool: "task_complete", parameters: {...} }))
-            if (tc.arguments) {
-                try {
-                    const args = JSON.parse(tc.arguments);
-                    if (args.tool === "task_complete")
-                        return true;
-                }
-                catch {
-                    // Not JSON — skip
-                }
-            }
         }
         return false;
     }
@@ -7628,107 +7611,6 @@ class Graphlit {
         }
         return false;
     }
-    /**
-     * Extract the `final_message` argument from a task_complete invocation
-     * within a list of tool calls. Handles both direct invocation and
-     * meta-executor wrapping (mirrors `detectTaskComplete`).
-     *
-     * Returns undefined if task_complete was not called, the arg is missing,
-     * or the arg is not a non-empty string.
-     */
-    extractTaskCompleteFinalMessage(toolCalls) {
-        if (!toolCalls)
-            return undefined;
-        for (const tc of toolCalls) {
-            if (!tc?.arguments)
-                continue;
-            let args;
-            try {
-                args = JSON.parse(tc.arguments);
-            }
-            catch {
-                continue;
-            }
-            // Direct invocation: args ARE the task_complete params
-            if (tc.name === "task_complete") {
-                const fm = args.final_message;
-                if (typeof fm === "string" && fm.trim().length > 0)
-                    return fm;
-                continue;
-            }
-            // Meta-executor wrapping: { tool: "task_complete", parameters: {...} }
-            if (args.tool === "task_complete") {
-                const params = args.parameters;
-                const fm = params?.final_message;
-                if (typeof fm === "string" && fm.trim().length > 0)
-                    return fm;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Scan a list of messages for a task_complete invocation's `final_message`
-     * arg. Convenience wrapper over `extractTaskCompleteFinalMessage`.
-     */
-    extractTaskCompleteFinalMessageFromMessages(messages) {
-        for (const msg of messages) {
-            const fm = this.extractTaskCompleteFinalMessage(msg.toolCalls);
-            if (fm)
-                return fm;
-        }
-        return undefined;
-    }
-    /**
-     * Sanitize task_complete's `final_message` payload out of persisted
-     * intermediate messages. The tool call record (name, id, timing, ordering)
-     * is preserved as a completion marker, but its `final_message` arg is
-     * stripped because that content is already stored as the turn's assistant
-     * text via `completion`. Keeping the tool call without the payload yields
-     * the same storage win as full removal while preserving the trace.
-     *
-     * Handles both direct and meta-executor (`execute_tool({tool: ...})`)
-     * invocations, matching `detectTaskComplete`.
-     */
-    sanitizeTaskCompletePayload(messages) {
-        return messages.map((msg) => {
-            if (!msg.toolCalls || msg.toolCalls.length === 0)
-                return msg;
-            let mutated = false;
-            const sanitizedToolCalls = msg.toolCalls.map((tc) => {
-                if (!tc || !tc.arguments)
-                    return tc;
-                let args;
-                try {
-                    args = JSON.parse(tc.arguments);
-                }
-                catch {
-                    return tc;
-                }
-                // Direct invocation: args ARE the task_complete params
-                if (tc.name === "task_complete" && "final_message" in args) {
-                    const { final_message: _dropped, ...rest } = args;
-                    void _dropped;
-                    mutated = true;
-                    return { ...tc, arguments: JSON.stringify(rest) };
-                }
-                // Meta-executor wrapping: { tool: "task_complete", parameters: {...} }
-                if (args.tool === "task_complete") {
-                    const params = args.parameters;
-                    if (params && "final_message" in params) {
-                        const { final_message: _dropped, ...restParams } = params;
-                        void _dropped;
-                        mutated = true;
-                        return {
-                            ...tc,
-                            arguments: JSON.stringify({ ...args, parameters: restParams }),
-                        };
-                    }
-                }
-                return tc;
-            });
-            return mutated ? { ...msg, toolCalls: sanitizedToolCalls } : msg;
-        });
-    }
     /**
      * Run LLM-as-judge quality assessment on a completed agent run.
      */
@@ -8286,7 +8168,9 @@ class Graphlit {
                 if (!handler) {
                     throw new Error(`No handler found for tool: ${toolCall.name}`);
                 }
-                parsedArguments = toolCall.arguments ? JSON.parse(toolCall.arguments) : {};
+                parsedArguments = toolCall.arguments
+                    ? JSON.parse(toolCall.arguments)
+                    : {};
                 // Add timeout for individual tool calls (30 seconds)
                 const toolTimeout = new Promise((_, reject) => setTimeout(() => reject(new Error("Tool execution timeout")), 30000));
                 result = await Promise.race([

package/package.json

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