@threadplane/langgraph 0.0.47 → 0.0.49

package/README.md

@@ -1,8 +1,28 @@
 # @threadplane/langgraph
 
-Adapter that wraps a LangGraph agent into the runtime-neutral `Agent` contract from `@threadplane/chat`. The Angular equivalent of LangGraph's React `useStream()` hook — signal-driven access to messages, status, tool calls, interrupts, subagents, regenerate, and thread history.
+Adapter that wraps a LangGraph agent into the runtime-neutral `Agent` contract from `@threadplane/chat`. The Angular equivalent of LangGraph's React `useStream()` hook — signal-driven access to messages, status, tool calls, interrupts, subagents, branch history, and thread persistence.
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@threadplane/langgraph">
+    <img alt="npm version" src="https://img.shields.io/npm/v/@threadplane%2Flanggraph?color=6C8EFF&labelColor=080B14&style=flat-square" />
+  </a>
+  <a href="https://angular.dev">
+    <img alt="Angular 20+" src="https://img.shields.io/badge/Angular-20%2B%20%7C%2021-6C8EFF?labelColor=080B14&style=flat-square" />
+  </a>
+  <a href="https://opensource.org/licenses/MIT">
+    <img alt="MIT" src="https://img.shields.io/badge/License-MIT-6C8EFF?labelColor=080B14&style=flat-square" />
+  </a>
+</p>
+
+> Talking to a non-LangGraph backend? See [`@threadplane/ag-ui`](https://www.npmjs.com/package/@threadplane/ag-ui) — same API shape, AG-UI protocol underneath.
 
-Part of [Threadplane](https://github.com/cacheplane/angular-agent-framework). MIT licensed.
+## What it does
+
+- **`provideAgent()`** — wire the LangGraph adapter into Angular DI. Provided at the root injector or at any component subtree (multi-thread UIs work via Angular's hierarchical DI).
+- **`injectAgent()`** — retrieve the configured `LangGraphAgent` in any component. Returns a `LangGraphAgent` whose entire state surface (`messages`, `status`, `isLoading`, `error`, `interrupt`, `toolCalls`, `subagents`, `queue`, `branch`, `history`, and more) is exposed as Angular Signals. No subscriptions, no `async` pipe, no zone.js required.
+- **Human-in-the-loop** — `interrupt()` delivers a runtime-neutral interrupt value; `langGraphInterrupts()` exposes the raw LangGraph interrupt list when you need it.
+- **Subagent streaming** — `subagents()` + `getSubagent(toolCallId)`, `getSubagentsByType(type)`, `getSubagentsByMessage(msg)`, and `activeSubagents()` surface streaming subgraph state without extra bookkeeping.
+- **Time-travel and thread persistence** — `branch()` / `history()` / `experimentalBranchTree()` enable checkpoint navigation; `LangGraphThreadsAdapter` provides SDK-backed thread CRUD so you never have to hand-roll thread management.
 
 ## Install
 
@@ -10,18 +30,20 @@ Part of [Threadplane](https://github.com/cacheplane/angular-agent-framework). MI
 npm install @threadplane/langgraph @threadplane/chat
 ```
 
-**Peer dependencies:** `@angular/core ^20.0.0 || ^21.0.0`, `@langchain/core ^1.1.0`, `@langchain/langgraph-sdk ^1.7.0`, `rxjs ~7.8.0`
-
-## What it does
+**Peer dependencies:**
 
-- **`agent()`** — Angular Signal-based handle to a LangGraph streaming run. Returns `messages()`, `status()`, `isLoading()`, `error()`, `interrupt()`, `toolCalls()`, plus actions (`submit`, `stop`, `regenerate`, `reload`).
-- **`provideAgent()`** — configure the LangGraph endpoint once in `app.config.ts`. Per-call overrides are accepted by `agent()` itself.
-- **Thread persistence** — pass `threadId: signal(...)` + `onThreadId` to round-trip thread IDs through your own storage (localStorage, URL, etc.).
-- **`MockAgentTransport`** — deterministic in-memory transport for tests. Never mock `agent()` itself; swap the transport instead.
-- **`extractCitations()`** — populates `Message.citations` from LangGraph message metadata. Reads from `additional_kwargs.citations` (preferred) or `additional_kwargs.sources` (fallback).
+```
+@threadplane/chat          *
+@angular/core              ^20.0.0 || ^21.0.0
+@langchain/core            ^1.1.33
+@langchain/langgraph-sdk   ^1.7.4
+rxjs                       ~7.8.0
+```
 
 ## Quick start
 
+Configure the LangGraph endpoint once in `app.config.ts`:
+
 ```ts
 // app.config.ts
 import { provideAgent } from '@threadplane/langgraph';
@@ -30,15 +52,18 @@ export const appConfig: ApplicationConfig = {
   providers: [
     provideAgent({
       apiUrl: 'https://your-langgraph-platform.com',
+      assistantId: 'my-agent',
     }),
   ],
 };
 ```
 
+Then call `injectAgent()` in any component and pass the result to `<chat />`:
+
 ```ts
 // chat.component.ts
 import { Component } from '@angular/core';
-import { agent } from '@threadplane/langgraph';
+import { injectAgent } from '@threadplane/langgraph';
 import { ChatComponent } from '@threadplane/chat';
 
 @Component({
@@ -46,47 +71,143 @@ import { ChatComponent } from '@threadplane/chat';
   template: `<chat [agent]="chat" />`,
 })
 export class ChatComponentHost {
-  chat = agent({
-    apiUrl: 'https://your-langgraph-platform.com',
-    assistantId: 'my-agent',
-  });
+  protected readonly chat = injectAgent();
 }
 ```
 
-> `agent()` must be called within an Angular injection context (component field initializer or constructor). Calling it in `ngOnInit` or any async context throws `NG0203: inject() must be called from an injection context`.
+> `injectAgent()` must be called within an Angular injection context — a component field initializer or constructor. Calling it in `ngOnInit` or any async context throws `NG0203: inject() must be called from an injection context`.
 
-## Citations example
+> Need a different agent for a specific component subtree (e.g., a sidebar showing a separate conversation)? Re-provide `provideAgent({...})` in that component's `providers: []` array — Angular's hierarchical DI takes care of the rest.
+
+## Capabilities
+
+### Messages, status, and errors
+
+| Signal | Type | Description |
+|---|---|---|
+| `messages()` | `Message[]` | Accumulated chat messages from the stream |
+| `status()` | `'idle' \| 'running' \| 'error'` | Runtime-neutral run status |
+| `isLoading()` | `boolean` | `true` while a run is streaming |
+| `error()` | `unknown \| null` | Last error, if any |
+
+### Human-in-the-loop (interrupts)
 
 ```ts
-// In your LangGraph node:
-const response = await llm.invoke([...]);
-
-return new AIMessage({
-  content: response.content,
-  additional_kwargs: {
-    citations: [
-      {
-        id: 'doc-1',
-        index: 1,
-        title: 'Example Article',
-        url: 'https://example.com/article',
-        snippet: 'Relevant excerpt...',
-      },
-    ],
-  },
-});
-
-// Message.citations auto-populates in @threadplane/chat via extractCitations()
+const pending = chat.interrupt();       // runtime-neutral interrupt value
+const raw = chat.langGraphInterrupts(); // raw LangGraph Interrupt[]
 ```
 
+Resume by calling `chat.submit(response)`.
+
+### Tool calls
+
+`toolCalls()` is a Signal of all tool call entries observed in the current run, updated incrementally as the stream progresses.
+
+### Subagents
+
+```ts
+chat.subagents()                       // Signal<Map<string, Subagent>> of all subagents
+chat.activeSubagents()                 // currently streaming subagents (SubagentStreamRef[])
+chat.getSubagent(toolCallId)           // look up by tool call ID
+chat.getSubagentsByType(type)          // filter by subagent type
+chat.getSubagentsByMessage(msg)        // filter by parent message
+```
+
+### Queue
+
+`queue()` exposes pending run entries when the agent is configured with a multitask strategy that queues concurrent submissions.
+
+### Branch, history, and time-travel
+
+```ts
+chat.branch()                   // current branch identifier Signal
+chat.setBranch(b)               // switch to a checkpoint branch
+chat.history()                  // runtime-neutral history entries
+chat.langGraphHistory()         // raw LangGraph ThreadState[]
+chat.experimentalBranchTree()   // full branching tree for time-travel UI
+```
+
+### Actions
+
+```ts
+chat.submit(input, opts?)                   // send a new message
+chat.stop()                                 // cancel the active run
+chat.regenerate(assistantMessageIndex)      // re-run from a prior assistant turn
+chat.reload()                               // re-run the last submission
+chat.switchThread(threadId)                 // load a different thread
+chat.joinStream(runId, lastEventId?)        // reconnect to an in-flight run
+```
+
+### Thread persistence
+
+`LangGraphThreadsAdapter` is a drop-in, SDK-backed thread store. Provide it alongside the agent config:
+
+```ts
+import { provideAgent, LangGraphThreadsAdapter, LANGGRAPH_THREADS_CONFIG } from '@threadplane/langgraph';
+
+export const appConfig: ApplicationConfig = {
+  providers: [
+    provideAgent({ apiUrl: 'https://your-langgraph-platform.com' }),
+    { provide: LANGGRAPH_THREADS_CONFIG, useValue: { apiUrl: 'https://your-langgraph-platform.com' } },
+    LangGraphThreadsAdapter,
+  ],
+};
+```
+
+Pair it with the lifecycle helpers to keep your thread list fresh:
+
+```ts
+import { refreshOnRunEnd, refreshOnTransition } from '@threadplane/langgraph';
+
+refreshOnRunEnd(chat, () => threadsAdapter.loadThreads());
+```
+
+### Citations
+
+`extractCitations(msg)` reads citation metadata from a LangGraph message's `additional_kwargs`, returning `Citation[] | undefined` (`undefined` when no citation metadata is present). It checks `additional_kwargs.citations` first, falling back to `additional_kwargs.sources`.
+
+```ts
+import { extractCitations } from '@threadplane/langgraph';
+
+const citations = extractCitations(message);
+```
+
+`Citation` is a type from `@threadplane/chat`; `CitationsResolverService` and `provideChat` also live there.
+
+## Testing
+
+```ts
+// Fake backend — streams canned tokens, no server:
+import { provideFakeAgent } from '@threadplane/langgraph';
+providers: [provideFakeAgent({ tokens: ['Hello', ' world'] })];
+```
+
+For component/unit tests, use the writable-signal mock `mockLangGraphAgent()`
+(it extends the neutral `mockAgent` from `@threadplane/chat`). See
+[Choosing an adapter → Testing](https://threadplane.ai/docs/choosing-an-adapter#testing).
+
+Need to hand-script exact wire events (tool calls, interrupts, multi-batch
+lifecycles)? `MockAgentTransport` is the advanced escape hatch — swap the
+transport, never mock `injectAgent()` itself.
+
+## Reliability
+
+**Runtime-neutral contract.** `LangGraphAgent` implements the `Agent` contract from `@threadplane/chat`. Components that depend only on that contract are portable across adapters (`@threadplane/ag-ui`, future adapters) without modification.
+
+**Release policy.** Patch-only `0.0.x` releases — every change, including breaking ones, increments the patch version until the library reaches `1.0.0`.
+
+**CI.** The "Library — lint / test / build" job runs lint, tests, and build on every pull request.
+
 ## Documentation
 
-- [Quickstart](https://threadplane.ai/docs/agent/getting-started/quickstart)
-- [`agent()` API reference](https://threadplane.ai/docs/agent/api/agent)
-- [Human-in-the-loop / interrupts](https://threadplane.ai/docs/agent/guides/interrupts)
-- [Thread persistence](https://threadplane.ai/docs/agent/guides/persistence)
-- [Testing with `MockAgentTransport`](https://threadplane.ai/docs/agent/guides/testing)
+- [Quickstart](https://threadplane.ai/docs/langgraph/getting-started/quickstart)
+- [`injectAgent()` API reference](https://threadplane.ai/docs/langgraph/api/inject-agent)
+- [`provideAgent()` API reference](https://threadplane.ai/docs/langgraph/api/provide-agent)
+- [Human-in-the-loop / interrupts](https://threadplane.ai/docs/langgraph/guides/interrupts)
+- [Thread persistence](https://threadplane.ai/docs/langgraph/guides/persistence)
+- [Testing with `MockAgentTransport`](https://threadplane.ai/docs/langgraph/guides/testing)
+- [Choosing an adapter (LangGraph vs AG-UI)](https://threadplane.ai/docs/choosing-an-adapter)
 
 ## License
 
-MIT — free for any use. See [LICENSE](../../LICENSE).
+MIT. See [LICENSE](../../LICENSE).

package/fesm2022/threadplane-langgraph.mjs

@@ -1,20 +1,11 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, signal, Injectable, inject, DestroyRef, isSignal, computed, effect } from '@angular/core';
+import { signal, Injectable, inject, DestroyRef, isSignal, computed, effect, InjectionToken } from '@angular/core';
 import { toObservable, toSignal } from '@angular/core/rxjs-interop';
 import { takeUntil, Subject, BehaviorSubject, of, throttleTime, asyncScheduler } from 'rxjs';
 import { takeUntil as takeUntil$1 } from 'rxjs/operators';
 import { Client } from '@langchain/langgraph-sdk';
 import { getToolCallsWithResults } from '@langchain/langgraph-sdk/utils';
-
-// SPDX-License-Identifier: MIT
-const AGENT_CONFIG = new InjectionToken('AGENT_CONFIG');
-/**
- * Angular provider factory that registers global defaults for all
- * agent instances in the application.
- */
-function provideAgent(config) {
-    return { provide: AGENT_CONFIG, useValue: config };
-}
+import { mockAgent } from '@threadplane/chat';
 
 // SPDX-License-Identifier: MIT
 /**
@@ -1868,10 +1859,14 @@ function computeMessageCheckpoints(history) {
     return out;
 }
 /**
- * Creates a LangGraph-backed Angular agent.
+ * Internal factory that constructs a LangGraph-backed Angular agent.
+ *
+ * @internal Consumers do not call this directly. Configure the adapter with
+ * `provideAgent({...})` in `app.config.ts` (or a component's `providers`), then
+ * retrieve the agent with `injectAgent()`. This factory is the construction
+ * logic invoked by `provideAgent`'s DI factory.
  *
- * Must be called within an Angular injection context (component constructor,
- * field initializer, or `runInInjectionContext`). Returns a unified
+ * Must run within an Angular injection context. Returns a unified
  * {@link LangGraphAgent} whose properties are Angular Signals that update
  * in real time as LangGraph streams messages, values, tool calls, interrupts,
  * subagent state, and checkpoint history.
@@ -1883,13 +1878,18 @@ function computeMessageCheckpoints(history) {
  *
  * @example
  * ```typescript
- * // In a component field initializer
- * const chat = agent({
- *   assistantId: 'chat_agent',
- *   apiUrl: 'http://localhost:2024',
- *   threadId: signal(this.savedThreadId),
- *   onThreadId: (id) => localStorage.setItem('threadId', id),
- * });
+ * // app.config.ts — configure once
+ * providers: [
+ *   provideAgent({
+ *     assistantId: 'chat',
+ *     apiUrl: 'http://localhost:2024',
+ *     threadId: signal(savedThreadId),
+ *     onThreadId: (id) => localStorage.setItem('threadId', id),
+ *   }),
+ * ];
+ *
+ * // component — retrieve from DI
+ * const chat = injectAgent();
  *
  * // Access signals in template
  * // chat.messages(), chat.status(), chat.error()
@@ -2457,6 +2457,93 @@ function isRecord(v) {
     return typeof v === 'object' && v !== null && !Array.isArray(v);
 }
 
+// SPDX-License-Identifier: MIT
+/**
+ * @internal — exported only so the legacy in-tree `agent({...})` factory (and
+ * its tests) can read provider-supplied defaults. Not part of the public API;
+ * consumers should construct config inline at `provideAgent({...})`.
+ */
+const AGENT_CONFIG = new InjectionToken('AGENT_CONFIG');
+/**
+ * @internal — exported for spec access only. Consumers must use `injectAgent()`.
+ */
+const AGENT = new InjectionToken('AGENT');
+/**
+ * Wire the LangGraph adapter into Angular's dependency injection.
+ *
+ * Registers a singleton `LangGraphAgent` constructed from `config`. Retrieve it
+ * in any component with `injectAgent()`. Provide this at the application root
+ * (`app.config.ts`) for an app-wide agent.
+ *
+ * To use a different agent in a component subtree, re-provide
+ * `provideAgent({...})` in that component's `providers: []` array —
+ * Angular's hierarchical DI scopes the singleton accordingly.
+ *
+ * **Static vs factory config.** Pass a plain `AgentConfig` object when the
+ * config is known up front. Pass a `() => AgentConfig` factory when the config
+ * depends on runtime/DI state — the factory runs inside an Angular injection
+ * context, so it may call `inject()` to read services, route params, or
+ * component-scoped signals:
+ *
+ * ```ts
+ * providers: [
+ *   provideAgent(() => {
+ *     const route = inject(ActivatedRoute);
+ *     return { assistantId: 'chat', threadId: toSignal(route.paramMap) };
+ *   }),
+ * ];
+ * ```
+ */
+function provideAgent(configOrFactory) {
+    // Resolve the factory (if any) lazily, inside the injection context of the
+    // AGENT_CONFIG useFactory below — never at decoration time.
+    const resolveConfig = () => typeof configOrFactory === 'function' ? configOrFactory() : configOrFactory;
+    return [
+        // AGENT_CONFIG resolves the config once (running the factory in an
+        // injection context if a factory was passed). AGENT reads the resolved
+        // config from here, so the factory is invoked exactly once.
+        { provide: AGENT_CONFIG, useFactory: resolveConfig },
+        {
+            provide: AGENT,
+            useFactory: () => {
+                // useFactory runs in an injection context, so the legacy `agent()`
+                // factory's `inject(DestroyRef)` calls work.
+                const config = inject(AGENT_CONFIG);
+                if (config.assistantId === undefined) {
+                    throw new Error('provideAgent: `assistantId` is required to construct the AGENT singleton.');
+                }
+                return agent({
+                    assistantId: config.assistantId,
+                    ...(config.apiUrl !== undefined ? { apiUrl: config.apiUrl } : {}),
+                    ...(config.threadId !== undefined ? { threadId: config.threadId } : {}),
+                    ...(config.onThreadId !== undefined ? { onThreadId: config.onThreadId } : {}),
+                    ...(config.initialValues !== undefined ? { initialValues: config.initialValues } : {}),
+                    ...(config.throttle !== undefined ? { throttle: config.throttle } : {}),
+                    ...(config.toMessage !== undefined ? { toMessage: config.toMessage } : {}),
+                    ...(config.transport !== undefined ? { transport: config.transport } : {}),
+                    ...(config.telemetry !== undefined ? { telemetry: config.telemetry } : {}),
+                    ...(config.filterSubagentMessages !== undefined ? { filterSubagentMessages: config.filterSubagentMessages } : {}),
+                    ...(config.subagentToolNames !== undefined ? { subagentToolNames: config.subagentToolNames } : {}),
+                });
+            },
+        },
+    ];
+}
+
+// SPDX-License-Identifier: MIT
+/**
+ * Retrieve the LangGraph-backed Agent from the current Angular injection context.
+ *
+ * Mirrors `@threadplane/ag-ui`'s `injectAgent()` so consumer code is identical
+ * regardless of which adapter is wired in `app.config.ts`. The agent is a
+ * singleton scoped to the injector that called `provideAgent()` — re-provide
+ * in a child component's `providers: []` to scope a different agent to that
+ * subtree (Angular's hierarchical DI handles the rest).
+ */
+function injectAgent() {
+    return inject(AGENT);
+}
+
 // SPDX-License-Identifier: MIT
 const AGENT_LIFECYCLE = new InjectionToken('AGENT_LIFECYCLE');
 
@@ -2592,18 +2679,22 @@ class MockAgentTransport {
 /**
  * Creates a mock LangGraphAgent with writable signals for testing.
  * Control state by writing to the returned writable signals directly.
+ *
+ * Neutral `Agent`-contract signals come from {@link mockAgent}; LangGraph-specific
+ * signals are declared here and layered on top.
  */
 function mockLangGraphAgent(initial = {}) {
-    const messages$ = signal(initial.messages ?? [], ...(ngDevMode ? [{ debugName: "messages$" }] : []));
+    const base = mockAgent({
+        ...initial,
+        withInterrupt: true,
+        withSubagents: true,
+        history: initial.history ?? [],
+    });
+    // ── LangGraph-specific writable signals (defaults copied verbatim) ────────
     const langGraphMessages$ = signal(initial.langGraphMessages ?? [], ...(ngDevMode ? [{ debugName: "langGraphMessages$" }] : []));
-    const status$ = signal(initial.status ?? 'idle', ...(ngDevMode ? [{ debugName: "status$" }] : []));
-    const isLoading$ = signal(initial.isLoading ?? false, ...(ngDevMode ? [{ debugName: "isLoading$" }] : []));
-    const error$ = signal(initial.error ?? null, ...(ngDevMode ? [{ debugName: "error$" }] : []));
     const hasValue$ = signal(initial.hasValue ?? false, ...(ngDevMode ? [{ debugName: "hasValue$" }] : []));
     const value$ = signal(null, ...(ngDevMode ? [{ debugName: "value$" }] : []));
-    const interrupt$ = signal(undefined, ...(ngDevMode ? [{ debugName: "interrupt$" }] : []));
     const langGraphInterrupts$ = signal([], ...(ngDevMode ? [{ debugName: "langGraphInterrupts$" }] : []));
-    const toolCalls$ = signal([], ...(ngDevMode ? [{ debugName: "toolCalls$" }] : []));
     const langGraphToolCalls$ = signal([], ...(ngDevMode ? [{ debugName: "langGraphToolCalls$" }] : []));
     const toolProgress$ = signal([], ...(ngDevMode ? [{ debugName: "toolProgress$" }] : []));
     const queue$ = signal({
@@ -2613,33 +2704,20 @@ function mockLangGraphAgent(initial = {}) {
         clear: async () => undefined,
     }, ...(ngDevMode ? [{ debugName: "queue$" }] : []));
     const branch$ = signal('', ...(ngDevMode ? [{ debugName: "branch$" }] : []));
-    const history$ = signal([], ...(ngDevMode ? [{ debugName: "history$" }] : []));
     const langGraphHistory$ = signal([], ...(ngDevMode ? [{ debugName: "langGraphHistory$" }] : []));
     const experimentalBranchTree$ = signal({ type: 'sequence', items: [] }, ...(ngDevMode ? [{ debugName: "experimentalBranchTree$" }] : []));
     const isThreadLoading$ = signal(initial.isThreadLoading ?? false, ...(ngDevMode ? [{ debugName: "isThreadLoading$" }] : []));
-    const subagents$ = signal(new Map(), ...(ngDevMode ? [{ debugName: "subagents$" }] : []));
     const activeSubagents$ = signal([], ...(ngDevMode ? [{ debugName: "activeSubagents$" }] : []));
     const customEvents$ = signal([], ...(ngDevMode ? [{ debugName: "customEvents$" }] : []));
+    // `state` derives from the raw LangGraph value (preserves current behavior).
     const state$ = computed(() => {
         const v = value$();
         return v && typeof v === 'object' ? v : {};
     }, ...(ngDevMode ? [{ debugName: "state$" }] : []));
-    const eventsSubject = new Subject();
     const mock = {
-        // ── AgentWithHistory (runtime-neutral surface) ────────────────────────
-        messages: messages$,
-        status: status$,
-        isLoading: isLoading$,
-        error: error$,
-        toolCalls: toolCalls$,
+        ...base,
+        // ── Neutral surface: override `state` to derive from the LangGraph value ─
         state: state$,
-        interrupt: interrupt$,
-        subagents: subagents$,
-        events$: eventsSubject.asObservable(),
-        history: history$,
-        submit: (_input, _opts) => Promise.resolve(),
-        stop: () => Promise.resolve(),
-        regenerate: (_assistantMessageIndex) => Promise.resolve(),
         // ── Raw LangGraph signals ─────────────────────────────────────────────
         langGraphMessages: langGraphMessages$,
         langGraphInterrupts: langGraphInterrupts$,
@@ -2694,6 +2772,97 @@ function mockLangGraphAgent(initial = {}) {
     return mock;
 }
 
+const DEFAULT_TOKENS = ['Hello', ' from', ' the', ' fake', ' LangGraph', ' agent.'];
+/**
+ * In-process AgentTransport that auto-streams a canned assistant reply.
+ *
+ * Backs `provideFakeAgent()`. Unlike `MockAgentTransport` (passive, driven
+ * manually from specs), this transport emits its tokens automatically on
+ * `stream()`, then completes — suitable for offline demos and integration tests.
+ *
+ * NOT for production use.
+ */
+class FakeStreamTransport {
+    tokens;
+    reasoningTokens;
+    delayMs;
+    constructor(config = {}) {
+        this.tokens = config.tokens ?? DEFAULT_TOKENS;
+        this.reasoningTokens = config.reasoningTokens ?? [];
+        // Default 60ms matches @threadplane/ag-ui's FakeAgent so both adapters'
+        // provideFakeAgent() stream at the same cadence for the same config.
+        this.delayMs = config.delayMs ?? 60;
+    }
+    async *stream(_assistantId, _threadId, _payload, signal, _options) {
+        const id = 'fake-ai-1';
+        let reasoning = '';
+        for (const chunk of this.reasoningTokens) {
+            if (signal.aborted)
+                return;
+            reasoning += chunk;
+            yield {
+                type: 'messages',
+                messages: [
+                    { id, type: 'ai', content: '', additional_kwargs: { reasoning_content: reasoning } },
+                ],
+            };
+            if (this.delayMs > 0)
+                await delay(this.delayMs);
+        }
+        let content = '';
+        for (const tok of this.tokens) {
+            if (signal.aborted)
+                return;
+            content += tok;
+            yield {
+                type: 'messages',
+                messages: [{ id, type: 'ai', content }],
+            };
+            if (this.delayMs > 0)
+                await delay(this.delayMs);
+        }
+    }
+    async createQueuedRun(_assistantId, threadId, payload, _signal, options) {
+        return {
+            id: 'fake-queued-run',
+            threadId,
+            values: payload,
+            options: { ...options, multitaskStrategy: 'enqueue' },
+            createdAt: new Date(),
+        };
+    }
+    async cancelRun(_threadId, _runId, _signal) {
+        // No-op: the fake has no real runs to cancel.
+        return;
+    }
+    async getHistory(_threadId, _signal) {
+        return [];
+    }
+    async *joinStream() {
+        // No queued-run replay in the fake; yields nothing.
+        yield* [];
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Wire an in-process fake LangGraph agent into Angular DI.
+ *
+ * Streams a canned assistant reply (see FakeAgentConfig) with no backend —
+ * the symmetric counterpart to @threadplane/ag-ui's provideFakeAgent(). For
+ * advanced manual scripting (tool calls, interrupts, multi-batch), provide
+ * the agent yourself with
+ * `provideAgent({ assistantId, transport: new MockAgentTransport(...) })`.
+ */
+function provideFakeAgent(config = {}) {
+    return provideAgent({
+        assistantId: 'fake',
+        transport: new FakeStreamTransport(config),
+    });
+}
+
 // SPDX-License-Identifier: MIT
 const LANGGRAPH_THREADS_CONFIG = new InjectionToken('LANGGRAPH_THREADS_CONFIG');
 /** Optional adapter clients can pass an explicit Client (e.g. for
@@ -2918,11 +3087,11 @@ function refreshOnTransition(watch, isActive, fn) {
 }
 
 // SPDX-License-Identifier: MIT
-// Primary function
+// Provider
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { AGENT_CONFIG, AGENT_LIFECYCLE, AgentLifecycleRegistry, FetchStreamTransport, LANGGRAPH_CLIENT, LANGGRAPH_THREADS_CONFIG, LangGraphThreadsAdapter, MockAgentTransport, ResourceStatus, agent, createLangGraphClient, extractCitations, mockLangGraphAgent, provideAgent, refreshOnRunEnd, refreshOnTransition, toAbsoluteApiUrl };
+export { AGENT_LIFECYCLE, AgentLifecycleRegistry, FakeStreamTransport, FetchStreamTransport, LANGGRAPH_CLIENT, LANGGRAPH_THREADS_CONFIG, LangGraphThreadsAdapter, MockAgentTransport, ResourceStatus, createLangGraphClient, extractCitations, injectAgent, mockLangGraphAgent, provideAgent, provideFakeAgent, refreshOnRunEnd, refreshOnTransition, toAbsoluteApiUrl };
 //# sourceMappingURL=threadplane-langgraph.mjs.map