ai 7.0.108 → 7.0.109

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # ai
 
+## 7.0.109
+
+### Patch Changes
+
+- 0343bb1: fix(ai): keep replacement completion requests loading and cancellable when an earlier request settles
+- 2b105fa: fix(ai): preserve overlapping text blocks in reasoning extraction streams
+- 125f493: fix(harness): forward validated `toolsContext` to host-executed tools in alignment with `ToolLoopAgent`
+
 ## 7.0.108
 
 ### Patch Changes

package/dist/index.d.ts

@@ -3331,18 +3331,22 @@ type ToolInputRefinement<TOOLS extends ToolSet> = {
  */
 type IsEmptyObject<OBJECT> = keyof OBJECT extends never ? true : false;
 /**
- * Helper type to make the toolsContext parameter optional, required, or
- * unavailable based on the tool set.
+ * Makes the toolsContext setting optional, required, or unavailable based on
+ * the tool set.
  */
-type ToolsContextParameter<TOOLS extends ToolSet> = {
-    tools?: TOOLS;
-} & (IsEmptyObject<InferToolSetContext<TOOLS>> extends true ? {
+type ToolsContextSettings<TOOLS extends ToolSet> = IsEmptyObject<InferToolSetContext<TOOLS>> extends true ? {
     toolsContext?: never;
 } : HasRequiredKey<InferToolSetContext<TOOLS>> extends true ? {
     toolsContext: InferToolSetContext<TOOLS>;
 } : {
     toolsContext?: InferToolSetContext<TOOLS>;
-});
+};
+/**
+ * Helper type for request options that include both tools and their context.
+ */
+type ToolsContextParameter<TOOLS extends ToolSet> = {
+    tools?: TOOLS;
+} & ToolsContextSettings<TOOLS>;
 
 type StreamTextInclude = {
     /**
@@ -5399,7 +5403,7 @@ type UIMessageStreamOnStepEndCallback<UI_MESSAGE extends UIMessage> = (event: {
 type UIMessageStreamOnStepFinishCallback<UI_MESSAGE extends UIMessage> = UIMessageStreamOnStepEndCallback<UI_MESSAGE>;
 
 declare const getOriginalFetch: () => typeof fetch;
-declare function callCompletionApi({ api, prompt, credentials, headers, body, streamProtocol, setCompletion, setLoading, setError, setAbortController, onFinish, onError, fetch, }: {
+declare function callCompletionApi({ api, prompt, credentials, headers, body, streamProtocol, setCompletion, setLoading, setError, setAbortController, getAbortController, onFinish, onError, fetch, }: {
     api: string;
     prompt: string;
     credentials: RequestCredentials | undefined;
@@ -5410,6 +5414,7 @@ declare function callCompletionApi({ api, prompt, credentials, headers, body, st
     setLoading: (loading: boolean) => void;
     setError: (error: Error | undefined) => void;
     setAbortController: (abortController: AbortController | null) => void;
+    getAbortController?: () => AbortController | null | undefined;
     onFinish: ((prompt: string, completion: string) => void) | undefined;
     onError: ((error: Error) => void) | undefined;
     fetch: ReturnType<typeof getOriginalFetch> | undefined;

package/dist/index.js

@@ -1334,7 +1334,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "7.0.108" : "0.0.0-test";
+var VERSION = true ? "7.0.109" : "0.0.0-test";
 
 // src/util/download/download.ts
 var download = async ({
@@ -17430,18 +17430,19 @@ function extractReasoningMiddleware({
     wrapStream: async ({ doStream }) => {
       const { stream, ...rest } = await doStream();
       const reasoningExtractions = createIdMap();
-      let delayedTextStart;
+      let reasoningIdCounter = 0;
+      const delayedTextStarts = createIdMap();
       return {
         stream: stream.pipeThrough(
           new TransformStream({
             transform: (chunk, controller) => {
               if (chunk.type === "text-start") {
-                delayedTextStart = chunk;
+                delayedTextStarts[chunk.id] = chunk;
                 return;
               }
-              if (chunk.type === "text-end" && delayedTextStart) {
-                controller.enqueue(delayedTextStart);
-                delayedTextStart = void 0;
+              if (chunk.type === "text-end" && delayedTextStarts[chunk.id] != null) {
+                controller.enqueue(delayedTextStarts[chunk.id]);
+                delete delayedTextStarts[chunk.id];
               }
               if (chunk.type !== "text-delta") {
                 controller.enqueue(chunk);
@@ -17454,31 +17455,37 @@ function extractReasoningMiddleware({
                   afterSwitch: false,
                   isReasoning: startWithReasoning,
                   buffer: "",
-                  idCounter: 0,
+                  reasoningId: void 0,
                   textId: chunk.id
                 };
               }
               const activeExtraction = reasoningExtractions[chunk.id];
               activeExtraction.buffer += chunk.delta;
+              function getReasoningId() {
+                var _a25;
+                return (_a25 = activeExtraction.reasoningId) != null ? _a25 : activeExtraction.reasoningId = `reasoning-${reasoningIdCounter++}`;
+              }
               function publish(text2) {
                 if (text2.length > 0) {
                   const prefix = activeExtraction.afterSwitch && (activeExtraction.isReasoning ? !activeExtraction.isFirstReasoning : !activeExtraction.isFirstText) ? separator : "";
                   if (activeExtraction.isReasoning && (activeExtraction.afterSwitch || activeExtraction.isFirstReasoning)) {
                     controller.enqueue({
                       type: "reasoning-start",
-                      id: `reasoning-${activeExtraction.idCounter}`
+                      id: getReasoningId()
                     });
                   }
                   if (activeExtraction.isReasoning) {
                     controller.enqueue({
                       type: "reasoning-delta",
                       delta: prefix + text2,
-                      id: `reasoning-${activeExtraction.idCounter}`
+                      id: getReasoningId()
                     });
                   } else {
-                    if (delayedTextStart) {
-                      controller.enqueue(delayedTextStart);
-                      delayedTextStart = void 0;
+                    if (delayedTextStarts[activeExtraction.textId] != null) {
+                      controller.enqueue(
+                        delayedTextStarts[activeExtraction.textId]
+                      );
+                      delete delayedTextStarts[activeExtraction.textId];
                     }
                     controller.enqueue({
                       type: "text-delta",
@@ -17515,13 +17522,14 @@ function extractReasoningMiddleware({
                     if (activeExtraction.isFirstReasoning) {
                       controller.enqueue({
                         type: "reasoning-start",
-                        id: `reasoning-${activeExtraction.idCounter}`
+                        id: getReasoningId()
                       });
                     }
                     controller.enqueue({
                       type: "reasoning-end",
-                      id: `reasoning-${activeExtraction.idCounter++}`
+                      id: getReasoningId()
                     });
+                    activeExtraction.reasoningId = void 0;
                   }
                   activeExtraction.isReasoning = !activeExtraction.isReasoning;
                   activeExtraction.afterSwitch = true;
@@ -21661,14 +21669,16 @@ async function callCompletionApi({
   setLoading,
   setError,
   setAbortController,
+  getAbortController,
   onFinish,
   onError,
   fetch: fetch2 = getOriginalFetch()
 }) {
+  const abortController = new AbortController();
+  const isCurrentRequest = () => getAbortController == null || getAbortController() === abortController;
   try {
     setLoading(true);
     setError(void 0);
-    const abortController = new AbortController();
     setAbortController(abortController);
     setCompletion("");
     const response = await fetch2(api, {
@@ -21709,7 +21719,9 @@ async function callCompletionApi({
           stream: response.body,
           onTextPart: (chunk) => {
             result += chunk;
-            setCompletion(result);
+            if (isCurrentRequest()) {
+              setCompletion(result);
+            }
           }
         });
         break;
@@ -21728,7 +21740,9 @@ async function callCompletionApi({
                 const streamPart = part.value;
                 if (streamPart.type === "text-delta") {
                   result += streamPart.delta;
-                  setCompletion(result);
+                  if (isCurrentRequest()) {
+                    setCompletion(result);
+                  }
                 } else if (streamPart.type === "error") {
                   throw new UIMessageStreamError({
                     chunkType: "error",
@@ -21757,11 +21771,9 @@ async function callCompletionApi({
     if (onFinish) {
       onFinish(prompt, result);
     }
-    setAbortController(null);
     return result;
   } catch (err) {
     if (err.name === "AbortError") {
-      setAbortController(null);
       return null;
     }
     if (err instanceof Error) {
@@ -21769,9 +21781,14 @@ async function callCompletionApi({
         onError(err);
       }
     }
-    setError(err);
+    if (isCurrentRequest()) {
+      setError(err);
+    }
   } finally {
-    setLoading(false);
+    if (isCurrentRequest()) {
+      setAbortController(null);
+      setLoading(false);
+    }
   }
 }