Rename agent→langgraph, symmetric adapter API, Choosing-an-adapter docs (#556)

Squash-merge of the agent→langgraph rename + symmetric adapter API + Choosing-an-adapter docs.

All rename-caused CI failures fixed. The sole remaining red — cockpit-langgraph-interrupts e2e (aimock 'No fixture matched') — is pre-existing and fails identically on main; unrelated to this change. Merged via --admin to bypass the branch-protection gate held by that pre-existing check.

Author: blove

README.md

@@ -26,7 +26,7 @@
 
 Threadplane is a production-ready agent UI framework for Angular. Use `@threadplane/chat` for chat surfaces, `@threadplane/langgraph` for LangGraph-backed agents, `@threadplane/ag-ui` for AG-UI event streams, and `@threadplane/render` for generative UI that stays inside your Angular design system.
 
-When you are building on LangGraph, `agent()` is the Angular equivalent of LangGraph's React `useStream()` hook, projected into a runtime-neutral `Agent` contract consumed by `@threadplane/chat`. Drop it into any Angular 20+ component, point it at your LangGraph Platform endpoint, and get signal-driven access to messages, status, tool calls, interrupts, subagents, regenerate, and thread history.
+When you are building on LangGraph, `injectAgent()` is the Angular equivalent of LangGraph's React `useStream()` hook, projected into a runtime-neutral `Agent` contract consumed by `@threadplane/chat`. Configure it once with `provideAgent({...})`, inject it into any Angular 20+ component, and get signal-driven access to messages, status, tool calls, interrupts, subagents, regenerate, and thread history.
 
 ---
 
@@ -43,9 +43,22 @@ npm install @threadplane/langgraph @threadplane/chat
 ## 30-Second Example
 
 ```typescript
+// app.config.ts — wire the adapter once
+import { provideAgent } from '@threadplane/langgraph';
+
+export const appConfig: ApplicationConfig = {
+  providers: [
+    provideAgent({
+      apiUrl: 'https://your-langgraph-platform.com',
+      assistantId: 'my-agent',
+    }),
+  ],
+};
+
+// support-chat.component.ts
 import { Component } from '@angular/core';
 import { ChatComponent as ThreadplaneChatComponent } from '@threadplane/chat';
-import { agent } from '@threadplane/langgraph';
+import { injectAgent } from '@threadplane/langgraph';
 
 @Component({
   selector: 'app-support-chat',
@@ -61,10 +74,7 @@ import { agent } from '@threadplane/langgraph';
   `,
 })
 export class SupportChatComponent {
-  chat = agent({
-    apiUrl: 'https://your-langgraph-platform.com',
-    assistantId: 'my-agent',
-  });
+  protected readonly chat = injectAgent();
 
   send() {
     void this.chat.submit({ message: 'Hello' });
@@ -78,7 +88,7 @@ That's it. `chat.messages()` and `chat.status()` are Angular Signals. Bind them
 
 ## Feature Comparison
 
-| Feature | `agent()` (Angular) | `useStream()` (React) |
+| Feature | `injectAgent()` (Angular) | `useStream()` (React) |
 |---|---|---|
 | Streaming state as reactive primitives | Angular Signals | React state |
 | Messages signal | `messages()` | `messages` |
@@ -113,17 +123,18 @@ That's it. `chat.messages()` and `chat.status()` are Angular Signals. Bind them
   />
 </p>
 
-`agent()` creates its internal `BehaviorSubject`s at injection-context time — once, at component construction. The `StreamManager` bridge (the only file that touches `@langchain/langgraph-sdk` internals) pushes stream events into those subjects. `toSignal()` converts each subject to an Angular Signal, also at construction time. Dynamic actions (`submit`, `stop`, `switchThread`) push into the existing subjects — no new subjects are ever created after construction. This architecture is required because `toSignal()` must be called in an injection context and cannot be called again later.
+`injectAgent()` resolves an agent whose internal `BehaviorSubject`s were created at injection-context time — once, when `provideAgent()`'s factory ran. The `StreamManager` bridge (the only file that touches `@langchain/langgraph-sdk` internals) pushes stream events into those subjects. `toSignal()` converts each subject to an Angular Signal, also at construction time. Dynamic actions (`submit`, `stop`, `switchThread`) push into the existing subjects — no new subjects are ever created after construction. This architecture is required because `toSignal()` must be called in an injection context and cannot be called again later.
 
 ---
 
 ## Documentation
 
-- [Agent Quickstart](https://threadplane.ai/docs/agent/getting-started/quickstart)
-- [agent() API](https://threadplane.ai/docs/agent/api/agent)
+- [LangGraph Quickstart](https://threadplane.ai/docs/langgraph/getting-started/quickstart)
+- [injectAgent() API](https://threadplane.ai/docs/langgraph/api/inject-agent)
+- [Choosing an adapter (LangGraph vs AG-UI)](https://threadplane.ai/docs/choosing-an-adapter)
 - [Chat Introduction](https://threadplane.ai/docs/chat/getting-started/introduction)
-- [Human-in-the-Loop / Interrupts](https://threadplane.ai/docs/agent/guides/interrupts)
-- [Subgraph and Subagent Streaming](https://threadplane.ai/docs/agent/guides/subgraphs)
+- [Human-in-the-Loop / Interrupts](https://threadplane.ai/docs/langgraph/guides/interrupts)
+- [Subgraph and Subagent Streaming](https://threadplane.ai/docs/langgraph/guides/subgraphs)
 
 ---
 

apps/website/content/blog/2026-05-21-build-fullstack-agentic-angular-apps-using-ag-ui.mdx

@@ -96,18 +96,18 @@ yarn add @threadplane/ag-ui @threadplane/chat marked
 ```ts
 // app.config.ts
 import { ApplicationConfig } from '@angular/core';
-import { provideAgUiAgent } from '@threadplane/ag-ui';
+import { provideAgent } from '@threadplane/ag-ui';
 import { provideChat } from '@threadplane/chat';
 
 export const appConfig: ApplicationConfig = {
   providers: [
-    provideAgUiAgent({ url: 'http://localhost:8000/agent' }),
+    provideAgent({ url: 'http://localhost:8000/agent' }),
     provideChat({ assistantName: 'Astra' }),
   ],
 };
 ```
 
-That's the whole bootstrap. `provideAgUiAgent` is the AG-UI transport. It wraps the official `@ag-ui/client` `HttpAgent` and exposes the signal-shaped contract via DI. `provideChat` is the chat UI's configuration.
+That's the whole bootstrap. `provideAgent` is the AG-UI transport. It wraps the official `@ag-ui/client` `HttpAgent` and exposes the signal-shaped contract via DI. `provideChat` is the chat UI's configuration.
 
 Notice they're independent. `@threadplane/chat` doesn't know it's talking to an AG-UI backend. It just reads from the `Agent` contract. We'll lean on that boundary later.
 
@@ -116,7 +116,7 @@ Notice they're independent. `@threadplane/chat` doesn't know it's talking to an
 ```ts
 // chat-page.component.ts
 import { Component, ChangeDetectionStrategy, inject } from '@angular/core';
-import { AG_UI_AGENT } from '@threadplane/ag-ui';
+import { injectAgent } from '@threadplane/ag-ui';
 import { ChatComponent } from '@threadplane/chat';
 
 @Component({
@@ -131,7 +131,7 @@ import { ChatComponent } from '@threadplane/chat';
   `,
 })
 export class ChatPageComponent {
-  protected readonly agent = inject(AG_UI_AGENT);
+  protected readonly agent = injectAgent();
 }
 ```
 
@@ -275,10 +275,10 @@ Say you started with a Python LangGraph backend, shipped to production, and a qu
 
 ```ts
 // before
-provideAgUiAgent({ url: '/agents/langgraph' }),
+provideAgent({ url: '/agents/langgraph' }),
 
 // after
-provideAgUiAgent({ url: '/agents/mastra' }),
+provideAgent({ url: '/agents/mastra' }),
 ```
 
 That's the diff.

apps/website/content/docs/ag-ui/api/api-docs.json

@@ -365,7 +365,7 @@
     ]
   },
   {
-    "name": "AgUiAgentConfig",
+    "name": "AgentConfig",
     "kind": "interface",
     "description": "Configuration for the AG-UI agent provider.\nHttpAgentConfig shape (from @ag-ui/client@0.0.52):\n  - url: string (required) — endpoint for the HTTP agent\n  - agentId: string (optional) — agent identifier\n  - threadId: string (optional) — thread identifier\n  - headers: Record<string, string> (optional) — custom HTTP headers",
     "properties": [
@@ -403,7 +403,7 @@
     "examples": []
   },
   {
-    "name": "FakeAgUiAgentConfig",
+    "name": "FakeAgentConfig",
     "kind": "interface",
     "description": "",
     "properties": [
@@ -468,10 +468,10 @@
     "examples": []
   },
   {
-    "name": "injectAgUiAgent",
+    "name": "injectAgent",
     "kind": "function",
-    "description": "Injects the AG_UI_AGENT from Angular's dependency injection container.\nUse this in components or services that have been provided via provideAgUiAgent().",
-    "signature": "injectAgUiAgent(): Agent",
+    "description": "Injects the Agent from Angular's dependency injection container.\nUse this in components or services that have been provided via provideAgent().",
+    "signature": "injectAgent(): Agent",
     "params": [],
     "returns": {
       "type": "Agent",
@@ -480,14 +480,14 @@
     "examples": []
   },
   {
-    "name": "provideAgUiAgent",
+    "name": "provideAgent",
     "kind": "function",
-    "description": "Provides an Agent instance wired through HttpAgent and toAgent.\nConstructs an HttpAgent from config and wraps it in the runtime-neutral\nAgent contract via toAgent(). Returns a provider array suitable for\nbootstrapApplication or TestBed.configureTestingModule().",
-    "signature": "provideAgUiAgent(config: AgUiAgentConfig): Provider[]",
+    "description": "Provides an Agent instance wired through HttpAgent and toAgent.\nConstructs an HttpAgent from config and wraps it in the runtime-neutral\nAgent contract via toAgent(). Returns a provider array suitable for\nbootstrapApplication or TestBed.configureTestingModule().\n\n**Static vs factory config.** Pass a plain `AgentConfig` object when the\nconfig is known up front. Pass a `() => AgentConfig` factory when the config\ndepends on runtime/DI state — the factory runs inside an Angular injection\ncontext, so it may call `inject()` to read services or route params.",
+    "signature": "provideAgent(configOrFactory: AgentConfig | object): Provider[]",
     "params": [
       {
-        "name": "config",
-        "type": "AgUiAgentConfig",
+        "name": "configOrFactory",
+        "type": "AgentConfig | object",
         "description": "",
         "optional": false
       }
@@ -499,14 +499,14 @@
     "examples": []
   },
   {
-    "name": "provideFakeAgUiAgent",
+    "name": "provideFakeAgent",
     "kind": "function",
-    "description": "Registers an in-process FakeAgent under AG_UI_AGENT.\n\nUse for offline demos and development. Drop-in replacement for\nprovideAgUiAgent({ url }) when no real backend is available.",
-    "signature": "provideFakeAgUiAgent(config: FakeAgUiAgentConfig): Provider[]",
+    "description": "Registers an in-process FakeAgent under AGENT.\n\nUse for offline demos and development. Drop-in replacement for\nprovideAgent({ url }) when no real backend is available.",
+    "signature": "provideFakeAgent(config: FakeAgentConfig): Provider[]",
     "params": [
       {
         "name": "config",
-        "type": "FakeAgUiAgentConfig",
+        "type": "FakeAgentConfig",
         "description": "",
         "optional": false
       }

apps/website/content/docs/ag-ui/concepts/architecture.mdx

@@ -42,39 +42,39 @@ Most Angular apps should use DI instead:
 
 ```ts
 import { ApplicationConfig } from '@angular/core';
-import { provideAgUiAgent } from '@threadplane/ag-ui';
+import { provideAgent } from '@threadplane/ag-ui';
 
 export const appConfig: ApplicationConfig = {
   providers: [
-    provideAgUiAgent({ url: '/api/agent' }),
+    provideAgent({ url: '/api/agent' }),
   ],
 };
 ```
 
-`provideAgUiAgent()` creates an AG-UI `HttpAgent` and registers the wrapped `Agent` under `AG_UI_AGENT`.
+`provideAgent()` creates an AG-UI `HttpAgent` and registers the wrapped `Agent` under an internal DI token. Retrieve it with `injectAgent()`.
 
 ```ts
 import { Component } from '@angular/core';
 import { ChatComponent } from '@threadplane/chat';
-import { injectAgUiAgent } from '@threadplane/ag-ui';
+import { injectAgent } from '@threadplane/ag-ui';
 
 @Component({
   standalone: true,
   imports: [ChatComponent],
   template: `<chat [agent]="agent" />`,
 })
 export class ChatPage {
-  protected readonly agent = injectAgUiAgent();
+  protected readonly agent = injectAgent();
 }
 ```
 
 You can also inject the token directly:
 
 ```ts
 import { inject } from '@angular/core';
-import { AG_UI_AGENT } from '@threadplane/ag-ui';
+import { injectAgent } from '@threadplane/ag-ui';
 
-const agent = inject(AG_UI_AGENT);
+const agent = injectAgent();
 ```
 
 ## Runtime data flow
@@ -95,10 +95,10 @@ This is optimistic on purpose. The user message appears immediately while the ba
 
 ## Provider choices
 
-Use `provideAgUiAgent()` when you have a real AG-UI HTTP endpoint.
+Use `provideAgent()` when you have a real AG-UI HTTP endpoint.
 
 ```ts
-provideAgUiAgent({
+provideAgent({
   url: '/api/agent',
   agentId: 'support-agent',
   threadId: 'thread-123',
@@ -110,16 +110,16 @@ The config maps directly to the AG-UI `HttpAgent` options currently exposed by t
 
 `threadId` here is a plain string consumed once at construction — the provider does not accept an Angular Signal, and the adapter does not observe changes to it at runtime. The AG-UI protocol carries events, not snapshots, and defines no server-side endpoint for "fetch the messages of thread X". To move a user between threads with their prior conversation restored, you have two options:
 
-- **Recreate the provider.** Inject `provideAgUiAgent({ ..., threadId: newId })` from a fresh injector when the active thread changes. Any prior message history must come from your own host service — pre-populate `setMessages()` on the source before the adapter boots, or render a "loading…" surface while you fetch it.
-- **Use the LangGraph adapter instead.** `@threadplane/langgraph` accepts `threadId: Signal<string | null>` and hydrates messages from the latest checkpoint on every change. See its [Persistence guide](/docs/agent/guides/persistence). Use AG-UI when your runtime publishes events without checkpoint storage; use LangGraph when the server owns durable thread state.
+- **Recreate the provider.** Inject `provideAgent({ ..., threadId: newId })` from a fresh injector when the active thread changes. Any prior message history must come from your own host service — pre-populate `setMessages()` on the source before the adapter boots, or render a "loading…" surface while you fetch it.
+- **Use the LangGraph adapter instead.** `@threadplane/langgraph` accepts `threadId: Signal<string | null>` and hydrates messages from the latest checkpoint on every change. See its [Persistence guide](/docs/langgraph/guides/persistence). Use AG-UI when your runtime publishes events without checkpoint storage; use LangGraph when the server owns durable thread state.
 
-Use `provideFakeAgUiAgent()` when you need the UI to run without a backend:
+Use `provideFakeAgent()` when you need the UI to run without a backend:
 
 ```ts
-import { provideFakeAgUiAgent } from '@threadplane/ag-ui';
+import { provideFakeAgent } from '@threadplane/ag-ui';
 
 providers: [
-  provideFakeAgUiAgent({
+  provideFakeAgent({
     tokens: ['Offline', ' demo', ' response.'],
     delayMs: 40,
   }),

apps/website/content/docs/ag-ui/getting-started/installation.mdx

@@ -32,18 +32,18 @@ In your app config:
 
 ```ts
 import { ApplicationConfig } from '@angular/core';
-import { provideAgUiAgent } from '@threadplane/ag-ui';
+import { provideAgent } from '@threadplane/ag-ui';
 
 export const appConfig: ApplicationConfig = {
   providers: [
-    provideAgUiAgent({
+    provideAgent({
       url: 'http://localhost:3000/agent',  // your AG-UI backend
     }),
   ],
 };
 ```
 
-`provideAgUiAgent` accepts:
+`provideAgent` accepts:
 
 | Option | Type | Description |
 |---|---|---|
@@ -57,7 +57,7 @@ export const appConfig: ApplicationConfig = {
 ```ts
 import { Component, inject } from '@angular/core';
 import { ChatComponent } from '@threadplane/chat';
-import { AG_UI_AGENT } from '@threadplane/ag-ui';
+import { injectAgent } from '@threadplane/ag-ui';
 
 @Component({
   selector: 'app-streaming',
@@ -66,7 +66,7 @@ import { AG_UI_AGENT } from '@threadplane/ag-ui';
   template: `<chat [agent]="agent" />`,
 })
 export class StreamingComponent {
-  protected readonly agent = inject(AG_UI_AGENT);
+  protected readonly agent = injectAgent();
 }
 ```
 
@@ -75,19 +75,19 @@ export class StreamingComponent {
 Use the `FakeAgent` for offline demos:
 
 ```ts
-import { provideFakeAgUiAgent } from '@threadplane/ag-ui';
+import { provideFakeAgent } from '@threadplane/ag-ui';
 
 export const appConfig: ApplicationConfig = {
   providers: [
-    provideFakeAgUiAgent({
+    provideFakeAgent({
       tokens: ['Hello', ' from', ' a', ' fake', ' agent.'],
       delayMs: 60,
     }),
   ],
 };
 ```
 
-`FakeAgent` extends `AbstractAgent` and emits a canned `RUN_STARTED -> TEXT_MESSAGE_START -> TEXT_MESSAGE_CONTENT x N -> TEXT_MESSAGE_END -> RUN_FINISHED` sequence. Drop-in replacement for `provideAgUiAgent({ url })` while you're prototyping.
+`FakeAgent` extends `AbstractAgent` and emits a canned `RUN_STARTED -> TEXT_MESSAGE_START -> TEXT_MESSAGE_CONTENT x N -> TEXT_MESSAGE_END -> RUN_FINISHED` sequence. Drop-in replacement for `provideAgent({ url })` while you're prototyping.
 
 ## Custom transport
 

apps/website/content/docs/ag-ui/getting-started/introduction.mdx

@@ -1,5 +1,7 @@
 # Introduction
 
+> **Picking an adapter?** This guide covers `@threadplane/ag-ui` — the AG-UI protocol adapter. If you're talking to LangGraph Platform directly via the LangGraph SDK, use [`@threadplane/langgraph`](/langgraph) instead. See [Choosing an adapter](/docs/choosing-an-adapter) for a side-by-side comparison.
+
 `@threadplane/ag-ui` is the runtime adapter that wraps an [AG-UI](https://github.com/ag-ui-protocol/ag-ui) `AbstractAgent` into the runtime-neutral `Agent` contract from `@threadplane/chat`. The chat UI primitives consume the Agent contract; the AG-UI adapter translates between the contract and the AG-UI event protocol.
 
 <Callout type="info" title="What is AG-UI?">
@@ -25,7 +27,7 @@ AG-UI is the open agent-to-UI protocol from the CopilotKit ecosystem. It standar
 ## What you get
 
 - **`toAgent(source: AbstractAgent): Agent`** - wraps any `AbstractAgent` subclass (custom transports, mocks) into the runtime-neutral `Agent` contract.
-- **`provideAgUiAgent({ url })`** - DI convenience that instantiates `HttpAgent` under the hood for the common SSE/HTTP case.
+- **`provideAgent({ url })`** - DI convenience that instantiates `HttpAgent` under the hood for the common SSE/HTTP case.
 - **`FakeAgent`** - in-process `AbstractAgent` subclass that emits canned streaming events for offline demos and tests.
 
 ## What's covered