@threadplane/ag-ui 0.0.47 → 0.0.50

package/fesm2022/threadplane-ag-ui.mjs

@@ -1,4 +1,4 @@
-import { signal, InjectionToken, inject } from '@angular/core';
+import { signal, computed, InjectionToken, inject } from '@angular/core';
 import { Subject, Observable } from 'rxjs';
 import { HttpAgent, AbstractAgent, EventType } from '@ag-ui/client';
 
@@ -259,6 +259,11 @@ function normalizeCitation(entry, fallbackIndex) {
     };
 }
 
+// SPDX-License-Identifier: MIT
+// @ag-ui/client@0.0.52 — EventType is a string enum with uppercase values.
+// Discriminator strings (e.g. 'RUN_STARTED') match EventType enum members
+// verbatim; the switch cases below use the string literals directly so this
+// file has no runtime dependency on the EventType enum import.
 /**
  * Per-message reasoning timing. Populated by REASONING_MESSAGE_START /
  * REASONING_MESSAGE_END handlers. The map lives on the module — same
@@ -288,6 +293,9 @@ function reduceEvent(event, store) {
             store.status.set('running');
             store.isLoading.set(true);
             store.error.set(null);
+            store.interrupt.set(undefined);
+            store.customEvents.set([]);
+            store.activities.set(new Map());
             return;
         }
         case 'RUN_FINISHED': {
@@ -358,22 +366,60 @@ function reduceEvent(event, store) {
                 ...prev,
                 { id: e.toolCallId, name: e.toolCallName, args: {}, status: 'running' },
             ]);
+            // Link the tool call to its parent assistant message so the chat lib's
+            // per-message tool-call resolution (chat-tool-calls / chat-tool-views)
+            // can scope it. ag-ui-langgraph emits parentMessageId for every tool
+            // call. If the parent assistant message hasn't been created yet (a
+            // tool-call-only turn emits no TEXT_MESSAGE_START), create a slot.
+            const parentId = e.parentMessageId;
+            if (parentId) {
+                store.messages.update((prev) => {
+                    const existing = prev.find((m) => m.id === parentId);
+                    if (existing) {
+                        return prev.map((m) => m.id === parentId
+                            ? { ...m, toolCallIds: [...(m.toolCallIds ?? []), e.toolCallId] }
+                            : m);
+                    }
+                    return [...prev, { id: parentId, role: 'assistant', content: '', toolCallIds: [e.toolCallId] }];
+                });
+            }
             return;
         }
         case 'TOOL_CALL_ARGS': {
             const e = event;
-            const args = safeParseArgs(e.delta);
-            store.toolCalls.update((prev) => prev.map((t) => t.id === e.toolCallId ? { ...t, args } : t));
+            // Deltas are FRAGMENTS of a JSON document, not standalone JSON: a live
+            // model streams args token-by-token (`{"loca`, `tion":"Pa`, …), so we
+            // accumulate the raw text and parse the accumulated buffer. Until the
+            // buffer parses, keep the last-good args (initially {}).
+            const buffers = (store.argsBuffers ??= new Map());
+            const buffer = (buffers.get(e.toolCallId) ?? '') + e.delta;
+            buffers.set(e.toolCallId, buffer);
+            const args = tryParseArgs(buffer);
+            if (args !== undefined) {
+                store.toolCalls.update((prev) => prev.map((t) => t.id === e.toolCallId ? { ...t, args } : t));
+            }
             return;
         }
         case 'TOOL_CALL_END': {
             const e = event;
-            store.toolCalls.update((prev) => prev.map((t) => t.id === e.toolCallId ? { ...t, status: 'complete' } : t));
+            // Belt and braces: apply the final accumulated args (in case the last
+            // ARGS delta arrived but an intermediate state was left unparsed), then
+            // drop the buffer.
+            const finalBuffer = store.argsBuffers?.get(e.toolCallId);
+            store.argsBuffers?.delete(e.toolCallId);
+            const finalArgs = finalBuffer !== undefined ? tryParseArgs(finalBuffer) : undefined;
+            store.toolCalls.update((prev) => prev.map((t) => t.id === e.toolCallId
+                ? { ...t, status: 'complete', ...(finalArgs !== undefined ? { args: finalArgs } : {}) }
+                : t));
             return;
         }
         case 'TOOL_CALL_RESULT': {
             const e = event;
-            store.toolCalls.update((prev) => prev.map((t) => t.id === e.toolCallId ? { ...t, result: e.content } : t));
+            // ag_ui_langgraph serialises tool results via normalize_tool_content()
+            // which always returns a string. Parse it so downstream consumers
+            // (chat-tool-views / toToolViewSpec) can spread the object into props.
+            const result = typeof e.content === 'string' ? safeParseJson(e.content) : e.content;
+            store.toolCalls.update((prev) => prev.map((t) => t.id === e.toolCallId ? { ...t, result } : t));
             return;
         }
         case 'STATE_SNAPSHOT': {
@@ -392,17 +438,87 @@ function reduceEvent(event, store) {
         }
         case 'MESSAGES_SNAPSHOT': {
             const e = event;
-            store.messages.set(e.messages ?? []);
+            const raw = e.messages ?? [];
+            // AG-UI AssistantMessage carries `toolCalls` (ToolCall objects) on the
+            // snapshot wire. Bridge them to `toolCallIds` so that the chat lib's
+            // per-message tool-call resolution (resolveMessageToolCalls) can scope
+            // correctly. Also merge any snapshot-only tool calls into store.toolCalls
+            // so the data is visible to <chat-tool-views>.
+            const snapshotToolCalls = [];
+            const messages = raw.map((m) => {
+                if (m.role !== 'assistant' || !m.toolCalls || m.toolCalls.length === 0) {
+                    return m;
+                }
+                const ids = [];
+                for (const tc of m.toolCalls) {
+                    ids.push(tc.id);
+                    snapshotToolCalls.push({
+                        id: tc.id,
+                        name: tc.function.name,
+                        args: safeParseArgs(tc.function.arguments),
+                        status: 'complete',
+                    });
+                }
+                const { toolCalls: _dropped, ...rest } = m;
+                return { ...rest, toolCallIds: ids };
+            });
+            store.messages.set(messages);
+            if (snapshotToolCalls.length > 0) {
+                store.toolCalls.update((prev) => {
+                    // Merge: keep existing entries (they may carry richer state from
+                    // streaming) and only insert entries not already present by id.
+                    const existingIds = new Set(prev.map((tc) => tc.id));
+                    const toAdd = snapshotToolCalls.filter((tc) => !existingIds.has(tc.id));
+                    return toAdd.length > 0 ? [...prev, ...toAdd] : prev;
+                });
+            }
             return;
         }
         case 'CUSTOM': {
             const e = event;
-            if (e.name === 'state_update' && isRecord(e.value)) {
-                store.events$.next({ type: 'state_update', data: e.value });
+            // ag_ui_langgraph serializes interrupt payloads as JSON strings.
+            // Parse the value if it arrives as a string so downstream consumers
+            // (e.g. ChatApprovalCardComponent) receive a plain object, not a string.
+            const parsedValue = typeof e.value === 'string' ? safeParseJson(e.value) : e.value;
+            if (e.name === 'on_interrupt') {
+                store.interrupt.set({ id: randomId$1(), value: parsedValue, resumable: true });
+                return;
+            }
+            // Surface every other custom event on the customEvents signal so the
+            // chat a2ui partial-args bridge (which reads agent.customEvents()) lights
+            // up live/progressive a2ui rendering — parity with the LangGraph adapter.
+            store.customEvents.update((prev) => [...prev, { name: e.name, data: parsedValue }]);
+            if (e.name === 'state_update' && isRecord(parsedValue)) {
+                store.events$.next({ type: 'state_update', data: parsedValue });
+            }
+            else {
+                store.events$.next({ type: 'custom', name: e.name, data: parsedValue });
+            }
+            return;
+        }
+        case 'ACTIVITY_SNAPSHOT': {
+            const e = event;
+            const map = new Map(store.activities());
+            const existing = map.get(e.messageId);
+            if (existing && existing.activityType === e.activityType && !e.replace) {
+                existing.content.update((c) => ({ ...c, ...e.content }));
             }
             else {
-                store.events$.next({ type: 'custom', name: e.name, data: e.value });
+                map.set(e.messageId, {
+                    messageId: e.messageId,
+                    activityType: e.activityType,
+                    content: signal(e.content ?? {}),
+                });
             }
+            store.activities.set(map); // new ref → projection picks up membership change
+            return;
+        }
+        case 'ACTIVITY_DELTA': {
+            const e = event;
+            const entry = store.activities().get(e.messageId);
+            if (!entry)
+                return; // unknown activity — ignore
+            entry.content.update((c) => applyPatch(c, e.patch)); // inner signal → live, no map churn
             return;
         }
         default: {
@@ -413,6 +529,9 @@ function reduceEvent(event, store) {
         }
     }
 }
+function randomId$1() {
+    return Math.random().toString(36).slice(2);
+}
 function messageIdFrom(event) {
     return event.messageId ?? 'unknown';
 }
@@ -425,6 +544,26 @@ function safeParseArgs(delta) {
         return {};
     }
 }
+/** Parse an (accumulated) args buffer; `undefined` when it isn't valid JSON
+ *  yet — callers keep the previous args rather than clobbering them with {}. */
+function tryParseArgs(buffer) {
+    try {
+        const parsed = JSON.parse(buffer);
+        return isRecord(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Parse a JSON string to its value; return the original string on failure. */
+function safeParseJson(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return s;
+    }
+}
 function isRecord(v) {
     return typeof v === 'object' && v !== null && !Array.isArray(v);
 }
@@ -432,6 +571,93 @@ function deepClone(v) {
     return JSON.parse(JSON.stringify(v));
 }
 
+// SPDX-License-Identifier: MIT
+/** Convert a ClientToolSpec to the AG-UI Tool wire shape. */
+function toAgUiTool(spec) {
+    return { name: spec.name, description: spec.description, parameters: spec.parameters };
+}
+/** Serialize a tool result value to a string for the ToolMessage content. */
+function safeStringify(v) {
+    return typeof v === 'string' ? v : JSON.stringify(v);
+}
+/**
+ * Creates a ClientToolsCapability backed by an AG-UI source agent and a
+ * ReducerStore. Extracted into a factory so it can be unit-tested in isolation
+ * without standing up a full Angular DI environment.
+ *
+ * The capability:
+ *  - Maintains a catalog of client tool specs (setCatalog).
+ *  - Exposes a `pending` computed signal: tool calls whose name is in the catalog,
+ *    have no backend result, and haven't been resolved client-side yet — but ONLY
+ *    when the run is not in progress (isLoading===false). The backend ends the run
+ *    without emitting TOOL_CALL_RESULT for client tools, so result stays undefined.
+ *  - resolve(id, result): marks the call as resolved, writes the outcome onto
+ *    the local ToolCall in the store (so the transcript freezes: the mounted
+ *    ask component re-renders with its emitted value as props and can branch to
+ *    a frozen state), adds a ToolMessage via source.addMessage, then re-runs
+ *    the agent with the catalog tools attached.
+ *
+ * Call catalogAsAgUiTools() to get the current catalog as AG-UI Tool[] for
+ * threading into runAgent().
+ */
+function createClientToolsCapability(source, store) {
+    const catalog = signal([], ...(ngDevMode ? [{ debugName: "catalog" }] : []));
+    const resolvedIds = signal(new Set(), ...(ngDevMode ? [{ debugName: "resolvedIds" }] : []));
+    function catalogAsAgUiTools() {
+        return catalog().map(toAgUiTool);
+    }
+    const clientTools = {
+        setCatalog(specs) {
+            catalog.set([...specs]);
+        },
+        pending: computed(() => {
+            // Client tools are only actionable after the run ends (backend signals it
+            // by ending the run WITHOUT emitting TOOL_CALL_RESULT for client tools).
+            if (store.isLoading())
+                return [];
+            const names = new Set(catalog().map((s) => s.name));
+            const done = resolvedIds();
+            return store.toolCalls().filter((tc) => names.has(tc.name) && tc.result === undefined && !done.has(tc.id));
+        }),
+        resolve(id, result) {
+            // Mark as resolved first so pending() drops it immediately.
+            resolvedIds.update((s) => new Set(s).add(id));
+            // Write the outcome onto the LOCAL ToolCall in the store. The client tool
+            // DID produce a result client-side, so this is semantically correct — and
+            // it freezes the transcript card: toToolViewSpec spreads `{...args,
+            // ...result, status}` into the mounted ask component, so the component
+            // re-renders with its own emitted value as props and can branch to a
+            // resolved/frozen state. The backend ToolMessage never reaches this local
+            // ToolCall, so without this write the card stays interactive forever.
+            const ok = result.ok;
+            const value = result.value;
+            const error = result.error;
+            store.toolCalls.update((calls) => calls.map((tc) => tc.id === id
+                ? {
+                    ...tc,
+                    result: ok ? value : { error },
+                    ...(ok ? {} : { error, status: 'error' }),
+                }
+                : tc));
+            // Cast rather than rely on discriminant narrowing: consumer apps that
+            // compile this source with `strictNullChecks: false` don't narrow the
+            // ClientToolResult union in a ternary.
+            const content = ok
+                ? safeStringify(value)
+                : `Error: ${error}`;
+            source.addMessage({
+                id: `tool-${id}`,
+                role: 'tool',
+                toolCallId: id,
+                content,
+            });
+            void source.runAgent({ tools: catalogAsAgUiTools() });
+        },
+        catalogAsAgUiTools,
+    };
+    return clientTools;
+}
+
 // SPDX-License-Identifier: MIT
 function captureAgentRuntimeTelemetry(sink, event, properties) {
     if (!sink)
@@ -477,10 +703,71 @@ function toAgent(source, options = {}) {
         error: signal(null),
         toolCalls: signal([]),
         state: signal({}),
+        interrupt: signal(undefined),
         events$: new Subject(),
+        customEvents: signal([]),
+        activities: signal(new Map()),
     };
     const telemetryProperties = { transport: 'ag-ui', surface: 'to_agent' };
     let activeRun = null;
+    // Set by stop(); lets run-failure handlers distinguish a user-initiated
+    // abort (graceful cancel) from a genuine stream failure.
+    let abortRequested = false;
+    // Set to true the first time settleIfAborted() handles an abort error for the
+    // current run. The AG-UI client can surface the same abort via both the event
+    // stream (RUN_ERROR event) AND onRunFailed — abortSettled lets the second
+    // delivery see through as a no-op rather than re-writing store state or
+    // triggering a real error path. Both flags are reset together at the top of
+    // submit() so the next run starts clean.
+    let abortSettled = false;
+    function isAbortError(error) {
+        return error instanceof Error
+            && (error.name === 'AbortError' || /abort/i.test(error.message));
+    }
+    /** Settles the store as idle for stop()-induced failures; returns true if handled. */
+    function settleIfAborted(error) {
+        // If we already settled this abort (duplicate delivery — e.g. RUN_ERROR
+        // event THEN onRunFailed), defensively re-apply the idle settle so any
+        // state written between the two deliveries (e.g. RUN_STARTED from a new
+        // run that started before flags were reset) is corrected. Telemetry is
+        // not re-emitted — the guard returns true to suppress further processing.
+        if (abortSettled && isAbortError(error)) {
+            store.status.set('idle');
+            store.isLoading.set(false);
+            return true;
+        }
+        if (!abortRequested || !isAbortError(error))
+            return false;
+        abortRequested = false;
+        abortSettled = true;
+        store.status.set('idle');
+        store.isLoading.set(false);
+        // Not a failure: leave store.error null and close out telemetry as a
+        // normal finish so the aborted run doesn't count as errored.
+        const run = activeRun;
+        if (run) {
+            finishRunTelemetry(run);
+            // Mark errored so any subsequent finishRunTelemetry/failRunTelemetry
+            // call on the same run object (e.g. from submit's try block resolving
+            // after the abort) is a no-op — telemetry fires at most once per run.
+            run.errored = true;
+        }
+        return true;
+    }
+    // Build the client-tools capability. catalogAsAgUiTools() is used below to
+    // thread the catalog into every runAgent() call.
+    const clientToolsCap = createClientToolsCapability(source, store);
+    /** Forward a neutral-contract state patch onto the AG-UI run input.
+     *  Mirrors the canonical demo's `input.state` mechanism: the patch is
+     *  merged into the source agent's client state (carried on
+     *  RunAgentInput.state) and reflected optimistically in the local
+     *  state signal — the server's next STATE_SNAPSHOT stays authoritative. */
+    const applyStatePatch = (patch) => {
+        if (!patch || Object.keys(patch).length === 0)
+            return;
+        source.state = { ...(source.state ?? {}), ...patch };
+        store.state.update((prev) => ({ ...prev, ...patch }));
+    };
     captureAgentRuntimeTelemetry(options.telemetry, 'ngaf:runtime_instance_created', telemetryProperties);
     function startRunTelemetry(requestType) {
         const run = { startedAt: Date.now(), errored: false };
@@ -518,15 +805,44 @@ function toAgent(source, options = {}) {
     // This subscription lives for the lifetime of `source`.
     source.subscribe({
         onEvent({ event }) {
+            // The AG-UI client surfaces a user-initiated abort both as a
+            // RUN_ERROR event (here) and via onRunFailed; guard the event path too
+            // so the reducer never marks a deliberate stop as an error.
+            if (event.type === 'RUN_ERROR') {
+                const message = event.message ?? '';
+                if (settleIfAborted(new Error(message)))
+                    return;
+            }
             reduceEvent(event, store);
         },
         onRunFailed({ error }) {
+            if (settleIfAborted(error))
+                return;
             store.status.set('error');
             store.isLoading.set(false);
             store.error.set(error);
             failRunTelemetry(error);
         },
     });
+    // Stable Subagent wrappers per messageId so chat-subagents (tracks by
+    // toolCallId) doesn't churn as activity content streams.
+    const subagentWrappers = new Map();
+    function subagentFor(id, entry) {
+        let w = subagentWrappers.get(id);
+        if (!w) {
+            w = {
+                toolCallId: entry.content()['toolCallId'] ?? id,
+                name: entry.content()['name'],
+                status: computed(() => entry.content()['status'] ?? 'running'),
+                messages: computed(() => [
+                    { id, role: 'assistant', content: String(entry.content()['text'] ?? '') },
+                ]),
+                state: computed(() => entry.content()['state'] ?? {}),
+            };
+            subagentWrappers.set(id, w);
+        }
+        return w;
+    }
     return {
         messages: store.messages,
         status: store.status,
@@ -534,8 +850,56 @@ function toAgent(source, options = {}) {
         error: store.error,
         toolCalls: store.toolCalls,
         state: store.state,
+        interrupt: store.interrupt,
         events$: store.events$.asObservable(),
+        customEvents: store.customEvents,
+        subagents: computed(() => {
+            const out = new Map();
+            for (const [id, entry] of store.activities()) {
+                if (entry.activityType !== 'subagent')
+                    continue;
+                out.set(id, subagentFor(id, entry));
+            }
+            // Prune stale wrappers: keeps the cache bounded and prevents a reused
+            // tool-call-id from binding to an orphaned (pre-RUN_STARTED) content signal.
+            for (const id of subagentWrappers.keys()) {
+                if (!out.has(id))
+                    subagentWrappers.delete(id);
+            }
+            return out;
+        }),
+        clientTools: clientToolsCap,
         submit: async (input, _opts) => {
+            // Reset both abort flags so a new submit starts clean and genuine
+            // failures after a previous stop are never swallowed.
+            abortRequested = false;
+            abortSettled = false;
+            if (input.resume !== undefined) {
+                // Resume path: clear the pending interrupt and replay the run with the
+                // resume payload forwarded to the LangGraph backend via AG-UI's
+                // forwardedProps.command.resume mechanism.
+                applyStatePatch(input.state);
+                store.interrupt.set(undefined);
+                const run = startRunTelemetry('resume');
+                const tools = clientToolsCap.catalogAsAgUiTools();
+                try {
+                    await source.runAgent({
+                        forwardedProps: { command: { resume: input.resume } },
+                        ...(tools.length > 0 ? { tools } : {}),
+                    });
+                    finishRunTelemetry(run);
+                }
+                catch (err) {
+                    if (!settleIfAborted(err)) {
+                        store.status.set('error');
+                        store.isLoading.set(false);
+                        store.error.set(err);
+                        failRunTelemetry(err, run);
+                    }
+                }
+                return;
+            }
+            applyStatePatch(input.state);
             // Optimistic append of user message to our signals and to the source
             // agent's own message list so runAgent() sees the new message.
             const userMsg = buildUserMessage(input);
@@ -545,26 +909,34 @@ function toAgent(source, options = {}) {
                 source.addMessage(userMsg);
             }
             const run = startRunTelemetry('submit');
+            const tools = clientToolsCap.catalogAsAgUiTools();
             try {
-                await source.runAgent();
+                await source.runAgent(tools.length > 0 ? { tools } : undefined);
                 finishRunTelemetry(run);
             }
             catch (err) {
-                // If the run was aborted via stop(), abortRun() resolves the promise
-                // rather than rejecting — but catch any unexpected errors here.
-                store.status.set('error');
-                store.isLoading.set(false);
-                store.error.set(err);
-                failRunTelemetry(err, run);
+                if (!settleIfAborted(err)) {
+                    store.status.set('error');
+                    store.isLoading.set(false);
+                    store.error.set(err);
+                    failRunTelemetry(err, run);
+                }
             }
         },
         stop: async () => {
+            abortRequested = true;
             source.abortRun();
         },
         regenerate: async (assistantMessageIndex) => {
             if (store.isLoading()) {
                 throw new Error('Cannot regenerate while agent is loading another response');
             }
+            // Reset abort flags so a regenerate starts clean, exactly like submit().
+            // Without this, flags left over from a prior stop() would cause the
+            // duplicate-delivery guard in settleIfAborted() to silently swallow the
+            // abort error without settling, wedging the store in streaming/running.
+            abortRequested = false;
+            abortSettled = false;
             const msgs = store.messages();
             const target = msgs[assistantMessageIndex];
             if (!target || target.role !== 'assistant') {
@@ -591,15 +963,18 @@ function toAgent(source, options = {}) {
             // message in `trimmed` becomes the active prompt for the next run.
             source.setMessages(trimmed);
             const run = startRunTelemetry('regenerate');
+            const regenTools = clientToolsCap.catalogAsAgUiTools();
             try {
-                await source.runAgent();
+                await source.runAgent(regenTools.length > 0 ? { tools: regenTools } : undefined);
                 finishRunTelemetry(run);
             }
             catch (err) {
-                store.status.set('error');
-                store.isLoading.set(false);
-                store.error.set(err);
-                failRunTelemetry(err, run);
+                if (!settleIfAborted(err)) {
+                    store.status.set('error');
+                    store.isLoading.set(false);
+                    store.error.set(err);
+                    failRunTelemetry(err, run);
+                }
             }
         },
     };
@@ -617,18 +992,31 @@ function randomId() {
 }
 
 // SPDX-License-Identifier: MIT
-const AG_UI_AGENT = new InjectionToken('AG_UI_AGENT');
+/**
+ * @internal — exported for spec access only. Consumers must use injectAgent().
+ * Both `provideAgent` and `provideFakeAgent` register the result of `toAgent()`,
+ * which is always an `AgUiAgent`, so the token is typed accordingly.
+ */
+const AGENT = new InjectionToken('AGENT');
 /**
  * Provides an Agent instance wired through HttpAgent and toAgent.
  * Constructs an HttpAgent from config and wraps it in the runtime-neutral
  * Agent contract via toAgent(). Returns a provider array suitable for
  * bootstrapApplication or TestBed.configureTestingModule().
+ *
+ * **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 or route params.
  */
-function provideAgUiAgent(config) {
+function provideAgent(configOrFactory) {
     return [
         {
-            provide: AG_UI_AGENT,
+            provide: AGENT,
             useFactory: () => {
+                // useFactory runs in an injection context, so a config factory may
+                // call inject() to read runtime/DI state.
+                const config = typeof configOrFactory === 'function' ? configOrFactory() : configOrFactory;
                 const source = new HttpAgent({
                     url: config.url,
                     ...(config.agentId !== undefined ? { agentId: config.agentId } : {}),
@@ -641,11 +1029,16 @@ function provideAgUiAgent(config) {
     ];
 }
 /**
- * Injects the AG_UI_AGENT from Angular's dependency injection container.
- * Use this in components or services that have been provided via provideAgUiAgent().
+ * Injects the AG-UI agent from Angular's dependency injection container.
+ * Use this in components or services provided via `provideAgent()` (or
+ * `provideFakeAgent()`).
+ *
+ * Returns an `AgUiAgent` — the runtime-neutral `Agent` contract plus the
+ * AG-UI-specific `customEvents` signal — so `customEvents` is reachable
+ * directly, without casting.
  */
-function injectAgUiAgent() {
-    return inject(AG_UI_AGENT);
+function injectAgent() {
+    return inject(AGENT);
 }
 
 // libs/ag-ui/src/lib/testing/fake-agent.ts
@@ -725,15 +1118,15 @@ class FakeAgent extends AbstractAgent {
 }
 
 /**
- * Registers an in-process FakeAgent under AG_UI_AGENT.
+ * Registers an in-process FakeAgent under AGENT.
  *
  * Use for offline demos and development. Drop-in replacement for
- * provideAgUiAgent({ url }) when no real backend is available.
+ * provideAgent({ url }) when no real backend is available.
  */
-function provideFakeAgUiAgent(config = {}) {
+function provideFakeAgent(config = {}) {
     return [
         {
-            provide: AG_UI_AGENT,
+            provide: AGENT,
             useFactory: () => toAgent(new FakeAgent(config)),
         },
     ];
@@ -745,5 +1138,5 @@ function provideFakeAgUiAgent(config = {}) {
  * Generated bundle index. Do not edit.
  */
 
-export { AG_UI_AGENT, FakeAgent, bridgeCitationsState, injectAgUiAgent, provideAgUiAgent, provideFakeAgUiAgent, toAgent };
+export { FakeAgent, bridgeCitationsState, injectAgent, provideAgent, provideFakeAgent, toAgent };
 //# sourceMappingURL=threadplane-ag-ui.mjs.map