diff --git a/.changeset/plugin-api.md b/.changeset/plugin-api.md
new file mode 100644
index 000000000..3d30da75b
--- /dev/null
+++ b/.changeset/plugin-api.md
@@ -0,0 +1,10 @@
+---
+'@tanstack/ai': minor
+'@tanstack/ai-client': minor
+'@tanstack/ai-react': minor
+'@tanstack/ai-solid': minor
+'@tanstack/ai-vue': minor
+'@tanstack/ai-svelte': minor
+---
+
+Add definePlugin (server) and usePlugin/createPlugin (client): declare app-defined plugins — chatPlugin for conversational surfaces, generationPlugin for one-shot work with schema-validated inputs, plus media factories (imagePlugin, videoPlugin, etc.) — behind one endpoint and drive them from one fully typed client hook. Server-side composition is coming via a future workflowPlugin.
diff --git a/.changeset/transaction-verbs.md b/.changeset/transaction-verbs.md
deleted file mode 100644
index 18e39df9a..000000000
--- a/.changeset/transaction-verbs.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-'@tanstack/ai': minor
-'@tanstack/ai-client': minor
-'@tanstack/ai-react': minor
-'@tanstack/ai-solid': minor
-'@tanstack/ai-vue': minor
-'@tanstack/ai-svelte': minor
----
-
-Add defineTransaction (server) and useTransaction/createTransaction (client): declare app-defined verbs — chatVerb for conversational surfaces, verb for one-shot work with schema-validated inputs — behind one endpoint and drive them from one fully typed client hook. A verb's execute can compose sibling verbs via ctx.call into a server-composed transaction: one request runs the whole pipeline, every sub-run streams back live, and a single stop()/disconnect aborts everything. clientTransaction binds a type-only client stub to a server definition without mirroring inert verb callbacks in the browser.
diff --git a/docs/config.json b/docs/config.json
index 79022d30f..4398dccef 100644
--- a/docs/config.json
+++ b/docs/config.json
@@ -309,25 +309,25 @@
       ]
     },
     {
-      "label": "Transaction",
+      "label": "Plugin",
       "children": [
         {
           "label": "Overview",
-          "to": "transaction/overview",
+          "to": "plugin/overview",
           "addedAt": "2026-07-14",
-          "updatedAt": "2026-07-14"
+          "updatedAt": "2026-07-15"
         },
         {
-          "label": "Transactions",
-          "to": "transaction/transactions",
+          "label": "Orchestration",
+          "to": "plugin/plugins",
           "addedAt": "2026-07-14",
-          "updatedAt": "2026-07-14"
+          "updatedAt": "2026-07-15"
         },
         {
           "label": "Scenarios",
-          "to": "transaction/scenarios",
+          "to": "plugin/scenarios",
           "addedAt": "2026-07-14",
-          "updatedAt": "2026-07-14"
+          "updatedAt": "2026-07-15"
         }
       ]
     },
diff --git a/docs/plugin/overview.md b/docs/plugin/overview.md
new file mode 100644
index 000000000..28582ced6
--- /dev/null
+++ b/docs/plugin/overview.md
@@ -0,0 +1,528 @@
+---
+title: Plugin Overview
+id: plugin-overview
+order: 1
+description: "A plugin endpoint declares plugins — app-named units of AI work like `drafting`, `heroImage`, or `narration` — behind ONE request handler, and hands you ONE typed client. Learn the plugin kinds (chat, generation, and the media factories), how the client infers everything from the server definition, and when to reach for a plugin endpoint instead of the single-capability hooks."
+keywords:
+  - tanstack ai
+  - plugin
+  - definePlugin
+  - usePlugin
+  - chatPlugin
+  - generationPlugin
+  - imagePlugin
+  - chat
+  - image generation
+  - text-to-speech
+---
+
+**A plugin endpoint declares a set of _plugins_ — app-named units of AI work — behind a single request handler on the server, and gives you back a single typed client in the browser.** You declare the plugins once with `definePlugin()`; `usePlugin()` returns one object keyed by exactly the plugins you declared, all sharing one connection.
+
+Plugin names are *your* domain language, not a fixed set of library nouns. A blog studio declares `drafting`, `heroImage`, and `narration`; a video tool might declare `storyboard`, `thumbnail`, and `voiceover`. The library doesn't care what you call them — it routes on the names you choose and types the client from them.
+
+`definePlugin()` lives on the `/plugin` subpath of `@tanstack/ai`, and `usePlugin()` on the `/plugin` subpath of `@tanstack/ai-react` (Solid and Vue follow the same pattern; Svelte exports `createPlugin` from `@tanstack/ai-svelte/plugin`) — not the package root.
+
+```ts group=overview-blog
+// lib/blog-studio.ts — define once; the API route only calls `.handler`
+import { chat, generateImage, generateSpeech } from '@tanstack/ai'
+import {
+  chatPlugin,
+  definePlugin,
+  imagePlugin,
+  speechPlugin,
+} from '@tanstack/ai/plugin'
+import { openaiImage, openaiSpeech, openaiText } from '@tanstack/ai-openai'
+
+export const blogPlugin = definePlugin({
+  // A conversational plugin: message history in, streamed chat out.
+  drafting: chatPlugin((req) =>
+    chat({
+      adapter: openaiText('gpt-5.5'),
+      messages: req.messages,
+      systemPrompts: ['You are a seasoned staff writer.'],
+    }),
+  ),
+
+  // A one-shot media plugin: a hero image from a typed prompt.
+  heroImage: imagePlugin((req) =>
+    generateImage({
+      adapter: openaiImage('gpt-image-2'),
+      prompt: req.input.prompt,
+    }),
+  ),
+
+  // A one-shot media plugin: narrate a piece of text.
+  narration: speechPlugin((req) =>
+    generateSpeech({
+      adapter: openaiSpeech('tts-1'),
+      text: req.input.text,
+      voice: 'alloy',
+    }),
+  ),
+})
+```
+
+```ts group=overview-blog
+// routes/api.blog-studio.ts — thin server route
+export const POST = (request: Request) => blogPlugin.handler(request)
+```
+
+That one route now serves conversational drafting, image generation, and narration. On the client, one hook drives all three:
+
+```tsx group=overview-client
+// routes/blog-studio.tsx
+import { fetchServerSentEvents } from '@tanstack/ai-react'
+import { usePlugin } from '@tanstack/ai-react/plugin'
+import type { UIMessage } from '@tanstack/ai-react'
+import { blogPlugin } from '../lib/blog-studio'
+
+function BlogStudio() {
+  const plugin = usePlugin(blogPlugin, {
+    connection: fetchServerSentEvents('/api/blog-studio'),
+  })
+
+  return (
+    <div>
+      <button onClick={() => plugin.drafting.sendMessage('Hello!')}>Send</button>
+      {plugin.drafting.messages.map((message: UIMessage) => (
+        <p key={message.id}>
+          {message.parts.find((part) => part.type === 'text')?.content}
+        </p>
+      ))}
+
+      <button
+        onClick={() =>
+          plugin.heroImage.run({ prompt: 'a red fox in a snowy forest' })
+        }
+      >
+        Generate image
+      </button>
+      {plugin.heroImage.result?.images[0]?.url && (
+        <img src={plugin.heroImage.result.images[0].url} alt="" />
+      )}
+    </div>
+  )
+}
+```
+
+`plugin.drafting` behaves exactly like [`useChat`](../chat/streaming) — streaming, tool calls, and message parts all work the same way. Each one-shot plugin (`plugin.heroImage`, `plugin.narration`, ...) is a typed run/result surface: a `.run(input)` method — its `input` typed by the plugin's schema, its resolved value by the callback's return — plus reactive `.result`, `.isLoading`, `.error`, `.status`, `.stop()`, and `.reset()`.
+
+Both `plugin.<oneShot>.run(input)` and `plugin.<chatPlugin>.sendMessage(...)` **resolve to their result**, so you can chain them with a single `await` — `run` resolves to the plugin's result (or `null`), and `sendMessage` resolves to the structured `final` (when the chat callback set `outputSchema`) or the messages array otherwise. Because each plugin is an independent surface, the client sequences a multi-step pipeline itself — see [Orchestration](./plugins).
+
+## Sharing the definition with the client
+
+`usePlugin` takes the **`definePlugin` value directly** — the same value the server route calls `.handler` on. There is no separate client stub to declare and keep in sync.
+
+```ts group=overview-share
+// lib/blog-studio.ts
+import { chat } from '@tanstack/ai'
+import { chatPlugin, definePlugin } from '@tanstack/ai/plugin'
+import { openaiText } from '@tanstack/ai-openai'
+
+// One value, imported by BOTH the API route (calls `.handler`) and the
+// page (passes it to `usePlugin`).
+export const blogPlugin = definePlugin({
+  drafting: chatPlugin((req) =>
+    chat({ adapter: openaiText('gpt-5.5'), messages: req.messages }),
+  ),
+})
+```
+
+This works because `definePlugin` returns a value that carries, at runtime, the declared plugin **names** and their **kinds** (`chat` vs `one-shot`). `usePlugin` reads those to build the right client surface per plugin — a `ChatClient` for chat plugins, a `GenerationClient` for generation plugins — for whatever names you chose, with no kinds map to hand-maintain. The input/result/tool/schema *types* come from the value's type at compile time.
+
+**Importing the definition into the browser is safe — it never leaks credentials.** `definePlugin()` is inert: none of the callbacks run and no adapter is constructed until a request actually reaches `handler` on the server. API keys are read from the server environment when `handler` runs; they are never present in code. Importing the value ships the (inert) adapter *code* to the client bundle, not any secret, and the callbacks never fire client-side.
+
+The [`blog-studio` example](https://github.com/TanStack/ai/blob/main/examples/ts-react-chat/src/lib/blog-studio.ts) defines the plugin in one shared lib module and imports it from both the route and the page.
+
+## The plugin kinds
+
+### `chatPlugin(callback)` — conversational
+
+The callback receives the parsed chat request (`messages`, `threadId`, `runId`, client-declared `tools`, `forwardedProps`, and the raw `request`) and returns the stream `chat()` produces. On the client it becomes the full chat surface: `sendMessage`, `messages`, tool calls, approvals, structured output.
+
+### `generationPlugin({ input, execute })` — one-shot
+
+`input` is a [Standard Schema](https://standardschema.dev) (Zod, Valibot, ArkType, ...) describing the input; the handler validates every incoming request against it **at runtime** before `execute` runs (a mismatch gets a `400` with the validation issues — the callback never sees a malformed input). `execute` receives the validated `req` (with `input`, `threadId`, `runId`, an abort `signal`, and the raw `request`) and returns a `Promise` of the result, or an `AsyncIterable` of stream chunks. On the client it becomes the `run`/`result` surface.
+
+You can declare **several plugins of the same kind** — including several chat plugins. Each gets its own conversation state, system prompt, and even model:
+
+```ts group=overview-support
+// api/support.ts
+import { chat } from '@tanstack/ai'
+import { chatPlugin, definePlugin } from '@tanstack/ai/plugin'
+import { openaiText } from '@tanstack/ai-openai'
+
+export const supportPlugin = definePlugin({
+  // The main conversation the user sees.
+  primaryChat: chatPlugin((req) =>
+    chat({
+      adapter: openaiText('gpt-5.5'),
+      messages: req.messages,
+      systemPrompts: [
+        'You are a customer-support agent for Acme. Be concise and friendly.',
+      ],
+    }),
+  ),
+  // A second, independent chat surface: condense the ticket for handoff.
+  summaryChat: chatPlugin((req) =>
+    chat({
+      adapter: openaiText('gpt-5.5'),
+      messages: req.messages,
+      systemPrompts: [
+        'Summarize the conversation you are given as a terse handoff note.',
+      ],
+    }),
+  ),
+})
+
+export const POST = (request: Request) => supportPlugin.handler(request)
+```
+
+On the client, `plugin.primaryChat` and `plugin.summaryChat` are two fully independent chat surfaces — separate `messages`, separate `sendMessage` — behind the same endpoint.
+
+The handler discriminates each incoming request by a `plugin` field the client sends, routes it to the matching callback, and streams the result back over Server-Sent Events. Undeclared plugin names get a `400` before any callback runs.
+
+## Media factories
+
+The six **media factories** are `generationPlugin` with the input schema and result type pre-bound for one media activity — so `plugin.<name>.run(input)` is typed input → output end to end without you writing a schema:
+
+| Factory | Input | Result |
+|---|---|---|
+| `imagePlugin` | `{ prompt, numberOfImages?, size?, modelOptions? }` | `ImageGenerationResult` |
+| `videoPlugin` | `{ prompt, size?, duration?, modelOptions? }` | `VideoJobResult` |
+| `audioPlugin` | `{ prompt, duration?, modelOptions? }` | `AudioGenerationResult` |
+| `speechPlugin` | `{ text, voice?, format?, speed?, modelOptions? }` | `TTSResult` |
+| `transcriptionPlugin` | `{ audio, language?, prompt?, responseFormat?, modelOptions? }` | `TranscriptionResult` |
+| `summarizePlugin` | `{ text, maxLength?, style?, focus?, modelOptions? }` | `SummarizationResult` |
+
+Each takes a single callback `(req) => result` — `req.input` is already typed to that media contract. Wire the callback to the matching `generate*` / `summarize` activity:
+
+```ts group=overview-media
+// api/studio.ts
+import {
+  generateImage,
+  generateSpeech,
+  generateTranscription,
+  generateVideo,
+  summarize,
+} from '@tanstack/ai'
+import {
+  definePlugin,
+  imagePlugin,
+  speechPlugin,
+  summarizePlugin,
+  transcriptionPlugin,
+  videoPlugin,
+} from '@tanstack/ai/plugin'
+import {
+  openaiImage,
+  openaiSpeech,
+  openaiSummarize,
+  openaiTranscription,
+  openaiVideo,
+} from '@tanstack/ai-openai'
+
+export const studioPlugin = definePlugin({
+  poster: imagePlugin((req) =>
+    generateImage({ adapter: openaiImage('gpt-image-2'), prompt: req.input.prompt }),
+  ),
+  teaser: videoPlugin((req) =>
+    generateVideo({ adapter: openaiVideo('sora-2'), prompt: req.input.prompt }),
+  ),
+  voiceover: speechPlugin((req) =>
+    generateSpeech({
+      adapter: openaiSpeech('tts-1'),
+      text: req.input.text,
+      voice: req.input.voice ?? 'alloy',
+    }),
+  ),
+  captions: transcriptionPlugin((req) =>
+    generateTranscription({
+      adapter: openaiTranscription('whisper-1'),
+      audio: req.input.audio,
+    }),
+  ),
+  recap: summarizePlugin((req) =>
+    summarize({ adapter: openaiSummarize('gpt-5.5'), text: req.input.text }),
+  ),
+})
+
+export const POST = (request: Request) => studioPlugin.handler(request)
+```
+
+`audioPlugin` follows the same shape for music / sound-effect generation via a provider that supports it. When you need a shape the factories don't cover, drop down to `generationPlugin({ input, execute })` and pass your own schema — the factories are just that call with the media contract filled in.
+
+On the client, each is the same typed run/result surface as any generation plugin:
+
+```tsx group=overview-media-client
+// components/Poster.tsx
+import { generateImage } from '@tanstack/ai'
+import { definePlugin, imagePlugin } from '@tanstack/ai/plugin'
+import { openaiImage } from '@tanstack/ai-openai'
+import { fetchServerSentEvents } from '@tanstack/ai-react'
+import { usePlugin } from '@tanstack/ai-react/plugin'
+
+// The same definition your server route exports — share it from one module in
+// a real app; repeated here so this snippet type-checks on its own.
+const studioPlugin = definePlugin({
+  poster: imagePlugin((req) =>
+    generateImage({
+      adapter: openaiImage('gpt-image-2'),
+      prompt: req.input.prompt,
+    }),
+  ),
+})
+
+function Poster() {
+  const plugin = usePlugin(studioPlugin, {
+    connection: fetchServerSentEvents('/api/studio'),
+  })
+
+  return (
+    <div>
+      {/* `run`'s input is typed to `{ prompt; numberOfImages?; size?; ... }` */}
+      <button onClick={() => plugin.poster.run({ prompt: 'a red fox', size: '1024x1024' })}>
+        Generate
+      </button>
+      {plugin.poster.result?.images[0]?.url && (
+        <img src={plugin.poster.result.images[0].url} alt="" />
+      )}
+    </div>
+  )
+}
+```
+
+## Typed chat plugins: tools and structured output
+
+A chat plugin inherits `useChat`'s full type inference, driven entirely by what its server callback passes to `chat()` — you don't re-declare anything on the client.
+
+**Callback tools auto-type the plugin's `messages`.** Pass `tools` to `chat()` in the callback and the tool-call/result parts on `plugin.<name>.messages` are typed from those tools, with nothing to register on the client:
+
+```tsx
+// components/WeatherChat.tsx
+import { fetchServerSentEvents } from '@tanstack/ai-react'
+import { usePlugin } from '@tanstack/ai-react/plugin'
+import { chat, toolDefinition } from '@tanstack/ai'
+import { chatPlugin, definePlugin } from '@tanstack/ai/plugin'
+import { openaiText } from '@tanstack/ai-openai'
+import { z } from 'zod'
+
+const getWeatherDef = toolDefinition({
+  name: 'get_weather',
+  description: 'Get the current weather for a city',
+  inputSchema: z.object({ city: z.string() }),
+  outputSchema: z.object({ tempF: z.number(), conditions: z.string() }),
+})
+
+const getWeather = getWeatherDef.server(async ({ city }) => {
+  return { tempF: 72, conditions: `Sunny in ${city}` }
+})
+
+// The same definition your server route exports — share it from one module in
+// a real app; repeated here so this snippet type-checks on its own.
+const weatherPlugin = definePlugin({
+  primaryChat: chatPlugin((req) =>
+    chat({
+      adapter: openaiText('gpt-5.5'),
+      messages: req.messages,
+      tools: [getWeather],
+    }),
+  ),
+})
+
+function WeatherChat() {
+  const plugin = usePlugin(weatherPlugin, {
+    connection: fetchServerSentEvents('/api/weather'),
+  })
+
+  const weatherCall = plugin.primaryChat.messages
+    .at(-1)
+    ?.parts.find(
+      (part) => part.type === 'tool-call' && part.name === 'get_weather',
+    )
+
+  return (
+    <div>
+      <button
+        onClick={() =>
+          plugin.primaryChat.sendMessage('What is the weather in Denver?')
+        }
+      >
+        Ask
+      </button>
+      {weatherCall?.type === 'tool-call' && weatherCall.output && (
+        <p>{weatherCall.output.conditions}</p>
+      )}
+    </div>
+  )
+}
+```
+
+No tools option was passed to `usePlugin` — `weatherCall.output` is still narrowed to `{ tempF: number; conditions: string }`, inferred entirely from `tools: [getWeather]` on the server callback.
+
+**Per-plugin `tools` are only for client-executed tools.** A [client tool](../tools/client-tools)'s `.client()` implementation runs in the browser, so its code can't cross the wire. The server callback sees only the tool's *definition* (for typing and to tell the model it exists); the client registers the runtime implementation under the plugin's entry in the flat options. Types still come from the server callback either way:
+
+```tsx
+import { fetchServerSentEvents } from '@tanstack/ai-react'
+import { usePlugin } from '@tanstack/ai-react/plugin'
+import { chat, toolDefinition } from '@tanstack/ai'
+import { chatPlugin, definePlugin } from '@tanstack/ai/plugin'
+import { openaiText } from '@tanstack/ai-openai'
+import { z } from 'zod'
+
+const showToastDef = toolDefinition({
+  name: 'show_toast',
+  description: 'Show a browser notification',
+  inputSchema: z.object({ message: z.string() }),
+})
+
+const showToast = showToastDef.client((input) => {
+  console.log(input.message)
+  return { ok: true }
+})
+
+// The same definition your server route exports — share it from one module in
+// a real app; repeated here so this snippet type-checks on its own.
+const toastPlugin = definePlugin({
+  primaryChat: chatPlugin((req) =>
+    chat({
+      adapter: openaiText('gpt-5.5'),
+      messages: req.messages,
+      tools: [showToastDef], // definition only — the client executes it
+    }),
+  ),
+})
+
+function useToastChat() {
+  return usePlugin(toastPlugin, {
+    connection: fetchServerSentEvents('/api/toast'),
+    // Per-plugin options are keyed by the plugin's declared name.
+    primaryChat: { tools: [showToast] },
+  })
+}
+```
+
+**`outputSchema` → typed `partial` / `final`.** If a chat plugin's callback passes an `outputSchema` to `chat()`, that plugin's surface picks up a progressively-parsed `partial` (`DeepPartial`) and a validated terminal `final` — the same inference [`useChat({ outputSchema })`](../structured-outputs/streaming) gives you:
+
+```tsx
+// components/BlogOutlineForm.tsx
+import { fetchServerSentEvents } from '@tanstack/ai-react'
+import { usePlugin } from '@tanstack/ai-react/plugin'
+import { chat } from '@tanstack/ai'
+import { chatPlugin, definePlugin } from '@tanstack/ai/plugin'
+import { openaiText } from '@tanstack/ai-openai'
+import { z } from 'zod'
+
+const BlogOutlineSchema = z.object({
+  title: z.string(),
+  sections: z.array(z.string()),
+})
+
+// The same definition your server route exports — share it from one module in
+// a real app; repeated here so this snippet type-checks on its own.
+const outlinePlugin = definePlugin({
+  drafting: chatPlugin((req) =>
+    chat({
+      adapter: openaiText('gpt-5.5'),
+      messages: req.messages,
+      outputSchema: BlogOutlineSchema,
+      stream: true,
+    }),
+  ),
+})
+
+function BlogOutlineForm() {
+  const plugin = usePlugin(outlinePlugin, {
+    connection: fetchServerSentEvents('/api/outline'),
+  })
+
+  return (
+    <div>
+      <button
+        onClick={() =>
+          plugin.drafting.sendMessage('Outline a blog post about red foxes')
+        }
+      >
+        Generate outline
+      </button>
+      <p>Title: {plugin.drafting.partial.title ?? '…'}</p>
+      <ul>
+        {plugin.drafting.partial.sections?.map((section, i) => (
+          <li key={i}>{section}</li>
+        ))}
+      </ul>
+      {plugin.drafting.final && (
+        <pre>{JSON.stringify(plugin.drafting.final, null, 2)}</pre>
+      )}
+    </div>
+  )
+}
+```
+
+`partial` and `final` only exist on the type when the callback declares `outputSchema` — omit it and the plugin's surface has no such fields, exactly like `useChat` without `outputSchema`. See [Structured Outputs](../structured-outputs/overview) for the full story.
+
+## Transforming one-shot results
+
+Each generation plugin's entry in the flat options accepts an `onResult` transform. It runs on the raw backend result before it lands on `plugin.<name>.result`, and **its return type becomes that plugin's `result` type**. Use it to reshape a result once, at the hook, instead of deriving it in every component that reads it:
+
+```tsx
+// components/CoverArt.tsx
+import { fetchServerSentEvents } from '@tanstack/ai-react'
+import { usePlugin } from '@tanstack/ai-react/plugin'
+import { generateImage } from '@tanstack/ai'
+import { definePlugin, imagePlugin } from '@tanstack/ai/plugin'
+import { openaiImage } from '@tanstack/ai-openai'
+
+const coverPlugin = definePlugin({
+  heroImage: imagePlugin((req) =>
+    generateImage({
+      adapter: openaiImage('gpt-image-2'),
+      prompt: req.input.prompt,
+    }),
+  ),
+})
+
+function CoverArt() {
+  const plugin = usePlugin(coverPlugin, {
+    connection: fetchServerSentEvents('/api/cover'),
+    // `result` is the raw `ImageGenerationResult`; the return type flows
+    // through to `plugin.heroImage.result`.
+    heroImage: { onResult: (result) => result.images[0]?.url ?? null },
+  })
+
+  return (
+    <div>
+      <button onClick={() => plugin.heroImage.run({ prompt: 'a red fox' })}>
+        Generate
+      </button>
+      {/* `plugin.heroImage.result` is now `string | null`, not the raw result */}
+      {plugin.heroImage.result && <img src={plugin.heroImage.result} alt="" />}
+    </div>
+  )
+}
+```
+
+Return `undefined` (or nothing) from `onResult` to keep the raw result. Each plugin's entry also takes `forwardedProps` to merge extra fields into that plugin's request body. Options are **flat** — one entry per plugin name, alongside the reserved `connection` / `id` / `threadId` keys, which are excluded from the per-name map so a plugin name can never collide with them.
+
+## When should you reach for a plugin endpoint?
+
+A plugin endpoint is not "a better `useChat`." It earns its place when you have **two or more plugins that live on the same surface** — a page, a workflow, a pipeline. If you need exactly one chat box or one image button, the single hook is simpler and there is nothing to gain from the extra layer.
+
+| Your situation | Reach for | Why |
+|---|---|---|
+| One page needs chat **and** images **and** narration | A plugin endpoint | One connection, one typed client, one route to deploy and secure |
+| One plugin's output feeds the next (draft a post → illustrate it → narrate it) | A plugin endpoint, [orchestrated on the client](./plugins) | The client `await`s each plugin and sequences them; same endpoint, same types |
+| The user drives each step by hand (regenerate the image, re-narrate) | The same plugins, called directly from the client | `plugin.heroImage.run(...)` — same endpoint, same types |
+| A page that only sends chat messages | [`useChat`](../chat/streaming) | No second plugin to share — the plugin layer adds nothing |
+| A page that only generates images | [`useGenerateImage`](../media/generation-hooks) | Same — a single hook is the whole story |
+
+**The honest tradeoff:** a plugin endpoint centralizes routing and typing across plugins, but it also couples them into one definition and one endpoint. If two features never appear together and want different auth or system prompts, don't force them into one definition — give each surface its own (see [Scenarios](./scenarios)).
+
+## Which page do I read?
+
+| You want to… | Read |
+|---|---|
+| Sequence plugins into a pipeline — draft a post, then illustrate and narrate it — with client-side orchestration | [Orchestration](./plugins) |
+| Give different pages or features their own plugin sets, routes, and system prompts | [Scenarios](./scenarios) |
+| Understand the underlying chat surface (streaming, tools, message parts) | [Chat: Streaming](../chat/streaming) |
+| Drive a single capability without a plugin endpoint | [Media & Generation Hooks](../media/generation-hooks) |
diff --git a/docs/plugin/plugins.md b/docs/plugin/plugins.md
new file mode 100644
index 000000000..7402fe782
--- /dev/null
+++ b/docs/plugin/plugins.md
@@ -0,0 +1,252 @@
+---
+title: Orchestration
+id: plugin-orchestration
+order: 2
+description: "Sequence plugins into a pipeline from the client: draft a post, then — in parallel — illustrate and narrate it, each derived from the finished draft. One endpoint, one typed client, orchestrated in the browser with plain `await` and `Promise.all`. Each step drives its own reactive surface; each can be retried, cancelled, or re-run on its own."
+keywords:
+  - tanstack ai
+  - plugin
+  - orchestration
+  - pipeline
+  - definePlugin
+  - usePlugin
+  - client-side
+  - Promise.all
+---
+
+**A plugin endpoint hands you one typed client with an independent surface per plugin — so a multi-step pipeline is orchestrated on the _client_, with plain `await` and `Promise.all`.** The client calls each plugin, awaits its result, and feeds it into the next step. There is no server-side composition: each plugin is its own request, so each can be retried, cancelled, or re-run on its own, and the UI fills in as each step finishes.
+
+> **Server-side composition is coming.** A future `workflowPlugin` will let one client call run a whole pipeline as a *single* server request — one abort scope, intermediate values that never round-trip through the browser, live sub-run progress. Until then, orchestrate on the client as shown below; it's the right default for most pipelines anyway, because every step stays independently retryable.
+
+## The worked example: a blog studio
+
+One submission turns a topic into a finished post: draft the article as a typed object, then — in parallel — generate a hero image and record a voice-over, both derived from the validated draft. This is the [`blog-studio` example](https://github.com/TanStack/ai/blob/main/examples/ts-react-chat/src/routes/blog-studio.tsx) from the repository, condensed.
+
+### Server: three independent plugins behind one endpoint
+
+```ts group=orchestration
+// lib/blog-studio.ts
+import { chat, generateImage, generateSpeech } from '@tanstack/ai'
+import {
+  chatPlugin,
+  definePlugin,
+  imagePlugin,
+  speechPlugin,
+} from '@tanstack/ai/plugin'
+import { openaiImage, openaiSpeech, openaiText } from '@tanstack/ai-openai'
+import { z } from 'zod'
+
+export const BlogPostSchema = z.object({
+  title: z.string(),
+  subtitle: z.string(),
+  body: z.string().describe('The full post as Markdown'),
+})
+
+export const blogPlugin = definePlugin({
+  // Conversational plugin: writes the post as a typed object
+  // (structured output + streaming). `sendMessage` resolves to the validated
+  // `BlogPost`, so the client can derive the next steps' inputs from it.
+  drafting: chatPlugin((req) =>
+    chat({
+      adapter: openaiText('gpt-5.5'),
+      messages: req.messages,
+      systemPrompts: ['You are a seasoned staff writer.'],
+      outputSchema: BlogPostSchema,
+      stream: true,
+      threadId: req.threadId,
+      runId: req.runId,
+    }),
+  ),
+
+  // One-shot media plugin: a landscape hero image from a prompt.
+  heroImage: imagePlugin((req) =>
+    generateImage({
+      adapter: openaiImage('gpt-image-2'),
+      prompt: req.input.prompt,
+      size: '1536x1024',
+    }),
+  ),
+
+  // One-shot media plugin: narrate a piece of text.
+  narration: speechPlugin((req) =>
+    generateSpeech({
+      adapter: openaiSpeech('tts-1'),
+      text: req.input.text,
+      voice: 'alloy',
+    }),
+  ),
+})
+```
+
+```ts group=orchestration
+// routes/api.blog-studio.ts
+export const POST = (request: Request) => blogPlugin.handler(request)
+```
+
+### Client: draft, then illustrate and narrate in parallel
+
+The page imports the `blogPlugin` value directly and sequences the steps itself. `drafting.sendMessage(...)` resolves to the validated `BlogPost` (because the callback declared `outputSchema`), so the hero-image prompt and the narration text are derived from the finished draft. The two media plugins then run in parallel:
+
+```tsx group=orchestration-client
+// routes/blog-studio.tsx
+import { chat, generateImage, generateSpeech } from '@tanstack/ai'
+import {
+  chatPlugin,
+  definePlugin,
+  imagePlugin,
+  speechPlugin,
+} from '@tanstack/ai/plugin'
+import { openaiImage, openaiSpeech, openaiText } from '@tanstack/ai-openai'
+import { fetchServerSentEvents } from '@tanstack/ai-react'
+import { usePlugin } from '@tanstack/ai-react/plugin'
+import { z } from 'zod'
+
+const BlogPostSchema = z.object({
+  title: z.string(),
+  subtitle: z.string(),
+  body: z.string(),
+})
+
+// The same definition your server route exports — share it from one module in
+// a real app; repeated here so this snippet type-checks on its own.
+const blogPlugin = definePlugin({
+  drafting: chatPlugin((req) =>
+    chat({
+      adapter: openaiText('gpt-5.5'),
+      messages: req.messages,
+      outputSchema: BlogPostSchema,
+      stream: true,
+    }),
+  ),
+  heroImage: imagePlugin((req) =>
+    generateImage({
+      adapter: openaiImage('gpt-image-2'),
+      prompt: req.input.prompt,
+    }),
+  ),
+  narration: speechPlugin((req) =>
+    generateSpeech({ adapter: openaiSpeech('tts-1'), text: req.input.text }),
+  ),
+})
+
+function BlogStudio() {
+  const plugin = usePlugin(blogPlugin, {
+    connection: fetchServerSentEvents('/api/blog-studio'),
+  })
+  const { drafting, heroImage, narration } = plugin
+
+  // Client-side orchestration: draft the post, then illustrate and narrate in
+  // parallel — both derived from the completed draft.
+  async function orchestrate(topic: string) {
+    drafting.clear()
+    heroImage.reset()
+    narration.reset()
+
+    const draft = await drafting.sendMessage(`Write a blog post about: ${topic}`)
+    if (!draft) return // drafting failed or was stopped before completing
+
+    await Promise.all([
+      heroImage.run({
+        prompt: `Editorial hero image for "${draft.title}". ${draft.subtitle}.`,
+      }),
+      narration.run({ text: draft.body }),
+    ])
+  }
+
+  const isRunning = drafting.isLoading || heroImage.isLoading || narration.isLoading
+
+  return (
+    <div>
+      <button disabled={isRunning} onClick={() => void orchestrate('urban foxes')}>
+        Write the post
+      </button>
+      {isRunning && (
+        <button
+          onClick={() => {
+            drafting.stop()
+            heroImage.stop()
+            narration.stop()
+          }}
+        >
+          Stop
+        </button>
+      )}
+
+      {/* Each step drives its own reactive surface — the UI fills in as work
+          finishes, no shared pipeline state to thread through. */}
+      <ol>
+        <li>Writing: {drafting.isLoading ? 'active' : drafting.final ? 'done' : 'pending'}</li>
+        <li>Illustrating: {heroImage.isLoading ? 'active' : heroImage.result ? 'done' : 'pending'}</li>
+        <li>Recording voice-over: {narration.isLoading ? 'active' : narration.result ? 'done' : 'pending'}</li>
+      </ol>
+
+      {drafting.final && (
+        <article>
+          <h1>{drafting.final.title}</h1>
+          <p>{drafting.final.subtitle}</p>
+          {heroImage.result?.images[0]?.url && (
+            <img src={heroImage.result.images[0].url} alt="" />
+          )}
+        </article>
+      )}
+    </div>
+  )
+}
+```
+
+`drafting.final` is typed as `BlogPost | null` — inferred from the callback's `outputSchema`, nothing re-declared on the client. `heroImage.result` is typed as `ImageGenerationResult | null`, from `imagePlugin`'s result contract. The `await drafting.sendMessage(...)` return value is the same validated `BlogPost`, so `draft.title` / `draft.body` are fully typed when you build the next steps' inputs.
+
+## Each step is independent
+
+Because there is no server-side pipeline, the three plugins are genuinely independent surfaces. That's the whole point of client-side orchestration:
+
+- **Retry a single step.** If narration fails but the draft and image are fine, call `narration.run(...)` again — the other steps keep their results. Nothing re-runs that you didn't ask to.
+- **Re-run on demand.** The same plugins the pipeline used can be driven directly by the user. A "Regenerate hero image" button is just `heroImage.run({ prompt })` again with a prompt derived from the current post — same endpoint, same types, no second definition.
+- **Reorder or skip.** The client decides the sequence. Draft-then-illustrate, illustrate-then-draft, or draft-only — it's ordinary control flow.
+
+## Cancellation
+
+Each surface has its own `stop()` (see the "Stop" button in the example above, which calls `drafting.stop()`, `heroImage.stop()`, and `narration.stop()` together). Because each step is its own request, cancelling is per-step — abort the drafting stream, or the image run, or all of them at once.
+
+Server-side, each plugin's `execute` / chat callback receives the request's `AbortSignal` (as `req.signal`). Pass it into the activities you run so a client `stop()` aborts the upstream provider call too, rather than orphaning it:
+
+```ts
+import { chat } from '@tanstack/ai'
+import { generationPlugin } from '@tanstack/ai/plugin'
+import { openaiText } from '@tanstack/ai-openai'
+import { z } from 'zod'
+
+const tagline = generationPlugin({
+  input: z.object({ product: z.string() }),
+  execute: async (req) => {
+    // `chat()` takes an AbortController; chain it off the request signal so a
+    // client disconnect / stop() aborts this provider call mid-flight.
+    const abortController = new AbortController()
+    req.signal.addEventListener('abort', () => abortController.abort(), {
+      once: true,
+    })
+    const text = await chat({
+      adapter: openaiText('gpt-5.5'),
+      messages: [
+        { role: 'user', content: `Write a tagline for ${req.input.product}` },
+      ],
+      stream: false,
+      abortController,
+    })
+    return { tagline: text }
+  },
+})
+```
+
+## Error behavior
+
+Client-side orchestration means failures are **per step**, and you decide how to compose them:
+
+- A failed step sets that plugin's `.error` and leaves its `.result` at `null`; the other steps keep their results. The UI can show exactly which step failed and offer a retry for just that one.
+- Because you write the sequence, "fail the whole thing" vs. "best-effort" is your choice. `await drafting.sendMessage(...)` resolving to `null` (failed / stopped) is a natural place to bail before the parallel media steps — the example returns early. Wrap an individual `run` in `try`/`catch` to make it best-effort instead.
+- Top-level input to a generation plugin is validated against its schema **before** `execute` runs — a mismatch is a `400` with the validation issues, and the callback never sees a malformed input.
+
+## Next
+
+- [Plugin Overview](./overview) — the plugin kinds, client typing, tools, and structured output.
+- [Scenarios](./scenarios) — one definition per product surface, and choosing between a plugin endpoint, client orchestration, and plain `useChat`.
diff --git a/docs/plugin/scenarios.md b/docs/plugin/scenarios.md
new file mode 100644
index 000000000..ea94d90eb
--- /dev/null
+++ b/docs/plugin/scenarios.md
@@ -0,0 +1,202 @@
+---
+title: Scenarios
+id: plugin-scenarios
+order: 3
+description: "One plugin definition per product surface — a support page with a single chat plugin, a content studio with drafting + image + narration — each with its own route, its own usePlugin, and its own system prompts. Plus the decision guide: a single hook, a plugin endpoint, or client-orchestrated pipeline?"
+keywords:
+  - tanstack ai
+  - plugin
+  - definePlugin
+  - usePlugin
+  - multiple endpoints
+  - system prompt
+  - routes
+---
+
+**One `definePlugin` per product surface.** A plugin definition bundles a set of plugins behind one endpoint. When different pages or features want different plugin sets, different instructions, or different auth, don't stretch a single definition to cover them all — define one per surface. Each gets its own route and its own `usePlugin` on its own page.
+
+A typical app ends up with a few:
+
+| Surface | Plugins | Why its own definition |
+|---|---|---|
+| Customer **support** page | `supportChat` | Tight, support-flavored system prompt; nothing else to expose |
+| **Content studio** page | `drafting` + `heroImage` + `narration` | A creative workflow, orchestrated on the client |
+| Internal **dashboard** | `analystChat` + `weeklyDigest` | Different auth boundary; different instructions |
+
+## Two definitions, two routes
+
+Give each definition its own module and its own handler. A small helper keeps the shared adapter config — the model choice and any provider options — in one place, so the surfaces stay in sync without duplicating it:
+
+```ts
+// api/plugins.ts
+import { chat, generateImage, generateSpeech } from '@tanstack/ai'
+import {
+  chatPlugin,
+  definePlugin,
+  imagePlugin,
+  speechPlugin,
+} from '@tanstack/ai/plugin'
+import { openaiImage, openaiSpeech, openaiText } from '@tanstack/ai-openai'
+
+// One place to change the model / provider options for every surface.
+const textModel = () => openaiText('gpt-5.5')
+
+// Support: a single chat plugin, with a support-flavored system prompt.
+export const supportPlugin = definePlugin({
+  supportChat: chatPlugin((req) =>
+    chat({
+      adapter: textModel(),
+      messages: req.messages,
+      systemPrompts: [
+        'You are a customer-support agent for Acme. Be concise and friendly.',
+      ],
+    }),
+  ),
+})
+
+// Studio: drafting + image + narration, for a creative workflow.
+export const studioPlugin = definePlugin({
+  drafting: chatPlugin((req) =>
+    chat({
+      adapter: textModel(),
+      messages: req.messages,
+      systemPrompts: ['You are a creative copywriter.'],
+    }),
+  ),
+  heroImage: imagePlugin((req) =>
+    generateImage({
+      adapter: openaiImage('gpt-image-2'),
+      prompt: req.input.prompt,
+    }),
+  ),
+  narration: speechPlugin((req) =>
+    generateSpeech({ adapter: openaiSpeech('tts-1'), text: req.input.text }),
+  ),
+})
+
+// Two routes — one per definition.
+export const supportPOST = (request: Request) => supportPlugin.handler(request)
+export const studioPOST = (request: Request) => studioPlugin.handler(request)
+```
+
+In a real app these are two route files — `/api/support` and `/api/studio` — each exporting its own `POST`. The `supportPOST` / `studioPOST` names above just let both live in one snippet.
+
+## Two pages, two clients
+
+Each page calls `usePlugin` against *its own* definition value and *its own* connection. The support page only ever sees `plugin.supportChat`, because that's all `supportPlugin` declared:
+
+```tsx
+// pages/SupportPage.tsx
+import { chat } from '@tanstack/ai'
+import { chatPlugin, definePlugin } from '@tanstack/ai/plugin'
+import { fetchServerSentEvents } from '@tanstack/ai-react'
+import { usePlugin } from '@tanstack/ai-react/plugin'
+import { openaiText } from '@tanstack/ai-openai'
+
+// The same definition your server route exports — share it from one module
+// in a real app; repeated here so this snippet type-checks on its own.
+const supportPlugin = definePlugin({
+  supportChat: chatPlugin((req) =>
+    chat({ adapter: openaiText('gpt-5.5'), messages: req.messages }),
+  ),
+})
+
+function SupportPage() {
+  const plugin = usePlugin(supportPlugin, {
+    connection: fetchServerSentEvents('/api/support'),
+  })
+
+  return (
+    <div>
+      <button
+        onClick={() => plugin.supportChat.sendMessage('My order is late.')}
+      >
+        Ask support
+      </button>
+      {plugin.supportChat.messages.map((message) => (
+        <p key={message.id}>
+          {message.parts.find((part) => part.type === 'text')?.content}
+        </p>
+      ))}
+    </div>
+  )
+}
+```
+
+The studio page points at `/api/studio` and gets `plugin.drafting`, `plugin.heroImage`, and `plugin.narration`:
+
+```tsx
+// pages/StudioPage.tsx
+import { fetchServerSentEvents } from '@tanstack/ai-react'
+import { usePlugin } from '@tanstack/ai-react/plugin'
+import { studioPlugin } from '../api/plugins'
+
+function StudioPage() {
+  const plugin = usePlugin(studioPlugin, {
+    connection: fetchServerSentEvents('/api/studio'),
+  })
+
+  return (
+    <div>
+      <button
+        onClick={() => plugin.drafting.sendMessage('Tagline for a fox plushie?')}
+      >
+        Write copy
+      </button>
+      <button onClick={() => plugin.heroImage.run({ prompt: 'a fox plushie' })}>
+        Generate art
+      </button>
+      {plugin.heroImage.result?.images[0]?.url && (
+        <img src={plugin.heroImage.result.images[0].url} alt="" />
+      )}
+    </div>
+  )
+}
+```
+
+Each page's `plugin` object is typed to exactly its definition's plugins — `SupportPage` has no `plugin.heroImage` to misuse, and there's no way to accidentally call the support route with an image request. Because `usePlugin` takes the `definePlugin` value directly, there is no separate client stub to keep in sync (see [Sharing the definition with the client](./overview#sharing-the-definition-with-the-client)).
+
+## Split, or one broad definition?
+
+Both are valid. Choose by how the plugins actually relate:
+
+**Split into multiple definitions when:**
+
+- **Different product surfaces.** A support widget and a content studio are different features with different users — separate definitions keep their prompts, plugins, and routes independent.
+- **Different plugin sets.** If support never needs image generation, don't expose it there. A narrower definition is a narrower attack surface and a simpler client type.
+- **Different auth or rate-limit boundaries.** Separate routes let you guard `/api/support` and `/api/studio` independently.
+
+**Use one broad definition when:**
+
+- **The plugins are always used together** on the same page or in the same workflow — especially when one plugin's output feeds the next. Siblings must live in the same definition to share one endpoint and one typed client.
+- **They share a system prompt and auth boundary.** If splitting would just duplicate the same configuration twice, keep it as one.
+
+The rule of thumb: **split by surface, not by plugin count.** A single page that happens to use four plugins is one definition; three pages that each use chat are three definitions.
+
+## A single hook, a plugin endpoint, or a client-orchestrated pipeline?
+
+The same feature can be built three ways. Pick by *how many kinds of AI work the surface has* and *who sequences them*:
+
+**Just `useChat` (or a single generation hook)** when there's exactly one kind of AI work on the page. A chat box is a chat box — the plugin layer adds a definition and a routing discriminator and nothing else. Reach for `definePlugin` only once a second plugin shows up.
+
+**A plugin endpoint, driven step by step** when the *user* orchestrates: each step is its own gesture — draft in the chat, then click "illustrate", then click "narrate", regenerate any step at will. Each step is its own request and can be retried independently. This is the loosest coupling: steps can be abandoned halfway, reordered, or repeated.
+
+**A plugin endpoint with a client-orchestrated pipeline** when the steps form a sequence but you kick it off with one action: the client `await`s `drafting.sendMessage(...)`, then fires `heroImage.run(...)` and `narration.run(...)` in `Promise.all`, deriving each input from the finished draft. One endpoint, one typed client, orchestrated in the browser — each step still independently retryable. See [Orchestration](./plugins).
+
+| | `useChat` / single hook | Plugin endpoint, user-driven | Plugin endpoint, client-orchestrated |
+|---|---|---|---|
+| Orchestrated by | — (single step) | The user, click by click | The client, in one handler |
+| Requests | One per interaction | One per step | One per step (sequenced in code) |
+| Cancel | Per request | Per step | Per step; or `stop()` each surface |
+| Failure | Per request | Per step; earlier steps keep their results | Per step; you compose fail-fast vs. best-effort |
+| Best for | A page with one AI feature | Exploratory, editable workflows | One-action pipelines with a definite finished artifact |
+
+> A future `workflowPlugin` will add a fourth option — running the whole pipeline as a *single* server request (one abort scope, intermediate values that stay on the server, live sub-run progress). Until it lands, orchestrate on the client.
+
+These compose: a blog studio declares `drafting`, `heroImage`, and `narration` in one definition — the client runs them as a pipeline for the first pass *and* lets the user drive the same plugins directly for "regenerate" touch-ups. One definition and one endpoint for both.
+
+## Next
+
+- [Plugin Overview](./overview) — the plugin kinds, client typing, and when to reach for a plugin endpoint at all.
+- [Orchestration](./plugins) — sequencing plugins into a pipeline from the client.
+- [Client Tools](../tools/client-tools) — run tool implementations in the browser inside a chat plugin.
diff --git a/docs/transaction/overview.md b/docs/transaction/overview.md
deleted file mode 100644
index cca573a69..000000000
--- a/docs/transaction/overview.md
+++ /dev/null
@@ -1,435 +0,0 @@
----
-title: Transaction Overview
-id: transaction-overview
-order: 1
-description: "A transaction endpoint declares verbs — app-named units of AI work like `drafting`, `heroImage`, or `narration` — behind ONE request handler, and hands you ONE typed client. Learn the two kinds of verbs, how the client infers everything from the server definition, and when to reach for a transaction endpoint instead of the single-capability hooks."
-keywords:
-  - tanstack ai
-  - transaction
-  - defineTransaction
-  - clientTransaction
-  - useTransaction
-  - verbs
-  - chat
-  - image generation
-  - text-to-speech
----
-
-**A transaction endpoint declares _verbs_ — app-named units of AI work — behind a single request handler on the server, and gives you back a single typed client in the browser.** You declare the verbs once with `defineTransaction()`; `useTransaction()` returns one object keyed by exactly the verbs you declared, all sharing one connection. And because a verb can compose its siblings server-side, one client call can run a whole multi-step pipeline as a single request — a [transaction](./transactions).
-
-Verb names are *your* domain language, not a fixed set of library nouns. A blog studio declares `drafting`, `heroImage`, `narration`, and `blogPost`; a video tool might declare `storyboard`, `thumbnail`, and `voiceover`. The library doesn't care what you call them — it routes on the names you choose and types the client from them.
-
-`defineTransaction()` lives on the `/transaction` subpath of `@tanstack/ai`, and `useTransaction()` on the `/transaction` subpath of `@tanstack/ai-react` (Solid and Vue follow the same pattern; Svelte exports `createTransaction` from `@tanstack/ai-svelte/transaction`) — not the package root.
-
-```ts group=overview-1
-// lib/blog-studio.ts — define once; the API route only calls `.handler`
-import { chat, generateImage, generateSpeech } from '@tanstack/ai'
-import { chatVerb, clientTransaction, defineTransaction, verb } from '@tanstack/ai/transaction'
-import { openaiImage, openaiSpeech, openaiText } from '@tanstack/ai-openai'
-import { z } from 'zod'
-
-export const blogTransaction = defineTransaction({
-  // A conversational verb: message history in, streamed chat out.
-  drafting: chatVerb((req) =>
-    chat({
-      adapter: openaiText('gpt-5.5'),
-      messages: req.messages,
-      systemPrompts: ['You are a seasoned staff writer.'],
-    }),
-  ),
-
-  // A one-shot verb: schema-validated input in, typed result out.
-  heroImage: verb({
-    input: z.object({ prompt: z.string() }),
-    execute: ({ input }) =>
-      generateImage({
-        adapter: openaiImage('gpt-image-2'),
-        prompt: input.prompt,
-      }),
-  }),
-
-  narration: verb({
-    input: z.object({ text: z.string() }),
-    execute: ({ input }) =>
-      generateSpeech({
-        adapter: openaiSpeech('tts-1'),
-        text: input.text,
-        voice: 'alloy',
-      }),
-  }),
-})
-
-export const blogTxnDef = clientTransaction<typeof blogTransaction>({
-  drafting: 'chat',
-  heroImage: 'one-shot',
-  narration: 'one-shot',
-})
-```
-
-```ts group=overview-1
-// routes/api.blog-studio.ts — thin server route
-export const POST = (request: Request) => blogTransaction.handler(request)
-```
-
-That one route now serves conversational drafting, image generation, and narration. On the client, one hook drives all three:
-
-```tsx group=overview-client
-// routes/blog-studio.tsx
-import { fetchServerSentEvents } from '@tanstack/ai-react'
-import { useTransaction } from '@tanstack/ai-react/transaction'
-import type { UIMessage } from '@tanstack/ai-react'
-import { blogTxnDef } from '../lib/blog-studio'
-
-function BlogStudio() {
-  const txn = useTransaction(blogTxnDef, {
-    connection: fetchServerSentEvents('/api/blog-studio'),
-  })
-
-  return (
-    <div>
-      <button onClick={() => txn.drafting.sendMessage('Hello!')}>Send</button>
-      {txn.drafting.messages.map((message: UIMessage) => (
-        <p key={message.id}>
-          {message.parts.find((part) => part.type === 'text')?.content}
-        </p>
-      ))}
-
-      <button
-        onClick={() =>
-          txn.heroImage.run({ prompt: 'a red fox in a snowy forest' })
-        }
-      >
-        Generate image
-      </button>
-      {txn.heroImage.result?.images[0]?.url && (
-        <img src={txn.heroImage.result.images[0].url} alt="" />
-      )}
-    </div>
-  )
-}
-```
-
-`txn.drafting` behaves exactly like [`useChat`](../chat/streaming) — streaming, tool calls, and message parts all work the same way. Each one-shot verb (`txn.heroImage`, `txn.narration`, ...) is a typed run/result surface: a `.run(input)` method — its `input` typed by the verb's schema, its resolved value by `execute`'s return — plus reactive `.result`, `.isLoading`, `.error`, `.status`, `.stop()`, `.reset()`, and live [`.subRuns`](./transactions#watching-sub-runs-live).
-
-Both `txn.<oneShot>.run(input)` and `txn.<chatVerb>.sendMessage(...)` **resolve to their result**, so you can chain them with a single `await` — `run` resolves to the verb's result (or `null`), and `sendMessage` resolves to the structured `final` (when the chat callback set `outputSchema`) or the messages array otherwise. When steps should be composed *server-side* instead — one request, one abort scope — declare a verb that calls its siblings with `ctx.call`; that's a [transaction](./transactions).
-
-## The two kinds of verbs
-
-**`chatVerb(callback)` — conversational.** The callback receives the parsed chat request (`messages`, `threadId`, `runId`, client-declared `tools`, `forwardedProps`, and the raw `request`) and returns the stream `chat()` produces. On the client it becomes the full chat surface: `sendMessage`, `messages`, tool calls, approvals, structured output.
-
-**`verb({ input, execute })` — one-shot.** `input` is a [Standard Schema](https://standardschema.dev) (Zod, Valibot, ArkType, ...) describing the input; the handler validates every incoming request against it **at runtime** before `execute` runs (a mismatch gets a `400` with the validation issues — the callback never sees a malformed input). `execute` receives the validated `req` (with `input`, `threadId`, `runId`, an abort `signal`, and the raw `request`) plus a composition context `ctx`, and returns a `Promise` of the result. On the client it becomes the `run`/`result` surface.
-
-You can declare **several verbs of the same kind** — including several chat verbs. Each gets its own conversation state, system prompt, and even model:
-
-```ts group=overview-2
-// api/support.ts
-import { chat } from '@tanstack/ai'
-import { chatVerb, defineTransaction } from '@tanstack/ai/transaction'
-import { openaiText } from '@tanstack/ai-openai'
-
-export const supportTransaction = defineTransaction({
-  // The main conversation the user sees.
-  primaryChat: chatVerb((req) =>
-    chat({
-      adapter: openaiText('gpt-5.5'),
-      messages: req.messages,
-      systemPrompts: [
-        'You are a customer-support agent for Acme. Be concise and friendly.',
-      ],
-    }),
-  ),
-  // A second, independent chat surface: condense the ticket for handoff.
-  summaryChat: chatVerb((req) =>
-    chat({
-      adapter: openaiText('gpt-5.5'),
-      messages: req.messages,
-      systemPrompts: [
-        'Summarize the conversation you are given as a terse handoff note.',
-      ],
-    }),
-  ),
-})
-
-export const POST = (request: Request) => supportTransaction.handler(request)
-```
-
-On the client, `txn.primaryChat` and `txn.summaryChat` are two fully independent chat surfaces — separate `messages`, separate `sendMessage` — behind the same endpoint.
-
-`defineTransaction()` itself is **inert**: none of these callbacks run, and no adapter is constructed, until a request actually reaches `handler`. The handler discriminates each incoming request by a `verb` field the client sends, routes it to the matching callback, and streams the result back over Server-Sent Events. Undeclared verbs get a `400` before any callback runs.
-
-## Sharing the definition with the client
-
-`useTransaction` needs the definition's **type** to build the typed client — verb names and kinds at runtime, input/result/tool/schema types at compile time.
-
-The recommended pattern is to **`defineTransaction` once in a shared module** and export a **`blogTxnDef`** client stub beside it via `clientTransaction<typeof blogTransaction>({ kinds })`. The page imports `blogTxnDef`; the API route imports `blogTransaction` and calls `.handler`. The kinds map is checked exhaustively against the server definition, so drift fails at compile time.
-
-```ts group=overview-sharing
-import { clientTransaction, defineTransaction } from '@tanstack/ai/transaction'
-
-// lib/blog-studio.ts
-export const blogTransaction = defineTransaction({ /* … */ })
-
-export const blogTxnDef = clientTransaction<typeof blogTransaction>({
-  drafting: 'chat',
-  heroImage: 'one-shot',
-  narration: 'one-shot',
-  blogPost: 'one-shot',
-})
-```
-
-When the definition is built per-request inside a handler (for example, to pick adapters from routing props), export a `ReturnType<typeof createTransaction>` type and bind on the client with `import type` — the generic is erased from the bundle:
-
-```tsx
-import type { blogTransaction } from './api/blog-studio'
-import { clientTransaction } from '@tanstack/ai/transaction'
-
-const blogTxnDef = clientTransaction<typeof blogTransaction>({
-  drafting: 'chat',
-  heroImage: 'one-shot',
-  narration: 'one-shot',
-  blogPost: 'one-shot',
-})
-```
-
-When the definition truly has no provider imports, you can also pass one shared `defineTransaction(...)` value to both `handler` and `useTransaction` directly. The [`blog-studio` example](https://github.com/TanStack/ai/blob/main/examples/ts-react-chat/src/lib/blog-studio.ts) defines both exports in one lib module.
-
-## When should you reach for a transaction endpoint?
-
-A transaction endpoint is not "a better `useChat`." It earns its place when you have **two or more verbs that live on the same surface** — a page, a workflow, a pipeline — or when the server should compose steps into a single request. If you need exactly one chat box or one image button, the single hook is simpler and there is nothing to gain from the extra layer.
-
-| Your situation | Reach for | Why |
-|---|---|---|
-| One page needs chat **and** images **and** narration | A transaction endpoint | One connection, one typed client, one route to deploy and secure |
-| One verb's output feeds the next (draft a post → illustrate it → narrate it) as a single unit of work | A [transaction](./transactions) | Server-side composition via `ctx.call`: one request, live sub-run streaming, one abort scope |
-| The user drives each step by hand (regenerate the image, re-narrate) | The same verbs, called directly from the client | `txn.heroImage.run(...)` — same endpoint, same types |
-| A page that only sends chat messages | [`useChat`](../chat/streaming) | No second verb to share — the transaction layer adds nothing |
-| A page that only generates images | [`useGenerateImage`](../media/generation-hooks) | Same — a single hook is the whole story |
-
-**The honest tradeoff:** a transaction endpoint centralizes routing and typing across verbs, but it also couples them into one definition and one endpoint. If two features never appear together and want different auth or system prompts, don't force them into one definition — give each surface its own (see [Scenarios](./scenarios)).
-
-## Typed chat verbs: tools and structured output
-
-A chat verb inherits `useChat`'s full type inference, driven entirely by what its server callback passes to `chat()` — you don't re-declare anything on the client.
-
-**Callback tools auto-type the verb's `messages`.** Pass `tools` to `chat()` in the callback and the tool-call/result parts on `txn.<verb>.messages` are typed from those tools, with nothing to register on the client:
-
-```tsx
-// components/WeatherChat.tsx
-import { fetchServerSentEvents } from '@tanstack/ai-react'
-import { useTransaction } from '@tanstack/ai-react/transaction'
-import { chat, toolDefinition } from '@tanstack/ai'
-import { chatVerb, defineTransaction } from '@tanstack/ai/transaction'
-import { openaiText } from '@tanstack/ai-openai'
-import { z } from 'zod'
-
-const getWeatherDef = toolDefinition({
-  name: 'get_weather',
-  description: 'Get the current weather for a city',
-  inputSchema: z.object({ city: z.string() }),
-  outputSchema: z.object({ tempF: z.number(), conditions: z.string() }),
-})
-
-const getWeather = getWeatherDef.server(async ({ city }) => {
-  return { tempF: 72, conditions: `Sunny in ${city}` }
-})
-
-// The same definition your server route exports — share it from one module in
-// a real app; repeated here so this snippet type-checks on its own.
-const weatherTransaction = defineTransaction({
-  primaryChat: chatVerb((req) =>
-    chat({
-      adapter: openaiText('gpt-5.5'),
-      messages: req.messages,
-      tools: [getWeather],
-    }),
-  ),
-})
-
-function WeatherChat() {
-  const txn = useTransaction(weatherTransaction, {
-    connection: fetchServerSentEvents('/api/weather'),
-  })
-
-  const weatherCall = txn.primaryChat.messages
-    .at(-1)
-    ?.parts.find(
-      (part) => part.type === 'tool-call' && part.name === 'get_weather',
-    )
-
-  return (
-    <div>
-      <button
-        onClick={() =>
-          txn.primaryChat.sendMessage('What is the weather in Denver?')
-        }
-      >
-        Ask
-      </button>
-      {weatherCall?.type === 'tool-call' && weatherCall.output && (
-        <p>{weatherCall.output.conditions}</p>
-      )}
-    </div>
-  )
-}
-```
-
-No tools option was passed to `useTransaction` — `weatherCall.output` is still narrowed to `{ tempF: number; conditions: string }`, inferred entirely from `tools: [getWeather]` on the server callback.
-
-**Per-verb `tools` are only for client-executed tools.** A [client tool](../tools/client-tools)'s `.client()` implementation runs in the browser, so its code can't cross the wire. The server callback sees only the tool's *definition* (for typing and to tell the model it exists); the client registers the runtime implementation under the verb's entry in the nested `verbs` option. Types still come from the server callback either way:
-
-```tsx
-import { fetchServerSentEvents } from '@tanstack/ai-react'
-import { useTransaction } from '@tanstack/ai-react/transaction'
-import { chat, toolDefinition } from '@tanstack/ai'
-import { chatVerb, defineTransaction } from '@tanstack/ai/transaction'
-import { openaiText } from '@tanstack/ai-openai'
-import { z } from 'zod'
-
-const showToastDef = toolDefinition({
-  name: 'show_toast',
-  description: 'Show a browser notification',
-  inputSchema: z.object({ message: z.string() }),
-})
-
-const showToast = showToastDef.client((input) => {
-  console.log(input.message)
-  return { ok: true }
-})
-
-// The same definition your server route exports — share it from one module in
-// a real app; repeated here so this snippet type-checks on its own.
-const toastTransaction = defineTransaction({
-  primaryChat: chatVerb((req) =>
-    chat({
-      adapter: openaiText('gpt-5.5'),
-      messages: req.messages,
-      tools: [showToastDef], // definition only — the client executes it
-    }),
-  ),
-})
-
-function useToastChat() {
-  return useTransaction(toastTransaction, {
-    connection: fetchServerSentEvents('/api/toast'),
-    verbs: {
-      primaryChat: { tools: [showToast] },
-    },
-  })
-}
-```
-
-**`outputSchema` → typed `partial` / `final`.** If a chat verb's callback passes an `outputSchema` to `chat()`, that verb's surface picks up a progressively-parsed `partial` (`DeepPartial`) and a validated terminal `final` — the same inference [`useChat({ outputSchema })`](../structured-outputs/streaming) gives you:
-
-```tsx
-// components/BlogOutlineForm.tsx
-import { fetchServerSentEvents } from '@tanstack/ai-react'
-import { useTransaction } from '@tanstack/ai-react/transaction'
-import { chat } from '@tanstack/ai'
-import { chatVerb, defineTransaction } from '@tanstack/ai/transaction'
-import { openaiText } from '@tanstack/ai-openai'
-import { z } from 'zod'
-
-const BlogOutlineSchema = z.object({
-  title: z.string(),
-  sections: z.array(z.string()),
-})
-
-// The same definition your server route exports — share it from one module in
-// a real app; repeated here so this snippet type-checks on its own.
-const outlineTransaction = defineTransaction({
-  drafting: chatVerb((req) =>
-    chat({
-      adapter: openaiText('gpt-5.5'),
-      messages: req.messages,
-      outputSchema: BlogOutlineSchema,
-      stream: true,
-    }),
-  ),
-})
-
-function BlogOutlineForm() {
-  const txn = useTransaction(outlineTransaction, {
-    connection: fetchServerSentEvents('/api/outline'),
-  })
-
-  return (
-    <div>
-      <button
-        onClick={() =>
-          txn.drafting.sendMessage('Outline a blog post about red foxes')
-        }
-      >
-        Generate outline
-      </button>
-      <p>Title: {txn.drafting.partial.title ?? '…'}</p>
-      <ul>
-        {txn.drafting.partial.sections?.map((section, i) => (
-          <li key={i}>{section}</li>
-        ))}
-      </ul>
-      {txn.drafting.final && (
-        <pre>{JSON.stringify(txn.drafting.final, null, 2)}</pre>
-      )}
-    </div>
-  )
-}
-```
-
-`partial` and `final` only exist on the type when the callback declares `outputSchema` — omit it and the verb's surface has no such fields, exactly like `useChat` without `outputSchema`. See [Structured Outputs](../structured-outputs/overview) for the full story.
-
-## Transforming one-shot results
-
-Each one-shot verb's entry in the nested `verbs` option accepts an `onResult` transform. It runs on the raw backend result before it lands on `txn.<verb>.result`, and **its return type becomes that verb's `result` type**. Use it to reshape a result once, at the hook, instead of deriving it in every component that reads it:
-
-```tsx
-// components/CoverArt.tsx
-import { fetchServerSentEvents } from '@tanstack/ai-react'
-import { useTransaction } from '@tanstack/ai-react/transaction'
-import { generateImage } from '@tanstack/ai'
-import { defineTransaction, verb } from '@tanstack/ai/transaction'
-import { openaiImage } from '@tanstack/ai-openai'
-import { z } from 'zod'
-
-const coverTransaction = defineTransaction({
-  heroImage: verb({
-    input: z.object({ prompt: z.string() }),
-    execute: ({ input }) =>
-      generateImage({
-        adapter: openaiImage('gpt-image-2'),
-        prompt: input.prompt,
-      }),
-  }),
-})
-
-function CoverArt() {
-  const txn = useTransaction(coverTransaction, {
-    connection: fetchServerSentEvents('/api/cover'),
-    verbs: {
-      // `result` is the raw `ImageGenerationResult`; the return type flows
-      // through to `txn.heroImage.result`.
-      heroImage: { onResult: (result) => result.images[0]?.url ?? null },
-    },
-  })
-
-  return (
-    <div>
-      <button onClick={() => txn.heroImage.run({ prompt: 'a red fox' })}>
-        Generate
-      </button>
-      {/* `txn.heroImage.result` is now `string | null`, not the raw result */}
-      {txn.heroImage.result && <img src={txn.heroImage.result} alt="" />}
-    </div>
-  )
-}
-```
-
-Return `undefined` (or nothing) from `onResult` to keep the raw result. Each verb's entry also takes `forwardedProps` to merge extra fields into that verb's request body. The per-verb options are nested under `verbs` (rather than spread at the top level) so your verb names can never collide with `connection` / `id` / `threadId`.
-
-## Which page do I read?
-
-| You want to… | Read |
-|---|---|
-| Compose verbs server-side — one client call runs a whole pipeline as a single request with live progress and one abort scope | [Transactions](./transactions) |
-| Give different pages or features their own verb sets, routes, and system prompts — and decide between user-driven verbs, server-composed transactions, and plain `useChat` | [Scenarios](./scenarios) |
-| Understand the underlying chat surface (streaming, tools, message parts) | [Chat: Streaming](../chat/streaming) |
-| Drive a single capability without a transaction endpoint | [Media & Generation Hooks](../media/generation-hooks) |
diff --git a/docs/transaction/scenarios.md b/docs/transaction/scenarios.md
deleted file mode 100644
index f3cb6fda0..000000000
--- a/docs/transaction/scenarios.md
+++ /dev/null
@@ -1,203 +0,0 @@
----
-title: Scenarios
-id: transaction-scenarios
-order: 3
-description: "One transaction definition per product surface — a support page with a single chat verb, a content studio with drafting + image + narration — each with its own route, its own useTransaction, and its own system prompts. Plus the decision guide: user-driven verbs, server-composed transactions, or plain useChat?"
-keywords:
-  - tanstack ai
-  - transaction
-  - defineTransaction
-  - useTransaction
-  - multiple endpoints
-  - system prompt
-  - routes
----
-
-**One `defineTransaction` per product surface.** A transaction definition bundles a set of verbs behind one endpoint. When different pages or features want different verb sets, different instructions, or different auth, don't stretch a single definition to cover them all — define one per surface. Each gets its own route and its own `useTransaction` on its own page.
-
-A typical app ends up with a few:
-
-| Surface | Verbs | Why its own definition |
-|---|---|---|
-| Customer **support** page | `supportChat` | Tight, support-flavored system prompt; nothing else to expose |
-| **Content studio** page | `drafting` + `heroImage` + `narration` + `blogPost` | A creative workflow, including a server-composed [transaction](./transactions) |
-| Internal **dashboard** | `analystChat` + `weeklyDigest` | Different auth boundary; different instructions |
-
-## Two definitions, two routes
-
-Give each definition its own module and its own handler. A small helper keeps the shared adapter config — the model choice and any provider options — in one place, so the surfaces stay in sync without duplicating it:
-
-```ts
-// api/transactions.ts
-import { chat, generateImage, generateSpeech } from '@tanstack/ai'
-import { chatVerb, defineTransaction, verb } from '@tanstack/ai/transaction'
-import { openaiImage, openaiSpeech, openaiText } from '@tanstack/ai-openai'
-import { z } from 'zod'
-
-// One place to change the model / provider options for every surface.
-const textModel = () => openaiText('gpt-5.5')
-
-// Support: a single chat verb, with a support-flavored system prompt.
-export const supportTransaction = defineTransaction({
-  supportChat: chatVerb((req) =>
-    chat({
-      adapter: textModel(),
-      messages: req.messages,
-      systemPrompts: [
-        'You are a customer-support agent for Acme. Be concise and friendly.',
-      ],
-    }),
-  ),
-})
-
-// Studio: drafting + image + narration, for a creative workflow.
-export const studioTransaction = defineTransaction({
-  drafting: chatVerb((req) =>
-    chat({
-      adapter: textModel(),
-      messages: req.messages,
-      systemPrompts: ['You are a creative copywriter.'],
-    }),
-  ),
-  heroImage: verb({
-    input: z.object({ prompt: z.string() }),
-    execute: ({ input }) =>
-      generateImage({
-        adapter: openaiImage('gpt-image-2'),
-        prompt: input.prompt,
-      }),
-  }),
-  narration: verb({
-    input: z.object({ text: z.string() }),
-    execute: ({ input }) =>
-      generateSpeech({ adapter: openaiSpeech('tts-1'), text: input.text }),
-  }),
-})
-
-// Two routes — one per definition.
-export const supportPOST = (request: Request) =>
-  supportTransaction.handler(request)
-export const studioPOST = (request: Request) =>
-  studioTransaction.handler(request)
-```
-
-In a real app these are two route files — `/api/support` and `/api/studio` — each exporting its own `POST`. The `supportPOST` / `studioPOST` names above just let both live in one snippet.
-
-## Two pages, two clients
-
-Each page calls `useTransaction` against *its own* definition and *its own* connection. The support page only ever sees `txn.supportChat`, because that's all `supportTransaction` declared:
-
-```tsx
-// pages/SupportPage.tsx
-import { chat } from '@tanstack/ai'
-import { chatVerb, defineTransaction } from '@tanstack/ai/transaction'
-import { fetchServerSentEvents } from '@tanstack/ai-react'
-import { useTransaction } from '@tanstack/ai-react/transaction'
-import { openaiText } from '@tanstack/ai-openai'
-
-// The same definition your server route exports — share it from one module
-// in a real app; repeated here so this snippet type-checks on its own.
-const supportTransaction = defineTransaction({
-  supportChat: chatVerb((req) =>
-    chat({ adapter: openaiText('gpt-5.5'), messages: req.messages }),
-  ),
-})
-
-function SupportPage() {
-  const txn = useTransaction(supportTransaction, {
-    connection: fetchServerSentEvents('/api/support'),
-  })
-
-  return (
-    <div>
-      <button onClick={() => txn.supportChat.sendMessage('My order is late.')}>
-        Ask support
-      </button>
-      {txn.supportChat.messages.map((message) => (
-        <p key={message.id}>
-          {message.parts.find((part) => part.type === 'text')?.content}
-        </p>
-      ))}
-    </div>
-  )
-}
-```
-
-The studio page points at `/api/studio` and gets `txn.drafting`, `txn.heroImage`, and `txn.narration`:
-
-```tsx
-// pages/StudioPage.tsx
-import { fetchServerSentEvents } from '@tanstack/ai-react'
-import { useTransaction } from '@tanstack/ai-react/transaction'
-import { studioTransaction } from '../api/transactions'
-
-function StudioPage() {
-  const txn = useTransaction(studioTransaction, {
-    connection: fetchServerSentEvents('/api/studio'),
-  })
-
-  return (
-    <div>
-      <button
-        onClick={() => txn.drafting.sendMessage('Tagline for a fox plushie?')}
-      >
-        Write copy
-      </button>
-      <button
-        onClick={() => txn.heroImage.run({ prompt: 'a fox plushie' })}
-      >
-        Generate art
-      </button>
-      {txn.heroImage.result?.images[0]?.url && (
-        <img src={txn.heroImage.result.images[0].url} alt="" />
-      )}
-    </div>
-  )
-}
-```
-
-Each page's `txn` object is typed to exactly its definition's verbs — `SupportPage` has no `txn.heroImage` to misuse, and there's no way to accidentally call the support route with an image request. (When a route builds its definition inside the handler, bind the client with `clientTransaction` as described in [Sharing the definition with the client](./overview#sharing-the-definition-with-the-client).)
-
-## Split, or one broad definition?
-
-Both are valid. Choose by how the verbs actually relate:
-
-**Split into multiple definitions when:**
-
-- **Different product surfaces.** A support widget and a content studio are different features with different users — separate definitions keep their prompts, verbs, and routes independent.
-- **Different verb sets.** If support never needs image generation, don't expose it there. A narrower definition is a narrower attack surface and a simpler client type.
-- **Different auth or rate-limit boundaries.** Separate routes let you guard `/api/support` and `/api/studio` independently.
-
-**Use one broad definition when:**
-
-- **The verbs are always used together** on the same page or in the same workflow — especially when a composing verb needs to `ctx.call` them: siblings must live in the same definition to be composed into a [transaction](./transactions).
-- **They share a system prompt and auth boundary.** If splitting would just duplicate the same configuration twice, keep it as one.
-
-The rule of thumb: **split by surface, not by verb count.** A single page that happens to use four verbs is one definition; three pages that each use chat are three definitions.
-
-## User-driven verbs, server-composed transactions, or just `useChat`?
-
-The same pipeline can be built three ways. Pick by *who orchestrates* and *what the unit of work is*:
-
-**Just `useChat` (or a single generation hook)** when there's exactly one kind of AI work on the page. A chat box is a chat box — the transaction layer adds a definition, a routing discriminator, and nothing else. Reach for `defineTransaction` only once a second verb shows up.
-
-**User-driven verbs** when the *user* orchestrates: each step is its own gesture — draft in the chat, then click "illustrate", then click "narrate", regenerate any step at will. The client chains awaited returns (`const messages = await txn.drafting.sendMessage(...)`, then `await txn.heroImage.run(...)`), each step is its own request, and each can be retried independently. This is the loosest coupling: steps can be abandoned halfway, reordered, or repeated.
-
-**A server-composed transaction** when the pipeline is *one unit of work* from the user's point of view: one click should produce the finished artifact or fail as a whole. Declare a composing verb and let `ctx.call` run the steps server-side — one request, live sub-run progress, one abort scope, intermediate values that never round-trip through the browser, and a single typed result. See [Transactions](./transactions).
-
-| | `useChat` / single hook | User-driven verbs | Server-composed transaction |
-|---|---|---|---|
-| Orchestrated by | — (single step) | The client, step by step | The server, inside `execute` |
-| Requests | One per interaction | One per step | **One for the whole pipeline** |
-| Cancel | Per request | Per step | One `stop()` aborts everything |
-| Intermediate values | — | Round-trip through the browser | Stay on the server (streamed live as sub-runs) |
-| Failure | Per request | Per step; earlier steps keep their results | The run fails as a unit (unless `execute` catches) |
-| Best for | A page with one AI feature | Exploratory, editable workflows | One-click pipelines with a definite finished artifact |
-
-These compose: the blog studio in [Transactions](./transactions) declares `blogPost` (the one-click transaction) *alongside* `heroImage` and `narration` — the same one-shot verbs the transaction composes are also driven directly by the user for "regenerate" buttons. Server-composed for the first pass, user-driven for the touch-ups, one definition and one endpoint for both.
-
-## Next
-
-- [Transaction Overview](./overview) — the two verb kinds, client typing, and when to reach for a transaction endpoint at all.
-- [Transactions](./transactions) — composing verbs with `ctx.call`: sub-runs, abort semantics, and error behavior.
-- [Client Tools](../tools/client-tools) — run tool implementations in the browser inside a chat verb.
diff --git a/docs/transaction/transactions.md b/docs/transaction/transactions.md
deleted file mode 100644
index 6e2d0cdcc..000000000
--- a/docs/transaction/transactions.md
+++ /dev/null
@@ -1,273 +0,0 @@
----
-title: Transactions
-id: transaction-transactions
-order: 2
-description: "Compose verbs server-side with ctx.call: one client call runs a whole pipeline — draft a post, illustrate it, narrate it — as a SINGLE request, with every step streamed back live as a sub-run and one abort scope covering the lot. Learn the sub-run protocol, cancellation semantics, and error behavior."
-keywords:
-  - tanstack ai
-  - transaction
-  - ctx.call
-  - sub-runs
-  - defineTransaction
-  - clientTransaction
-  - useTransaction
-  - abort
-  - cancellation
----
-
-**A transaction is a one-shot verb that composes its sibling verbs server-side.** Its `execute` receives a context `ctx`, and `ctx.call(siblingVerb, input)` runs that sibling *inside the same request* — the sub-run's stream is forwarded live to the client as tagged events, and the `await` resolves with the sibling's result for the next step to consume. One client call, one HTTP request, one abort scope for the entire pipeline.
-
-This is the closest thing to transactional semantics this domain allows: you can't roll back tokens a model already generated, but you *can* treat the pipeline as a single unit of work — one call starts it, live progress streams out of it, cancelling it halts the orchestration and aborts the in-flight provider work, and the UI unwinds its partial state.
-
-## The worked example: a blog studio
-
-One click turns a topic into a finished post: draft the article as a typed object, then — in parallel — generate a hero image and record a voice-over, both derived from the validated draft. This is the [`blog-studio` example](https://github.com/TanStack/ai/blob/main/examples/ts-react-chat/src/routes/blog-studio.tsx) from the repository, condensed.
-
-### Server: a `blogPost` verb that composes its siblings
-
-```ts group=transactions
-// lib/blog-studio.ts
-import { chat, generateImage, generateSpeech } from '@tanstack/ai'
-import { chatVerb, defineTransaction, verb } from '@tanstack/ai/transaction'
-import { openaiImage, openaiSpeech, openaiText } from '@tanstack/ai-openai'
-import { z } from 'zod'
-
-export const BlogPostSchema = z.object({
-  title: z.string(),
-  subtitle: z.string(),
-  body: z.string().describe('The full post as Markdown'),
-})
-
-// Conversational verb: writes the post as a typed object
-// (structured output + streaming).
-const drafting = chatVerb((req) =>
-  chat({
-    adapter: openaiText('gpt-5.5'),
-    messages: req.messages,
-    systemPrompts: ['You are a seasoned staff writer.'],
-    outputSchema: BlogPostSchema,
-    stream: true,
-    threadId: req.threadId,
-    runId: req.runId,
-  }),
-)
-
-// One-shot verb: a hero image from a prompt.
-const heroImage = verb({
-  input: z.object({ prompt: z.string() }),
-  execute: ({ input }) =>
-    generateImage({
-      adapter: openaiImage('gpt-image-2'),
-      prompt: input.prompt,
-      size: '1536x1024',
-    }),
-})
-
-// One-shot verb: narrate a piece of text.
-const narration = verb({
-  input: z.object({ text: z.string() }),
-  execute: ({ input }) =>
-    generateSpeech({
-      adapter: openaiSpeech('tts-1'),
-      text: input.text,
-      voice: 'alloy',
-    }),
-})
-
-// The transaction: one client call composes the three verbs above,
-// entirely server-side.
-const blogPost = verb({
-  input: z.object({ topic: z.string() }),
-  execute: async ({ input }, ctx) => {
-    // 1. Draft the post. `ctx.call` on a chat verb resolves with the
-    //    accumulated text and the structured output; re-validate it so a
-    //    half-finished draft fails the run with a clear error.
-    const draft = await ctx.call(drafting, [
-      { role: 'user', content: `Write a blog post about: ${input.topic}` },
-    ])
-    const parsed = BlogPostSchema.safeParse(draft.structured)
-    if (!parsed.success) {
-      throw new Error(
-        `Drafting did not produce a valid blog post: ${parsed.error.message}`,
-      )
-    }
-    const post = parsed.data
-
-    // 2. Illustrate and narrate in parallel, both derived from the
-    //    validated draft.
-    const [hero, audio] = await Promise.all([
-      ctx.call(heroImage, {
-        prompt: `Editorial hero image for "${post.title}". ${post.subtitle}.`,
-      }),
-      ctx.call(narration, { text: post.body }),
-    ])
-
-    // 3. The return value becomes the run's final result on the client
-    //    (`txn.blogPost.result`).
-    return { post, hero, audio }
-  },
-})
-
-export const blogTransaction = defineTransaction({
-  drafting,
-  heroImage,
-  narration,
-  blogPost,
-})
-```
-
-```ts group=transactions
-// routes/api.blog-studio.ts
-export const POST = (request: Request) => blogTransaction.handler(request)
-```
-
-`ctx.call` has two shapes, both typed end to end:
-
-- **`ctx.call(oneShotVerb, input)`** validates `input` against the sibling's schema, runs its `execute`, and resolves with its result — typed as that verb's result type.
-- **`ctx.call(chatVerbObj, messages)`** runs the chat verb's callback to completion server-side and resolves with `{ text, structured }` — the accumulated assistant text plus the structured output when the callback declared an `outputSchema`. `structured` arrives as `unknown`; re-validate it with `safeParse` (as above) rather than trusting the shape.
-
-### Client: one call, live progress, typed result
-
-```tsx group=transactions
-// routes/blog-studio.tsx
-import { fetchServerSentEvents } from '@tanstack/ai-react'
-import { useTransaction } from '@tanstack/ai-react/transaction'
-import type { TransactionSubRun } from '@tanstack/ai-client/transaction'
-import { blogTxnDef } from '../lib/blog-studio'
-
-function BlogStudio() {
-  const txn = useTransaction(blogTxnDef, {
-    connection: fetchServerSentEvents('/api/blog-studio'),
-  })
-
-  const { blogPost } = txn
-  // One entry per `ctx.call` the server made, keyed by verb name.
-  const draftingRun = blogPost.subRuns.find(
-    (run: TransactionSubRun) => run.verb === 'drafting',
-  )
-  const heroRun = blogPost.subRuns.find(
-    (run: TransactionSubRun) => run.verb === 'heroImage',
-  )
-  const narrationRun = blogPost.subRuns.find(
-    (run: TransactionSubRun) => run.verb === 'narration',
-  )
-
-  return (
-    <div>
-      <button
-        disabled={blogPost.isLoading}
-        onClick={() => {
-          // ONE call. The server composes drafting → (illustrate ∥ narrate)
-          // and streams every sub-run live into `blogPost.subRuns`; the final
-          // `{ post, hero, audio }` lands in `blogPost.result`.
-          void blogPost.run({ topic: 'The quiet comeback of urban foxes' })
-        }}
-      >
-        Write the post
-      </button>
-      {blogPost.isLoading && (
-        <button onClick={() => blogPost.stop()}>Stop</button>
-      )}
-
-      <ol>
-        <li>Writing: {draftingRun?.status ?? 'pending'}</li>
-        <li>Illustrating: {heroRun?.status ?? 'pending'}</li>
-        <li>Recording voice-over: {narrationRun?.status ?? 'pending'}</li>
-      </ol>
-
-      {blogPost.result && (
-        <article>
-          <h1>{blogPost.result.post.title}</h1>
-          <p>{blogPost.result.post.subtitle}</p>
-        </article>
-      )}
-      {blogPost.error && <p>{blogPost.error.message}</p>}
-    </div>
-  )
-}
-```
-
-`blogPost.result` is typed as `{ post, hero, audio } | null` — inferred from `execute`'s return type on the server definition, nothing re-declared on the client. The lib module exports a `blogTxnDef` stub via `clientTransaction` so the page never duplicates verb callbacks (see [Sharing the definition with the client](./overview#sharing-the-definition-with-the-client)).
-
-And because `heroImage` and `narration` are ordinary declared verbs, the *same* client can also drive them directly — `txn.heroImage.run({ prompt })` for a "regenerate hero image" button — without another endpoint or another definition. Server-composed and user-driven are two ways to call the same verbs.
-
-## Watching sub-runs live
-
-Everything a transaction does streams back over the single SSE response. Each `ctx.call` is wrapped in tagged `CUSTOM` events (the names live on `TRANSACTION_EVENTS`, exported from `@tanstack/ai/transaction`):
-
-| Event | When |
-|---|---|
-| `transaction:sub-run:started` | A `ctx.call` began; carries `{ runId, parentRunId, verb, index }` |
-| `transaction:sub-run:chunk` | A chunk of the sub-run's own stream, forwarded live |
-| `transaction:sub-run:result` | The sub-run completed; carries its `result` |
-| `transaction:sub-run:error` | The sub-run threw; carries its `message` |
-
-You rarely touch these directly — the client demultiplexes them into `txn.<verb>.subRuns`, an array of live sub-run states in server start order:
-
-```ts
-interface TransactionSubRun {
-  runId: string
-  verb: string // the sub-verb's name in the definition
-  index: number // 0-based server start order
-  status: 'running' | 'success' | 'error'
-  result: unknown // set once the sub-run completes
-  text: string // accumulated streamed text, for chat-verb sub-runs
-  error?: string
-}
-```
-
-For chat-verb sub-runs, `text` accumulates the streamed assistant text as it arrives — a live word count or progress indicator falls out for free. One caveat from the worked example: when the chat callback declares an `outputSchema`, the streamed text is the structured output's partial JSON, so show progress by length (`${run.text.length} chars drafted`) rather than rendering it verbatim. The array resets when a new run starts, and `subRuns` is empty for verbs that don't compose siblings.
-
-The verb's own return value travels as a terminal `generation:result` event and lands in `txn.<verb>.result` — the same place it lands for a simple, non-composing verb.
-
-## One request, one abort scope
-
-Because the entire pipeline is a single HTTP request, cancellation is one gesture end to end:
-
-- **Client:** `txn.blogPost.stop()` aborts the fetch. The reactive surfaces unwind — `isLoading` drops, in-flight sub-runs stop updating.
-- **Server:** the aborted request trips `req.signal` (also available as `ctx.signal` — both are the request's `AbortSignal`). `ctx.call` refuses to start new sub-runs once the signal is aborted, and chat sub-runs stop consuming their stream.
-- **Providers:** pass the signal into the activities your verbs run so the upstream provider calls are cancelled too, not just orphaned:
-
-```ts
-import { chat } from '@tanstack/ai'
-import { verb } from '@tanstack/ai/transaction'
-import { openaiText } from '@tanstack/ai-openai'
-import { z } from 'zod'
-
-const tagline = verb({
-  input: z.object({ product: z.string() }),
-  execute: async (req) => {
-    // `chat()` takes an AbortController; chain it off the request signal so
-    // a client disconnect / stop() aborts this provider call mid-flight.
-    const abortController = new AbortController()
-    req.signal.addEventListener('abort', () => abortController.abort(), {
-      once: true,
-    })
-    const text = await chat({
-      adapter: openaiText('gpt-5.5'),
-      messages: [
-        { role: 'user', content: `Write a tagline for ${req.input.product}` },
-      ],
-      stream: false,
-      abortController,
-    })
-    return { tagline: text }
-  },
-})
-```
-
-The same applies inside a composing verb: `ctx.signal` is the one signal for the whole transaction, so every provider call at any depth hangs off the same scope. Cancel once, and the orchestration halts, in-flight sub-work aborts, and nothing keeps burning tokens in the background.
-
-## Error behavior
-
-A transaction fails as a unit:
-
-- If a sub-run throws (or a `ctx.call` input fails its sibling's schema validation), the server emits `transaction:sub-run:error` for that sub-run and the error propagates out of `ctx.call` into your `execute` — unless you catch it. An uncaught error fails the whole run: the stream terminates with a `RUN_ERROR` event instead of `RUN_FINISHED`.
-- On the client, the failed step shows up in `subRuns` with `status: 'error'` and its `error` message, `txn.<verb>.error` is set, and `txn.<verb>.result` stays `null`. Completed sub-runs keep their `success` status, so the UI can show exactly which step failed.
-- Want a step to be best-effort instead? Wrap that `ctx.call` in `try`/`catch` inside `execute` and return a partial result — the run then finishes normally. The example above deliberately does *not* do this: a post without its image is a failed post.
-- Validation failures of the *top-level* input (the object passed to `txn.<verb>.run(...)`) never reach `execute` at all — the handler responds `400` with the schema issues.
-
-## Next
-
-- [Transaction Overview](./overview) — the two verb kinds, client typing, tools, and structured output.
-- [Scenarios](./scenarios) — one definition per product surface, and choosing between user-driven verbs, server-composed transactions, and plain `useChat`.
diff --git a/examples/ts-react-chat/src/lib/blog-studio.ts b/examples/ts-react-chat/src/lib/blog-studio.ts
index 3f9ad3afe..d5354731c 100644
--- a/examples/ts-react-chat/src/lib/blog-studio.ts
+++ b/examples/ts-react-chat/src/lib/blog-studio.ts
@@ -1,18 +1,17 @@
 import { chat, generateImage, generateSpeech } from '@tanstack/ai'
 import {
-  chatVerb,
-  clientTransaction,
-  defineTransaction,
-  verb,
-} from '@tanstack/ai/transaction'
+  chatPlugin,
+  definePlugin,
+  imagePlugin,
+  speechPlugin,
+} from '@tanstack/ai/plugin'
 import { openaiImage, openaiSpeech, openaiText } from '@tanstack/ai-openai'
 import { z } from 'zod'
 
 /**
- * The shape a blog post is drafted into. The `drafting` chat verb declares
- * this as its `outputSchema`, so its structured output is schema-validated —
- * both when the client talks to it directly and when the `blogPost`
- * transaction runs it server-side via `ctx.call`.
+ * The shape a blog post is drafted into. The `drafting` chat plugin declares
+ * this as its `outputSchema`, so its structured output is schema-validated and
+ * the client's `drafting.sendMessage(topic)` resolves to a typed `BlogPost`.
  */
 export const BlogPostSchema = z.object({
   title: z.string().describe('A punchy, editorial blog post title'),
@@ -34,9 +33,9 @@ export const BLOG_STUDIO_SYSTEM_PROMPT =
   'paragraphs. Be vivid and concrete; avoid filler and clichés.'
 
 /**
- * Build the hero-image prompt from a drafted post. Used by the server-side
- * `blogPost` transaction and by the client's "Regenerate hero image" button,
- * so both produce the same style of illustration.
+ * Build the hero-image prompt from a drafted post. Called on the client to
+ * derive the `heroImage` plugin's input from the finished draft, so the
+ * initial illustration and the "Regenerate hero image" button match.
  */
 export function heroPromptFor(post: BlogPost): string {
   return (
@@ -49,8 +48,9 @@ export function heroPromptFor(post: BlogPost): string {
 /**
  * Prepare the post body for narration: strip Markdown so TTS doesn't read the
  * syntax aloud, and cap the length at a sentence boundary (OpenAI TTS rejects
- * input over 4096 characters, and long posts easily exceed it). Used by the
- * server-side `blogPost` transaction and by the client's "Re-narrate" button.
+ * input over 4096 characters, and long posts easily exceed it). Called on the
+ * client to derive the `narration` plugin's input for both the initial
+ * voice-over and the "Re-narrate" button.
  */
 export function forNarration(markdown: string, max = 4000): string {
   const plain = markdown
@@ -72,92 +72,49 @@ export function forNarration(markdown: string, max = 4000): string {
   return (boundary > max / 2 ? clipped.slice(0, boundary + 1) : clipped).trim()
 }
 
-// Conversational verb: writes the post as a typed object
-// (structured output + streaming).
-const drafting = chatVerb((req) =>
-  chat({
-    adapter: openaiText('gpt-5.5'),
-    messages: req.messages,
-    systemPrompts: [BLOG_STUDIO_SYSTEM_PROMPT],
-    outputSchema: BlogPostSchema,
-    stream: true,
-    threadId: req.threadId,
-    runId: req.runId,
-  }),
-)
+/**
+ * The blog-studio plugin: three independent plugins behind one endpoint.
+ *
+ * - `drafting` is a chat plugin that streams the post as structured output
+ *   (schema-validated against {@link BlogPostSchema}).
+ * - `heroImage` / `narration` are one-shot media plugins (image + TTS).
+ *
+ * There is no server-side composition: the client sequences these itself —
+ * `drafting.sendMessage(topic)`, then `heroImage.run(...)` and
+ * `narration.run(...)` in parallel (see the route). `definePlugin` is inert
+ * until `handler(request)` runs, so importing this module into the browser
+ * ships only the (inert) adapter code, never the API keys.
+ */
+export const blogPlugin = definePlugin({
+  // Conversational plugin: writes the post as a typed object
+  // (structured output + streaming).
+  drafting: chatPlugin((req) =>
+    chat({
+      adapter: openaiText('gpt-5.5'),
+      messages: req.messages,
+      systemPrompts: [BLOG_STUDIO_SYSTEM_PROMPT],
+      outputSchema: BlogPostSchema,
+      stream: true,
+      threadId: req.threadId,
+      runId: req.runId,
+    }),
+  ),
 
-// One-shot verb: a landscape hero / OG image from a prompt.
-const heroImage = verb({
-  input: z.object({ prompt: z.string() }),
-  execute: ({ input }) =>
+  // One-shot media plugin: a landscape hero / OG image from a prompt.
+  heroImage: imagePlugin((req) =>
     generateImage({
       adapter: openaiImage('gpt-image-2'),
-      prompt: input.prompt,
+      prompt: req.input.prompt,
       size: '1536x1024',
     }),
-})
+  ),
 
-// One-shot verb: narrate a piece of text.
-const narration = verb({
-  input: z.object({ text: z.string() }),
-  execute: ({ input }) =>
+  // One-shot media plugin: narrate a piece of text.
+  narration: speechPlugin((req) =>
     generateSpeech({
       adapter: openaiSpeech('tts-1'),
-      text: input.text,
+      text: req.input.text,
       voice: 'alloy',
     }),
-})
-
-// The transaction: one client call composes the three verbs above,
-// entirely server-side. Each `ctx.call` streams back to the client as
-// a live, tagged sub-run of this single request — and the whole
-// pipeline shares one abort scope (client disconnect / stop() cancels
-// everything).
-const blogPost = verb({
-  input: z.object({ topic: z.string() }),
-  execute: async ({ input }, ctx) => {
-    // 1. Draft the post. `ctx.call` on a chat verb resolves with the
-    //    accumulated text and the structured output; re-validate it so
-    //    a half-finished draft fails the run with a clear error.
-    const draft = await ctx.call(drafting, [
-      {
-        role: 'user',
-        content: `Write a blog post about: ${input.topic}`,
-      },
-    ])
-    const parsed = BlogPostSchema.safeParse(draft.structured)
-    if (!parsed.success) {
-      throw new Error(
-        `Drafting did not produce a valid blog post: ${parsed.error.message}`,
-      )
-    }
-    const post = parsed.data
-
-    // 2. Illustrate and narrate in parallel, both derived from the
-    //    validated draft.
-    const [hero, audio] = await Promise.all([
-      ctx.call(heroImage, { prompt: heroPromptFor(post) }),
-      ctx.call(narration, { text: forNarration(post.body) }),
-    ])
-
-    // 3. The return value becomes the run's final result on the
-    //    client (`txn.blogPost.result`).
-    return { post, hero, audio }
-  },
-})
-
-/** Server-side transaction definition — wire to `blogTransaction.handler`. */
-export const blogTransaction = defineTransaction({
-  drafting,
-  heroImage,
-  narration,
-  blogPost,
-})
-
-/** Client-side type binding — pass to `useTransaction`. */
-export const blogTxnDef = clientTransaction<typeof blogTransaction>({
-  drafting: 'chat',
-  heroImage: 'one-shot',
-  narration: 'one-shot',
-  blogPost: 'one-shot',
+  ),
 })
diff --git a/examples/ts-react-chat/src/routes/api.blog-studio.ts b/examples/ts-react-chat/src/routes/api.blog-studio.ts
index 3b5481cbc..259034883 100644
--- a/examples/ts-react-chat/src/routes/api.blog-studio.ts
+++ b/examples/ts-react-chat/src/routes/api.blog-studio.ts
@@ -1,14 +1,14 @@
 import { createFileRoute } from '@tanstack/react-router'
-import { blogTransaction } from '../lib/blog-studio'
+import { blogPlugin } from '../lib/blog-studio'
 
 export const Route = createFileRoute('/api/blog-studio')({
   server: {
     handlers: {
-      // One endpoint, four verbs. `defineTransaction` is inert until
+      // One endpoint, three plugins. `definePlugin` is inert until
       // `handler(request)` runs, at which point it parses the AG-UI request,
-      // routes by the `verb` discriminator the client sends, and streams the
+      // routes by the `plugin` discriminator the client sends, and streams the
       // result back over SSE.
-      POST: ({ request }) => blogTransaction.handler(request),
+      POST: ({ request }) => blogPlugin.handler(request),
     },
   },
 })
diff --git a/examples/ts-react-chat/src/routes/blog-studio.tsx b/examples/ts-react-chat/src/routes/blog-studio.tsx
index aa3e9fac6..799c15382 100644
--- a/examples/ts-react-chat/src/routes/blog-studio.tsx
+++ b/examples/ts-react-chat/src/routes/blog-studio.tsx
@@ -1,6 +1,6 @@
 import { createFileRoute } from '@tanstack/react-router'
 import { fetchServerSentEvents } from '@tanstack/ai-react'
-import { useTransaction } from '@tanstack/ai-react/transaction'
+import { usePlugin } from '@tanstack/ai-react/plugin'
 import ReactMarkdown from 'react-markdown'
 import remarkGfm from 'remark-gfm'
 import {
@@ -15,7 +15,7 @@ import {
   Volume2,
   Wand2,
 } from 'lucide-react'
-import { blogTxnDef, forNarration, heroPromptFor } from '../lib/blog-studio'
+import { blogPlugin, forNarration, heroPromptFor } from '../lib/blog-studio'
 import type { ImageGenerationResult, TTSResult } from '@tanstack/ai'
 import type { FormEvent, ReactNode } from 'react'
 
@@ -25,18 +25,17 @@ export const Route = createFileRoute('/blog-studio')({
 
 type StepState = 'pending' | 'active' | 'done' | 'failed'
 
-// Map a live sub-run's status onto a step state. `undefined` means the
-// server hasn't started that sub-run yet.
-function subRunToStep(
-  status: 'running' | 'success' | 'error' | undefined,
-): StepState {
-  return status === 'running'
-    ? 'active'
-    : status === 'success'
-      ? 'done'
-      : status === 'error'
-        ? 'failed'
-        : 'pending'
+// Derive a step's UI state from a one-shot plugin surface (heroImage /
+// narration): active while running, failed on error, done once a result lands.
+function genStep(surface: {
+  isLoading: boolean
+  error: Error | undefined
+  result: unknown
+}): StepState {
+  if (surface.isLoading) return 'active'
+  if (surface.error) return 'failed'
+  if (surface.result) return 'done'
+  return 'pending'
 }
 
 // The image result carries either a URL or base64 data, provider-dependent.
@@ -55,99 +54,92 @@ function audioSrcOf(result: TTSResult | null): string | null {
   return `data:${result.contentType ?? 'audio/mpeg'};base64,${result.audio}`
 }
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null
-}
-
-// The drafting sub-run's live `partial` is typed `unknown` (progressively
-// parsed structured output). Narrow it to the blog-post fields without an
-// `as` cast — each field may be absent or half-written while streaming.
-function asBlogPostDraft(partial: unknown): {
-  title?: string
-  subtitle?: string
-  body?: string
-} {
-  if (!isRecord(partial)) return {}
-  const str = (value: unknown): string | undefined =>
-    typeof value === 'string' ? value : undefined
-  return {
-    title: str(partial.title),
-    subtitle: str(partial.subtitle),
-    body: str(partial.body),
-  }
-}
-
 function BlogStudio() {
-  const txn = useTransaction(blogTxnDef, {
+  // The blog plugin exposes three independent surfaces behind one endpoint.
+  // Orchestration happens here on the client — there is no server composition.
+  const p = usePlugin(blogPlugin, {
     connection: fetchServerSentEvents('/api/blog-studio'),
+    drafting: {},
+    heroImage: {},
+    narration: {},
   })
 
-  // Everything below is derived from the transaction's reactive state — no
-  // useState / useEffect. `blogPost` is the one-click transaction; `heroImage`
-  // and `narration` are the same verbs, driven directly by the user for
-  // regeneration.
-  const { blogPost } = txn
-  const heroRerun = txn.heroImage
-  const narrationRerun = txn.narration
+  const { drafting, heroImage, narration } = p
 
-  const post = blogPost.result?.post ?? null
-  // Prefer an individually regenerated hero / narration over the one the
-  // transaction produced.
-  const imageUrl = imageUrlOf(heroRerun.result ?? blogPost.result?.hero ?? null)
-  const audioSrc = audioSrcOf(
-    narrationRerun.result ?? blogPost.result?.audio ?? null,
-  )
-
-  // Live sub-run state, demultiplexed from the single SSE response: one entry
-  // per `ctx.call` the server made, keyed by verb name.
-  const subRuns = blogPost.subRuns
-  const draftingRun = subRuns.find((run) => run.verb === 'drafting')
-  const heroRun = subRuns.find((run) => run.verb === 'heroImage')
-  const narrationRun = subRuns.find((run) => run.verb === 'narration')
+  // The finished, schema-validated draft (once the structured-output stream
+  // completes); `partial` is the live, progressively-parsed version.
+  const post = drafting.final
+  const partial = drafting.partial
 
-  const isRunning = blogPost.isLoading
-  const hasRun = blogPost.status !== 'idle'
+  const imageUrl = imageUrlOf(heroImage.result)
+  const audioSrc = audioSrcOf(narration.result)
 
-  // While the `drafting` chat sub-run streams, the demux progressively parses
-  // its structured output into `partial` — a live `{ title?, subtitle?, body? }`
-  // that fills in as the JSON arrives. Render it directly for a streaming
-  // preview before the transaction finishes and `blogPost.result` lands.
-  const liveDraft = asBlogPostDraft(draftingRun?.partial)
-  const draftedChars = liveDraft.body?.length ?? 0
-  const writingStep = subRunToStep(draftingRun?.status)
+  // Any leg of the pipeline in flight.
+  const isRunning =
+    drafting.isLoading || heroImage.isLoading || narration.isLoading
 
   // Prefer the finished post; fall back to the live streaming draft.
-  const shownTitle = post?.title ?? liveDraft.title
-  const shownSubtitle = post?.subtitle ?? liveDraft.subtitle
-  const shownBody = post?.body ?? liveDraft.body
+  const shownTitle = post?.title ?? partial.title
+  const shownSubtitle = post?.subtitle ?? partial.subtitle
+  const shownBody = post?.body ?? partial.body
   const showArticle = Boolean(shownTitle || shownBody)
+  const draftedChars = shownBody?.length ?? 0
 
-  const heroBusy = heroRerun.isLoading || heroRun?.status === 'running'
-  const heroFailed = heroRerun.status === 'error' || heroRun?.status === 'error'
-  const narrationBusy =
-    narrationRerun.isLoading || narrationRun?.status === 'running'
-  const narrationFailed =
-    narrationRerun.status === 'error' || narrationRun?.status === 'error'
+  const writingStep: StepState = drafting.isLoading
+    ? 'active'
+    : post
+      ? 'done'
+      : drafting.error
+        ? 'failed'
+        : 'pending'
+  const heroStep = genStep(heroImage)
+  const narrationStep = genStep(narration)
+
+  const heroBusy = heroImage.isLoading
+  const heroFailed = heroStep === 'failed'
+  const narrationBusy = narration.isLoading
+  const narrationFailed = narrationStep === 'failed'
+
+  // Has anything started? Drives the step list + empty state.
+  const hasRun =
+    isRunning ||
+    Boolean(post) ||
+    Boolean(heroImage.result) ||
+    Boolean(narration.result) ||
+    Boolean(shownBody)
+
+  // Client-side orchestration: draft the post, then illustrate and narrate in
+  // parallel — both derived from the completed draft. Each step drives its own
+  // reactive surface, so the UI fills in as work finishes.
+  async function orchestrate(topic: string) {
+    drafting.clear()
+    heroImage.reset()
+    narration.reset()
 
-  function run(e: FormEvent<HTMLFormElement>) {
+    const draft = await drafting.sendMessage(
+      `Write a blog post about: ${topic}`,
+    )
+    if (!draft) return // drafting failed / was stopped before completing
+
+    await Promise.all([
+      heroImage.run({ prompt: heroPromptFor(draft) }),
+      narration.run({ text: forNarration(draft.body) }),
+    ])
+  }
+
+  function onSubmit(e: FormEvent<HTMLFormElement>) {
     e.preventDefault()
     const topic = String(
       new FormData(e.currentTarget).get('topic') ?? '',
     ).trim()
     if (!topic || isRunning) return
+    void orchestrate(topic)
+  }
 
-    // Reset the surfaces so a re-run starts clean: the previous post, and any
-    // individually regenerated hero/narration that would shadow the new
-    // transaction's results.
-    blogPost.reset()
-    heroRerun.reset()
-    narrationRerun.reset()
-
-    // ONE call. The server composes drafting → (illustrate ∥ narrate) and
-    // streams every sub-run live into `blogPost.subRuns`; the final
-    // `{ post, hero, audio }` lands in `blogPost.result`. Fire and forget —
-    // the reactive surfaces drive the UI.
-    void blogPost.run({ topic })
+  function stopAll() {
+    drafting.stop()
+    heroImage.stop()
+    narration.stop()
   }
 
   return (
@@ -164,12 +156,12 @@ function BlogStudio() {
           Turn a topic into a finished post
         </h1>
         <p className="mb-5 text-stone-500">
-          One transaction writes the article, then illustrates it and records a
-          voice-over in parallel — composed on the server from a single request,
-          with every step streamed back live.
+          The client writes the article, then illustrates it and records a
+          voice-over in parallel — three independent plugins behind one
+          endpoint, orchestrated in the browser, each streamed back live.
         </p>
 
-        <form onSubmit={run}>
+        <form onSubmit={onSubmit}>
           <label
             htmlFor="blog-topic"
             className="mb-1 block text-sm font-medium text-stone-600"
@@ -200,7 +192,7 @@ function BlogStudio() {
             {isRunning && (
               <button
                 type="button"
-                onClick={() => blogPost.stop()}
+                onClick={stopAll}
                 className="inline-flex items-center justify-center gap-2 rounded-lg border border-stone-300 bg-white px-4 py-3 font-medium text-stone-600 shadow-sm transition-colors hover:bg-stone-50"
               >
                 <Square size={16} />
@@ -225,12 +217,12 @@ function BlogStudio() {
             <StepRow
               label="Illustrating"
               icon={<ImageIcon size={16} />}
-              state={subRunToStep(heroRun?.status)}
+              state={heroStep}
             />
             <StepRow
               label="Recording voice-over"
               icon={<Volume2 size={16} />}
-              state={subRunToStep(narrationRun?.status)}
+              state={narrationStep}
             />
           </div>
         )}
@@ -240,17 +232,17 @@ function BlogStudio() {
             <span className="text-xs font-semibold uppercase tracking-wider text-stone-400">
               Touch up
             </span>
-            {/* The same verbs the transaction composed, driven directly by
-                the user — inputs derived from the current post. */}
+            {/* The same plugins the pipeline used, driven directly by the user
+                — inputs derived from the current post. */}
             <button
               type="button"
-              disabled={isRunning || heroRerun.isLoading}
+              disabled={isRunning || heroImage.isLoading}
               onClick={() =>
-                void heroRerun.run({ prompt: heroPromptFor(post) })
+                void heroImage.run({ prompt: heroPromptFor(post) })
               }
               className="inline-flex items-center justify-center gap-2 rounded-lg border border-stone-300 bg-white px-4 py-2.5 text-sm font-medium text-stone-600 shadow-sm transition-colors hover:bg-stone-50 disabled:cursor-not-allowed disabled:opacity-50"
             >
-              {heroRerun.isLoading ? (
+              {heroImage.isLoading ? (
                 <Loader2 size={16} className="animate-spin" />
               ) : (
                 <ImageIcon size={16} />
@@ -259,13 +251,13 @@ function BlogStudio() {
             </button>
             <button
               type="button"
-              disabled={isRunning || narrationRerun.isLoading}
+              disabled={isRunning || narration.isLoading}
               onClick={() =>
-                void narrationRerun.run({ text: forNarration(post.body) })
+                void narration.run({ text: forNarration(post.body) })
               }
               className="inline-flex items-center justify-center gap-2 rounded-lg border border-stone-300 bg-white px-4 py-2.5 text-sm font-medium text-stone-600 shadow-sm transition-colors hover:bg-stone-50 disabled:cursor-not-allowed disabled:opacity-50"
             >
-              {narrationRerun.isLoading ? (
+              {narration.isLoading ? (
                 <Loader2 size={16} className="animate-spin" />
               ) : (
                 <Volume2 size={16} />
@@ -275,16 +267,16 @@ function BlogStudio() {
           </div>
         )}
 
-        {blogPost.error && (
+        {(drafting.error || heroImage.error || narration.error) && (
           <div className="mt-4 rounded-lg border border-red-200 bg-red-50 px-4 py-3 text-sm text-red-700">
-            {blogPost.error.message}
+            {(drafting.error ?? heroImage.error ?? narration.error)?.message}
           </div>
         )}
       </aside>
 
-      {/* Right: the post. Appears as soon as the drafting sub-run streams a
+      {/* Right: the post. Appears as soon as the drafting stream emits a
           title/body — the body fills in live — then the hero image and
-          voice-over slot in as their sub-runs finish. */}
+          voice-over slot in as their runs finish. */}
       <main className="flex-1 overflow-y-auto p-6">
         {showArticle ? (
           <article className="mx-auto max-w-3xl overflow-hidden rounded-2xl border border-stone-200 bg-white shadow-xl shadow-stone-200/60">
@@ -354,9 +346,8 @@ function BlogStudio() {
               </div>
 
               {/* Body — rendered as Markdown live while the draft streams in.
-                  The client batches the streamed structured-output updates
-                  (see TransactionClient), so this re-parses at a bounded rate
-                  rather than once per token. */}
+                  The client batches the streamed structured-output updates, so
+                  this re-parses at a bounded rate rather than once per token. */}
               <div className="text-[1.05rem] leading-8 text-stone-800 [&_a]:text-amber-700 [&_a]:underline [&_blockquote]:border-l-4 [&_blockquote]:border-amber-300 [&_blockquote]:pl-4 [&_blockquote]:italic [&_blockquote]:text-stone-600 [&_code]:rounded [&_code]:bg-stone-100 [&_code]:px-1.5 [&_code]:py-0.5 [&_code]:text-sm [&_h2]:mb-3 [&_h2]:mt-8 [&_h2]:text-2xl [&_h2]:font-bold [&_h2]:text-stone-900 [&_h3]:mb-2 [&_h3]:mt-6 [&_h3]:text-xl [&_h3]:font-semibold [&_li]:my-1 [&_ol]:my-4 [&_ol]:list-decimal [&_ol]:pl-6 [&_p]:my-4 [&_strong]:font-semibold [&_ul]:my-4 [&_ul]:list-disc [&_ul]:pl-6">
                 <ReactMarkdown remarkPlugins={[remarkGfm]}>
                   {shownBody ?? ''}
@@ -374,7 +365,7 @@ function BlogStudio() {
               <p className="max-w-xs text-sm">
                 {draftedChars > 0
                   ? `Drafting the article… ${draftedChars} characters so far.`
-                  : 'Starting the transaction…'}
+                  : 'Starting the draft…'}
               </p>
             </div>
           </div>
diff --git a/packages/ai-client/package.json b/packages/ai-client/package.json
index b7d471e9c..95c6e8655 100644
--- a/packages/ai-client/package.json
+++ b/packages/ai-client/package.json
@@ -43,9 +43,9 @@
       "types": "./dist/esm/devtools.d.ts",
       "import": "./dist/esm/devtools.js"
     },
-    "./transaction": {
-      "types": "./dist/esm/transaction.d.ts",
-      "import": "./dist/esm/transaction.js"
+    "./plugin": {
+      "types": "./dist/esm/plugin.d.ts",
+      "import": "./dist/esm/plugin.js"
     }
   },
   "files": [
diff --git a/packages/ai-client/src/plugin-client.ts b/packages/ai-client/src/plugin-client.ts
new file mode 100644
index 000000000..8418e129f
--- /dev/null
+++ b/packages/ai-client/src/plugin-client.ts
@@ -0,0 +1,95 @@
+import { ChatClient } from './chat-client.js'
+import { GenerationClient } from './generation-client.js'
+import type { PluginDefinition } from '@tanstack/ai/plugin'
+import type {
+  ChatPluginOptions,
+  GenerationPluginClientOptions,
+  PluginClientOptions,
+} from './plugin-types.js'
+
+/**
+ * Composes one `ChatClient` per chat plugin and one `GenerationClient` per
+ * generation plugin declared on a `PluginDefinition`, sharing the single
+ * `connection` adapter passed in `options`.
+ *
+ * Each sub-client tags its own requests with the plugin name — `ChatClient`
+ * via `forwardedProps: { plugin }`, `GenerationClient` via `body: { plugin }`
+ * — so the single server endpoint can route on that field.
+ */
+export class PluginClient<
+  TDef extends PluginDefinition<any> = PluginDefinition<any>,
+> {
+  private readonly chats = new Map<string, ChatClient<any>>()
+  private readonly oneShots = new Map<string, GenerationClient<any, any, any>>()
+  readonly plugins: ReadonlyArray<string>
+
+  constructor(options: PluginClientOptions<TDef>) {
+    const { plugin, connection, id, threadId, plugins, callbacks } = options
+    this.plugins = plugin.plugins
+
+    for (const pluginName of plugin.plugins) {
+      const kind = plugin.pluginKinds[pluginName]
+      if (kind === 'chat') {
+        const pluginOptions: ChatPluginOptions | undefined =
+          plugins?.[pluginName as keyof typeof plugins]
+        this.chats.set(
+          pluginName,
+          new ChatClient<any>({
+            connection,
+            id: id ? `${id}:${pluginName}` : undefined,
+            threadId,
+            tools: pluginOptions?.tools as any,
+            forwardedProps: {
+              ...pluginOptions?.forwardedProps,
+              plugin: pluginName,
+            },
+            ...callbacks?.chat?.(pluginName),
+          }),
+        )
+        continue
+      }
+
+      const pluginOptions: GenerationPluginClientOptions<any> | undefined =
+        plugins?.[pluginName as keyof typeof plugins]
+      const oneShotCallbacks = callbacks?.oneShot?.(pluginName)
+      this.oneShots.set(
+        pluginName,
+        new GenerationClient({
+          connection,
+          id: id ? `${id}:${pluginName}` : undefined,
+          // Merge per-plugin forwardedProps under the routing discriminator.
+          body: { ...pluginOptions?.forwardedProps, plugin: pluginName },
+          ...(pluginOptions?.onResult !== undefined && {
+            onResult: pluginOptions.onResult,
+          }),
+          ...oneShotCallbacks,
+        }),
+      )
+    }
+  }
+
+  /** Whether the plugin definition declares the given plugin. */
+  has(pluginName: string): boolean {
+    return this.plugins.includes(pluginName)
+  }
+
+  /** The `ChatClient` for a declared chat plugin, if any. */
+  chat(pluginName: string): ChatClient<any> | undefined {
+    return this.chats.get(pluginName)
+  }
+
+  /** The `GenerationClient` for a declared generation plugin, if any. */
+  oneShot(pluginName: string): GenerationClient<any, any, any> | undefined {
+    return this.oneShots.get(pluginName)
+  }
+
+  /** Tears down every chat and generation sub-client. */
+  dispose(): void {
+    for (const chat of this.chats.values()) {
+      chat.dispose()
+    }
+    for (const oneShot of this.oneShots.values()) {
+      oneShot.dispose()
+    }
+  }
+}
diff --git a/packages/ai-client/src/transaction-structured.ts b/packages/ai-client/src/plugin-structured.ts
similarity index 96%
rename from packages/ai-client/src/transaction-structured.ts
rename to packages/ai-client/src/plugin-structured.ts
index 7b65b3c75..8a7736d66 100644
--- a/packages/ai-client/src/transaction-structured.ts
+++ b/packages/ai-client/src/plugin-structured.ts
@@ -3,7 +3,7 @@ import type { UIMessage } from './types.js'
 /**
  * Computes the "active" structured-output `partial`/`final` values from a
  * `UIMessage` history — the framework-agnostic core of `useChat`'s
- * `partial`/`final` fields, shared by the transaction hooks.
+ * `partial`/`final` fields, shared by the plugin hooks.
  *
  * The "active" structured-output part is the one on the assistant message
  * that follows the latest user message. No such message exists between
diff --git a/packages/ai-client/src/transaction-types.ts b/packages/ai-client/src/plugin-types.ts
similarity index 58%
rename from packages/ai-client/src/transaction-types.ts
rename to packages/ai-client/src/plugin-types.ts
index b7e7a56e6..8a076d173 100644
--- a/packages/ai-client/src/transaction-types.ts
+++ b/packages/ai-client/src/plugin-types.ts
@@ -1,10 +1,10 @@
-// packages/ai-client/src/transaction-types.ts
+// packages/ai-client/src/plugin-types.ts
 import type { InferChatSchema, InferChatTools } from '@tanstack/ai'
 import type {
-  ChatVerb,
-  OneShotVerb,
-  TransactionDefinition,
-} from '@tanstack/ai/transaction'
+  ChatPlugin,
+  GenerationPlugin,
+  PluginDefinition,
+} from '@tanstack/ai/plugin'
 import type {
   AnyClientTool,
   InferSchemaType,
@@ -25,63 +25,36 @@ import type {
   InferGenerationOutput,
 } from './generation-types.js'
 
-/**
- * Live state of one sub-run inside a transaction run — a sibling verb the
- * server-side `execute` invoked via `ctx.call`. Demultiplexed from the
- * single SSE response by `TransactionClient`.
- */
-export interface TransactionSubRun {
-  runId: string
-  /** The sub-verb's name in the transaction definition. */
-  verb: string
-  /** 0-based order in which the server started this sub-run. */
-  index: number
-  status: 'running' | 'success' | 'error'
-  /** The sub-run's result, once it completes. */
-  result: unknown
-  /** Accumulated streamed text, for chat-verb sub-runs. */
-  text: string
-  /**
-   * Live, progressively-parsed structured output for a chat-verb sub-run
-   * whose callback declared an `outputSchema` — the partial object built from
-   * the streamed JSON as it arrives, snapped to the fully-validated object on
-   * completion. `undefined` for plain-text chat verbs and one-shot verbs
-   * (whose streamed `text`, if any, is prose, not JSON). Typed `unknown`;
-   * narrow it before use.
-   */
-  partial?: unknown
-  error?: string
-}
-
-/** Per-chat-verb client options. */
-export interface ChatVerbOptions {
-  /** Client-executed tools for this chat verb. */
+/** Per-chat-plugin client options. */
+export interface ChatPluginOptions {
+  /** Client-executed tools for this chat plugin. */
   tools?: ReadonlyArray<AnyClientTool>
-  /** Extra fields merged into this verb's request body. */
+  /** Extra fields merged into this plugin's request body. */
   forwardedProps?: Record<string, any>
 }
 
 /**
- * Per-one-shot-verb client options: an optional `onResult` transform (its
- * return type becomes the verb surface's `result` type) plus extra
+ * Per-generation-plugin client options: an optional `onResult` transform (its
+ * return type becomes the plugin surface's `result` type) plus extra
  * `forwardedProps` merged into the request body.
  */
-export interface OneShotVerbOptions<TResult> {
+export interface GenerationPluginClientOptions<TResult> {
   /**
    * Transform the raw backend result before it is stored on the surface.
    * Return `undefined`/`null`/`void` to keep the raw result.
    */
   onResult?: (result: TResult) => unknown
-  /** Extra fields merged into this verb's request body. */
+  /** Extra fields merged into this plugin's request body. */
   forwardedProps?: Record<string, any>
 }
 
-/** Maps each declared verb name to its per-verb client options shape. */
-export type VerbOptionsMap<TDef extends TransactionDefinition<any>> = {
-  [K in keyof TDef['~verbs'] & string]?: TDef['~verbs'][K] extends ChatVerb<any>
-    ? ChatVerbOptions
-    : TDef['~verbs'][K] extends OneShotVerb<any, infer TRes>
-      ? OneShotVerbOptions<TRes>
+/** Maps each declared plugin name to its per-plugin client options shape. */
+export type PluginOptionsMap<TDef extends PluginDefinition<any>> = {
+  [K in keyof TDef['~plugins'] &
+    string]?: TDef['~plugins'][K] extends ChatPlugin<any>
+    ? ChatPluginOptions
+    : TDef['~plugins'][K] extends GenerationPlugin<any, infer TRes>
+      ? GenerationPluginClientOptions<TRes>
       : never
 }
 
@@ -89,13 +62,13 @@ export type VerbOptionsMap<TDef extends TransactionDefinition<any>> = {
  * Reactive state callbacks forwarded into the underlying sub-clients'
  * constructors. Set by the framework hooks (not users) to wire up reactive
  * state. `ChatClient` and `GenerationClient` only accept these via their
- * constructors, so `TransactionClient` threads them through at construction
+ * constructors, so `PluginClient` threads them through at construction
  * time.
  */
-export interface TransactionClientCallbacks {
-  /** Reactive state callbacks for each chat verb's `ChatClient`. */
+export interface PluginClientCallbacks {
+  /** Reactive state callbacks for each chat plugin's `ChatClient`. */
   chat?: (
-    verb: string,
+    plugin: string,
   ) => Pick<
     ChatClientOptions,
     | 'onMessagesChange'
@@ -106,32 +79,29 @@ export interface TransactionClientCallbacks {
     | 'onConnectionStatusChange'
     | 'onSessionGeneratingChange'
   >
-  /** Reactive state callbacks for each one-shot verb's `GenerationClient`. */
-  oneShot?: (verb: string) => Pick<
+  /** Reactive state callbacks for each generation plugin's `GenerationClient`. */
+  oneShot?: (
+    plugin: string,
+  ) => Pick<
     GenerationClientOptions<any, any, any>,
     'onResultChange' | 'onLoadingChange' | 'onErrorChange' | 'onStatusChange'
-  > & {
-    /** Invoked whenever the verb's live sub-run state changes. */
-    onSubRunsChange?: (subRuns: Array<TransactionSubRun>) => void
-  }
+  >
 }
 
-/** Options for TransactionClient (framework-agnostic core). */
-export interface TransactionClientOptions<
-  TDef extends TransactionDefinition<any>,
-> {
-  transaction: TDef
+/** Options for PluginClient (framework-agnostic core). */
+export interface PluginClientOptions<TDef extends PluginDefinition<any>> {
+  plugin: TDef
   connection: ConnectConnectionAdapter
   id?: string
   threadId?: string
   /**
-   * Per-verb options, keyed by the verb names declared on the definition.
-   * Nested (rather than spread at the top level) so verb names can never
+   * Per-plugin options, keyed by the plugin names declared on the definition.
+   * Nested (rather than spread at the top level) so plugin names can never
    * collide with `connection`/`id`/`threadId`/`callbacks`.
    */
-  verbs?: VerbOptionsMap<TDef>
+  plugins?: PluginOptionsMap<TDef>
   /** Set by framework hooks (not users) to wire up reactive state. */
-  callbacks?: TransactionClientCallbacks
+  callbacks?: PluginClientCallbacks
 }
 
 /**
@@ -181,27 +151,29 @@ type ToClientTools<TTools> = TTools extends readonly [
   ? [ToClientToolShape<THead>, ...ToClientTools<TRest>]
   : []
 
-/** The return type of a chat verb's captured callback. */
-type ChatVerbReturn<TVerb> =
-  TVerb extends ChatVerb<infer TCallback>
+/** The return type of a chat plugin's captured callback. */
+type ChatPluginReturn<TPlugin> =
+  TPlugin extends ChatPlugin<infer TCallback>
     ? TCallback extends (...args: Array<any>) => infer TRet
       ? TRet
       : never
     : never
 
 /**
- * Client-tool-shaped tuple recovered from a chat verb's captured tools.
+ * Client-tool-shaped tuple recovered from a chat plugin's captured tools.
  * Drives the `messages` tool-call/result part typing on that chat surface.
  */
-export type ChatToolsOfVerb<TVerb> = ToClientTools<
-  NonNullable<InferChatTools<ChatVerbReturn<TVerb>>>
+export type ChatToolsOfPlugin<TPlugin> = ToClientTools<
+  NonNullable<InferChatTools<ChatPluginReturn<TPlugin>>>
 >
 
-/** Structured-output schema recovered from a chat verb (or `undefined`). */
-export type ChatSchemaOfVerb<TVerb> = InferChatSchema<ChatVerbReturn<TVerb>>
+/** Structured-output schema recovered from a chat plugin (or `undefined`). */
+export type ChatSchemaOfPlugin<TPlugin> = InferChatSchema<
+  ChatPluginReturn<TPlugin>
+>
 
-/** The base chat verb surface — mirrors the frameworks' useChat return. */
-export interface TransactionChatSurfaceBase<
+/** The base chat plugin surface — mirrors the frameworks' useChat return. */
+export interface PluginChatSurfaceBase<
   TTools extends ReadonlyArray<AnyClientTool> = [],
 > {
   /** Current messages in the conversation. */
@@ -283,15 +255,15 @@ export interface TransactionChatSurfaceBase<
 }
 
 /**
- * The chat verb surface. Extends {@link TransactionChatSurfaceBase} and,
+ * The chat plugin surface. Extends {@link PluginChatSurfaceBase} and,
  * when the callback declared an `outputSchema` (`TSchema extends
  * SchemaInput`), adds the typed structured-output fields `partial` / `final`
  * — mirroring the framework `useChat` hooks' conditional return.
  */
-export type TransactionChatSurface<
+export type PluginChatSurface<
   TTools extends ReadonlyArray<AnyClientTool> = [],
   TSchema = undefined,
-> = TransactionChatSurfaceBase<TTools> & {
+> = PluginChatSurfaceBase<TTools> & {
   /**
    * Send a message and get a response. Can be a simple string or multimodal
    * content with images, audio, etc.
@@ -322,9 +294,9 @@ export type TransactionChatSurface<
       }
     : Record<never, never>)
 
-/** The one-shot verb surface — a typed run/result pair plus live sub-runs. */
-export interface TransactionVerbSurface<TInput, TResult> {
-  /** Invoke the verb. Resolves with its (transformed) result, or null. */
+/** The generation plugin surface — a typed run/result pair. */
+export interface PluginGenerationSurface<TInput, TResult> {
+  /** Invoke the plugin. Resolves with its (transformed) result, or null. */
   run: (input: TInput) => Promise<TResult | null>
   result: TResult | null
   isLoading: boolean
@@ -332,52 +304,48 @@ export interface TransactionVerbSurface<TInput, TResult> {
   status: GenerationClientState
   stop: () => void
   reset: () => void
-  /**
-   * Live state of the sub-runs the server-side `execute` spawned via
-   * `ctx.call` during the current/last run, in start order. Empty for verbs
-   * that don't compose siblings.
-   */
-  subRuns: Array<TransactionSubRun>
 }
 
 /**
- * The stored `result` type for a one-shot verb `K`: the `onResult`
+ * The stored `result` type for a generation plugin `K`: the `onResult`
  * transform's return type when the options declare one, otherwise the raw
- * result type captured from the verb's `execute`.
+ * result type captured from the plugin's `execute`.
  */
-export type VerbResultType<
+export type PluginResultType<
   TOptions,
-  TVerbName extends string,
+  TPluginName extends string,
   TResult,
-> = TOptions extends { verbs?: infer TVerbOptions }
-  ? TVerbName extends keyof TVerbOptions
-    ? NonNullable<TVerbOptions[TVerbName]> extends { onResult?: infer TFn }
+> = TOptions extends { plugins?: infer TPluginOptions }
+  ? TPluginName extends keyof TPluginOptions
+    ? NonNullable<TPluginOptions[TPluginName]> extends { onResult?: infer TFn }
       ? InferGenerationOutput<TResult, TFn>
       : TResult
     : TResult
   : TResult
 
 /**
- * The full typed system returned by useTransaction: one surface per declared
- * verb. Chat verbs get the conversational surface (tools and structured
- * output inferred from their callback); one-shot verbs get a typed
+ * The full typed system returned by usePlugin: one surface per declared
+ * plugin. Chat plugins get the conversational surface (tools and structured
+ * output inferred from their callback); generation plugins get a typed
  * `run`/`result` surface (input from their schema, result from `execute`,
  * transformed by the options' `onResult` when declared).
  */
-export type TransactionSystem<
-  TDef extends TransactionDefinition<any>,
+export type PluginSystem<
+  TDef extends PluginDefinition<any>,
   /**
-   * The user's options object. Its per-verb `onResult` transforms drive each
-   * one-shot verb's `result` type. Defaults to `unknown` (no transforms).
+   * The user's options object. Its per-plugin `onResult` transforms drive
+   * each generation plugin's `result` type. Defaults to `unknown` (no
+   * transforms).
    */
   TOptions = unknown,
 > = {
-  [K in keyof TDef['~verbs'] & string]: TDef['~verbs'][K] extends ChatVerb<any>
-    ? TransactionChatSurface<
-        ChatToolsOfVerb<TDef['~verbs'][K]>,
-        ChatSchemaOfVerb<TDef['~verbs'][K]>
+  [K in keyof TDef['~plugins'] &
+    string]: TDef['~plugins'][K] extends ChatPlugin<any>
+    ? PluginChatSurface<
+        ChatToolsOfPlugin<TDef['~plugins'][K]>,
+        ChatSchemaOfPlugin<TDef['~plugins'][K]>
       >
-    : TDef['~verbs'][K] extends OneShotVerb<infer TInput, infer TResult>
-      ? TransactionVerbSurface<TInput, VerbResultType<TOptions, K, TResult>>
+    : TDef['~plugins'][K] extends GenerationPlugin<infer TInput, infer TResult>
+      ? PluginGenerationSurface<TInput, PluginResultType<TOptions, K, TResult>>
       : never
 }
diff --git a/packages/ai-client/src/plugin.ts b/packages/ai-client/src/plugin.ts
new file mode 100644
index 000000000..c8646ee8e
--- /dev/null
+++ b/packages/ai-client/src/plugin.ts
@@ -0,0 +1,17 @@
+export { PluginClient } from './plugin-client'
+export { computeStructuredParts } from './plugin-structured'
+export type {
+  ChatPluginOptions,
+  ChatSchemaOfPlugin,
+  ChatToolsOfPlugin,
+  DeepPartial,
+  GenerationPluginClientOptions,
+  PluginChatSurface,
+  PluginChatSurfaceBase,
+  PluginClientCallbacks,
+  PluginClientOptions,
+  PluginGenerationSurface,
+  PluginOptionsMap,
+  PluginResultType,
+  PluginSystem,
+} from './plugin-types'
diff --git a/packages/ai-client/src/transaction-client.ts b/packages/ai-client/src/transaction-client.ts
deleted file mode 100644
index 093ef804c..000000000
--- a/packages/ai-client/src/transaction-client.ts
+++ /dev/null
@@ -1,245 +0,0 @@
-import { parsePartialJSON } from '@tanstack/ai'
-import { ChatClient } from './chat-client.js'
-import { GenerationClient } from './generation-client.js'
-import type { StreamChunk } from '@tanstack/ai'
-import type { TransactionDefinition } from '@tanstack/ai/transaction'
-import type {
-  ChatVerbOptions,
-  OneShotVerbOptions,
-  TransactionClientOptions,
-  TransactionSubRun,
-} from './transaction-types.js'
-
-/** CUSTOM event names of the transaction sub-run protocol (server-emitted). */
-const SUB_RUN_EVENTS = {
-  STARTED: 'transaction:sub-run:started',
-  CHUNK: 'transaction:sub-run:chunk',
-  RESULT: 'transaction:sub-run:result',
-  ERROR: 'transaction:sub-run:error',
-} as const
-
-/**
- * Coalesce reactive `notify`s for streamed text deltas to one per this many
- * chunks, so consumers rendering the live `partial`/`text` (e.g. Markdown)
- * re-render at a bounded rate rather than once per token. The internal
- * sub-run state is still updated on every chunk; only the reactive
- * notification is batched. Status transitions and completion always flush
- * immediately. Mirrors the core StreamProcessor's structured-output batch
- * size so the transaction path streams as smoothly as the chat path.
- */
-const SUB_RUN_TEXT_NOTIFY_BATCH = 12
-
-/**
- * Composes one `ChatClient` per chat verb and one `GenerationClient` per
- * one-shot verb declared on a `TransactionDefinition`, sharing the single
- * `connection` adapter passed in `options`.
- *
- * Each sub-client tags its own requests with the verb name — `ChatClient`
- * via `forwardedProps: { verb }`, `GenerationClient` via `body: { verb }` —
- * so the single server endpoint can route on that field.
- *
- * For one-shot verbs, the client also demultiplexes the transaction sub-run
- * events (`transaction:sub-run:*`) the server emits when the verb's
- * `execute` composes siblings via `ctx.call`, exposing them as live
- * per-verb {@link TransactionSubRun} state.
- */
-export class TransactionClient<
-  TDef extends TransactionDefinition<any> = TransactionDefinition<any>,
-> {
-  private readonly chats = new Map<string, ChatClient<any>>()
-  private readonly oneShots = new Map<string, GenerationClient<any, any, any>>()
-  private readonly subRuns = new Map<string, Array<TransactionSubRun>>()
-  /** Per-sub-run streamed-text-chunk counter, for batching reactive notifies. */
-  private readonly subRunChunkCounts = new Map<string, number>()
-  readonly verbs: ReadonlyArray<string>
-
-  constructor(options: TransactionClientOptions<TDef>) {
-    const { transaction, connection, id, threadId, verbs, callbacks } = options
-    this.verbs = transaction.verbs
-
-    for (const verbName of transaction.verbs) {
-      const kind = transaction.verbKinds[verbName]
-      if (kind === 'chat') {
-        const verbOptions: ChatVerbOptions | undefined =
-          verbs?.[verbName as keyof typeof verbs]
-        this.chats.set(
-          verbName,
-          new ChatClient<any>({
-            connection,
-            id: id ? `${id}:${verbName}` : undefined,
-            threadId,
-            tools: verbOptions?.tools as any,
-            forwardedProps: { ...verbOptions?.forwardedProps, verb: verbName },
-            ...callbacks?.chat?.(verbName),
-          }),
-        )
-        continue
-      }
-
-      const verbOptions: OneShotVerbOptions<any> | undefined =
-        verbs?.[verbName as keyof typeof verbs]
-      const oneShotCallbacks = callbacks?.oneShot?.(verbName)
-      this.subRuns.set(verbName, [])
-      this.oneShots.set(
-        verbName,
-        new GenerationClient({
-          connection,
-          id: id ? `${id}:${verbName}` : undefined,
-          // Merge per-verb forwardedProps under the routing discriminator.
-          body: { ...verbOptions?.forwardedProps, verb: verbName },
-          ...(verbOptions?.onResult !== undefined && {
-            onResult: verbOptions.onResult,
-          }),
-          onChunk: (chunk) => {
-            this.handleSubRunChunk(
-              verbName,
-              chunk,
-              oneShotCallbacks?.onSubRunsChange,
-            )
-          },
-          ...oneShotCallbacks,
-        }),
-      )
-    }
-  }
-
-  /** Whether the transaction declares the given verb. */
-  has(verbName: string): boolean {
-    return this.verbs.includes(verbName)
-  }
-
-  /** The `ChatClient` for a declared chat verb, if any. */
-  chat(verbName: string): ChatClient<any> | undefined {
-    return this.chats.get(verbName)
-  }
-
-  /** The `GenerationClient` for a declared one-shot verb, if any. */
-  oneShot(verbName: string): GenerationClient<any, any, any> | undefined {
-    return this.oneShots.get(verbName)
-  }
-
-  /** Live sub-run state for a one-shot verb's current/last run. */
-  getSubRuns(verbName: string): Array<TransactionSubRun> {
-    return this.subRuns.get(verbName) ?? []
-  }
-
-  /**
-   * Demultiplex `transaction:sub-run:*` CUSTOM events from a one-shot verb's
-   * response stream into that verb's sub-run array. A RUN_STARTED chunk
-   * (the root run beginning) resets the array.
-   */
-  private handleSubRunChunk(
-    verbName: string,
-    chunk: StreamChunk,
-    notify: ((subRuns: Array<TransactionSubRun>) => void) | undefined,
-  ): void {
-    const type = (chunk as { type?: string }).type
-    if (type === 'RUN_STARTED') {
-      this.subRuns.set(verbName, [])
-      this.subRunChunkCounts.clear()
-      notify?.([])
-      return
-    }
-    if (type !== 'CUSTOM') return
-    const { name, value } = chunk as {
-      name?: string
-      value?: {
-        runId?: string
-        verb?: string
-        index?: number
-        result?: unknown
-        message?: string
-        chunk?: {
-          type?: string
-          delta?: unknown
-          name?: string
-          value?: { object?: unknown }
-        }
-      }
-    }
-    if (!name || !name.startsWith('transaction:sub-run:') || !value) return
-
-    const current = this.subRuns.get(verbName) ?? []
-    const next = current.slice()
-    const at = next.findIndex((s) => s.runId === value.runId)
-    const existing = at === -1 ? undefined : next[at]
-
-    // Streamed text deltas fire per token; coalesce their reactive notifies so
-    // consumers re-render at a bounded rate. Every other event (status change,
-    // completion) flushes immediately. Internal state updates on every chunk
-    // regardless, so `getSubRuns()` is always current.
-    let shouldNotify = true
-
-    if (name === SUB_RUN_EVENTS.STARTED) {
-      next.push({
-        runId: value.runId ?? '',
-        verb: value.verb ?? 'verb',
-        index: value.index ?? next.length,
-        status: 'running',
-        result: null,
-        text: '',
-      })
-    } else if (!existing) {
-      return
-    } else if (name === SUB_RUN_EVENTS.CHUNK) {
-      const inner = value.chunk
-      if (
-        inner?.type === 'TEXT_MESSAGE_CONTENT' &&
-        typeof inner.delta === 'string'
-      ) {
-        // Accumulate the streamed text. For a structured-output chat verb
-        // these deltas are the output's JSON; attempt a partial parse so a
-        // live object streams into `partial`. Plain prose yields `undefined`
-        // (parsePartialJSON only produces object-shaped values), so `partial`
-        // stays unset for non-structured verbs.
-        const text = existing.text + inner.delta
-        const parsed = parsePartialJSON(text)
-        next[at] = {
-          ...existing,
-          text,
-          ...(parsed != null && typeof parsed === 'object'
-            ? { partial: parsed }
-            : {}),
-        }
-        // Notify only on batch boundaries; the internal map is still updated.
-        const runId = value.runId ?? ''
-        const count = (this.subRunChunkCounts.get(runId) ?? 0) + 1
-        this.subRunChunkCounts.set(runId, count)
-        shouldNotify = count % SUB_RUN_TEXT_NOTIFY_BATCH === 0
-      } else if (
-        inner?.type === 'CUSTOM' &&
-        inner.name === 'structured-output.complete'
-      ) {
-        // Snap `partial` to the fully-parsed, schema-validated object.
-        const object = inner.value?.object
-        next[at] =
-          object !== undefined ? { ...existing, partial: object } : existing
-      } else {
-        return
-      }
-    } else if (name === SUB_RUN_EVENTS.RESULT) {
-      next[at] = { ...existing, status: 'success', result: value.result }
-    } else if (name === SUB_RUN_EVENTS.ERROR) {
-      next[at] = {
-        ...existing,
-        status: 'error',
-        error: value.message ?? 'Sub-run failed',
-      }
-    } else {
-      return
-    }
-
-    this.subRuns.set(verbName, next)
-    if (shouldNotify) notify?.(next)
-  }
-
-  /** Tears down every chat and one-shot sub-client. */
-  dispose(): void {
-    for (const chat of this.chats.values()) {
-      chat.dispose()
-    }
-    for (const oneShot of this.oneShots.values()) {
-      oneShot.dispose()
-    }
-  }
-}
diff --git a/packages/ai-client/src/transaction.ts b/packages/ai-client/src/transaction.ts
deleted file mode 100644
index 4dff6f079..000000000
--- a/packages/ai-client/src/transaction.ts
+++ /dev/null
@@ -1,18 +0,0 @@
-export { TransactionClient } from './transaction-client'
-export { computeStructuredParts } from './transaction-structured'
-export type {
-  ChatSchemaOfVerb,
-  ChatToolsOfVerb,
-  ChatVerbOptions,
-  DeepPartial,
-  OneShotVerbOptions,
-  TransactionChatSurface,
-  TransactionChatSurfaceBase,
-  TransactionClientCallbacks,
-  TransactionClientOptions,
-  TransactionSubRun,
-  TransactionSystem,
-  TransactionVerbSurface,
-  VerbOptionsMap,
-  VerbResultType,
-} from './transaction-types'
diff --git a/packages/ai-client/tests/plugin-client.test.ts b/packages/ai-client/tests/plugin-client.test.ts
new file mode 100644
index 000000000..e13345a1d
--- /dev/null
+++ b/packages/ai-client/tests/plugin-client.test.ts
@@ -0,0 +1,159 @@
+import { describe, expect, expectTypeOf, it } from 'vitest'
+import { chat, toolDefinition } from '@tanstack/ai'
+import { chatPlugin, definePlugin, generationPlugin } from '@tanstack/ai/plugin'
+import { z } from 'zod'
+import { PluginClient } from '../src/plugin-client.js'
+import { fetchServerSentEvents } from '../src/connection-adapters.js'
+import type { AnyTextAdapter } from '@tanstack/ai'
+import type { PluginSystem } from '../src/plugin-types.js'
+
+// Declared, never executed — used only inside chat callbacks that the type
+// tests never invoke (`definePlugin` only runs `Object.keys`). Ambient,
+// so it emits no runtime binding and is never read.
+declare const adapter: AnyTextAdapter
+
+const emptyChatPlugin = () => chatPlugin(async function* () {} as any)
+
+describe('PluginClient', () => {
+  it('creates one sub-client per declared plugin, by kind', () => {
+    const def = definePlugin({
+      primaryChat: emptyChatPlugin(),
+      banner: generationPlugin({ execute: async () => ({ url: 'x' }) }),
+    })
+    const client = new PluginClient({
+      plugin: def,
+      connection: fetchServerSentEvents('/api/plugin'),
+    })
+
+    expect(client.has('primaryChat')).toBe(true)
+    expect(client.has('banner')).toBe(true)
+    expect(client.has('speech')).toBe(false)
+    expect(client.chat('primaryChat')).toBeDefined()
+    expect(client.oneShot('banner')).toBeDefined()
+    expect(client.chat('banner')).toBeUndefined()
+    expect(client.oneShot('primaryChat')).toBeUndefined()
+    expect(client.plugins).toEqual(['primaryChat', 'banner'])
+  })
+
+  it('supports multiple chat plugins, each with its own ChatClient', () => {
+    const def = definePlugin({
+      primaryChat: emptyChatPlugin(),
+      summaryChat: emptyChatPlugin(),
+    })
+    const client = new PluginClient({
+      plugin: def,
+      connection: fetchServerSentEvents('/api/plugin'),
+    })
+
+    expect(client.chat('primaryChat')).toBeDefined()
+    expect(client.chat('summaryChat')).toBeDefined()
+    expect(client.chat('primaryChat')).not.toBe(client.chat('summaryChat'))
+  })
+
+  it('dispose() tears down every sub-client', () => {
+    const def = definePlugin({
+      primaryChat: emptyChatPlugin(),
+      banner: generationPlugin({ execute: async () => ({}) }),
+      narration: generationPlugin({ execute: async () => ({}) }),
+    })
+    const client = new PluginClient({
+      plugin: def,
+      connection: fetchServerSentEvents('/api/plugin'),
+    })
+
+    const disposed: Array<string> = []
+    client.chat('primaryChat')!.dispose = () => {
+      disposed.push('primaryChat')
+    }
+    client.oneShot('banner')!.dispose = () => {
+      disposed.push('banner')
+    }
+    client.oneShot('narration')!.dispose = () => {
+      disposed.push('narration')
+    }
+
+    client.dispose()
+
+    expect(disposed.sort()).toEqual(['banner', 'narration', 'primaryChat'])
+  })
+})
+
+describe('PluginSystem typing', () => {
+  it('exposes only declared plugins, typed by kind', () => {
+    const def = definePlugin({
+      primaryChat: emptyChatPlugin(),
+      banner: generationPlugin({
+        input: z.object({ prompt: z.string() }),
+        execute: async ({ input }) => ({ url: `img:${input.prompt}` }),
+      }),
+    })
+    type Sys = PluginSystem<typeof def>
+    expectTypeOf<Sys>().toHaveProperty('primaryChat')
+    expectTypeOf<Sys>().toHaveProperty('banner')
+    // @ts-expect-error speech was not declared
+    expectTypeOf<Sys>().toHaveProperty('speech')
+
+    // Generation input comes from the plugin's schema; result from execute.
+    expectTypeOf<Parameters<Sys['banner']['run']>[0]>().toEqualTypeOf<{
+      prompt: string
+    }>()
+    expectTypeOf<Sys['banner']['result']>().toEqualTypeOf<{
+      url: string
+    } | null>()
+  })
+
+  it('chat plugin tools narrow that surface message tool-call parts', () => {
+    const weatherDef = toolDefinition({
+      name: 'get_weather',
+      description: 'Get the weather for a city',
+      inputSchema: z.object({ city: z.string() }),
+      outputSchema: z.object({ tempC: z.number() }),
+    })
+
+    const def = definePlugin({
+      primaryChat: chatPlugin((req) =>
+        chat({ adapter, messages: req.messages, tools: [weatherDef] }),
+      ),
+    })
+
+    type Sys = PluginSystem<typeof def>
+    type Part = Sys['primaryChat']['messages'][number]['parts'][number]
+    type WeatherCall = Extract<Part, { type: 'tool-call'; name: 'get_weather' }>
+
+    expectTypeOf<WeatherCall['name']>().toEqualTypeOf<'get_weather'>()
+    expectTypeOf<WeatherCall['input']>().toEqualTypeOf<
+      { city: string } | undefined
+    >()
+    expectTypeOf<WeatherCall['output']>().toEqualTypeOf<
+      { tempC: number } | undefined
+    >()
+  })
+
+  it('outputSchema adds typed partial/final to that chat surface only', () => {
+    const outputSchema = z.object({ answer: z.string(), score: z.number() })
+
+    const def = definePlugin({
+      drafting: chatPlugin((req) =>
+        chat({ adapter, messages: req.messages, outputSchema, stream: true }),
+      ),
+      support: chatPlugin((req) => chat({ adapter, messages: req.messages })),
+    })
+
+    type Drafting = PluginSystem<typeof def>['drafting']
+    type Support = PluginSystem<typeof def>['support']
+
+    expectTypeOf<Drafting['final']>().toEqualTypeOf<{
+      answer: string
+      score: number
+    } | null>()
+    expectTypeOf<Drafting['partial']>().toEqualTypeOf<{
+      answer?: string
+      score?: number
+    }>()
+
+    // @ts-expect-error no outputSchema → no `partial` on this chat surface
+    expectTypeOf<Support>().toHaveProperty('partial')
+    // @ts-expect-error no outputSchema → no `final` on this chat surface
+    expectTypeOf<Support>().toHaveProperty('final')
+  })
+})
diff --git a/packages/ai-client/tests/transaction-structured.test.ts b/packages/ai-client/tests/plugin-structured.test.ts
similarity index 97%
rename from packages/ai-client/tests/transaction-structured.test.ts
rename to packages/ai-client/tests/plugin-structured.test.ts
index 84c5eb189..679cc97ce 100644
--- a/packages/ai-client/tests/transaction-structured.test.ts
+++ b/packages/ai-client/tests/plugin-structured.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { computeStructuredParts } from '../src/transaction-structured.js'
+import { computeStructuredParts } from '../src/plugin-structured.js'
 import type { UIMessage } from '../src/types.js'
 
 function userMessage(id: string): UIMessage {
diff --git a/packages/ai-client/tests/transaction-client.test.ts b/packages/ai-client/tests/transaction-client.test.ts
deleted file mode 100644
index 07d7ed090..000000000
--- a/packages/ai-client/tests/transaction-client.test.ts
+++ /dev/null
@@ -1,371 +0,0 @@
-import { describe, expect, expectTypeOf, it } from 'vitest'
-import { chat, toolDefinition } from '@tanstack/ai'
-import { chatVerb, defineTransaction, verb } from '@tanstack/ai/transaction'
-import { z } from 'zod'
-import { TransactionClient } from '../src/transaction-client.js'
-import { fetchServerSentEvents } from '../src/connection-adapters.js'
-import type { AnyTextAdapter } from '@tanstack/ai'
-import type {
-  TransactionSubRun,
-  TransactionSystem,
-} from '../src/transaction-types.js'
-
-// Declared, never executed — used only inside chat callbacks that the type
-// tests never invoke (`defineTransaction` only runs `Object.keys`). Ambient,
-// so it emits no runtime binding and is never read.
-declare const adapter: AnyTextAdapter
-
-const emptyChatVerb = () => chatVerb(async function* () {} as any)
-
-describe('TransactionClient', () => {
-  it('creates one sub-client per declared verb, by kind', () => {
-    const txn = defineTransaction({
-      primaryChat: emptyChatVerb(),
-      banner: verb({ execute: async () => ({ url: 'x' }) }),
-    })
-    const client = new TransactionClient({
-      transaction: txn,
-      connection: fetchServerSentEvents('/api/transaction'),
-    })
-
-    expect(client.has('primaryChat')).toBe(true)
-    expect(client.has('banner')).toBe(true)
-    expect(client.has('speech')).toBe(false)
-    expect(client.chat('primaryChat')).toBeDefined()
-    expect(client.oneShot('banner')).toBeDefined()
-    expect(client.chat('banner')).toBeUndefined()
-    expect(client.oneShot('primaryChat')).toBeUndefined()
-    expect(client.verbs).toEqual(['primaryChat', 'banner'])
-  })
-
-  it('supports multiple chat verbs, each with its own ChatClient', () => {
-    const txn = defineTransaction({
-      primaryChat: emptyChatVerb(),
-      summaryChat: emptyChatVerb(),
-    })
-    const client = new TransactionClient({
-      transaction: txn,
-      connection: fetchServerSentEvents('/api/transaction'),
-    })
-
-    expect(client.chat('primaryChat')).toBeDefined()
-    expect(client.chat('summaryChat')).toBeDefined()
-    expect(client.chat('primaryChat')).not.toBe(client.chat('summaryChat'))
-  })
-
-  it('dispose() tears down every sub-client', () => {
-    const txn = defineTransaction({
-      primaryChat: emptyChatVerb(),
-      banner: verb({ execute: async () => ({}) }),
-      narration: verb({ execute: async () => ({}) }),
-    })
-    const client = new TransactionClient({
-      transaction: txn,
-      connection: fetchServerSentEvents('/api/transaction'),
-    })
-
-    const disposed: Array<string> = []
-    client.chat('primaryChat')!.dispose = () => {
-      disposed.push('primaryChat')
-    }
-    client.oneShot('banner')!.dispose = () => {
-      disposed.push('banner')
-    }
-    client.oneShot('narration')!.dispose = () => {
-      disposed.push('narration')
-    }
-
-    client.dispose()
-
-    expect(disposed.sort()).toEqual(['banner', 'narration', 'primaryChat'])
-  })
-
-  it('demuxes transaction sub-run events into per-verb state', () => {
-    const banner = verb({ execute: async () => ({ url: 'x' }) })
-    const txn = defineTransaction({
-      banner,
-      blogPost: verb({
-        execute: async (_r, ctx) => ctx.call(banner, undefined as never),
-      }),
-    })
-    const changes: Array<Array<TransactionSubRun>> = []
-    const client = new TransactionClient({
-      transaction: txn,
-      connection: fetchServerSentEvents('/api/transaction'),
-      callbacks: {
-        oneShot: (verbName) =>
-          verbName === 'blogPost'
-            ? { onSubRunsChange: (s) => changes.push(s) }
-            : {},
-      },
-    })
-
-    // Drive the demux directly through the GenerationClient's onChunk hook,
-    // simulating the server's event order.
-    const onChunk = (chunk: any) =>
-      (client as any).handleSubRunChunk(
-        'blogPost',
-        chunk,
-        changes.length >= 0 ? (s: any) => changes.push(s) : undefined,
-      )
-
-    onChunk({ type: 'RUN_STARTED', runId: 'r1', threadId: 't1' })
-    onChunk({
-      type: 'CUSTOM',
-      name: 'transaction:sub-run:started',
-      value: { runId: 'r1-sub-0', parentRunId: 'r1', verb: 'banner', index: 0 },
-    })
-    onChunk({
-      type: 'CUSTOM',
-      name: 'transaction:sub-run:chunk',
-      value: {
-        runId: 'r1-sub-0',
-        verb: 'banner',
-        index: 0,
-        chunk: { type: 'TEXT_MESSAGE_CONTENT', delta: 'Hel' },
-      },
-    })
-    onChunk({
-      type: 'CUSTOM',
-      name: 'transaction:sub-run:chunk',
-      value: {
-        runId: 'r1-sub-0',
-        verb: 'banner',
-        index: 0,
-        chunk: { type: 'TEXT_MESSAGE_CONTENT', delta: 'lo' },
-      },
-    })
-    onChunk({
-      type: 'CUSTOM',
-      name: 'transaction:sub-run:result',
-      value: {
-        runId: 'r1-sub-0',
-        verb: 'banner',
-        index: 0,
-        result: { url: 'img' },
-      },
-    })
-
-    const subRuns = client.getSubRuns('blogPost')
-    expect(subRuns).toHaveLength(1)
-    expect(subRuns[0]).toMatchObject({
-      runId: 'r1-sub-0',
-      verb: 'banner',
-      index: 0,
-      status: 'success',
-      result: { url: 'img' },
-      text: 'Hello',
-    })
-
-    // A new root run resets the sub-run state.
-    onChunk({ type: 'RUN_STARTED', runId: 'r2', threadId: 't1' })
-    expect(client.getSubRuns('blogPost')).toHaveLength(0)
-  })
-
-  it('marks a sub-run errored on the error event', () => {
-    const txn = defineTransaction({
-      blogPost: verb({ execute: async () => ({}) }),
-    })
-    const client = new TransactionClient({
-      transaction: txn,
-      connection: fetchServerSentEvents('/api/transaction'),
-    })
-    const onChunk = (chunk: any) =>
-      (client as any).handleSubRunChunk('blogPost', chunk, undefined)
-
-    onChunk({ type: 'RUN_STARTED', runId: 'r1', threadId: 't1' })
-    onChunk({
-      type: 'CUSTOM',
-      name: 'transaction:sub-run:started',
-      value: { runId: 'r1-sub-0', parentRunId: 'r1', verb: 'banner', index: 0 },
-    })
-    onChunk({
-      type: 'CUSTOM',
-      name: 'transaction:sub-run:error',
-      value: { runId: 'r1-sub-0', verb: 'banner', index: 0, message: 'nope' },
-    })
-
-    expect(client.getSubRuns('blogPost')[0]).toMatchObject({
-      status: 'error',
-      error: 'nope',
-    })
-  })
-
-  it('parses a structured chat sub-run into a live `partial`', () => {
-    const txn = defineTransaction({
-      blogPost: verb({ execute: async () => ({}) }),
-    })
-    const client = new TransactionClient({
-      transaction: txn,
-      connection: fetchServerSentEvents('/api/transaction'),
-    })
-    const onChunk = (chunk: any) =>
-      (client as any).handleSubRunChunk('blogPost', chunk, undefined)
-    const chunkEvent = (inner: any) =>
-      onChunk({
-        type: 'CUSTOM',
-        name: 'transaction:sub-run:chunk',
-        value: { runId: 'r1-sub-0', verb: 'drafting', index: 0, chunk: inner },
-      })
-
-    onChunk({ type: 'RUN_STARTED', runId: 'r1', threadId: 't1' })
-    onChunk({
-      type: 'CUSTOM',
-      name: 'transaction:sub-run:started',
-      value: {
-        runId: 'r1-sub-0',
-        parentRunId: 'r1',
-        verb: 'drafting',
-        index: 0,
-      },
-    })
-
-    // The structured output streams as partial JSON via TEXT_MESSAGE_CONTENT.
-    chunkEvent({ type: 'TEXT_MESSAGE_CONTENT', delta: '{"title":"Sour' })
-    expect(client.getSubRuns('blogPost')[0]?.partial).toEqual({ title: 'Sour' })
-
-    chunkEvent({
-      type: 'TEXT_MESSAGE_CONTENT',
-      delta: 'dough","body":"Once upon',
-    })
-    expect(client.getSubRuns('blogPost')[0]?.partial).toEqual({
-      title: 'Sourdough',
-      body: 'Once upon',
-    })
-
-    // The terminal event snaps `partial` to the fully-validated object.
-    chunkEvent({
-      type: 'CUSTOM',
-      name: 'structured-output.complete',
-      value: { object: { title: 'Sourdough', body: 'Once upon a loaf.' } },
-    })
-    expect(client.getSubRuns('blogPost')[0]?.partial).toEqual({
-      title: 'Sourdough',
-      body: 'Once upon a loaf.',
-    })
-  })
-
-  it('leaves `partial` unset for a plain-text (prose) chat sub-run', () => {
-    const txn = defineTransaction({
-      blogPost: verb({ execute: async () => ({}) }),
-    })
-    const client = new TransactionClient({
-      transaction: txn,
-      connection: fetchServerSentEvents('/api/transaction'),
-    })
-    const onChunk = (chunk: any) =>
-      (client as any).handleSubRunChunk('blogPost', chunk, undefined)
-
-    onChunk({ type: 'RUN_STARTED', runId: 'r1', threadId: 't1' })
-    onChunk({
-      type: 'CUSTOM',
-      name: 'transaction:sub-run:started',
-      value: {
-        runId: 'r1-sub-0',
-        parentRunId: 'r1',
-        verb: 'support',
-        index: 0,
-      },
-    })
-    onChunk({
-      type: 'CUSTOM',
-      name: 'transaction:sub-run:chunk',
-      value: {
-        runId: 'r1-sub-0',
-        verb: 'support',
-        index: 0,
-        chunk: {
-          type: 'TEXT_MESSAGE_CONTENT',
-          delta: 'Hello, how can I help?',
-        },
-      },
-    })
-
-    const sub = client.getSubRuns('blogPost')[0]
-    expect(sub?.text).toBe('Hello, how can I help?')
-    expect(sub?.partial).toBeUndefined()
-  })
-})
-
-describe('TransactionSystem typing', () => {
-  it('exposes only declared verbs, typed by kind', () => {
-    const txn = defineTransaction({
-      primaryChat: emptyChatVerb(),
-      banner: verb({
-        input: z.object({ prompt: z.string() }),
-        execute: async ({ input }) => ({ url: `img:${input.prompt}` }),
-      }),
-    })
-    type Sys = TransactionSystem<typeof txn>
-    expectTypeOf<Sys>().toHaveProperty('primaryChat')
-    expectTypeOf<Sys>().toHaveProperty('banner')
-    // @ts-expect-error speech was not declared
-    expectTypeOf<Sys>().toHaveProperty('speech')
-
-    // One-shot input comes from the verb's schema; result from execute.
-    expectTypeOf<Parameters<Sys['banner']['run']>[0]>().toEqualTypeOf<{
-      prompt: string
-    }>()
-    expectTypeOf<Sys['banner']['result']>().toEqualTypeOf<{
-      url: string
-    } | null>()
-    expectTypeOf<Sys['banner']['subRuns']>().toEqualTypeOf<
-      Array<TransactionSubRun>
-    >()
-  })
-
-  it('chat verb tools narrow that surface message tool-call parts', () => {
-    const weatherDef = toolDefinition({
-      name: 'get_weather',
-      description: 'Get the weather for a city',
-      inputSchema: z.object({ city: z.string() }),
-      outputSchema: z.object({ tempC: z.number() }),
-    })
-
-    const txn = defineTransaction({
-      primaryChat: chatVerb((req) =>
-        chat({ adapter, messages: req.messages, tools: [weatherDef] }),
-      ),
-    })
-
-    type Sys = TransactionSystem<typeof txn>
-    type Part = Sys['primaryChat']['messages'][number]['parts'][number]
-    type WeatherCall = Extract<Part, { type: 'tool-call'; name: 'get_weather' }>
-
-    expectTypeOf<WeatherCall['name']>().toEqualTypeOf<'get_weather'>()
-    expectTypeOf<WeatherCall['input']>().toEqualTypeOf<
-      { city: string } | undefined
-    >()
-    expectTypeOf<WeatherCall['output']>().toEqualTypeOf<
-      { tempC: number } | undefined
-    >()
-  })
-
-  it('outputSchema adds typed partial/final to that chat surface only', () => {
-    const outputSchema = z.object({ answer: z.string(), score: z.number() })
-
-    const txn = defineTransaction({
-      drafting: chatVerb((req) =>
-        chat({ adapter, messages: req.messages, outputSchema, stream: true }),
-      ),
-      support: chatVerb((req) => chat({ adapter, messages: req.messages })),
-    })
-
-    type Drafting = TransactionSystem<typeof txn>['drafting']
-    type Support = TransactionSystem<typeof txn>['support']
-
-    expectTypeOf<Drafting['final']>().toEqualTypeOf<{
-      answer: string
-      score: number
-    } | null>()
-    expectTypeOf<Drafting['partial']>().toEqualTypeOf<{
-      answer?: string
-      score?: number
-    }>()
-
-    // @ts-expect-error no outputSchema → no `partial` on this chat surface
-    expectTypeOf<Support>().toHaveProperty('partial')
-    // @ts-expect-error no outputSchema → no `final` on this chat surface
-    expectTypeOf<Support>().toHaveProperty('final')
-  })
-})
diff --git a/packages/ai-client/vite.config.ts b/packages/ai-client/vite.config.ts
index 0b9b5153a..f976d51f0 100644
--- a/packages/ai-client/vite.config.ts
+++ b/packages/ai-client/vite.config.ts
@@ -40,7 +40,7 @@ export default mergeConfig(
     // implementations; declare it as its own entry so the build emits
     // it independently and the main entry can stay free of the bridge
     // classes (they're imported only via `import type` from clients).
-    entry: ['./src/index.ts', './src/devtools.ts', './src/transaction.ts'],
+    entry: ['./src/index.ts', './src/devtools.ts', './src/plugin.ts'],
     srcDir: './src',
     cjs: false,
   }),
diff --git a/packages/ai-react/package.json b/packages/ai-react/package.json
index 6ff056126..acf8cf812 100644
--- a/packages/ai-react/package.json
+++ b/packages/ai-react/package.json
@@ -29,9 +29,9 @@
       "types": "./dist/esm/mcp-apps.d.ts",
       "import": "./dist/esm/mcp-apps.js"
     },
-    "./transaction": {
-      "types": "./dist/esm/transaction.d.ts",
-      "import": "./dist/esm/transaction.js"
+    "./plugin": {
+      "types": "./dist/esm/plugin.d.ts",
+      "import": "./dist/esm/plugin.js"
     }
   },
   "files": [
diff --git a/packages/ai-react/src/plugin.ts b/packages/ai-react/src/plugin.ts
new file mode 100644
index 000000000..f722b3895
--- /dev/null
+++ b/packages/ai-react/src/plugin.ts
@@ -0,0 +1 @@
+export { usePlugin } from './use-plugin'
diff --git a/packages/ai-react/src/transaction.ts b/packages/ai-react/src/transaction.ts
deleted file mode 100644
index 643dca5bf..000000000
--- a/packages/ai-react/src/transaction.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { useTransaction } from './use-transaction'
diff --git a/packages/ai-react/src/use-plugin.ts b/packages/ai-react/src/use-plugin.ts
new file mode 100644
index 000000000..e9adf2025
--- /dev/null
+++ b/packages/ai-react/src/use-plugin.ts
@@ -0,0 +1,307 @@
+import {
+  PluginClient,
+  computeStructuredParts,
+} from '@tanstack/ai-client/plugin'
+import { useEffect, useId, useMemo, useRef, useState } from 'react'
+import type { PluginDefinition } from '@tanstack/ai/plugin'
+import type {
+  PluginClientOptions,
+  PluginOptionsMap,
+  PluginSystem,
+} from '@tanstack/ai-client/plugin'
+import type {
+  ChatClientState,
+  ConnectConnectionAdapter,
+  ConnectionStatus,
+  GenerationClientState,
+} from '@tanstack/ai-client'
+
+/** Reactive chat-plugin state mirrored from the underlying ChatClient. */
+interface ChatState {
+  messages: Array<any>
+  isLoading: boolean
+  error: Error | undefined
+  status: ChatClientState
+  isSubscribed: boolean
+  connectionStatus: ConnectionStatus
+  sessionGenerating: boolean
+}
+
+/** Reactive generation-plugin state mirrored from a GenerationClient. */
+interface OneShotState {
+  result: any
+  isLoading: boolean
+  error: Error | undefined
+  status: GenerationClientState
+}
+
+const initialChatState: ChatState = {
+  messages: [],
+  isLoading: false,
+  error: undefined,
+  status: 'ready',
+  isSubscribed: false,
+  connectionStatus: 'disconnected',
+  sessionGenerating: false,
+}
+
+const initialOneShotState: OneShotState = {
+  result: null,
+  isLoading: false,
+  error: undefined,
+  status: 'idle',
+}
+
+/**
+ * Config keys reserved at the top level of the flat options object. Anything
+ * that is NOT one of these keys is treated as a per-plugin options entry keyed
+ * by the plugin's declared name. They are excluded from the per-name map at the
+ * type level (below) so a plugin literally named `connection`/`id`/`threadId`
+ * can never collide with these config keys.
+ */
+type ReservedOptionKey = 'connection' | 'id' | 'threadId'
+
+/**
+ * The FLAT options object accepted by {@link usePlugin}: the reserved config
+ * keys at the top level, PLUS one optional entry per declared plugin name whose
+ * value is that plugin's client options (`ChatPluginOptions` for chat plugins,
+ * `GenerationPluginClientOptions` for generation plugins — see
+ * `PluginOptionsMap`). Reserved keys are removed from the per-name map so they
+ * can never collide with a plugin whose name happens to match a config key.
+ *
+ * This is the reference shape the other framework packages (solid/vue/svelte)
+ * mirror:
+ *
+ * ```ts
+ * usePlugin(def, {
+ *   connection,                       // required transport
+ *   id?, threadId?,                   // optional config
+ *   drafting: { forwardedProps },     // chat plugin options
+ *   heroImage: { onResult },          // generation plugin options
+ * })
+ * ```
+ */
+export type UsePluginOptions<TDef extends PluginDefinition<any>> = {
+  connection: ConnectConnectionAdapter
+  id?: string
+  threadId?: string
+} & Omit<PluginOptionsMap<TDef>, ReservedOptionKey>
+
+/**
+ * The per-plugin options extracted from the flat options object once the
+ * reserved config keys have been removed — i.e. exactly the nested `plugins`
+ * map the underlying `PluginClient` consumes.
+ */
+type PerPluginOptions<TOptions> = Omit<TOptions, ReservedOptionKey>
+
+/**
+ * React hook wrapping `PluginClient`, composing the chat + generation clients
+ * behind one endpoint into a single typed system keyed by the plugin's declared
+ * names.
+ *
+ * Options are FLAT: reserved config keys (`connection`/`id`/`threadId`) sit at
+ * the top level alongside one optional entry per plugin name. Internally the
+ * hook splits the reserved keys back out and feeds the remaining per-plugin
+ * entries to `PluginClient` as its nested `plugins` map.
+ *
+ * @example
+ * ```tsx
+ * const plugin = usePlugin(blogPlugin, {
+ *   connection: fetchServerSentEvents('/api/blog'),
+ *   drafting: { forwardedProps: { tone: 'punchy' } },
+ *   heroImage: { onResult: (img) => img.url },
+ * })
+ *
+ * await plugin.drafting.sendMessage('hi')
+ * await plugin.heroImage.run({ prompt: 'a fox' })
+ * ```
+ */
+export function usePlugin<
+  TDef extends PluginDefinition<any>,
+  // Capture the concrete options object so each generation plugin's `onResult`
+  // transform flows into that plugin's `result` type.
+  TOptions extends UsePluginOptions<TDef>,
+>(
+  plugin: TDef,
+  options: TOptions,
+  // The returned system is typed off the NESTED `{ plugins }` shape because the
+  // client-side `PluginSystem`/`PluginResultType` helpers read per-plugin
+  // options from a nested `plugins` key. We adapt the flat options to that shape
+  // both here (type level) and below (runtime) — the flat→nested boundary lives
+  // entirely inside this hook.
+): PluginSystem<TDef, { plugins: PerPluginOptions<TOptions> }> {
+  const hookId = useId()
+  const clientId = options.id ?? hookId
+
+  const optionsRef = useRef(options)
+  optionsRef.current = options
+  const activeClientRef = useRef<PluginClient<TDef> | null>(null)
+
+  const [chatState, setChatState] = useState<Record<string, ChatState>>({})
+  const [oneShotState, setOneShotState] = useState<
+    Record<string, OneShotState>
+  >({})
+
+  const client = useMemo(() => {
+    // Widen to the concrete flat-options type first (a safe upcast, since
+    // TOptions extends it) so the rest-destructure below yields the concrete
+    // per-plugin map instead of an opaque generic `Omit`.
+    const base: UsePluginOptions<TDef> = optionsRef.current
+    // Split the reserved config keys out of the flat options; every remaining
+    // key is a per-plugin options entry keyed by plugin name.
+    const { connection, id, threadId, ...pluginOptions } = base
+
+    const setChatSlice = (
+      instance: PluginClient<TDef>,
+      pluginName: string,
+      patch: Partial<ChatState>,
+    ) => {
+      if (activeClientRef.current !== instance) return
+      setChatState((s) => ({
+        ...s,
+        [pluginName]: { ...(s[pluginName] ?? initialChatState), ...patch },
+      }))
+    }
+    const setOneShotSlice = (
+      instance: PluginClient<TDef>,
+      pluginName: string,
+      patch: Partial<OneShotState>,
+    ) => {
+      if (activeClientRef.current !== instance) return
+      setOneShotState((s) => ({
+        ...s,
+        [pluginName]: {
+          ...(s[pluginName] ?? initialOneShotState),
+          ...patch,
+        },
+      }))
+    }
+
+    const clientOptions: PluginClientOptions<TDef> = {
+      plugin,
+      connection,
+      id: id ?? hookId,
+      threadId,
+      // Flat→nested adaptation: the leftover per-name entries ARE the client's
+      // nested `plugins` map. Bridged through `unknown` because for a generic
+      // `TDef`, TS can't relate the rest's key set (`plugin names minus reserved
+      // keys`) to `PluginOptionsMap`'s (`all plugin names`). The conversion is
+      // safe by construction: reserving `connection`/`id`/`threadId` makes it
+      // impossible to supply options for a plugin whose name collides with a
+      // config key, so this map is exactly `PluginOptionsMap` minus (at most)
+      // those never-present optional keys.
+      plugins: pluginOptions as unknown as PluginOptionsMap<TDef>,
+      callbacks: {
+        chat: (pluginName) => ({
+          onMessagesChange: (m) =>
+            setChatSlice(instance, pluginName, { messages: m }),
+          onLoadingChange: (v) =>
+            setChatSlice(instance, pluginName, { isLoading: v }),
+          onErrorChange: (v) =>
+            setChatSlice(instance, pluginName, { error: v }),
+          onStatusChange: (v) =>
+            setChatSlice(instance, pluginName, { status: v }),
+          onSubscriptionChange: (v) =>
+            setChatSlice(instance, pluginName, { isSubscribed: v }),
+          onConnectionStatusChange: (v) =>
+            setChatSlice(instance, pluginName, { connectionStatus: v }),
+          onSessionGeneratingChange: (v) =>
+            setChatSlice(instance, pluginName, { sessionGenerating: v }),
+        }),
+        oneShot: (pluginName) => ({
+          onResultChange: (r) =>
+            setOneShotSlice(instance, pluginName, { result: r }),
+          onLoadingChange: (v) =>
+            setOneShotSlice(instance, pluginName, { isLoading: v }),
+          onErrorChange: (v) =>
+            setOneShotSlice(instance, pluginName, { error: v }),
+          onStatusChange: (v) =>
+            setOneShotSlice(instance, pluginName, { status: v }),
+        }),
+      },
+    }
+
+    const instance: PluginClient<TDef> = new PluginClient<TDef>(clientOptions)
+    activeClientRef.current = instance
+    return instance
+    // Client is intentionally keyed only on clientId, mirroring useChat.
+  }, [clientId])
+
+  useEffect(() => {
+    activeClientRef.current = client
+    return () => {
+      if (activeClientRef.current === client) {
+        activeClientRef.current = null
+      }
+      client.dispose()
+    }
+  }, [client])
+
+  const system = useMemo(() => {
+    const out: Record<string, unknown> = {}
+
+    for (const pluginName of client.plugins) {
+      const c = client.chat(pluginName)
+      if (c) {
+        const slice = chatState[pluginName] ?? initialChatState
+        const { partial, final } = computeStructuredParts(slice.messages)
+        out[pluginName] = {
+          messages: slice.messages,
+          sendMessage: async (content: any) => {
+            await c.sendMessage(content)
+            const msgs = c.getMessages()
+            const hasStructured =
+              msgs.at(-1)?.parts.some((p) => p.type === 'structured-output') ??
+              false
+            // Cast: TS can't structurally narrow the conditional return of
+            // PluginChatSurface['sendMessage'] against this runtime branch,
+            // mirroring the assembled-`system` cast below.
+            return (
+              hasStructured ? computeStructuredParts(msgs).final : msgs
+            ) as any
+          },
+          append: (message: any) => c.append(message),
+          reload: () => c.reload(),
+          stop: () => c.stop(),
+          clear: () => c.clear(),
+          setMessages: (messages: any) => c.setMessagesManually(messages),
+          addToolResult: (result: any) => c.addToolResult(result),
+          addToolApprovalResponse: (response: any) =>
+            c.addToolApprovalResponse(response),
+          isLoading: slice.isLoading,
+          error: slice.error,
+          status: slice.status,
+          isSubscribed: slice.isSubscribed,
+          connectionStatus: slice.connectionStatus,
+          sessionGenerating: slice.sessionGenerating,
+          // Runtime shape unconditionally exposes partial/final; the public
+          // PluginSystem type hides them when the chat plugin's outputSchema is
+          // absent, matching useChat's behavior.
+          partial,
+          final,
+        }
+        continue
+      }
+
+      const g = client.oneShot(pluginName)
+      if (!g) continue
+      const slice = oneShotState[pluginName] ?? initialOneShotState
+      out[pluginName] = {
+        run: async (input: any) => {
+          await g.generate(input)
+          return g.getResult()
+        },
+        result: slice.result,
+        isLoading: slice.isLoading,
+        error: slice.error,
+        status: slice.status,
+        stop: () => g.stop(),
+        reset: () => g.reset(),
+      }
+    }
+
+    return out as PluginSystem<TDef, { plugins: PerPluginOptions<TOptions> }>
+  }, [client, chatState, oneShotState])
+
+  return system
+}
diff --git a/packages/ai-react/src/use-transaction.ts b/packages/ai-react/src/use-transaction.ts
deleted file mode 100644
index ec3bc0c29..000000000
--- a/packages/ai-react/src/use-transaction.ts
+++ /dev/null
@@ -1,232 +0,0 @@
-import {
-  TransactionClient,
-  computeStructuredParts,
-} from '@tanstack/ai-client/transaction'
-import { useEffect, useId, useMemo, useRef, useState } from 'react'
-import type { TransactionDefinition } from '@tanstack/ai/transaction'
-import type {
-  TransactionClientOptions,
-  TransactionSubRun,
-  TransactionSystem,
-} from '@tanstack/ai-client/transaction'
-import type {
-  ChatClientState,
-  ConnectionStatus,
-  GenerationClientState,
-} from '@tanstack/ai-client'
-
-/** Reactive chat-verb state mirrored from the underlying ChatClient. */
-interface ChatState {
-  messages: Array<any>
-  isLoading: boolean
-  error: Error | undefined
-  status: ChatClientState
-  isSubscribed: boolean
-  connectionStatus: ConnectionStatus
-  sessionGenerating: boolean
-}
-
-/** Reactive one-shot-verb state mirrored from a GenerationClient. */
-interface OneShotState {
-  result: any
-  isLoading: boolean
-  error: Error | undefined
-  status: GenerationClientState
-  subRuns: Array<TransactionSubRun>
-}
-
-const initialChatState: ChatState = {
-  messages: [],
-  isLoading: false,
-  error: undefined,
-  status: 'ready',
-  isSubscribed: false,
-  connectionStatus: 'disconnected',
-  sessionGenerating: false,
-}
-
-const initialOneShotState: OneShotState = {
-  result: null,
-  isLoading: false,
-  error: undefined,
-  status: 'idle',
-  subRuns: [],
-}
-
-/**
- * React hook wrapping `TransactionClient`, composing the existing chat +
- * generation clients behind one endpoint into a single typed system keyed by
- * the transaction's declared verbs.
- *
- * @example
- * ```tsx
- * const txn = useTransaction(blogTransaction, {
- *   connection: fetchServerSentEvents('/api/blog'),
- * })
- *
- * await txn.primaryChat.sendMessage('hi')
- * await txn.banner.run({ prompt: 'a fox' })
- * txn.blogPost.subRuns // live sub-run state during a transaction run
- * ```
- */
-export function useTransaction<
-  TDef extends TransactionDefinition<any>,
-  // Capture the options object so per-verb `onResult` transforms flow into
-  // each one-shot verb's `result` type.
-  TOptions extends Omit<
-    TransactionClientOptions<TDef>,
-    'transaction' | 'callbacks'
-  >,
->(transaction: TDef, options: TOptions): TransactionSystem<TDef, TOptions> {
-  const hookId = useId()
-  const clientId = options.id ?? hookId
-
-  const optionsRef = useRef(options)
-  optionsRef.current = options
-  const activeClientRef = useRef<TransactionClient<TDef> | null>(null)
-
-  const [chatState, setChatState] = useState<Record<string, ChatState>>({})
-  const [oneShotState, setOneShotState] = useState<
-    Record<string, OneShotState>
-  >({})
-
-  const client = useMemo(() => {
-    const initial = optionsRef.current
-
-    const setChatSlice = (
-      instance: TransactionClient<TDef>,
-      verb: string,
-      patch: Partial<ChatState>,
-    ) => {
-      if (activeClientRef.current !== instance) return
-      setChatState((s) => ({
-        ...s,
-        [verb]: { ...(s[verb] ?? initialChatState), ...patch },
-      }))
-    }
-    const setOneShotSlice = (
-      instance: TransactionClient<TDef>,
-      verb: string,
-      patch: Partial<OneShotState>,
-    ) => {
-      if (activeClientRef.current !== instance) return
-      setOneShotState((s) => ({
-        ...s,
-        [verb]: { ...(s[verb] ?? initialOneShotState), ...patch },
-      }))
-    }
-
-    const instance: TransactionClient<TDef> = new TransactionClient<TDef>({
-      ...initial,
-      transaction,
-      id: clientId,
-      callbacks: {
-        chat: (verb) => ({
-          onMessagesChange: (m) =>
-            setChatSlice(instance, verb, { messages: m }),
-          onLoadingChange: (v) =>
-            setChatSlice(instance, verb, { isLoading: v }),
-          onErrorChange: (v) => setChatSlice(instance, verb, { error: v }),
-          onStatusChange: (v) => setChatSlice(instance, verb, { status: v }),
-          onSubscriptionChange: (v) =>
-            setChatSlice(instance, verb, { isSubscribed: v }),
-          onConnectionStatusChange: (v) =>
-            setChatSlice(instance, verb, { connectionStatus: v }),
-          onSessionGeneratingChange: (v) =>
-            setChatSlice(instance, verb, { sessionGenerating: v }),
-        }),
-        oneShot: (verb) => ({
-          onResultChange: (r) => setOneShotSlice(instance, verb, { result: r }),
-          onLoadingChange: (v) =>
-            setOneShotSlice(instance, verb, { isLoading: v }),
-          onErrorChange: (v) => setOneShotSlice(instance, verb, { error: v }),
-          onStatusChange: (v) => setOneShotSlice(instance, verb, { status: v }),
-          onSubRunsChange: (subRuns) =>
-            setOneShotSlice(instance, verb, { subRuns }),
-        }),
-      },
-    })
-    activeClientRef.current = instance
-    return instance
-    // Client is intentionally keyed only on clientId, mirroring useChat.
-  }, [clientId])
-
-  useEffect(() => {
-    activeClientRef.current = client
-    return () => {
-      if (activeClientRef.current === client) {
-        activeClientRef.current = null
-      }
-      client.dispose()
-    }
-  }, [client])
-
-  const system = useMemo(() => {
-    const out: Record<string, unknown> = {}
-
-    for (const verb of client.verbs) {
-      const c = client.chat(verb)
-      if (c) {
-        const slice = chatState[verb] ?? initialChatState
-        const { partial, final } = computeStructuredParts(slice.messages)
-        out[verb] = {
-          messages: slice.messages,
-          sendMessage: async (content: any) => {
-            await c.sendMessage(content)
-            const msgs = c.getMessages()
-            const hasStructured =
-              msgs.at(-1)?.parts.some((p) => p.type === 'structured-output') ??
-              false
-            // Cast: TS can't structurally narrow the conditional return of
-            // TransactionChatSurface['sendMessage'] against this runtime
-            // branch, mirroring the assembled-`system` cast below.
-            return (
-              hasStructured ? computeStructuredParts(msgs).final : msgs
-            ) as any
-          },
-          append: (message: any) => c.append(message),
-          reload: () => c.reload(),
-          stop: () => c.stop(),
-          clear: () => c.clear(),
-          setMessages: (messages: any) => c.setMessagesManually(messages),
-          addToolResult: (result: any) => c.addToolResult(result),
-          addToolApprovalResponse: (response: any) =>
-            c.addToolApprovalResponse(response),
-          isLoading: slice.isLoading,
-          error: slice.error,
-          status: slice.status,
-          isSubscribed: slice.isSubscribed,
-          connectionStatus: slice.connectionStatus,
-          sessionGenerating: slice.sessionGenerating,
-          // Runtime shape unconditionally exposes partial/final; the public
-          // TransactionSystem type hides them when the chat verb's
-          // outputSchema is absent, matching useChat's behavior.
-          partial,
-          final,
-        }
-        continue
-      }
-
-      const g = client.oneShot(verb)
-      if (!g) continue
-      const slice = oneShotState[verb] ?? initialOneShotState
-      out[verb] = {
-        run: async (input: any) => {
-          await g.generate(input)
-          return g.getResult()
-        },
-        result: slice.result,
-        isLoading: slice.isLoading,
-        error: slice.error,
-        status: slice.status,
-        stop: () => g.stop(),
-        reset: () => g.reset(),
-        subRuns: slice.subRuns,
-      }
-    }
-
-    return out as TransactionSystem<TDef, TOptions>
-  }, [client, chatState, oneShotState])
-
-  return system
-}
diff --git a/packages/ai-react/tests/use-plugin.test.tsx b/packages/ai-react/tests/use-plugin.test.tsx
new file mode 100644
index 000000000..1f6e5a79a
--- /dev/null
+++ b/packages/ai-react/tests/use-plugin.test.tsx
@@ -0,0 +1,208 @@
+import { describe, expect, expectTypeOf, it } from 'vitest'
+import { act, renderHook } from '@testing-library/react'
+import { chatPlugin, definePlugin, generationPlugin } from '@tanstack/ai/plugin'
+import { stream } from '@tanstack/ai-client'
+import { z } from 'zod'
+import { usePlugin } from '../src/use-plugin.js'
+
+// A connection adapter that replays canned chunks per plugin, branching on the
+// `plugin` discriminator forwarded by PluginClient.
+function fakeConnection() {
+  return stream(async function* (_messages, data) {
+    const pluginName = (data as Record<string, unknown> | undefined)?.plugin
+
+    if (pluginName === 'primaryChat') {
+      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
+      yield {
+        type: 'TEXT_MESSAGE_START',
+        messageId: 'm1',
+        role: 'assistant',
+      } as any
+      yield {
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'm1',
+        delta: 'hello',
+      } as any
+      yield { type: 'TEXT_MESSAGE_END', messageId: 'm1' } as any
+      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
+    } else {
+      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
+      yield {
+        type: 'CUSTOM',
+        name: 'generation:result',
+        value: { url: 'u' },
+      } as any
+      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
+    }
+  })
+}
+
+// A connection adapter that records every request body it sees, so tests can
+// assert per-plugin options (forwardedProps) reached the client's request.
+function capturingConnection(seen: Array<Record<string, unknown>>) {
+  return stream(async function* (_messages, data) {
+    seen.push((data ?? {}) as Record<string, unknown>)
+    const pluginName = (data as Record<string, unknown> | undefined)?.plugin
+    if (pluginName === 'primaryChat') {
+      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
+      yield {
+        type: 'TEXT_MESSAGE_START',
+        messageId: 'm1',
+        role: 'assistant',
+      } as any
+      yield {
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'm1',
+        delta: 'hello',
+      } as any
+      yield { type: 'TEXT_MESSAGE_END', messageId: 'm1' } as any
+      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
+    } else {
+      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
+      yield {
+        type: 'CUSTOM',
+        name: 'generation:result',
+        value: { url: 'u' },
+      } as any
+      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
+    }
+  })
+}
+
+function makePlugin() {
+  return definePlugin({
+    primaryChat: chatPlugin(async function* (r: any) {
+      yield { type: 'RUN_STARTED', threadId: r.threadId, runId: r.runId } as any
+    } as any),
+    banner: generationPlugin({
+      input: z.object({ prompt: z.string() }),
+      execute: async ({ input }) => ({ url: `img:${input.prompt}` }),
+    }),
+  })
+}
+
+describe('usePlugin', () => {
+  it('exposes only the declared plugins, by kind', () => {
+    const def = makePlugin()
+    const { result } = renderHook(() =>
+      usePlugin(def, { connection: fakeConnection() }),
+    )
+    expect(result.current.primaryChat).toBeDefined()
+    expect(result.current.primaryChat.sendMessage).toBeDefined()
+    expect(result.current.banner).toBeDefined()
+    expect(result.current.banner.run).toBeDefined()
+    expect((result.current as any).speech).toBeUndefined()
+  })
+
+  it('run() on a generation plugin populates its result, typed by the schema', async () => {
+    const def = makePlugin()
+    const { result } = renderHook(() =>
+      usePlugin(def, { connection: fakeConnection() }),
+    )
+
+    // The input type comes from the plugin's schema.
+    expectTypeOf(result.current.banner.run)
+      .parameter(0)
+      .toEqualTypeOf<{ prompt: string }>()
+
+    // Holder object (not a bare `let`) so TS keeps the awaited return type
+    // at the read site.
+    const captured: { value: typeof result.current.banner.result } = {
+      value: null,
+    }
+    await act(async () => {
+      captured.value = await result.current.banner.run({ prompt: 'a fox' })
+    })
+
+    expect(captured.value?.url).toBe('u')
+    expect(result.current.banner.result?.url).toBe('u')
+  })
+
+  it('sendMessage() on a chat plugin populates its messages', async () => {
+    const def = makePlugin()
+    const { result } = renderHook(() =>
+      usePlugin(def, { connection: fakeConnection() }),
+    )
+
+    const captured: { value: typeof result.current.primaryChat.messages } = {
+      value: [],
+    }
+    await act(async () => {
+      captured.value = await result.current.primaryChat.sendMessage('hi')
+    })
+
+    expect(captured.value.length).toBeGreaterThan(0)
+    expect(result.current.primaryChat.messages.length).toBeGreaterThan(0)
+  })
+
+  it('exposes chat partial/final with cleared defaults on first render', () => {
+    const def = makePlugin()
+    const { result } = renderHook(() =>
+      usePlugin(def, { connection: fakeConnection() }),
+    )
+
+    expect((result.current.primaryChat as any).partial).toEqual({})
+    expect((result.current.primaryChat as any).final).toBeNull()
+  })
+
+  it('applies a generation onResult transform and infers its type', async () => {
+    const def = makePlugin()
+    const { result } = renderHook(() =>
+      // Flat options: the per-plugin `banner` entry sits at the top level
+      // alongside `connection`, no nested `plugins`/`verbs` wrapper.
+      usePlugin(def, {
+        connection: fakeConnection(),
+        banner: {
+          onResult: (raw) => {
+            // The transform's input is the plugin's typed result
+            // (`toEqualTypeOf` fails if `raw` were `any`).
+            expectTypeOf(raw).toEqualTypeOf<{ url: string }>()
+            return raw.url
+          },
+        },
+      }),
+    )
+
+    // The surface `result` is the transform's (non-nullish) return type.
+    expectTypeOf(result.current.banner.result).toEqualTypeOf<string | null>()
+
+    const captured: { value: typeof result.current.banner.result } = {
+      value: null,
+    }
+    await act(async () => {
+      captured.value = await result.current.banner.run({ prompt: 'a fox' })
+    })
+
+    expect(captured.value).toBe('u')
+    expect(result.current.banner.result).toBe('u')
+  })
+
+  it('threads flat per-plugin options through to the client', async () => {
+    const def = makePlugin()
+    const seen: Array<Record<string, unknown>> = []
+    const { result } = renderHook(() =>
+      // A chat plugin's `forwardedProps` AND a generation plugin's `onResult`
+      // provided as sibling top-level keys — proving the flat shape both wires
+      // the request body and threads the result transform.
+      usePlugin(def, {
+        connection: capturingConnection(seen),
+        primaryChat: { forwardedProps: { tone: 'punchy' } },
+        banner: { onResult: (raw) => `url:${raw.url}` },
+      }),
+    )
+
+    await act(async () => {
+      await result.current.primaryChat.sendMessage('hi')
+    })
+    await act(async () => {
+      await result.current.banner.run({ prompt: 'a fox' })
+    })
+
+    // The chat plugin's forwardedProps reached the request body alongside the
+    // routing discriminator.
+    const chatData = seen.find((d) => d.plugin === 'primaryChat')
+    expect(chatData?.tone).toBe('punchy')
+    // The generation plugin's onResult transform was applied to its result.
+    expect(result.current.banner.result).toBe('url:u')
+  })
+})
diff --git a/packages/ai-react/tests/use-transaction.test.tsx b/packages/ai-react/tests/use-transaction.test.tsx
deleted file mode 100644
index 31e86d259..000000000
--- a/packages/ai-react/tests/use-transaction.test.tsx
+++ /dev/null
@@ -1,204 +0,0 @@
-import { describe, expect, expectTypeOf, it } from 'vitest'
-import { act, renderHook } from '@testing-library/react'
-import { chatVerb, defineTransaction, verb } from '@tanstack/ai/transaction'
-import { stream } from '@tanstack/ai-client'
-import { z } from 'zod'
-import { useTransaction } from '../src/use-transaction.js'
-
-// A connection adapter that replays canned chunks per verb, branching on the
-// `verb` discriminator forwarded by TransactionClient.
-function fakeConnection() {
-  return stream(async function* (_messages, data) {
-    const verbName = (data as Record<string, unknown> | undefined)?.verb
-
-    if (verbName === 'primaryChat') {
-      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
-      yield {
-        type: 'TEXT_MESSAGE_START',
-        messageId: 'm1',
-        role: 'assistant',
-      } as any
-      yield {
-        type: 'TEXT_MESSAGE_CONTENT',
-        messageId: 'm1',
-        delta: 'hello',
-      } as any
-      yield { type: 'TEXT_MESSAGE_END', messageId: 'm1' } as any
-      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
-    } else if (verbName === 'blogPost') {
-      // A transaction run: one banner sub-run, then the final result.
-      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
-      yield {
-        type: 'CUSTOM',
-        name: 'transaction:sub-run:started',
-        value: { runId: 'r-sub-0', parentRunId: 'r', verb: 'banner', index: 0 },
-      } as any
-      yield {
-        type: 'CUSTOM',
-        name: 'transaction:sub-run:result',
-        value: {
-          runId: 'r-sub-0',
-          verb: 'banner',
-          index: 0,
-          result: { url: 'hero.png' },
-        },
-      } as any
-      yield {
-        type: 'CUSTOM',
-        name: 'generation:result',
-        value: { title: 'Foxes', heroUrl: 'hero.png' },
-      } as any
-      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
-    } else {
-      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
-      yield {
-        type: 'CUSTOM',
-        name: 'generation:result',
-        value: { url: 'u' },
-      } as any
-      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
-    }
-  })
-}
-
-function makeTransaction() {
-  const banner = verb({
-    input: z.object({ prompt: z.string() }),
-    execute: async ({ input }) => ({ url: `img:${input.prompt}` }),
-  })
-  return defineTransaction({
-    primaryChat: chatVerb(async function* (r: any) {
-      yield { type: 'RUN_STARTED', threadId: r.threadId, runId: r.runId } as any
-    } as any),
-    banner,
-    blogPost: verb({
-      input: z.object({ topic: z.string() }),
-      execute: async ({ input }, ctx) => {
-        const hero = await ctx.call(banner, { prompt: input.topic })
-        return { title: input.topic, heroUrl: hero.url }
-      },
-    }),
-  })
-}
-
-describe('useTransaction', () => {
-  it('exposes only the declared verbs, by kind', () => {
-    const txn = makeTransaction()
-    const { result } = renderHook(() =>
-      useTransaction(txn, { connection: fakeConnection() }),
-    )
-    expect(result.current.primaryChat).toBeDefined()
-    expect(result.current.primaryChat.sendMessage).toBeDefined()
-    expect(result.current.banner).toBeDefined()
-    expect(result.current.banner.run).toBeDefined()
-    expect(result.current.blogPost).toBeDefined()
-    expect((result.current as any).speech).toBeUndefined()
-  })
-
-  it('run() on a one-shot verb populates its result, typed by the schema', async () => {
-    const txn = makeTransaction()
-    const { result } = renderHook(() =>
-      useTransaction(txn, { connection: fakeConnection() }),
-    )
-
-    // The input type comes from the verb's schema.
-    expectTypeOf(result.current.banner.run)
-      .parameter(0)
-      .toEqualTypeOf<{ prompt: string }>()
-
-    // Holder object (not a bare `let`) so TS keeps the awaited return type
-    // at the read site.
-    const captured: { value: typeof result.current.banner.result } = {
-      value: null,
-    }
-    await act(async () => {
-      captured.value = await result.current.banner.run({ prompt: 'a fox' })
-    })
-
-    expect(captured.value?.url).toBe('u')
-    expect(result.current.banner.result?.url).toBe('u')
-  })
-
-  it('sendMessage() on a chat verb populates its messages', async () => {
-    const txn = makeTransaction()
-    const { result } = renderHook(() =>
-      useTransaction(txn, { connection: fakeConnection() }),
-    )
-
-    const captured: { value: typeof result.current.primaryChat.messages } = {
-      value: [],
-    }
-    await act(async () => {
-      captured.value = await result.current.primaryChat.sendMessage('hi')
-    })
-
-    expect(captured.value.length).toBeGreaterThan(0)
-    expect(result.current.primaryChat.messages.length).toBeGreaterThan(0)
-  })
-
-  it('surfaces live sub-run state on a transaction run', async () => {
-    const txn = makeTransaction()
-    const { result } = renderHook(() =>
-      useTransaction(txn, { connection: fakeConnection() }),
-    )
-
-    await act(async () => {
-      await result.current.blogPost.run({ topic: 'foxes' })
-    })
-
-    expect(result.current.blogPost.result).toEqual({
-      title: 'Foxes',
-      heroUrl: 'hero.png',
-    })
-    expect(result.current.blogPost.subRuns).toHaveLength(1)
-    expect(result.current.blogPost.subRuns[0]).toMatchObject({
-      verb: 'banner',
-      status: 'success',
-      result: { url: 'hero.png' },
-    })
-    // The sibling banner surface is untouched by the transaction's sub-run.
-    expect(result.current.banner.result).toBeNull()
-  })
-
-  it('exposes chat partial/final with cleared defaults on first render', () => {
-    const txn = makeTransaction()
-    const { result } = renderHook(() =>
-      useTransaction(txn, { connection: fakeConnection() }),
-    )
-
-    expect((result.current.primaryChat as any).partial).toEqual({})
-    expect((result.current.primaryChat as any).final).toBeNull()
-  })
-
-  it('applies a one-shot onResult transform and infers its type', async () => {
-    const txn = makeTransaction()
-    const { result } = renderHook(() =>
-      useTransaction(txn, {
-        connection: fakeConnection(),
-        verbs: {
-          banner: {
-            onResult: (raw) => {
-              // The transform's input is the verb's typed result
-              // (`toEqualTypeOf` fails if `raw` were `any`).
-              expectTypeOf(raw).toEqualTypeOf<{ url: string }>()
-              return raw.url
-            },
-          },
-        },
-      }),
-    )
-
-    // The surface `result` is the transform's (non-nullish) return type.
-    expectTypeOf(result.current.banner.result).toEqualTypeOf<string | null>()
-
-    const captured: { value: typeof result.current.banner.result } = {
-      value: null,
-    }
-    await act(async () => {
-      captured.value = await result.current.banner.run({ prompt: 'a fox' })
-    })
-
-    expect(captured.value).toBe('u')
-    expect(result.current.banner.result).toBe('u')
-  })
-})
diff --git a/packages/ai-react/vite.config.ts b/packages/ai-react/vite.config.ts
index 8e9b04cb2..e0b7ec933 100644
--- a/packages/ai-react/vite.config.ts
+++ b/packages/ai-react/vite.config.ts
@@ -29,7 +29,7 @@ const config = defineConfig({
 export default mergeConfig(
   config,
   tanstackViteConfig({
-    entry: ['./src/index.ts', './src/mcp-apps.ts', './src/transaction.ts'],
+    entry: ['./src/index.ts', './src/mcp-apps.ts', './src/plugin.ts'],
     srcDir: './src',
     cjs: false,
   }),
diff --git a/packages/ai-solid/package.json b/packages/ai-solid/package.json
index 14b46d87b..387fada07 100644
--- a/packages/ai-solid/package.json
+++ b/packages/ai-solid/package.json
@@ -25,9 +25,9 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./transaction": {
-      "types": "./dist/transaction.d.ts",
-      "import": "./dist/transaction.js"
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "import": "./dist/plugin.js"
     }
   },
   "files": [
diff --git a/packages/ai-solid/src/plugin.ts b/packages/ai-solid/src/plugin.ts
new file mode 100644
index 000000000..f722b3895
--- /dev/null
+++ b/packages/ai-solid/src/plugin.ts
@@ -0,0 +1 @@
+export { usePlugin } from './use-plugin'
diff --git a/packages/ai-solid/src/transaction.ts b/packages/ai-solid/src/transaction.ts
deleted file mode 100644
index 643dca5bf..000000000
--- a/packages/ai-solid/src/transaction.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { useTransaction } from './use-transaction'
diff --git a/packages/ai-solid/src/use-plugin.ts b/packages/ai-solid/src/use-plugin.ts
new file mode 100644
index 000000000..d2c2d8de0
--- /dev/null
+++ b/packages/ai-solid/src/use-plugin.ts
@@ -0,0 +1,399 @@
+import {
+  createMemo,
+  createSignal,
+  createUniqueId,
+  onCleanup,
+  onMount,
+} from 'solid-js'
+
+import {
+  PluginClient,
+  computeStructuredParts,
+} from '@tanstack/ai-client/plugin'
+import type {
+  ChatClientState,
+  ConnectConnectionAdapter,
+  ConnectionStatus,
+  GenerationClientState,
+  MultimodalContent,
+  UIMessage,
+} from '@tanstack/ai-client'
+import type {
+  PluginClientOptions,
+  PluginOptionsMap,
+  PluginSystem,
+} from '@tanstack/ai-client/plugin'
+import type { ModelMessage } from '@tanstack/ai'
+import type { PluginDefinition } from '@tanstack/ai/plugin'
+
+/** Reactive chat-plugin sub-state, mirrored from that plugin's `ChatClient` callbacks. */
+interface ChatState {
+  messages: Array<UIMessage<any>>
+  isLoading: boolean
+  error: Error | undefined
+  status: ChatClientState
+  isSubscribed: boolean
+  connectionStatus: ConnectionStatus
+  sessionGenerating: boolean
+}
+
+/** Reactive generation-plugin sub-state, mirrored from a `GenerationClient`'s callbacks. */
+interface OneShotState {
+  result: unknown
+  isLoading: boolean
+  error: Error | undefined
+  status: GenerationClientState
+}
+
+const defaultChatState: ChatState = {
+  messages: [],
+  isLoading: false,
+  error: undefined,
+  status: 'ready',
+  isSubscribed: false,
+  connectionStatus: 'disconnected',
+  sessionGenerating: false,
+}
+
+const defaultOneShotState: OneShotState = {
+  result: null,
+  isLoading: false,
+  error: undefined,
+  status: 'idle',
+}
+
+/**
+ * Config keys reserved at the top level of the flat options object. Anything
+ * that is NOT one of these keys is treated as a per-plugin options entry keyed
+ * by the plugin's declared name. They are excluded from the per-name map at the
+ * type level (below) so a plugin literally named `connection`/`id`/`threadId`
+ * can never collide with these config keys.
+ */
+type ReservedOptionKey = 'connection' | 'id' | 'threadId'
+
+/**
+ * The FLAT options object accepted by {@link usePlugin}: the reserved config
+ * keys at the top level, PLUS one optional entry per declared plugin name whose
+ * value is that plugin's client options (`ChatPluginOptions` for chat plugins,
+ * `GenerationPluginClientOptions` for generation plugins — see
+ * `PluginOptionsMap`). Reserved keys are removed from the per-name map so they
+ * can never collide with a plugin whose name happens to match a config key.
+ *
+ * Mirrors the ai-react reference shape:
+ *
+ * ```ts
+ * usePlugin(def, {
+ *   connection,                       // required transport
+ *   id?, threadId?,                   // optional config
+ *   drafting: { forwardedProps },     // chat plugin options
+ *   heroImage: { onResult },          // generation plugin options
+ * })
+ * ```
+ */
+export type UsePluginOptions<TDef extends PluginDefinition<any>> = {
+  connection: ConnectConnectionAdapter
+  id?: string
+  threadId?: string
+} & Omit<PluginOptionsMap<TDef>, ReservedOptionKey>
+
+/**
+ * The per-plugin options extracted from the flat options object once the
+ * reserved config keys have been removed — i.e. exactly the nested `plugins`
+ * map the underlying `PluginClient` consumes.
+ */
+type PerPluginOptions<TOptions> = Omit<TOptions, ReservedOptionKey>
+
+/**
+ * Solid hook wrapping `PluginClient`, composing the existing chat + generation
+ * clients behind one endpoint into a single typed system keyed by the plugin's
+ * declared names.
+ *
+ * Mirrors the `useChat` idiom: state lives in `createSignal`s, the client is
+ * built once in a `createMemo` (`clientId` is a stable per-hook id), and every
+ * reactive callback is threaded into the `PluginClient` constructor via its
+ * `callbacks` option — `ChatClient` and `GenerationClient` only accept these
+ * callbacks at construction time, not through `updateOptions`.
+ *
+ * Options are FLAT: reserved config keys (`connection`/`id`/`threadId`) sit at
+ * the top level alongside one optional entry per plugin name. Internally the
+ * hook splits the reserved keys back out and feeds the remaining per-plugin
+ * entries to `PluginClient` as its nested `plugins` map.
+ *
+ * @example
+ * ```tsx
+ * const plugin = usePlugin(blogPlugin, {
+ *   connection: fetchServerSentEvents('/api/blog'),
+ *   drafting: { forwardedProps: { tone: 'punchy' } },
+ *   heroImage: { onResult: (img) => img.url },
+ * })
+ *
+ * await plugin.drafting.sendMessage('hi')
+ * await plugin.heroImage.run({ prompt: 'a fox' })
+ * ```
+ */
+export function usePlugin<
+  TDef extends PluginDefinition<any>,
+  // Capture the concrete options object so each generation plugin's `onResult`
+  // transform flows into that plugin's `result` type.
+  TOptions extends UsePluginOptions<TDef>,
+>(
+  plugin: TDef,
+  options: TOptions,
+  // The returned system is typed off the NESTED `{ plugins }` shape because the
+  // client-side `PluginSystem`/`PluginResultType` helpers read per-plugin
+  // options from a nested `plugins` key. We adapt the flat options to that shape
+  // both here (type level) and below (runtime) — the flat→nested boundary lives
+  // entirely inside this hook.
+): PluginSystem<TDef, { plugins: PerPluginOptions<TOptions> }> {
+  const hookId = createUniqueId()
+  const clientId = options.id || hookId
+
+  const [chatState, setChatState] = createSignal<Record<string, ChatState>>({})
+  const [oneShotState, setOneShotState] = createSignal<
+    Record<string, OneShotState>
+  >({})
+
+  const patchChatState = (pluginName: string, patch: Partial<ChatState>) => {
+    setChatState((s) => ({
+      ...s,
+      [pluginName]: { ...(s[pluginName] ?? defaultChatState), ...patch },
+    }))
+  }
+  const patchOneShotState = (
+    pluginName: string,
+    patch: Partial<OneShotState>,
+  ) => {
+    setOneShotState((s) => ({
+      ...s,
+      [pluginName]: { ...(s[pluginName] ?? defaultOneShotState), ...patch },
+    }))
+  }
+
+  // Build the PluginClient with every reactive callback wired through the
+  // constructor's `callbacks` option (ChatClient/GenerationClient only accept
+  // these at construction time).
+  const client = createMemo(() => {
+    // Widen to the concrete flat-options type first (a safe upcast, since
+    // TOptions extends it) so the rest-destructure below yields the concrete
+    // per-plugin map instead of an opaque generic `Omit`.
+    const base: UsePluginOptions<TDef> = options
+    // Split the reserved config keys out of the flat options; every remaining
+    // key is a per-plugin options entry keyed by plugin name.
+    const { connection, id, threadId, ...pluginOptions } = base
+
+    const clientOptions: PluginClientOptions<TDef> = {
+      plugin,
+      connection,
+      id: id ?? clientId,
+      threadId,
+      // Flat→nested adaptation: the leftover per-name entries ARE the client's
+      // nested `plugins` map. Bridged through `unknown` because for a generic
+      // `TDef`, TS can't relate the rest's key set (`plugin names minus reserved
+      // keys`) to `PluginOptionsMap`'s (`all plugin names`). The conversion is
+      // safe by construction: reserving `connection`/`id`/`threadId` makes it
+      // impossible to supply options for a plugin whose name collides with a
+      // config key, so this map is exactly `PluginOptionsMap` minus (at most)
+      // those never-present optional keys.
+      plugins: pluginOptions as unknown as PluginOptionsMap<TDef>,
+      callbacks: {
+        chat: (pluginName) => ({
+          onMessagesChange: (messages) =>
+            patchChatState(pluginName, { messages }),
+          onLoadingChange: (isLoading) =>
+            patchChatState(pluginName, { isLoading }),
+          onErrorChange: (error) => patchChatState(pluginName, { error }),
+          onStatusChange: (status) => patchChatState(pluginName, { status }),
+          onSubscriptionChange: (isSubscribed) =>
+            patchChatState(pluginName, { isSubscribed }),
+          onConnectionStatusChange: (connectionStatus) =>
+            patchChatState(pluginName, { connectionStatus }),
+          onSessionGeneratingChange: (sessionGenerating) =>
+            patchChatState(pluginName, { sessionGenerating }),
+        }),
+        oneShot: (pluginName) => ({
+          onResultChange: (result) => patchOneShotState(pluginName, { result }),
+          onLoadingChange: (isLoading) =>
+            patchOneShotState(pluginName, { isLoading }),
+          onErrorChange: (error) => patchOneShotState(pluginName, { error }),
+          onStatusChange: (status) => patchOneShotState(pluginName, { status }),
+        }),
+      },
+    }
+
+    return new PluginClient<TDef>(clientOptions)
+  })
+
+  // Sync initial chat state now that the client (and its per-plugin chat
+  // sub-clients) exists — mirrors useChat's `setMessages(client().getMessages())`.
+  for (const pluginName of client().plugins) {
+    const chatClient = client().chat(pluginName)
+    if (chatClient) {
+      patchChatState(pluginName, {
+        messages: chatClient.getMessages(),
+        isLoading: chatClient.getIsLoading(),
+        error: chatClient.getError(),
+        status: chatClient.getStatus(),
+        isSubscribed: chatClient.getIsSubscribed(),
+        connectionStatus: chatClient.getConnectionStatus(),
+        sessionGenerating: chatClient.getSessionGenerating(),
+      })
+    }
+  }
+
+  onMount(() => {
+    for (const pluginName of client().plugins) {
+      client().chat(pluginName)?.mountDevtools()
+    }
+  })
+
+  // Cleanup on unmount: tear down every chat and one-shot sub-client.
+  onCleanup(() => {
+    client().dispose()
+  })
+
+  // Narrowing helpers: plugin presence is guaranteed by construction (a surface
+  // for `pluginName` is only built below when the plugin actually declares it),
+  // but the sub-client getters are typed as `T | undefined`, so reads go
+  // through an explicit check rather than a non-null assertion.
+  const requireChatClient = (pluginName: string) => {
+    const chatClient = client().chat(pluginName)
+    if (chatClient === undefined) {
+      throw new Error(
+        `usePlugin: "${pluginName}" is not a chat plugin on this definition`,
+      )
+    }
+    return chatClient
+  }
+
+  const requireOneShotClient = (pluginName: string) => {
+    const oneShotClient = client().oneShot(pluginName)
+    if (oneShotClient === undefined) {
+      throw new Error(
+        `usePlugin: "${pluginName}" is not a one-shot plugin on this definition`,
+      )
+    }
+    return oneShotClient
+  }
+
+  // Built dynamically per declared plugin below; the object shape can't be
+  // statically checked against the mapped `PluginSystem` type, so it's
+  // assembled as `Record<string, any>` and cast once at the end.
+  const system: Record<string, any> = {}
+
+  for (const pluginName of client().plugins) {
+    if (client().chat(pluginName)) {
+      system[pluginName] = {
+        get messages() {
+          return chatState()[pluginName]?.messages ?? defaultChatState.messages
+        },
+        get isLoading() {
+          return chatState()[pluginName]?.isLoading ?? false
+        },
+        get error() {
+          return chatState()[pluginName]?.error
+        },
+        get status() {
+          return chatState()[pluginName]?.status ?? 'ready'
+        },
+        get isSubscribed() {
+          return chatState()[pluginName]?.isSubscribed ?? false
+        },
+        get connectionStatus() {
+          return chatState()[pluginName]?.connectionStatus ?? 'disconnected'
+        },
+        get sessionGenerating() {
+          return chatState()[pluginName]?.sessionGenerating ?? false
+        },
+        // Runtime shape unconditionally exposes partial/final; the public
+        // PluginSystem type hides them when the chat plugin's outputSchema
+        // is absent, matching useChat's behavior.
+        get partial() {
+          return computeStructuredParts(chatState()[pluginName]?.messages ?? [])
+            .partial
+        },
+        get final() {
+          return computeStructuredParts(chatState()[pluginName]?.messages ?? [])
+            .final
+        },
+        sendMessage: async (content: string | MultimodalContent) => {
+          const chatClient = requireChatClient(pluginName)
+          await chatClient.sendMessage(content)
+          const msgs = chatClient.getMessages()
+          const hasStructured =
+            msgs.at(-1)?.parts.some((p) => p.type === 'structured-output') ??
+            false
+          // Cast: TS can't structurally narrow the conditional return of
+          // PluginChatSurface['sendMessage'] against this runtime branch,
+          // mirroring the assembled-`system` cast at the end of this hook.
+          return (
+            hasStructured ? computeStructuredParts(msgs).final : msgs
+          ) as any
+        },
+        append: async (message: ModelMessage | UIMessage<any>) => {
+          await requireChatClient(pluginName).append(message)
+        },
+        reload: async () => {
+          await requireChatClient(pluginName).reload()
+        },
+        stop: () => {
+          requireChatClient(pluginName).stop()
+        },
+        clear: () => {
+          requireChatClient(pluginName).clear()
+        },
+        setMessages: (messages: Array<UIMessage<any>>) => {
+          requireChatClient(pluginName).setMessagesManually(messages)
+        },
+        addToolResult: async (result: {
+          toolCallId: string
+          tool: string
+          output: any
+          state?: 'output-available' | 'output-error'
+          errorText?: string
+        }) => {
+          await requireChatClient(pluginName).addToolResult(result)
+        },
+        addToolApprovalResponse: async (response: {
+          id: string
+          approved: boolean
+        }) => {
+          await requireChatClient(pluginName).addToolApprovalResponse(response)
+        },
+      }
+      continue
+    }
+
+    if (!client().oneShot(pluginName)) continue
+    system[pluginName] = {
+      get result() {
+        return oneShotState()[pluginName]?.result ?? null
+      },
+      get isLoading() {
+        return oneShotState()[pluginName]?.isLoading ?? false
+      },
+      get error() {
+        return oneShotState()[pluginName]?.error
+      },
+      get status() {
+        return oneShotState()[pluginName]?.status ?? 'idle'
+      },
+      run: async (input: Record<string, any>) => {
+        const oneShotClient = requireOneShotClient(pluginName)
+        await oneShotClient.generate(input)
+        return oneShotClient.getResult()
+      },
+      stop: () => {
+        requireOneShotClient(pluginName).stop()
+      },
+      reset: () => {
+        requireOneShotClient(pluginName).reset()
+      },
+    }
+  }
+
+  // eslint-disable-next-line no-restricted-syntax -- built dynamically per declared plugin; TS can't structurally verify the assembled object against the mapped PluginSystem type
+  return system as unknown as PluginSystem<
+    TDef,
+    { plugins: PerPluginOptions<TOptions> }
+  >
+}
diff --git a/packages/ai-solid/src/use-transaction.ts b/packages/ai-solid/src/use-transaction.ts
deleted file mode 100644
index b41a7525d..000000000
--- a/packages/ai-solid/src/use-transaction.ts
+++ /dev/null
@@ -1,323 +0,0 @@
-import {
-  createMemo,
-  createSignal,
-  createUniqueId,
-  onCleanup,
-  onMount,
-} from 'solid-js'
-
-import {
-  TransactionClient,
-  computeStructuredParts,
-} from '@tanstack/ai-client/transaction'
-import type {
-  ChatClientState,
-  ConnectionStatus,
-  GenerationClientState,
-  MultimodalContent,
-  UIMessage,
-} from '@tanstack/ai-client'
-import type {
-  TransactionClientOptions,
-  TransactionSubRun,
-  TransactionSystem,
-} from '@tanstack/ai-client/transaction'
-import type { ModelMessage } from '@tanstack/ai'
-import type { TransactionDefinition } from '@tanstack/ai/transaction'
-
-/** Reactive chat-verb sub-state, mirrored from that verb's `ChatClient` callbacks. */
-interface ChatState {
-  messages: Array<UIMessage<any>>
-  isLoading: boolean
-  error: Error | undefined
-  status: ChatClientState
-  isSubscribed: boolean
-  connectionStatus: ConnectionStatus
-  sessionGenerating: boolean
-}
-
-/** Reactive one-shot-verb sub-state, mirrored from a `GenerationClient`'s callbacks. */
-interface OneShotState {
-  result: unknown
-  isLoading: boolean
-  error: Error | undefined
-  status: GenerationClientState
-  subRuns: Array<TransactionSubRun>
-}
-
-const defaultChatState: ChatState = {
-  messages: [],
-  isLoading: false,
-  error: undefined,
-  status: 'ready',
-  isSubscribed: false,
-  connectionStatus: 'disconnected',
-  sessionGenerating: false,
-}
-
-const defaultOneShotState: OneShotState = {
-  result: null,
-  isLoading: false,
-  error: undefined,
-  status: 'idle',
-  subRuns: [],
-}
-
-/**
- * Solid hook wrapping `TransactionClient`, composing the existing chat +
- * generation clients behind one endpoint into a single typed system keyed by
- * the transaction's declared verbs.
- *
- * Mirrors the `useChat` idiom: state lives in `createSignal`s, the client is
- * built once in a `createMemo` (`clientId` is a stable per-hook id), and every
- * reactive callback is threaded into the `TransactionClient` constructor via
- * its `callbacks` option — `ChatClient` and `GenerationClient` only accept
- * these callbacks at construction time, not through `updateOptions`.
- *
- * @example
- * ```tsx
- * const txn = useTransaction(blogTransaction, {
- *   connection: fetchServerSentEvents('/api/blog'),
- * })
- *
- * await txn.primaryChat.sendMessage('hi')
- * await txn.banner.run({ prompt: 'a fox' })
- * txn.blogPost.subRuns // live sub-run state during a transaction run
- * ```
- */
-export function useTransaction<
-  TDef extends TransactionDefinition<any>,
-  // Capture the options object so per-verb `onResult` transforms flow into
-  // each one-shot verb's `result` type.
-  TOptions extends Omit<
-    TransactionClientOptions<TDef>,
-    'transaction' | 'callbacks'
-  >,
->(transaction: TDef, options: TOptions): TransactionSystem<TDef, TOptions> {
-  const hookId = createUniqueId()
-  const clientId = options.id || hookId
-
-  const [chatState, setChatState] = createSignal<Record<string, ChatState>>({})
-  const [oneShotState, setOneShotState] = createSignal<
-    Record<string, OneShotState>
-  >({})
-
-  const patchChatState = (verb: string, patch: Partial<ChatState>) => {
-    setChatState((s) => ({
-      ...s,
-      [verb]: { ...(s[verb] ?? defaultChatState), ...patch },
-    }))
-  }
-  const patchOneShotState = (verb: string, patch: Partial<OneShotState>) => {
-    setOneShotState((s) => ({
-      ...s,
-      [verb]: { ...(s[verb] ?? defaultOneShotState), ...patch },
-    }))
-  }
-
-  // Build the TransactionClient with every reactive callback wired through the
-  // constructor's `callbacks` option (ChatClient/GenerationClient only accept
-  // these at construction time).
-  const client = createMemo(() => {
-    return new TransactionClient<TDef>({
-      ...options,
-      transaction,
-      id: clientId,
-      callbacks: {
-        chat: (verb) => ({
-          onMessagesChange: (messages) => patchChatState(verb, { messages }),
-          onLoadingChange: (isLoading) => patchChatState(verb, { isLoading }),
-          onErrorChange: (error) => patchChatState(verb, { error }),
-          onStatusChange: (status) => patchChatState(verb, { status }),
-          onSubscriptionChange: (isSubscribed) =>
-            patchChatState(verb, { isSubscribed }),
-          onConnectionStatusChange: (connectionStatus) =>
-            patchChatState(verb, { connectionStatus }),
-          onSessionGeneratingChange: (sessionGenerating) =>
-            patchChatState(verb, { sessionGenerating }),
-        }),
-        oneShot: (verb) => ({
-          onResultChange: (result) => patchOneShotState(verb, { result }),
-          onLoadingChange: (isLoading) =>
-            patchOneShotState(verb, { isLoading }),
-          onErrorChange: (error) => patchOneShotState(verb, { error }),
-          onStatusChange: (status) => patchOneShotState(verb, { status }),
-          onSubRunsChange: (subRuns) => patchOneShotState(verb, { subRuns }),
-        }),
-      },
-    })
-  })
-
-  // Sync initial chat state now that the client (and its per-verb chat
-  // sub-clients) exists — mirrors useChat's `setMessages(client().getMessages())`.
-  for (const verb of client().verbs) {
-    const chatClient = client().chat(verb)
-    if (chatClient) {
-      patchChatState(verb, {
-        messages: chatClient.getMessages(),
-        isLoading: chatClient.getIsLoading(),
-        error: chatClient.getError(),
-        status: chatClient.getStatus(),
-        isSubscribed: chatClient.getIsSubscribed(),
-        connectionStatus: chatClient.getConnectionStatus(),
-        sessionGenerating: chatClient.getSessionGenerating(),
-      })
-    }
-  }
-
-  onMount(() => {
-    for (const verb of client().verbs) {
-      client().chat(verb)?.mountDevtools()
-    }
-  })
-
-  // Cleanup on unmount: tear down every chat and one-shot sub-client.
-  onCleanup(() => {
-    client().dispose()
-  })
-
-  // Narrowing helpers: verb presence is guaranteed by construction (a surface
-  // for `verb` is only built below when the transaction actually declares it),
-  // but the sub-client getters are typed as `T | undefined`, so reads go
-  // through an explicit check rather than a non-null assertion.
-  const requireChatClient = (verb: string) => {
-    const chatClient = client().chat(verb)
-    if (chatClient === undefined) {
-      throw new Error(
-        `useTransaction: "${verb}" is not a chat verb on this transaction`,
-      )
-    }
-    return chatClient
-  }
-
-  const requireOneShotClient = (verb: string) => {
-    const oneShotClient = client().oneShot(verb)
-    if (oneShotClient === undefined) {
-      throw new Error(
-        `useTransaction: "${verb}" is not a one-shot verb on this transaction`,
-      )
-    }
-    return oneShotClient
-  }
-
-  // Built dynamically per declared verb below; the object shape can't be
-  // statically checked against the mapped `TransactionSystem` type, so it's
-  // assembled as `Record<string, any>` and cast once at the end.
-  const system: Record<string, any> = {}
-
-  for (const verb of client().verbs) {
-    if (client().chat(verb)) {
-      system[verb] = {
-        get messages() {
-          return chatState()[verb]?.messages ?? defaultChatState.messages
-        },
-        get isLoading() {
-          return chatState()[verb]?.isLoading ?? false
-        },
-        get error() {
-          return chatState()[verb]?.error
-        },
-        get status() {
-          return chatState()[verb]?.status ?? 'ready'
-        },
-        get isSubscribed() {
-          return chatState()[verb]?.isSubscribed ?? false
-        },
-        get connectionStatus() {
-          return chatState()[verb]?.connectionStatus ?? 'disconnected'
-        },
-        get sessionGenerating() {
-          return chatState()[verb]?.sessionGenerating ?? false
-        },
-        // Runtime shape unconditionally exposes partial/final; the public
-        // TransactionSystem type hides them when the chat verb's outputSchema
-        // is absent, matching useChat's behavior.
-        get partial() {
-          return computeStructuredParts(chatState()[verb]?.messages ?? [])
-            .partial
-        },
-        get final() {
-          return computeStructuredParts(chatState()[verb]?.messages ?? []).final
-        },
-        sendMessage: async (content: string | MultimodalContent) => {
-          const chatClient = requireChatClient(verb)
-          await chatClient.sendMessage(content)
-          const msgs = chatClient.getMessages()
-          const hasStructured =
-            msgs.at(-1)?.parts.some((p) => p.type === 'structured-output') ??
-            false
-          // Cast: TS can't structurally narrow the conditional return of
-          // TransactionChatSurface['sendMessage'] against this runtime branch,
-          // mirroring the assembled-`system` cast at the end of this hook.
-          return (
-            hasStructured ? computeStructuredParts(msgs).final : msgs
-          ) as any
-        },
-        append: async (message: ModelMessage | UIMessage<any>) => {
-          await requireChatClient(verb).append(message)
-        },
-        reload: async () => {
-          await requireChatClient(verb).reload()
-        },
-        stop: () => {
-          requireChatClient(verb).stop()
-        },
-        clear: () => {
-          requireChatClient(verb).clear()
-        },
-        setMessages: (messages: Array<UIMessage<any>>) => {
-          requireChatClient(verb).setMessagesManually(messages)
-        },
-        addToolResult: async (result: {
-          toolCallId: string
-          tool: string
-          output: any
-          state?: 'output-available' | 'output-error'
-          errorText?: string
-        }) => {
-          await requireChatClient(verb).addToolResult(result)
-        },
-        addToolApprovalResponse: async (response: {
-          id: string
-          approved: boolean
-        }) => {
-          await requireChatClient(verb).addToolApprovalResponse(response)
-        },
-      }
-      continue
-    }
-
-    if (!client().oneShot(verb)) continue
-    system[verb] = {
-      get result() {
-        return oneShotState()[verb]?.result ?? null
-      },
-      get isLoading() {
-        return oneShotState()[verb]?.isLoading ?? false
-      },
-      get error() {
-        return oneShotState()[verb]?.error
-      },
-      get status() {
-        return oneShotState()[verb]?.status ?? 'idle'
-      },
-      get subRuns() {
-        return oneShotState()[verb]?.subRuns ?? defaultOneShotState.subRuns
-      },
-      run: async (input: Record<string, any>) => {
-        const oneShotClient = requireOneShotClient(verb)
-        await oneShotClient.generate(input)
-        return oneShotClient.getResult()
-      },
-      stop: () => {
-        requireOneShotClient(verb).stop()
-      },
-      reset: () => {
-        requireOneShotClient(verb).reset()
-      },
-    }
-  }
-
-  // eslint-disable-next-line no-restricted-syntax -- built dynamically per declared verb; TS can't structurally verify the assembled object against the mapped TransactionSystem type
-  return system as unknown as TransactionSystem<TDef, TOptions>
-}
diff --git a/packages/ai-solid/tests/use-transaction.test.tsx b/packages/ai-solid/tests/use-plugin.test.tsx
similarity index 52%
rename from packages/ai-solid/tests/use-transaction.test.tsx
rename to packages/ai-solid/tests/use-plugin.test.tsx
index ded1faaaa..7c6b3a313 100644
--- a/packages/ai-solid/tests/use-transaction.test.tsx
+++ b/packages/ai-solid/tests/use-plugin.test.tsx
@@ -1,17 +1,17 @@
 import { renderHook, waitFor } from '@solidjs/testing-library'
 import { describe, expect, expectTypeOf, it } from 'vitest'
-import { chatVerb, defineTransaction, verb } from '@tanstack/ai/transaction'
+import { chatPlugin, definePlugin, generationPlugin } from '@tanstack/ai/plugin'
 import { stream } from '@tanstack/ai-client'
 import { z } from 'zod'
-import { useTransaction } from '../src/use-transaction.js'
+import { usePlugin } from '../src/use-plugin.js'
 
-// A connection adapter that replays canned chunks per verb, branching on the
-// `verb` discriminator forwarded by TransactionClient.
+// A connection adapter that replays canned chunks per plugin, branching on the
+// `plugin` discriminator forwarded by PluginClient.
 function fakeConnection() {
   return stream(async function* (_messages, data) {
-    const verbName = (data as Record<string, unknown> | undefined)?.verb
+    const pluginName = (data as Record<string, unknown> | undefined)?.plugin
 
-    if (verbName === 'primaryChat') {
+    if (pluginName === 'primaryChat') {
       yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
       yield {
         type: 'TEXT_MESSAGE_START',
@@ -25,29 +25,37 @@ function fakeConnection() {
       } as any
       yield { type: 'TEXT_MESSAGE_END', messageId: 'm1' } as any
       yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
-    } else if (verbName === 'blogPost') {
-      // A transaction run: one banner sub-run, then the final result.
+    } else {
       yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
       yield {
         type: 'CUSTOM',
-        name: 'transaction:sub-run:started',
-        value: { runId: 'r-sub-0', parentRunId: 'r', verb: 'banner', index: 0 },
+        name: 'generation:result',
+        value: { url: 'u' },
       } as any
+      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
+    }
+  })
+}
+
+// A connection adapter that records every request body it sees, so tests can
+// assert per-plugin options (forwardedProps) reached the client's request.
+function capturingConnection(seen: Array<Record<string, unknown>>) {
+  return stream(async function* (_messages, data) {
+    seen.push((data ?? {}) as Record<string, unknown>)
+    const pluginName = (data as Record<string, unknown> | undefined)?.plugin
+    if (pluginName === 'primaryChat') {
+      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
       yield {
-        type: 'CUSTOM',
-        name: 'transaction:sub-run:result',
-        value: {
-          runId: 'r-sub-0',
-          verb: 'banner',
-          index: 0,
-          result: { url: 'hero.png' },
-        },
+        type: 'TEXT_MESSAGE_START',
+        messageId: 'm1',
+        role: 'assistant',
       } as any
       yield {
-        type: 'CUSTOM',
-        name: 'generation:result',
-        value: { title: 'Foxes', heroUrl: 'hero.png' },
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'm1',
+        delta: 'hello',
       } as any
+      yield { type: 'TEXT_MESSAGE_END', messageId: 'm1' } as any
       yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
     } else {
       yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
@@ -61,48 +69,39 @@ function fakeConnection() {
   })
 }
 
-function makeTransaction() {
-  const banner = verb({
-    input: z.object({ prompt: z.string() }),
-    execute: async ({ input }) => ({ url: `img:${input.prompt}` }),
-  })
-  return defineTransaction({
-    primaryChat: chatVerb(async function* (r: any) {
+function makePlugin() {
+  return definePlugin({
+    primaryChat: chatPlugin(async function* (r: any) {
       yield { type: 'RUN_STARTED', threadId: r.threadId, runId: r.runId } as any
     } as any),
-    banner,
-    blogPost: verb({
-      input: z.object({ topic: z.string() }),
-      execute: async ({ input }, ctx) => {
-        const hero = await ctx.call(banner, { prompt: input.topic })
-        return { title: input.topic, heroUrl: hero.url }
-      },
+    banner: generationPlugin({
+      input: z.object({ prompt: z.string() }),
+      execute: async ({ input }) => ({ url: `img:${input.prompt}` }),
     }),
   })
 }
 
-describe('useTransaction', () => {
-  it('exposes only the declared verbs, by kind', () => {
-    const txn = makeTransaction()
+describe('usePlugin', () => {
+  it('exposes only the declared plugins, by kind', () => {
+    const def = makePlugin()
     const { result } = renderHook(() =>
-      useTransaction(txn, { connection: fakeConnection() }),
+      usePlugin(def, { connection: fakeConnection() }),
     )
 
     expect(result.primaryChat).toBeDefined()
     expect(result.primaryChat.sendMessage).toBeDefined()
     expect(result.banner).toBeDefined()
     expect(result.banner.run).toBeDefined()
-    expect(result.blogPost).toBeDefined()
     expect((result as any).speech).toBeUndefined()
   })
 
-  it('run() on a one-shot verb populates its result, typed by the schema', async () => {
-    const txn = makeTransaction()
+  it('run() on a generation plugin populates its result, typed by the schema', async () => {
+    const def = makePlugin()
     const { result } = renderHook(() =>
-      useTransaction(txn, { connection: fakeConnection() }),
+      usePlugin(def, { connection: fakeConnection() }),
     )
 
-    // The input type comes from the verb's schema.
+    // The input type comes from the plugin's schema.
     expectTypeOf(result.banner.run)
       .parameter(0)
       .toEqualTypeOf<{ prompt: string }>()
@@ -121,10 +120,10 @@ describe('useTransaction', () => {
     expect(result.banner.isLoading).toBe(false)
   })
 
-  it('sendMessage() on a chat verb populates its messages', async () => {
-    const txn = makeTransaction()
+  it('sendMessage() on a chat plugin populates its messages', async () => {
+    const def = makePlugin()
     const { result } = renderHook(() =>
-      useTransaction(txn, { connection: fakeConnection() }),
+      usePlugin(def, { connection: fakeConnection() }),
     )
 
     expect(result.primaryChat.messages).toEqual([])
@@ -154,51 +153,29 @@ describe('useTransaction', () => {
     expect(textPart?.content).toBe('hello')
   })
 
-  it('surfaces live sub-run state on a transaction run', async () => {
-    const txn = makeTransaction()
-    const { result } = renderHook(() =>
-      useTransaction(txn, { connection: fakeConnection() }),
-    )
-
-    await result.blogPost.run({ topic: 'foxes' })
-
-    expect(result.blogPost.result).toEqual({
-      title: 'Foxes',
-      heroUrl: 'hero.png',
-    })
-    expect(result.blogPost.subRuns).toHaveLength(1)
-    expect(result.blogPost.subRuns[0]).toMatchObject({
-      verb: 'banner',
-      status: 'success',
-      result: { url: 'hero.png' },
-    })
-    // The sibling banner surface is untouched by the transaction's sub-run.
-    expect(result.banner.result).toBeNull()
-  })
-
   it('exposes chat partial/final with cleared defaults on first render', () => {
-    const txn = makeTransaction()
+    const def = makePlugin()
     const { result } = renderHook(() =>
-      useTransaction(txn, { connection: fakeConnection() }),
+      usePlugin(def, { connection: fakeConnection() }),
     )
 
     expect((result.primaryChat as any).partial).toEqual({})
     expect((result.primaryChat as any).final).toBeNull()
   })
 
-  it('applies a one-shot onResult transform and infers its type', async () => {
-    const txn = makeTransaction()
+  it('applies a generation onResult transform and infers its type', async () => {
+    const def = makePlugin()
     const { result } = renderHook(() =>
-      useTransaction(txn, {
+      // Flat options: the per-plugin `banner` entry sits at the top level
+      // alongside `connection`, no nested `plugins`/`verbs` wrapper.
+      usePlugin(def, {
         connection: fakeConnection(),
-        verbs: {
-          banner: {
-            onResult: (raw) => {
-              // The transform's input is the verb's typed result
-              // (`toEqualTypeOf` fails if `raw` were `any`).
-              expectTypeOf(raw).toEqualTypeOf<{ url: string }>()
-              return raw.url
-            },
+        banner: {
+          onResult: (raw) => {
+            // The transform's input is the plugin's typed result
+            // (`toEqualTypeOf` fails if `raw` were `any`).
+            expectTypeOf(raw).toEqualTypeOf<{ url: string }>()
+            return raw.url
           },
         },
       }),
@@ -212,10 +189,35 @@ describe('useTransaction', () => {
     expect(result.banner.result).toBe('u')
   })
 
+  it('threads flat per-plugin options through to the client', async () => {
+    const def = makePlugin()
+    const seen: Array<Record<string, unknown>> = []
+    const { result } = renderHook(() =>
+      // A chat plugin's `forwardedProps` AND a generation plugin's `onResult`
+      // provided as sibling top-level keys — proving the flat shape both wires
+      // the request body and threads the result transform.
+      usePlugin(def, {
+        connection: capturingConnection(seen),
+        primaryChat: { forwardedProps: { tone: 'punchy' } },
+        banner: { onResult: (raw) => `url:${raw.url}` },
+      }),
+    )
+
+    await result.primaryChat.sendMessage('hi')
+    await result.banner.run({ prompt: 'a fox' })
+
+    // The chat plugin's forwardedProps reached the request body alongside the
+    // routing discriminator.
+    const chatData = seen.find((d) => d.plugin === 'primaryChat')
+    expect(chatData?.tone).toBe('punchy')
+    // The generation plugin's onResult transform was applied to its result.
+    expect(result.banner.result).toBe('url:u')
+  })
+
   it('disposes every chat and one-shot sub-client on cleanup', () => {
-    const txn = makeTransaction()
+    const def = makePlugin()
     const { result, cleanup } = renderHook(() =>
-      useTransaction(txn, { connection: fakeConnection() }),
+      usePlugin(def, { connection: fakeConnection() }),
     )
 
     expect(result.primaryChat).toBeDefined()
diff --git a/packages/ai-solid/tsdown.config.ts b/packages/ai-solid/tsdown.config.ts
index e2591dbd6..78db2c84d 100644
--- a/packages/ai-solid/tsdown.config.ts
+++ b/packages/ai-solid/tsdown.config.ts
@@ -1,7 +1,7 @@
 import { defineConfig } from 'tsdown'
 
 export default defineConfig({
-  entry: ['./src/index.ts', './src/transaction.ts'],
+  entry: ['./src/index.ts', './src/plugin.ts'],
   format: ['esm'],
   unbundle: true,
   dts: true,
diff --git a/packages/ai-svelte/package.json b/packages/ai-svelte/package.json
index 86e1471ee..d6e973d7f 100644
--- a/packages/ai-svelte/package.json
+++ b/packages/ai-svelte/package.json
@@ -27,10 +27,10 @@
       "svelte": "./dist/index.js",
       "import": "./dist/index.js"
     },
-    "./transaction": {
-      "types": "./dist/transaction.d.ts",
-      "svelte": "./dist/transaction.js",
-      "import": "./dist/transaction.js"
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "svelte": "./dist/plugin.js",
+      "import": "./dist/plugin.js"
     }
   },
   "files": [
diff --git a/packages/ai-svelte/src/create-plugin.svelte.ts b/packages/ai-svelte/src/create-plugin.svelte.ts
new file mode 100644
index 000000000..de6f06981
--- /dev/null
+++ b/packages/ai-svelte/src/create-plugin.svelte.ts
@@ -0,0 +1,376 @@
+import {
+  PluginClient,
+  computeStructuredParts,
+} from '@tanstack/ai-client/plugin'
+import type {
+  PluginClientOptions,
+  PluginOptionsMap,
+  PluginSystem,
+} from '@tanstack/ai-client/plugin'
+import type {
+  ChatClientState,
+  ConnectConnectionAdapter,
+  ConnectionStatus,
+  GenerationClientState,
+} from '@tanstack/ai-client'
+import type { PluginDefinition } from '@tanstack/ai/plugin'
+import type { ModelMessage } from '@tanstack/ai'
+import type { MultimodalContent, UIMessage } from './types'
+
+/** Reactive chat-plugin state mirrored from the underlying ChatClient. */
+interface ChatState {
+  messages: Array<UIMessage<any>>
+  isLoading: boolean
+  error: Error | undefined
+  status: ChatClientState
+  isSubscribed: boolean
+  connectionStatus: ConnectionStatus
+  sessionGenerating: boolean
+}
+
+/** Reactive one-shot-plugin state mirrored from a GenerationClient. */
+interface OneShotState {
+  result: unknown
+  isLoading: boolean
+  error: Error | undefined
+  status: GenerationClientState
+}
+
+const makeInitialChatState = (): ChatState => ({
+  messages: [],
+  isLoading: false,
+  error: undefined,
+  status: 'ready',
+  isSubscribed: false,
+  connectionStatus: 'disconnected',
+  sessionGenerating: false,
+})
+
+const makeInitialOneShotState = (): OneShotState => ({
+  result: null,
+  isLoading: false,
+  error: undefined,
+  status: 'idle',
+})
+
+/**
+ * Config keys reserved at the top level of the flat options object. Anything
+ * that is NOT one of these keys is treated as a per-plugin options entry keyed
+ * by the plugin's declared name. They are excluded from the per-name map at the
+ * type level (below) so a plugin literally named `connection`/`id`/`threadId`
+ * can never collide with these config keys.
+ */
+type ReservedOptionKey = 'connection' | 'id' | 'threadId'
+
+/**
+ * The FLAT options object accepted by {@link createPlugin}: the reserved config
+ * keys at the top level, PLUS one optional entry per declared plugin name whose
+ * value is that plugin's client options (`ChatPluginOptions` for chat plugins,
+ * `GenerationPluginClientOptions` for generation plugins — see
+ * `PluginOptionsMap`). Reserved keys are removed from the per-name map so they
+ * can never collide with a plugin whose name happens to match a config key.
+ *
+ * This mirrors the reference shape shared with the other framework packages
+ * (react/solid/vue):
+ *
+ * ```ts
+ * createPlugin(def, {
+ *   connection,                       // required transport
+ *   id?, threadId?,                   // optional config
+ *   drafting: { forwardedProps },     // chat plugin options
+ *   heroImage: { onResult },          // generation plugin options
+ * })
+ * ```
+ */
+export type CreatePluginOptions<TDef extends PluginDefinition<any>> = {
+  connection: ConnectConnectionAdapter
+  id?: string
+  threadId?: string
+} & Omit<PluginOptionsMap<TDef>, ReservedOptionKey>
+
+/**
+ * The per-plugin options extracted from the flat options object once the
+ * reserved config keys have been removed — i.e. exactly the nested `plugins`
+ * map the underlying `PluginClient` consumes.
+ */
+type PerPluginOptions<TOptions> = Omit<TOptions, ReservedOptionKey>
+
+/**
+ * Creates a reactive plugin instance for Svelte 5.
+ *
+ * This function wraps the `PluginClient` from `@tanstack/ai-client` and exposes
+ * reactive state using Svelte 5 runes, one surface per declared plugin (any
+ * number of chat plugins plus any one-shot/generation plugins). The returned
+ * object exposes reactive getters that automatically update when state changes.
+ *
+ * Options are FLAT: reserved config keys (`connection`/`id`/`threadId`) sit at
+ * the top level alongside one optional entry per plugin name. Internally the
+ * function splits the reserved keys back out and feeds the remaining per-plugin
+ * entries to `PluginClient` as its nested `plugins` map.
+ *
+ * @example
+ * ```svelte
+ * <script>
+ *   import { createPlugin, fetchServerSentEvents } from '@tanstack/ai-svelte'
+ *   // myPlugin: your definePlugin(...) value
+ *
+ *   const plugin = createPlugin(myPlugin, {
+ *     connection: fetchServerSentEvents('/api/blog'),
+ *     drafting: { forwardedProps: { tone: 'punchy' } },
+ *     heroImage: { onResult: (img) => img.url },
+ *   })
+ * </script>
+ *
+ * <div>
+ *   {#each plugin.primaryChat.messages as message}
+ *     <div>{message.role}: {message.parts[0].content}</div>
+ *   {/each}
+ *
+ *   <button onclick={() => plugin.primaryChat.sendMessage('Hello!')}>Send</button>
+ *   <button onclick={() => plugin.heroImage.run({ prompt: 'a fox' })}>
+ *     Generate banner
+ *   </button>
+ * </div>
+ * ```
+ */
+export function createPlugin<
+  TDef extends PluginDefinition<any>,
+  // Capture the concrete options object so each generation plugin's `onResult`
+  // transform flows into that plugin's `result` type.
+  TOptions extends CreatePluginOptions<TDef> = CreatePluginOptions<TDef>,
+>(
+  plugin: TDef,
+  options: TOptions,
+  // The returned system is typed off the NESTED `{ plugins }` shape because the
+  // client-side `PluginSystem`/`PluginResultType` helpers read per-plugin
+  // options from a nested `plugins` key. We adapt the flat options to that shape
+  // both here (type level) and below (runtime) — the flat→nested boundary lives
+  // entirely inside this function.
+): PluginSystem<TDef, { plugins: PerPluginOptions<TOptions> }> & {
+  dispose: () => void
+} {
+  // Split the reserved config keys out of the flat options; every remaining
+  // key is a per-plugin options entry keyed by plugin name.
+  const { connection, id, threadId, ...pluginOptions } = options
+
+  // Reactive state per chat plugin, keyed by plugin name. Initialized eagerly
+  // for every declared plugin, since `plugin.plugins` is fixed at creation
+  // time (mirrors `PluginClient`'s own constructor, which iterates the same
+  // array).
+  const chatStates = $state<Record<string, ChatState>>({})
+  // Reactive state per one-shot plugin, keyed by plugin name.
+  const oneShotStates = $state<Record<string, OneShotState>>({})
+  for (const pluginName of plugin.plugins) {
+    if (plugin.pluginKinds[pluginName] === 'chat') {
+      chatStates[pluginName] = makeInitialChatState()
+    } else {
+      oneShotStates[pluginName] = makeInitialOneShotState()
+    }
+  }
+
+  // Return (and lazily create) the reactive state slot for a plugin, avoiding
+  // a non-null assertion at each call site below.
+  const ensureChatState = (pluginName: string): ChatState => {
+    let state = chatStates[pluginName]
+    if (!state) {
+      state = makeInitialChatState()
+      chatStates[pluginName] = state
+    }
+    return state
+  }
+  const ensureOneShotState = (pluginName: string): OneShotState => {
+    let state = oneShotStates[pluginName]
+    if (!state) {
+      state = makeInitialOneShotState()
+      oneShotStates[pluginName] = state
+    }
+    return state
+  }
+
+  // Create the PluginClient eagerly, once. Reactive callbacks are passed into
+  // the constructor (the only place ChatClient/GenerationClient accept them)
+  // rather than via `updateOptions`, mirroring `createChat`.
+  const clientOptions: PluginClientOptions<TDef> = {
+    plugin,
+    connection,
+    id,
+    threadId,
+    // Flat→nested adaptation: the leftover per-name entries ARE the client's
+    // nested `plugins` map. Bridged through `unknown` because for a generic
+    // `TDef`, TS can't relate the rest's key set (`plugin names minus reserved
+    // keys`) to `PluginOptionsMap`'s (`all plugin names`). The conversion is
+    // safe by construction: reserving `connection`/`id`/`threadId` makes it
+    // impossible to supply options for a plugin whose name collides with a
+    // config key, so this map is exactly `PluginOptionsMap` minus (at most)
+    // those never-present optional keys.
+    plugins: pluginOptions as unknown as PluginOptionsMap<TDef>,
+    callbacks: {
+      chat: (pluginName) => ({
+        onMessagesChange: (newMessages) => {
+          ensureChatState(pluginName).messages = newMessages
+        },
+        onLoadingChange: (newIsLoading) => {
+          ensureChatState(pluginName).isLoading = newIsLoading
+        },
+        onErrorChange: (newError) => {
+          ensureChatState(pluginName).error = newError
+        },
+        onStatusChange: (newStatus) => {
+          ensureChatState(pluginName).status = newStatus
+        },
+        onSubscriptionChange: (nextIsSubscribed) => {
+          ensureChatState(pluginName).isSubscribed = nextIsSubscribed
+        },
+        onConnectionStatusChange: (nextStatus) => {
+          ensureChatState(pluginName).connectionStatus = nextStatus
+        },
+        onSessionGeneratingChange: (isGenerating) => {
+          ensureChatState(pluginName).sessionGenerating = isGenerating
+        },
+      }),
+      oneShot: (pluginName) => ({
+        onResultChange: (result) => {
+          ensureOneShotState(pluginName).result = result
+        },
+        onLoadingChange: (isLoading) => {
+          ensureOneShotState(pluginName).isLoading = isLoading
+        },
+        onErrorChange: (error) => {
+          ensureOneShotState(pluginName).error = error
+        },
+        onStatusChange: (status) => {
+          ensureOneShotState(pluginName).status = status
+        },
+      }),
+    },
+  }
+
+  const client = new PluginClient<TDef>(clientOptions)
+
+  // Note: No auto-cleanup in Svelte — call `dispose()` in your component's
+  // cleanup if needed. Unlike React/Vue/Solid, Svelte 5 runes like $effect
+  // can only be used during component initialization.
+  const dispose = () => {
+    client.dispose()
+  }
+
+  // Build the returned system: one entry per declared plugin, plus a
+  // top-level `dispose`. Uses getters so Svelte tracks the underlying
+  // `$state` without a `$` prefix.
+  const system: Record<string, unknown> = {}
+
+  for (const pluginName of client.plugins) {
+    const chatClient = client.chat(pluginName)
+    if (chatClient) {
+      ensureChatState(pluginName).messages = chatClient.getMessages()
+
+      // Derived structured-output `partial`/`final`, recomputed whenever
+      // this plugin's messages change (mirrors `usePlugin`'s `useMemo`).
+      const structuredParts = $derived(
+        computeStructuredParts(chatStates[pluginName]?.messages ?? []),
+      )
+
+      system[pluginName] = {
+        get messages() {
+          return chatStates[pluginName]?.messages ?? []
+        },
+        get isLoading() {
+          return chatStates[pluginName]?.isLoading ?? false
+        },
+        get error() {
+          return chatStates[pluginName]?.error
+        },
+        get status() {
+          return chatStates[pluginName]?.status ?? 'ready'
+        },
+        get isSubscribed() {
+          return chatStates[pluginName]?.isSubscribed ?? false
+        },
+        get connectionStatus() {
+          return chatStates[pluginName]?.connectionStatus ?? 'disconnected'
+        },
+        get sessionGenerating() {
+          return chatStates[pluginName]?.sessionGenerating ?? false
+        },
+        // Runtime shape unconditionally exposes partial/final; the public
+        // PluginSystem type hides them when the chat plugin's outputSchema is
+        // absent, matching useChat's behavior.
+        get partial() {
+          return structuredParts.partial
+        },
+        get final() {
+          return structuredParts.final
+        },
+        sendMessage: async (content: string | MultimodalContent) => {
+          await chatClient.sendMessage(content)
+          const msgs = chatClient.getMessages()
+          const hasStructured =
+            msgs.at(-1)?.parts.some((p) => p.type === 'structured-output') ??
+            false
+          // Cast: TS can't structurally narrow the conditional return of
+          // PluginChatSurface['sendMessage'] against this runtime branch,
+          // mirroring the assembled-`system` cast at the end of this function.
+          return (
+            hasStructured ? computeStructuredParts(msgs).final : msgs
+          ) as any
+        },
+        append: (message: ModelMessage | UIMessage<any>) =>
+          chatClient.append(message),
+        reload: () => chatClient.reload(),
+        stop: () => chatClient.stop(),
+        clear: () => chatClient.clear(),
+        setMessages: (newMessages: Array<UIMessage<any>>) =>
+          chatClient.setMessagesManually(newMessages),
+        addToolResult: (result: {
+          toolCallId: string
+          tool: string
+          output: any
+          state?: 'output-available' | 'output-error'
+          errorText?: string
+        }) => chatClient.addToolResult(result),
+        addToolApprovalResponse: (response: {
+          id: string
+          approved: boolean
+        }) => chatClient.addToolApprovalResponse(response),
+      }
+      continue
+    }
+
+    const oneShotClient = client.oneShot(pluginName)
+    if (!oneShotClient) continue
+    system[pluginName] = {
+      run: async (input: any) => {
+        await oneShotClient.generate(input)
+        return oneShotClient.getResult()
+      },
+      get result() {
+        return oneShotStates[pluginName]?.result ?? null
+      },
+      get isLoading() {
+        return oneShotStates[pluginName]?.isLoading ?? false
+      },
+      get error() {
+        return oneShotStates[pluginName]?.error
+      },
+      get status() {
+        return oneShotStates[pluginName]?.status ?? 'idle'
+      },
+      stop: () => {
+        oneShotClient.stop()
+      },
+      reset: () => {
+        oneShotClient.reset()
+      },
+    }
+  }
+
+  system.dispose = dispose
+
+  // eslint-disable-next-line no-restricted-syntax -- built dynamically from a runtime `plugin.plugins` array; the static PluginSystem<TDef, ...> shape can't be verified structurally here, plus the added `dispose` field.
+  return system as unknown as PluginSystem<
+    TDef,
+    { plugins: PerPluginOptions<TOptions> }
+  > & {
+    dispose: () => void
+  }
+}
diff --git a/packages/ai-svelte/src/create-transaction.svelte.ts b/packages/ai-svelte/src/create-transaction.svelte.ts
deleted file mode 100644
index 33bc527d2..000000000
--- a/packages/ai-svelte/src/create-transaction.svelte.ts
+++ /dev/null
@@ -1,311 +0,0 @@
-import {
-  TransactionClient,
-  computeStructuredParts,
-} from '@tanstack/ai-client/transaction'
-import type {
-  TransactionClientOptions,
-  TransactionSubRun,
-  TransactionSystem,
-} from '@tanstack/ai-client/transaction'
-import type {
-  ChatClientState,
-  ConnectionStatus,
-  GenerationClientState,
-} from '@tanstack/ai-client'
-import type { TransactionDefinition } from '@tanstack/ai/transaction'
-import type { ModelMessage } from '@tanstack/ai'
-import type { MultimodalContent, UIMessage } from './types'
-
-/** Reactive chat-verb state mirrored from the underlying ChatClient. */
-interface ChatState {
-  messages: Array<UIMessage<any>>
-  isLoading: boolean
-  error: Error | undefined
-  status: ChatClientState
-  isSubscribed: boolean
-  connectionStatus: ConnectionStatus
-  sessionGenerating: boolean
-}
-
-/** Reactive one-shot-verb state mirrored from a GenerationClient. */
-interface OneShotState {
-  result: unknown
-  isLoading: boolean
-  error: Error | undefined
-  status: GenerationClientState
-  subRuns: Array<TransactionSubRun>
-}
-
-const makeInitialChatState = (): ChatState => ({
-  messages: [],
-  isLoading: false,
-  error: undefined,
-  status: 'ready',
-  isSubscribed: false,
-  connectionStatus: 'disconnected',
-  sessionGenerating: false,
-})
-
-const makeInitialOneShotState = (): OneShotState => ({
-  result: null,
-  isLoading: false,
-  error: undefined,
-  status: 'idle',
-  subRuns: [],
-})
-
-/**
- * Creates a reactive transaction instance for Svelte 5.
- *
- * This function wraps the `TransactionClient` from `@tanstack/ai-client` and
- * exposes reactive state using Svelte 5 runes, one surface per declared verb
- * (any number of chat verbs plus any one-shot verbs). The returned object
- * exposes reactive getters that automatically update when state changes.
- *
- * @example
- * ```svelte
- * <script>
- *   import { createTransaction, fetchServerSentEvents } from '@tanstack/ai-svelte'
- *   // myTransaction: your defineTransaction(...) value
- *
- *   const txn = createTransaction(myTransaction, {
- *     connection: fetchServerSentEvents('/api/blog'),
- *   })
- * </script>
- *
- * <div>
- *   {#each txn.primaryChat.messages as message}
- *     <div>{message.role}: {message.parts[0].content}</div>
- *   {/each}
- *
- *   <button onclick={() => txn.primaryChat.sendMessage('Hello!')}>Send</button>
- *   <button onclick={() => txn.banner.run({ prompt: 'a fox' })}>
- *     Generate banner
- *   </button>
- * </div>
- * ```
- */
-export function createTransaction<
-  TDef extends TransactionDefinition<any>,
-  // Capture the options object so per-verb `onResult` transforms flow into
-  // each one-shot verb's `result` type.
-  TOptions extends Omit<
-    TransactionClientOptions<TDef>,
-    'transaction' | 'callbacks'
-  > = Omit<TransactionClientOptions<TDef>, 'transaction' | 'callbacks'>,
->(
-  transaction: TDef,
-  options: TOptions,
-): TransactionSystem<TDef, TOptions> & { dispose: () => void } {
-  // Reactive state per chat verb, keyed by verb name. Initialized eagerly
-  // for every declared verb, since `transaction.verbs` is fixed at creation
-  // time (mirrors `TransactionClient`'s own constructor, which iterates the
-  // same array).
-  const chatStates = $state<Record<string, ChatState>>({})
-  // Reactive state per one-shot verb, keyed by verb name.
-  const oneShotStates = $state<Record<string, OneShotState>>({})
-  for (const verbName of transaction.verbs) {
-    if (transaction.verbKinds[verbName] === 'chat') {
-      chatStates[verbName] = makeInitialChatState()
-    } else {
-      oneShotStates[verbName] = makeInitialOneShotState()
-    }
-  }
-
-  // Return (and lazily create) the reactive state slot for a verb, avoiding
-  // a non-null assertion at each call site below.
-  const ensureChatState = (verbName: string): ChatState => {
-    let state = chatStates[verbName]
-    if (!state) {
-      state = makeInitialChatState()
-      chatStates[verbName] = state
-    }
-    return state
-  }
-  const ensureOneShotState = (verbName: string): OneShotState => {
-    let state = oneShotStates[verbName]
-    if (!state) {
-      state = makeInitialOneShotState()
-      oneShotStates[verbName] = state
-    }
-    return state
-  }
-
-  // Create the TransactionClient eagerly, once. Reactive callbacks are
-  // passed into the constructor (the only place ChatClient/GenerationClient
-  // accept them) rather than via `updateOptions`, mirroring `createChat`.
-  const client = new TransactionClient<TDef>({
-    ...options,
-    transaction,
-    callbacks: {
-      chat: (verbName) => ({
-        onMessagesChange: (newMessages) => {
-          ensureChatState(verbName).messages = newMessages
-        },
-        onLoadingChange: (newIsLoading) => {
-          ensureChatState(verbName).isLoading = newIsLoading
-        },
-        onErrorChange: (newError) => {
-          ensureChatState(verbName).error = newError
-        },
-        onStatusChange: (newStatus) => {
-          ensureChatState(verbName).status = newStatus
-        },
-        onSubscriptionChange: (nextIsSubscribed) => {
-          ensureChatState(verbName).isSubscribed = nextIsSubscribed
-        },
-        onConnectionStatusChange: (nextStatus) => {
-          ensureChatState(verbName).connectionStatus = nextStatus
-        },
-        onSessionGeneratingChange: (isGenerating) => {
-          ensureChatState(verbName).sessionGenerating = isGenerating
-        },
-      }),
-      oneShot: (verbName) => ({
-        onResultChange: (result) => {
-          ensureOneShotState(verbName).result = result
-        },
-        onLoadingChange: (isLoading) => {
-          ensureOneShotState(verbName).isLoading = isLoading
-        },
-        onErrorChange: (error) => {
-          ensureOneShotState(verbName).error = error
-        },
-        onStatusChange: (status) => {
-          ensureOneShotState(verbName).status = status
-        },
-        onSubRunsChange: (subRuns) => {
-          ensureOneShotState(verbName).subRuns = subRuns
-        },
-      }),
-    },
-  })
-
-  // Note: No auto-cleanup in Svelte — call `dispose()` in your component's
-  // cleanup if needed. Unlike React/Vue/Solid, Svelte 5 runes like $effect
-  // can only be used during component initialization.
-  const dispose = () => {
-    client.dispose()
-  }
-
-  // Build the returned system: one entry per declared verb, plus a
-  // top-level `dispose`. Uses getters so Svelte tracks the underlying
-  // `$state` without a `$` prefix.
-  const system: Record<string, unknown> = {}
-
-  for (const verbName of client.verbs) {
-    const chatClient = client.chat(verbName)
-    if (chatClient) {
-      ensureChatState(verbName).messages = chatClient.getMessages()
-
-      // Derived structured-output `partial`/`final`, recomputed whenever
-      // this verb's messages change (mirrors `useTransaction`'s `useMemo`).
-      const structuredParts = $derived(
-        computeStructuredParts(chatStates[verbName]?.messages ?? []),
-      )
-
-      system[verbName] = {
-        get messages() {
-          return chatStates[verbName]?.messages ?? []
-        },
-        get isLoading() {
-          return chatStates[verbName]?.isLoading ?? false
-        },
-        get error() {
-          return chatStates[verbName]?.error
-        },
-        get status() {
-          return chatStates[verbName]?.status ?? 'ready'
-        },
-        get isSubscribed() {
-          return chatStates[verbName]?.isSubscribed ?? false
-        },
-        get connectionStatus() {
-          return chatStates[verbName]?.connectionStatus ?? 'disconnected'
-        },
-        get sessionGenerating() {
-          return chatStates[verbName]?.sessionGenerating ?? false
-        },
-        // Runtime shape unconditionally exposes partial/final; the public
-        // TransactionSystem type hides them when the chat verb's
-        // outputSchema is absent, matching useChat's behavior.
-        get partial() {
-          return structuredParts.partial
-        },
-        get final() {
-          return structuredParts.final
-        },
-        sendMessage: async (content: string | MultimodalContent) => {
-          await chatClient.sendMessage(content)
-          const msgs = chatClient.getMessages()
-          const hasStructured =
-            msgs.at(-1)?.parts.some((p) => p.type === 'structured-output') ??
-            false
-          // Cast: TS can't structurally narrow the conditional return of
-          // TransactionChatSurface['sendMessage'] against this runtime
-          // branch, mirroring the assembled-`system` cast at the end of
-          // this function.
-          return (
-            hasStructured ? computeStructuredParts(msgs).final : msgs
-          ) as any
-        },
-        append: (message: ModelMessage | UIMessage<any>) =>
-          chatClient.append(message),
-        reload: () => chatClient.reload(),
-        stop: () => chatClient.stop(),
-        clear: () => chatClient.clear(),
-        setMessages: (newMessages: Array<UIMessage<any>>) =>
-          chatClient.setMessagesManually(newMessages),
-        addToolResult: (result: {
-          toolCallId: string
-          tool: string
-          output: any
-          state?: 'output-available' | 'output-error'
-          errorText?: string
-        }) => chatClient.addToolResult(result),
-        addToolApprovalResponse: (response: {
-          id: string
-          approved: boolean
-        }) => chatClient.addToolApprovalResponse(response),
-      }
-      continue
-    }
-
-    const oneShotClient = client.oneShot(verbName)
-    if (!oneShotClient) continue
-    system[verbName] = {
-      run: async (input: any) => {
-        await oneShotClient.generate(input)
-        return oneShotClient.getResult()
-      },
-      get result() {
-        return oneShotStates[verbName]?.result ?? null
-      },
-      get isLoading() {
-        return oneShotStates[verbName]?.isLoading ?? false
-      },
-      get error() {
-        return oneShotStates[verbName]?.error
-      },
-      get status() {
-        return oneShotStates[verbName]?.status ?? 'idle'
-      },
-      stop: () => {
-        oneShotClient.stop()
-      },
-      reset: () => {
-        oneShotClient.reset()
-      },
-      get subRuns() {
-        return oneShotStates[verbName]?.subRuns ?? []
-      },
-    }
-  }
-
-  system.dispose = dispose
-
-  // eslint-disable-next-line no-restricted-syntax -- built dynamically from a runtime `transaction.verbs` array; the static TransactionSystem<TDef, TOptions> shape can't be verified structurally here, plus the added `dispose` field.
-  return system as unknown as TransactionSystem<TDef, TOptions> & {
-    dispose: () => void
-  }
-}
diff --git a/packages/ai-svelte/src/plugin.ts b/packages/ai-svelte/src/plugin.ts
new file mode 100644
index 000000000..71b35a741
--- /dev/null
+++ b/packages/ai-svelte/src/plugin.ts
@@ -0,0 +1 @@
+export { createPlugin } from './create-plugin.svelte'
diff --git a/packages/ai-svelte/src/transaction.ts b/packages/ai-svelte/src/transaction.ts
deleted file mode 100644
index 7c4809d1e..000000000
--- a/packages/ai-svelte/src/transaction.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { createTransaction } from './create-transaction.svelte'
diff --git a/packages/ai-svelte/tests/create-plugin.svelte.test.ts b/packages/ai-svelte/tests/create-plugin.svelte.test.ts
new file mode 100644
index 000000000..e78aaf129
--- /dev/null
+++ b/packages/ai-svelte/tests/create-plugin.svelte.test.ts
@@ -0,0 +1,189 @@
+import { describe, expect, expectTypeOf, it } from 'vitest'
+import { chatPlugin, definePlugin, generationPlugin } from '@tanstack/ai/plugin'
+import { stream } from '@tanstack/ai-client'
+import { z } from 'zod'
+import { createPlugin } from '../src/create-plugin.svelte.js'
+
+// A connection adapter that replays canned chunks per plugin, branching on the
+// `plugin` discriminator forwarded by PluginClient.
+function fakeConnection() {
+  return stream(async function* (_messages, data) {
+    const pluginName = (data as Record<string, unknown> | undefined)?.plugin
+
+    if (pluginName === 'primaryChat') {
+      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
+      yield {
+        type: 'TEXT_MESSAGE_START',
+        messageId: 'm1',
+        role: 'assistant',
+      } as any
+      yield {
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'm1',
+        delta: 'hello',
+      } as any
+      yield { type: 'TEXT_MESSAGE_END', messageId: 'm1' } as any
+      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
+    } else {
+      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
+      yield {
+        type: 'CUSTOM',
+        name: 'generation:result',
+        value: { url: 'u' },
+      } as any
+      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
+    }
+  })
+}
+
+// A connection adapter that records every request body it sees, so tests can
+// assert per-plugin options (forwardedProps) reached the client's request.
+function capturingConnection(seen: Array<Record<string, unknown>>) {
+  return stream(async function* (_messages, data) {
+    seen.push((data ?? {}) as Record<string, unknown>)
+    const pluginName = (data as Record<string, unknown> | undefined)?.plugin
+    if (pluginName === 'primaryChat') {
+      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
+      yield {
+        type: 'TEXT_MESSAGE_START',
+        messageId: 'm1',
+        role: 'assistant',
+      } as any
+      yield {
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'm1',
+        delta: 'hello',
+      } as any
+      yield { type: 'TEXT_MESSAGE_END', messageId: 'm1' } as any
+      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
+    } else {
+      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
+      yield {
+        type: 'CUSTOM',
+        name: 'generation:result',
+        value: { url: 'u' },
+      } as any
+      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
+    }
+  })
+}
+
+function makePlugin() {
+  return definePlugin({
+    primaryChat: chatPlugin(async function* (r: any) {
+      yield { type: 'RUN_STARTED', threadId: r.threadId, runId: r.runId } as any
+    } as any),
+    banner: generationPlugin({
+      input: z.object({ prompt: z.string() }),
+      execute: async ({ input }) => ({ url: `img:${input.prompt}` }),
+    }),
+  })
+}
+
+describe('createPlugin', () => {
+  it('exposes only the declared plugins, by kind', () => {
+    const def = makePlugin()
+    const system = createPlugin(def, { connection: fakeConnection() })
+
+    expect(system.primaryChat).toBeDefined()
+    expect(system.primaryChat.sendMessage).toBeDefined()
+    expect(system.banner).toBeDefined()
+    expect(system.banner.run).toBeDefined()
+    expect((system as any).speech).toBeUndefined()
+
+    system.dispose()
+  })
+
+  it('run() on a generation plugin populates its result, typed by the schema', async () => {
+    const def = makePlugin()
+    const system = createPlugin(def, { connection: fakeConnection() })
+
+    // The input type comes from the plugin's schema.
+    expectTypeOf(system.banner.run)
+      .parameter(0)
+      .toEqualTypeOf<{ prompt: string }>()
+
+    // run() resolves to the fresh result...
+    const generated = await system.banner.run({ prompt: 'a fox' })
+    expect(generated?.url).toBe('u')
+
+    // ...and the reactive result state is still populated.
+    expect(system.banner.result?.url).toBe('u')
+
+    system.dispose()
+  })
+
+  it('sendMessage() on a chat plugin populates its messages', async () => {
+    const def = makePlugin()
+    const system = createPlugin(def, { connection: fakeConnection() })
+
+    // With no outputSchema, sendMessage() resolves to the messages array.
+    const returned = await system.primaryChat.sendMessage('hi')
+    expect(returned.length).toBeGreaterThan(0)
+
+    expect(system.primaryChat.messages.length).toBeGreaterThan(0)
+
+    system.dispose()
+  })
+
+  it('exposes chat partial/final with cleared defaults on creation', () => {
+    const def = makePlugin()
+    const system = createPlugin(def, { connection: fakeConnection() })
+
+    expect((system.primaryChat as any).partial).toEqual({})
+    expect((system.primaryChat as any).final).toBeNull()
+
+    system.dispose()
+  })
+
+  it('applies a generation onResult transform and infers its type', async () => {
+    const def = makePlugin()
+    // Flat options: the per-plugin `banner` entry sits at the top level
+    // alongside `connection`, no nested `plugins`/`verbs` wrapper.
+    const system = createPlugin(def, {
+      connection: fakeConnection(),
+      banner: {
+        onResult: (raw) => {
+          // The transform's input is the plugin's typed result
+          // (`toEqualTypeOf` fails if `raw` were `any`).
+          expectTypeOf(raw).toEqualTypeOf<{ url: string }>()
+          return raw.url
+        },
+      },
+    })
+
+    // The surface `result` is the transform's (non-nullish) return type.
+    expectTypeOf(system.banner.result).toEqualTypeOf<string | null>()
+
+    const generated = await system.banner.run({ prompt: 'a fox' })
+    expect(generated).toBe('u')
+    expect(system.banner.result).toBe('u')
+
+    system.dispose()
+  })
+
+  it('threads flat per-plugin options through to the client', async () => {
+    const def = makePlugin()
+    const seen: Array<Record<string, unknown>> = []
+    // A chat plugin's `forwardedProps` AND a generation plugin's `onResult`
+    // provided as sibling top-level keys — proving the flat shape both wires
+    // the request body and threads the result transform.
+    const system = createPlugin(def, {
+      connection: capturingConnection(seen),
+      primaryChat: { forwardedProps: { tone: 'punchy' } },
+      banner: { onResult: (raw) => `url:${raw.url}` },
+    })
+
+    await system.primaryChat.sendMessage('hi')
+    await system.banner.run({ prompt: 'a fox' })
+
+    // The chat plugin's forwardedProps reached the request body alongside the
+    // routing discriminator.
+    const chatData = seen.find((d) => d.plugin === 'primaryChat')
+    expect(chatData?.tone).toBe('punchy')
+    // The generation plugin's onResult transform was applied to its result.
+    expect(system.banner.result).toBe('url:u')
+
+    system.dispose()
+  })
+})
diff --git a/packages/ai-svelte/tests/create-transaction.svelte.test.ts b/packages/ai-svelte/tests/create-transaction.svelte.test.ts
deleted file mode 100644
index 96f9ad973..000000000
--- a/packages/ai-svelte/tests/create-transaction.svelte.test.ts
+++ /dev/null
@@ -1,187 +0,0 @@
-import { describe, expect, expectTypeOf, it } from 'vitest'
-import { chatVerb, defineTransaction, verb } from '@tanstack/ai/transaction'
-import { stream } from '@tanstack/ai-client'
-import { z } from 'zod'
-import { createTransaction } from '../src/create-transaction.svelte.js'
-
-// A connection adapter that replays canned chunks per verb, branching on the
-// `verb` discriminator forwarded by TransactionClient.
-function fakeConnection() {
-  return stream(async function* (_messages, data) {
-    const verbName = (data as Record<string, unknown> | undefined)?.verb
-
-    if (verbName === 'primaryChat') {
-      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
-      yield {
-        type: 'TEXT_MESSAGE_START',
-        messageId: 'm1',
-        role: 'assistant',
-      } as any
-      yield {
-        type: 'TEXT_MESSAGE_CONTENT',
-        messageId: 'm1',
-        delta: 'hello',
-      } as any
-      yield { type: 'TEXT_MESSAGE_END', messageId: 'm1' } as any
-      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
-    } else if (verbName === 'blogPost') {
-      // A transaction run: one banner sub-run, then the final result.
-      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
-      yield {
-        type: 'CUSTOM',
-        name: 'transaction:sub-run:started',
-        value: { runId: 'r-sub-0', parentRunId: 'r', verb: 'banner', index: 0 },
-      } as any
-      yield {
-        type: 'CUSTOM',
-        name: 'transaction:sub-run:result',
-        value: {
-          runId: 'r-sub-0',
-          verb: 'banner',
-          index: 0,
-          result: { url: 'hero.png' },
-        },
-      } as any
-      yield {
-        type: 'CUSTOM',
-        name: 'generation:result',
-        value: { title: 'Foxes', heroUrl: 'hero.png' },
-      } as any
-      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
-    } else {
-      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
-      yield {
-        type: 'CUSTOM',
-        name: 'generation:result',
-        value: { url: 'u' },
-      } as any
-      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
-    }
-  })
-}
-
-function makeTransaction() {
-  const banner = verb({
-    input: z.object({ prompt: z.string() }),
-    execute: async ({ input }) => ({ url: `img:${input.prompt}` }),
-  })
-  return defineTransaction({
-    primaryChat: chatVerb(async function* (r: any) {
-      yield { type: 'RUN_STARTED', threadId: r.threadId, runId: r.runId } as any
-    } as any),
-    banner,
-    blogPost: verb({
-      input: z.object({ topic: z.string() }),
-      execute: async ({ input }, ctx) => {
-        const hero = await ctx.call(banner, { prompt: input.topic })
-        return { title: input.topic, heroUrl: hero.url }
-      },
-    }),
-  })
-}
-
-describe('createTransaction', () => {
-  it('exposes only the declared verbs, by kind', () => {
-    const txn = makeTransaction()
-    const system = createTransaction(txn, { connection: fakeConnection() })
-
-    expect(system.primaryChat).toBeDefined()
-    expect(system.primaryChat.sendMessage).toBeDefined()
-    expect(system.banner).toBeDefined()
-    expect(system.banner.run).toBeDefined()
-    expect(system.blogPost).toBeDefined()
-    expect((system as any).speech).toBeUndefined()
-
-    system.dispose()
-  })
-
-  it('run() on a one-shot verb populates its result, typed by the schema', async () => {
-    const txn = makeTransaction()
-    const system = createTransaction(txn, { connection: fakeConnection() })
-
-    // The input type comes from the verb's schema.
-    expectTypeOf(system.banner.run)
-      .parameter(0)
-      .toEqualTypeOf<{ prompt: string }>()
-
-    // run() resolves to the fresh result...
-    const generated = await system.banner.run({ prompt: 'a fox' })
-    expect(generated?.url).toBe('u')
-
-    // ...and the reactive result state is still populated.
-    expect(system.banner.result?.url).toBe('u')
-
-    system.dispose()
-  })
-
-  it('sendMessage() on a chat verb populates its messages', async () => {
-    const txn = makeTransaction()
-    const system = createTransaction(txn, { connection: fakeConnection() })
-
-    // With no outputSchema, sendMessage() resolves to the messages array.
-    const returned = await system.primaryChat.sendMessage('hi')
-    expect(returned.length).toBeGreaterThan(0)
-
-    expect(system.primaryChat.messages.length).toBeGreaterThan(0)
-
-    system.dispose()
-  })
-
-  it('surfaces live sub-run state on a transaction run', async () => {
-    const txn = makeTransaction()
-    const system = createTransaction(txn, { connection: fakeConnection() })
-
-    await system.blogPost.run({ topic: 'foxes' })
-
-    expect(system.blogPost.result).toEqual({
-      title: 'Foxes',
-      heroUrl: 'hero.png',
-    })
-    expect(system.blogPost.subRuns).toHaveLength(1)
-    expect(system.blogPost.subRuns[0]).toMatchObject({
-      verb: 'banner',
-      status: 'success',
-      result: { url: 'hero.png' },
-    })
-    // The sibling banner surface is untouched by the transaction's sub-run.
-    expect(system.banner.result).toBeNull()
-
-    system.dispose()
-  })
-
-  it('exposes chat partial/final with cleared defaults on creation', () => {
-    const txn = makeTransaction()
-    const system = createTransaction(txn, { connection: fakeConnection() })
-
-    expect((system.primaryChat as any).partial).toEqual({})
-    expect((system.primaryChat as any).final).toBeNull()
-
-    system.dispose()
-  })
-
-  it('applies a one-shot onResult transform and infers its type', async () => {
-    const txn = makeTransaction()
-    const system = createTransaction(txn, {
-      connection: fakeConnection(),
-      verbs: {
-        banner: {
-          onResult: (raw) => {
-            // The transform's input is the verb's typed result
-            // (`toEqualTypeOf` fails if `raw` were `any`).
-            expectTypeOf(raw).toEqualTypeOf<{ url: string }>()
-            return raw.url
-          },
-        },
-      },
-    })
-
-    // The surface `result` is the transform's (non-nullish) return type.
-    expectTypeOf(system.banner.result).toEqualTypeOf<string | null>()
-
-    const generated = await system.banner.run({ prompt: 'a fox' })
-    expect(generated).toBe('u')
-    expect(system.banner.result).toBe('u')
-
-    system.dispose()
-  })
-})
diff --git a/packages/ai-vue/package.json b/packages/ai-vue/package.json
index 6d2ee7678..5b19622c6 100644
--- a/packages/ai-vue/package.json
+++ b/packages/ai-vue/package.json
@@ -25,9 +25,9 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./transaction": {
-      "types": "./dist/transaction.d.ts",
-      "import": "./dist/transaction.js"
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "import": "./dist/plugin.js"
     }
   },
   "files": [
diff --git a/packages/ai-vue/src/plugin.ts b/packages/ai-vue/src/plugin.ts
new file mode 100644
index 000000000..f722b3895
--- /dev/null
+++ b/packages/ai-vue/src/plugin.ts
@@ -0,0 +1 @@
+export { usePlugin } from './use-plugin'
diff --git a/packages/ai-vue/src/transaction.ts b/packages/ai-vue/src/transaction.ts
deleted file mode 100644
index 643dca5bf..000000000
--- a/packages/ai-vue/src/transaction.ts
+++ /dev/null
@@ -1 +0,0 @@
-export { useTransaction } from './use-transaction'
diff --git a/packages/ai-vue/src/use-plugin.ts b/packages/ai-vue/src/use-plugin.ts
new file mode 100644
index 000000000..d24591b12
--- /dev/null
+++ b/packages/ai-vue/src/use-plugin.ts
@@ -0,0 +1,367 @@
+import {
+  PluginClient,
+  computeStructuredParts,
+} from '@tanstack/ai-client/plugin'
+import { computed, onMounted, onScopeDispose, readonly, shallowRef } from 'vue'
+import type { ShallowRef } from 'vue'
+import type { ModelMessage } from '@tanstack/ai'
+import type { PluginDefinition } from '@tanstack/ai/plugin'
+import type {
+  PluginClientOptions,
+  PluginOptionsMap,
+  PluginSystem,
+} from '@tanstack/ai-client/plugin'
+import type {
+  ChatClientState,
+  ConnectConnectionAdapter,
+  ConnectionStatus,
+  GenerationClientState,
+  MultimodalContent,
+  UIMessage,
+} from '@tanstack/ai-client'
+
+/** Per-chat-plugin reactive state mirrored from the underlying ChatClient. */
+interface ChatRefs {
+  messages: ShallowRef<Array<UIMessage<any>>>
+  isLoading: ShallowRef<boolean>
+  error: ShallowRef<Error | undefined>
+  status: ShallowRef<ChatClientState>
+  isSubscribed: ShallowRef<boolean>
+  connectionStatus: ShallowRef<ConnectionStatus>
+  sessionGenerating: ShallowRef<boolean>
+}
+
+/** Per-generation-plugin reactive state mirrored from a GenerationClient. */
+interface OneShotRefs {
+  result: ShallowRef<unknown>
+  isLoading: ShallowRef<boolean>
+  error: ShallowRef<Error | undefined>
+  status: ShallowRef<GenerationClientState>
+}
+
+/**
+ * Config keys reserved at the top level of the flat options object. Anything
+ * that is NOT one of these keys is treated as a per-plugin options entry keyed
+ * by the plugin's declared name. They are excluded from the per-name map at the
+ * type level (below) so a plugin literally named `connection`/`id`/`threadId`
+ * can never collide with these config keys.
+ */
+type ReservedOptionKey = 'connection' | 'id' | 'threadId'
+
+/**
+ * The FLAT options object accepted by {@link usePlugin}: the reserved config
+ * keys at the top level, PLUS one optional entry per declared plugin name whose
+ * value is that plugin's client options (`ChatPluginOptions` for chat plugins,
+ * `GenerationPluginClientOptions` for generation plugins — see
+ * `PluginOptionsMap`). Reserved keys are removed from the per-name map so they
+ * can never collide with a plugin whose name happens to match a config key.
+ *
+ * Mirrors the `@tanstack/ai-react` reference shape:
+ *
+ * ```ts
+ * usePlugin(def, {
+ *   connection,                       // required transport
+ *   id?, threadId?,                   // optional config
+ *   drafting: { forwardedProps },     // chat plugin options
+ *   heroImage: { onResult },          // generation plugin options
+ * })
+ * ```
+ */
+export type UsePluginOptions<TDef extends PluginDefinition<any>> = {
+  connection: ConnectConnectionAdapter
+  id?: string
+  threadId?: string
+} & Omit<PluginOptionsMap<TDef>, ReservedOptionKey>
+
+/**
+ * The per-plugin options extracted from the flat options object once the
+ * reserved config keys have been removed — i.e. exactly the nested `plugins`
+ * map the underlying `PluginClient` consumes.
+ */
+type PerPluginOptions<TOptions> = Omit<TOptions, ReservedOptionKey>
+
+/**
+ * Vue composable wrapping `PluginClient`, composing the existing chat +
+ * generation clients behind one endpoint into a single typed system keyed by
+ * the plugin's declared names.
+ *
+ * Options are FLAT: reserved config keys (`connection`/`id`/`threadId`) sit at
+ * the top level alongside one optional entry per plugin name. Internally the
+ * composable splits the reserved keys back out and feeds the remaining
+ * per-plugin entries to `PluginClient` as its nested `plugins` map.
+ *
+ * Mirrors the `useChat` idiom: the `PluginClient` is built eagerly, once, with
+ * reactive state callbacks wired into its constructor — `ChatClient` and
+ * `GenerationClient` (the sub-clients `PluginClient` composes) only accept
+ * these callbacks via construction, not `updateOptions`, so they must be
+ * threaded through up front rather than attached after the fact.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ * import { usePlugin } from '@tanstack/ai-vue/plugin'
+ * import { fetchServerSentEvents } from '@tanstack/ai-client'
+ * // plugin: your definePlugin(...) value
+ *
+ * const system = usePlugin(plugin, {
+ *   connection: fetchServerSentEvents('/api/blog'),
+ *   drafting: { forwardedProps: { tone: 'punchy' } },
+ *   heroImage: { onResult: (img) => img.url },
+ * })
+ *
+ * // system.drafting.sendMessage('hi')
+ * // system.heroImage.run({ prompt: 'a fox' })
+ * </script>
+ *
+ * <template>
+ *   <div v-for="message in system.drafting.messages.value" :key="message.id">
+ *     {{ message.parts[0]?.content }}
+ *   </div>
+ * </template>
+ * ```
+ */
+export function usePlugin<
+  TDef extends PluginDefinition<any>,
+  // Capture the concrete options object so each generation plugin's `onResult`
+  // transform flows into that plugin's `result` type.
+  TOptions extends UsePluginOptions<TDef>,
+>(
+  plugin: TDef,
+  options: TOptions,
+  // The returned system is typed off the NESTED `{ plugins }` shape because the
+  // client-side `PluginSystem`/`PluginResultType` helpers read per-plugin
+  // options from a nested `plugins` key. We adapt the flat options to that shape
+  // both here (type level) and below (runtime) — the flat→nested boundary lives
+  // entirely inside this composable.
+): PluginSystem<TDef, { plugins: PerPluginOptions<TOptions> }> {
+  // Per-plugin reactive state, keyed by plugin name and created lazily the first
+  // time the PluginClient constructor asks for a plugin's callbacks — so the
+  // callbacks and the assembled surfaces share the same refs.
+  const chatRefs = new Map<string, ChatRefs>()
+  const oneShotRefs = new Map<string, OneShotRefs>()
+
+  const getChatRefs = (pluginName: string): ChatRefs => {
+    let refs = chatRefs.get(pluginName)
+    if (!refs) {
+      refs = {
+        messages: shallowRef<Array<UIMessage<any>>>([]),
+        isLoading: shallowRef(false),
+        error: shallowRef<Error | undefined>(undefined),
+        status: shallowRef<ChatClientState>('ready'),
+        isSubscribed: shallowRef(false),
+        connectionStatus: shallowRef<ConnectionStatus>('disconnected'),
+        sessionGenerating: shallowRef(false),
+      }
+      chatRefs.set(pluginName, refs)
+    }
+    return refs
+  }
+
+  const getOneShotRefs = (pluginName: string): OneShotRefs => {
+    let refs = oneShotRefs.get(pluginName)
+    if (!refs) {
+      refs = {
+        result: shallowRef<unknown>(null),
+        isLoading: shallowRef(false),
+        error: shallowRef<Error | undefined>(undefined),
+        status: shallowRef<GenerationClientState>('idle'),
+      }
+      oneShotRefs.set(pluginName, refs)
+    }
+    return refs
+  }
+
+  // Split the reserved config keys out of the flat options; every remaining key
+  // is a per-plugin options entry keyed by plugin name. Widen to the concrete
+  // flat-options type first (a safe upcast, since TOptions extends it) so the
+  // rest-destructure yields the concrete per-plugin map instead of an opaque
+  // generic `Omit`.
+  const base: UsePluginOptions<TDef> = options
+  const { connection, id, threadId, ...pluginOptions } = base
+
+  const clientOptions: PluginClientOptions<TDef> = {
+    plugin,
+    connection,
+    id,
+    threadId,
+    // Flat→nested adaptation: the leftover per-name entries ARE the client's
+    // nested `plugins` map. Bridged through `unknown` because for a generic
+    // `TDef`, TS can't relate the rest's key set (`plugin names minus reserved
+    // keys`) to `PluginOptionsMap`'s (`all plugin names`). The conversion is
+    // safe by construction: reserving `connection`/`id`/`threadId` makes it
+    // impossible to supply options for a plugin whose name collides with a
+    // config key, so this map is exactly `PluginOptionsMap` minus (at most)
+    // those never-present optional keys.
+    // eslint-disable-next-line no-restricted-syntax -- flat→nested bridge: for a generic `TDef`, TS can't relate the rest's key set (plugin names minus reserved keys) to `PluginOptionsMap`'s (all plugin names); safe by construction (see comment above)
+    plugins: pluginOptions as unknown as PluginOptionsMap<TDef>,
+    // Build the PluginClient eagerly, once (no memo). Reactive callbacks are
+    // passed into the constructor's `callbacks` option — not wired up via
+    // `updateOptions` afterwards — because the sub-clients (`ChatClient`,
+    // `GenerationClient`) only accept these callbacks at construction time.
+    callbacks: {
+      chat: (pluginName) => {
+        const refs = getChatRefs(pluginName)
+        return {
+          onMessagesChange: (messages) => {
+            refs.messages.value = messages
+          },
+          onLoadingChange: (isLoading) => {
+            refs.isLoading.value = isLoading
+          },
+          onErrorChange: (error) => {
+            refs.error.value = error
+          },
+          onStatusChange: (status) => {
+            refs.status.value = status
+          },
+          onSubscriptionChange: (isSubscribed) => {
+            refs.isSubscribed.value = isSubscribed
+          },
+          onConnectionStatusChange: (connectionStatus) => {
+            refs.connectionStatus.value = connectionStatus
+          },
+          onSessionGeneratingChange: (sessionGenerating) => {
+            refs.sessionGenerating.value = sessionGenerating
+          },
+        }
+      },
+      oneShot: (pluginName) => {
+        const refs = getOneShotRefs(pluginName)
+        return {
+          onResultChange: (result) => {
+            refs.result.value = result
+          },
+          onLoadingChange: (isLoading) => {
+            refs.isLoading.value = isLoading
+          },
+          onErrorChange: (error) => {
+            refs.error.value = error
+          },
+          onStatusChange: (status) => {
+            refs.status.value = status
+          },
+        }
+      },
+    },
+  }
+
+  const client = new PluginClient<TDef>(clientOptions)
+
+  onMounted(() => {
+    for (const pluginName of client.plugins) {
+      client.chat(pluginName)?.mountDevtools()
+    }
+  })
+
+  // Cleanup on unmount: tears down every chat and one-shot sub-client (stops
+  // in-flight requests, unregisters devtools).
+  onScopeDispose(() => {
+    client.dispose()
+  })
+
+  const system: Record<string, unknown> = {}
+
+  for (const pluginName of client.plugins) {
+    const chatClient = client.chat(pluginName)
+    if (chatClient) {
+      const refs = getChatRefs(pluginName)
+      const structuredParts = computed(() =>
+        computeStructuredParts(refs.messages.value),
+      )
+
+      system[pluginName] = {
+        messages: readonly(refs.messages),
+        sendMessage: async (content: string | MultimodalContent) => {
+          await chatClient.sendMessage(content)
+          const msgs = chatClient.getMessages()
+          const hasStructured =
+            msgs.at(-1)?.parts.some((p) => p.type === 'structured-output') ??
+            false
+          // Cast: TS can't structurally narrow the conditional return of
+          // PluginChatSurface['sendMessage'] against this runtime branch,
+          // mirroring the assembled-`system` cast at the end of this
+          // composable.
+          return (
+            hasStructured ? computeStructuredParts(msgs).final : msgs
+          ) as any
+        },
+        append: async (message: ModelMessage | UIMessage<any>) => {
+          await chatClient.append(message)
+        },
+        reload: async () => {
+          await chatClient.reload()
+        },
+        stop: () => {
+          chatClient.stop()
+        },
+        clear: () => {
+          chatClient.clear()
+        },
+        setMessages: (messages: Array<UIMessage<any>>) => {
+          chatClient.setMessagesManually(messages)
+        },
+        addToolResult: async (result: {
+          toolCallId: string
+          tool: string
+          output: any
+          state?: 'output-available' | 'output-error'
+          errorText?: string
+        }) => {
+          await chatClient.addToolResult(result)
+        },
+        addToolApprovalResponse: async (response: {
+          id: string
+          approved: boolean
+        }) => {
+          await chatClient.addToolApprovalResponse(response)
+        },
+        isLoading: readonly(refs.isLoading),
+        error: readonly(refs.error),
+        status: readonly(refs.status),
+        isSubscribed: readonly(refs.isSubscribed),
+        connectionStatus: readonly(refs.connectionStatus),
+        sessionGenerating: readonly(refs.sessionGenerating),
+        // Runtime shape unconditionally exposes partial/final; the public
+        // PluginSystem type hides them when the chat plugin's outputSchema is
+        // absent, matching useChat's behavior.
+        partial: readonly(computed(() => structuredParts.value.partial)),
+        final: readonly(computed(() => structuredParts.value.final)),
+      }
+      continue
+    }
+
+    const oneShotClient = client.oneShot(pluginName)
+    // `client.plugins` only contains plugins the constructor built a sub-client
+    // for, so this is always defined here — but the map lookup is typed as
+    // possibly `undefined`, so guard rather than assert.
+    if (!oneShotClient) continue
+
+    const refs = getOneShotRefs(pluginName)
+    system[pluginName] = {
+      run: async (input: Record<string, any>) => {
+        await oneShotClient.generate(input)
+        return oneShotClient.getResult()
+      },
+      result: readonly(refs.result),
+      isLoading: readonly(refs.isLoading),
+      error: readonly(refs.error),
+      status: readonly(refs.status),
+      stop: () => {
+        oneShotClient.stop()
+      },
+      reset: () => {
+        oneShotClient.reset()
+      },
+    }
+  }
+
+  // The runtime shape (refs nested per plugin) diverges from the declared
+  // `PluginSystem` type (plain values) — the same divergence `useChat`
+  // accepts for its return, since consumers unwrap refs via `.value`
+  // (script) or Vue's template auto-unwrapping.
+  // eslint-disable-next-line no-restricted-syntax -- composable return shape (nested refs per plugin) diverges from the framework-agnostic PluginSystem type (plain values); TS can't structurally relate the two
+  return system as unknown as PluginSystem<
+    TDef,
+    { plugins: PerPluginOptions<TOptions> }
+  >
+}
diff --git a/packages/ai-vue/src/use-transaction.ts b/packages/ai-vue/src/use-transaction.ts
deleted file mode 100644
index 90fc2f1cf..000000000
--- a/packages/ai-vue/src/use-transaction.ts
+++ /dev/null
@@ -1,296 +0,0 @@
-import {
-  TransactionClient,
-  computeStructuredParts,
-} from '@tanstack/ai-client/transaction'
-import { computed, onMounted, onScopeDispose, readonly, shallowRef } from 'vue'
-import type { ShallowRef } from 'vue'
-import type { ModelMessage } from '@tanstack/ai'
-import type { TransactionDefinition } from '@tanstack/ai/transaction'
-import type {
-  TransactionClientOptions,
-  TransactionSubRun,
-  TransactionSystem,
-} from '@tanstack/ai-client/transaction'
-import type {
-  ChatClientState,
-  ConnectionStatus,
-  GenerationClientState,
-  MultimodalContent,
-  UIMessage,
-} from '@tanstack/ai-client'
-
-/** Per-chat-verb reactive state mirrored from the underlying ChatClient. */
-interface ChatRefs {
-  messages: ShallowRef<Array<UIMessage<any>>>
-  isLoading: ShallowRef<boolean>
-  error: ShallowRef<Error | undefined>
-  status: ShallowRef<ChatClientState>
-  isSubscribed: ShallowRef<boolean>
-  connectionStatus: ShallowRef<ConnectionStatus>
-  sessionGenerating: ShallowRef<boolean>
-}
-
-/** Per-one-shot-verb reactive state mirrored from a GenerationClient. */
-interface OneShotRefs {
-  result: ShallowRef<unknown>
-  isLoading: ShallowRef<boolean>
-  error: ShallowRef<Error | undefined>
-  status: ShallowRef<GenerationClientState>
-  subRuns: ShallowRef<Array<TransactionSubRun>>
-}
-
-/**
- * Vue composable wrapping `TransactionClient`, composing the existing chat +
- * generation clients behind one endpoint into a single typed system keyed by
- * the transaction's declared verbs.
- *
- * Mirrors the `useChat` idiom: the `TransactionClient` is built eagerly,
- * once, with reactive state callbacks wired into its constructor —
- * `ChatClient` and `GenerationClient` (the sub-clients `TransactionClient`
- * composes) only accept these callbacks via construction, not
- * `updateOptions`, so they must be threaded through up front rather than
- * attached after the fact.
- *
- * @example
- * ```vue
- * <script setup>
- * import { useTransaction } from '@tanstack/ai-vue/transaction'
- * import { fetchServerSentEvents } from '@tanstack/ai-client'
- * // transaction: your defineTransaction(...) value
- *
- * const txn = useTransaction(transaction, {
- *   connection: fetchServerSentEvents('/api/blog'),
- * })
- *
- * // txn.primaryChat.sendMessage('hi')
- * // txn.banner.run({ prompt: 'a fox' })
- * // txn.blogPost.subRuns — live sub-run state during a transaction run
- * </script>
- *
- * <template>
- *   <div v-for="message in txn.primaryChat.messages.value" :key="message.id">
- *     {{ message.parts[0]?.content }}
- *   </div>
- * </template>
- * ```
- */
-export function useTransaction<
-  TDef extends TransactionDefinition<any>,
-  // Capture the options so per-verb `onResult` transforms flow into each
-  // one-shot verb's `result` type.
-  TOptions extends Omit<
-    TransactionClientOptions<TDef>,
-    'transaction' | 'callbacks'
-  >,
->(transaction: TDef, options: TOptions): TransactionSystem<TDef, TOptions> {
-  // Per-verb reactive state, keyed by verb name and created lazily the first
-  // time the TransactionClient constructor asks for a verb's callbacks — so
-  // the callbacks and the assembled surfaces share the same refs.
-  const chatRefs = new Map<string, ChatRefs>()
-  const oneShotRefs = new Map<string, OneShotRefs>()
-
-  const getChatRefs = (verb: string): ChatRefs => {
-    let refs = chatRefs.get(verb)
-    if (!refs) {
-      refs = {
-        messages: shallowRef<Array<UIMessage<any>>>([]),
-        isLoading: shallowRef(false),
-        error: shallowRef<Error | undefined>(undefined),
-        status: shallowRef<ChatClientState>('ready'),
-        isSubscribed: shallowRef(false),
-        connectionStatus: shallowRef<ConnectionStatus>('disconnected'),
-        sessionGenerating: shallowRef(false),
-      }
-      chatRefs.set(verb, refs)
-    }
-    return refs
-  }
-
-  const getOneShotRefs = (verb: string): OneShotRefs => {
-    let refs = oneShotRefs.get(verb)
-    if (!refs) {
-      refs = {
-        result: shallowRef<unknown>(null),
-        isLoading: shallowRef(false),
-        error: shallowRef<Error | undefined>(undefined),
-        status: shallowRef<GenerationClientState>('idle'),
-        subRuns: shallowRef<Array<TransactionSubRun>>([]),
-      }
-      oneShotRefs.set(verb, refs)
-    }
-    return refs
-  }
-
-  // Build the TransactionClient eagerly, once (no memo). Reactive callbacks
-  // are passed into the constructor's `callbacks` option — not wired up via
-  // `updateOptions` afterwards — because the sub-clients (`ChatClient`,
-  // `GenerationClient`) only accept these callbacks at construction time.
-  const client = new TransactionClient<TDef>({
-    ...options,
-    transaction,
-    callbacks: {
-      chat: (verb) => {
-        const refs = getChatRefs(verb)
-        return {
-          onMessagesChange: (messages) => {
-            refs.messages.value = messages
-          },
-          onLoadingChange: (isLoading) => {
-            refs.isLoading.value = isLoading
-          },
-          onErrorChange: (error) => {
-            refs.error.value = error
-          },
-          onStatusChange: (status) => {
-            refs.status.value = status
-          },
-          onSubscriptionChange: (isSubscribed) => {
-            refs.isSubscribed.value = isSubscribed
-          },
-          onConnectionStatusChange: (connectionStatus) => {
-            refs.connectionStatus.value = connectionStatus
-          },
-          onSessionGeneratingChange: (sessionGenerating) => {
-            refs.sessionGenerating.value = sessionGenerating
-          },
-        }
-      },
-      oneShot: (verb) => {
-        const refs = getOneShotRefs(verb)
-        return {
-          onResultChange: (result) => {
-            refs.result.value = result
-          },
-          onLoadingChange: (isLoading) => {
-            refs.isLoading.value = isLoading
-          },
-          onErrorChange: (error) => {
-            refs.error.value = error
-          },
-          onStatusChange: (status) => {
-            refs.status.value = status
-          },
-          onSubRunsChange: (subRuns) => {
-            refs.subRuns.value = subRuns
-          },
-        }
-      },
-    },
-  })
-
-  onMounted(() => {
-    for (const verbName of client.verbs) {
-      client.chat(verbName)?.mountDevtools()
-    }
-  })
-
-  // Cleanup on unmount: tears down every chat and one-shot sub-client (stops
-  // in-flight requests, unregisters devtools).
-  onScopeDispose(() => {
-    client.dispose()
-  })
-
-  const system: Record<string, unknown> = {}
-
-  for (const verbName of client.verbs) {
-    const chatClient = client.chat(verbName)
-    if (chatClient) {
-      const refs = getChatRefs(verbName)
-      const structuredParts = computed(() =>
-        computeStructuredParts(refs.messages.value),
-      )
-
-      system[verbName] = {
-        messages: readonly(refs.messages),
-        sendMessage: async (content: string | MultimodalContent) => {
-          await chatClient.sendMessage(content)
-          const msgs = chatClient.getMessages()
-          const hasStructured =
-            msgs.at(-1)?.parts.some((p) => p.type === 'structured-output') ??
-            false
-          // Cast: TS can't structurally narrow the conditional return of
-          // TransactionChatSurface['sendMessage'] against this runtime
-          // branch, mirroring the assembled-`system` cast at the end of this
-          // composable.
-          return (
-            hasStructured ? computeStructuredParts(msgs).final : msgs
-          ) as any
-        },
-        append: async (message: ModelMessage | UIMessage<any>) => {
-          await chatClient.append(message)
-        },
-        reload: async () => {
-          await chatClient.reload()
-        },
-        stop: () => {
-          chatClient.stop()
-        },
-        clear: () => {
-          chatClient.clear()
-        },
-        setMessages: (messages: Array<UIMessage<any>>) => {
-          chatClient.setMessagesManually(messages)
-        },
-        addToolResult: async (result: {
-          toolCallId: string
-          tool: string
-          output: any
-          state?: 'output-available' | 'output-error'
-          errorText?: string
-        }) => {
-          await chatClient.addToolResult(result)
-        },
-        addToolApprovalResponse: async (response: {
-          id: string
-          approved: boolean
-        }) => {
-          await chatClient.addToolApprovalResponse(response)
-        },
-        isLoading: readonly(refs.isLoading),
-        error: readonly(refs.error),
-        status: readonly(refs.status),
-        isSubscribed: readonly(refs.isSubscribed),
-        connectionStatus: readonly(refs.connectionStatus),
-        sessionGenerating: readonly(refs.sessionGenerating),
-        // Runtime shape unconditionally exposes partial/final; the public
-        // TransactionSystem type hides them when the chat verb's
-        // outputSchema is absent, matching useChat's behavior.
-        partial: readonly(computed(() => structuredParts.value.partial)),
-        final: readonly(computed(() => structuredParts.value.final)),
-      }
-      continue
-    }
-
-    const oneShotClient = client.oneShot(verbName)
-    // `client.verbs` only contains verbs the constructor built a sub-client
-    // for, so this is always defined here — but the map lookup is typed as
-    // possibly `undefined`, so guard rather than assert.
-    if (!oneShotClient) continue
-
-    const refs = getOneShotRefs(verbName)
-    system[verbName] = {
-      run: async (input: Record<string, any>) => {
-        await oneShotClient.generate(input)
-        return oneShotClient.getResult()
-      },
-      result: readonly(refs.result),
-      isLoading: readonly(refs.isLoading),
-      error: readonly(refs.error),
-      status: readonly(refs.status),
-      stop: () => {
-        oneShotClient.stop()
-      },
-      reset: () => {
-        oneShotClient.reset()
-      },
-      subRuns: readonly(refs.subRuns),
-    }
-  }
-
-  // The runtime shape (refs nested per verb) diverges from the declared
-  // `TransactionSystem` type (plain values) — the same divergence `useChat`
-  // accepts for its return, since consumers unwrap refs via `.value`
-  // (script) or Vue's template auto-unwrapping.
-  // eslint-disable-next-line no-restricted-syntax -- composable return shape (nested refs per verb) diverges from the framework-agnostic TransactionSystem type (plain values); TS can't structurally relate the two
-  return system as unknown as TransactionSystem<TDef, TOptions>
-}
diff --git a/packages/ai-vue/tests/use-plugin.test.ts b/packages/ai-vue/tests/use-plugin.test.ts
new file mode 100644
index 000000000..f1578defc
--- /dev/null
+++ b/packages/ai-vue/tests/use-plugin.test.ts
@@ -0,0 +1,239 @@
+import { flushPromises, mount } from '@vue/test-utils'
+import { defineComponent } from 'vue'
+import { describe, expect, expectTypeOf, it } from 'vitest'
+import { chatPlugin, definePlugin, generationPlugin } from '@tanstack/ai/plugin'
+import { stream } from '@tanstack/ai-client'
+import { z } from 'zod'
+import { usePlugin } from '../src/use-plugin.js'
+
+// A connection adapter that replays canned chunks per plugin, branching on the
+// `plugin` discriminator forwarded by PluginClient — the same way a real server
+// handler (`definePlugin(...).handler`) would route.
+function fakeConnection() {
+  return stream(async function* (_messages, data) {
+    const pluginName = (data as Record<string, unknown> | undefined)?.plugin
+
+    if (pluginName === 'primaryChat') {
+      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
+      yield {
+        type: 'TEXT_MESSAGE_START',
+        messageId: 'm1',
+        role: 'assistant',
+      } as any
+      yield {
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'm1',
+        delta: 'hello',
+      } as any
+      yield { type: 'TEXT_MESSAGE_END', messageId: 'm1' } as any
+      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
+    } else {
+      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
+      yield {
+        type: 'CUSTOM',
+        name: 'generation:result',
+        value: { url: 'u' },
+      } as any
+      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
+    }
+  })
+}
+
+// A connection adapter that records every request body it sees, so tests can
+// assert per-plugin options (forwardedProps) reached the client's request.
+function capturingConnection(seen: Array<Record<string, unknown>>) {
+  return stream(async function* (_messages, data) {
+    seen.push((data ?? {}) as Record<string, unknown>)
+    const pluginName = (data as Record<string, unknown> | undefined)?.plugin
+    if (pluginName === 'primaryChat') {
+      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
+      yield {
+        type: 'TEXT_MESSAGE_START',
+        messageId: 'm1',
+        role: 'assistant',
+      } as any
+      yield {
+        type: 'TEXT_MESSAGE_CONTENT',
+        messageId: 'm1',
+        delta: 'hello',
+      } as any
+      yield { type: 'TEXT_MESSAGE_END', messageId: 'm1' } as any
+      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
+    } else {
+      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
+      yield {
+        type: 'CUSTOM',
+        name: 'generation:result',
+        value: { url: 'u' },
+      } as any
+      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
+    }
+  })
+}
+
+function makePlugin() {
+  return definePlugin({
+    primaryChat: chatPlugin(async function* (r: any) {
+      yield { type: 'RUN_STARTED', threadId: r.threadId, runId: r.runId } as any
+    } as any),
+    banner: generationPlugin({
+      input: z.object({ prompt: z.string() }),
+      execute: async ({ input }) => ({ url: `img:${input.prompt}` }),
+    }),
+  })
+}
+
+/**
+ * Mount the composable inside a component (the harness style shared by the
+ * other ai-vue tests), capturing its return via a closure so the declared
+ * `PluginSystem` typing survives for the type-level assertions. Runtime
+ * assertions on reactive fields unwrap the nested refs via `vm` (`as any`),
+ * matching the runtime shape the composable actually returns.
+ */
+function renderUsePlugin<T>(setup: () => T) {
+  let system!: T
+  const TestComponent = defineComponent({
+    setup() {
+      system = setup()
+      return {}
+    },
+    template: '<div></div>',
+  })
+
+  const wrapper = mount(TestComponent)
+  return { wrapper, system, vm: system as any }
+}
+
+describe('usePlugin', () => {
+  it('exposes only the declared plugins, by kind', () => {
+    const def = makePlugin()
+    const { system, vm } = renderUsePlugin(() =>
+      usePlugin(def, { connection: fakeConnection() }),
+    )
+
+    expect(system.primaryChat).toBeDefined()
+    expect(system.primaryChat.sendMessage).toBeDefined()
+    expect(system.banner).toBeDefined()
+    expect(system.banner.run).toBeDefined()
+    expect(vm.speech).toBeUndefined()
+  })
+
+  it('run() on a generation plugin populates its result, typed by the schema', async () => {
+    const def = makePlugin()
+    const { system, vm } = renderUsePlugin(() =>
+      usePlugin(def, { connection: fakeConnection() }),
+    )
+
+    // The input type comes from the plugin's schema.
+    expectTypeOf(system.banner.run)
+      .parameter(0)
+      .toEqualTypeOf<{ prompt: string }>()
+
+    // run() resolves to the fresh result...
+    const returned = await system.banner.run({ prompt: 'a fox' })
+    expect(returned?.url).toBe('u')
+    await flushPromises()
+
+    // ...and the reactive result ref is still populated.
+    expect(vm.banner.result.value).toEqual({ url: 'u' })
+    expect(vm.banner.isLoading.value).toBe(false)
+    expect(vm.banner.status.value).toBe('success')
+  })
+
+  it('sendMessage() on a chat plugin populates its messages', async () => {
+    const def = makePlugin()
+    const { system, vm } = renderUsePlugin(() =>
+      usePlugin(def, { connection: fakeConnection() }),
+    )
+
+    // With no outputSchema, sendMessage() resolves to the messages array.
+    const returned = await system.primaryChat.sendMessage('hi')
+    expect(returned.length).toBeGreaterThan(0)
+    await flushPromises()
+
+    expect(vm.primaryChat.messages.value.length).toBeGreaterThan(0)
+    const assistantMessage = vm.primaryChat.messages.value.find(
+      (m: any) => m.role === 'assistant',
+    )
+    expect(assistantMessage).toBeDefined()
+    const textPart = assistantMessage?.parts.find((p: any) => p.type === 'text')
+    expect(textPart?.content).toBe('hello')
+  })
+
+  it('exposes chat partial/final with cleared defaults on first render', () => {
+    const def = makePlugin()
+    const { vm } = renderUsePlugin(() =>
+      usePlugin(def, { connection: fakeConnection() }),
+    )
+
+    expect(vm.primaryChat.partial.value).toEqual({})
+    expect(vm.primaryChat.final.value).toBeNull()
+  })
+
+  it('applies a generation onResult transform and infers its type', async () => {
+    const def = makePlugin()
+    const { system, vm } = renderUsePlugin(() =>
+      // Flat options: the per-plugin `banner` entry sits at the top level
+      // alongside `connection`, no nested `plugins`/`verbs` wrapper.
+      usePlugin(def, {
+        connection: fakeConnection(),
+        banner: {
+          onResult: (raw) => {
+            // The transform's input is the plugin's typed result
+            // (`toEqualTypeOf` fails if `raw` were `any`).
+            expectTypeOf(raw).toEqualTypeOf<{ url: string }>()
+            return raw.url
+          },
+        },
+      }),
+    )
+
+    // The surface `result` is the transform's (non-nullish) return type.
+    expectTypeOf(system.banner.result).toEqualTypeOf<string | null>()
+
+    const returned = await system.banner.run({ prompt: 'a fox' })
+    await flushPromises()
+
+    expect(returned).toBe('u')
+    expect(vm.banner.result.value).toBe('u')
+  })
+
+  it('threads flat per-plugin options through to the client', async () => {
+    const def = makePlugin()
+    const seen: Array<Record<string, unknown>> = []
+    const { system, vm } = renderUsePlugin(() =>
+      // A chat plugin's `forwardedProps` AND a generation plugin's `onResult`
+      // provided as sibling top-level keys — proving the flat shape both wires
+      // the request body and threads the result transform.
+      usePlugin(def, {
+        connection: capturingConnection(seen),
+        primaryChat: { forwardedProps: { tone: 'punchy' } },
+        banner: { onResult: (raw) => `url:${raw.url}` },
+      }),
+    )
+
+    await system.primaryChat.sendMessage('hi')
+    await flushPromises()
+    await system.banner.run({ prompt: 'a fox' })
+    await flushPromises()
+
+    // The chat plugin's forwardedProps reached the request body alongside the
+    // routing discriminator.
+    const chatData = seen.find((d) => d.plugin === 'primaryChat')
+    expect(chatData?.tone).toBe('punchy')
+    // The generation plugin's onResult transform was applied to its result.
+    expect(vm.banner.result.value).toBe('url:u')
+  })
+
+  it('disposes the underlying client on unmount without throwing', async () => {
+    const def = makePlugin()
+    const { wrapper, system } = renderUsePlugin(() =>
+      usePlugin(def, { connection: fakeConnection() }),
+    )
+
+    await system.primaryChat.sendMessage('hi')
+    await flushPromises()
+
+    expect(() => wrapper.unmount()).not.toThrow()
+  })
+})
diff --git a/packages/ai-vue/tests/use-transaction.test.ts b/packages/ai-vue/tests/use-transaction.test.ts
deleted file mode 100644
index 7e7ce1634..000000000
--- a/packages/ai-vue/tests/use-transaction.test.ts
+++ /dev/null
@@ -1,236 +0,0 @@
-import { flushPromises, mount } from '@vue/test-utils'
-import { defineComponent } from 'vue'
-import { describe, expect, expectTypeOf, it } from 'vitest'
-import { chatVerb, defineTransaction, verb } from '@tanstack/ai/transaction'
-import { stream } from '@tanstack/ai-client'
-import { z } from 'zod'
-import { useTransaction } from '../src/use-transaction.js'
-
-// A connection adapter that replays canned chunks per verb, branching on the
-// `verb` discriminator forwarded by TransactionClient — the same way a real
-// server handler (`defineTransaction(...).handler`) would route.
-function fakeConnection() {
-  return stream(async function* (_messages, data) {
-    const verbName = (data as Record<string, unknown> | undefined)?.verb
-
-    if (verbName === 'primaryChat') {
-      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
-      yield {
-        type: 'TEXT_MESSAGE_START',
-        messageId: 'm1',
-        role: 'assistant',
-      } as any
-      yield {
-        type: 'TEXT_MESSAGE_CONTENT',
-        messageId: 'm1',
-        delta: 'hello',
-      } as any
-      yield { type: 'TEXT_MESSAGE_END', messageId: 'm1' } as any
-      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
-    } else if (verbName === 'blogPost') {
-      // A transaction run: one banner sub-run, then the final result.
-      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
-      yield {
-        type: 'CUSTOM',
-        name: 'transaction:sub-run:started',
-        value: { runId: 'r-sub-0', parentRunId: 'r', verb: 'banner', index: 0 },
-      } as any
-      yield {
-        type: 'CUSTOM',
-        name: 'transaction:sub-run:result',
-        value: {
-          runId: 'r-sub-0',
-          verb: 'banner',
-          index: 0,
-          result: { url: 'hero.png' },
-        },
-      } as any
-      yield {
-        type: 'CUSTOM',
-        name: 'generation:result',
-        value: { title: 'Foxes', heroUrl: 'hero.png' },
-      } as any
-      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
-    } else {
-      yield { type: 'RUN_STARTED', threadId: 't', runId: 'r' } as any
-      yield {
-        type: 'CUSTOM',
-        name: 'generation:result',
-        value: { url: 'u' },
-      } as any
-      yield { type: 'RUN_FINISHED', threadId: 't', runId: 'r' } as any
-    }
-  })
-}
-
-function makeTransaction() {
-  const banner = verb({
-    input: z.object({ prompt: z.string() }),
-    execute: async ({ input }) => ({ url: `img:${input.prompt}` }),
-  })
-  return defineTransaction({
-    primaryChat: chatVerb(async function* (r: any) {
-      yield { type: 'RUN_STARTED', threadId: r.threadId, runId: r.runId } as any
-    } as any),
-    banner,
-    blogPost: verb({
-      input: z.object({ topic: z.string() }),
-      execute: async ({ input }, ctx) => {
-        const hero = await ctx.call(banner, { prompt: input.topic })
-        return { title: input.topic, heroUrl: hero.url }
-      },
-    }),
-  })
-}
-
-/**
- * Mount the composable inside a component (the harness style shared by the
- * other ai-vue tests), capturing its return via a closure so the declared
- * `TransactionSystem` typing survives for the type-level assertions. Runtime
- * assertions on reactive fields unwrap the nested refs via `vm` (`as any`),
- * matching the runtime shape the composable actually returns.
- */
-function renderUseTransaction<T>(setup: () => T) {
-  let system!: T
-  const TestComponent = defineComponent({
-    setup() {
-      system = setup()
-      return {}
-    },
-    template: '<div></div>',
-  })
-
-  const wrapper = mount(TestComponent)
-  return { wrapper, system, vm: system as any }
-}
-
-describe('useTransaction', () => {
-  it('exposes only the declared verbs, by kind', () => {
-    const txn = makeTransaction()
-    const { system, vm } = renderUseTransaction(() =>
-      useTransaction(txn, { connection: fakeConnection() }),
-    )
-
-    expect(system.primaryChat).toBeDefined()
-    expect(system.primaryChat.sendMessage).toBeDefined()
-    expect(system.banner).toBeDefined()
-    expect(system.banner.run).toBeDefined()
-    expect(system.blogPost).toBeDefined()
-    expect(vm.speech).toBeUndefined()
-  })
-
-  it('run() on a one-shot verb populates its result, typed by the schema', async () => {
-    const txn = makeTransaction()
-    const { system, vm } = renderUseTransaction(() =>
-      useTransaction(txn, { connection: fakeConnection() }),
-    )
-
-    // The input type comes from the verb's schema.
-    expectTypeOf(system.banner.run)
-      .parameter(0)
-      .toEqualTypeOf<{ prompt: string }>()
-
-    // run() resolves to the fresh result...
-    const returned = await system.banner.run({ prompt: 'a fox' })
-    expect(returned?.url).toBe('u')
-    await flushPromises()
-
-    // ...and the reactive result ref is still populated.
-    expect(vm.banner.result.value).toEqual({ url: 'u' })
-    expect(vm.banner.isLoading.value).toBe(false)
-    expect(vm.banner.status.value).toBe('success')
-  })
-
-  it('sendMessage() on a chat verb populates its messages', async () => {
-    const txn = makeTransaction()
-    const { system, vm } = renderUseTransaction(() =>
-      useTransaction(txn, { connection: fakeConnection() }),
-    )
-
-    // With no outputSchema, sendMessage() resolves to the messages array.
-    const returned = await system.primaryChat.sendMessage('hi')
-    expect(returned.length).toBeGreaterThan(0)
-    await flushPromises()
-
-    expect(vm.primaryChat.messages.value.length).toBeGreaterThan(0)
-    const assistantMessage = vm.primaryChat.messages.value.find(
-      (m: any) => m.role === 'assistant',
-    )
-    expect(assistantMessage).toBeDefined()
-    const textPart = assistantMessage?.parts.find((p: any) => p.type === 'text')
-    expect(textPart?.content).toBe('hello')
-  })
-
-  it('surfaces live sub-run state on a transaction run', async () => {
-    const txn = makeTransaction()
-    const { system, vm } = renderUseTransaction(() =>
-      useTransaction(txn, { connection: fakeConnection() }),
-    )
-
-    await system.blogPost.run({ topic: 'foxes' })
-    await flushPromises()
-
-    expect(vm.blogPost.result.value).toEqual({
-      title: 'Foxes',
-      heroUrl: 'hero.png',
-    })
-    expect(vm.blogPost.subRuns.value).toHaveLength(1)
-    expect(vm.blogPost.subRuns.value[0]).toMatchObject({
-      verb: 'banner',
-      status: 'success',
-      result: { url: 'hero.png' },
-    })
-    // The sibling banner surface is untouched by the transaction's sub-run.
-    expect(vm.banner.result.value).toBeNull()
-  })
-
-  it('exposes chat partial/final with cleared defaults on first render', () => {
-    const txn = makeTransaction()
-    const { vm } = renderUseTransaction(() =>
-      useTransaction(txn, { connection: fakeConnection() }),
-    )
-
-    expect(vm.primaryChat.partial.value).toEqual({})
-    expect(vm.primaryChat.final.value).toBeNull()
-  })
-
-  it('applies a one-shot onResult transform and infers its type', async () => {
-    const txn = makeTransaction()
-    const { system, vm } = renderUseTransaction(() =>
-      useTransaction(txn, {
-        connection: fakeConnection(),
-        verbs: {
-          banner: {
-            onResult: (raw) => {
-              // The transform's input is the verb's typed result
-              // (`toEqualTypeOf` fails if `raw` were `any`).
-              expectTypeOf(raw).toEqualTypeOf<{ url: string }>()
-              return raw.url
-            },
-          },
-        },
-      }),
-    )
-
-    // The surface `result` is the transform's (non-nullish) return type.
-    expectTypeOf(system.banner.result).toEqualTypeOf<string | null>()
-
-    const returned = await system.banner.run({ prompt: 'a fox' })
-    await flushPromises()
-
-    expect(returned).toBe('u')
-    expect(vm.banner.result.value).toBe('u')
-  })
-
-  it('disposes the underlying client on unmount without throwing', async () => {
-    const txn = makeTransaction()
-    const { wrapper, system } = renderUseTransaction(() =>
-      useTransaction(txn, { connection: fakeConnection() }),
-    )
-
-    await system.primaryChat.sendMessage('hi')
-    await flushPromises()
-
-    expect(() => wrapper.unmount()).not.toThrow()
-  })
-})
diff --git a/packages/ai-vue/tsdown.config.ts b/packages/ai-vue/tsdown.config.ts
index e2591dbd6..78db2c84d 100644
--- a/packages/ai-vue/tsdown.config.ts
+++ b/packages/ai-vue/tsdown.config.ts
@@ -1,7 +1,7 @@
 import { defineConfig } from 'tsdown'
 
 export default defineConfig({
-  entry: ['./src/index.ts', './src/transaction.ts'],
+  entry: ['./src/index.ts', './src/plugin.ts'],
   format: ['esm'],
   unbundle: true,
   dts: true,
diff --git a/packages/ai/package.json b/packages/ai/package.json
index 92e80a1e0..6094adaf9 100644
--- a/packages/ai/package.json
+++ b/packages/ai/package.json
@@ -25,9 +25,9 @@
       "types": "./dist/esm/index.d.ts",
       "import": "./dist/esm/index.js"
     },
-    "./transaction": {
-      "types": "./dist/esm/transaction.d.ts",
-      "import": "./dist/esm/transaction.js"
+    "./plugin": {
+      "types": "./dist/esm/plugin.d.ts",
+      "import": "./dist/esm/plugin.js"
     },
     "./client": {
       "types": "./dist/esm/client.d.ts",
diff --git a/packages/ai/skills/ai-core/SKILL.md b/packages/ai/skills/ai-core/SKILL.md
index 50612ba7a..45dae251c 100644
--- a/packages/ai/skills/ai-core/SKILL.md
+++ b/packages/ai/skills/ai-core/SKILL.md
@@ -21,19 +21,19 @@ Always import from the framework package on the client — never from
 
 ## Sub-Skills
 
-| Need to...                                                | Read                                        |
-| --------------------------------------------------------- | ------------------------------------------- |
-| Build a chat UI with streaming                            | ai-core/chat-experience/SKILL.md            |
-| Add tool calling (server, client, or both)                | ai-core/tool-calling/SKILL.md               |
-| Generate images, video, speech, or transcriptions         | ai-core/media-generation/SKILL.md           |
-| Get typed JSON responses from the LLM                     | ai-core/structured-outputs/SKILL.md         |
-| Choose and configure a provider adapter                   | ai-core/adapter-configuration/SKILL.md      |
-| Implement AG-UI streaming protocol server-side            | ai-core/ag-ui-protocol/SKILL.md             |
-| Add analytics, logging, or lifecycle hooks                | ai-core/middleware/SKILL.md                 |
-| Compose verbs / server-side pipelines behind one endpoint | ai-core/transaction/SKILL.md                |
-| Connect to a non-TanStack-AI backend                      | ai-core/custom-backend-integration/SKILL.md |
-| Turn on/off debug logging, pipe into pino/winston         | ai-core/debug-logging/SKILL.md              |
-| Set up Code Mode (LLM code execution)                     | See `@tanstack/ai-code-mode` package skills |
+| Need to...                                                  | Read                                        |
+| ----------------------------------------------------------- | ------------------------------------------- |
+| Build a chat UI with streaming                              | ai-core/chat-experience/SKILL.md            |
+| Add tool calling (server, client, or both)                  | ai-core/tool-calling/SKILL.md               |
+| Generate images, video, speech, or transcriptions           | ai-core/media-generation/SKILL.md           |
+| Get typed JSON responses from the LLM                       | ai-core/structured-outputs/SKILL.md         |
+| Choose and configure a provider adapter                     | ai-core/adapter-configuration/SKILL.md      |
+| Implement AG-UI streaming protocol server-side              | ai-core/ag-ui-protocol/SKILL.md             |
+| Add analytics, logging, or lifecycle hooks                  | ai-core/middleware/SKILL.md                 |
+| Bundle app-named plugins (chat + media) behind one endpoint | ai-core/plugin/SKILL.md                     |
+| Connect to a non-TanStack-AI backend                        | ai-core/custom-backend-integration/SKILL.md |
+| Turn on/off debug logging, pipe into pino/winston           | ai-core/debug-logging/SKILL.md              |
+| Set up Code Mode (LLM code execution)                       | See `@tanstack/ai-code-mode` package skills |
 
 ## Quick Decision Tree
 
@@ -44,7 +44,7 @@ Always import from the framework package on the client — never from
 - Choosing/configuring a provider? → ai-core/adapter-configuration
 - Building a server-only AG-UI backend? → ai-core/ag-ui-protocol
 - Adding analytics or post-stream events? → ai-core/middleware
-- Bundling several AI verbs (chat + media + pipelines) behind one endpoint? → ai-core/transaction
+- Bundling several app-named plugins (chat + media) behind one endpoint? → ai-core/plugin
 - Connecting to a custom backend? → ai-core/custom-backend-integration
 - Turning on debug logging to trace chunks/tools/middleware? → ai-core/debug-logging
 - Debugging mistakes? → Check Common Mistakes in the relevant sub-skill
diff --git a/packages/ai/skills/ai-core/chat-experience/SKILL.md b/packages/ai/skills/ai-core/chat-experience/SKILL.md
index e3a7466ea..985d3e767 100644
--- a/packages/ai/skills/ai-core/chat-experience/SKILL.md
+++ b/packages/ai/skills/ai-core/chat-experience/SKILL.md
@@ -620,7 +620,7 @@ If not handled, the UI appears to hang with no feedback.
 - See also: **ai-core/tool-calling/SKILL.md** -- Most chats include tools
 - See also: **ai-core/adapter-configuration/SKILL.md** -- Adapter choice affects available features
 - See also: **ai-core/middleware/SKILL.md** -- Use middleware for analytics and lifecycle events
-- See also: **ai-core/transaction/SKILL.md** -- To compose chat with other
-  app-defined verbs (image generation, narration, server-composed pipelines)
-  behind a single `defineTransaction` handler + `useTransaction` hook instead
-  of wiring up `chat()` and `useChat` alone
+- See also: **ai-core/plugin/SKILL.md** -- To bundle chat with other
+  app-defined plugins (image generation, narration, other one-shot
+  activities) behind a single `definePlugin` handler + `usePlugin` hook
+  instead of wiring up `chat()` and `useChat` alone
diff --git a/packages/ai/skills/ai-core/custom-backend-integration/SKILL.md b/packages/ai/skills/ai-core/custom-backend-integration/SKILL.md
index 974b87605..7d47ed4a9 100644
--- a/packages/ai/skills/ai-core/custom-backend-integration/SKILL.md
+++ b/packages/ai/skills/ai-core/custom-backend-integration/SKILL.md
@@ -461,8 +461,7 @@ Source: `docs/protocol/http-stream-protocol.md`
 - See also: **ai-core/ag-ui-protocol/SKILL.md** -- Understanding the AG-UI protocol helps build compatible custom servers
 - See also: **ai-core/chat-experience/SKILL.md** -- Full chat setup patterns including server-side `chat()` and `toServerSentEventsResponse()`
 - See also: **ai-core/middleware/SKILL.md** -- Use middleware for analytics and lifecycle events on the server side
-- See also: **ai-core/transaction/SKILL.md** -- If the backend needs to
-  compose chat with other app-defined verbs (media generation,
-  server-composed pipelines) behind one endpoint, `defineTransaction` +
-  `useTransaction` may fit better than a custom connection adapter wrapping
-  `useChat` alone
+- See also: **ai-core/plugin/SKILL.md** -- If the backend needs to bundle
+  chat with other app-defined plugins (media generation, one-shot
+  activities) behind one endpoint, `definePlugin` + `usePlugin` may fit
+  better than a custom connection adapter wrapping `useChat` alone
diff --git a/packages/ai/skills/ai-core/media-generation/SKILL.md b/packages/ai/skills/ai-core/media-generation/SKILL.md
index de04c8f34..7ab5c761d 100644
--- a/packages/ai/skills/ai-core/media-generation/SKILL.md
+++ b/packages/ai/skills/ai-core/media-generation/SKILL.md
@@ -876,8 +876,9 @@ and piping into a custom logger.
   returns unexpected output or fails mid-stream, toggle `debug: true` on
   any `generate*()` call to see request metadata, raw provider chunks, and
   errors. Covers per-category toggling and piping into pino/winston.
-- See also: **ai-core/transaction/SKILL.md** -- To combine multiple media
+- See also: **ai-core/plugin/SKILL.md** -- To combine multiple media
   activities (image/audio/speech/video/transcription) with chat as app-named
-  verbs behind one `defineTransaction` handler + `useTransaction` hook —
-  including server-composed transactions via `ctx.call` — instead of wiring
-  up each `generate*()` activity and its own hook separately.
+  plugins behind one `definePlugin` handler + `usePlugin` hook — using the
+  ready-made `imagePlugin`/`videoPlugin`/`audioPlugin`/`speechPlugin`/
+  `transcriptionPlugin`/`summarizePlugin` factories — instead of wiring up
+  each `generate*()` activity and its own hook separately.
diff --git a/packages/ai/skills/ai-core/plugin/SKILL.md b/packages/ai/skills/ai-core/plugin/SKILL.md
new file mode 100644
index 000000000..39f38642c
--- /dev/null
+++ b/packages/ai/skills/ai-core/plugin/SKILL.md
@@ -0,0 +1,424 @@
+---
+name: ai-core/plugin
+description: >
+  App-defined plugin registry: definePlugin() registers app-named plugins —
+  chatPlugin(callback) for conversational surfaces, generationPlugin({ input,
+  execute }) for one-shot schema-validated work, plus ready-made media
+  factories (imagePlugin, videoPlugin, audioPlugin, speechPlugin,
+  transcriptionPlugin, summarizePlugin) — behind one handler; usePlugin()
+  consumes all declared plugins from a single client hook with flat options
+  and no generics, types inferred from the server definition.
+type: sub-skill
+library: tanstack-ai
+library_version: '0.10.0'
+sources:
+  - 'TanStack/ai:packages/ai/src/activities/plugin/index.ts'
+  - 'TanStack/ai:packages/ai/src/activities/plugin/types.ts'
+  - 'TanStack/ai:packages/ai/src/activities/plugin/media.ts'
+  - 'TanStack/ai:packages/ai/src/plugin.ts'
+  - 'TanStack/ai:packages/ai-client/src/plugin-client.ts'
+  - 'TanStack/ai:packages/ai-client/src/plugin-types.ts'
+  - 'TanStack/ai:packages/ai-react/src/use-plugin.ts'
+---
+
+# Plugin
+
+This skill builds on ai-core, ai-core/chat-experience, and
+ai-core/media-generation. Read them first.
+
+`definePlugin` + `usePlugin` are a **registry layer**, not a new activity or
+wire format. They wire together activities you already know (`chat()`,
+`generateImage()`, `generateSpeech()`, …) behind one server endpoint and one
+client hook, keyed by **app-named plugins** — `drafting`, `heroImage`,
+`narration` — not a fixed set of library nouns. There are two plugin kinds:
+
+- `chatPlugin(callback)` — conversational: message history in, streamed chat
+  out. Client surface = the full `useChat` return. A definition may declare
+  several chat plugins (e.g. `primaryChat` + `summaryChat`).
+- `generationPlugin({ input, execute })` — one-shot: Standard-Schema-validated
+  input in, typed result out. Client surface = `run(input)` / `result` /
+  `isLoading` / `error` / `status` / `stop` / `reset`.
+
+For common media activities, six factory functions wrap `generationPlugin`
+with the input/result contract pre-bound so you don't hand-roll a schema:
+`imagePlugin`, `videoPlugin`, `audioPlugin`, `speechPlugin`,
+`transcriptionPlugin`, `summarizePlugin`.
+
+A `generationPlugin`'s `execute` receives a single `req` argument (parsed
+input + the raw `Request`) — there is **no** second `ctx` argument, and a
+plugin cannot invoke a sibling plugin server-side. Each plugin runs its own
+request, independently. Orchestrating multiple plugins into one pipeline
+(e.g. "draft, then illustrate, then narrate") is the client's job — see
+Pattern 1. **Server-side composition is coming via a future `workflowPlugin`.**
+
+## Setup — Chat + Media Plugins End-to-End
+
+### Server: `definePlugin` + a single `handler`
+
+The definition is **inert** — `definePlugin` only stores the plugins and
+their names/kinds. It constructs nothing (no adapters, no connections) until
+a request actually reaches `handler`, so it's safe to import into an
+isomorphic module shared with the client — the client binds directly off the
+same value (see Client binding, below); there is no separate client stub.
+
+```typescript
+// src/lib/blog-studio.ts — shared module: server definition
+import { chat, generateImage, generateSpeech } from '@tanstack/ai'
+import {
+  chatPlugin,
+  definePlugin,
+  imagePlugin,
+  speechPlugin,
+} from '@tanstack/ai/plugin'
+import { openaiImage, openaiSpeech, openaiText } from '@tanstack/ai-openai'
+import { z } from 'zod'
+
+export const BlogPostSchema = z.object({
+  title: z.string(),
+  subtitle: z.string(),
+  body: z.string(),
+})
+
+export const blogPlugin = definePlugin({
+  // Conversational plugin: writes the post as a typed object
+  // (structured output + streaming).
+  drafting: chatPlugin((req) =>
+    chat({
+      adapter: openaiText('gpt-5.5'),
+      messages: req.messages,
+      outputSchema: BlogPostSchema, // → typed structured output
+      stream: true,
+      threadId: req.threadId,
+      runId: req.runId,
+    }),
+  ),
+
+  // One-shot media plugin: a hero image from a prompt. `imagePlugin`
+  // pre-binds `req.input` to `{ prompt, numberOfImages?, size?,
+  // modelOptions? }` and the result to `ImageGenerationResult`.
+  heroImage: imagePlugin((req) =>
+    generateImage({
+      adapter: openaiImage('gpt-image-2'),
+      prompt: req.input.prompt,
+    }),
+  ),
+
+  // One-shot media plugin: narrate a piece of text.
+  narration: speechPlugin((req) =>
+    generateSpeech({
+      adapter: openaiSpeech('tts-1'),
+      text: req.input.text,
+      voice: 'alloy',
+    }),
+  ),
+})
+```
+
+```typescript
+// src/routes/api.blog-studio.ts — server route, single handler
+import { createFileRoute } from '@tanstack/react-router'
+import { blogPlugin } from '../lib/blog-studio'
+
+export const Route = createFileRoute('/api/blog-studio')({
+  server: {
+    handlers: {
+      POST: ({ request }) => blogPlugin.handler(request),
+    },
+  },
+})
+```
+
+`handler` is the **only** thing the route needs to call. Internally it
+routes by a `plugin` discriminator carried in the request's `forwardedProps`:
+chat plugins dispatch to the AG-UI `RunAgentInput` parsing path (same as a
+standalone chat route); generation plugins get their forwarded props
+validated against the plugin's `input` schema (`400` with the validation
+issues on failure) before `execute` runs. Unknown or undeclared plugins get
+a `400` before any callback runs.
+
+### Client: `usePlugin` — binds off the definition value directly
+
+```tsx
+import { fetchServerSentEvents } from '@tanstack/ai-react'
+import { usePlugin } from '@tanstack/ai-react/plugin'
+import { blogPlugin } from '../lib/blog-studio'
+
+function BlogStudio() {
+  const plugin = usePlugin(blogPlugin, {
+    connection: fetchServerSentEvents('/api/blog-studio'),
+    heroImage: { onResult: (result) => result.images[0] ?? null },
+  })
+
+  return (
+    <div>
+      <div>
+        {plugin.drafting.messages.map((message) => (
+          <div key={message.id}>{message.role}</div>
+        ))}
+      </div>
+      <button
+        onClick={async () => {
+          const draft = await plugin.drafting.sendMessage('Pitch me a topic')
+          if (!draft) return
+          await Promise.all([
+            plugin.heroImage.run({ prompt: draft.title }),
+            plugin.narration.run({ text: draft.body }),
+          ])
+        }}
+      >
+        Write the post
+      </button>
+      {plugin.drafting.isLoading && (
+        <button onClick={() => plugin.drafting.stop()}>Stop</button>
+      )}
+      {plugin.drafting.final && <h1>{plugin.drafting.final.title}</h1>}
+    </div>
+  )
+}
+```
+
+`plugin` is typed from the definition value passed in — **no generics** at
+the call site (inference rides the definition's `'~plugins'` phantom type).
+Only declared plugins appear on `plugin`; referencing an undeclared key is a
+compile error. A chat plugin's surface is the full `useChat` return
+(`messages`, `sendMessage`, `isLoading`, `error`, `status`, `stop`, `clear`,
+`addToolResult`, `addToolApprovalResponse`, …, plus `partial`/`final` when the
+callback declared `outputSchema`); a generation plugin's surface is
+`run(input)` (input typed by the plugin's schema; resolves with the result or
+`null`), `result`, `isLoading`, `error`, `status`, `stop`, and `reset`.
+
+Vue/Solid have identical patterns with different hook imports
+(e.g. `import { usePlugin } from '@tanstack/ai-solid/plugin'`); Svelte
+exports `createPlugin` from `@tanstack/ai-svelte/plugin`.
+
+## Client binding — no `clientPlugin`, no kinds map
+
+There is no `clientPlugin` stub and nothing to declare a second time on the
+client. `definePlugin` returns `{ plugins, pluginKinds, handler, '~plugins' }`
+— `pluginKinds` (a runtime `Record<name, 'chat' | 'one-shot'>`) is present on
+the value itself, so `usePlugin(def, options)` reads it at runtime to decide
+`ChatClient` vs `GenerationClient` per entry, for any set of names. Import the
+same `blogPlugin` value on both the server route and the client component;
+there's nothing else to define or keep in sync.
+
+## Core Patterns
+
+### 1. Client-side orchestration — sequencing plugins yourself
+
+Because `execute` has no way to call a sibling plugin, a multi-step pipeline
+("draft, then illustrate and narrate in parallel") is orchestrated on the
+client with plain `await`/`Promise.all`:
+
+```typescript
+async function orchestrate(topic: string) {
+  const draft = await plugin.drafting.sendMessage(
+    `Write a blog post about: ${topic}`,
+  )
+  if (!draft) return // drafting failed or was stopped before completing
+
+  await Promise.all([
+    plugin.heroImage.run({ prompt: heroPromptFor(draft) }),
+    plugin.narration.run({ text: forNarration(draft.body) }),
+  ])
+}
+```
+
+Each step drives its own reactive surface (`isLoading`/`result`/`error`), so
+the UI fills in as each request finishes — you don't need a single combined
+loading flag unless you want one (`drafting.isLoading || heroImage.isLoading
+|| narration.isLoading`). This is also what lets a "Regenerate hero image" /
+"Re-narrate" button re-run just one plugin without repeating the whole
+pipeline.
+
+This is **N requests, N independent abort scopes** — call each surface's own
+`stop()` (there's no single "stop everything" call; call `stop()` on each
+plugin surface you started). Server-side composition — one request, one
+abort scope, live sub-run streaming — is coming later via a dedicated
+`workflowPlugin`; it doesn't exist yet.
+
+### 2. Chat tools auto-type from the server callback; per-plugin options are flat
+
+Tools passed to `chat({ tools: [...] })` inside a chat plugin's callback
+automatically type that plugin's `messages` tool-call/result parts — with
+**no** client-side re-declaration needed for typing. Per-plugin client
+options sit as flat top-level keys on the options object (alongside
+`connection`/`id`/`threadId`), _not_ nested under a `plugins`/`verbs` map —
+this is what lets `usePlugin` avoid a second generic:
+
+```typescript
+const plugin = usePlugin(blogPlugin, {
+  connection: fetchServerSentEvents('/api/blog-studio'),
+  // runtime only for client-executed (.client()) tools — types already
+  // came from the server callback
+  drafting: { tools: [showToast] },
+})
+```
+
+Each **generation** plugin's entry accepts `{ onResult, forwardedProps }`:
+`onResult` runs on the raw backend result and its return type becomes
+`plugin.<name>.result`'s type (return nothing to keep the raw result); chat
+plugin entries accept `{ tools, forwardedProps }`.
+
+```typescript
+const plugin = usePlugin(blogPlugin, {
+  connection: fetchServerSentEvents('/api/blog-studio'),
+  heroImage: { onResult: (result) => result.images[0]?.url ?? null },
+})
+
+plugin.heroImage.result // string | null — the transform's return type
+```
+
+Because the map is flat, a plugin literally named `connection`, `id`, or
+`threadId` would collide with the reserved config keys — pick app names that
+avoid those (`drafting`, `heroImage`, `narration`, not `connection`).
+
+### 3. Structured output via `outputSchema` in a chat plugin's callback
+
+If a chat plugin's callback passes `outputSchema` to `chat()`, that plugin's
+surface picks up typed `partial` (progressive `DeepPartial`) and `final`
+(validated terminal object), and `sendMessage` resolves to the validated
+final (or `null`) instead of the messages array. Omit `outputSchema` and
+neither field is present on the type — same conditional shape as
+`useChat({ outputSchema })`.
+
+### 4. Media factories over `generationPlugin`
+
+`imagePlugin`, `videoPlugin`, `audioPlugin`, `speechPlugin`,
+`transcriptionPlugin`, and `summarizePlugin` are thin wrappers: each is
+`generationPlugin({ input: <fixed schema>, execute: callback })` with the
+input contract and result type pre-bound to the corresponding media
+activity, so `plugin.<name>.run(input)` is fully typed end to end without you
+writing a Zod schema.
+
+| Factory               | `req.input` shape (all fields on the object)                                              | Result type             |
+| --------------------- | ----------------------------------------------------------------------------------------- | ----------------------- |
+| `imagePlugin`         | `{ prompt, numberOfImages?, size?, modelOptions? }`                                       | `ImageGenerationResult` |
+| `videoPlugin`         | `{ prompt, size?, duration?, modelOptions? }`                                             | `VideoJobResult`        |
+| `audioPlugin`         | `{ prompt, duration?, modelOptions? }`                                                    | `AudioGenerationResult` |
+| `speechPlugin`        | `{ text, voice?, format?, speed?, modelOptions? }`                                        | `TTSResult`             |
+| `transcriptionPlugin` | `{ audio, language?, prompt?, responseFormat?, modelOptions? }` (`audio` = base64 string) | `TranscriptionResult`   |
+| `summarizePlugin`     | `{ text, maxLength?, style?, focus?, modelOptions? }`                                     | `SummarizationResult`   |
+
+```typescript
+import { transcriptionPlugin } from '@tanstack/ai/plugin'
+import { generateTranscription } from '@tanstack/ai'
+import { openaiTranscription } from '@tanstack/ai-openai'
+
+const transcript = transcriptionPlugin((req) =>
+  generateTranscription({
+    adapter: openaiTranscription('whisper-1'),
+    audio: req.input.audio,
+    language: req.input.language,
+  }),
+)
+```
+
+When none of the six shapes fit, fall back to `generationPlugin({ input, execute })`
+directly with your own Standard Schema (Zod, Valibot, ArkType, …).
+
+### 5. Only declared plugins are constructed; one shared connection
+
+`definePlugin({ drafting, heroImage })` produces a client with exactly
+`plugin.drafting` and `plugin.heroImage`. All plugins share the single
+`connection` passed to `usePlugin` — one endpoint, one adapter. Each
+underlying sub-client (a `ChatClient` per chat plugin, a `GenerationClient`
+per generation plugin) tags its own requests with the plugin name so the
+single `handler` can route.
+
+## Common Mistakes
+
+### a. HIGH: Writing a custom handler that branches on plugin manually
+
+```typescript
+// WRONG — reimplementing what `handler` already does
+export const POST = async (request: Request) => {
+  const body = await request.json()
+  if (body.forwardedProps.plugin === 'drafting') {
+    return toServerSentEventsResponse(
+      chat({ adapter, messages: body.messages }),
+    )
+  }
+  // ...manual branching for every plugin
+}
+
+// CORRECT — definePlugin's handler already parses, validates, routes,
+// and serializes
+export const POST = (request: Request) => blogPlugin.handler(request)
+```
+
+### b. HIGH: Passing `model` or generation options to `usePlugin`
+
+There is no `model`/`prompt` option on `usePlugin`. Model choice and
+generation parameters belong inside the server plugins
+(`openaiImage('gpt-image-2')`, …). Besides `connection`/`id`/`threadId`, the
+client options are one flat entry per plugin name: chat plugins take
+`{ tools, forwardedProps }`, generation plugins `{ onResult, forwardedProps }`.
+
+```typescript
+// WRONG — no model/prompt options, and per-plugin options aren't nested
+// under a verbs/plugins map
+usePlugin(blogPlugin, { connection, model: 'gpt-5.5' })
+
+// CORRECT — flat, per-plugin-name options
+usePlugin(blogPlugin, {
+  connection: fetchServerSentEvents('/api/blog-studio'),
+  heroImage: { onResult: (r) => r.images[0]?.url ?? null },
+})
+```
+
+### c. HIGH: Expecting `execute` to compose a sibling plugin server-side
+
+```typescript
+// WRONG — there is no second `ctx` argument, and no ctx.call
+const blogPost = generationPlugin({
+  input: z.object({ topic: z.string() }),
+  execute: async (req, ctx) => {
+    const draft = await ctx.call(drafting, [...]) // ctx does not exist
+    return draft
+  },
+})
+
+// CORRECT — one arg; orchestrate sibling plugins on the client instead
+// (Pattern 1), or wait for workflowPlugin once it ships
+const heroImage = imagePlugin((req) => generateImage({ ... }))
+```
+
+### d. MEDIUM: Forgetting to propagate `req.signal` into provider calls
+
+`stop()` aborts that plugin's fetch, but a provider call not chained to
+`req.signal` (e.g. via `chat()`'s `abortController`) keeps burning tokens
+server-side until it completes. Thread the signal into every activity a
+plugin runs:
+
+```typescript
+const narrate = generationPlugin({
+  input: z.object({ text: z.string() }),
+  execute: (req) => {
+    const abortController = new AbortController()
+    req.signal.addEventListener('abort', () => abortController.abort(), {
+      once: true,
+    })
+    return chat({
+      adapter: openaiText('gpt-5.5'),
+      messages: [{ role: 'user', content: req.input.text }],
+      stream: false,
+      abortController, // stop() / disconnect cancels the provider call
+    })
+  },
+})
+```
+
+## Cross-References
+
+- See also: **ai-core/chat-experience/SKILL.md** -- a chat plugin's surface
+  is the same `useChat` surface; streaming, tool rendering, and multimodal
+  messages all apply unchanged.
+- See also: **ai-core/media-generation/SKILL.md** -- the media factories
+  wrap the generation activities documented there (`generateImage`,
+  `generateSpeech`, …); a plain `generationPlugin` can wrap any of them too.
+- See also: **ai-core/tool-calling/SKILL.md** -- Tools passed to a chat
+  plugin's callback follow the same server/client tool patterns as a
+  standalone `chat()` route.
+- See also: **ai-core/custom-backend-integration/SKILL.md** -- The shared
+  `connection` passed to `usePlugin` is the same `ConnectConnectionAdapter`
+  used by `useChat` / `useGenerate*`.
diff --git a/packages/ai/skills/ai-core/transaction/SKILL.md b/packages/ai/skills/ai-core/transaction/SKILL.md
deleted file mode 100644
index 19ab563e2..000000000
--- a/packages/ai/skills/ai-core/transaction/SKILL.md
+++ /dev/null
@@ -1,431 +0,0 @@
----
-name: ai-core/transaction
-description: >
-  App-defined verb composition and server-composed transactions:
-  defineTransaction() registers app-named verbs — chatVerb(callback) for
-  conversational surfaces, verb({ input, execute }) for one-shot
-  schema-validated work — behind one handler; useTransaction() consumes all
-  declared verbs from a single client hook with no generics, types inferred
-  from the server definition. A one-shot verb's execute can compose sibling
-  verbs via ctx.call as live-streamed sub-runs of the same single request,
-  with one abort scope.
-type: sub-skill
-library: tanstack-ai
-library_version: '0.10.0'
-sources:
-  - 'TanStack/ai:packages/ai/src/activities/transaction/index.ts'
-  - 'TanStack/ai:packages/ai/src/activities/transaction/types.ts'
-  - 'TanStack/ai:packages/ai-client/src/transaction-client.ts'
-  - 'TanStack/ai:packages/ai-client/src/transaction-types.ts'
-  - 'TanStack/ai:packages/ai-react/src/use-transaction.ts'
----
-
-# Transaction
-
-This skill builds on ai-core, ai-core/chat-experience, and
-ai-core/media-generation. Read them first.
-
-`defineTransaction` + `useTransaction` are a **composition layer**, not a new
-activity or wire format. They wire together activities you already know
-(`chat()`, `generateImage()`, `generateSpeech()`, …) behind one server
-endpoint and one client hook, keyed by **app-named verbs** — `drafting`,
-`heroImage`, `narration`, `blogPost` — not a fixed set of library nouns.
-There are two verb kinds:
-
-- `chatVerb(callback)` — conversational: message history in, streamed chat
-  out. Client surface = the full `useChat` return. A definition may declare
-  several chat verbs (e.g. `primaryChat` + `summaryChat`).
-- `verb({ input, execute })` — one-shot: Standard-Schema-validated input in,
-  typed result out. Client surface = `run(input)` / `result` /
-  `isLoading` / `error` / `status` / `stop` / `reset` / `subRuns`.
-
-A one-shot verb's `execute` receives `(req, ctx)`; `ctx.call(sibling, input)`
-runs a sibling verb **inside the same request** as a live-streamed sub-run —
-a server-composed **transaction** with one abort scope.
-
-## Setup — Chat + Image + Composing Verb End-to-End
-
-### Server: `defineTransaction` + a single `handler`
-
-The definition is **inert** — `defineTransaction` only stores the verbs and
-their names/kinds. It constructs nothing (no adapters, no connections) until
-a request actually reaches `handler`, so it's safe to import into an
-isomorphic module shared with the client.
-
-```typescript
-// src/lib/blog-studio.ts — shared module: server definition + client stub
-import { chat, generateImage } from '@tanstack/ai'
-import {
-  chatVerb,
-  clientTransaction,
-  defineTransaction,
-  verb,
-} from '@tanstack/ai/transaction'
-import { openaiText, openaiImage } from '@tanstack/ai-openai/adapters'
-import { z } from 'zod'
-import { BlogPostSchema } from './schemas'
-
-const drafting = chatVerb((req) =>
-  chat({
-    adapter: openaiText('gpt-5.5'),
-    messages: req.messages,
-    outputSchema: BlogPostSchema, // → typed structured output
-    stream: true,
-    threadId: req.threadId,
-    runId: req.runId,
-  }),
-)
-
-const heroImage = verb({
-  input: z.object({ prompt: z.string() }), // validated at runtime, 400 + issues on mismatch
-  execute: ({ input }) =>
-    generateImage({
-      adapter: openaiImage('gpt-image-2'),
-      prompt: input.prompt,
-    }),
-})
-
-// A transaction: composes the siblings above server-side via ctx.call.
-const blogPost = verb({
-  input: z.object({ topic: z.string() }),
-  execute: async ({ input }, ctx) => {
-    // ctx.call on a chat verb → { text, structured }; re-validate structured.
-    const draft = await ctx.call(drafting, [
-      { role: 'user', content: `Write a blog post about: ${input.topic}` },
-    ])
-    const parsed = BlogPostSchema.safeParse(draft.structured)
-    if (!parsed.success) throw new Error('invalid draft')
-    // ctx.call on a one-shot verb → its typed result.
-    const hero = await ctx.call(heroImage, {
-      prompt: `Hero image for "${parsed.data.title}"`,
-    })
-    return { post: parsed.data, hero } // → txn.blogPost.result on the client
-  },
-})
-
-export const blogTransaction = defineTransaction({
-  drafting,
-  heroImage,
-  blogPost,
-})
-
-export const blogTxnDef = clientTransaction<typeof blogTransaction>({
-  drafting: 'chat',
-  heroImage: 'one-shot',
-  blogPost: 'one-shot',
-})
-```
-
-```typescript
-// src/routes/api.blog-studio.ts — server route, single handler
-import { createFileRoute } from '@tanstack/react-router'
-import { blogTransaction } from '../lib/blog-studio'
-
-export const Route = createFileRoute('/api/blog-studio')({
-  server: {
-    handlers: {
-      POST: ({ request }) => blogTransaction.handler(request),
-    },
-  },
-})
-```
-
-`handler` is the **only** thing the route needs to call. Internally it
-routes by a `verb` discriminator carried in the request's `forwardedProps`:
-chat verbs dispatch to the AG-UI `RunAgentInput` parsing path (same as a
-standalone chat route); one-shot verbs get their forwarded props validated
-against the verb's `input` schema (`400` with the validation issues on
-failure) before `execute` runs. Unknown or undeclared verbs get a `400`
-before any callback runs.
-
-### Client: `useTransaction`
-
-```tsx
-import { fetchServerSentEvents } from '@tanstack/ai-react'
-import { useTransaction } from '@tanstack/ai-react/transaction'
-import { blogTxnDef } from '../lib/blog-studio'
-
-function BlogStudio() {
-  const txn = useTransaction(blogTxnDef, {
-    connection: fetchServerSentEvents('/api/blog-studio'),
-  })
-
-  return (
-    <div>
-      <div>
-        {txn.drafting.messages.map((message) => (
-          <div key={message.id}>{message.role}</div>
-        ))}
-      </div>
-      <button onClick={() => txn.drafting.sendMessage('Pitch me a topic')}>
-        Ask
-      </button>
-
-      {/* ONE request runs the whole pipeline; sub-runs stream back live. */}
-      <button
-        onClick={() => void txn.blogPost.run({ topic: 'urban foxes' })}
-        disabled={txn.blogPost.isLoading}
-      >
-        {txn.blogPost.isLoading ? 'Working…' : 'Write the post'}
-      </button>
-      {txn.blogPost.isLoading && (
-        <button onClick={() => txn.blogPost.stop()}>Stop</button>
-      )}
-      <ol>
-        {txn.blogPost.subRuns.map((run) => (
-          <li key={run.runId}>
-            {run.verb}: {run.status}
-          </li>
-        ))}
-      </ol>
-      {txn.blogPost.result && <h1>{txn.blogPost.result.post.title}</h1>}
-    </div>
-  )
-}
-```
-
-`txn` is typed from the definition value passed in — **no generics** at the
-call site (inference rides the definition's `'~verbs'` phantom type). Only
-declared verbs appear on `txn`; referencing an undeclared key is a compile
-error. A chat verb's surface is the full `useChat` return (`messages`,
-`sendMessage`, `isLoading`, `error`, `status`, `stop`, `clear`,
-`addToolResult`, `addToolApprovalResponse`, …, plus `partial`/`final` when
-the callback declared `outputSchema`); a one-shot verb's surface is
-`run(input)` (input typed by the verb's schema; resolves with the result or
-`null`), `result`, `isLoading`, `error`, `status`, `stop`, `reset`, and
-`subRuns`.
-
-Vue/Solid have identical patterns with different hook imports
-(e.g. `import { useTransaction } from '@tanstack/ai-solid/transaction'`);
-Svelte exports `createTransaction` from `@tanstack/ai-svelte/transaction`.
-
-## Core Patterns
-
-### 1. Server-composed transactions: `ctx.call` + live `subRuns`
-
-Inside a one-shot verb's `execute`, `ctx.call(sibling, input)` runs a sibling
-verb as a tagged sub-run of the **same request**:
-
-- `ctx.call(oneShotVerb, input)` → validates input against the sibling's
-  schema, resolves with its typed result.
-- `ctx.call(chatVerbObj, messagesArray)` → runs the chat callback to
-  completion server-side, resolves with `{ text, structured }` (`structured`
-  is `unknown` — re-validate with `safeParse`).
-
-Every sub-run streams to the client live as `transaction:sub-run:*` CUSTOM
-events (names on `TRANSACTION_EVENTS` from `@tanstack/ai/transaction`:
-`SUB_RUN_STARTED` / `SUB_RUN_CHUNK` / `SUB_RUN_RESULT` / `SUB_RUN_ERROR`).
-The client demultiplexes them into `txn.<verb>.subRuns`:
-`{ runId, verb, index, status: 'running' | 'success' | 'error', result,
-text, error? }` in server start order, reset on each new run. For chat
-sub-runs `text` accumulates the streamed text — note that with an
-`outputSchema` it's partial JSON, so show progress by length, don't render
-it. `Promise.all` over multiple `ctx.call`s runs sub-work in parallel.
-
-### 2. One request, one abort scope
-
-`txn.<verb>.stop()` aborts the single fetch. Server-side, `req.signal`
-(=== `ctx.signal`, the request's `AbortSignal`) trips: `ctx.call` refuses
-new sub-runs and chat sub-runs stop draining. Chain the signal into
-activities so provider work is cancelled too — `chat()` takes an
-`abortController`, so hang one off the request signal:
-
-```typescript
-const narrate = verb({
-  input: z.object({ text: z.string() }),
-  execute: (req) => {
-    const abortController = new AbortController()
-    req.signal.addEventListener('abort', () => abortController.abort(), {
-      once: true,
-    })
-    return chat({
-      adapter: openaiText('gpt-5.5'),
-      messages: [{ role: 'user', content: req.input.text }],
-      stream: false,
-      abortController, // stop() / disconnect cancels the provider call
-    })
-  },
-})
-```
-
-Error semantics: a throwing sub-run emits `transaction:sub-run:error` and
-rejects that `ctx.call`; uncaught, the run terminates with `RUN_ERROR`
-(client: `txn.<verb>.error` set, `result` stays `null`, failed step marked
-`status: 'error'` in `subRuns`, completed steps keep `'success'`). Catch a
-`ctx.call` rejection inside `execute` to make a step best-effort.
-
-### 3. Chat tools auto-type from the server callback; per-verb `tools` is only for client-executed runtime
-
-Tools passed to `chat({ tools: [...] })` inside a chat verb's callback
-automatically type that verb's `messages` tool-call/result parts — with
-**no** client-side re-declaration needed for typing. Per-verb client options
-are nested under `verbs` (so verb names can't collide with
-`connection`/`id`/`threadId`):
-
-```typescript
-const txn = useTransaction(blogTransaction, {
-  connection: fetchServerSentEvents('/api/blog-studio'),
-  verbs: {
-    // runtime only for client-executed (.client()) tools — types already
-    // came from the server callback
-    drafting: { tools: [showToast] },
-  },
-})
-```
-
-Each **one-shot** verb's entry accepts `{ onResult, forwardedProps }`:
-`onResult` runs on the raw backend result and its return type becomes
-`txn.<verb>.result`'s type (return nothing to keep the raw result); chat
-verb entries accept `{ tools, forwardedProps }`.
-
-```typescript
-const txn = useTransaction(blogTransaction, {
-  connection: fetchServerSentEvents('/api/blog-studio'),
-  verbs: {
-    heroImage: { onResult: (result) => result.images[0]?.url ?? null },
-  },
-})
-
-txn.heroImage.result // string | null — the transform's return type
-```
-
-### 4. Structured output via `outputSchema` in a chat verb's callback
-
-If a chat verb's callback passes `outputSchema` to `chat()`, that verb's
-surface picks up typed `partial` (progressive `DeepPartial`) and `final`
-(validated terminal object), and `sendMessage` resolves to the validated
-final (or `null`) instead of the messages array. Omit `outputSchema` and
-neither field is present on the type — same conditional shape as
-`useChat({ outputSchema })`.
-
-### 5. Client needs the definition's TYPE — use `clientTransaction`
-
-`useTransaction` reads verb names/kinds at runtime and everything else at
-the type level. Define the transaction in a shared lib module, export
-`blogTransaction` for the API route and `blogTxnDef` beside it:
-
-```tsx
-// lib/blog-studio.ts
-export const blogTransaction = defineTransaction({
-  /* … */
-})
-
-export const blogTxnDef = clientTransaction<typeof blogTransaction>({
-  drafting: 'chat',
-  heroImage: 'one-shot',
-  blogPost: 'one-shot',
-})
-```
-
-When the definition is built per-request inside a handler, export a
-`ReturnType<typeof createTransaction>` type and bind with `import type`:
-
-```tsx
-import type { blogTransaction } from './api/blog-studio'
-import { clientTransaction } from '@tanstack/ai/transaction'
-
-const blogTxnDef = clientTransaction<typeof blogTransaction>({
-  drafting: 'chat',
-  heroImage: 'one-shot',
-  blogPost: 'one-shot',
-})
-```
-
-The generic is supplied via `import type` — erased from the bundle. The
-kinds map is checked exhaustively against the server definition. See
-`examples/ts-react-chat/src/lib/blog-studio.ts` for the full pattern.
-
-### 6. Only declared verbs are constructed; one shared connection
-
-`defineTransaction({ drafting, heroImage })` produces a client with exactly
-`txn.drafting` and `txn.heroImage`. All verbs share the single `connection`
-passed to `useTransaction` — one endpoint, one adapter. Each underlying
-sub-client (a `ChatClient` per chat verb, a `GenerationClient` per one-shot
-verb) tags its own requests with the verb name so the single `handler` can
-route.
-
-## Common Mistakes
-
-### a. HIGH: Writing a custom handler that branches on verb manually
-
-```typescript
-// WRONG — reimplementing what `handler` already does
-export const POST = async (request: Request) => {
-  const body = await request.json()
-  if (body.forwardedProps.verb === 'drafting') {
-    return toServerSentEventsResponse(
-      chat({ adapter, messages: body.messages }),
-    )
-  }
-  // ...manual branching for every verb
-}
-
-// CORRECT — defineTransaction's handler already parses, validates, routes,
-// and serializes
-export const POST = (request: Request) => blogTransaction.handler(request)
-```
-
-### b. HIGH: Passing `model` or generation options to `useTransaction`
-
-There is no `model`/`prompt` option on `useTransaction`. Model choice and
-generation parameters belong inside the server verbs
-(`openaiImage('gpt-image-2')`, …). Besides `connection`, the client options
-are `id`/`threadId` and the nested `verbs` map: chat verbs take
-`{ tools, forwardedProps }`, one-shot verbs `{ onResult, forwardedProps }`.
-
-```typescript
-// WRONG — no model/prompt options, and per-verb options are not top-level
-useTransaction(blogTransaction, { connection, model: 'gpt-5.5' })
-
-// CORRECT
-useTransaction(blogTxnDef, {
-  connection: fetchServerSentEvents('/api/blog-studio'),
-  verbs: { heroImage: { onResult: (r) => r.images[0]?.url ?? null } },
-})
-```
-
-### c. HIGH: Trusting `ctx.call(chatVerb, ...)`'s `structured` without re-validating
-
-`structured` is `unknown` (the callback's schema validated the stream, but a
-stopped/failed generation can leave it `null` or partial). Always
-`safeParse` it and throw on failure so the transaction fails with a clear
-`RUN_ERROR` instead of returning a half-built result.
-
-### d. MEDIUM: Client-side orchestration when the pipeline should be one request
-
-```typescript
-// WORKS, but: N requests, N abort scopes, intermediate values round-trip
-// through the browser
-const draft = await txn.drafting.sendMessage(topic)
-await txn.heroImage.run({ prompt: draft.title })
-
-// TRANSACTIONAL — declare a composing verb; ONE request, live subRuns, one
-// stop() for the whole pipeline
-await txn.blogPost.run({ topic })
-```
-
-Client-side chaining is right when the _user_ drives each step (regenerate
-buttons, editable intermediate state). Server-side `ctx.call` is right when
-one gesture should produce the finished artifact or fail as a unit.
-
-### e. MEDIUM: Forgetting to propagate `req.signal` into provider calls
-
-`stop()` aborts the fetch and halts orchestration, but a provider call not
-chained to `req.signal` (e.g. via `chat()`'s `abortController`) keeps
-burning tokens server-side until it completes. Thread the signal into every
-activity a verb runs.
-
-## Cross-References
-
-- See also: **ai-core/chat-experience/SKILL.md** -- a chat verb's surface is
-  the same `useChat` surface; streaming, tool rendering, and multimodal
-  messages all apply unchanged.
-- See also: **ai-core/media-generation/SKILL.md** -- one-shot verbs
-  typically wrap the generation activities documented there
-  (`generateImage`, `generateSpeech`, …).
-- See also: **ai-core/tool-calling/SKILL.md** -- Tools passed to a chat
-  verb's callback follow the same server/client tool patterns as a
-  standalone `chat()` route.
-- See also: **ai-core/custom-backend-integration/SKILL.md** -- The shared
-  `connection` passed to `useTransaction` is the same
-  `ConnectConnectionAdapter` used by `useChat` / `useGenerate*`.
diff --git a/packages/ai/src/activities/plugin/index.ts b/packages/ai/src/activities/plugin/index.ts
new file mode 100644
index 000000000..7cec5438b
--- /dev/null
+++ b/packages/ai/src/activities/plugin/index.ts
@@ -0,0 +1,234 @@
+import { EventType } from '@ag-ui/core'
+import { chatParamsFromRequestBody } from '../../utilities/chat-params.js'
+import { toServerSentEventsResponse } from '../../stream-to-response.js'
+import { toRunErrorPayload } from '../error-payload.js'
+import { validateWithStandardSchema } from '../chat/tools/schema-converter.js'
+import type {
+  AnyPlugin,
+  ChatPlugin,
+  ChatPluginReturn,
+  ChatPluginRequest,
+  GenerationPlugin,
+  GenerationPluginOptions,
+  GenerationPluginRequest,
+  PluginConfig,
+  PluginDefinition,
+} from './types.js'
+import type { InferSchemaType, SchemaInput, StreamChunk } from '../../types.js'
+
+export type * from './types.js'
+
+/** Declare a conversational plugin (full chat surface on the client). */
+export function chatPlugin<TRet extends ChatPluginReturn>(
+  callback: (req: ChatPluginRequest) => TRet,
+): ChatPlugin<(req: ChatPluginRequest) => TRet> {
+  return { kind: 'chat', callback }
+}
+
+/** Declare a one-shot plugin: (optionally schema-validated) input in, result out. */
+export function generationPlugin<
+  TResult,
+  const TSchema extends SchemaInput | undefined = undefined,
+>(
+  options: GenerationPluginOptions<TSchema, TResult>,
+): GenerationPlugin<
+  TSchema extends SchemaInput ? InferSchemaType<TSchema> : unknown,
+  TResult
+> {
+  return {
+    kind: 'one-shot',
+    ...(options.input !== undefined && { input: options.input }),
+    execute: options.execute,
+  }
+}
+
+function isAsyncIterable(value: unknown): value is AsyncIterable<unknown> {
+  return (
+    value != null && typeof value === 'object' && Symbol.asyncIterator in value
+  )
+}
+
+function customEvent(name: string, value: unknown): StreamChunk {
+  return {
+    type: EventType.CUSTOM,
+    name,
+    value,
+    timestamp: Date.now(),
+  }
+}
+
+interface RunEnvelope {
+  threadId: string
+  runId: string
+  parentRunId?: string
+  state: unknown
+  aguiContext: ChatPluginRequest['aguiContext']
+  forwardedProps: Record<string, unknown>
+}
+
+/**
+ * Define a server-side plugin endpoint: a registry of app-named plugins
+ * exposing a single request `handler`. Inert — no adapters, connections, or
+ * other resources are constructed until a request actually arrives.
+ *
+ * Routing: the client tags each request with a `plugin` discriminator in
+ * `forwardedProps`. Chat plugins speak the conversational AG-UI protocol;
+ * one-shot plugins receive validated input and return a result (or stream)
+ * for the response — one request, one abort scope.
+ */
+export function definePlugin<const T extends PluginConfig>(
+  config: T,
+): PluginDefinition<T> {
+  const plugins = Object.keys(config) as Array<keyof T & string>
+  const pluginKinds = Object.fromEntries(
+    Object.entries(config).map(([name, p]) => [name, p.kind]),
+  ) as Record<string, AnyPlugin['kind']>
+
+  const handler = async (request: Request): Promise<Response> => {
+    let body: unknown
+    try {
+      body = await request.json()
+    } catch {
+      return new Response('Invalid JSON body', { status: 400 })
+    }
+
+    // Both plugin kinds ride the AG-UI envelope; reject malformed bodies with
+    // a 400 (chatParamsFromRequestBody rejects with an AGUIError).
+    let params: Awaited<ReturnType<typeof chatParamsFromRequestBody>>
+    try {
+      params = await chatParamsFromRequestBody(body)
+    } catch (error) {
+      if (error instanceof Response) return error
+      return new Response(
+        error instanceof Error ? error.message : 'Invalid request body',
+        { status: 400 },
+      )
+    }
+
+    const pluginName = params.forwardedProps.plugin
+    // Route on OWN, DECLARED plugin names only — `plugins` comes from
+    // `Object.keys(config)`, which excludes inherited `Object.prototype`
+    // members (`toString`, `constructor`, ...) that a bare `in` check would
+    // otherwise treat as callable plugins.
+    const declared =
+      typeof pluginName === 'string' &&
+      (plugins as Array<string>).includes(pluginName)
+    // `Reflect.get` returns `any`; this is a single narrowing cast.
+    const target =
+      declared && typeof pluginName === 'string'
+        ? (Reflect.get(config, pluginName) as AnyPlugin | undefined)
+        : undefined
+    if (!target) {
+      return new Response(`Unknown plugin: ${String(pluginName)}`, {
+        status: 400,
+      })
+    }
+
+    const envelope: RunEnvelope = {
+      threadId: params.threadId,
+      runId: params.runId,
+      ...(params.parentRunId !== undefined && {
+        parentRunId: params.parentRunId,
+      }),
+      state: params.state,
+      aguiContext: params.aguiContext,
+      forwardedProps: params.forwardedProps,
+    }
+
+    if (target.kind === 'chat') {
+      const chatReq: ChatPluginRequest = {
+        messages: params.messages,
+        tools: params.tools,
+        ...envelope,
+        request,
+      }
+      const result = target.callback(chatReq)
+      if (!isAsyncIterable(result)) {
+        return new Response('chat plugin must return a streaming ChatStream', {
+          status: 400,
+        })
+      }
+      return toServerSentEventsResponse(result as AsyncIterable<any>)
+    }
+
+    // One-shot plugin: input = the forwarded props minus the routing
+    // discriminator, validated against the plugin's schema when declared.
+    const { plugin: _omit, ...rawInput } = params.forwardedProps
+    const validation = await validateWithStandardSchema(target.input, rawInput)
+    if (!validation.success) {
+      return new Response(
+        JSON.stringify({
+          error: 'Invalid plugin input',
+          plugin: pluginName,
+          issues: validation.issues,
+        }),
+        { status: 400, headers: { 'content-type': 'application/json' } },
+      )
+    }
+
+    return toServerSentEventsResponse(
+      runGenerationPluginStream(target, validation.data, envelope, request),
+    )
+  }
+
+  return { plugins, pluginKinds, handler, '~plugins': config }
+}
+
+/**
+ * Run a one-shot plugin to completion as a response stream: RUN_STARTED, the
+ * plugin's own `generation:result`, RUN_FINISHED — or RUN_ERROR on failure.
+ */
+async function* runGenerationPluginStream(
+  target: GenerationPlugin<any, any>,
+  input: unknown,
+  envelope: RunEnvelope,
+  request: Request,
+): AsyncIterable<StreamChunk> {
+  const { threadId, runId } = envelope
+
+  const req: GenerationPluginRequest = {
+    input,
+    ...envelope,
+    request,
+    signal: request.signal,
+  }
+
+  const out = target.execute(req)
+
+  // Escape hatch: an execute returning a raw StreamChunk iterable (e.g. a
+  // `stream: true` activity) is forwarded as-is.
+  if (isAsyncIterable(out)) {
+    yield* out
+    return
+  }
+
+  yield {
+    type: EventType.RUN_STARTED,
+    runId,
+    threadId,
+    timestamp: Date.now(),
+  }
+
+  try {
+    const result = await out
+    yield customEvent('generation:result', result)
+    yield {
+      type: EventType.RUN_FINISHED,
+      runId,
+      threadId,
+      finishReason: 'stop',
+      timestamp: Date.now(),
+    }
+  } catch (error) {
+    const payload = toRunErrorPayload(error, 'Plugin failed')
+    const codeFields =
+      payload.code !== undefined ? { code: payload.code } : undefined
+    yield {
+      type: EventType.RUN_ERROR,
+      message: payload.message,
+      ...codeFields,
+      error: { message: payload.message, ...codeFields },
+      timestamp: Date.now(),
+    }
+  }
+}
diff --git a/packages/ai/src/activities/plugin/media.ts b/packages/ai/src/activities/plugin/media.ts
new file mode 100644
index 000000000..b282710ff
--- /dev/null
+++ b/packages/ai/src/activities/plugin/media.ts
@@ -0,0 +1,225 @@
+// packages/ai/src/activities/plugin/media.ts
+//
+// Media plugin factories: thin, callback-style wrappers over the generic
+// `generationPlugin`. Each fixes the input schema + result type for one media
+// activity, so the client surface `plugin.<name>.run(input)` is typed input →
+// output end to end. The input schemas mirror the client-facing fields of the
+// corresponding `generate*` / `summarize` activity options (the adapter,
+// stream, debug, and middleware knobs are server concerns and are omitted).
+//
+// The input schemas are hand-rolled Standard Schemas rather than zod: this
+// package is schema-library-agnostic (it validates via `@standard-schema/spec`
+// and never ships a concrete schema library), so importing zod here would drag
+// zod into the bundle and make it a hard runtime dependency. Callers who want
+// richer input validation can bypass these factories and pass their own
+// zod/valibot/arktype schema straight to `generationPlugin({ input, execute })`.
+import type { StandardSchemaV1 } from '@standard-schema/spec'
+import { generationPlugin } from './index.js'
+import type { GenerationPlugin, GenerationPluginRequest } from './types.js'
+import type {
+  AudioGenerationResult,
+  ImageGenerationResult,
+  StreamChunk,
+  SummarizationResult,
+  TTSResult,
+  TranscriptionResult,
+  VideoJobResult,
+} from '../../types.js'
+
+/**
+ * A media plugin callback may resolve to the activity's result, or return a
+ * raw `StreamChunk` iterable (e.g. a `stream: true` activity) forwarded as-is.
+ */
+export type MaybeStream<T> = Promise<T> | AsyncIterable<StreamChunk>
+
+/**
+ * Build a zero-dependency Standard Schema for a media input `T`. Validation is
+ * intentionally lightweight — it confirms the value is an object and that the
+ * `required` keys are present, then types it as `T`. The typed client
+ * (`plugin.<name>.run(input)`) is the primary guardrail; deeper validation is
+ * a caller's choice via a custom `generationPlugin` schema.
+ *
+ * `StandardSchemaV1<T, T>` (input === output) is what makes `InferSchemaType`
+ * resolve `req.input` to `T`.
+ */
+function mediaSchema<T>(
+  required: ReadonlyArray<keyof T & string>,
+): StandardSchemaV1<T, T> {
+  return {
+    '~standard': {
+      version: 1,
+      vendor: 'tanstack-ai',
+      validate: (value) => {
+        if (typeof value !== 'object' || value === null) {
+          return { issues: [{ message: 'Expected an object' }] }
+        }
+        const record = value as Record<string, unknown>
+        for (const key of required) {
+          if (record[key] === undefined) {
+            return {
+              issues: [
+                { message: `Missing required field: ${key}`, path: [key] },
+              ],
+            }
+          }
+        }
+        return { value: value as T }
+      },
+    },
+  }
+}
+
+// ===========================
+// Image
+// ===========================
+
+export interface ImagePluginInput {
+  prompt: string
+  numberOfImages?: number
+  size?: string
+  modelOptions?: Record<string, unknown>
+}
+const imageInput = mediaSchema<ImagePluginInput>(['prompt'])
+
+/**
+ * A one-shot plugin that generates images. Pre-binds `req.input` to the image
+ * contract (`{ prompt, numberOfImages?, size?, modelOptions? }`) and the result
+ * to {@link ImageGenerationResult}.
+ */
+export function imagePlugin(
+  callback: (
+    req: GenerationPluginRequest<ImagePluginInput>,
+  ) => MaybeStream<ImageGenerationResult>,
+): GenerationPlugin<ImagePluginInput, ImageGenerationResult> {
+  return generationPlugin({ input: imageInput, execute: callback })
+}
+
+// ===========================
+// Video
+// ===========================
+
+export interface VideoPluginInput {
+  prompt: string
+  size?: string
+  duration?: number
+  modelOptions?: Record<string, unknown>
+}
+const videoInput = mediaSchema<VideoPluginInput>(['prompt'])
+
+/**
+ * A one-shot plugin that generates video. Pre-binds `req.input` to the video
+ * contract (`{ prompt, size?, duration?, modelOptions? }`) and the result to
+ * {@link VideoJobResult}.
+ */
+export function videoPlugin(
+  callback: (
+    req: GenerationPluginRequest<VideoPluginInput>,
+  ) => MaybeStream<VideoJobResult>,
+): GenerationPlugin<VideoPluginInput, VideoJobResult> {
+  return generationPlugin({ input: videoInput, execute: callback })
+}
+
+// ===========================
+// Audio
+// ===========================
+
+export interface AudioPluginInput {
+  prompt: string
+  duration?: number
+  modelOptions?: Record<string, unknown>
+}
+const audioInput = mediaSchema<AudioPluginInput>(['prompt'])
+
+/**
+ * A one-shot plugin that generates audio (music, sound effects, ...).
+ * Pre-binds `req.input` to the audio contract (`{ prompt, duration?,
+ * modelOptions? }`) and the result to {@link AudioGenerationResult}.
+ */
+export function audioPlugin(
+  callback: (
+    req: GenerationPluginRequest<AudioPluginInput>,
+  ) => MaybeStream<AudioGenerationResult>,
+): GenerationPlugin<AudioPluginInput, AudioGenerationResult> {
+  return generationPlugin({ input: audioInput, execute: callback })
+}
+
+// ===========================
+// Speech (TTS)
+// ===========================
+
+export interface SpeechPluginInput {
+  text: string
+  voice?: string
+  format?: 'mp3' | 'opus' | 'aac' | 'flac' | 'wav' | 'pcm'
+  speed?: number
+  modelOptions?: Record<string, unknown>
+}
+const speechInput = mediaSchema<SpeechPluginInput>(['text'])
+
+/**
+ * A one-shot plugin that generates speech from text. Pre-binds `req.input` to
+ * the speech contract (`{ text, voice?, format?, speed?, modelOptions? }`) and
+ * the result to {@link TTSResult}.
+ */
+export function speechPlugin(
+  callback: (
+    req: GenerationPluginRequest<SpeechPluginInput>,
+  ) => MaybeStream<TTSResult>,
+): GenerationPlugin<SpeechPluginInput, TTSResult> {
+  return generationPlugin({ input: speechInput, execute: callback })
+}
+
+// ===========================
+// Transcription
+// ===========================
+
+export interface TranscriptionPluginInput {
+  // Audio input travels over the wire as a base64 string (the activity's
+  // File/Blob/ArrayBuffer forms aren't JSON-serializable through the plugin
+  // request envelope).
+  audio: string
+  language?: string
+  prompt?: string
+  responseFormat?: 'json' | 'text' | 'srt' | 'verbose_json' | 'vtt'
+  modelOptions?: Record<string, unknown>
+}
+const transcriptionInput = mediaSchema<TranscriptionPluginInput>(['audio'])
+
+/**
+ * A one-shot plugin that transcribes audio to text. Pre-binds `req.input` to
+ * the transcription contract (`{ audio, language?, prompt?, responseFormat?,
+ * modelOptions? }`) and the result to {@link TranscriptionResult}.
+ */
+export function transcriptionPlugin(
+  callback: (
+    req: GenerationPluginRequest<TranscriptionPluginInput>,
+  ) => MaybeStream<TranscriptionResult>,
+): GenerationPlugin<TranscriptionPluginInput, TranscriptionResult> {
+  return generationPlugin({ input: transcriptionInput, execute: callback })
+}
+
+// ===========================
+// Summarize
+// ===========================
+
+export interface SummarizePluginInput {
+  text: string
+  maxLength?: number
+  style?: 'bullet-points' | 'paragraph' | 'concise'
+  focus?: Array<string>
+  modelOptions?: Record<string, unknown>
+}
+const summarizeInput = mediaSchema<SummarizePluginInput>(['text'])
+
+/**
+ * A one-shot plugin that summarizes text. Pre-binds `req.input` to the
+ * summarize contract (`{ text, maxLength?, style?, focus?, modelOptions? }`)
+ * and the result to {@link SummarizationResult}.
+ */
+export function summarizePlugin(
+  callback: (
+    req: GenerationPluginRequest<SummarizePluginInput>,
+  ) => MaybeStream<SummarizationResult>,
+): GenerationPlugin<SummarizePluginInput, SummarizationResult> {
+  return generationPlugin({ input: summarizeInput, execute: callback })
+}
diff --git a/packages/ai/src/activities/plugin/types.ts b/packages/ai/src/activities/plugin/types.ts
new file mode 100644
index 000000000..30bc42fdf
--- /dev/null
+++ b/packages/ai/src/activities/plugin/types.ts
@@ -0,0 +1,131 @@
+// packages/ai/src/activities/plugin/types.ts
+import type { Context as AGUIContext } from '@ag-ui/core'
+import type {
+  ChatStream,
+  InferSchemaType,
+  JSONSchema,
+  ModelMessage,
+  SchemaInput,
+  StreamChunk,
+  StructuredOutputStream,
+  UIMessage,
+} from '../../types.js'
+
+/** The parsed request handed to a chat plugin's callback. */
+export interface ChatPluginRequest {
+  messages: Array<UIMessage | ModelMessage>
+  threadId: string
+  runId: string
+  parentRunId?: string
+  /** Client-declared tools (name/description/JSON-schema) from the AG-UI body. */
+  tools: Array<{ name: string; description: string; parameters: JSONSchema }>
+  forwardedProps: Record<string, unknown>
+  state: unknown
+  aguiContext: Array<AGUIContext>
+  /** Raw request, for escape hatches (headers, auth). */
+  request: Request
+}
+
+/**
+ * The return types a chat plugin callback may produce. The promise forms are
+ * accepted for assignability with `chat()`'s overloads but rejected at
+ * request time — a chat plugin must stream.
+ */
+export type ChatPluginReturn =
+  | ChatStream
+  | StructuredOutputStream<any>
+  | Promise<string>
+  | Promise<object>
+
+/**
+ * The callback shape a chat plugin wraps: full conversational turns —
+ * message history in, a streaming chat (or structured-output) stream out.
+ */
+export type ChatPluginCallback = (req: ChatPluginRequest) => ChatPluginReturn
+
+/**
+ * A conversational plugin. Produces the full chat surface on the client
+ * (`sendMessage` / `messages` / tools / approvals). Create with
+ * {@link chatPlugin}; the callback generic is preserved so the client can
+ * infer tool and output-schema types from its return type.
+ */
+export interface ChatPlugin<
+  TCallback extends ChatPluginCallback = ChatPluginCallback,
+> {
+  readonly kind: 'chat'
+  readonly callback: TCallback
+}
+
+/** The parsed request handed to a one-shot plugin's `execute`. */
+export interface GenerationPluginRequest<TInput = unknown> {
+  /**
+   * The client-sent input. Validated against the plugin's `input` schema
+   * (when one is declared) before `execute` runs.
+   */
+  input: TInput
+  threadId: string
+  runId: string
+  parentRunId?: string
+  state: unknown
+  aguiContext: Array<AGUIContext>
+  /** The raw forwarded props, including fields outside the input schema. */
+  forwardedProps: Record<string, unknown>
+  /** Raw request, for escape hatches (headers, auth). */
+  request: Request
+  /**
+   * Aborted when the client disconnects or stops the run. Pass into
+   * activities (e.g. `chat({ abortSignal })`) to cancel provider work.
+   */
+  signal: AbortSignal
+}
+
+/** The `execute` shape of a one-shot plugin. */
+export type GenerationPluginExecute<TInput, TResult> = (
+  req: GenerationPluginRequest<TInput>,
+) => Promise<TResult> | AsyncIterable<StreamChunk>
+
+/**
+ * A one-shot plugin: validated input in, result out. Create with
+ * {@link generationPlugin}; the input/result generics are preserved so the
+ * client can type `plugin.<name>.run(input)` end to end.
+ */
+export interface GenerationPlugin<TInput = unknown, TResult = unknown> {
+  readonly kind: 'one-shot'
+  /** Optional Standard Schema for the input; validated before `execute`. */
+  readonly input?: SchemaInput
+  readonly execute: GenerationPluginExecute<TInput, TResult>
+}
+
+/** The options accepted by {@link generationPlugin}. */
+export interface GenerationPluginOptions<
+  TSchema extends SchemaInput | undefined,
+  TResult,
+> {
+  /**
+   * Standard Schema (Zod, ArkType, Valibot, ...) describing the input.
+   * Validated at runtime before `execute`; drives the client-side input type.
+   */
+  input?: TSchema
+  execute: GenerationPluginExecute<
+    TSchema extends SchemaInput ? InferSchemaType<TSchema> : unknown,
+    TResult
+  >
+}
+
+export type AnyPlugin = ChatPlugin<any> | GenerationPlugin<any, any>
+
+/** The shape a user passes to `definePlugin`: app-named plugins. */
+export type PluginConfig = Record<string, AnyPlugin>
+
+export type PluginKind = AnyPlugin['kind']
+
+export interface PluginDefinition<T extends PluginConfig = PluginConfig> {
+  /** The declared plugin names (for the client to enumerate). */
+  readonly plugins: ReadonlyArray<keyof T & string>
+  /** Each plugin's kind, so the client composer picks the right sub-client. */
+  readonly pluginKinds: Readonly<Record<string, PluginKind>>
+  /** Single request handler; routes by the `plugin` discriminator. */
+  handler: (request: Request) => Promise<Response>
+  /** Type-only carrier of the config for client inference. Never read at runtime. */
+  readonly '~plugins': T
+}
diff --git a/packages/ai/src/activities/transaction/index.ts b/packages/ai/src/activities/transaction/index.ts
deleted file mode 100644
index 6e1cb056e..000000000
--- a/packages/ai/src/activities/transaction/index.ts
+++ /dev/null
@@ -1,471 +0,0 @@
-import { EventType } from '@ag-ui/core'
-import { chatParamsFromRequestBody } from '../../utilities/chat-params.js'
-import { toServerSentEventsResponse } from '../../stream-to-response.js'
-import { toRunErrorPayload } from '../error-payload.js'
-import {
-  StandardSchemaValidationError,
-  validateWithStandardSchema,
-} from '../chat/tools/schema-converter.js'
-import { TRANSACTION_EVENTS } from './types.js'
-import type {
-  AnyVerb,
-  ChatVerb,
-  ChatVerbReturn,
-  ClientTransactionKinds,
-  CollectedChatResult,
-  OneShotVerb,
-  TransactionChatRequest,
-  TransactionConfig,
-  TransactionDefinition,
-  TransactionRunContext,
-  VerbOptions,
-  VerbRequest,
-} from './types.js'
-import type { InferSchemaType, SchemaInput, StreamChunk } from '../../types.js'
-
-export type * from './types.js'
-export { TRANSACTION_EVENTS } from './types.js'
-
-/** Declare a conversational verb (full chat surface on the client). */
-export function chatVerb<TRet extends ChatVerbReturn>(
-  callback: (req: TransactionChatRequest) => TRet,
-): ChatVerb<(req: TransactionChatRequest) => TRet> {
-  return { kind: 'chat', callback }
-}
-
-/** Declare a one-shot verb: (optionally schema-validated) input in, result out. */
-export function verb<
-  TResult,
-  const TSchema extends SchemaInput | undefined = undefined,
->(
-  options: VerbOptions<TSchema, TResult>,
-): OneShotVerb<
-  TSchema extends SchemaInput ? InferSchemaType<TSchema> : unknown,
-  TResult
-> {
-  return {
-    kind: 'one-shot',
-    ...(options.input !== undefined && { input: options.input }),
-    execute: options.execute,
-  }
-}
-
-function isAsyncIterable(value: unknown): value is AsyncIterable<unknown> {
-  return (
-    value != null && typeof value === 'object' && Symbol.asyncIterator in value
-  )
-}
-
-/**
- * An unbounded push channel bridging concurrently-running sub-verb streams
- * into the single response iterable. `push` after `close` is a no-op.
- */
-function createChunkChannel(): {
-  push: (chunk: StreamChunk) => void
-  close: () => void
-  [Symbol.asyncIterator]: () => AsyncIterator<StreamChunk>
-} {
-  const queue: Array<StreamChunk> = []
-  let notify: (() => void) | null = null
-  let closed = false
-
-  return {
-    push(chunk: StreamChunk) {
-      if (closed) return
-      queue.push(chunk)
-      notify?.()
-    },
-    close() {
-      closed = true
-      notify?.()
-    },
-    [Symbol.asyncIterator]() {
-      return {
-        async next(): Promise<IteratorResult<StreamChunk>> {
-          for (;;) {
-            const chunk = queue.shift()
-            if (chunk !== undefined) return { value: chunk, done: false }
-            if (closed) return { value: undefined, done: true }
-            await new Promise<void>((resolve) => {
-              notify = resolve
-            })
-            notify = null
-          }
-        },
-      }
-    },
-  }
-}
-
-function customEvent(name: string, value: unknown): StreamChunk {
-  return {
-    type: EventType.CUSTOM,
-    name,
-    value,
-    timestamp: Date.now(),
-  }
-}
-
-interface RunEnvelope {
-  threadId: string
-  runId: string
-  parentRunId?: string
-  state: unknown
-  aguiContext: TransactionChatRequest['aguiContext']
-  forwardedProps: Record<string, unknown>
-}
-
-/**
- * Define a server-side transaction endpoint: a registry of app-named verbs
- * exposing a single request `handler`. Inert — no adapters, connections, or
- * other resources are constructed until a request actually arrives.
- *
- * Routing: the client tags each request with a `verb` discriminator in
- * `forwardedProps`. Chat verbs speak the conversational AG-UI protocol;
- * one-shot verbs receive validated input and may compose sibling verbs via
- * `ctx.call`, which streams each sub-run back to the client tagged with
- * {@link TRANSACTION_EVENTS} custom events — one request, one abort scope.
- */
-export function defineTransaction<const T extends TransactionConfig>(
-  config: T,
-): TransactionDefinition<T> {
-  const verbs = Object.keys(config) as Array<keyof T & string>
-  const verbKinds = Object.fromEntries(
-    Object.entries(config).map(([name, v]) => [name, v.kind]),
-  ) as Record<string, AnyVerb['kind']>
-
-  const verbNameOf = (v: AnyVerb): string =>
-    verbs.find((name) => config[name] === v) ?? 'verb'
-
-  const handler = async (request: Request): Promise<Response> => {
-    let body: unknown
-    try {
-      body = await request.json()
-    } catch {
-      return new Response('Invalid JSON body', { status: 400 })
-    }
-
-    // Both verb kinds ride the AG-UI envelope; reject malformed bodies with
-    // a 400 (chatParamsFromRequestBody rejects with an AGUIError).
-    let params: Awaited<ReturnType<typeof chatParamsFromRequestBody>>
-    try {
-      params = await chatParamsFromRequestBody(body)
-    } catch (error) {
-      if (error instanceof Response) return error
-      return new Response(
-        error instanceof Error ? error.message : 'Invalid request body',
-        { status: 400 },
-      )
-    }
-
-    const verbName = params.forwardedProps.verb
-    // Route on OWN, DECLARED verb names only — `verbs` comes from
-    // `Object.keys(config)`, which excludes inherited `Object.prototype`
-    // members (`toString`, `constructor`, ...) that a bare `in` check would
-    // otherwise treat as callable verbs.
-    const declared =
-      typeof verbName === 'string' &&
-      (verbs as Array<string>).includes(verbName)
-    // `Reflect.get` returns `any`; this is a single narrowing cast.
-    const target =
-      declared && typeof verbName === 'string'
-        ? (Reflect.get(config, verbName) as AnyVerb | undefined)
-        : undefined
-    if (!target) {
-      return new Response(`Unknown transaction verb: ${String(verbName)}`, {
-        status: 400,
-      })
-    }
-
-    const envelope: RunEnvelope = {
-      threadId: params.threadId,
-      runId: params.runId,
-      ...(params.parentRunId !== undefined && {
-        parentRunId: params.parentRunId,
-      }),
-      state: params.state,
-      aguiContext: params.aguiContext,
-      forwardedProps: params.forwardedProps,
-    }
-
-    if (target.kind === 'chat') {
-      const chatReq: TransactionChatRequest = {
-        messages: params.messages,
-        tools: params.tools,
-        ...envelope,
-        request,
-      }
-      const result = target.callback(chatReq)
-      if (!isAsyncIterable(result)) {
-        return new Response(
-          'transaction chat verb must return a streaming ChatStream',
-          { status: 400 },
-        )
-      }
-      return toServerSentEventsResponse(result as AsyncIterable<any>)
-    }
-
-    // One-shot verb: input = the forwarded props minus the routing
-    // discriminator, validated against the verb's schema when declared.
-    const { verb: _omit, ...rawInput } = params.forwardedProps
-    const validation = await validateWithStandardSchema(target.input, rawInput)
-    if (!validation.success) {
-      return new Response(
-        JSON.stringify({
-          error: 'Invalid verb input',
-          verb: verbName,
-          issues: validation.issues,
-        }),
-        { status: 400, headers: { 'content-type': 'application/json' } },
-      )
-    }
-
-    return toServerSentEventsResponse(
-      runVerbStream(target, validation.data, envelope, request, verbNameOf),
-    )
-  }
-
-  return { verbs, verbKinds, handler, '~verbs': config }
-}
-
-/**
- * Build a type-only client stub for a server-side {@link defineTransaction}
- * definition. The browser only needs verb names and kinds at runtime; input,
- * result, tool, and schema types flow from `TDef` via `import type`.
- *
- * @example
- * ```ts
- * import { clientTransaction } from '@tanstack/ai/transaction'
- *
- * // `blogTransaction` is your server-side defineTransaction() export.
- * const txnDef = clientTransaction<typeof blogTransaction>({
- *   drafting: 'chat',
- *   heroImage: 'one-shot',
- *   narration: 'one-shot',
- *   blogPost: 'one-shot',
- * })
- * ```
- */
-export function clientTransaction<TDef extends TransactionDefinition<any>>(
-  kinds: ClientTransactionKinds<TDef>,
-): TDef {
-  const verbs = Object.keys(kinds) as Array<keyof TDef['~verbs'] & string>
-  const stub = {
-    verbs,
-    verbKinds: kinds,
-    handler: async () => {
-      throw new Error(
-        'clientTransaction definitions are type-only stubs and must not handle requests in the browser. Route requests to the server transaction handler.',
-      )
-    },
-    '~verbs': {} as TDef['~verbs'],
-  }
-  // Type-only stub: runtime value carries verb names/kinds; `~verbs` phantom
-  // comes from the generic `TDef` supplied by the caller.
-  // eslint-disable-next-line no-restricted-syntax -- phantom-only cast, see comment above
-  return stub as unknown as TDef
-}
-
-/**
- * Run a one-shot verb as the root of a (possibly multi-sub-run) transaction
- * stream: RUN_STARTED, live sub-run events from `ctx.call`, the verb's own
- * `generation:result`, RUN_FINISHED — or RUN_ERROR on failure.
- */
-async function* runVerbStream(
-  target: OneShotVerb<any, any>,
-  input: unknown,
-  envelope: RunEnvelope,
-  request: Request,
-  verbNameOf: (v: AnyVerb) => string,
-): AsyncIterable<StreamChunk> {
-  const { threadId, runId } = envelope
-  const channel = createChunkChannel()
-  let subIndex = 0
-
-  const call = async (subVerb: AnyVerb, subInput: unknown): Promise<any> => {
-    request.signal.throwIfAborted()
-    const index = subIndex++
-    const subRunId = `${runId}-sub-${index}`
-    const verbName = verbNameOf(subVerb)
-    const tag = { runId: subRunId, parentRunId: runId, verb: verbName, index }
-    channel.push(customEvent(TRANSACTION_EVENTS.SUB_RUN_STARTED, tag))
-    try {
-      let result: unknown
-      if (subVerb.kind === 'chat') {
-        result = await collectChatSubRun(
-          subVerb,
-          subInput as TransactionChatRequest['messages'],
-          { ...envelope, runId: subRunId, parentRunId: runId },
-          request,
-          (chunk) =>
-            channel.push(
-              customEvent(TRANSACTION_EVENTS.SUB_RUN_CHUNK, { ...tag, chunk }),
-            ),
-        )
-      } else {
-        const validation = await validateWithStandardSchema(
-          subVerb.input,
-          subInput,
-        )
-        if (!validation.success) {
-          throw new StandardSchemaValidationError(
-            validation.issues.map((issue) => ({ message: issue.message })),
-          )
-        }
-        const subReq: VerbRequest = {
-          input: validation.data,
-          threadId,
-          runId: subRunId,
-          parentRunId: runId,
-          state: envelope.state,
-          aguiContext: envelope.aguiContext,
-          forwardedProps: envelope.forwardedProps,
-          request,
-          signal: request.signal,
-        }
-        const out = subVerb.execute(subReq, ctx)
-        result = isAsyncIterable(out)
-          ? await forwardAndExtractResult(out, (chunk) =>
-              channel.push(
-                customEvent(TRANSACTION_EVENTS.SUB_RUN_CHUNK, {
-                  ...tag,
-                  chunk,
-                }),
-              ),
-            )
-          : await out
-      }
-      channel.push(
-        customEvent(TRANSACTION_EVENTS.SUB_RUN_RESULT, { ...tag, result }),
-      )
-      return result
-    } catch (error) {
-      channel.push(
-        customEvent(TRANSACTION_EVENTS.SUB_RUN_ERROR, {
-          ...tag,
-          message: error instanceof Error ? error.message : String(error),
-        }),
-      )
-      throw error
-    }
-  }
-
-  const ctx: TransactionRunContext = {
-    call: call as TransactionRunContext['call'],
-    signal: request.signal,
-  }
-
-  const req: VerbRequest = {
-    input,
-    ...envelope,
-    request,
-    signal: request.signal,
-  }
-
-  const out = target.execute(req, ctx)
-
-  // Escape hatch: an execute returning a raw StreamChunk iterable (e.g. a
-  // `stream: true` activity) is forwarded as-is. `ctx.call` is unavailable
-  // on this path — nothing drains the channel.
-  if (isAsyncIterable(out)) {
-    channel.close()
-    yield* out
-    return
-  }
-
-  yield {
-    type: EventType.RUN_STARTED,
-    runId,
-    threadId,
-    timestamp: Date.now(),
-  }
-
-  const execution = out.then(
-    (result) => ({ ok: true as const, result }),
-    (error: unknown) => ({ ok: false as const, error }),
-  )
-  void execution.finally(() => channel.close())
-
-  for await (const chunk of channel) {
-    yield chunk
-  }
-
-  const outcome = await execution
-  if (outcome.ok) {
-    yield customEvent('generation:result', outcome.result)
-    yield {
-      type: EventType.RUN_FINISHED,
-      runId,
-      threadId,
-      finishReason: 'stop',
-      timestamp: Date.now(),
-    }
-  } else {
-    const payload = toRunErrorPayload(outcome.error, 'Transaction failed')
-    const codeFields =
-      payload.code !== undefined ? { code: payload.code } : undefined
-    yield {
-      type: EventType.RUN_ERROR,
-      message: payload.message,
-      ...codeFields,
-      error: { message: payload.message, ...codeFields },
-      timestamp: Date.now(),
-    }
-  }
-}
-
-/**
- * Run a chat verb's callback to completion server-side, forwarding every
- * chunk to the transaction stream and collecting the accumulated text plus
- * the structured output (from the `structured-output.complete` event).
- */
-async function collectChatSubRun(
-  target: ChatVerb<any>,
-  messages: TransactionChatRequest['messages'],
-  envelope: RunEnvelope,
-  request: Request,
-  forward: (chunk: unknown) => void,
-): Promise<CollectedChatResult> {
-  const stream = target.callback({
-    messages,
-    tools: [],
-    ...envelope,
-    request,
-  })
-  if (!isAsyncIterable(stream)) {
-    throw new Error('transaction chat verb must return a streaming ChatStream')
-  }
-  let text = ''
-  let structured: unknown = null
-  for await (const chunk of stream as AsyncIterable<any>) {
-    request.signal.throwIfAborted()
-    forward(chunk)
-    if (chunk.type === EventType.TEXT_MESSAGE_CONTENT) {
-      text += typeof chunk.delta === 'string' ? chunk.delta : ''
-    } else if (
-      chunk.type === EventType.CUSTOM &&
-      chunk.name === 'structured-output.complete'
-    ) {
-      structured = chunk.value?.object ?? null
-    }
-  }
-  return { text, structured }
-}
-
-/**
- * Forward a streaming sub-verb's chunks and recover its result from the
- * terminal `generation:result` CUSTOM event.
- */
-async function forwardAndExtractResult(
-  stream: AsyncIterable<StreamChunk>,
-  forward: (chunk: unknown) => void,
-): Promise<unknown> {
-  let result: unknown = null
-  for await (const chunk of stream as AsyncIterable<any>) {
-    forward(chunk)
-    if (chunk.type === EventType.CUSTOM && chunk.name === 'generation:result') {
-      result = chunk.value
-    }
-  }
-  return result
-}
diff --git a/packages/ai/src/activities/transaction/types.ts b/packages/ai/src/activities/transaction/types.ts
deleted file mode 100644
index d66e98185..000000000
--- a/packages/ai/src/activities/transaction/types.ts
+++ /dev/null
@@ -1,201 +0,0 @@
-// packages/ai/src/activities/transaction/types.ts
-import type { Context as AGUIContext } from '@ag-ui/core'
-import type {
-  ChatStream,
-  InferSchemaType,
-  JSONSchema,
-  ModelMessage,
-  SchemaInput,
-  StreamChunk,
-  StructuredOutputStream,
-  UIMessage,
-} from '../../types.js'
-
-/** The parsed request handed to a chat verb's callback. */
-export interface TransactionChatRequest {
-  messages: Array<UIMessage | ModelMessage>
-  threadId: string
-  runId: string
-  parentRunId?: string
-  /** Client-declared tools (name/description/JSON-schema) from the AG-UI body. */
-  tools: Array<{ name: string; description: string; parameters: JSONSchema }>
-  forwardedProps: Record<string, unknown>
-  state: unknown
-  aguiContext: Array<AGUIContext>
-  /** Raw request, for escape hatches (headers, auth). */
-  request: Request
-}
-
-/**
- * The return types a chat verb callback may produce. The promise forms are
- * accepted for assignability with `chat()`'s overloads but rejected at
- * request time — a chat verb must stream.
- */
-export type ChatVerbReturn =
-  | ChatStream
-  | StructuredOutputStream<any>
-  | Promise<string>
-  | Promise<object>
-
-/**
- * The callback shape a chat verb wraps: full conversational turns — message
- * history in, a streaming chat (or structured-output) stream out.
- */
-export type ChatVerbCallback = (req: TransactionChatRequest) => ChatVerbReturn
-
-/**
- * A conversational verb. Produces the full chat surface on the client
- * (`sendMessage` / `messages` / tools / approvals). Create with
- * {@link chatVerb}; the callback generic is preserved so the client can
- * infer tool and output-schema types from its return type.
- */
-export interface ChatVerb<
-  TCallback extends ChatVerbCallback = ChatVerbCallback,
-> {
-  readonly kind: 'chat'
-  readonly callback: TCallback
-}
-
-/** The parsed request handed to a one-shot verb's `execute`. */
-export interface VerbRequest<TInput = unknown> {
-  /**
-   * The client-sent input. Validated against the verb's `input` schema
-   * (when one is declared) before `execute` runs.
-   */
-  input: TInput
-  threadId: string
-  runId: string
-  parentRunId?: string
-  state: unknown
-  aguiContext: Array<AGUIContext>
-  /** The raw forwarded props, including fields outside the input schema. */
-  forwardedProps: Record<string, unknown>
-  /** Raw request, for escape hatches (headers, auth). */
-  request: Request
-  /**
-   * Aborted when the client disconnects or stops the run. Pass into
-   * activities (e.g. `chat({ abortSignal })`) to cancel provider work.
-   */
-  signal: AbortSignal
-}
-
-/**
- * The result of running a chat verb to completion inside a transaction via
- * `ctx.call`: the accumulated assistant text plus the schema-validated
- * structured output (when the callback declared an `outputSchema`).
- */
-export interface CollectedChatResult<TStructured = unknown> {
-  text: string
-  structured: TStructured | null
-}
-
-/**
- * Composition context handed to every one-shot verb's `execute`. `ctx.call`
- * invokes another verb as a tagged sub-run of the current transaction: its
- * stream is forwarded into the parent response (so the client can observe it
- * live) and the call resolves with the sub-verb's result.
- */
-export interface TransactionRunContext {
-  call: TransactionCall
-  /** Aborted when the client disconnects or stops the run. */
-  signal: AbortSignal
-}
-
-export interface TransactionCall {
-  /** Run a one-shot verb as a sub-run; resolves with its result. */
-  <TIn, TRes>(verb: OneShotVerb<TIn, TRes>, input: TIn): Promise<TRes>
-  /**
-   * Run a chat verb's callback to completion as a sub-run; resolves with the
-   * accumulated text and (if the callback declared an `outputSchema`) the
-   * validated structured output.
-   */
-  <TCallback extends ChatVerbCallback>(
-    verb: ChatVerb<TCallback>,
-    messages: Array<UIMessage | ModelMessage>,
-  ): Promise<CollectedChatResult>
-}
-
-/** The `execute` shape of a one-shot verb. */
-export type VerbExecute<TInput, TResult> = (
-  req: VerbRequest<TInput>,
-  ctx: TransactionRunContext,
-) => Promise<TResult> | AsyncIterable<StreamChunk>
-
-/**
- * A one-shot verb: validated input in, result out. Create with {@link verb};
- * the input/result generics are preserved so the client can type
- * `txn.<name>.run(input)` end to end.
- */
-export interface OneShotVerb<TInput = unknown, TResult = unknown> {
-  readonly kind: 'one-shot'
-  /** Optional Standard Schema for the input; validated before `execute`. */
-  readonly input?: SchemaInput
-  readonly execute: VerbExecute<TInput, TResult>
-}
-
-/** The options accepted by {@link verb}. */
-export interface VerbOptions<TSchema extends SchemaInput | undefined, TResult> {
-  /**
-   * Standard Schema (Zod, ArkType, Valibot, ...) describing the input.
-   * Validated at runtime before `execute`; drives the client-side input type.
-   */
-  input?: TSchema
-  execute: VerbExecute<
-    TSchema extends SchemaInput ? InferSchemaType<TSchema> : unknown,
-    TResult
-  >
-}
-
-export type AnyVerb = ChatVerb<any> | OneShotVerb<any, any>
-
-/** The shape a user passes to `defineTransaction`: app-named verbs. */
-export type TransactionConfig = Record<string, AnyVerb>
-
-export type VerbKind = AnyVerb['kind']
-
-export interface TransactionDefinition<
-  T extends TransactionConfig = TransactionConfig,
-> {
-  /** The declared verb names (for the client to enumerate). */
-  readonly verbs: ReadonlyArray<keyof T & string>
-  /** Each verb's kind, so the client composer picks the right sub-client. */
-  readonly verbKinds: Readonly<Record<string, VerbKind>>
-  /** Single request handler; routes by the `verb` discriminator. */
-  handler: (request: Request) => Promise<Response>
-  /** Type-only carrier of the config for client inference. Never read at runtime. */
-  readonly '~verbs': T
-}
-
-/**
- * Verb-name → kind map required by {@link clientTransaction}. Every declared
- * verb must appear exactly once with its correct kind so client/server drift
- * fails at compile time.
- */
-export type ClientTransactionKinds<TDef extends TransactionDefinition<any>> = {
-  [K in keyof TDef['~verbs'] & string]: TDef['~verbs'][K]['kind']
-}
-
-/** Payloads of the CUSTOM events a transaction run emits for its sub-runs. */
-export interface SubRunStartedPayload {
-  runId: string
-  parentRunId: string
-  verb: string
-  index: number
-}
-export interface SubRunChunkPayload extends SubRunStartedPayload {
-  chunk: unknown
-}
-export interface SubRunResultPayload extends SubRunStartedPayload {
-  result: unknown
-}
-export interface SubRunErrorPayload extends SubRunStartedPayload {
-  message: string
-}
-
-/** CUSTOM event names used by the transaction sub-run protocol. */
-export const TRANSACTION_EVENTS = {
-  SUB_RUN_STARTED: 'transaction:sub-run:started',
-  SUB_RUN_CHUNK: 'transaction:sub-run:chunk',
-  SUB_RUN_RESULT: 'transaction:sub-run:result',
-  SUB_RUN_ERROR: 'transaction:sub-run:error',
-} as const
diff --git a/packages/ai/src/plugin.ts b/packages/ai/src/plugin.ts
new file mode 100644
index 000000000..46a91697a
--- /dev/null
+++ b/packages/ai/src/plugin.ts
@@ -0,0 +1,36 @@
+export {
+  chatPlugin,
+  definePlugin,
+  generationPlugin,
+} from './activities/plugin/index'
+export type {
+  AnyPlugin,
+  ChatPlugin,
+  ChatPluginCallback,
+  ChatPluginRequest,
+  ChatPluginReturn,
+  GenerationPlugin,
+  GenerationPluginExecute,
+  GenerationPluginOptions,
+  GenerationPluginRequest,
+  PluginConfig,
+  PluginDefinition,
+  PluginKind,
+} from './activities/plugin/index'
+export {
+  audioPlugin,
+  imagePlugin,
+  speechPlugin,
+  summarizePlugin,
+  transcriptionPlugin,
+  videoPlugin,
+} from './activities/plugin/media'
+export type {
+  AudioPluginInput,
+  ImagePluginInput,
+  MaybeStream,
+  SpeechPluginInput,
+  SummarizePluginInput,
+  TranscriptionPluginInput,
+  VideoPluginInput,
+} from './activities/plugin/media'
diff --git a/packages/ai/src/transaction.ts b/packages/ai/src/transaction.ts
deleted file mode 100644
index 4409b58cb..000000000
--- a/packages/ai/src/transaction.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-export {
-  chatVerb,
-  clientTransaction,
-  defineTransaction,
-  verb,
-  TRANSACTION_EVENTS,
-} from './activities/transaction/index'
-export type {
-  AnyVerb,
-  ChatVerb,
-  ChatVerbCallback,
-  ClientTransactionKinds,
-  CollectedChatResult,
-  OneShotVerb,
-  SubRunChunkPayload,
-  SubRunErrorPayload,
-  SubRunResultPayload,
-  SubRunStartedPayload,
-  TransactionCall,
-  TransactionChatRequest,
-  TransactionConfig,
-  TransactionDefinition,
-  TransactionRunContext,
-  VerbExecute,
-  VerbKind,
-  VerbOptions,
-  VerbRequest,
-} from './activities/transaction/index'
diff --git a/packages/ai/tests/activities/chat/chat-result-meta.test.ts b/packages/ai/tests/activities/chat/chat-result-meta.test.ts
index 7d8cab14f..de58ab18e 100644
--- a/packages/ai/tests/activities/chat/chat-result-meta.test.ts
+++ b/packages/ai/tests/activities/chat/chat-result-meta.test.ts
@@ -9,7 +9,7 @@
  *
  * The phantom is optional (`'~chatMeta'?:`), so it must not change
  * assignability of `chat()`'s return to its pre-existing consumers (see
- * `chat-result-types.test.ts` and `activities/transaction/index.test.ts` for
+ * `chat-result-types.test.ts` and `activities/plugin/index.test.ts` for
  * the pinned pre-phantom shapes).
  */
 import { describe, expectTypeOf, it } from 'vitest'
diff --git a/packages/ai/tests/activities/plugin/index.test.ts b/packages/ai/tests/activities/plugin/index.test.ts
new file mode 100644
index 000000000..ad808799f
--- /dev/null
+++ b/packages/ai/tests/activities/plugin/index.test.ts
@@ -0,0 +1,199 @@
+import { describe, expect, it, vi } from 'vitest'
+import { z } from 'zod'
+import {
+  chatPlugin,
+  definePlugin,
+  generationPlugin,
+} from '../../../src/activities/plugin/index.js'
+import type { ChatPluginCallback } from '../../../src/activities/plugin/types.js'
+import type { ChatStream } from '../../../src/types.js'
+
+// Compile-only: a streaming chat callback (the shape `chat()` returns by
+// default) must be assignable to `ChatPluginCallback` without a cast.
+const _chatCbAssignable: ChatPluginCallback = (_req) =>
+  undefined as unknown as ChatStream
+void _chatCbAssignable
+
+function runAgentBody(pluginName: string, extra: Record<string, unknown> = {}) {
+  return {
+    threadId: 't1',
+    runId: 'r1',
+    state: {},
+    messages: [],
+    tools: [],
+    context: [],
+    forwardedProps: { plugin: pluginName, ...extra },
+  }
+}
+
+function req(body: unknown) {
+  return new Request('http://x/api/plugin', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+}
+
+async function readSse(res: Response): Promise<Array<any>> {
+  const text = await res.text()
+  return text
+    .split('\n\n')
+    .map((l) => l.replace(/^data: /, '').trim())
+    .filter(Boolean)
+    .map((l) => JSON.parse(l))
+}
+
+const emptyChat = () =>
+  chatPlugin(async function* (r: any) {
+    yield {
+      type: 'RUN_STARTED',
+      threadId: r.threadId,
+      runId: r.runId,
+    } as any
+    yield {
+      type: 'RUN_FINISHED',
+      threadId: r.threadId,
+      runId: r.runId,
+    } as any
+  } as any)
+
+describe('definePlugin', () => {
+  it('is inert: does not invoke any plugin at define time', () => {
+    const execute = vi.fn()
+    const callback = vi.fn()
+    const def = definePlugin({
+      primaryChat: chatPlugin(callback as any),
+      banner: generationPlugin({ execute }),
+    })
+    expect(execute).not.toHaveBeenCalled()
+    expect(callback).not.toHaveBeenCalled()
+    expect(def.plugins.slice().sort()).toEqual(['banner', 'primaryChat'])
+    expect(def.pluginKinds).toEqual({ primaryChat: 'chat', banner: 'one-shot' })
+    expect(typeof def.handler).toBe('function')
+  })
+
+  it('is exported from the plugin subpath entry', async () => {
+    const mod = await import('../../../src/plugin.js')
+    expect(typeof mod.definePlugin).toBe('function')
+    expect(typeof mod.generationPlugin).toBe('function')
+    expect(typeof mod.chatPlugin).toBe('function')
+  }, 30000)
+})
+
+describe('plugin.handler routing', () => {
+  it('400s on an unknown plugin', async () => {
+    const def = definePlugin({ primaryChat: emptyChat() })
+    const res = await def.handler(req(runAgentBody('banner')))
+    expect(res.status).toBe(400)
+  })
+
+  it('400s on an inherited Object.prototype key used as plugin name', async () => {
+    const def = definePlugin({ primaryChat: emptyChat() })
+    const res = await def.handler(req(runAgentBody('toString')))
+    expect(res.status).toBe(400)
+  })
+
+  it('routes a chat plugin and streams the callback iterable', async () => {
+    const def = definePlugin({ primaryChat: emptyChat() })
+    const res = await def.handler(req(runAgentBody('primaryChat')))
+    expect(res.headers.get('content-type')).toContain('text/event-stream')
+    const chunks = await readSse(res)
+    expect(chunks[0].type).toBe('RUN_STARTED')
+  })
+
+  it('supports multiple independently-routed chat plugins', async () => {
+    const seen: Array<string> = []
+    const mkChat = (label: string) =>
+      chatPlugin(async function* (r: any) {
+        seen.push(label)
+        yield {
+          type: 'RUN_STARTED',
+          threadId: r.threadId,
+          runId: r.runId,
+        } as any
+      } as any)
+    const def = definePlugin({
+      primaryChat: mkChat('primary'),
+      summaryChat: mkChat('summary'),
+    })
+    await (await def.handler(req(runAgentBody('summaryChat')))).text()
+    expect(seen).toEqual(['summary'])
+    await (await def.handler(req(runAgentBody('primaryChat')))).text()
+    expect(seen).toEqual(['summary', 'primary'])
+  })
+})
+
+describe('one-shot plugins', () => {
+  it('wraps the execute result as a generation:result CUSTOM event', async () => {
+    const def = definePlugin({
+      banner: generationPlugin({
+        input: z.object({ prompt: z.string() }),
+        execute: async ({ input }) => ({ url: `generated:${input.prompt}` }),
+      }),
+    })
+    const res = await def.handler(
+      req(runAgentBody('banner', { prompt: 'a fox' })),
+    )
+    const chunks = await readSse(res)
+    expect(chunks[0].type).toBe('RUN_STARTED')
+    const custom = chunks.find((c) => c.type === 'CUSTOM')
+    expect(custom.name).toBe('generation:result')
+    expect(custom.value.url).toBe('generated:a fox')
+    expect(chunks.at(-1).type).toBe('RUN_FINISHED')
+  })
+
+  it('validates input against the plugin schema and 400s with issues', async () => {
+    const execute = vi.fn()
+    const def = definePlugin({
+      banner: generationPlugin({
+        input: z.object({ prompt: z.string() }),
+        execute,
+      }),
+    })
+    const res = await def.handler(req(runAgentBody('banner', { prompt: 42 })))
+    expect(res.status).toBe(400)
+    const body = await res.json()
+    expect(body.error).toBe('Invalid plugin input')
+    expect(body.plugin).toBe('banner')
+    expect(body.issues.length).toBeGreaterThan(0)
+    expect(execute).not.toHaveBeenCalled()
+  })
+
+  it('gives execute the validated envelope and an abort signal', async () => {
+    const def = definePlugin({
+      echo: generationPlugin({
+        execute: async (r) => ({
+          threadId: r.threadId,
+          runId: r.runId,
+          state: r.state,
+          hasSignal: r.signal instanceof AbortSignal,
+          plugin: r.forwardedProps.plugin,
+        }),
+      }),
+    })
+    const body = runAgentBody('echo', { anything: true })
+    const chunks = await readSse(await def.handler(req(body)))
+    const custom = chunks.find((c) => c.type === 'CUSTOM')
+    expect(custom.value).toEqual({
+      threadId: 't1',
+      runId: 'r1',
+      state: {},
+      hasSignal: true,
+      plugin: 'echo',
+    })
+  })
+
+  it('emits RUN_ERROR when execute rejects', async () => {
+    const def = definePlugin({
+      boom: generationPlugin({
+        execute: async () => {
+          throw new Error('kaboom')
+        },
+      }),
+    })
+    const chunks = await readSse(await def.handler(req(runAgentBody('boom'))))
+    const error = chunks.find((c) => c.type === 'RUN_ERROR')
+    expect(error.message).toContain('kaboom')
+    expect(chunks.find((c) => c.type === 'RUN_FINISHED')).toBeUndefined()
+  })
+})
diff --git a/packages/ai/tests/activities/plugin/media.test.ts b/packages/ai/tests/activities/plugin/media.test.ts
new file mode 100644
index 000000000..15fcd2676
--- /dev/null
+++ b/packages/ai/tests/activities/plugin/media.test.ts
@@ -0,0 +1,41 @@
+import { describe, expect, it } from 'vitest'
+import { generationPlugin, imagePlugin } from '../../../src/plugin'
+
+describe('imagePlugin', () => {
+  it('produces a one-shot generation plugin that types req.input as the image contract', async () => {
+    const p = imagePlugin(async (req) => ({
+      id: 'img-1',
+      model: 'test-model',
+      images: [{ b64Json: `img:${req.input.prompt}` }],
+    }))
+    expect(p.kind).toBe('one-shot')
+    // execute runs the callback with the parsed input
+    const req = {
+      input: { prompt: 'a cat' },
+      threadId: 't',
+      runId: 'r',
+      state: null,
+      aguiContext: [],
+      forwardedProps: {},
+      request: new Request('http://x'),
+      signal: new AbortController().signal,
+    }
+    const out = await p.execute(req)
+    if (Symbol.asyncIterator in out) {
+      throw new Error('expected a resolved result, not a stream')
+    }
+    expect(out.images[0]?.b64Json).toBe('img:a cat')
+  })
+
+  it('is equivalent to generationPlugin with the image schema (accepts numberOfImages/size)', () => {
+    const p = imagePlugin(async () => ({
+      id: 'img-2',
+      model: 'test-model',
+      images: [],
+    }))
+    expect(typeof p.execute).toBe('function')
+    expect(p.input).toBeDefined() // image input schema present
+    // sanity: generationPlugin is the underlying primitive
+    expect(typeof generationPlugin).toBe('function')
+  })
+})
diff --git a/packages/ai/tests/activities/transaction/index.test.ts b/packages/ai/tests/activities/transaction/index.test.ts
deleted file mode 100644
index cbeff77de..000000000
--- a/packages/ai/tests/activities/transaction/index.test.ts
+++ /dev/null
@@ -1,408 +0,0 @@
-import { describe, expect, expectTypeOf, it, vi } from 'vitest'
-import { z } from 'zod'
-import {
-  TRANSACTION_EVENTS,
-  chatVerb,
-  clientTransaction,
-  defineTransaction,
-  verb,
-} from '../../../src/activities/transaction/index.js'
-import type { ChatVerbCallback } from '../../../src/activities/transaction/types.js'
-import type { ChatStream } from '../../../src/types.js'
-
-// Compile-only: a streaming chat callback (the shape `chat()` returns by
-// default) must be assignable to `ChatVerbCallback` without a cast.
-const _chatCbAssignable: ChatVerbCallback = (_req) =>
-  undefined as unknown as ChatStream
-void _chatCbAssignable
-
-function runAgentBody(verbName: string, extra: Record<string, unknown> = {}) {
-  return {
-    threadId: 't1',
-    runId: 'r1',
-    state: {},
-    messages: [],
-    tools: [],
-    context: [],
-    forwardedProps: { verb: verbName, ...extra },
-  }
-}
-
-function req(body: unknown) {
-  return new Request('http://x/api/transaction', {
-    method: 'POST',
-    headers: { 'content-type': 'application/json' },
-    body: JSON.stringify(body),
-  })
-}
-
-async function readSse(res: Response): Promise<Array<any>> {
-  const text = await res.text()
-  return text
-    .split('\n\n')
-    .map((l) => l.replace(/^data: /, '').trim())
-    .filter(Boolean)
-    .map((l) => JSON.parse(l))
-}
-
-const emptyChat = () =>
-  chatVerb(async function* (r: any) {
-    yield {
-      type: 'RUN_STARTED',
-      threadId: r.threadId,
-      runId: r.runId,
-    } as any
-    yield {
-      type: 'RUN_FINISHED',
-      threadId: r.threadId,
-      runId: r.runId,
-    } as any
-  } as any)
-
-describe('defineTransaction', () => {
-  it('is inert: does not invoke any verb at define time', () => {
-    const execute = vi.fn()
-    const callback = vi.fn()
-    const txn = defineTransaction({
-      primaryChat: chatVerb(callback as any),
-      banner: verb({ execute }),
-    })
-    expect(execute).not.toHaveBeenCalled()
-    expect(callback).not.toHaveBeenCalled()
-    expect(txn.verbs.slice().sort()).toEqual(['banner', 'primaryChat'])
-    expect(txn.verbKinds).toEqual({ primaryChat: 'chat', banner: 'one-shot' })
-    expect(typeof txn.handler).toBe('function')
-  })
-
-  it('is exported from the transaction subpath entry', async () => {
-    const mod = await import('../../../src/transaction.js')
-    expect(typeof mod.defineTransaction).toBe('function')
-    expect(typeof mod.verb).toBe('function')
-    expect(typeof mod.chatVerb).toBe('function')
-  }, 30000)
-})
-
-describe('transaction.handler routing', () => {
-  it('400s on an unknown verb', async () => {
-    const txn = defineTransaction({ primaryChat: emptyChat() })
-    const res = await txn.handler(req(runAgentBody('banner')))
-    expect(res.status).toBe(400)
-  })
-
-  it('400s on an inherited Object.prototype key used as verb', async () => {
-    const txn = defineTransaction({ primaryChat: emptyChat() })
-    const res = await txn.handler(req(runAgentBody('toString')))
-    expect(res.status).toBe(400)
-  })
-
-  it('routes a chat verb and streams the callback iterable', async () => {
-    const txn = defineTransaction({ primaryChat: emptyChat() })
-    const res = await txn.handler(req(runAgentBody('primaryChat')))
-    expect(res.headers.get('content-type')).toContain('text/event-stream')
-    const chunks = await readSse(res)
-    expect(chunks[0].type).toBe('RUN_STARTED')
-  })
-
-  it('supports multiple independently-routed chat verbs', async () => {
-    const seen: Array<string> = []
-    const mkChat = (label: string) =>
-      chatVerb(async function* (r: any) {
-        seen.push(label)
-        yield {
-          type: 'RUN_STARTED',
-          threadId: r.threadId,
-          runId: r.runId,
-        } as any
-      } as any)
-    const txn = defineTransaction({
-      primaryChat: mkChat('primary'),
-      summaryChat: mkChat('summary'),
-    })
-    await (await txn.handler(req(runAgentBody('summaryChat')))).text()
-    expect(seen).toEqual(['summary'])
-    await (await txn.handler(req(runAgentBody('primaryChat')))).text()
-    expect(seen).toEqual(['summary', 'primary'])
-  })
-})
-
-describe('one-shot verbs', () => {
-  it('wraps the execute result as a generation:result CUSTOM event', async () => {
-    const txn = defineTransaction({
-      banner: verb({
-        input: z.object({ prompt: z.string() }),
-        execute: async ({ input }) => ({ url: `generated:${input.prompt}` }),
-      }),
-    })
-    const res = await txn.handler(
-      req(runAgentBody('banner', { prompt: 'a fox' })),
-    )
-    const chunks = await readSse(res)
-    expect(chunks[0].type).toBe('RUN_STARTED')
-    const custom = chunks.find((c) => c.type === 'CUSTOM')
-    expect(custom.name).toBe('generation:result')
-    expect(custom.value.url).toBe('generated:a fox')
-    expect(chunks.at(-1).type).toBe('RUN_FINISHED')
-  })
-
-  it('validates input against the verb schema and 400s with issues', async () => {
-    const execute = vi.fn()
-    const txn = defineTransaction({
-      banner: verb({
-        input: z.object({ prompt: z.string() }),
-        execute,
-      }),
-    })
-    const res = await txn.handler(req(runAgentBody('banner', { prompt: 42 })))
-    expect(res.status).toBe(400)
-    const body = await res.json()
-    expect(body.error).toBe('Invalid verb input')
-    expect(body.verb).toBe('banner')
-    expect(body.issues.length).toBeGreaterThan(0)
-    expect(execute).not.toHaveBeenCalled()
-  })
-
-  it('gives execute the validated envelope and an abort signal', async () => {
-    const txn = defineTransaction({
-      echo: verb({
-        execute: async (r) => ({
-          threadId: r.threadId,
-          runId: r.runId,
-          state: r.state,
-          hasSignal: r.signal instanceof AbortSignal,
-          verb: r.forwardedProps.verb,
-        }),
-      }),
-    })
-    const body = runAgentBody('echo', { anything: true })
-    const chunks = await readSse(await txn.handler(req(body)))
-    const custom = chunks.find((c) => c.type === 'CUSTOM')
-    expect(custom.value).toEqual({
-      threadId: 't1',
-      runId: 'r1',
-      state: {},
-      hasSignal: true,
-      verb: 'echo',
-    })
-  })
-
-  it('emits RUN_ERROR when execute rejects', async () => {
-    const txn = defineTransaction({
-      boom: verb({
-        execute: async () => {
-          throw new Error('kaboom')
-        },
-      }),
-    })
-    const chunks = await readSse(await txn.handler(req(runAgentBody('boom'))))
-    const error = chunks.find((c) => c.type === 'RUN_ERROR')
-    expect(error.message).toContain('kaboom')
-    expect(chunks.find((c) => c.type === 'RUN_FINISHED')).toBeUndefined()
-  })
-})
-
-describe('transactions (ctx.call)', () => {
-  it('runs sibling one-shot verbs as tagged sub-runs inside one response', async () => {
-    const banner = verb({
-      input: z.object({ prompt: z.string() }),
-      execute: async ({ input }) => ({ url: `img:${input.prompt}` }),
-    })
-    const txn = defineTransaction({
-      banner,
-      blogPost: verb({
-        input: z.object({ topic: z.string() }),
-        execute: async ({ input }, ctx) => {
-          const [hero, thumb] = await Promise.all([
-            ctx.call(banner, { prompt: `hero ${input.topic}` }),
-            ctx.call(banner, { prompt: `thumb ${input.topic}` }),
-          ])
-          return { hero, thumb }
-        },
-      }),
-    })
-
-    const chunks = await readSse(
-      await txn.handler(req(runAgentBody('blogPost', { topic: 'foxes' }))),
-    )
-
-    const started = chunks.filter(
-      (c) => c.name === TRANSACTION_EVENTS.SUB_RUN_STARTED,
-    )
-    expect(started).toHaveLength(2)
-    expect(started[0].value.verb).toBe('banner')
-    expect(started[0].value.parentRunId).toBe('r1')
-    expect(started[0].value.runId).not.toBe(started[1].value.runId)
-
-    const results = chunks.filter(
-      (c) => c.name === TRANSACTION_EVENTS.SUB_RUN_RESULT,
-    )
-    expect(results.map((r) => r.value.result.url).sort()).toEqual([
-      'img:hero foxes',
-      'img:thumb foxes',
-    ])
-
-    const final = chunks.find((c) => c.name === 'generation:result')
-    expect(final.value).toEqual({
-      hero: { url: 'img:hero foxes' },
-      thumb: { url: 'img:thumb foxes' },
-    })
-    expect(chunks.at(-1).type).toBe('RUN_FINISHED')
-  })
-
-  it('validates sub-verb input and surfaces a sub-run error + RUN_ERROR', async () => {
-    const banner = verb({
-      input: z.object({ prompt: z.string() }),
-      execute: async () => ({ url: 'never' }),
-    })
-    const txn = defineTransaction({
-      banner,
-      bad: verb({
-        execute: async (_r, ctx) => ctx.call(banner, { prompt: 42 as any }),
-      }),
-    })
-    const chunks = await readSse(await txn.handler(req(runAgentBody('bad'))))
-    const subError = chunks.find(
-      (c) => c.name === TRANSACTION_EVENTS.SUB_RUN_ERROR,
-    )
-    expect(subError.value.verb).toBe('banner')
-    expect(chunks.find((c) => c.type === 'RUN_ERROR')).toBeDefined()
-  })
-
-  it('collects text and structured output from a chat verb sub-run', async () => {
-    const drafting = chatVerb(async function* (r: any) {
-      yield { type: 'RUN_STARTED', threadId: r.threadId, runId: r.runId } as any
-      yield {
-        type: 'TEXT_MESSAGE_CONTENT',
-        messageId: 'm1',
-        delta: 'Hel',
-      } as any
-      yield {
-        type: 'TEXT_MESSAGE_CONTENT',
-        messageId: 'm1',
-        delta: 'lo',
-      } as any
-      yield {
-        type: 'CUSTOM',
-        name: 'structured-output.complete',
-        value: { object: { title: 'Foxes' }, raw: '{"title":"Foxes"}' },
-      } as any
-      yield {
-        type: 'RUN_FINISHED',
-        threadId: r.threadId,
-        runId: r.runId,
-      } as any
-    } as any)
-    const txn = defineTransaction({
-      drafting,
-      blogPost: verb({
-        execute: async (_r, ctx) => {
-          const draft = await ctx.call(drafting, [
-            { role: 'user', content: 'write about foxes' },
-          ])
-          return draft
-        },
-      }),
-    })
-    const chunks = await readSse(
-      await txn.handler(req(runAgentBody('blogPost'))),
-    )
-    const forwarded = chunks.filter(
-      (c) => c.name === TRANSACTION_EVENTS.SUB_RUN_CHUNK,
-    )
-    expect(forwarded.length).toBeGreaterThan(0)
-    expect(forwarded[0].value.verb).toBe('drafting')
-    const final = chunks.find((c) => c.name === 'generation:result')
-    expect(final.value).toEqual({
-      text: 'Hello',
-      structured: { title: 'Foxes' },
-    })
-  })
-})
-
-describe('clientTransaction', () => {
-  const serverTxn = defineTransaction({
-    primaryChat: chatVerb(async function* () {} as any),
-    banner: verb({
-      input: z.object({ prompt: z.string() }),
-      execute: async ({ input }) => ({ prompt: input.prompt, url: 'x' }),
-    }),
-    bannerPair: verb({
-      input: z.object({ topic: z.string() }),
-      execute: async ({ input }, ctx) => {
-        const hero = await ctx.call(
-          verb({
-            input: z.object({ prompt: z.string() }),
-            execute: async () => ({ url: 'hero' }),
-          }),
-          { prompt: input.topic },
-        )
-        return { hero }
-      },
-    }),
-  })
-
-  it('builds verbs and verbKinds from the kinds map', () => {
-    const clientTxn = clientTransaction<typeof serverTxn>({
-      primaryChat: 'chat',
-      banner: 'one-shot',
-      bannerPair: 'one-shot',
-    })
-    expect(clientTxn.verbs.slice().sort()).toEqual([
-      'banner',
-      'bannerPair',
-      'primaryChat',
-    ])
-    expect(clientTxn.verbKinds).toEqual({
-      primaryChat: 'chat',
-      banner: 'one-shot',
-      bannerPair: 'one-shot',
-    })
-  })
-
-  it('handler throws — client stubs must not handle requests', async () => {
-    const clientTxn = clientTransaction<typeof serverTxn>({
-      primaryChat: 'chat',
-      banner: 'one-shot',
-      bannerPair: 'one-shot',
-    })
-    await expect(clientTxn.handler(new Request('http://x'))).rejects.toThrow(
-      /type-only stubs/,
-    )
-  })
-
-  it('is exported from the transaction subpath entry', async () => {
-    const mod = await import('../../../src/transaction.js')
-    expect(typeof mod.clientTransaction).toBe('function')
-  })
-
-  it('is assignable to the server definition type', () => {
-    const clientTxn = clientTransaction<typeof serverTxn>({
-      primaryChat: 'chat',
-      banner: 'one-shot',
-      bannerPair: 'one-shot',
-    })
-    expectTypeOf(clientTxn).toMatchTypeOf<typeof serverTxn>()
-  })
-
-  // Compile-only: missing or wrong kinds must fail type-check.
-  void (() =>
-    // @ts-expect-error — bannerPair is required
-    clientTransaction<typeof serverTxn>({
-      primaryChat: 'chat',
-      banner: 'one-shot',
-    }))
-  void (() =>
-    clientTransaction<typeof serverTxn>({
-      primaryChat: 'chat',
-      banner: 'one-shot',
-      bannerPair: 'one-shot',
-      // @ts-expect-error — extra verbs are rejected
-      extra: 'one-shot',
-    }))
-  void (() =>
-    clientTransaction<typeof serverTxn>({
-      // @ts-expect-error — wrong kind for primaryChat
-      primaryChat: 'one-shot',
-      banner: 'one-shot',
-      bannerPair: 'one-shot',
-    }))
-})
diff --git a/packages/ai/vite.config.ts b/packages/ai/vite.config.ts
index 234c159e4..844b1a603 100644
--- a/packages/ai/vite.config.ts
+++ b/packages/ai/vite.config.ts
@@ -31,7 +31,7 @@ export default mergeConfig(
   tanstackViteConfig({
     entry: [
       './src/index.ts',
-      './src/transaction.ts',
+      './src/plugin.ts',
       './src/client.ts',
       './src/activities/index.ts',
       './src/middlewares/index.ts',
diff --git a/testing/e2e/fixtures/plugin/basic.json b/testing/e2e/fixtures/plugin/basic.json
new file mode 100644
index 000000000..0189d8f13
--- /dev/null
+++ b/testing/e2e/fixtures/plugin/basic.json
@@ -0,0 +1,24 @@
+{
+  "fixtures": [
+    {
+      "match": { "userMessage": "[plugin] recommend a guitar" },
+      "response": {
+        "content": "I'd recommend the Fender Stratocaster — versatile and comfortable."
+      }
+    },
+    {
+      "match": { "userMessage": "[plugin] banner: solo banner" },
+      "response": {
+        "content": "BANNER: solo banner"
+      }
+    },
+    {
+      "match": { "userMessage": "solo banner image" },
+      "response": {
+        "image": {
+          "url": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII="
+        }
+      }
+    }
+  ]
+}
diff --git a/testing/e2e/fixtures/transaction/basic.json b/testing/e2e/fixtures/transaction/basic.json
deleted file mode 100644
index cf4c974b9..000000000
--- a/testing/e2e/fixtures/transaction/basic.json
+++ /dev/null
@@ -1,28 +0,0 @@
-{
-  "fixtures": [
-    {
-      "match": { "userMessage": "[transaction] recommend a guitar" },
-      "response": {
-        "content": "I'd recommend the Fender Stratocaster — versatile and comfortable."
-      }
-    },
-    {
-      "match": { "userMessage": "[transaction] banner: solo banner" },
-      "response": {
-        "content": "BANNER: solo banner"
-      }
-    },
-    {
-      "match": { "userMessage": "[transaction] banner: hero guitars" },
-      "response": {
-        "content": "BANNER: hero guitars"
-      }
-    },
-    {
-      "match": { "userMessage": "[transaction] banner: thumb guitars" },
-      "response": {
-        "content": "BANNER: thumb guitars"
-      }
-    }
-  ]
-}
diff --git a/testing/e2e/src/lib/e2e-plugin.ts b/testing/e2e/src/lib/e2e-plugin.ts
new file mode 100644
index 000000000..8fcce789c
--- /dev/null
+++ b/testing/e2e/src/lib/e2e-plugin.ts
@@ -0,0 +1,126 @@
+import { chat, generateImage, maxIterations } from '@tanstack/ai'
+import {
+  chatPlugin,
+  definePlugin,
+  generationPlugin,
+  imagePlugin,
+} from '@tanstack/ai/plugin'
+import { z } from 'zod'
+import { createTextAdapter } from './providers'
+import { createImageAdapter } from './media-providers'
+import type { Provider } from './types'
+
+/**
+ * Routing metadata (provider/testId/aimockPort) rides along in every
+ * plugin's `forwardedProps` — the callbacks below read it straight off
+ * `req.forwardedProps` (unaffected by input-schema stripping) to build the
+ * right adapter for the test's provider/aimock instance.
+ */
+interface Routing {
+  provider: Provider
+  testId?: string
+  aimockPort?: number
+}
+
+function routingFrom(forwardedProps: Record<string, unknown>): Routing {
+  const provider =
+    typeof forwardedProps.provider === 'string'
+      ? (forwardedProps.provider as Provider)
+      : 'openai'
+  const testId =
+    typeof forwardedProps.testId === 'string'
+      ? forwardedProps.testId
+      : undefined
+  const aimockPort =
+    typeof forwardedProps.aimockPort === 'number'
+      ? forwardedProps.aimockPort
+      : undefined
+  return { provider, testId, aimockPort }
+}
+
+/**
+ * Drain a ChatStream and accumulate the assistant text. Used by the one-shot
+ * `banner` plugin below to turn a (mocked, deterministic) chat completion into
+ * a plain result value.
+ */
+async function collectText(stream: AsyncIterable<unknown>): Promise<string> {
+  let text = ''
+  for await (const chunk of stream) {
+    if (
+      chunk != null &&
+      typeof chunk === 'object' &&
+      'type' in chunk &&
+      chunk.type === 'TEXT_MESSAGE_CONTENT' &&
+      'delta' in chunk &&
+      typeof chunk.delta === 'string'
+    ) {
+      text += chunk.delta
+    }
+  }
+  return text
+}
+
+/**
+ * The e2e plugin registry: one endpoint exercising all three plugin kinds —
+ * a conversational plugin, a one-shot text plugin, and a one-shot media
+ * (image) plugin — against aimock. `definePlugin` is inert until
+ * `handler(request)` runs, so importing this module into the browser ships
+ * only the (inert) adapter code, never the API keys (`createTextAdapter` /
+ * `createImageAdapter` build with a test-only dummy key).
+ */
+export const e2ePlugin = definePlugin({
+  // Conversational plugin: full chat surface on the client.
+  primaryChat: chatPlugin((req) => {
+    const { provider, testId, aimockPort } = routingFrom(req.forwardedProps)
+    return chat({
+      ...createTextAdapter(provider, 'gpt-5.5', aimockPort, testId, 'plugin'),
+      messages: req.messages,
+      agentLoopStrategy: maxIterations(5),
+      threadId: req.threadId,
+      runId: req.runId,
+    })
+  }),
+
+  // One-shot plugin: schema-validated input in, result out. Runs a single
+  // deterministic chat completion against aimock (the fixture keys on the
+  // exact `[plugin] banner: …` user message).
+  banner: generationPlugin({
+    input: z.object({ prompt: z.string() }),
+    execute: async (req) => {
+      const { provider, testId, aimockPort } = routingFrom(req.forwardedProps)
+      const text = await collectText(
+        chat({
+          ...createTextAdapter(
+            provider,
+            'gpt-5.5',
+            aimockPort,
+            testId,
+            'plugin',
+          ),
+          messages: [
+            {
+              role: 'user',
+              content: `[plugin] banner: ${req.input.prompt}`,
+            },
+          ],
+          agentLoopStrategy: maxIterations(1),
+          threadId: req.threadId,
+          runId: req.runId,
+        }),
+      )
+      return { prompt: req.input.prompt, text }
+    },
+  }),
+
+  // One-shot media plugin: image generation, exercising the `imagePlugin`
+  // factory over `generateImage` end to end (aimock's image mock).
+  bannerImage: imagePlugin((req) => {
+    const { provider, testId, aimockPort } = routingFrom(req.forwardedProps)
+    return generateImage({
+      adapter: createImageAdapter(provider, aimockPort, testId),
+      prompt: req.input.prompt,
+    })
+  }),
+})
+
+export type E2ePlugin = typeof e2ePlugin
diff --git a/testing/e2e/src/lib/feature-support.ts b/testing/e2e/src/lib/feature-support.ts
index 2f6b1c135..cfb8d5179 100644
--- a/testing/e2e/src/lib/feature-support.ts
+++ b/testing/e2e/src/lib/feature-support.ts
@@ -254,7 +254,7 @@ export const matrix: Record<Feature, Set<Provider>> = {
   // Only Gemini currently surfaces a first-class stateful conversation API via
   // the adapter (geminiTextInteractions, behind @tanstack/ai-gemini/experimental).
   'stateful-interactions': new Set(['gemini']),
-  transaction: new Set(['openai']),
+  plugin: new Set(['openai']),
 }
 
 export function isSupported(provider: Provider, feature: Feature): boolean {
diff --git a/testing/e2e/src/lib/features.ts b/testing/e2e/src/lib/features.ts
index 660923ff6..7c33d8c1a 100644
--- a/testing/e2e/src/lib/features.ts
+++ b/testing/e2e/src/lib/features.ts
@@ -144,7 +144,7 @@ export const featureConfigs: Record<Feature, FeatureConfig> = {
     tools: [],
     modelOptions: {},
   },
-  transaction: {
+  plugin: {
     tools: [],
     modelOptions: {},
   },
diff --git a/testing/e2e/src/lib/types.ts b/testing/e2e/src/lib/types.ts
index 691f632eb..ac28788b7 100644
--- a/testing/e2e/src/lib/types.ts
+++ b/testing/e2e/src/lib/types.ts
@@ -44,7 +44,7 @@ export type Feature =
   | 'image-to-video'
   | 'interactions-video'
   | 'stateful-interactions'
-  | 'transaction'
+  | 'plugin'
 
 export const ALL_PROVIDERS: Provider[] = [
   'openai',
@@ -91,5 +91,5 @@ export const ALL_FEATURES: Feature[] = [
   'image-to-video',
   'interactions-video',
   'stateful-interactions',
-  'transaction',
+  'plugin',
 ]
diff --git a/testing/e2e/src/routeTree.gen.ts b/testing/e2e/src/routeTree.gen.ts
index 1cff5ca1d..e2e1be1a6 100644
--- a/testing/e2e/src/routeTree.gen.ts
+++ b/testing/e2e/src/routeTree.gen.ts
@@ -9,8 +9,8 @@
 // Additionally, you should also exclude this file from your linter and/or formatter to prevent it from being checked or modified.
 
 import { Route as rootRouteImport } from './routes/__root'
-import { Route as TransactionRouteImport } from './routes/transaction'
 import { Route as ToolsTestRouteImport } from './routes/tools-test'
+import { Route as PluginRouteImport } from './routes/plugin'
 import { Route as MiddlewareTestRouteImport } from './routes/middleware-test'
 import { Route as MarkdownCjkRouteImport } from './routes/markdown-cjk'
 import { Route as DevtoolsToolsRouteImport } from './routes/devtools-tools'
@@ -25,10 +25,10 @@ import { Route as ProviderIndexRouteImport } from './routes/$provider/index'
 import { Route as ApiVideoRouteImport } from './routes/api.video'
 import { Route as ApiTtsRouteImport } from './routes/api.tts'
 import { Route as ApiTranscriptionRouteImport } from './routes/api.transcription'
-import { Route as ApiTransactionRouteImport } from './routes/api.transaction'
 import { Route as ApiToolsTestRouteImport } from './routes/api.tools-test'
 import { Route as ApiToolCallLifecycleWireRouteImport } from './routes/api.tool-call-lifecycle-wire'
 import { Route as ApiSummarizeRouteImport } from './routes/api.summarize'
+import { Route as ApiPluginRouteImport } from './routes/api.plugin'
 import { Route as ApiOtelUsageRouteImport } from './routes/api.otel-usage'
 import { Route as ApiOtelMediaRouteImport } from './routes/api.otel-media'
 import { Route as ApiOpenrouterWebToolsWireRouteImport } from './routes/api.openrouter-web-tools-wire'
@@ -60,16 +60,16 @@ import { Route as ApiTranscriptionStreamRouteImport } from './routes/api.transcr
 import { Route as ApiImageStreamRouteImport } from './routes/api.image.stream'
 import { Route as ApiAudioStreamRouteImport } from './routes/api.audio.stream'
 
-const TransactionRoute = TransactionRouteImport.update({
-  id: '/transaction',
-  path: '/transaction',
-  getParentRoute: () => rootRouteImport,
-} as any)
 const ToolsTestRoute = ToolsTestRouteImport.update({
   id: '/tools-test',
   path: '/tools-test',
   getParentRoute: () => rootRouteImport,
 } as any)
+const PluginRoute = PluginRouteImport.update({
+  id: '/plugin',
+  path: '/plugin',
+  getParentRoute: () => rootRouteImport,
+} as any)
 const MiddlewareTestRoute = MiddlewareTestRouteImport.update({
   id: '/middleware-test',
   path: '/middleware-test',
@@ -140,11 +140,6 @@ const ApiTranscriptionRoute = ApiTranscriptionRouteImport.update({
   path: '/api/transcription',
   getParentRoute: () => rootRouteImport,
 } as any)
-const ApiTransactionRoute = ApiTransactionRouteImport.update({
-  id: '/api/transaction',
-  path: '/api/transaction',
-  getParentRoute: () => rootRouteImport,
-} as any)
 const ApiToolsTestRoute = ApiToolsTestRouteImport.update({
   id: '/api/tools-test',
   path: '/api/tools-test',
@@ -161,6 +156,11 @@ const ApiSummarizeRoute = ApiSummarizeRouteImport.update({
   path: '/api/summarize',
   getParentRoute: () => rootRouteImport,
 } as any)
+const ApiPluginRoute = ApiPluginRouteImport.update({
+  id: '/api/plugin',
+  path: '/api/plugin',
+  getParentRoute: () => rootRouteImport,
+} as any)
 const ApiOtelUsageRoute = ApiOtelUsageRouteImport.update({
   id: '/api/otel-usage',
   path: '/api/otel-usage',
@@ -327,8 +327,8 @@ export interface FileRoutesByFullPath {
   '/devtools-tools': typeof DevtoolsToolsRoute
   '/markdown-cjk': typeof MarkdownCjkRoute
   '/middleware-test': typeof MiddlewareTestRoute
+  '/plugin': typeof PluginRoute
   '/tools-test': typeof ToolsTestRoute
-  '/transaction': typeof TransactionRoute
   '/$provider/$feature': typeof ProviderFeatureRoute
   '/api/anthropic-bug-test': typeof ApiAnthropicBugTestRoute
   '/api/anthropic-skills-wire': typeof ApiAnthropicSkillsWireRoute
@@ -354,10 +354,10 @@ export interface FileRoutesByFullPath {
   '/api/openrouter-web-tools-wire': typeof ApiOpenrouterWebToolsWireRoute
   '/api/otel-media': typeof ApiOtelMediaRoute
   '/api/otel-usage': typeof ApiOtelUsageRoute
+  '/api/plugin': typeof ApiPluginRoute
   '/api/summarize': typeof ApiSummarizeRoute
   '/api/tool-call-lifecycle-wire': typeof ApiToolCallLifecycleWireRoute
   '/api/tools-test': typeof ApiToolsTestRoute
-  '/api/transaction': typeof ApiTransactionRoute
   '/api/transcription': typeof ApiTranscriptionRouteWithChildren
   '/api/tts': typeof ApiTtsRouteWithChildren
   '/api/video': typeof ApiVideoRouteWithChildren
@@ -379,8 +379,8 @@ export interface FileRoutesByTo {
   '/devtools-tools': typeof DevtoolsToolsRoute
   '/markdown-cjk': typeof MarkdownCjkRoute
   '/middleware-test': typeof MiddlewareTestRoute
+  '/plugin': typeof PluginRoute
   '/tools-test': typeof ToolsTestRoute
-  '/transaction': typeof TransactionRoute
   '/$provider/$feature': typeof ProviderFeatureRoute
   '/api/anthropic-bug-test': typeof ApiAnthropicBugTestRoute
   '/api/anthropic-skills-wire': typeof ApiAnthropicSkillsWireRoute
@@ -406,10 +406,10 @@ export interface FileRoutesByTo {
   '/api/openrouter-web-tools-wire': typeof ApiOpenrouterWebToolsWireRoute
   '/api/otel-media': typeof ApiOtelMediaRoute
   '/api/otel-usage': typeof ApiOtelUsageRoute
+  '/api/plugin': typeof ApiPluginRoute
   '/api/summarize': typeof ApiSummarizeRoute
   '/api/tool-call-lifecycle-wire': typeof ApiToolCallLifecycleWireRoute
   '/api/tools-test': typeof ApiToolsTestRoute
-  '/api/transaction': typeof ApiTransactionRoute
   '/api/transcription': typeof ApiTranscriptionRouteWithChildren
   '/api/tts': typeof ApiTtsRouteWithChildren
   '/api/video': typeof ApiVideoRouteWithChildren
@@ -432,8 +432,8 @@ export interface FileRoutesById {
   '/devtools-tools': typeof DevtoolsToolsRoute
   '/markdown-cjk': typeof MarkdownCjkRoute
   '/middleware-test': typeof MiddlewareTestRoute
+  '/plugin': typeof PluginRoute
   '/tools-test': typeof ToolsTestRoute
-  '/transaction': typeof TransactionRoute
   '/$provider/$feature': typeof ProviderFeatureRoute
   '/api/anthropic-bug-test': typeof ApiAnthropicBugTestRoute
   '/api/anthropic-skills-wire': typeof ApiAnthropicSkillsWireRoute
@@ -459,10 +459,10 @@ export interface FileRoutesById {
   '/api/openrouter-web-tools-wire': typeof ApiOpenrouterWebToolsWireRoute
   '/api/otel-media': typeof ApiOtelMediaRoute
   '/api/otel-usage': typeof ApiOtelUsageRoute
+  '/api/plugin': typeof ApiPluginRoute
   '/api/summarize': typeof ApiSummarizeRoute
   '/api/tool-call-lifecycle-wire': typeof ApiToolCallLifecycleWireRoute
   '/api/tools-test': typeof ApiToolsTestRoute
-  '/api/transaction': typeof ApiTransactionRoute
   '/api/transcription': typeof ApiTranscriptionRouteWithChildren
   '/api/tts': typeof ApiTtsRouteWithChildren
   '/api/video': typeof ApiVideoRouteWithChildren
@@ -486,8 +486,8 @@ export interface FileRouteTypes {
     | '/devtools-tools'
     | '/markdown-cjk'
     | '/middleware-test'
+    | '/plugin'
     | '/tools-test'
-    | '/transaction'
     | '/$provider/$feature'
     | '/api/anthropic-bug-test'
     | '/api/anthropic-skills-wire'
@@ -513,10 +513,10 @@ export interface FileRouteTypes {
     | '/api/openrouter-web-tools-wire'
     | '/api/otel-media'
     | '/api/otel-usage'
+    | '/api/plugin'
     | '/api/summarize'
     | '/api/tool-call-lifecycle-wire'
     | '/api/tools-test'
-    | '/api/transaction'
     | '/api/transcription'
     | '/api/tts'
     | '/api/video'
@@ -538,8 +538,8 @@ export interface FileRouteTypes {
     | '/devtools-tools'
     | '/markdown-cjk'
     | '/middleware-test'
+    | '/plugin'
     | '/tools-test'
-    | '/transaction'
     | '/$provider/$feature'
     | '/api/anthropic-bug-test'
     | '/api/anthropic-skills-wire'
@@ -565,10 +565,10 @@ export interface FileRouteTypes {
     | '/api/openrouter-web-tools-wire'
     | '/api/otel-media'
     | '/api/otel-usage'
+    | '/api/plugin'
     | '/api/summarize'
     | '/api/tool-call-lifecycle-wire'
     | '/api/tools-test'
-    | '/api/transaction'
     | '/api/transcription'
     | '/api/tts'
     | '/api/video'
@@ -590,8 +590,8 @@ export interface FileRouteTypes {
     | '/devtools-tools'
     | '/markdown-cjk'
     | '/middleware-test'
+    | '/plugin'
     | '/tools-test'
-    | '/transaction'
     | '/$provider/$feature'
     | '/api/anthropic-bug-test'
     | '/api/anthropic-skills-wire'
@@ -617,10 +617,10 @@ export interface FileRouteTypes {
     | '/api/openrouter-web-tools-wire'
     | '/api/otel-media'
     | '/api/otel-usage'
+    | '/api/plugin'
     | '/api/summarize'
     | '/api/tool-call-lifecycle-wire'
     | '/api/tools-test'
-    | '/api/transaction'
     | '/api/transcription'
     | '/api/tts'
     | '/api/video'
@@ -643,8 +643,8 @@ export interface RootRouteChildren {
   DevtoolsToolsRoute: typeof DevtoolsToolsRoute
   MarkdownCjkRoute: typeof MarkdownCjkRoute
   MiddlewareTestRoute: typeof MiddlewareTestRoute
+  PluginRoute: typeof PluginRoute
   ToolsTestRoute: typeof ToolsTestRoute
-  TransactionRoute: typeof TransactionRoute
   ProviderFeatureRoute: typeof ProviderFeatureRoute
   ApiAnthropicBugTestRoute: typeof ApiAnthropicBugTestRoute
   ApiAnthropicSkillsWireRoute: typeof ApiAnthropicSkillsWireRoute
@@ -670,10 +670,10 @@ export interface RootRouteChildren {
   ApiOpenrouterWebToolsWireRoute: typeof ApiOpenrouterWebToolsWireRoute
   ApiOtelMediaRoute: typeof ApiOtelMediaRoute
   ApiOtelUsageRoute: typeof ApiOtelUsageRoute
+  ApiPluginRoute: typeof ApiPluginRoute
   ApiSummarizeRoute: typeof ApiSummarizeRoute
   ApiToolCallLifecycleWireRoute: typeof ApiToolCallLifecycleWireRoute
   ApiToolsTestRoute: typeof ApiToolsTestRoute
-  ApiTransactionRoute: typeof ApiTransactionRoute
   ApiTranscriptionRoute: typeof ApiTranscriptionRouteWithChildren
   ApiTtsRoute: typeof ApiTtsRouteWithChildren
   ApiVideoRoute: typeof ApiVideoRouteWithChildren
@@ -682,13 +682,6 @@ export interface RootRouteChildren {
 
 declare module '@tanstack/react-router' {
   interface FileRoutesByPath {
-    '/transaction': {
-      id: '/transaction'
-      path: '/transaction'
-      fullPath: '/transaction'
-      preLoaderRoute: typeof TransactionRouteImport
-      parentRoute: typeof rootRouteImport
-    }
     '/tools-test': {
       id: '/tools-test'
       path: '/tools-test'
@@ -696,6 +689,13 @@ declare module '@tanstack/react-router' {
       preLoaderRoute: typeof ToolsTestRouteImport
       parentRoute: typeof rootRouteImport
     }
+    '/plugin': {
+      id: '/plugin'
+      path: '/plugin'
+      fullPath: '/plugin'
+      preLoaderRoute: typeof PluginRouteImport
+      parentRoute: typeof rootRouteImport
+    }
     '/middleware-test': {
       id: '/middleware-test'
       path: '/middleware-test'
@@ -794,13 +794,6 @@ declare module '@tanstack/react-router' {
       preLoaderRoute: typeof ApiTranscriptionRouteImport
       parentRoute: typeof rootRouteImport
     }
-    '/api/transaction': {
-      id: '/api/transaction'
-      path: '/api/transaction'
-      fullPath: '/api/transaction'
-      preLoaderRoute: typeof ApiTransactionRouteImport
-      parentRoute: typeof rootRouteImport
-    }
     '/api/tools-test': {
       id: '/api/tools-test'
       path: '/api/tools-test'
@@ -822,6 +815,13 @@ declare module '@tanstack/react-router' {
       preLoaderRoute: typeof ApiSummarizeRouteImport
       parentRoute: typeof rootRouteImport
     }
+    '/api/plugin': {
+      id: '/api/plugin'
+      path: '/api/plugin'
+      fullPath: '/api/plugin'
+      preLoaderRoute: typeof ApiPluginRouteImport
+      parentRoute: typeof rootRouteImport
+    }
     '/api/otel-usage': {
       id: '/api/otel-usage'
       path: '/api/otel-usage'
@@ -1104,8 +1104,8 @@ const rootRouteChildren: RootRouteChildren = {
   DevtoolsToolsRoute: DevtoolsToolsRoute,
   MarkdownCjkRoute: MarkdownCjkRoute,
   MiddlewareTestRoute: MiddlewareTestRoute,
+  PluginRoute: PluginRoute,
   ToolsTestRoute: ToolsTestRoute,
-  TransactionRoute: TransactionRoute,
   ProviderFeatureRoute: ProviderFeatureRoute,
   ApiAnthropicBugTestRoute: ApiAnthropicBugTestRoute,
   ApiAnthropicSkillsWireRoute: ApiAnthropicSkillsWireRoute,
@@ -1131,10 +1131,10 @@ const rootRouteChildren: RootRouteChildren = {
   ApiOpenrouterWebToolsWireRoute: ApiOpenrouterWebToolsWireRoute,
   ApiOtelMediaRoute: ApiOtelMediaRoute,
   ApiOtelUsageRoute: ApiOtelUsageRoute,
+  ApiPluginRoute: ApiPluginRoute,
   ApiSummarizeRoute: ApiSummarizeRoute,
   ApiToolCallLifecycleWireRoute: ApiToolCallLifecycleWireRoute,
   ApiToolsTestRoute: ApiToolsTestRoute,
-  ApiTransactionRoute: ApiTransactionRoute,
   ApiTranscriptionRoute: ApiTranscriptionRouteWithChildren,
   ApiTtsRoute: ApiTtsRouteWithChildren,
   ApiVideoRoute: ApiVideoRouteWithChildren,
diff --git a/testing/e2e/src/routes/api.plugin.ts b/testing/e2e/src/routes/api.plugin.ts
new file mode 100644
index 000000000..9cfa4e095
--- /dev/null
+++ b/testing/e2e/src/routes/api.plugin.ts
@@ -0,0 +1,17 @@
+import { createFileRoute } from '@tanstack/react-router'
+import { e2ePlugin } from '@/lib/e2e-plugin'
+
+export const Route = createFileRoute('/api/plugin')({
+  server: {
+    handlers: {
+      // One endpoint, three plugins (`primaryChat` / `banner` / `bannerImage`).
+      // `definePlugin` is inert until `handler(request)` runs, at which point
+      // it parses the AG-UI request, routes by the `plugin` discriminator the
+      // client sends, and streams the result back over SSE.
+      POST: async ({ request }) => {
+        await import('@/lib/llmock-server').then((m) => m.ensureLLMock())
+        return e2ePlugin.handler(request)
+      },
+    },
+  },
+})
diff --git a/testing/e2e/src/routes/api.transaction.ts b/testing/e2e/src/routes/api.transaction.ts
deleted file mode 100644
index 6b7a931e1..000000000
--- a/testing/e2e/src/routes/api.transaction.ts
+++ /dev/null
@@ -1,126 +0,0 @@
-import { createFileRoute } from '@tanstack/react-router'
-import { chat, maxIterations } from '@tanstack/ai'
-import { chatVerb, defineTransaction, verb } from '@tanstack/ai/transaction'
-import { z } from 'zod'
-import type { Provider } from '@/lib/types'
-import { createTextAdapter } from '@/lib/providers'
-
-/**
- * Drain a ChatStream and accumulate the assistant text. Used by the one-shot
- * `banner` verb below to turn a (mocked, deterministic) chat completion into
- * a plain result value.
- */
-async function collectText(stream: AsyncIterable<unknown>): Promise<string> {
-  let text = ''
-  for await (const chunk of stream) {
-    if (
-      chunk != null &&
-      typeof chunk === 'object' &&
-      'type' in chunk &&
-      chunk.type === 'TEXT_MESSAGE_CONTENT' &&
-      'delta' in chunk &&
-      typeof chunk.delta === 'string'
-    ) {
-      text += chunk.delta
-    }
-  }
-  return text
-}
-
-type TextOptions = ReturnType<typeof createTextAdapter>
-
-/** Build the e2e transaction for a resolved provider/test routing context. */
-export function createE2eTransaction(textOptions: () => TextOptions) {
-  // One-shot verb: schema-validated input in, result out. Runs a
-  // single deterministic chat completion against aimock (the fixture
-  // keys on the exact `[transaction] banner: …` user message).
-  const banner = verb({
-    input: z.object({ prompt: z.string() }),
-    execute: async (req) => {
-      const text = await collectText(
-        chat({
-          ...textOptions(),
-          messages: [
-            {
-              role: 'user',
-              content: `[transaction] banner: ${req.input.prompt}`,
-            },
-          ],
-          agentLoopStrategy: maxIterations(1),
-          threadId: req.threadId,
-          runId: req.runId,
-        }),
-      )
-      return { prompt: req.input.prompt, text }
-    },
-  })
-
-  return defineTransaction({
-    // Conversational verb: full chat surface on the client.
-    primaryChat: chatVerb((req) =>
-      chat({
-        ...textOptions(),
-        messages: req.messages,
-        agentLoopStrategy: maxIterations(5),
-        threadId: req.threadId,
-        runId: req.runId,
-      }),
-    ),
-    banner,
-    // Composing verb: runs the sibling `banner` verb twice via
-    // `ctx.call`, so the client observes two tagged sub-runs
-    // (transaction:sub-run:* CUSTOM events) inside one SSE response.
-    bannerPair: verb({
-      input: z.object({ topic: z.string() }),
-      execute: async ({ input }, ctx) => {
-        // Sequential so sub-run start order (hero=0, thumb=1) is
-        // deterministic for the spec's per-index assertions.
-        const hero = await ctx.call(banner, {
-          prompt: `hero ${input.topic}`,
-        })
-        const thumb = await ctx.call(banner, {
-          prompt: `thumb ${input.topic}`,
-        })
-        return { hero, thumb }
-      },
-    }),
-  })
-}
-
-/** Server-side transaction shape — import with `import type` on the client. */
-export type E2eTransaction = ReturnType<typeof createE2eTransaction>
-
-export const Route = createFileRoute('/api/transaction')({
-  server: {
-    handlers: {
-      POST: async ({ request }) => {
-        await import('@/lib/llmock-server').then((m) => m.ensureLLMock())
-
-        // `transaction.handler(request)` below consumes the body itself via
-        // `request.json()`, so peek at a clone here to pull the
-        // provider/testId/aimockPort needed to construct adapters, and pass
-        // the original (unconsumed) request through to the handler.
-        const peekBody = await request.clone().json()
-        const peekData = peekBody.forwardedProps ?? peekBody.data ?? peekBody
-        const { provider, testId, aimockPort } = peekData as {
-          provider: Provider
-          testId?: string
-          aimockPort?: number
-        }
-
-        const textOptions = () =>
-          createTextAdapter(
-            provider,
-            undefined,
-            aimockPort,
-            testId,
-            'transaction',
-          )
-
-        const transaction = createE2eTransaction(textOptions)
-
-        return transaction.handler(request)
-      },
-    },
-  },
-})
diff --git a/testing/e2e/src/routes/plugin.tsx b/testing/e2e/src/routes/plugin.tsx
new file mode 100644
index 000000000..024fcaffe
--- /dev/null
+++ b/testing/e2e/src/routes/plugin.tsx
@@ -0,0 +1,137 @@
+import { createFileRoute } from '@tanstack/react-router'
+import { fetchServerSentEvents } from '@tanstack/ai-react'
+import { usePlugin } from '@tanstack/ai-react/plugin'
+import { ChatUI } from '@/components/ChatUI'
+import { e2ePlugin } from '@/lib/e2e-plugin'
+import type { ImageGenerationResult } from '@tanstack/ai'
+import type { Provider } from '@/lib/types'
+
+export interface PluginRouteSearch {
+  provider: Provider
+  testId?: string
+  aimockPort?: number
+}
+
+const DEFAULT_PROVIDER: Provider = 'openai'
+
+function parsePluginRouteSearch(
+  search: Record<string, unknown>,
+): PluginRouteSearch {
+  const aimockPort =
+    typeof search.aimockPort === 'string'
+      ? Number.parseInt(search.aimockPort, 10)
+      : undefined
+  const provider =
+    typeof search.provider === 'string'
+      ? (search.provider as Provider)
+      : DEFAULT_PROVIDER
+
+  return {
+    provider,
+    ...(typeof search.testId === 'string' ? { testId: search.testId } : {}),
+    ...(aimockPort !== undefined && !Number.isNaN(aimockPort)
+      ? { aimockPort }
+      : {}),
+  }
+}
+
+export const Route = createFileRoute('/plugin')({
+  component: PluginRoute,
+  validateSearch: parsePluginRouteSearch,
+})
+
+// The image result carries either a URL or base64 data, provider-dependent.
+function imageUrlOf(result: ImageGenerationResult | null): string | null {
+  const image = result?.images[0]
+  if (!image) return null
+  return (
+    image.url ??
+    (image.b64Json ? `data:image/png;base64,${image.b64Json}` : null)
+  )
+}
+
+function PluginRoute() {
+  const { provider, testId, aimockPort } = Route.useSearch()
+
+  // Routing metadata (provider/testId/aimockPort) rides along in every
+  // plugin's forwardedProps; the server route peeks it (via req.forwardedProps)
+  // to build adapters, and the one-shot plugins' schemas simply strip the
+  // extra fields off `req.input`.
+  const routing = { provider, testId, aimockPort }
+
+  const plugin = usePlugin(e2ePlugin, {
+    connection: fetchServerSentEvents('/api/plugin'),
+    primaryChat: { forwardedProps: routing },
+    banner: { forwardedProps: routing },
+    bannerImage: { forwardedProps: routing },
+  })
+
+  const imageUrl = imageUrlOf(plugin.bannerImage.result)
+
+  return (
+    <div className="flex h-screen flex-col">
+      <div className="space-y-2 border-b border-gray-700 p-3">
+        <div className="flex items-center gap-3">
+          <button
+            type="button"
+            data-testid="plugin-run-banner"
+            className="rounded bg-orange-500 px-3 py-2 text-sm font-medium text-white"
+            onClick={() => {
+              void plugin.banner.run({ prompt: 'solo banner' })
+            }}
+          >
+            Run Banner
+          </button>
+          <span
+            data-testid="plugin-banner-status"
+            className="text-xs text-gray-400"
+          >
+            {plugin.banner.status}
+          </span>
+          <span
+            data-testid="plugin-banner-result"
+            className="break-all text-xs text-gray-400"
+          >
+            {plugin.banner.result?.text ?? ''}
+          </span>
+        </div>
+        <div className="flex items-center gap-3">
+          <button
+            type="button"
+            data-testid="plugin-run-banner-image"
+            className="rounded bg-purple-500 px-3 py-2 text-sm font-medium text-white"
+            onClick={() => {
+              void plugin.bannerImage.run({ prompt: 'solo banner image' })
+            }}
+          >
+            Run Banner Image
+          </button>
+          <span
+            data-testid="plugin-banner-image-status"
+            className="text-xs text-gray-400"
+          >
+            {plugin.bannerImage.status}
+          </span>
+          {imageUrl && (
+            <img
+              data-testid="plugin-banner-image-result"
+              src={imageUrl}
+              alt="Generated banner"
+              className="h-8 w-8 object-cover"
+            />
+          )}
+        </div>
+      </div>
+      <div className="flex-1 overflow-hidden">
+        <ChatUI
+          messages={plugin.primaryChat.messages}
+          isLoading={plugin.primaryChat.isLoading}
+          onSendMessage={(text) => {
+            void plugin.primaryChat.sendMessage(text)
+          }}
+          onStop={plugin.primaryChat.stop}
+        />
+      </div>
+    </div>
+  )
+}
diff --git a/testing/e2e/src/routes/transaction.tsx b/testing/e2e/src/routes/transaction.tsx
deleted file mode 100644
index 7520f7852..000000000
--- a/testing/e2e/src/routes/transaction.tsx
+++ /dev/null
@@ -1,147 +0,0 @@
-import { createFileRoute } from '@tanstack/react-router'
-import { clientTransaction } from '@tanstack/ai/transaction'
-import { fetchServerSentEvents } from '@tanstack/ai-react'
-import { useTransaction } from '@tanstack/ai-react/transaction'
-import { ChatUI } from '@/components/ChatUI'
-import type { E2eTransaction } from './api.transaction'
-import type { Provider } from '@/lib/types'
-
-export interface TransactionRouteSearch {
-  provider: Provider
-  testId?: string
-  aimockPort?: number
-}
-
-const DEFAULT_PROVIDER: Provider = 'openai'
-
-function parseTransactionRouteSearch(
-  search: Record<string, unknown>,
-): TransactionRouteSearch {
-  const aimockPort =
-    typeof search.aimockPort === 'string'
-      ? Number.parseInt(search.aimockPort, 10)
-      : undefined
-  const provider =
-    typeof search.provider === 'string'
-      ? (search.provider as Provider)
-      : DEFAULT_PROVIDER
-
-  return {
-    provider,
-    ...(typeof search.testId === 'string' ? { testId: search.testId } : {}),
-    ...(aimockPort !== undefined && !Number.isNaN(aimockPort)
-      ? { aimockPort }
-      : {}),
-  }
-}
-
-export const Route = createFileRoute('/transaction')({
-  component: TransactionRoute,
-  validateSearch: parseTransactionRouteSearch,
-})
-
-// Type-only binding to the server definition — no inert verb mirrors or
-// provider imports in the browser bundle.
-const e2eTxnDef = clientTransaction<E2eTransaction>({
-  primaryChat: 'chat',
-  banner: 'one-shot',
-  bannerPair: 'one-shot',
-})
-
-function TransactionRoute() {
-  const { provider, testId, aimockPort } = Route.useSearch()
-
-  // Routing metadata (provider/testId/aimockPort) rides along in every
-  // verb's forwardedProps; the server route peeks it to build adapters and
-  // the one-shot verbs' zod schemas simply strip the extra fields.
-  const routing = { provider, testId, aimockPort }
-
-  const txn = useTransaction(e2eTxnDef, {
-    connection: fetchServerSentEvents('/api/transaction'),
-    verbs: {
-      primaryChat: { forwardedProps: routing },
-      banner: { forwardedProps: routing },
-      bannerPair: { forwardedProps: routing },
-    },
-  })
-
-  return (
-    <div className="flex h-screen flex-col">
-      <div className="space-y-2 border-b border-gray-700 p-3">
-        <div className="flex items-center gap-3">
-          <button
-            type="button"
-            data-testid="transaction-run-banner"
-            className="rounded bg-orange-500 px-3 py-2 text-sm font-medium text-white"
-            onClick={() => {
-              void txn.banner.run({ prompt: 'solo banner' })
-            }}
-          >
-            Run Banner
-          </button>
-          <span
-            data-testid="transaction-banner-status"
-            className="text-xs text-gray-400"
-          >
-            {txn.banner.status}
-          </span>
-          <span
-            data-testid="transaction-banner-result"
-            className="break-all text-xs text-gray-400"
-          >
-            {txn.banner.result?.text ?? ''}
-          </span>
-        </div>
-        <div className="flex items-center gap-3">
-          <button
-            type="button"
-            data-testid="transaction-run-banner-pair"
-            className="rounded bg-purple-500 px-3 py-2 text-sm font-medium text-white"
-            onClick={() => {
-              void txn.bannerPair.run({ topic: 'guitars' })
-            }}
-          >
-            Run Banner Pair
-          </button>
-          <span
-            data-testid="transaction-banner-pair-status"
-            className="text-xs text-gray-400"
-          >
-            {txn.bannerPair.status}
-          </span>
-          <span
-            data-testid="transaction-banner-pair-result"
-            className="break-all text-xs text-gray-400"
-          >
-            {txn.bannerPair.result
-              ? `${txn.bannerPair.result.hero.text} + ${txn.bannerPair.result.thumb.text}`
-              : ''}
-          </span>
-        </div>
-        <ul data-testid="transaction-sub-runs" className="space-y-1">
-          {txn.bannerPair.subRuns.map((sub) => (
-            <li
-              key={sub.runId}
-              data-testid={`transaction-sub-run-${sub.index}`}
-              data-verb={sub.verb}
-              data-status={sub.status}
-              className="text-xs text-gray-400"
-            >
-              {sub.verb}:{sub.status}
-            </li>
-          ))}
-        </ul>
-      </div>
-      <div className="flex-1 overflow-hidden">
-        <ChatUI
-          messages={txn.primaryChat.messages}
-          isLoading={txn.primaryChat.isLoading}
-          onSendMessage={(text) => {
-            void txn.primaryChat.sendMessage(text)
-          }}
-          onStop={txn.primaryChat.stop}
-        />
-      </div>
-    </div>
-  )
-}
diff --git a/testing/e2e/tests/plugin.spec.ts b/testing/e2e/tests/plugin.spec.ts
new file mode 100644
index 000000000..dfa64c5b3
--- /dev/null
+++ b/testing/e2e/tests/plugin.spec.ts
@@ -0,0 +1,101 @@
+import { test, expect } from './fixtures'
+import type { Page } from '@playwright/test'
+import {
+  getLastAssistantMessage,
+  sendMessage,
+  waitForResponse,
+} from './helpers'
+import { providersFor } from './test-matrix'
+
+// The plugin feature has its own dedicated page (`/plugin`) that drives
+// `usePlugin`, which posts to the `/api/plugin` handler — NOT the generic
+// matrix page (`/$provider/$feature` → `/api/chat`). So we navigate directly
+// rather than via `featureUrl`, exercising the real definePlugin/usePlugin
+// path end to end.
+function pluginUrl(provider: string, testId: string, aimockPort: number) {
+  const params = new URLSearchParams({
+    provider,
+    testId,
+    aimockPort: String(aimockPort),
+  })
+  return `/plugin?${params.toString()}`
+}
+
+/**
+ * Click a run button once the page is hydrated. A click that lands before
+ * React hydration is a silent no-op, so verify the plugin's status left
+ * 'idle' and retry once if it didn't (mirrors `clickGenerate` in helpers).
+ */
+async function clickRun(
+  page: Page,
+  buttonTestId: string,
+  statusTestId: string,
+) {
+  await page.waitForLoadState('networkidle')
+  const btn = page.getByTestId(buttonTestId)
+  await btn.click()
+  try {
+    await expect(page.getByTestId(statusTestId)).not.toHaveText('idle', {
+      timeout: 3_000,
+    })
+  } catch {
+    // Retry click — hydration likely wasn't complete on first attempt
+    await btn.click()
+  }
+}
+
+for (const provider of providersFor('plugin')) {
+  test.describe(`${provider} — plugin`, () => {
+    test('chat plugin streams through usePlugin + the plugin handler', async ({
+      page,
+      testId,
+      aimockPort,
+    }) => {
+      await page.goto(pluginUrl(provider, testId, aimockPort))
+
+      await sendMessage(page, '[plugin] recommend a guitar')
+      await waitForResponse(page)
+
+      const response = await getLastAssistantMessage(page)
+      expect(response).toContain('Fender Stratocaster')
+    })
+
+    test('one-shot generation plugin run() renders its result', async ({
+      page,
+      testId,
+      aimockPort,
+    }) => {
+      await page.goto(pluginUrl(provider, testId, aimockPort))
+
+      await clickRun(page, 'plugin-run-banner', 'plugin-banner-status')
+
+      await expect(page.getByTestId('plugin-banner-result')).toHaveText(
+        'BANNER: solo banner',
+        { timeout: 15_000 },
+      )
+    })
+
+    test('media plugin (bannerImage) run() renders its result', async ({
+      page,
+      testId,
+      aimockPort,
+    }) => {
+      await page.goto(pluginUrl(provider, testId, aimockPort))
+
+      await clickRun(
+        page,
+        'plugin-run-banner-image',
+        'plugin-banner-image-status',
+      )
+
+      await expect(page.getByTestId('plugin-banner-image-status')).toHaveText(
+        'success',
+        { timeout: 15_000 },
+      )
+
+      const image = page.getByTestId('plugin-banner-image-result')
+      await expect(image).toHaveCount(1)
+      await expect(image).toHaveAttribute('src', /.+/)
+    })
+  })
+}
diff --git a/testing/e2e/tests/transaction.spec.ts b/testing/e2e/tests/transaction.spec.ts
deleted file mode 100644
index bd0646960..000000000
--- a/testing/e2e/tests/transaction.spec.ts
+++ /dev/null
@@ -1,119 +0,0 @@
-import { test, expect } from './fixtures'
-import type { Page } from '@playwright/test'
-import {
-  getLastAssistantMessage,
-  sendMessage,
-  waitForResponse,
-} from './helpers'
-import { providersFor } from './test-matrix'
-
-// The transaction feature has its own dedicated page (`/transaction`) that
-// drives `useTransaction`, which posts to the `/api/transaction` handler —
-// NOT the generic matrix page (`/$provider/$feature` → `/api/chat`). So we
-// navigate directly rather than via `featureUrl`, exercising the real
-// defineTransaction/useTransaction path end to end.
-function transactionUrl(provider: string, testId: string, aimockPort: number) {
-  const params = new URLSearchParams({
-    provider,
-    testId,
-    aimockPort: String(aimockPort),
-  })
-  return `/transaction?${params.toString()}`
-}
-
-/**
- * Click a run button once the page is hydrated. A click that lands before
- * React hydration is a silent no-op, so verify the verb's status left
- * 'idle' and retry once if it didn't (mirrors `clickGenerate` in helpers).
- */
-async function clickRun(
-  page: Page,
-  buttonTestId: string,
-  statusTestId: string,
-) {
-  await page.waitForLoadState('networkidle')
-  const btn = page.getByTestId(buttonTestId)
-  await btn.click()
-  try {
-    await expect(page.getByTestId(statusTestId)).not.toHaveText('idle', {
-      timeout: 3_000,
-    })
-  } catch {
-    // Retry click — hydration likely wasn't complete on first attempt
-    await btn.click()
-  }
-}
-
-for (const provider of providersFor('transaction')) {
-  test.describe(`${provider} — transaction`, () => {
-    test('chat verb streams through useTransaction + the transaction handler', async ({
-      page,
-      testId,
-      aimockPort,
-    }) => {
-      await page.goto(transactionUrl(provider, testId, aimockPort))
-
-      await sendMessage(page, '[transaction] recommend a guitar')
-      await waitForResponse(page)
-
-      const response = await getLastAssistantMessage(page)
-      expect(response).toContain('Fender Stratocaster')
-    })
-
-    test('one-shot verb run() renders its result', async ({
-      page,
-      testId,
-      aimockPort,
-    }) => {
-      await page.goto(transactionUrl(provider, testId, aimockPort))
-
-      await clickRun(
-        page,
-        'transaction-run-banner',
-        'transaction-banner-status',
-      )
-
-      await expect(page.getByTestId('transaction-banner-result')).toHaveText(
-        'BANNER: solo banner',
-        { timeout: 15_000 },
-      )
-    })
-
-    test('composing verb streams two sub-runs and a final result', async ({
-      page,
-      testId,
-      aimockPort,
-    }) => {
-      await page.goto(transactionUrl(provider, testId, aimockPort))
-
-      await clickRun(
-        page,
-        'transaction-run-banner-pair',
-        'transaction-banner-pair-status',
-      )
-
-      // Two `ctx.call(banner, …)` sub-runs, tagged in start order, both
-      // reaching success.
-      const subRuns = page.locator('[data-testid^="transaction-sub-run-"]')
-      await expect(subRuns).toHaveCount(2, { timeout: 15_000 })
-      for (const index of [0, 1]) {
-        const subRun = page.getByTestId(`transaction-sub-run-${index}`)
-        await expect(subRun).toHaveAttribute('data-verb', 'banner')
-        await expect(subRun).toHaveAttribute('data-status', 'success', {
-          timeout: 15_000,
-        })
-      }
-
-      // The composing verb's own return value arrives as the final
-      // generation:result and lands on `txn.bannerPair.result`.
-      await expect(
-        page.getByTestId('transaction-banner-pair-result'),
-      ).toHaveText('BANNER: hero guitars + BANNER: thumb guitars', {
-        timeout: 15_000,
-      })
-      await expect(
-        page.getByTestId('transaction-banner-pair-status'),
-      ).toHaveText('success')
-    })
-  })
-}