ai 7.0.108 → 7.0.109

package/docs/03-ai-sdk-harnesses/02-harness-agent.mdx

@@ -362,6 +362,8 @@ When you only have raw continuation state from `suspendTurn()`, resume with
 const session = await agent.createSession({
   sessionId: chatId,
   continueFrom: continuationState,
+  // Rebind this when the suspended turn used host-only tool context:
+  toolsContext,
 });
 
 const result = await agent.continueStream({ session });
@@ -370,6 +372,11 @@ const result = await agent.continueStream({ session });
 Use `continueStream()` for incremental output, or `continueGenerate()` to drain
 the continued turn and return a `GenerateTextResult`.
 
+`toolsContext` is intentionally not stored in continuation state because it can
+contain credentials or non-serializable host objects. When a suspended turn
+used static or `prepareCall`-derived tool context, pass the same per-tool map to
+`createSession` to rebind it in the process that continues the turn.
+
 ## Stop After a Harness Step
 
 Use `stopWhen` to opt into semantic step boundaries. Predicates run after real

package/docs/03-ai-sdk-harnesses/03-tools.mdx

@@ -93,6 +93,52 @@ const agent = new HarnessAgent({
 When the harness calls `weather`, `HarnessAgent` executes the tool in your host
 process, then submits the result back to the harness runtime.
 
+Host-executed tools can declare a `contextSchema` and receive turn-scoped
+context through `toolsContext`:
+
+```ts
+const lookupAccount = tool({
+  inputSchema: z.object({}),
+  contextSchema: z.object({ userId: z.string() }),
+  execute: async (_, { context }) => {
+    return loadAccount(context.userId);
+  },
+});
+
+const agent = new HarnessAgent({
+  harness: claudeCode,
+  tools: { lookupAccount },
+  toolsContext: {
+    lookupAccount: { userId: 'user-123' },
+  },
+});
+```
+
+Use `prepareCall` to replace `toolsContext` when the value depends on custom
+call options. The type of `toolsContext` follows the tool set: it is rejected
+when no tool declares a context schema, required when a tool requires a
+context object, and optional when every context object is optional.
+`HarnessAgent` validates each entry against the tool's `contextSchema` before
+execution and exposes the configured map in step results and lifecycle
+callbacks.
+
+Tool context remains host-only and is not serialized into suspended-turn state.
+When recreating a session for an unfinished turn, rebind it explicitly:
+
+```ts
+const session = await agent.createSession({
+  sessionId,
+  continueFrom,
+  toolsContext: {
+    lookupAccount: { userId: 'user-123' },
+  },
+});
+```
+
+Missing or invalid context fails validation before the host tool executes. The
+validation error returned to the harness runtime is intentionally generic so
+host-only context values and schema details are not disclosed to the model.
+
 ## Client-Side Tools
 
 Omit `execute` when a browser, user interaction, or another external process

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.108",
+  "version": "7.0.109",
   "type": "module",
   "description": "AI SDK by Vercel - build apps like ChatGPT, Claude, Gemini, and more with a single interface for any model using the Vercel AI Gateway or go direct to OpenAI, Anthropic, Google, or any other model provider.",
   "license": "Apache-2.0",
@@ -47,7 +47,7 @@
     "@ai-sdk/provider-utils": "5.0.45"
   },
   "devDependencies": {
-    "@ai-sdk/amazon-bedrock": "5.0.89",
+    "@ai-sdk/amazon-bedrock": "5.0.90",
     "@ai-sdk/deepseek": "3.0.50",
     "@ai-sdk/google": "4.0.76",
     "@ai-sdk/groq": "4.0.46",

package/src/generate-text/tools-context-parameter.ts

@@ -10,13 +10,19 @@ import type {
 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.
+ */
+export 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.
  */
 export type ToolsContextParameter<TOOLS extends ToolSet> = {
   tools?: TOOLS;
-} & (IsEmptyObject<InferToolSetContext<TOOLS>> extends true
-  ? { toolsContext?: never }
-  : HasRequiredKey<InferToolSetContext<TOOLS>> extends true
-    ? { toolsContext: InferToolSetContext<TOOLS> }
-    : { toolsContext?: InferToolSetContext<TOOLS> });
+} & ToolsContextSettings<TOOLS>;

package/src/middleware/extract-reasoning-middleware.ts

@@ -90,12 +90,17 @@ export function extractReasoningMiddleware({
           afterSwitch: boolean;
           isReasoning: boolean;
           buffer: string;
-          idCounter: number;
+          reasoningId: string | undefined;
           textId: string;
         }
       > = createIdMap();
 
-      let delayedTextStart: LanguageModelV4StreamPart | undefined;
+      let reasoningIdCounter = 0;
+
+      const delayedTextStarts: Record<
+        string,
+        Extract<LanguageModelV4StreamPart, { type: 'text-start' }>
+      > = createIdMap();
 
       return {
         stream: stream.pipeThrough(
@@ -107,13 +112,16 @@ export function extractReasoningMiddleware({
               // do not send `text-start` before `reasoning-start`
               // https://github.com/vercel/ai/issues/7774
               if (chunk.type === 'text-start') {
-                delayedTextStart = chunk;
+                delayedTextStarts[chunk.id] = chunk;
                 return;
               }
 
-              if (chunk.type === 'text-end' && delayedTextStart) {
-                controller.enqueue(delayedTextStart);
-                delayedTextStart = undefined;
+              if (
+                chunk.type === 'text-end' &&
+                delayedTextStarts[chunk.id] != null
+              ) {
+                controller.enqueue(delayedTextStarts[chunk.id]);
+                delete delayedTextStarts[chunk.id];
               }
 
               if (chunk.type !== 'text-delta') {
@@ -128,7 +136,7 @@ export function extractReasoningMiddleware({
                   afterSwitch: false,
                   isReasoning: startWithReasoning,
                   buffer: '',
-                  idCounter: 0,
+                  reasoningId: undefined,
                   textId: chunk.id,
                 };
               }
@@ -137,6 +145,10 @@ export function extractReasoningMiddleware({
 
               activeExtraction.buffer += chunk.delta;
 
+              function getReasoningId() {
+                return (activeExtraction.reasoningId ??= `reasoning-${reasoningIdCounter++}`);
+              }
+
               function publish(text: string) {
                 if (text.length > 0) {
                   const prefix =
@@ -154,7 +166,7 @@ export function extractReasoningMiddleware({
                   ) {
                     controller.enqueue({
                       type: 'reasoning-start',
-                      id: `reasoning-${activeExtraction.idCounter}`,
+                      id: getReasoningId(),
                     });
                   }
 
@@ -162,12 +174,14 @@ export function extractReasoningMiddleware({
                     controller.enqueue({
                       type: 'reasoning-delta',
                       delta: prefix + text,
-                      id: `reasoning-${activeExtraction.idCounter}`,
+                      id: getReasoningId(),
                     });
                   } else {
-                    if (delayedTextStart) {
-                      controller.enqueue(delayedTextStart);
-                      delayedTextStart = undefined;
+                    if (delayedTextStarts[activeExtraction.textId] != null) {
+                      controller.enqueue(
+                        delayedTextStarts[activeExtraction.textId],
+                      );
+                      delete delayedTextStarts[activeExtraction.textId];
                     }
                     controller.enqueue({
                       type: 'text-delta',
@@ -221,15 +235,16 @@ export function extractReasoningMiddleware({
                     if (activeExtraction.isFirstReasoning) {
                       controller.enqueue({
                         type: 'reasoning-start',
-                        id: `reasoning-${activeExtraction.idCounter}`,
+                        id: getReasoningId(),
                       });
                     }
 
                     // reasoning part finished:
                     controller.enqueue({
                       type: 'reasoning-end',
-                      id: `reasoning-${activeExtraction.idCounter++}`,
+                      id: getReasoningId(),
                     });
+                    activeExtraction.reasoningId = undefined;
                   }
 
                   activeExtraction.isReasoning = !activeExtraction.isReasoning;

package/src/ui/call-completion-api.ts

@@ -30,6 +30,7 @@ export async function callCompletionApi({
   setLoading,
   setError,
   setAbortController,
+  getAbortController,
   onFinish,
   onError,
   fetch = getOriginalFetch(),
@@ -44,15 +45,19 @@ export async function callCompletionApi({
   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;
 }) {
+  const abortController = new AbortController();
+  const isCurrentRequest = () =>
+    getAbortController == null || getAbortController() === abortController;
+
   try {
     setLoading(true);
     setError(undefined);
 
-    const abortController = new AbortController();
     setAbortController(abortController);
 
     // Empty the completion immediately.
@@ -100,7 +105,9 @@ export async function callCompletionApi({
           stream: response.body,
           onTextPart: chunk => {
             result += chunk;
-            setCompletion(result);
+            if (isCurrentRequest()) {
+              setCompletion(result);
+            }
           },
         });
         break;
@@ -120,7 +127,9 @@ export 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',
@@ -151,12 +160,10 @@ export async function callCompletionApi({
       onFinish(prompt, result);
     }
 
-    setAbortController(null);
     return result;
   } catch (err) {
     // Ignore abort errors as they are expected.
     if ((err as any).name === 'AbortError') {
-      setAbortController(null);
       return null;
     }
 
@@ -166,8 +173,14 @@ export async function callCompletionApi({
       }
     }
 
-    setError(err as Error);
+    if (isCurrentRequest()) {
+      setError(err as Error);
+    }
   } finally {
-    setLoading(false);
+    // A newer request may have started while this one was settling.
+    if (isCurrentRequest()) {
+      setAbortController(null);
+      setLoading(false);
+    }
   }
 }