@mastra/mcp-docs-server 1.2.4 → 1.2.5-alpha.3

package/.docs/guides/build-your-ui/copilotkit/generative-ui.md

@@ -0,0 +1,174 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# CopilotKit generative UI
+
+Generative UI is the family of UI paradigms enabled by agents and useful for interacting with them. CopilotKit organizes these along a single axis, the **generative UI spectrum**, which runs from author-controlled (you decide every pixel) to agent-invented (the agent owns the rendered surface). Where you sit on the axis is a trade-off between predictability and breadth.
+
+The spectrum has three tiers:
+
+| Tier            | Who controls the surface                                                                   | Primitives                                                           |
+| --------------- | ------------------------------------------------------------------------------------------ | -------------------------------------------------------------------- |
+| **Controlled**  | You wrote the component; the agent picks which one and what data to pass.                  | Tool call rendering, state rendering, reasoning, components as tools |
+| **Declarative** | The agent emits a structured spec; the frontend composes it from a catalog you registered. | A2UI (fixed schema and dynamic)                                      |
+| **Open-ended**  | The UI is invented elsewhere (an MCP server) and you sandbox it.                           | MCP Apps                                                             |
+
+Each tier is a Mastra agent exposed through `registerCopilotKit()` (see [CopilotKit overview](https://mastra.ai/guides/build-your-ui/copilotkit/overview)) plus the matching CopilotKit hook on the frontend. For the full concept, see CopilotKit's [generative UI spectrum](https://www.copilotkit.ai/generative-ui-spectrum) and [generative UI overview](https://docs.copilotkit.ai/concepts/generative-ui-overview).
+
+> **Tip:** Mastra's [UI Dojo](https://ui-dojo.mastra.ai/) has working CopilotKit examples; browse the source under `src/pages/copilot-kit`.
+
+## Controlled
+
+You ship a fixed set of components and the agent chooses which to render, with what data. This is the workhorse of the spectrum: predictable and brand-safe, the right tool for high-traffic surfaces. The Controlled primitives use CopilotKit's v2 API, imported from `@copilotkit/react-core/v2`.
+
+### Tool call rendering
+
+Render an agent's tool call as a React component. Define the agent and tool on the Mastra server as usual:
+
+```typescript
+import { Agent } from '@mastra/core/agent'
+import { weatherTool } from '../tools/weather-tool'
+
+export const weatherAgent = new Agent({
+  id: 'weather-agent',
+  name: 'Weather Agent',
+  instructions: 'Use the weatherTool to fetch current weather data.',
+  model: 'openai/gpt-5.5',
+  tools: { weatherTool },
+})
+```
+
+On the frontend, register a renderer for the tool by name with `useRenderTool`. It is render-only (it does not execute the tool); the `render` function receives the tool call's `status` and, once the agent returns, its `result`:
+
+```tsx
+import { z } from 'zod'
+import { CopilotChat } from '@copilotkit/react-ui'
+import { CopilotKit, useRenderTool } from '@copilotkit/react-core/v2'
+import { Weather } from '@/components/weather'
+
+function Chat() {
+  useRenderTool(
+    {
+      name: 'weatherTool',
+      parameters: z.object({ location: z.string() }),
+      render: ({ status, result }) => {
+        if (status !== 'complete') {
+          return <div>Retrieving weather...</div>
+        }
+        return <Weather {...result} />
+      },
+    },
+    [],
+  )
+
+  return <CopilotChat labels={{ title: 'Weather Assistant' }} />
+}
+
+export default function Page() {
+  return (
+    <CopilotKit runtimeUrl="http://localhost:4111/copilotkit" agent="weatherAgent">
+      <Chat />
+    </CopilotKit>
+  )
+}
+```
+
+Because Mastra streams tool-call arguments incrementally, the `render` function is called repeatedly as the arguments arrive, so the UI can paint progressively while the agent works.
+
+### Components as tools
+
+Register a React component and let the agent call it as a tool. CopilotKit renders it inline with typed props (defined with a Zod schema):
+
+```tsx
+import { z } from 'zod'
+import { useComponent } from '@copilotkit/react-core/v2'
+
+const schema = z.object({ text: z.string() })
+
+function Callout({ text }: z.infer<typeof schema>) {
+  return <div className="callout">{text}</div>
+}
+
+function Chat() {
+  useComponent({ name: 'callout', render: Callout, parameters: schema }, [])
+  return <CopilotChat labels={{ title: 'Assistant' }} />
+}
+```
+
+The agent invokes `callout` like any other tool, and CopilotKit renders `Callout` with the props it passed.
+
+### State rendering
+
+Render UI from the agent's state and re-render as it streams. On Mastra, agent state is the agent's working memory, streamed to the client as it changes. Read it with `useAgent`; `agent.state` is reactive, so the component updates automatically:
+
+```tsx
+import { useAgent } from '@copilotkit/react-core/v2'
+
+function TaskBoard() {
+  const { agent } = useAgent()
+  const tasks = (agent.state.tasks as any[]) ?? []
+
+  return (
+    <ul>
+      {tasks.map((task, i) => (
+        <li key={i}>
+          {task.title}: {task.status}
+        </li>
+      ))}
+    </ul>
+  )
+}
+```
+
+### Reasoning
+
+Reasoning is zero-config: when your Mastra agent runs a reasoning-capable model, `CopilotChat` renders the model's thinking inline as a dedicated message type, with no extra code. To restyle it, pass your own component to the `reasoningMessage` slot on `CopilotChat`. See CopilotKit's [generative UI guides](https://docs.copilotkit.ai/) for details.
+
+## Declarative
+
+Instead of a fixed component per tool, you register a catalog of typed building blocks and the agent assembles them into a UI tree per request. CopilotKit calls this **A2UI** (Agent-to-UI), available in a fixed-schema and a dynamic variant. It suits the long tail of secondary interactions where breadth matters more than pixel-perfection.
+
+The path of least resistance is to pass your catalog to the `<CopilotKit>` provider. That single prop enables A2UI rendering and injects the A2UI tool into your agent, so no backend change is needed:
+
+```tsx
+import { CopilotKit } from '@copilotkit/react-core/v2'
+import { myCatalog } from './a2ui-catalog'
+
+export default function Page() {
+  return (
+    <CopilotKit
+      runtimeUrl="http://localhost:4111/copilotkit"
+      agent="weatherAgent"
+      a2ui={{ catalog: myCatalog }}
+    >
+      {/* your app */}
+    </CopilotKit>
+  )
+}
+```
+
+The catalog defines the primitives (their schemas) and the renderers (how each primitive displays). In the fixed-schema variant the components are pre-authored and the agent's tool only supplies data; the dynamic variant lets the agent compose the tree more freely. See CopilotKit's [A2UI documentation](https://docs.copilotkit.ai/a2a/generative-ui/a2ui).
+
+## Open-ended
+
+At the far end of the spectrum, the agent owns the entire surface: the UI is invented elsewhere and sandboxed in your app. CopilotKit supports this through **MCP Apps**, where an MCP server ships UI that renders inside your application. This tier trades determinism for novelty and is the most experimental point on the spectrum.
+
+The path of least resistance keeps the frontend untouched: your existing `<CopilotKit>` provider is enough. On the backend, point `registerCopilotKit()` at one or more MCP servers with the `mcpApps` option (it is forwarded to the CopilotKit runtime):
+
+```typescript
+registerCopilotKit({
+  path: '/copilotkit',
+  resourceId: 'weatherAgent',
+  mcpApps: {
+    servers: [{ type: 'http', url: 'http://localhost:3108/mcp', serverId: 'my-server' }],
+  },
+})
+```
+
+When the agent calls an MCP App tool, CopilotKit fetches and renders that tool's UI in the chat with no additional frontend code. See CopilotKit's [MCP Apps documentation](https://docs.copilotkit.ai/agno/generative-ui/mcp-apps).
+
+## App control and interactivity
+
+Some capabilities sit next to the spectrum rather than on it: they control your app or gate a run instead of rendering agent output. Both are covered in [Get started](https://mastra.ai/guides/build-your-ui/copilotkit/overview):
+
+- **Frontend tools** (`useFrontendTool`): let the agent act on your application. This is part of CopilotKit's separate [App Control](https://docs.copilotkit.ai/) concept, alongside shared state and agent context.
+- **Human-in-the-loop**: pause a run and wait for user approval or edits. Backend side, see Mastra's [Agent approval](https://mastra.ai/docs/agents/agent-approval); frontend side, see CopilotKit's [`useHumanInTheLoop`](https://docs.copilotkit.ai/reference/hooks/useHumanInTheLoop).

package/.docs/guides/build-your-ui/copilotkit/overview.md

@@ -0,0 +1,411 @@
+> Discover all available pages from the documentation index: https://mastra.ai/llms.txt
+
+# Using CopilotKit
+
+[CopilotKit](https://www.copilotkit.ai/) provides React components to quickly integrate customizable AI copilots into your application. Combined with Mastra, you can build sophisticated AI apps featuring bidirectional state synchronization and interactive UIs.
+
+CopilotKit talks to Mastra through the [AG-UI protocol](https://docs.ag-ui.com/). The `@ag-ui/mastra` package exposes your Mastra agents as an AG-UI endpoint, and CopilotKit's React hooks and components consume it. This unlocks a spectrum of experiences on top of ordinary chat: [generative UI, human-in-the-loop, and frontend tools](https://mastra.ai/guides/build-your-ui/copilotkit/generative-ui), plus deploying the same agent to [messaging channels like Slack](https://mastra.ai/guides/build-your-ui/copilotkit/channels).
+
+Visit the [CopilotKit documentation](https://docs.copilotkit.ai/) to learn more about CopilotKit concepts, components, and advanced usage patterns.
+
+> **Info:** For a full-stack integration approach where Mastra runs directly in your Next.js API routes, see the [CopilotKit Quickstart](https://docs.copilotkit.ai/mastra/quickstart) guide.
+
+> **Tip:** Visit Mastra's ["UI Dojo"](https://ui-dojo.mastra.ai/) to see real-world examples of CopilotKit integrated with Mastra.
+
+## Integration guide
+
+Run Mastra as a standalone server and connect your Next.js frontend (with CopilotKit) to its API endpoints.
+
+1. Set up your directory structure. A possible directory structure could look like this:
+
+   ```bash
+   project-root
+   ├── mastra-server
+   │   ├── src
+   │   │   └── mastra
+   │   └── package.json
+   └── my-copilot-app
+       └── package.json
+   ```
+
+   Bootstrap your Mastra server:
+
+   **npm**:
+
+   ```bash
+   npx create-mastra@latest
+   ```
+
+   **pnpm**:
+
+   ```bash
+   pnpm dlx create-mastra@latest
+   ```
+
+   **Yarn**:
+
+   ```bash
+   yarn dlx create-mastra@latest
+   ```
+
+   **Bun**:
+
+   ```bash
+   bun x create-mastra@latest
+   ```
+
+   This command opens an interactive wizard that scaffolds a new Mastra project. Follow the prompts to create your server project.
+
+   Navigate to your newly created Mastra server directory:
+
+   ```bash
+   cd mastra-server # Replace with the actual directory name you provided
+   ```
+
+   You now have a basic Mastra server project ready.
+
+   > **Note:** Ensure that you have set the appropriate environment variables for your LLM provider in the `.env` file.
+
+2. Create a chat route for the CopilotKit frontend by using the `registerCopilotKit()` helper from `@ag-ui/mastra`. Add it to your Mastra project (and its peer dependencies):
+
+   **npm**:
+
+   ```bash
+   npm install @ag-ui/mastra @mastra/client-js @mastra/core @ag-ui/core @ag-ui/client @copilotkit/runtime
+   ```
+
+   **pnpm**:
+
+   ```bash
+   pnpm add @ag-ui/mastra @mastra/client-js @mastra/core @ag-ui/core @ag-ui/client @copilotkit/runtime
+   ```
+
+   **Yarn**:
+
+   ```bash
+   yarn add @ag-ui/mastra @mastra/client-js @mastra/core @ag-ui/core @ag-ui/client @copilotkit/runtime
+   ```
+
+   **Bun**:
+
+   ```bash
+   bun add @ag-ui/mastra @mastra/client-js @mastra/core @ag-ui/core @ag-ui/client @copilotkit/runtime
+   ```
+
+   In your `src/mastra/index.ts` file, register the chat route:
+
+   ```typescript
+   import { Mastra } from '@mastra/core/mastra'
+   import { registerCopilotKit } from '@ag-ui/mastra/copilotkit'
+   // Rest of the imports...
+
+   export const mastra = new Mastra({
+     // Rest of the configuration...
+     server: {
+       cors: {
+         origin: '*',
+         allowMethods: ['*'],
+         allowHeaders: ['*'],
+       },
+       apiRoutes: [
+         registerCopilotKit({
+           path: '/copilotkit',
+           resourceId: 'weatherAgent',
+         }),
+       ],
+     },
+   })
+   ```
+
+   This exposes the agents on your Mastra instance at `/copilotkit` in a CopilotKit-compatible format. The frontend selects which agent to talk to with the `agent` prop shown below. Add the CORS configuration so the CopilotKit frontend can access the Mastra server. For production deployments, restrict CORS origins to your frontend domain.
+
+3. Run the Mastra server using the following command:
+
+   **npm**:
+
+   ```bash
+   npm run dev
+   ```
+
+   **pnpm**:
+
+   ```bash
+   pnpm run dev
+   ```
+
+   **Yarn**:
+
+   ```bash
+   yarn dev
+   ```
+
+   **Bun**:
+
+   ```bash
+   bun run dev
+   ```
+
+   By default, the Mastra server runs on `http://localhost:4111`. Keep this server running while you set up the CopilotKit frontend.
+
+4. Go up one directory to your project root.
+
+   ```bash
+   cd ..
+   ```
+
+   Create a new Next.js project with the name `my-copilot-app`:
+
+   **npm**:
+
+   ```bash
+   npx create-next-app@latest my-copilot-app
+   ```
+
+   **pnpm**:
+
+   ```bash
+   pnpm dlx create-next-app@latest my-copilot-app
+   ```
+
+   **Yarn**:
+
+   ```bash
+   yarn dlx create-next-app@latest my-copilot-app
+   ```
+
+   **Bun**:
+
+   ```bash
+   bun x create-next-app@latest my-copilot-app
+   ```
+
+   Navigate to your newly created Next.js project directory:
+
+   ```bash
+   cd my-copilot-app
+   ```
+
+5. Install the CopilotKit UI packages which you'll use to display a chat interface:
+
+   **npm**:
+
+   ```bash
+   npm install @copilotkit/react-ui @copilotkit/react-core
+   ```
+
+   **pnpm**:
+
+   ```bash
+   pnpm add @copilotkit/react-ui @copilotkit/react-core
+   ```
+
+   **Yarn**:
+
+   ```bash
+   yarn add @copilotkit/react-ui @copilotkit/react-core
+   ```
+
+   **Bun**:
+
+   ```bash
+   bun add @copilotkit/react-ui @copilotkit/react-core
+   ```
+
+   Open the home route of the Next.js app (usually `app/page.tsx` or `src/app/page.tsx`) and replace the existing contents with the following code to set up a basic CopilotKit chat interface:
+
+   ```typescript
+   import { CopilotChat } from '@copilotkit/react-ui'
+   import { CopilotKit } from '@copilotkit/react-core'
+   import '@copilotkit/react-ui/styles.css'
+
+   export default function Home() {
+     return (
+       <CopilotKit runtimeUrl="http://localhost:4111/copilotkit" agent="weatherAgent">
+         <CopilotChat
+           labels={{
+             title: 'Weather Agent',
+             initial: 'Hi! 👋 Ask me about the weather, forecasts, and climate.',
+           }}
+         />
+       </CopilotKit>
+     )
+   }
+   ```
+
+   The `agent` prop names the Mastra agent to route to. It must match a key in your Mastra instance's `agents` map.
+
+6. Ensure both the Mastra server and the CopilotKit frontend are running. Start the Next.js development server:
+
+   **npm**:
+
+   ```bash
+   npm run dev
+   ```
+
+   **pnpm**:
+
+   ```bash
+   pnpm run dev
+   ```
+
+   **Yarn**:
+
+   ```bash
+   yarn dev
+   ```
+
+   **Bun**:
+
+   ```bash
+   bun run dev
+   ```
+
+   Open the app in your browser and chat with your agent.
+
+Your CopilotKit frontend now communicates with a standalone Mastra agent server.
+
+## Chat UI options
+
+`CopilotChat` renders an inline, full-height chat. CopilotKit ships two other drop-in surfaces that share the same props:
+
+- `CopilotSidebar`: a collapsible panel docked to the side of your app.
+- `CopilotPopup`: a floating button that opens a chat window.
+
+Swap the component to change the surface. All three connect through the same `CopilotKit` provider:
+
+```typescript
+import { CopilotSidebar } from '@copilotkit/react-ui'
+import { CopilotKit } from '@copilotkit/react-core'
+import '@copilotkit/react-ui/styles.css'
+
+export default function Home() {
+  return (
+    <CopilotKit runtimeUrl="http://localhost:4111/copilotkit" agent="weatherAgent">
+      <CopilotSidebar
+        labels={{
+          title: 'Weather Agent',
+          initial: 'Hi! 👋 Ask me about the weather.',
+        }}
+      />
+      {/* your app */}
+    </CopilotKit>
+  )
+}
+```
+
+For fully custom chat UIs (bring your own components), see [CopilotKit's headless UI guide](https://docs.copilotkit.ai/).
+
+## App control and interactivity
+
+Beyond rendering agent output as UI (see [generative UI](https://mastra.ai/guides/build-your-ui/copilotkit/generative-ui)), CopilotKit lets the agent act on your application and pause for the user. Both patterns run against the same Mastra setup.
+
+### Frontend tools
+
+Give the agent the ability to act on your app. Register the tool on the frontend with `useFrontendTool`; the `handler` runs in the browser when the agent calls it:
+
+```tsx
+import { CopilotChat } from '@copilotkit/react-ui'
+import { CopilotKit, useFrontendTool } from '@copilotkit/react-core'
+
+function Chat() {
+  useFrontendTool({
+    name: 'colorChangeTool',
+    description: 'Changes the background color',
+    parameters: [
+      { name: 'color', type: 'string', description: 'The color to change to', required: true },
+    ],
+    handler: ({ color }) => {
+      document.body.style.setProperty('--background', color)
+    },
+  })
+
+  return <CopilotChat labels={{ title: 'Background Color Changer' }} />
+}
+
+export default function Page() {
+  return (
+    <CopilotKit runtimeUrl="http://localhost:4111/copilotkit" agent="bgColorAgent">
+      <Chat />
+    </CopilotKit>
+  )
+}
+```
+
+The matching Mastra agent is a normal agent instructed to call `colorChangeTool` with the requested color.
+
+### Human-in-the-loop
+
+Pause the agent mid-run and wait for the user to approve, edit, or reject before continuing. Use `useHumanInTheLoop`: its `render` function receives a `respond` callback, and the agent's run stays suspended until you call it.
+
+```tsx
+import { CopilotChat } from '@copilotkit/react-ui'
+import { CopilotKit, useHumanInTheLoop } from '@copilotkit/react-core'
+import { StepsFeedback } from '@/components/steps-feedback'
+
+function Chat() {
+  useHumanInTheLoop({
+    name: 'generate_task_steps',
+    description: 'Generates a list of steps for the user to perform',
+    parameters: [
+      {
+        name: 'steps',
+        type: 'object[]',
+        attributes: [
+          { name: 'description', type: 'string' },
+          { name: 'status', type: 'string', enum: ['enabled', 'disabled', 'executing'] },
+        ],
+      },
+    ],
+    available: 'enabled',
+    // `respond` resumes the agent with the user's edited selection.
+    render: ({ args, respond, status }) => (
+      <StepsFeedback args={args} respond={respond} status={status} />
+    ),
+  })
+
+  return <CopilotChat labels={{ title: 'Planning Agent' }} />
+}
+
+export default function Page() {
+  return (
+    <CopilotKit runtimeUrl="http://localhost:4111/copilotkit" agent="planningAgent">
+      <Chat />
+    </CopilotKit>
+  )
+}
+```
+
+Inside `StepsFeedback`, let the user toggle steps and then call `respond({ accepted: true, steps })` to resume the agent, or `respond({ accepted: false })` to reject. The agent reads the returned value and continues accordingly. See the full component in the [UI Dojo](https://ui-dojo.mastra.ai/).
+
+The example above uses a client tool: the agent calls `generate_task_steps` and the frontend fulfills it through `respond`. Mastra can also pause on the server, suspending a tool call before it executes so a human approves or supplies input. For that path, see Mastra's [Agent approval](https://mastra.ai/docs/agents/agent-approval) guide for the backend side and CopilotKit's [`useHumanInTheLoop`](https://docs.copilotkit.ai/reference/hooks/useHumanInTheLoop) reference for the frontend.
+
+## Configuration options
+
+Use these `registerCopilotKit()` options for the common integration points:
+
+| Option           | Use it to                                                                                     |
+| ---------------- | --------------------------------------------------------------------------------------------- |
+| `path`           | Set the route path, such as `/copilotkit`.                                                    |
+| `resourceId`     | Scope Mastra memory for conversations.                                                        |
+| `cors`           | Configure per-route CORS in addition to `server.cors`.                                        |
+| `setContext`     | Populate request context before agents run, such as auth or per-user resource IDs.            |
+| `agents`         | Provide pre-constructed AG-UI agents instead of the agents registered on the Mastra instance. |
+| `tracingOptions` | Forward Mastra tracing options to each agent run.                                             |
+
+By default, the endpoint exposes every agent registered on the Mastra instance, and the frontend chooses one with the `agent` prop. Other CopilotKit runtime options are forwarded to the underlying runtime. For example, see [Open-ended generative UI](https://mastra.ai/guides/build-your-ui/copilotkit/generative-ui) for `mcpApps`.
+
+## Deployment
+
+When deploying your Mastra server with CopilotKit, you must exclude `@copilotkit/runtime` from the bundle. This package contains dependencies that aren't compatible with bundling and will cause 500 errors if included.
+
+> **Note:** This issue doesn't occur during development with `mastra dev` since it doesn't require bundling. However, anyone running `mastra build` for deployment will encounter this issue.
+
+Add the `@copilotkit/runtime` package to your bundler externals configuration:
+
+```typescript
+export const mastra = new Mastra({
+  bundler: {
+    externals: ['@copilotkit/runtime'],
+  },
+})
+```

package/.docs/guides/concepts/streaming.md

@@ -31,7 +31,7 @@ for await (const chunk of stream.textStream) {
 
 > **Info:** Visit [Agent.stream()](https://mastra.ai/reference/streaming/agents/stream) for more information.
 
-> **Tip:** For agents that dispatch [background tasks](https://mastra.ai/docs/agents/background-tasks), use [`Agent.streamUntilIdle()`](https://mastra.ai/reference/streaming/agents/streamUntilIdle) to keep the stream open until those tasks complete and the agent has had a chance to respond to their results.
+> **Tip:** For agents that dispatch [background tasks](https://mastra.ai/docs/long-running-agents/background-tasks), use [`Agent.streamUntilIdle()`](https://mastra.ai/reference/streaming/agents/streamUntilIdle) to keep the stream open until those tasks complete and the agent has had a chance to respond to their results.
 
 ### Output from `Agent.stream()`
 

package/.docs/guides/deployment/vercel.md

@@ -105,8 +105,7 @@ export default async function handler(req: VercelRequest, res: VercelResponse) {
   const agent = mastra.getAgent('myAgent')
   const result = await agent.generate([{ role: 'user', content: message }])
 
-  const observability = mastra.getObservability()
-  await observability?.flush()
+  await mastra.observability.flush()
 
   return res.json(result)
 }

package/.docs/guides/guide/signal-provider.md

@@ -14,11 +14,11 @@ The example watches build pipelines in a fake CI service, but the pattern applie
 - An API key from a supported [Model Provider](https://mastra.ai/models)
 - An existing Mastra project. Follow the [installation guide](https://mastra.ai/guides/getting-started/quickstart) if needed.
 
-This guide also assumes you understand [signals](https://mastra.ai/docs/agents/signals) at a high level. For the full API surface, see the [`SignalProvider` reference](https://mastra.ai/reference/signals/signal-provider).
+This guide also assumes you understand [signals](https://mastra.ai/docs/long-running-agents/signals) at a high level. For the full API surface, see the [`SignalProvider` reference](https://mastra.ai/reference/signals/signal-provider).
 
 ## Add notification storage
 
-A signal provider pushes [notification signals](https://mastra.ai/docs/agents/signals) into threads, and notifications require a storage adapter that supports the notifications domain. Configure storage on your Mastra instance.
+A signal provider pushes [notification signals](https://mastra.ai/docs/long-running-agents/signals) into threads, and notifications require a storage adapter that supports the notifications domain. Configure storage on your Mastra instance.
 
 ```typescript
 import { Mastra } from '@mastra/core'
@@ -207,13 +207,13 @@ You can extend this signal provider to:
 
 - Replace `fetchBuildStatus()` with a real API client.
 - Persist subscriptions so they survive a restart, then rehydrate them in [`start()`](https://mastra.ai/reference/signals/signal-provider).
-- Add a [webhook](https://mastra.ai/docs/agents/signal-providers) entry point with [`handleWebhook()`](https://mastra.ai/reference/signals/signal-provider) for push-based sources.
+- Add a [webhook](https://mastra.ai/docs/long-running-agents/signal-providers) entry point with [`handleWebhook()`](https://mastra.ai/reference/signals/signal-provider) for push-based sources.
 - Expose `subscribe` and `unsubscribe` tools with [`getTools()`](https://mastra.ai/reference/signals/signal-provider) so the agent can manage its own subscriptions.
 - Use [`dedupeKey` and `coalesceKey`](https://mastra.ai/reference/agents/agent) when notifications need deduplication or batching.
 
 Learn more:
 
-- [Building signal providers](https://mastra.ai/docs/agents/signal-providers)
-- [Signals](https://mastra.ai/docs/agents/signals)
+- [Building signal providers](https://mastra.ai/docs/long-running-agents/signal-providers)
+- [Signals](https://mastra.ai/docs/long-running-agents/signals)
 - [`SignalProvider` reference](https://mastra.ai/reference/signals/signal-provider)
 - [`WebhookSignalProvider` reference](https://mastra.ai/reference/signals/webhook-signal-provider)

package/.docs/models/environment-variables.md

@@ -56,6 +56,7 @@ List of required environment variables for each model provider and gateway suppo
 | [Inference](https://mastra.ai/models/providers/inference)                                      | `inference/*`              | `INFERENCE_API_KEY`                                                                                   |
 | [IO.NET](https://mastra.ai/models/providers/io-net)                                            | `io-net/*`                 | `IOINTELLIGENCE_API_KEY`                                                                              |
 | [Jiekou.AI](https://mastra.ai/models/providers/jiekou)                                         | `jiekou/*`                 | `JIEKOU_API_KEY`                                                                                      |
+| [Kenari](https://mastra.ai/models/providers/kenari)                                            | `kenari/*`                 | `KENARI_API_KEY`                                                                                      |
 | [Kilo Gateway](https://mastra.ai/models/providers/kilo)                                        | `kilo/*`                   | `KILO_API_KEY`                                                                                        |
 | [Kimi For Coding](https://mastra.ai/models/providers/kimi-for-coding)                          | `kimi-for-coding/*`        | `KIMI_API_KEY`                                                                                        |
 | [KUAE Cloud Coding Plan](https://mastra.ai/models/providers/kuae-cloud-coding-plan)            | `kuae-cloud-coding-plan/*` | `KUAE_API_KEY`                                                                                        |
@@ -114,6 +115,7 @@ List of required environment variables for each model provider and gateway suppo
 | [submodel](https://mastra.ai/models/providers/submodel)                                        | `submodel/*`               | `SUBMODEL_INSTAGEN_ACCESS_KEY`                                                                        |
 | [Synthetic](https://mastra.ai/models/providers/synthetic)                                      | `synthetic/*`              | `SYNTHETIC_API_KEY`                                                                                   |
 | [Tencent Coding Plan (China)](https://mastra.ai/models/providers/tencent-coding-plan)          | `tencent-coding-plan/*`    | `TENCENT_CODING_PLAN_API_KEY`                                                                         |
+| [Tencent Token Plan](https://mastra.ai/models/providers/tencent-token-plan)                    | `tencent-token-plan/*`     | `TENCENT_TOKEN_PLAN_API_KEY`                                                                          |
 | [Tencent TokenHub](https://mastra.ai/models/providers/tencent-tokenhub)                        | `tencent-tokenhub/*`       | `TENCENT_TOKENHUB_API_KEY`                                                                            |
 | [The Grid AI](https://mastra.ai/models/providers/the-grid-ai)                                  | `the-grid-ai/*`            | `THEGRIDAI_API_KEY`                                                                                   |
 | [Tinfoil](https://mastra.ai/models/providers/tinfoil)                                          | `tinfoil/*`                | `TINFOIL_API_KEY`                                                                                     |

package/.docs/models/index.md

@@ -2,7 +2,7 @@
 
 # Model Providers
 
-Mastra provides a unified interface for working with LLMs across multiple providers, giving you access to 4520 models from 137 providers through a single API.
+Mastra provides a unified interface for working with LLMs across multiple providers, giving you access to 4544 models from 139 providers through a single API.
 
 ## Features