ai 7.0.9 → 7.0.10

package/docs/03-ai-sdk-core/16-mcp-tools.mdx

@@ -203,6 +203,34 @@ This hook is called before the SDK fetches authorization server metadata, so a
 rejected URL is not requested. It is optional and does not change existing OAuth
 flows unless you implement it.
 
+### Retrying Transient Tool Failures
+
+MCP tool calls can fail for transient transport reasons, such as rate limits,
+temporary overload, or gateway timeouts. You can opt into automatic retries for
+`tools/call` requests by passing `maxRetries` when creating the client:
+
+```typescript
+const mcpClient = await createMCPClient({
+  transport: {
+    type: 'http',
+    url: 'https://your-server.com/mcp',
+  },
+  maxRetries: 2,
+});
+```
+
+Retries are disabled by default. Built-in retry matching is intended for
+transient HTTP and network failures only. JSON-RPC application errors, such as
+invalid tool arguments, are surfaced immediately without retrying. Successful
+MCP tool responses with `isError: true` are also returned to the model without
+retrying.
+
+<Note type="warning">
+  Only enable retries for MCP tools where retrying is safe. Retrying
+  non-idempotent tools, such as tools that send emails or create records, can
+  duplicate side effects.
+</Note>
+
 ### Closing the MCP Client
 
 After initialization, you should close the MCP client based on your usage pattern:

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

@@ -345,6 +345,10 @@ console.log(preparation.identity);
 - `id`: optional stable agent identifier.
 - `instructions`: instructions applied once to a fresh session.
 - `tools`: AI SDK tools executed by the host when the harness calls them.
+- `activeTools`: allowlist of built-in and host-executed tools the harness can
+  call.
+- `inactiveTools`: denylist of built-in and host-executed tools the harness
+  cannot call.
 - `skills`: instruction bundles surfaced by the adapter.
 - `permissionMode`: built-in tool permission mode.
 - `toolApproval`: approval status map for host-executed tools.

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

@@ -91,6 +91,55 @@ 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.
 
+## Tool Filtering
+
+Use `activeTools` or `inactiveTools` on `HarnessAgent` to control which tools the
+harness can call. Both settings accept tool names from the combined tool set:
+the built-in tools declared by the harness adapter and the AI SDK tools passed
+with `tools`.
+
+`activeTools` is an allowlist:
+
+```ts
+const agent = new HarnessAgent({
+  harness: claudeCode,
+  sandbox: createVercelSandbox({
+    runtime: 'node24',
+    ports: [4000],
+  }),
+  tools: { weather },
+  activeTools: ['weather'],
+});
+```
+
+`inactiveTools` is a denylist:
+
+```ts
+const agent = new HarnessAgent({
+  harness: claudeCode,
+  sandbox: createVercelSandbox({
+    runtime: 'node24',
+    ports: [4000],
+  }),
+  tools: { weather },
+  inactiveTools: ['bash', 'write'],
+});
+```
+
+Pass either `activeTools` or `inactiveTools`, not both. The TypeScript settings
+type prevents combining them, and `HarnessAgent` also throws at runtime when
+both are specified.
+
+For host-executed tools, inactive tools are not passed to the underlying
+harness runtime. If the runtime still attempts to call one, `HarnessAgent`
+returns an execution-denied tool result.
+
+For built-in tools, support depends on the harness adapter. Some adapters can
+filter built-ins natively. Others enforce filtering through their built-in tool
+approval mechanism by denying inactive built-in calls before they execute,
+without emitting approval request or response stream parts. Adapters that
+support neither mechanism throw when you filter built-in tools.
+
 ## Sandbox in Tool Execution
 
 Host-executed tools receive the session sandbox through the same

package/docs/03-ai-sdk-harnesses/05-harness-adapters.mdx

@@ -28,10 +28,10 @@ The AI SDK includes the following harness adapters:
 
 ## Adapter Capabilities
 
-| Adapter                                                | Runtime location | Custom tools        | Custom skills       | Built-in tool approval |
-| ------------------------------------------------------ | ---------------- | ------------------- | ------------------- | ---------------------- |
-| [Claude Code](/providers/ai-sdk-harnesses/claude-code) | Sandbox bridge   | <Check size={18} /> | <Check size={18} /> | <Check size={18} />    |
-| [Codex](/providers/ai-sdk-harnesses/codex)             | Sandbox bridge   | <Check size={18} /> | <Check size={18} /> | <Cross size={18} />    |
-| [Deep Agents](/providers/ai-sdk-harnesses/deepagents)  | Sandbox bridge   | <Check size={18} /> | <Check size={18} /> | <Check size={18} />    |
-| [OpenCode](/providers/ai-sdk-harnesses/opencode)       | Sandbox bridge   | <Check size={18} /> | <Check size={18} /> | <Check size={18} />    |
-| [Pi](/providers/ai-sdk-harnesses/pi)                   | Host process     | <Check size={18} /> | <Check size={18} /> | <Check size={18} />    |
+| Adapter                                                | Runtime location | Custom tools        | Custom skills       | Built-in tool approval | Built-in tool filtering                |
+| ------------------------------------------------------ | ---------------- | ------------------- | ------------------- | ---------------------- | -------------------------------------- |
+| [Claude Code](/providers/ai-sdk-harnesses/claude-code) | Sandbox bridge   | <Check size={18} /> | <Check size={18} /> | <Check size={18} />    | <Check size={18} />                    |
+| [Codex](/providers/ai-sdk-harnesses/codex)             | Sandbox bridge   | <Check size={18} /> | <Check size={18} /> | <Cross size={18} />    | <Cross size={18} />                    |
+| [Deep Agents](/providers/ai-sdk-harnesses/deepagents)  | Sandbox bridge   | <Check size={18} /> | <Check size={18} /> | <Check size={18} />    | <Check size={18} /> via auto-rejection |
+| [OpenCode](/providers/ai-sdk-harnesses/opencode)       | Sandbox bridge   | <Check size={18} /> | <Check size={18} /> | <Check size={18} />    | <Check size={18} /> via auto-rejection |
+| [Pi](/providers/ai-sdk-harnesses/pi)                   | Host process     | <Check size={18} /> | <Check size={18} /> | <Check size={18} />    | <Check size={18} />                    |

package/docs/07-reference/01-ai-sdk-core/23-create-mcp-client.mdx

@@ -187,6 +187,13 @@ It currently does not support accepting notifications from an MCP server, and cu
               isOptional: true,
               description: 'Handler for uncaught errors',
             },
+            {
+              name: 'maxRetries',
+              type: 'number',
+              isOptional: true,
+              description:
+                'Maximum number of retries for transient MCP tool call failures. Set to 0 to disable retries. Defaults to 0. Retries are opt-in and apply to tools/call requests.',
+            },
             {
               name: 'initialInitializeResult',
               type: 'InitializeResult',

package/docs/08-migration-guides/23-migration-guide-7-0.mdx

@@ -1883,6 +1883,25 @@ The old names still work as deprecated aliases, but you should migrate to the ne
 
 The main entry point the `google` constant, remains unchanged, so if that's all you use from the provider, no changes are required.
 
+## xAI Provider
+
+### Default Model Now Uses the Responses API
+
+In AI SDK 7, `xai(modelId)` (and `xai.languageModel(modelId)`) uses the xAI Responses API by default instead of the Chat Completions API. Both APIs were already available in AI SDK 6 via `xai.chat(modelId)` and `xai.responses(modelId)`; AI SDK 7 only changes which one `xai(modelId)` uses by default. To keep using the Chat Completions API, use `xai.chat(modelId)`.
+
+```tsx filename="AI SDK 6"
+// used the Chat Completions API
+const model = xai('grok-4.3');
+```
+
+```tsx filename="AI SDK 7"
+// now uses the Responses API
+const model = xai('grok-4.3');
+
+// use the Chat Completions API explicitly
+const chatModel = xai.chat('grok-4.3');
+```
+
 # Migration Skill
 
 Use the command below to add the migration skill and guide your agent

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "7.0.9",
+  "version": "7.0.10",
   "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",
@@ -42,9 +42,9 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/gateway": "4.0.7",
+    "@ai-sdk/gateway": "4.0.8",
     "@ai-sdk/provider": "4.0.1",
-    "@ai-sdk/provider-utils": "5.0.2"
+    "@ai-sdk/provider-utils": "5.0.3"
   },
   "devDependencies": {
     "@edge-runtime/vm": "^5.0.0",

package/src/util/prepare-retries.ts

@@ -1,8 +1,6 @@
 import { InvalidArgumentError } from '../error/invalid-argument-error';
-import {
-  retryWithExponentialBackoffRespectingRetryHeaders,
-  type RetryFunction,
-} from '../util/retry-with-exponential-backoff';
+import type { RetryFunction } from '@ai-sdk/provider-utils';
+import { retryWithExponentialBackoffRespectingRetryHeaders } from '../util/retry-with-exponential-backoff';
 /**
  * Validate and prepare retries.
  */

package/src/util/retry-with-exponential-backoff.ts

@@ -1,12 +1,11 @@
 import { APICallError } from '@ai-sdk/provider';
 import { GatewayError } from '@ai-sdk/gateway';
-import { delay, getErrorMessage, isAbortError } from '@ai-sdk/provider-utils';
+import {
+  retryWithExponentialBackoff,
+  type RetryFunction,
+} from '@ai-sdk/provider-utils';
 import { RetryError } from './retry-error';
 
-export type RetryFunction = <OUTPUT>(
-  fn: () => PromiseLike<OUTPUT>,
-) => PromiseLike<OUTPUT>;
-
 function getRetryDelayInMs({
   error,
   exponentialBackoffDelay,
@@ -62,98 +61,31 @@ function getRetryDelayInMs({
  * while respecting rate limit headers (retry-after-ms and retry-after) if they are provided and reasonable (0-60 seconds).
  * You can configure the maximum number of retries, the initial delay, and the backoff factor.
  */
-export const retryWithExponentialBackoffRespectingRetryHeaders =
-  ({
-    maxRetries = 2,
-    initialDelayInMs = 2000,
-    backoffFactor = 2,
-    abortSignal,
-  }: {
-    maxRetries?: number;
-    initialDelayInMs?: number;
-    backoffFactor?: number;
-    abortSignal?: AbortSignal;
-  } = {}): RetryFunction =>
-  async <OUTPUT>(f: () => PromiseLike<OUTPUT>) =>
-    _retryWithExponentialBackoff(f, {
-      maxRetries,
-      delayInMs: initialDelayInMs,
-      backoffFactor,
-      abortSignal,
-    });
-
-async function _retryWithExponentialBackoff<OUTPUT>(
-  f: () => PromiseLike<OUTPUT>,
-  {
+export const retryWithExponentialBackoffRespectingRetryHeaders = ({
+  maxRetries = 2,
+  initialDelayInMs = 2000,
+  backoffFactor = 2,
+  abortSignal,
+}: {
+  maxRetries?: number;
+  initialDelayInMs?: number;
+  backoffFactor?: number;
+  abortSignal?: AbortSignal;
+} = {}): RetryFunction =>
+  retryWithExponentialBackoff({
     maxRetries,
-    delayInMs,
+    initialDelayInMs,
     backoffFactor,
     abortSignal,
-  }: {
-    maxRetries: number;
-    delayInMs: number;
-    backoffFactor: number;
-    abortSignal: AbortSignal | undefined;
-  },
-  errors: unknown[] = [],
-): Promise<OUTPUT> {
-  try {
-    return await f();
-  } catch (error) {
-    if (isAbortError(error)) {
-      throw error; // don't retry when the request was aborted
-    }
-
-    if (maxRetries === 0) {
-      throw error; // don't wrap the error when retries are disabled
-    }
-
-    const errorMessage = getErrorMessage(error);
-    const newErrors = [...errors, error];
-    const tryNumber = newErrors.length;
-
-    if (tryNumber > maxRetries) {
-      throw new RetryError({
-        message: `Failed after ${tryNumber} attempts. Last error: ${errorMessage}`,
-        reason: 'maxRetriesExceeded',
-        errors: newErrors,
-      });
-    }
-
-    if (
+    shouldRetry: error =>
       error instanceof Error &&
       ((APICallError.isInstance(error) && error.isRetryable === true) ||
-        (GatewayError.isInstance(error) && error.isRetryable === true)) &&
-      tryNumber <= maxRetries
-    ) {
-      await delay(
-        getRetryDelayInMs({
-          error: error as APICallError | GatewayError,
-          exponentialBackoffDelay: delayInMs,
-        }),
-        { abortSignal },
-      );
-
-      return _retryWithExponentialBackoff(
-        f,
-        {
-          maxRetries,
-          delayInMs: backoffFactor * delayInMs,
-          backoffFactor,
-          abortSignal,
-        },
-        newErrors,
-      );
-    }
-
-    if (tryNumber === 1) {
-      throw error; // don't wrap the error when a non-retryable error occurs on the first try
-    }
-
-    throw new RetryError({
-      message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`,
-      reason: 'errorNotRetryable',
-      errors: newErrors,
-    });
-  }
-}
+        (GatewayError.isInstance(error) && error.isRetryable === true)),
+    getDelayInMs: ({ error, exponentialBackoffDelay }) =>
+      getRetryDelayInMs({
+        error: error as APICallError | GatewayError,
+        exponentialBackoffDelay,
+      }),
+    createRetryError: ({ message, reason, errors }) =>
+      new RetryError({ message, reason, errors }),
+  });