You can now access anomaly alerts and their details directly through the Vercel CLI.

With the vercel alerts command, you can list all alerts for a team or given project. For each alert, you can view the start time, the type of alert, and whether or not the alert is still active.

With the --ai option, the AI investigation results appear alongside each alert. You and your agent can act on alerts without leaving the terminal.

vercel alerts --ai

Available on Observability Plus.

Learn more about vercel alerts in the CLI documentation.

Qwen 3.7 Max from Alibaba is now available on Vercel AI Gateway. The model is designed as an agent foundation, with capabilities spanning coding, office workflow automation, and long-horizon autonomous execution.

Qwen 3.7 Max shows improvements in frontend prototyping and complex multi-file engineering. The model supports office and productivity tasks through multi-agent orchestration and sustains coherent reasoning across long-horizon tool-calling sessions.

To use Qwen 3.7 Max, set model to alibaba/qwen-3.7-max in the AI SDK.

1
import { streamText } from 'ai';
2

3
const result = streamText({
4
  model: 'alibaba/qwen3.7-max',
5
  prompt: `Refactor this service into smaller modules and update callers across the repo.`,
6
});

AI Gateway provides a unified API for calling models, tracking usage and cost, and configuring retries, failover, and performance optimizations for higher-than-provider uptime. It includes built-in custom reporting, observability, Bring Your Own Key support, and intelligent provider routing with automatic retries.

Learn more about AI Gateway, view the AI Gateway model leaderboard or try it in our model playground.

Grok Build 0.1 is now available on Vercel AI Gateway.

This is a beta coding model trained for agentic coding, currently in early access, and powers the Grok Build CLI app. Reasoning effort is not configurable, and there is no non-reasoning mode.

To use Grok Build 0.1, set model to xai/grok-build-0.1 in the AI SDK.

1
import { streamText } from 'ai';
2

3
const result = streamText({
4
  model: 'xai/grok-build-0.1',
5
  prompt: 'Refactor this module to use async/await and add tests.',
6
});

AI Gateway provides a unified API for calling models, tracking usage and cost, and configuring retries, failover, and performance optimizations for higher-than-provider uptime. It includes built-in custom reporting, observability, Bring Your Own Key support, and intelligent provider routing with automatic retries.

Learn more about AI Gateway, view the AI Gateway model leaderboard or try it in our model playground.

Chat SDK now ships a built-in AI SDK toolset through the new chat/ai subpath. One createChatTools(chat) call wires Chat SDK's read and write actions into your agent.

import { Chat } from "chat";
import { createChatTools } from "chat/ai";
import { ToolLoopAgent } from "ai";

const chat = new Chat({ userName: "mybot" /* ... */ });

const agent = new ToolLoopAgent({
  model: "openai/gpt-5.4",
  instructions: 'You are a helpful assistant.'
  tools: createChatTools(chat, { preset: "messenger" }),
});

• Approval by default: write tools are gated by a requireApproval option.

• Presets: reader, messenger, and moderator scope the toolset.

• Lazy loading: only the tools your preset allows are constructed.

toAiMessages and its supporting types have moved to chat/ai. The previous chat re-exports are flagged @deprecated.

Read the documentation to get started, or try one of our templates.

You can now read the parent issue or pull request when your bot is mentioned in a Linear or GitHub comment. message.subject resolves to that parent with title, status, URL, and the full typed payload.

bot.onNewMention(async (thread, message) => {
  const subject = await message.subject;

  if (subject) {
    await thread.post(
      `This is about: ${subject.title} (${subject.status})\n${subject.url}`
    );
  }
});

message.subject is cached per message, so repeated access only hits the API once. It resolves to null on Slack and other chat platforms, where there's no parent resource.

Link to headingDirect access to platform SDKs

The GitHub, Linear, and Slack adapters now expose their underlying platform SDKs. Use them to extend your bot by calling provider APIs directly.

// Add a "triaged" label to issue #42
const { octokit } = bot.getAdapter("github");
await octokit.rest.issues.addLabels({ owner: "vercel", repo: "chat", issue_number: 42, labels: ["triaged"] });

// Create a new issue in a team
const { linearClient } = bot.getAdapter("linear");
await linearClient.createIssue({ teamId: "TEAM_ID", title: "Investigate flaky test" });

// Pin a message in a channel
const { webClient } = bot.getAdapter("slack");
await webClient.pins.add({ channel: "C123ABC", timestamp: "1234567890.123456" });

The previous .client getter remains as a @deprecated alias on the adapters.

Read the documentation to get started, or explore one of our templates.

You can now pause a Workflow run on a Chat SDK card and resume it when someone clicks a button. The same flow works for form submissions. Buttons and modals accept a new callbackUrl prop, and the event payload is sent to that endpoint.

To build a card like this, create a workflow webhook and pass its URL to each button's callbackUrl prop inside your <Card> component:

import { createWebhook } from "workflow";
import { Card, CardText, Actions, Button } from "chat";

export async function statusReport(
  thread,
  content: { title: string; message: string },
) {

  "use workflow";

  using hook = createWebhook<{ action: "approve" | "approve-and-send" | "deny" }>();

  await thread.post(
    <Card title="Status Report Communications">
      <CardText>Title: {content.title}</CardText>
      <CardText>Message: {content.message}</CardText>
      <Actions>
        <Button callbackUrl={hook.url} id="approve" style="primary">
          Approve
        </Button>
        <Button callbackUrl={hook.url} id="approve-and-send" style="primary">
          Approve & Send
        </Button>
        <Button callbackUrl={hook.url} id="deny" style="danger">
          Cancel
        </Button>
      </Actions>
    </Card>
  );

  const { action } = await hook;
  if (action === "approve" || action === "approve-and-send") {
    await sendReport(content);
  }

}

For the <Modal> component, the form data is in the payload. callbackUrl works for buttons on most platforms with an official adapter, and for modals on Slack and Teams.

Read the documentation or walkthrough guide to start building.

The Vercel AI Gateway plugin gives any WordPress site access to hundreds of models from 40+ providers through a single API key. Providers include Anthropic, Google, OpenAI, xAI, DeepSeek, MiniMax, Moonshot AI, and more.

The plugin is implemented as a connector for the new WordPress AI Client, which requires WordPress 7.0, released today.

Link to headingWhat this enables

• Any AI-powered plugin works automatically. Plugins built on the WordPress AI Client pick up the connector without their own provider integrations or API keys.

• One key, many providers. Manage a single AI Gateway key in Settings > Connectors instead of credentials per provider.

• Multi-modal content generation. Text, structured JSON, image generation and editing, and video, all through the same prompt builder.

• Automatic fallbacks. AI features stay online during provider outages.

• Dynamic model discovery. New models become available without a plugin update.

• Unified billing and observability across providers, at provider prices.

Link to headingGetting started

1. Install the Vercel AI Gateway plugin on your WordPress site

2. Add your AI Gateway API key under Settings > Connectors

To call AI Gateway directly from your own code:

1
$excerpt = wp_ai_client_prompt( 'Write a 2-sentence excerpt for this post: ' . $post->post_content )
2
    ->using_provider( 'ai_gateway' )
3
    ->generate_text();

See the plugin documentation for more details, including examples for text, structured JSON output, image generation, and video.

The Nuxt MCP Toolkit now supports MCP apps. Your agent tools can return interactive HTML responses that MCP clients like Claude and ChatGPT render inline, rather than plain-text responses.

Declare a tool with the defineMcpApp macro, then read pre-hydrated data, trigger follow-up prompts, or call other tools from inside the UI with the useMcpApp composable. The toolkit bundles each Vue SFC into a self-contained HTML file at build time and serves it from your MCP endpoint.

1
<script setup lang="ts">
2
import { z } from 'zod'
3

4
defineMcpApp({
5
  name: 'weather',
6
  description: 'Show the forecast for a city',
7
  inputSchema: {
8
    city: z.string().describe('City to get the forecast for'),
9
  },
10
  handler: async ({ city }) => ({
11
    structuredContent: await $fetch(`/api/weather?city=${city}`),
12
  }),
13
})
14

15
const { data, callTool } = useMcpApp<{ city: string, summary: string, tempC: number }>()
16
</script>
17

18
<template>
19
  <article>
20
    <h1>{{ data?.city }}</h1>
21
    <p>{{ data?.summary }}, {{ data?.tempC }}°C</p>
22
    <button @click="callTool('weather', { city: 'London' })">
23
      Check London
24
    </button>
25
  </article>
26
</template>

Read the Nuxt MCP Toolkit documentation to get started.