@threadplane/langgraph 0.0.46

package/fesm2022/threadplane-langgraph.mjs

@@ -0,0 +1,2928 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, signal, Injectable, inject, DestroyRef, isSignal, computed, effect } 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 };
+}
+
+// SPDX-License-Identifier: MIT
+/**
+ * Optional registry that collects per-instance agent lifecycles within
+ * an Angular injection context. External instrumentation packages
+ * (e.g. cockpit-telemetry) provide this token and read from it.
+ *
+ * `@threadplane/langgraph` does NOT provide this itself — `agent()` writes to
+ * the registry only when an external consumer has provided it.
+ */
+class AgentLifecycleRegistry {
+    _lifecycles = signal([], ...(ngDevMode ? [{ debugName: "_lifecycles" }] : []));
+    /** Reactive list of registered lifecycles. */
+    lifecycles = this._lifecycles.asReadonly();
+    register(lifecycle) {
+        this._lifecycles.update((curr) => [...curr, lifecycle]);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.6", ngImport: i0, type: AgentLifecycleRegistry, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.6", ngImport: i0, type: AgentLifecycleRegistry });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.6", ngImport: i0, type: AgentLifecycleRegistry, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Runtime constant mirroring Angular's ResourceStatus string-union type.
+ * Angular 21 ships ResourceStatus as a pure string-union type (no runtime value),
+ * so we provide a const-object shim for code that needs runtime comparisons.
+ */
+const ResourceStatus = {
+    Idle: 'idle',
+    Loading: 'loading',
+    Reloading: 'reloading',
+    Resolved: 'resolved',
+    Error: 'error',
+    Local: 'local',
+};
+
+// SPDX-License-Identifier: MIT
+/**
+ * Construct a LangGraph SDK Client that accepts both absolute URLs
+ * (`http://localhost:2024`) and relative `/api`-style paths that get
+ * proxied by middleware in production. The SDK itself rejects
+ * relative URLs, so this helper rewrites them against
+ * `window.location.origin` when running in the browser.
+ *
+ * Single source of truth for the absolute-URL rewrite — the streaming
+ * transport (`fetch-stream.transport.ts`) and the threads adapter
+ * (`LangGraphThreadsAdapter`) both go through here.
+ *
+ * @example
+ * ```ts
+ * const client = createLangGraphClient(environment.langGraphApiUrl);
+ * const threads = await client.threads.search({ limit: 50 });
+ * ```
+ */
+function createLangGraphClient(apiUrl) {
+    return new Client({ apiUrl: toAbsoluteApiUrl(apiUrl) });
+}
+/** Exported separately so non-Client callers (e.g. raw fetch) can
+ *  share the same normalization logic. */
+function toAbsoluteApiUrl(apiUrl) {
+    if (apiUrl.startsWith('http://') || apiUrl.startsWith('https://'))
+        return apiUrl;
+    return typeof window !== 'undefined' ? `${window.location.origin}${apiUrl}` : apiUrl;
+}
+
+/**
+ * Production transport that connects to a LangGraph Platform API via HTTP and SSE.
+ *
+ * Creates threads automatically if no threadId is provided, and streams events
+ * using the LangGraph SDK client.
+ *
+ * @example
+ * ```typescript
+ * const transport = new FetchStreamTransport(
+ *   'http://localhost:2024',
+ *   (id) => console.log('New thread:', id),
+ * );
+ * ```
+ */
+class FetchStreamTransport {
+    client;
+    onThreadId;
+    /**
+     * @param apiUrl - Base URL of the LangGraph Platform API
+     * @param onThreadId - Optional callback invoked when a new thread is created
+     */
+    constructor(apiUrl, onThreadId) {
+        // createLangGraphClient handles the absolute-URL normalization
+        // required by the SDK when `apiUrl` is a relative `/api`-style
+        // path proxied by middleware in production.
+        this.client = createLangGraphClient(apiUrl);
+        this.onThreadId = onThreadId;
+    }
+    /** Open a streaming connection, creating a thread if needed. */
+    async *stream(assistantId, threadId, payload, signal, options) {
+        let thread = threadId;
+        if (!thread) {
+            const t = await this.client.threads.create();
+            thread = t.thread_id;
+            this.onThreadId?.(thread);
+        }
+        const run = this.client.runs.stream(thread, assistantId, buildRunPayload(payload, signal, options));
+        for await (const event of run) {
+            yield normalizeSdkEvent(event.event, event.data);
+        }
+    }
+    /** Join an already-started run without creating a new thread. */
+    async *joinStream(threadId, runId, lastEventId, signal) {
+        // SDK joinStream: joins an already-started run without creating a new one.
+        const run = this.client.runs.joinStream(threadId, runId, {
+            signal,
+            ...(lastEventId !== undefined ? { lastEventId } : {}),
+        });
+        for await (const event of run) {
+            yield normalizeSdkEvent(event.event, event.data);
+        }
+    }
+    /** Create a pending server-side run using LangGraph's enqueue strategy. */
+    async createQueuedRun(assistantId, threadId, payload, signal, options) {
+        const run = await this.client.runs.create(threadId, assistantId, {
+            ...buildRunPayload(payload, signal, options),
+            multitaskStrategy: 'enqueue',
+        });
+        return {
+            id: run.run_id,
+            threadId: run.thread_id ?? threadId,
+            values: payload,
+            options: { multitaskStrategy: 'enqueue', signal },
+            createdAt: run.created_at ? new Date(run.created_at) : new Date(),
+        };
+    }
+    /** Cancel a server-side run. */
+    async cancelRun(threadId, runId, signal) {
+        await this.client.runs.cancel(threadId, runId, false, 'interrupt', { signal });
+    }
+    /** Load persisted checkpoint history for a thread. */
+    async getHistory(threadId, signal) {
+        return this.client.threads.getHistory(threadId, { signal });
+    }
+    /** Update server-side thread state, e.g. to remove messages for regenerate rollback. */
+    async updateState(threadId, values, _signal, options) {
+        const body = { values };
+        if (options?.asNode !== undefined) {
+            body.asNode = options.asNode;
+        }
+        await this.client.threads.updateState(threadId, body);
+    }
+}
+function buildRunPayload(input, signal, options) {
+    const runOptions = { ...(options ?? {}) };
+    const hasCheckpoint = Object.prototype.hasOwnProperty.call(runOptions, 'checkpoint');
+    const checkpoint = runOptions.checkpoint;
+    const streamMode = runOptions.streamMode;
+    const streamSubgraphs = runOptions.streamSubgraphs;
+    delete runOptions.signal;
+    delete runOptions.resume;
+    delete runOptions.checkpoint;
+    delete runOptions.streamMode;
+    delete runOptions.streamSubgraphs;
+    return {
+        ...runOptions,
+        ...(hasCheckpoint ? { checkpoint } : {}),
+        input: input,
+        streamMode: streamMode ?? defaultStreamMode(),
+        streamSubgraphs: streamSubgraphs ?? true,
+        signal,
+    };
+}
+function defaultStreamMode() {
+    // 'tools' is intentionally omitted: not supported by langgraph_api < 0.9.x
+    // Servers reject the entire request with HTTP 422 if any stream_mode in
+    // the array is unknown to them. Tool-call data is still derivable from
+    // the messages stream.
+    return ['values', 'messages-tuple', 'updates', 'custom'];
+}
+function normalizeSdkEvent(type, data) {
+    const namespace = extractNamespace(type);
+    const baseType = getBaseEventType$1(type);
+    if (baseType === 'messages' && Array.isArray(data) && data.length === 2 && isRecord$2(data[1])) {
+        return { type, ...(namespace ? { namespace } : {}), messages: [data[0]], messageMetadata: data[1], data };
+    }
+    if (isMessagesEvent$1(type) && Array.isArray(data)) {
+        return { type, ...(namespace ? { namespace } : {}), messages: data, data };
+    }
+    if (isRecord$2(data)) {
+        return { type, ...(namespace ? { namespace } : {}), ...data, data };
+    }
+    return { type, ...(namespace ? { namespace } : {}), data };
+}
+function isMessagesEvent$1(type) {
+    const baseType = getBaseEventType$1(type);
+    return baseType === 'messages' || baseType.startsWith('messages/');
+}
+function getBaseEventType$1(type) {
+    return String(type).split('|')[0];
+}
+function extractNamespace(type) {
+    const parts = String(type).split('|');
+    return parts.length > 1 ? parts.slice(1) : undefined;
+}
+function isRecord$2(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+const DEFAULT_SUBAGENT_TOOL_NAMES = ['task'];
+/**
+ * Lightweight Angular adapter for LangGraph subagent stream state.
+ *
+ * This intentionally mirrors only the SDK behavior this package exposes. Using
+ * the SDK UI barrel at runtime pulls StreamManager/client utilities into every
+ * Angular bundle, which breaks cockpit production budgets.
+ */
+class SubagentTracker {
+    subagentToolNames;
+    onSubagentChange;
+    subagents = new Map();
+    namespaceToToolCallId = new Map();
+    pendingMatches = new Map();
+    constructor(options = {}) {
+        this.subagentToolNames = new Set(options.subagentToolNames ?? DEFAULT_SUBAGENT_TOOL_NAMES);
+        this.onSubagentChange = options.onSubagentChange;
+    }
+    clear() {
+        this.subagents.clear();
+        this.namespaceToToolCallId.clear();
+        this.pendingMatches.clear();
+        this.onSubagentChange?.();
+    }
+    getSubagents() {
+        const visible = new Map();
+        for (const [id, subagent] of this.subagents) {
+            if (subagent.status !== 'pending') {
+                visible.set(id, subagent);
+            }
+        }
+        return visible;
+    }
+    registerFromToolCalls(toolCalls, aiMessageId) {
+        let changed = false;
+        for (const toolCall of toolCalls) {
+            if (!this.subagentToolNames.has(toolCall.name))
+                continue;
+            const id = toolCall.id;
+            if (!id)
+                continue;
+            const args = parseToolCallArgs(toolCall.args);
+            if (!isValidSubagentType(args['subagent_type']))
+                continue;
+            const existing = this.subagents.get(id);
+            this.subagents.set(id, {
+                id,
+                status: existing?.status ?? 'pending',
+                toolCall: {
+                    id,
+                    name: toolCall.name,
+                    args: {
+                        ...args,
+                        ...(aiMessageId ? { _aiMessageId: aiMessageId } : {}),
+                    },
+                },
+                values: existing?.values ?? {},
+                messages: existing?.messages ?? [],
+            });
+            changed = true;
+        }
+        if (changed) {
+            this.retryPendingMatches();
+            this.onSubagentChange?.();
+        }
+    }
+    reconstructFromMessages(messages, options = {}) {
+        if (options.skipIfPopulated && this.subagents.size > 0)
+            return;
+        for (const message of messages) {
+            const raw = message;
+            if (isAiMessageWithToolCalls$1(raw)) {
+                this.registerFromToolCalls(raw['tool_calls'], typeof raw['id'] === 'string' ? raw['id'] : null);
+            }
+            else if (isToolMessage$1(raw)) {
+                this.processToolMessage(raw['tool_call_id'], raw['content'], raw['status'] === 'error' ? 'error' : 'success');
+            }
+        }
+    }
+    matchSubgraphToSubagent(namespaceId, description) {
+        if (this.namespaceToToolCallId.has(namespaceId)) {
+            return this.namespaceToToolCallId.get(namespaceId);
+        }
+        const mapped = new Set(this.namespaceToToolCallId.values());
+        const establish = (toolCallId) => {
+            this.namespaceToToolCallId.set(namespaceId, toolCallId);
+            const subagent = this.subagents.get(toolCallId);
+            if (subagent) {
+                this.subagents.set(toolCallId, {
+                    ...subagent,
+                    status: subagent.status === 'complete' || subagent.status === 'error' ? subagent.status : 'running',
+                });
+            }
+            this.onSubagentChange?.();
+            return toolCallId;
+        };
+        for (const [toolCallId, subagent] of this.subagents) {
+            if (mapped.has(toolCallId))
+                continue;
+            if (subagent.toolCall.args['description'] === description) {
+                return establish(toolCallId);
+            }
+        }
+        for (const [toolCallId, subagent] of this.subagents) {
+            if (mapped.has(toolCallId))
+                continue;
+            const subagentDescription = subagent.toolCall.args['description'];
+            if (typeof subagentDescription !== 'string' || !subagentDescription)
+                continue;
+            if (description.includes(subagentDescription) || subagentDescription.includes(description)) {
+                return establish(toolCallId);
+            }
+        }
+        for (const [toolCallId, subagent] of this.subagents) {
+            if (!mapped.has(toolCallId) && (subagent.status === 'pending' || subagent.status === 'running')) {
+                return establish(toolCallId);
+            }
+        }
+        if (description) {
+            this.pendingMatches.set(namespaceId, description);
+        }
+        return undefined;
+    }
+    markRunningFromNamespace(namespaceId, namespace) {
+        const toolCallId = this.resolveToolCallId(namespaceId);
+        const subagent = this.subagents.get(toolCallId);
+        if (!subagent)
+            return;
+        if (!this.namespaceToToolCallId.has(namespaceId)) {
+            this.namespaceToToolCallId.set(namespaceId, toolCallId);
+        }
+        this.subagents.set(toolCallId, {
+            ...subagent,
+            status: subagent.status === 'complete' || subagent.status === 'error' ? subagent.status : 'running',
+            values: {
+                ...subagent.values,
+                ...(namespace ? { namespace } : {}),
+            },
+        });
+        this.onSubagentChange?.();
+    }
+    updateSubagentValues(namespaceId, values) {
+        const toolCallId = this.resolveToolCallId(namespaceId);
+        const subagent = this.subagents.get(toolCallId);
+        if (!subagent)
+            return;
+        this.subagents.set(toolCallId, {
+            ...subagent,
+            status: subagent.status === 'complete' || subagent.status === 'error' ? subagent.status : 'running',
+            values,
+        });
+        this.onSubagentChange?.();
+    }
+    addMessageToSubagent(namespaceId, message) {
+        const toolCallId = this.resolveToolCallId(namespaceId);
+        const subagent = this.subagents.get(toolCallId);
+        if (!subagent)
+            return;
+        this.subagents.set(toolCallId, {
+            ...subagent,
+            status: subagent.status === 'complete' || subagent.status === 'error' ? subagent.status : 'running',
+            messages: mergeMessages$1(subagent.messages, [message]),
+        });
+        this.onSubagentChange?.();
+    }
+    processToolMessage(toolCallId, content, status) {
+        const subagent = this.subagents.get(toolCallId);
+        if (!subagent)
+            return;
+        this.subagents.set(toolCallId, {
+            ...subagent,
+            status: status === 'error' ? 'error' : 'complete',
+            values: {
+                ...subagent.values,
+                result: content,
+            },
+        });
+        this.onSubagentChange?.();
+    }
+    retryPendingMatches() {
+        for (const [namespaceId, description] of this.pendingMatches) {
+            if (this.matchSubgraphToSubagent(namespaceId, description)) {
+                this.pendingMatches.delete(namespaceId);
+            }
+        }
+    }
+    resolveToolCallId(namespaceId) {
+        return this.namespaceToToolCallId.get(namespaceId) ?? namespaceId;
+    }
+}
+function isSubagentNamespace(namespace) {
+    if (!namespace)
+        return false;
+    if (typeof namespace === 'string')
+        return namespace.includes('tools:');
+    return namespace.some(segment => segment.startsWith('tools:'));
+}
+function extractToolCallIdFromNamespace(namespace) {
+    if (!namespace)
+        return undefined;
+    for (const segment of namespace) {
+        if (segment.startsWith('tools:'))
+            return segment.slice(6);
+    }
+    return undefined;
+}
+function parseToolCallArgs(args) {
+    if (typeof args !== 'string')
+        return args;
+    try {
+        const parsed = JSON.parse(args);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+function isValidSubagentType(value) {
+    return typeof value === 'string'
+        && value.length >= 3
+        && value.length <= 50
+        && /^[a-zA-Z][a-zA-Z0-9_-]*$/.test(value);
+}
+function isAiMessageWithToolCalls$1(value) {
+    return (value['type'] === 'ai' || value['type'] === 'assistant')
+        && Array.isArray(value['tool_calls']);
+}
+function isToolMessage$1(value) {
+    return value['type'] === 'tool' && typeof value['tool_call_id'] === 'string';
+}
+function mergeMessages$1(existing, incoming) {
+    const merged = [...existing];
+    for (const msg of incoming) {
+        const id = getMessageId(msg);
+        const idx = id ? merged.findIndex(m => getMessageId(m) === id) : -1;
+        if (idx >= 0) {
+            merged[idx] = msg;
+        }
+        else {
+            merged.push(msg);
+        }
+    }
+    return merged;
+}
+function getMessageId(message) {
+    return message.id;
+}
+
+// SPDX-License-Identifier: MIT
+// Local copy of the trace harness — same gating as @threadplane/chat's trace.ts.
+// Duplicated here to avoid an @threadplane/chat dep on the langgraph internals path.
+function isLgTraceEnabled() {
+    if (typeof globalThis === 'undefined')
+        return false;
+    const win = globalThis.window;
+    if (!win)
+        return false;
+    if (win.__threadplaneChatTrace === true)
+        return true;
+    try {
+        return win.localStorage?.getItem('THREADPLANE_CHAT_STREAM_TRACE') === '1';
+    }
+    catch {
+        return false;
+    }
+}
+function lgTrace(...args) {
+    if (isLgTraceEnabled()) {
+        // eslint-disable-next-line no-console
+        console.debug('[ngaf-chat-stream]', ...args);
+    }
+}
+function captureAgentRuntimeTelemetry(sink, event, properties) {
+    if (!sink)
+        return;
+    try {
+        void Promise.resolve(sink({ event, properties })).catch(() => undefined);
+    }
+    catch {
+        // Keep telemetry side effects isolated from stream control flow.
+    }
+}
+function agentRuntimeTelemetryErrorClass(error) {
+    if (error instanceof Error)
+        return error.name || error.constructor.name || 'Error';
+    if (error
+        && typeof error === 'object'
+        && 'name' in error
+        && typeof error.name === 'string'
+        && error.name.length > 0) {
+        return error.name;
+    }
+    return 'UnknownError';
+}
+function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
+    // Intercept onThreadId to update currentThreadId when the transport
+    // auto-creates a thread. Without this, each submit() creates a new thread
+    // because currentThreadId stays null.
+    const userOnThreadId = options.onThreadId;
+    const wrappedOnThreadId = (id) => {
+        currentThreadId = id;
+        userOnThreadId?.(id);
+    };
+    const transport = options.transport ?? new FetchStreamTransport(options.apiUrl, wrappedOnThreadId);
+    let currentThreadId = null;
+    let lastPayload = null;
+    let lastOptions;
+    let abortController = null;
+    let historyAbortController = null;
+    let hasSeenThreadId = false;
+    const toolProgressMap = new Map();
+    const queuedRuns = [];
+    let drainingQueue = false;
+    const subagentManager = new SubagentTracker({
+        subagentToolNames: options.subagentToolNames,
+        onSubagentChange: publishSubagents,
+    });
+    const telemetryProperties = { transport: 'langgraph', surface: 'agent' };
+    captureAgentRuntimeTelemetry(options.telemetry, 'ngaf:runtime_instance_created', telemetryProperties);
+    function captureRuntimeRequestTelemetry(requestType) {
+        captureAgentRuntimeTelemetry(options.telemetry, 'ngaf:runtime_request_created', {
+            ...telemetryProperties,
+            requestType,
+        });
+    }
+    /**
+     * Tracks reasoning timing per message id. Keys are message ids; values
+     * record when reasoning content first arrived and when response text
+     * first appeared (or the canonical message arrived). Cleared on
+     * resetThreadState() and on bridge teardown.
+     */
+    const reasoningTimingMap = new Map();
+    function resetThreadState() {
+        historyAbortController?.abort();
+        subjects.values$.next({});
+        subjects.messages$.next([]);
+        subjects.history$.next([]);
+        subjects.interrupt$.next(undefined);
+        subjects.interrupts$.next([]);
+        subjects.toolProgress$.next([]);
+        subjects.toolCalls$.next([]);
+        subjects.messageMetadata$.next(new Map());
+        subjects.subagents$.next(new Map());
+        void cancelQueueEntries(takeQueuedRuns()).catch(err => subjects.error$.next(err));
+        publishQueue();
+        subjects.custom$.next([]);
+        subjects.isThreadLoading$.next(false);
+        toolProgressMap.clear();
+        subagentManager.clear();
+        reasoningTimingMap.clear();
+    }
+    function setThreadId(id, resetState) {
+        if (resetState) {
+            abortController?.abort();
+        }
+        currentThreadId = id;
+        if (resetState) {
+            resetThreadState();
+        }
+        void refreshHistory();
+    }
+    // Track threadId changes
+    threadId$.pipe(takeUntil(destroy$)).subscribe(id => {
+        const shouldReset = hasSeenThreadId && currentThreadId !== id;
+        hasSeenThreadId = true;
+        setThreadId(id, shouldReset);
+    });
+    destroy$.subscribe(() => {
+        abortController?.abort();
+        historyAbortController?.abort();
+        reasoningTimingMap.clear();
+    });
+    async function refreshHistory(force = false) {
+        const getHistory = transport.getHistory?.bind(transport);
+        if (!currentThreadId || !getHistory)
+            return;
+        historyAbortController?.abort();
+        const controller = new AbortController();
+        historyAbortController = controller;
+        const threadId = currentThreadId;
+        subjects.isThreadLoading$.next(true);
+        try {
+            const history = await getHistory(threadId, controller.signal);
+            if (!controller.signal.aborted && currentThreadId === threadId) {
+                subjects.history$.next(history);
+                // Project the latest checkpoint into messages$ + values$:
+                //  - On first connect (`force=false`): only when messages$ is
+                //    empty, so optimistic local state isn't clobbered.
+                //  - At run completion (`force=true`): always — server state is
+                //    authoritative for node-level mutations (e.g. RemoveMessage
+                //    or id-match content replacement performed by post-process
+                //    nodes), and the streaming SDK doesn't always restream those.
+                const latest = history[0];
+                const shouldProject = latest?.values
+                    && (force || subjects.messages$.value.length === 0);
+                if (shouldProject) {
+                    const restoredMessages = latest.values?.messages ?? [];
+                    const restoredValues = { ...latest.values };
+                    // Strip the `messages` field from values — messages$ is the
+                    // canonical surface for them; keeping a duplicate in values$
+                    // would confuse downstream consumers reading both subjects.
+                    delete restoredValues.messages;
+                    subjects.messages$.next(restoredMessages);
+                    subjects.values$.next(restoredValues);
+                    // Rebuild derived subjects from the new authoritative messages$.
+                    // Tool-call results displayed by chat-tool-calls come from
+                    // toolCalls$, which is built from messages$; without this, the
+                    // panel keeps showing the streamed pre-mutation content.
+                    syncToolCallsFromMessages();
+                }
+                // Hydrate pending interrupts from the latest checkpoint. When a
+                // thread is reloaded mid-pause (paused at an interrupt), the
+                // streaming events won't replay — interrupts live on the
+                // checkpoint's tasks[i].interrupts and must be projected manually
+                // so the interrupt panel re-renders on page reload.
+                hydrateInterruptsFromHistory(history, subjects);
+            }
+        }
+        catch (err) {
+            if (!controller.signal.aborted && err?.name !== 'AbortError') {
+                subjects.error$.next(err);
+            }
+        }
+        finally {
+            if (historyAbortController === controller) {
+                historyAbortController = null;
+                subjects.isThreadLoading$.next(false);
+            }
+        }
+    }
+    function publishQueue() {
+        subjects.queue$.next(createQueueSnapshot());
+    }
+    function createQueueSnapshot() {
+        return {
+            entries: [...queuedRuns],
+            size: queuedRuns.length,
+            cancel: cancelQueuedRun,
+            clear: clearQueue,
+        };
+    }
+    async function enqueueRun(payload, opts) {
+        if (!currentThreadId) {
+            throw new Error('Cannot enqueue a run before a LangGraph thread exists.');
+        }
+        if (!transport.createQueuedRun) {
+            throw new Error('The configured LangGraph transport does not support server-side queueing.');
+        }
+        captureRuntimeRequestTelemetry('enqueue');
+        const controller = new AbortController();
+        const entry = await transport.createQueuedRun(options.assistantId, currentThreadId, payload, opts?.signal ?? controller.signal, opts);
+        queuedRuns.push({
+            ...entry,
+            values: payload,
+            options: { ...opts, multitaskStrategy: 'enqueue' },
+            createdAt: entry.createdAt ?? new Date(),
+        });
+        publishQueue();
+    }
+    async function cancelQueuedRun(id) {
+        const index = queuedRuns.findIndex(entry => entry.id === id);
+        if (index === -1)
+            return false;
+        const [entry] = queuedRuns.splice(index, 1);
+        publishQueue();
+        if (!entry || !transport.cancelRun)
+            return false;
+        await cancelQueueEntries([entry]);
+        return true;
+    }
+    async function clearQueue() {
+        const entries = takeQueuedRuns();
+        publishQueue();
+        await cancelQueueEntries(entries);
+    }
+    function takeQueuedRuns() {
+        return queuedRuns.splice(0, queuedRuns.length);
+    }
+    async function cancelQueueEntries(entries) {
+        const cancelRun = transport.cancelRun?.bind(transport);
+        if (!cancelRun)
+            return;
+        await Promise.all(entries.map(entry => cancelRun(entry.threadId, entry.id, new AbortController().signal)));
+    }
+    async function drainQueue() {
+        if (drainingQueue || queuedRuns.length === 0)
+            return;
+        drainingQueue = true;
+        try {
+            while (queuedRuns.length > 0) {
+                const entry = queuedRuns.shift();
+                publishQueue();
+                if (!entry || !transport.joinStream)
+                    continue;
+                await joinQueuedRun(entry);
+            }
+        }
+        finally {
+            drainingQueue = false;
+        }
+    }
+    async function joinQueuedRun(entry) {
+        abortController = new AbortController();
+        const startedAt = Date.now();
+        captureRuntimeRequestTelemetry('join_queued');
+        captureAgentRuntimeTelemetry(options.telemetry, 'ngaf:stream_started', telemetryProperties);
+        subjects.custom$.next([]);
+        subjects.toolProgress$.next([]);
+        toolProgressMap.clear();
+        subjects.status$.next(ResourceStatus.Loading);
+        try {
+            const iter = transport.joinStream
+                ? transport.joinStream(entry.threadId, entry.id, undefined, abortController.signal)
+                : [];
+            for await (const event of iter) {
+                if (abortController.signal.aborted)
+                    break;
+                processEvent(event);
+            }
+            if (!abortController.signal.aborted) {
+                subjects.status$.next(ResourceStatus.Resolved);
+                // force=true: rehydrate from server-authoritative state so any
+                // post-process node mutations (RemoveMessage, id-match content
+                // replacement) reflected on the server are picked up client-side.
+                await refreshHistory(true);
+                captureAgentRuntimeTelemetry(options.telemetry, 'ngaf:stream_ended', {
+                    ...telemetryProperties,
+                    durationMs: Date.now() - startedAt,
+                });
+            }
+        }
+        catch (err) {
+            subjects.error$.next(err);
+            subjects.status$.next(ResourceStatus.Error);
+            captureAgentRuntimeTelemetry(options.telemetry, 'ngaf:stream_errored', {
+                ...telemetryProperties,
+                durationMs: Date.now() - startedAt,
+                errorClass: agentRuntimeTelemetryErrorClass(err),
+            });
+        }
+    }
+    async function runStream(payload, opts, requestType = 'submit') {
+        abortController?.abort();
+        abortController = new AbortController();
+        const startedAt = Date.now();
+        captureRuntimeRequestTelemetry(requestType);
+        captureAgentRuntimeTelemetry(options.telemetry, 'ngaf:stream_started', telemetryProperties);
+        subjects.status$.next(ResourceStatus.Loading);
+        subjects.error$.next(undefined);
+        subjects.custom$.next([]);
+        subjects.toolProgress$.next([]);
+        toolProgressMap.clear();
+        lastPayload = payload;
+        lastOptions = opts;
+        // Optimistically inject human messages so they appear immediately
+        // without waiting for the server to echo them back. Assign a stable id
+        // when missing — track-by-id in the chat-message-list relies on stable
+        // ids across re-emissions, otherwise the optimistic message gets torn
+        // down + recreated on every messages$.next() during streaming, which
+        // restarts caret/typing animations and causes visible flicker.
+        const inputMessages = payload?.['messages'];
+        if (Array.isArray(inputMessages) && inputMessages.length > 0) {
+            const stamped = inputMessages.map((m) => {
+                const raw = m;
+                if (typeof raw['id'] === 'string' && raw['id'])
+                    return m;
+                const id = `optimistic-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                return { ...m, id };
+            });
+            const existing = subjects.messages$.value;
+            subjects.messages$.next([...existing, ...stamped]);
+        }
+        try {
+            const iter = transport.stream(options.assistantId, currentThreadId, payload, opts?.signal ?? abortController.signal, opts);
+            for await (const event of iter) {
+                if (abortController.signal.aborted)
+                    break;
+                processEvent(event);
+            }
+            if (!abortController.signal.aborted) {
+                subjects.status$.next(ResourceStatus.Resolved);
+                // force=true: see refreshHistory comment — server state is
+                // authoritative after run completion.
+                await refreshHistory(true);
+                await drainQueue();
+                captureAgentRuntimeTelemetry(options.telemetry, 'ngaf:stream_ended', {
+                    ...telemetryProperties,
+                    durationMs: Date.now() - startedAt,
+                });
+            }
+        }
+        catch (err) {
+            if (err?.name === 'AbortError') {
+                subjects.status$.next(ResourceStatus.Resolved);
+            }
+            else {
+                subjects.error$.next(err);
+                subjects.status$.next(ResourceStatus.Error);
+                captureAgentRuntimeTelemetry(options.telemetry, 'ngaf:stream_errored', {
+                    ...telemetryProperties,
+                    durationMs: Date.now() - startedAt,
+                    errorClass: agentRuntimeTelemetryErrorClass(err),
+                });
+            }
+        }
+    }
+    function processEvent(event) {
+        const baseType = getBaseEventType(event.type);
+        const namespace = getEventNamespace(event);
+        if (isMessagesEvent(event.type)) {
+            const msgs = normalizeMessages(event);
+            if (!msgs)
+                return;
+            const normalized = options.toMessage
+                ? msgs.map(options.toMessage)
+                : msgs;
+            if (isSubagentNamespace(namespace)) {
+                const namespaceId = namespace ? extractToolCallIdFromNamespace(namespace) : undefined;
+                if (namespaceId) {
+                    for (const msg of normalized) {
+                        subagentManager.addMessageToSubagent(namespaceId, msg);
+                    }
+                    publishSubagents();
+                }
+                if (options.filterSubagentMessages) {
+                    return;
+                }
+            }
+            // Partial and message-tuple events are incremental. Merge them by id
+            // so optimistic human messages and earlier tool messages are preserved.
+            if (event.type === 'messages/partial' || event.messageMetadata) {
+                subjects.messages$.next(mergeMessages(subjects.messages$.value, normalized, reasoningTimingMap));
+                if (isLgTraceEnabled()) {
+                    const msgs = subjects.messages$.value;
+                    const last = msgs[msgs.length - 1];
+                    lgTrace('bridge.messages-tuple', { id: last?.['id'], count: msgs.length });
+                }
+            }
+            else if (normalized.length === 0) {
+                // Defensive: skip empty replacements during streaming. An empty
+                // batch shouldn't tear down the entire UI (causes message DOM
+                // teardown + streaming renderer reset = visible jank).
+            }
+            else {
+                // Preserve existing ids by content so the final-id swap doesn't
+                // tear down the chat-message DOM (and its streaming-md renderer).
+                subjects.messages$.next(preserveIds(subjects.messages$.value, normalized));
+            }
+            storeMessageMetadata(normalized, event);
+            syncSubagentsFromMessages(normalized);
+            syncToolCallsFromMessages();
+            return;
+        }
+        // normalizeSdkEvent spreads event data directly into the event object,
+        // so the values/updates payload is at event['data'] (the original data object),
+        // NOT at event['values'] or event['updates'].
+        switch (baseType) {
+            case 'values': {
+                const vals = extractEventData(event);
+                if (isSubagentNamespace(namespace) && isRecord$1(vals)) {
+                    updateSubagentValues(namespace, vals);
+                    break;
+                }
+                if (vals != null) {
+                    extractInterrupts(vals, subjects);
+                    subjects.values$.next(vals);
+                    // Also sync messages$ from the values state so the full message
+                    // history (including human messages) is available to consumers.
+                    const stateMessages = vals['messages'];
+                    if (Array.isArray(stateMessages) && stateMessages.length > 0) {
+                        // Defensive: only sync when state carries messages. An empty
+                        // values payload shouldn't wipe the UI mid-stream.
+                        const projected = options.toMessage
+                            ? stateMessages.map(options.toMessage)
+                            : stateMessages;
+                        // Drop empty-content AI placeholders before merging. LangGraph
+                        // emits intermediate `values` events whose `state.messages`
+                        // includes an unfilled assistant turn at the tail. Keeping it
+                        // would create a phantom slot that competes with the chunk-
+                        // streamed AIMessageChunk arriving via messages-tuple — they'd
+                        // never merge (different ids; non-overlapping content fragments)
+                        // and the user sees two assistant bubbles.
+                        const filtered = projected.filter((m, i) => {
+                            if (i !== projected.length - 1)
+                                return true;
+                            const t = normalizeMessageType(typeof m._getType === 'function' ? m._getType() : m['type']);
+                            if (t !== 'ai')
+                                return true;
+                            const text = extractText(m.content);
+                            return text.length > 0;
+                        });
+                        // Preserve existing ids by content match (server echo / final-id swap).
+                        const remapped = preserveIds(subjects.messages$.value, filtered);
+                        // ALWAYS merge values-derived messages into existing rather
+                        // than replacing. LangGraph emits intermediate values events
+                        // during streaming where state.messages can lag behind what
+                        // we've already seen via messages-tuple — replacing would
+                        // drop the partial AI (or even the optimistic human) and
+                        // tear down their DOM mid-stream. Merge by id keeps both,
+                        // updates content where ids match, preserves the rest.
+                        subjects.messages$.next(mergeMessages(subjects.messages$.value, remapped, reasoningTimingMap));
+                        if (isLgTraceEnabled()) {
+                            lgTrace('bridge.values-sync', {
+                                incomingLength: stateMessages.length,
+                                mergedLength: subjects.messages$.value.length,
+                            });
+                        }
+                        syncSubagentsFromMessages(stateMessages);
+                        subagentManager.reconstructFromMessages(stateMessages, { skipIfPopulated: true });
+                        publishSubagents();
+                        syncToolCallsFromMessages();
+                    }
+                }
+                break;
+            }
+            case 'updates': {
+                const upd = extractEventData(event);
+                if (isSubagentNamespace(namespace)) {
+                    markSubagentRunning(namespace);
+                    break;
+                }
+                if (upd != null) {
+                    extractInterrupts(upd, subjects);
+                    subjects.values$.next({
+                        ...subjects.values$.value,
+                        ...upd,
+                    });
+                }
+                break;
+            }
+            case 'error':
+                subjects.error$.next(event['error']);
+                subjects.status$.next(ResourceStatus.Error);
+                break;
+            case 'interrupt':
+                subjects.interrupt$.next(event['interrupt']);
+                break;
+            case 'interrupts':
+                subjects.interrupts$.next(event['interrupts']);
+                break;
+            case 'custom': {
+                const eventData = event['data'];
+                const name = (event['name'] ?? eventData?.['name'] ?? '');
+                const data = eventData?.['data'] ?? eventData;
+                const current = subjects.custom$.value;
+                subjects.custom$.next([...current, { name, data }]);
+                break;
+            }
+            case 'tools':
+                updateToolProgress(event);
+                break;
+        }
+    }
+    function syncToolCallsFromMessages() {
+        const toolCalls = getToolCallsWithResults(subjects.messages$.value);
+        subjects.toolCalls$.next(toolCalls);
+    }
+    function syncSubagentsFromMessages(messages) {
+        for (const message of messages) {
+            const raw = message;
+            if (isAiMessageWithToolCalls(raw)) {
+                subagentManager.registerFromToolCalls(raw['tool_calls'], typeof raw['id'] === 'string' ? raw['id'] : null);
+            }
+            if (isToolMessage(raw)) {
+                const content = typeof raw['content'] === 'string'
+                    ? raw['content']
+                    : JSON.stringify(raw['content']);
+                const status = raw['status'] === 'error' ? 'error' : 'success';
+                subagentManager.processToolMessage(raw['tool_call_id'], content, status);
+            }
+        }
+        publishSubagents();
+    }
+    function updateSubagentValues(namespace, values) {
+        const namespaceId = namespace ? extractToolCallIdFromNamespace(namespace) : undefined;
+        if (!namespaceId)
+            return;
+        const messages = values['messages'];
+        if (Array.isArray(messages) && messages.length > 0) {
+            const first = messages[0];
+            if (isRecord$1(first) && (first['type'] === 'human' || first['type'] === 'user') && typeof first['content'] === 'string') {
+                subagentManager.matchSubgraphToSubagent(namespaceId, first['content']);
+            }
+        }
+        subagentManager.updateSubagentValues(namespaceId, values);
+        publishSubagents();
+    }
+    function markSubagentRunning(namespace) {
+        const namespaceId = namespace ? extractToolCallIdFromNamespace(namespace) : undefined;
+        if (!namespaceId)
+            return;
+        subagentManager.markRunningFromNamespace(namespaceId, namespace);
+        publishSubagents();
+    }
+    function publishSubagents() {
+        subjects.subagents$.next(toSubagentRefs(subagentManager.getSubagents()));
+    }
+    function storeMessageMetadata(messages, event) {
+        if (!event.messageMetadata)
+            return;
+        const next = new Map(subjects.messageMetadata$.value);
+        messages.forEach((message, index) => {
+            const id = message['id'];
+            const messageId = String(id ?? index);
+            next.set(messageId, {
+                messageId,
+                firstSeenState: undefined,
+                branch: undefined,
+                branchOptions: undefined,
+                streamMetadata: event.messageMetadata,
+            });
+        });
+        subjects.messageMetadata$.next(next);
+    }
+    function updateToolProgress(event) {
+        const data = extractEventData(event);
+        if (!isRecord$1(data))
+            return;
+        const toolEvent = data['event'];
+        const name = data['name'];
+        if (typeof toolEvent !== 'string' || typeof name !== 'string')
+            return;
+        const toolCallId = typeof data['toolCallId'] === 'string' ? data['toolCallId'] : undefined;
+        const key = toolCallId ?? name;
+        const existing = toolProgressMap.get(key);
+        switch (toolEvent) {
+            case 'on_tool_start':
+                toolProgressMap.set(key, {
+                    toolCallId,
+                    name,
+                    state: 'starting',
+                    input: data['input'],
+                });
+                break;
+            case 'on_tool_event':
+                toolProgressMap.set(key, {
+                    toolCallId,
+                    name,
+                    ...existing,
+                    state: 'running',
+                    data: data['data'],
+                });
+                break;
+            case 'on_tool_end':
+                toolProgressMap.set(key, {
+                    toolCallId,
+                    name,
+                    ...existing,
+                    state: 'completed',
+                    result: data['output'],
+                });
+                break;
+            case 'on_tool_error':
+                toolProgressMap.set(key, {
+                    toolCallId,
+                    name,
+                    ...existing,
+                    state: 'error',
+                    error: data['error'],
+                });
+                break;
+            default:
+                return;
+        }
+        subjects.toolProgress$.next([...toolProgressMap.values()]);
+    }
+    return {
+        submit: async (payload, opts) => {
+            if (opts?.multitaskStrategy === 'enqueue' && subjects.status$.value === ResourceStatus.Loading) {
+                await enqueueRun(payload, opts);
+                return;
+            }
+            await runStream(payload, opts);
+        },
+        stop: async () => {
+            abortController?.abort();
+            await clearQueue();
+            subjects.status$.next(ResourceStatus.Resolved);
+        },
+        switchThread: (id) => {
+            setThreadId(id, true);
+        },
+        joinStream: async (runId, lastEventId) => {
+            if (!currentThreadId)
+                return;
+            abortController?.abort();
+            abortController = new AbortController();
+            const startedAt = Date.now();
+            captureRuntimeRequestTelemetry('join');
+            captureAgentRuntimeTelemetry(options.telemetry, 'ngaf:stream_started', telemetryProperties);
+            subjects.custom$.next([]);
+            subjects.toolProgress$.next([]);
+            toolProgressMap.clear();
+            subjects.status$.next(ResourceStatus.Loading);
+            try {
+                const iter = transport.joinStream
+                    ? transport.joinStream(currentThreadId, runId, lastEventId, abortController.signal)
+                    : [];
+                for await (const event of iter) {
+                    processEvent(event);
+                }
+                subjects.status$.next(ResourceStatus.Resolved);
+                await refreshHistory();
+                captureAgentRuntimeTelemetry(options.telemetry, 'ngaf:stream_ended', {
+                    ...telemetryProperties,
+                    durationMs: Date.now() - startedAt,
+                });
+            }
+            catch (err) {
+                subjects.error$.next(err);
+                subjects.status$.next(ResourceStatus.Error);
+                captureAgentRuntimeTelemetry(options.telemetry, 'ngaf:stream_errored', {
+                    ...telemetryProperties,
+                    durationMs: Date.now() - startedAt,
+                    errorClass: agentRuntimeTelemetryErrorClass(err),
+                });
+            }
+        },
+        resubmitLast: async () => {
+            if (lastPayload !== null) {
+                await runStream(lastPayload, lastOptions, 'resubmit');
+            }
+        },
+        getReasoningDurationMs: (id) => {
+            const entry = reasoningTimingMap.get(id);
+            if (!entry)
+                return undefined;
+            if (entry.endedAt === undefined)
+                return undefined;
+            return entry.endedAt - entry.startedAt;
+        },
+        updateState: async (values, opts) => {
+            // No-op when there is no thread yet or the transport doesn't support
+            // updateState (e.g. MockAgentTransport in unit tests without a threadId).
+            if (!currentThreadId || !transport.updateState) {
+                return;
+            }
+            await transport.updateState(currentThreadId, values, new AbortController().signal, opts);
+        },
+        get currentThreadId() {
+            return currentThreadId;
+        },
+    };
+}
+/**
+ * Extracts the payload data from a normalized SDK event.
+ *
+ * Handles two formats:
+ * 1. SDK events (via normalizeSdkEvent): data at event['data'] (record) + spread into event
+ * 2. Mock/test events: data at event[event.type] (e.g., event['values'], event['updates'])
+ */
+/**
+ * LangGraph emits interrupts as part of `updates`/`values` events under the
+ * special `__interrupt__` key, not as standalone events. When such a payload
+ * appears, mirror it onto `interrupt$` (latest) and `interrupts$` (full list)
+ * so consumers can react via `agent.interrupt()` / `agent.interrupts()`.
+ */
+function extractInterrupts(payload, subjects) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload))
+        return;
+    const raw = payload['__interrupt__'];
+    // Cast through unknown — Interrupt$ is parameterized over Bag's InterruptType,
+    // and the SDK delivers raw Interrupt payloads here.
+    if (Array.isArray(raw) && raw.length > 0) {
+        const list = raw;
+        subjects.interrupts$.next(list);
+        subjects.interrupt$.next(list[list.length - 1]);
+        return;
+    }
+    // Payload has no `__interrupt__` key. Clear any stale interrupt so the UI
+    // dismisses the panel after a resume completes (LangGraph does not emit a
+    // separate "cleared" event — the absence of `__interrupt__` in subsequent
+    // values/updates is the signal). No-op if interrupt$ was already empty.
+    if (subjects.interrupt$.value !== undefined) {
+        subjects.interrupt$.next(undefined);
+        subjects.interrupts$.next([]);
+    }
+}
+/**
+ * Projects pending interrupts from the latest history checkpoint onto the
+ * interrupt$ / interrupts$ subjects. ThreadState exposes interrupts under
+ * `tasks[i].interrupts` (per the LangGraph SDK schema). When the latest
+ * checkpoint contains any pending interrupts, mirror them so consumers can
+ * react via `agent.interrupt()` on thread reload without needing a fresh
+ * stream event.
+ *
+ * If no interrupts are present, this is a no-op so existing streamed state
+ * (mid-run) isn't clobbered by a stale history refresh.
+ */
+function hydrateInterruptsFromHistory(history, subjects) {
+    const latest = history[0];
+    if (!latest || !Array.isArray(latest.tasks))
+        return;
+    const collected = [];
+    for (const task of latest.tasks) {
+        if (task && Array.isArray(task.interrupts) && task.interrupts.length > 0) {
+            for (const ix of task.interrupts) {
+                collected.push(ix);
+            }
+        }
+    }
+    if (collected.length > 0) {
+        subjects.interrupts$.next(collected);
+        subjects.interrupt$.next(collected[collected.length - 1]);
+    }
+}
+function extractEventData(event) {
+    // Try event['data'] first (SDK format from normalizeSdkEvent)
+    const d = event['data'];
+    if (d != null && typeof d === 'object' && !Array.isArray(d)) {
+        return d;
+    }
+    // Try event[event.type] (mock/test format: { type: 'values', values: {...} })
+    const named = event[event.type];
+    if (named != null && typeof named === 'object' && !Array.isArray(named)) {
+        return named;
+    }
+    // Fallback: reconstruct from remaining keys
+    const rest = Object.fromEntries(Object.entries(event).filter(([key]) => key !== 'type' && key !== 'data'));
+    return Object.keys(rest).length > 0 ? rest : d;
+}
+function isMessagesEvent(type) {
+    const baseType = getBaseEventType(type);
+    return baseType === 'messages' || baseType.startsWith('messages/');
+}
+function getBaseEventType(type) {
+    return String(type).split('|')[0];
+}
+function getEventNamespace(event) {
+    if (Array.isArray(event.namespace))
+        return event.namespace;
+    const parts = String(event.type).split('|');
+    return parts.length > 1 ? parts.slice(1) : undefined;
+}
+function normalizeMessages(event) {
+    const directMessages = event['messages'];
+    if (Array.isArray(directMessages)) {
+        // Filter out non-message metadata objects (e.g. { langgraph_node, langgraph_triggers })
+        // that the LangGraph SDK includes alongside real messages in messages/* events.
+        const filtered = directMessages.filter(isMessageLike);
+        return filtered.length > 0 ? filtered : null;
+    }
+    const data = event['data'];
+    if (Array.isArray(data)) {
+        if (data.every(isMessageLike)) {
+            return data;
+        }
+        if (isMessageLike(data[0])) {
+            return [data[0]];
+        }
+    }
+    const indexedValues = Object.keys(event)
+        .filter(key => /^\d+$/.test(key))
+        .sort((left, right) => Number(left) - Number(right))
+        .map(key => event[key]);
+    if (indexedValues.every(isMessageLike)) {
+        return indexedValues;
+    }
+    if (isMessageLike(indexedValues[0])) {
+        return [indexedValues[0]];
+    }
+    return null;
+}
+/**
+ * Collapse adjacent AI messages where one's text is a prefix of the other.
+ *
+ * When complex-content streaming is in play, the same conceptual assistant
+ * message can land in two slots: the canonical AI from values-sync (id
+ * `resp_…` or run id) and the chunk-streamed AIMessageChunk from
+ * messages-tuple (id `lc_run--…`). Both slots fill in parallel; once both
+ * carry the full text we collapse them, keeping the older slot's id so
+ * track-by-id stays stable in the chat list.
+ */
+function collapseAdjacentAi(messages) {
+    if (messages.length < 2)
+        return messages;
+    const out = [];
+    for (const msg of messages) {
+        const last = out[out.length - 1];
+        if (!last) {
+            out.push(msg);
+            continue;
+        }
+        const lastType = normalizeMessageType(typeof last._getType === 'function' ? last._getType() : last['type']);
+        const msgType = normalizeMessageType(typeof msg._getType === 'function' ? msg._getType() : msg['type']);
+        if (lastType === 'ai' && msgType === 'ai') {
+            const lastText = extractText(last.content);
+            const msgText = extractText(msg.content);
+            if (lastText.length === 0
+                || msgText.length === 0
+                || lastText === msgText
+                || lastText.startsWith(msgText)
+                || msgText.startsWith(lastText)) {
+                // Keep the longer content; preserve last (older) id and metadata.
+                const longerText = msgText.length >= lastText.length ? msgText : lastText;
+                out[out.length - 1] = { ...last, content: longerText };
+                continue;
+            }
+        }
+        out.push(msg);
+    }
+    return out;
+}
+function mergeMessages(existing, incoming, reasoningTimingMap) {
+    const merged = [...existing];
+    for (const msg of incoming) {
+        const rawIn = msg;
+        const id = rawIn['id'];
+        let idx = id ? merged.findIndex(m => m['id'] === id) : -1;
+        // Fallback: match by (role, content) when ids differ. This is the path
+        // that fires when the server echoes back our optimistic human message
+        // with a server-assigned id, or when partial AI tokens carry a chunk
+        // id but the final canonical message has a run id. Preserving the
+        // existing id here keeps track-by-id stable in the chat list and
+        // prevents DOM teardown + animation restarts mid-stream.
+        if (idx < 0) {
+            idx = findContentMatch(merged, msg);
+        }
+        // When an AIMessageChunk arrives without an id-match or content-prefix
+        // match, treat the trailing AI message as its accumulator. The
+        // OpenAI Responses API emits per-chunk events whose ids identify the
+        // *event*, not the message, so consecutive chunks land here. Without
+        // this we'd append every chunk as a separate bubble.
+        if (idx < 0) {
+            const inType = normalizeMessageType(rawIn['type']);
+            if (inType === 'ai') {
+                for (let i = merged.length - 1; i >= 0; i--) {
+                    const t = normalizeMessageType(typeof merged[i]._getType === 'function'
+                        ? merged[i]._getType()
+                        : merged[i]['type']);
+                    if (t === 'ai') {
+                        idx = i;
+                        break;
+                    }
+                    if (t === 'human' || t === 'tool' || t === 'system')
+                        break;
+                }
+            }
+        }
+        if (idx >= 0) {
+            const existing = merged[idx];
+            const existingId = existing['id'];
+            const incomingRaw = msg;
+            // Keep the *existing* id so downstream track-by-id sees stable identity.
+            // For complex-content streaming (OpenAI gpt-5/o-series, Anthropic) the
+            // SDK emits per-chunk *delta* arrays — not accumulated arrays — so a
+            // straight replacement collapses the rendered bubble to just the
+            // latest token. Accumulate text-bearing content across chunks here
+            // and hand a string to consumers; downstream code already handles
+            // string content uniformly.
+            const accumulatedContent = accumulateContent(existing.content, incomingRaw['content']);
+            // Only accumulate reasoning when the incoming message explicitly carries
+            // a `reasoning` field or complex-content array blocks with
+            // type='reasoning'/'thinking'. Never use a plain string content value
+            // as reasoning source — that would wrongly treat every assistant
+            // message text as reasoning content.
+            const incomingReasoningSource = 'reasoning' in incomingRaw
+                ? incomingRaw['reasoning']
+                : (Array.isArray(incomingRaw['content']) ? incomingRaw['content'] : undefined);
+            const accumulatedReasoning = accumulateReasoning(existing['reasoning'], incomingReasoningSource);
+            const idForTiming = existingId ?? incomingRaw['id'];
+            if (idForTiming && reasoningTimingMap) {
+                const hasReasoning = accumulatedReasoning.length > 0;
+                const hasText = (typeof accumulatedContent === 'string' ? accumulatedContent : '').length > 0;
+                if (hasReasoning) {
+                    const entry = reasoningTimingMap.get(idForTiming) ?? { startedAt: Date.now() };
+                    if (hasText && entry.endedAt === undefined)
+                        entry.endedAt = Date.now();
+                    reasoningTimingMap.set(idForTiming, entry);
+                }
+            }
+            const next = { ...msg, content: accumulatedContent };
+            next['reasoning'] = accumulatedReasoning;
+            if (existingId) {
+                next['id'] = existingId;
+            }
+            merged[idx] = next;
+        }
+        else {
+            const incomingRaw = msg;
+            const initialReasoningSource = 'reasoning' in incomingRaw
+                ? incomingRaw['reasoning']
+                : (Array.isArray(incomingRaw['content']) ? incomingRaw['content'] : undefined);
+            const initialReasoning = accumulateReasoning(undefined, initialReasoningSource);
+            if (initialReasoning.length > 0 && reasoningTimingMap) {
+                const msgId = incomingRaw['id'];
+                if (msgId && !reasoningTimingMap.has(msgId)) {
+                    reasoningTimingMap.set(msgId, { startedAt: Date.now() });
+                }
+            }
+            const next = { ...msg };
+            next['reasoning'] = initialReasoning;
+            merged.push(next);
+        }
+    }
+    return collapseAdjacentAi(merged);
+}
+/**
+ * Merge an incoming chunk's content into prior accumulated content for the
+ * same message id.
+ *
+ * - string + string → concat (delta append)
+ * - array + array  → concat extracted text from existing + incoming blocks
+ * - array + string → use the string (server final-id swap)
+ * - empty existing → use incoming as-is
+ *
+ * We deliberately collapse complex content arrays to a string at this layer.
+ * The langgraph-sdk client does not accumulate complex-content arrays the
+ * way it accumulates strings, and per-chunk arrays carry only the latest
+ * delta. Concatenating extracted text gives consumers the same uniform
+ * string they get for non-reasoning models.
+ */
+/**
+ * Heuristic: does this content look like a "final canonical" array
+ * carrying both reasoning and visible text blocks? OpenAI's Responses
+ * API ships the final assistant message in this shape after the
+ * streaming token chunks complete. Detection is narrow (requires BOTH
+ * a reasoning-shape block AND a text-shape block in the same array)
+ * so it doesn't trip on routine streaming chunks.
+ */
+function isFinalCanonicalReasoningContent(content) {
+    if (!Array.isArray(content))
+        return false;
+    let hasReasoning = false;
+    let hasText = false;
+    for (const block of content) {
+        if (block == null || typeof block !== 'object')
+            continue;
+        const t = block['type'];
+        if (t === 'reasoning' || t === 'thinking')
+            hasReasoning = true;
+        else if (t === 'text' || t === 'output_text')
+            hasText = true;
+    }
+    return hasReasoning && hasText;
+}
+function accumulateContent(existing, incoming) {
+    const existingText = extractText(existing);
+    const incomingText = extractText(incoming);
+    // Always return a string. We never want array content escaping the bridge:
+    // (a) downstream consumers expect string content, and (b) findContentMatch
+    // stringifies arrays, which would prevent the canonical-message id-swap
+    // dedupe from matching the streamed-chunk message after a partial chunk.
+    if (existingText.length === 0)
+        return incomingText;
+    if (incomingText.length === 0)
+        return existingText;
+    // Incoming is a strict-superset of accumulated (final-id swap with full content).
+    if (incomingText.startsWith(existingText))
+        return incomingText;
+    // Existing already a strict-superset — chunk arrived after the canonical
+    // message merged in via values-sync. Keep what we have.
+    if (existingText.startsWith(incomingText))
+        return existingText;
+    // Final-canonical detection: when incoming is the "reasoning + text"
+    // array shape that ships the authoritative final message after a
+    // streaming run, replace the partial streamed accumulator with the
+    // canonical text instead of appending. Without this branch a small
+    // formatting difference between the streamed accumulator and the
+    // canonical text breaks the prefix checks above and visible content
+    // is duplicated (`existingText + incomingText`).
+    if (isFinalCanonicalReasoningContent(incoming))
+        return incomingText;
+    // Otherwise treat incoming as a delta and append.
+    return existingText + incomingText;
+}
+function extractText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    let out = '';
+    for (const block of content) {
+        if (typeof block === 'string') {
+            out += block;
+            continue;
+        }
+        if (block == null || typeof block !== 'object')
+            continue;
+        const rec = block;
+        const t = rec['type'];
+        if (t === 'text' || t === 'output_text' || t === undefined) {
+            const text = rec['text'];
+            if (typeof text === 'string')
+                out += text;
+        }
+    }
+    return out;
+}
+function extractReasoning(content) {
+    if (typeof content === 'string')
+        return '';
+    if (!Array.isArray(content))
+        return '';
+    let out = '';
+    for (const block of content) {
+        if (block == null || typeof block !== 'object')
+            continue;
+        const rec = block;
+        const t = rec['type'];
+        if (t === 'reasoning' || t === 'thinking') {
+            // Direct text field — Anthropic-style "thinking" blocks and
+            // some LangChain-shaped reasoning blocks land here.
+            const text = rec['text'];
+            if (typeof text === 'string')
+                out += text;
+            // OpenAI Responses API: when `reasoning.summary='auto'` was
+            // requested, reasoning blocks carry a `summary` array of
+            // `{type: 'summary_text', text: '...'}` items. Concatenate
+            // their texts in order.
+            const summary = rec['summary'];
+            if (Array.isArray(summary)) {
+                for (const item of summary) {
+                    if (item == null || typeof item !== 'object')
+                        continue;
+                    const itemText = item['text'];
+                    if (typeof itemText === 'string')
+                        out += itemText;
+                }
+            }
+        }
+    }
+    return out;
+}
+function accumulateReasoning(existing, incoming) {
+    const existingText = typeof existing === 'string' ? existing : extractReasoning(existing);
+    const incomingText = typeof incoming === 'string' ? incoming : extractReasoning(incoming);
+    if (existingText.length === 0)
+        return incomingText;
+    if (incomingText.length === 0)
+        return existingText;
+    if (incomingText.startsWith(existingText))
+        return incomingText;
+    if (existingText.startsWith(incomingText))
+        return existingText;
+    return existingText + incomingText;
+}
+/**
+ * Replace the incoming messages' ids with the existing array's ids whenever
+ * (role, content) matches positionally and the existing id differs. Keeps
+ * track-by-id stable across server echoes and final-id swaps.
+ */
+function preserveIds(existing, incoming) {
+    if (existing.length === 0)
+        return collapseAdjacentAi(incoming);
+    const usedExisting = new Set();
+    const remapped = incoming.map((msg, i) => {
+        const inRaw = msg;
+        const inId = inRaw['id'];
+        // First try same-position match (the dominant case).
+        let matchIdx = -1;
+        if (i < existing.length && !usedExisting.has(i) && sameRoleAndContent(existing[i], msg)) {
+            matchIdx = i;
+        }
+        else {
+            // Fallback: any unused existing message with matching role+content.
+            matchIdx = existing.findIndex((m, j) => !usedExisting.has(j) && sameRoleAndContent(m, msg));
+        }
+        if (matchIdx < 0)
+            return msg;
+        usedExisting.add(matchIdx);
+        const existingId = existing[matchIdx]['id'];
+        if (!existingId || existingId === inId)
+            return msg;
+        return { ...msg, id: existingId };
+    });
+    return collapseAdjacentAi(remapped);
+}
+function sameRoleAndContent(a, b) {
+    const aType = normalizeMessageType(typeof a._getType === 'function' ? a._getType() : a['type']);
+    const bType = normalizeMessageType(typeof b._getType === 'function' ? b._getType() : b['type']);
+    if (aType !== bType)
+        return false;
+    const aContent = typeof a.content === 'string' ? a.content : JSON.stringify(a.content);
+    const bContent = typeof b.content === 'string' ? b.content : JSON.stringify(b.content);
+    if (aContent === bContent)
+        return true;
+    // For AI messages we accept prefix relationships (streaming → final).
+    if (aType === 'ai' && typeof aContent === 'string' && typeof bContent === 'string') {
+        return aContent.length > 0 && (bContent.startsWith(aContent) || aContent.startsWith(bContent));
+    }
+    return false;
+}
+function findContentMatch(merged, incoming) {
+    const inRaw = incoming;
+    const inType = normalizeMessageType(typeof incoming._getType === 'function' ? incoming._getType() : inRaw['type']);
+    const inContent = typeof incoming.content === 'string' ? incoming.content : JSON.stringify(incoming.content);
+    // Only worth matching for human messages (where the optimistic→echo
+    // mismatch happens) and for AI messages where content is a strict prefix
+    // of the existing (token-streaming + final-id swap pattern).
+    for (let i = merged.length - 1; i >= 0; i--) {
+        const m = merged[i];
+        const mType = normalizeMessageType(typeof merged[i]._getType === 'function'
+            ? merged[i]._getType()
+            : m['type']);
+        if (mType !== inType)
+            continue;
+        const mContent = typeof merged[i].content === 'string'
+            ? merged[i].content
+            : JSON.stringify(merged[i].content);
+        if (inType === 'human' && mContent === inContent)
+            return i;
+        if (inType === 'ai') {
+            // Skip empty placeholders. We don't want a pre-existing empty AI
+            // (created by an early values-sync emission with `state.messages`
+            // including an unfilled assistant turn) to absorb the first chunk
+            // arriving via messages-tuple — that strands subsequent chunks in a
+            // separate slot whose content no longer prefix-matches the canonical.
+            const aSafe = typeof mContent === 'string' ? mContent : '';
+            const bSafe = typeof inContent === 'string' ? inContent : '';
+            if (aSafe.length === 0 || bSafe.length === 0)
+                continue;
+            if (mContent === inContent || aSafe.startsWith(bSafe) || bSafe.startsWith(aSafe))
+                return i;
+        }
+    }
+    return -1;
+}
+/**
+ * Normalize message type so AIMessage and AIMessageChunk compare equal.
+ * The LangGraph SDK emits type='AIMessageChunk' on the messages-tuple
+ * streaming path and type='ai' on the values-sync path for the same
+ * canonical assistant message — distinguishing them prevents the
+ * content-prefix dedupe from collapsing the duplicate bubbles.
+ */
+function normalizeMessageType(t) {
+    if (!t)
+        return t;
+    if (t === 'AIMessageChunk' || t === 'AIMessage' || t === 'assistant')
+        return 'ai';
+    if (t === 'HumanMessage' || t === 'HumanMessageChunk' || t === 'user')
+        return 'human';
+    if (t === 'ToolMessage')
+        return 'tool';
+    if (t === 'SystemMessage')
+        return 'system';
+    return t;
+}
+function toSubagentRefs(subagents) {
+    const refs = new Map();
+    subagents.forEach((subagent, key) => {
+        refs.set(key, {
+            toolCallId: subagent.id,
+            name: typeof subagent.toolCall.args['subagent_type'] === 'string'
+                ? subagent.toolCall.args['subagent_type']
+                : undefined,
+            status: signal(subagent.status),
+            values: signal(subagent.values),
+            messages: signal(subagent.messages),
+        });
+    });
+    return refs;
+}
+function isAiMessageWithToolCalls(value) {
+    return (value['type'] === 'ai' || value['type'] === 'assistant')
+        && Array.isArray(value['tool_calls']);
+}
+function isToolMessage(value) {
+    return value['type'] === 'tool' && typeof value['tool_call_id'] === 'string';
+}
+function isMessageLike(value) {
+    return typeof value === 'object'
+        && value !== null
+        && ('content' in value
+            || 'type' in value
+            || 'id' in value);
+}
+function isRecord$1(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+const _internalsForTesting = {
+    extractText,
+    extractReasoning,
+    accumulateContent,
+    accumulateReasoning,
+    collapseAdjacentAi,
+    mergeMessages,
+    preserveIds,
+    normalizeMessageType,
+    isFinalCanonicalReasoningContent,
+};
+
+const ROOT_ID = '$';
+/**
+ * Builds a branch-aware checkpoint tree from LangGraph thread history.
+ *
+ * This mirrors the small SDK UI branching data shape without importing the
+ * SDK UI runtime helper, keeping Angular bundles independent of React UI code.
+ */
+function buildBranchTree(history = []) {
+    if (history.length <= 1) {
+        return {
+            type: 'sequence',
+            items: history.map(value => ({ type: 'node', value, path: [] })),
+        };
+    }
+    const nodeIds = new Set();
+    const childrenMap = {};
+    for (const state of history) {
+        const parentId = state.parent_checkpoint?.checkpoint_id ?? ROOT_ID;
+        childrenMap[parentId] ??= [];
+        childrenMap[parentId].push(state);
+        const checkpointId = state.checkpoint?.checkpoint_id;
+        if (checkpointId != null) {
+            nodeIds.add(checkpointId);
+        }
+    }
+    const orphanRoot = findLatestOrphanRoot(childrenMap, nodeIds);
+    if (orphanRoot != null) {
+        childrenMap[ROOT_ID] = childrenMap[orphanRoot];
+    }
+    const rootSequence = { type: 'sequence', items: [] };
+    const queue = [
+        { id: ROOT_ID, sequence: rootSequence, path: [] },
+    ];
+    const visited = new Set();
+    while (queue.length > 0) {
+        const task = queue.shift();
+        if (!task || visited.has(task.id))
+            continue;
+        visited.add(task.id);
+        const children = childrenMap[task.id];
+        if (!children?.length)
+            continue;
+        let fork;
+        if (children.length > 1) {
+            fork = { type: 'fork', items: [] };
+            task.sequence.items.push(fork);
+        }
+        for (const value of children) {
+            const id = value.checkpoint?.checkpoint_id;
+            if (id == null)
+                continue;
+            let sequence = task.sequence;
+            let path = task.path;
+            if (fork != null) {
+                sequence = { type: 'sequence', items: [] };
+                fork.items.unshift(sequence);
+                path = [...task.path, id];
+            }
+            sequence.items.push({ type: 'node', value, path });
+            queue.push({ id, sequence, path });
+        }
+    }
+    return rootSequence;
+}
+function findLatestOrphanRoot(childrenMap, nodeIds) {
+    if (childrenMap[ROOT_ID] != null)
+        return undefined;
+    return Object.keys(childrenMap)
+        .filter(parentId => !nodeIds.has(parentId))
+        .map(parentId => ({
+        parentId,
+        lastId: findLatestDescendantId(parentId, childrenMap),
+    }))
+        .sort((left, right) => left.lastId.localeCompare(right.lastId))
+        .at(-1)?.parentId;
+}
+function findLatestDescendantId(parentId, childrenMap) {
+    const queue = [parentId];
+    const seen = new Set();
+    let latestId = parentId;
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current || seen.has(current))
+            continue;
+        seen.add(current);
+        for (const child of childrenMap[current] ?? []) {
+            const childId = child.checkpoint?.checkpoint_id;
+            if (childId == null)
+                continue;
+            if (childId.localeCompare(latestId) > 0) {
+                latestId = childId;
+            }
+            queue.push(childId);
+        }
+    }
+    return latestId;
+}
+
+function extractCitations(msg) {
+    const raw = msg.additional_kwargs?.['citations'] ?? msg.additional_kwargs?.['sources'];
+    if (!Array.isArray(raw) || raw.length === 0)
+        return undefined;
+    return raw.map((entry, i) => normalizeCitation(entry, i + 1));
+}
+function normalizeCitation(entry, fallbackIndex) {
+    if (typeof entry === 'string') {
+        return { id: `c${fallbackIndex}`, index: fallbackIndex, url: entry };
+    }
+    const e = (entry ?? {});
+    const str = (key) => typeof e[key] === 'string' ? e[key] : undefined;
+    const firstStr = (...keys) => {
+        for (const k of keys) {
+            const v = str(k);
+            if (v !== undefined)
+                return v;
+        }
+        return undefined;
+    };
+    return {
+        id: str('id') ?? str('refId') ?? `c${fallbackIndex}`,
+        index: typeof e['index'] === 'number' ? e['index'] : fallbackIndex,
+        title: firstStr('title', 'name'),
+        url: firstStr('url', 'href', 'source'),
+        snippet: firstStr('snippet', 'content', 'excerpt'),
+        extra: typeof e['extra'] === 'object' && e['extra'] !== null
+            ? e['extra']
+            : undefined,
+    };
+}
+
+// SPDX-License-Identifier: MIT
+/**
+ * Walk LangGraph history (newest-first) and pair each AIMessage id with
+ * the most recent checkpoint that contains it as the tail message in
+ * `values.messages`.
+ *
+ * Implementation: iterate oldest → newest (i.e. reverse the input array)
+ * so later writes overwrite earlier ones; the final map has each
+ * AIMessage paired with the newest containing checkpoint where it is
+ * still the tail. Checkpoints with no AIMessage in scope are skipped.
+ * Checkpoints with no checkpoint_id are skipped.
+ */
+function computeMessageCheckpoints(history) {
+    const out = new Map();
+    for (let i = history.length - 1; i >= 0; i--) {
+        const state = history[i];
+        const cpId = state.checkpoint?.checkpoint_id;
+        if (typeof cpId !== 'string' || cpId.length === 0)
+            continue;
+        const values = state.values;
+        const msgs = Array.isArray(values?.messages) ? values.messages : [];
+        for (let j = msgs.length - 1; j >= 0; j--) {
+            const m = msgs[j];
+            const type = typeof m._getType === 'function' ? m._getType() : m.type;
+            if (type === 'ai' && typeof m.id === 'string') {
+                out.set(m.id, cpId);
+                break;
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Creates a LangGraph-backed Angular agent.
+ *
+ * Must be called within an Angular injection context (component constructor,
+ * field initializer, or `runInInjectionContext`). 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.
+ *
+ * @typeParam T - The state shape returned by the agent
+ * @typeParam Bag - Optional bag template for typed interrupts and submit payloads
+ * @param options - Configuration for the LangGraph agent
+ * @returns A {@link LangGraphAgent} with reactive signals and action methods
+ *
+ * @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),
+ * });
+ *
+ * // Access signals in template
+ * // chat.messages(), chat.status(), chat.error()
+ * ```
+ */
+function agent(options) {
+    // Injection context required
+    const destroyRef = inject(DestroyRef);
+    const globalConfig = inject(AGENT_CONFIG, { optional: true });
+    const destroy$ = new Subject();
+    destroyRef.onDestroy(() => { destroy$.next(); destroy$.complete(); });
+    // Merge: call-site options take precedence over global provider config
+    const apiUrl = options.apiUrl ?? globalConfig?.apiUrl ?? '';
+    const transport = options.transport ?? globalConfig?.transport;
+    const init = (options.initialValues ?? {});
+    // All subjects created before the bridge
+    const status$ = new BehaviorSubject(ResourceStatus.Idle);
+    const values$ = new BehaviorSubject(init);
+    const messages$ = new BehaviorSubject([]);
+    const error$ = new BehaviorSubject(undefined);
+    const interrupt$ = new BehaviorSubject(undefined);
+    const interrupts$ = new BehaviorSubject([]);
+    const branch$ = new BehaviorSubject('');
+    const history$ = new BehaviorSubject([]);
+    const isThreadLoading$ = new BehaviorSubject(false);
+    const toolProgress$ = new BehaviorSubject([]);
+    const toolCalls$ = new BehaviorSubject([]);
+    const messageMetadata$ = new BehaviorSubject(new Map());
+    const subagents$ = new BehaviorSubject(new Map());
+    const queue$ = new BehaviorSubject({
+        entries: [],
+        size: 0,
+        cancel: async () => false,
+        clear: async () => undefined,
+    });
+    const custom$ = new BehaviorSubject([]);
+    const hasValue$ = new BehaviorSubject(false);
+    function resetDerivedThreadState() {
+        status$.next(ResourceStatus.Idle);
+        error$.next(undefined);
+        hasValue$.next(false);
+    }
+    // Track hasValue — becomes true once values or messages arrive
+    values$.pipe(takeUntil$1(destroy$)).subscribe(v => {
+        if (v != null && Object.keys(v).length > 0)
+            hasValue$.next(true);
+    });
+    messages$.pipe(takeUntil$1(destroy$)).subscribe(m => { if (m.length > 0)
+        hasValue$.next(true); });
+    const subjects = {
+        status$, values$, messages$, error$,
+        interrupt$, interrupts$, branch$, history$,
+        isThreadLoading$, toolProgress$, toolCalls$, messageMetadata$, subagents$, queue$, custom$,
+    };
+    // threadId$ — resolved before bridge creation (injection context required for toObservable)
+    const threadId$ = isSignal(options.threadId)
+        ? toObservable(options.threadId)
+        : of(options.threadId ?? null);
+    let hasSeenThreadId = false;
+    let lastThreadId = null;
+    threadId$.pipe(takeUntil$1(destroy$)).subscribe((id) => {
+        if (hasSeenThreadId && lastThreadId !== id) {
+            resetDerivedThreadState();
+        }
+        hasSeenThreadId = true;
+        lastThreadId = id;
+    });
+    // ── Lifecycle instrumentation ─────────────────────────────────────────────
+    // Eight signals tracking key transitions for telemetry/observability.
+    // All reset together via resetLifecycle(); see switchThread() below.
+    const lcStreamStartedAt = signal(null, ...(ngDevMode ? [{ debugName: "lcStreamStartedAt" }] : []));
+    const lcStreamErrorAt = signal(null, ...(ngDevMode ? [{ debugName: "lcStreamErrorAt" }] : []));
+    const lcInterruptReceivedAt = signal(null, ...(ngDevMode ? [{ debugName: "lcInterruptReceivedAt" }] : []));
+    const lcInterruptResolvedAt = signal(null, ...(ngDevMode ? [{ debugName: "lcInterruptResolvedAt" }] : []));
+    const lcThreadCreatedAt = signal(null, ...(ngDevMode ? [{ debugName: "lcThreadCreatedAt" }] : []));
+    const lcThreadPersistedAt = signal(null, ...(ngDevMode ? [{ debugName: "lcThreadPersistedAt" }] : []));
+    const lcToolCallStartedAt = signal(null, ...(ngDevMode ? [{ debugName: "lcToolCallStartedAt" }] : []));
+    const lcToolCallCompletedAt = signal(null, ...(ngDevMode ? [{ debugName: "lcToolCallCompletedAt" }] : []));
+    const lifecycle = {
+        streamStartedAt: lcStreamStartedAt,
+        streamErrorAt: lcStreamErrorAt,
+        interruptReceivedAt: lcInterruptReceivedAt,
+        interruptResolvedAt: lcInterruptResolvedAt,
+        threadCreatedAt: lcThreadCreatedAt,
+        threadPersistedAt: lcThreadPersistedAt,
+        toolCallStartedAt: lcToolCallStartedAt,
+        toolCallCompletedAt: lcToolCallCompletedAt,
+    };
+    // Register with optional lifecycle registry. External instrumentation
+    // (e.g. cockpit-telemetry) provides AgentLifecycleRegistry to receive
+    // per-agent lifecycles created within this injection context.
+    const lifecycleRegistry = inject(AgentLifecycleRegistry, { optional: true });
+    lifecycleRegistry?.register(lifecycle);
+    function resetLifecycle() {
+        lcStreamStartedAt.set(null);
+        lcStreamErrorAt.set(null);
+        lcInterruptReceivedAt.set(null);
+        lcInterruptResolvedAt.set(null);
+        lcThreadCreatedAt.set(null);
+        lcThreadPersistedAt.set(null);
+        lcToolCallStartedAt.set(null);
+        lcToolCallCompletedAt.set(null);
+    }
+    // First chunk: first values$ or messages$ emission with content.
+    values$.pipe(takeUntil$1(destroy$)).subscribe(v => {
+        if (lcStreamStartedAt() === null && v != null && Object.keys(v).length > 0) {
+            lcStreamStartedAt.set(Date.now());
+        }
+    });
+    messages$.pipe(takeUntil$1(destroy$)).subscribe(m => {
+        if (lcStreamStartedAt() === null && m.length > 0)
+            lcStreamStartedAt.set(Date.now());
+    });
+    // Stream error: capture timestamp + classification (Error name or 'unknown').
+    error$.pipe(takeUntil$1(destroy$)).subscribe(e => {
+        if (e == null)
+            return;
+        const classification = e instanceof Error ? e.name : typeof e === 'string' ? 'string' : 'unknown';
+        lcStreamErrorAt.set({ at: Date.now(), classification });
+    });
+    // First non-null interrupt within this thread.
+    interrupt$.pipe(takeUntil$1(destroy$)).subscribe(ix => {
+        if (ix != null && lcInterruptReceivedAt() === null)
+            lcInterruptReceivedAt.set(Date.now());
+    });
+    // First tool call append; first completed/error result transition.
+    const seenToolCallStates = new Map();
+    toolCalls$.pipe(takeUntil$1(destroy$)).subscribe(tcs => {
+        if (tcs.length > 0 && lcToolCallStartedAt() === null)
+            lcToolCallStartedAt.set(Date.now());
+        if (lcToolCallCompletedAt() !== null)
+            return;
+        for (const tc of tcs) {
+            const prev = seenToolCallStates.get(tc.id);
+            if (prev !== tc.state && (tc.state === 'completed' || tc.state === 'error')) {
+                lcToolCallCompletedAt.set(Date.now());
+                seenToolCallStates.set(tc.id, tc.state);
+                break;
+            }
+            seenToolCallStates.set(tc.id, tc.state);
+        }
+    });
+    // Thread restored from server: history$ populates with content for a
+    // pre-existing threadId.
+    history$.pipe(takeUntil$1(destroy$)).subscribe(h => {
+        if (h.length > 0 && lcThreadPersistedAt() === null)
+            lcThreadPersistedAt.set(Date.now());
+    });
+    const manager = createStreamManagerBridge({
+        options: { ...options, apiUrl, transport },
+        subjects,
+        threadId$,
+        destroy$: destroy$.asObservable(),
+    });
+    // Throttle helper — default 16ms (~60fps) to batch SSE token updates into
+    // at most one signal update per frame, preventing change detection storms.
+    const ms = typeof options.throttle === 'number' ? options.throttle : 16;
+    const maybeThrottle = (obs) => ms > 0
+        ? obs.pipe(throttleTime(ms, asyncScheduler, { leading: true, trailing: true }))
+        : obs.asObservable();
+    // Convert to Angular Signals (must happen in injection context)
+    const value = toSignal(maybeThrottle(values$), { initialValue: init });
+    // No throttle on messages$: we need every token emission to propagate to
+    // Angular so streaming markdown actually streams. The bridge already
+    // batches per-tuple at the SDK level; further throttling at the signal
+    // boundary collapses tokens together and breaks visible token-by-token
+    // rendering. Same-frame multiple emissions are coalesced by Angular's
+    // CD anyway.
+    const rawMessages = toSignal(messages$, { initialValue: [] });
+    const statusSig = toSignal(status$, { initialValue: ResourceStatus.Idle });
+    const errorSig = toSignal(error$, { initialValue: undefined });
+    const hasValueSig = toSignal(hasValue$, { initialValue: false });
+    const interruptSig = toSignal(interrupt$, { initialValue: undefined });
+    const interruptsSig = toSignal(interrupts$, { initialValue: [] });
+    const branchSig = toSignal(branch$, { initialValue: '' });
+    const historySig = toSignal(history$, { initialValue: [] });
+    const threadLoadSig = toSignal(isThreadLoading$, { initialValue: false });
+    const toolProgSig = toSignal(toolProgress$, { initialValue: [] });
+    const rawToolCalls = toSignal(toolCalls$, { initialValue: [] });
+    const subagentsSig = toSignal(subagents$, { initialValue: new Map() });
+    const queueSig = toSignal(queue$, { initialValue: queue$.value });
+    const customSig = toSignal(custom$, { initialValue: [] });
+    const isLoading = computed(() => statusSig() === ResourceStatus.Loading, ...(ngDevMode ? [{ debugName: "isLoading" }] : []));
+    const activeSubagents = computed(() => [...subagentsSig().values()].filter(s => s.status() === 'running'), ...(ngDevMode ? [{ debugName: "activeSubagents" }] : []));
+    // ── Runtime-neutral projections ───────────────────────────────────────────
+    // Project BaseMessage → Message on every recompute. We deliberately do
+    // NOT cache: the LangGraph SDK mutates the same AIMessage instance in
+    // place during token streaming (appends content to the same object), so
+    // any identity-based cache returns stale projections and Angular's
+    // `@let content = messageContent(message)` short-circuits — DOM never
+    // updates per token. DOM stability is provided by `track message.id`
+    // in chat-message-list, not by Message identity.
+    const messagesNeutral = computed(() => rawMessages().map((m) => toMessage(m, manager.getReasoningDurationMs)), ...(ngDevMode ? [{ debugName: "messagesNeutral" }] : []));
+    const toolCallsNeutral = computed(() => rawToolCalls().map(toToolCall), ...(ngDevMode ? [{ debugName: "toolCallsNeutral" }] : []));
+    const statusNeutral = computed(() => mapStatus(statusSig()), ...(ngDevMode ? [{ debugName: "statusNeutral" }] : []));
+    const stateNeutral = computed(() => {
+        const v = value();
+        return v && typeof v === 'object' ? v : {};
+    }, ...(ngDevMode ? [{ debugName: "stateNeutral" }] : []));
+    const interruptNeutral = computed(() => {
+        const ix = interruptSig();
+        return ix ? toInterrupt(ix) : undefined;
+    }, ...(ngDevMode ? [{ debugName: "interruptNeutral" }] : []));
+    const subagentsNeutral = computed(() => {
+        const out = new Map();
+        subagentsSig().forEach((sa, key) => out.set(key, toSubagent(sa)));
+        return out;
+    }, ...(ngDevMode ? [{ debugName: "subagentsNeutral" }] : []));
+    const historyNeutral = computed(() => historySig().map(toCheckpoint), ...(ngDevMode ? [{ debugName: "historyNeutral" }] : []));
+    const messageCheckpointsSig = computed(() => computeMessageCheckpoints(historySig()), ...(ngDevMode ? [{ debugName: "messageCheckpointsSig" }] : []));
+    const experimentalBranchTree = computed(() => buildBranchTree(historySig()), ...(ngDevMode ? [{ debugName: "experimentalBranchTree" }] : []));
+    const events$ = buildEvents$(customSig);
+    return {
+        // ── Runtime-neutral surface (AgentWithHistory) ────────────────────────
+        messages: messagesNeutral,
+        status: statusNeutral,
+        isLoading,
+        error: errorSig,
+        toolCalls: toolCallsNeutral,
+        state: stateNeutral,
+        interrupt: interruptNeutral,
+        subagents: subagentsNeutral,
+        events$,
+        history: historyNeutral,
+        messageCheckpoints: messageCheckpointsSig,
+        submit: (input, opts) => {
+            // Lifecycle: first submit with no existing threadId → thread create.
+            if (lcThreadCreatedAt() === null && lastThreadId == null) {
+                lcThreadCreatedAt.set(Date.now());
+            }
+            // Lifecycle: any resume submit marks an interrupt resolution.
+            if (input?.resume !== undefined || opts?.resume !== undefined) {
+                lcInterruptResolvedAt.set(Date.now());
+            }
+            const request = buildSubmitRequest(input, opts);
+            return manager.submit(request.payload, request.options);
+        },
+        stop: () => manager.stop(),
+        regenerate: async (assistantMessageIndex) => {
+            if (isLoading()) {
+                throw new Error('Cannot regenerate while agent is loading another response');
+            }
+            const msgs = messagesNeutral();
+            const target = msgs[assistantMessageIndex];
+            if (!target || target.role !== 'assistant') {
+                throw new Error(`Message at index ${assistantMessageIndex} is not an assistant message`);
+            }
+            // Find the user message immediately preceding the target assistant message.
+            const userIdx = msgs
+                .slice(0, assistantMessageIndex)
+                .map((m, i) => ({ m, i }))
+                .reverse()
+                .find(({ m }) => m.role === 'user')?.i;
+            if (userIdx === undefined) {
+                throw new Error('No user message found before the target assistant message');
+            }
+            // Snapshot the raw BaseMessages that will be REMOVED (everything after userIdx).
+            const rawToRemove = messages$.value.slice(userIdx + 1);
+            // Truncate local buffer INCLUSIVE of the user message. The computed
+            // messagesNeutral signal immediately reflects this — user message is
+            // preserved in the UI while the new response streams in.
+            messages$.next(messages$.value.slice(0, userIdx + 1));
+            // Build RemoveMessage wire-shape instructions for server-side rollback.
+            // LangGraph's add_messages reducer recognises `{ type: 'remove', id }`
+            // and removes those entries from the thread state — ensuring the
+            // runtime re-runs against the same trimmed state rather than appending
+            // new messages on top.
+            const removeList = rawToRemove
+                .map(m => {
+                const raw = m;
+                const id = typeof raw['id'] === 'string' ? raw['id'] : undefined;
+                return id
+                    ? { type: 'remove', role: 'remove', id, content: '' }
+                    : null;
+            })
+                .filter((rm) => rm !== null);
+            // RemoveMessage rollback + reposition the graph to the entry node
+            // via `as_node: '__start__'`. After the original run, the thread is
+            // at `__end__` with `next: []` — submitting `null` would be a no-op
+            // because there is nothing pending to execute. Setting `asNode` to
+            // the start node tells LangGraph to treat the update as if `__start__`
+            // had just produced the values, so the next pull resumes at the entry
+            // node and runs `generate` against the rolled-back state.
+            //
+            // We always pass `asNode` even when removeList is empty (rare, but
+            // possible if the assistant message had no id) so the regenerate
+            // submit below still runs the graph.
+            await manager.updateState({ messages: removeList }, { asNode: '__start__' });
+            // Re-run the graph with no new input. With the thread now repositioned
+            // at `__start__`, this resumes at the entry node and produces a fresh
+            // assistant message — the trailing user message becomes the active
+            // prompt without being re-appended.
+            await manager.submit(null, undefined);
+        },
+        // ── Raw LangGraph signals ─────────────────────────────────────────────
+        langGraphMessages: rawMessages,
+        langGraphInterrupts: interruptsSig,
+        langGraphToolCalls: rawToolCalls,
+        langGraphHistory: historySig,
+        experimentalBranchTree,
+        // ── Other LangGraph-specific fields ──────────────────────────────────
+        value: value,
+        hasValue: hasValueSig,
+        reload: () => manager.resubmitLast(),
+        toolProgress: toolProgSig,
+        queue: queueSig,
+        activeSubagents,
+        getSubagent: (toolCallId) => subagentsSig().get(toolCallId),
+        getSubagentsByType: (type) => [...subagentsSig().values()].filter(sa => sa.name === type),
+        getSubagentsByMessage: (msg) => {
+            const ids = getToolCallIds(msg);
+            const subagents = subagentsSig();
+            return ids
+                .map(id => subagents.get(id))
+                .filter((subagent) => subagent != null);
+        },
+        customEvents: customSig,
+        branch: branchSig,
+        setBranch: (b) => branch$.next(b),
+        isThreadLoading: threadLoadSig,
+        switchThread: (id) => {
+            resetDerivedThreadState();
+            resetLifecycle();
+            seenToolCallStates.clear();
+            manager.switchThread(id);
+        },
+        lifecycle,
+        joinStream: (id, last) => manager.joinStream(id, last),
+        getMessagesMetadata: (msg, idx) => {
+            const id = msg['id'];
+            const key = id != null ? String(id) : idx != null ? String(idx) : undefined;
+            return key ? messageMetadata$.value.get(key) : undefined;
+        },
+        getToolCalls: (msg) => {
+            const id = msg['id'];
+            return id == null
+                ? []
+                : toolCalls$.value.filter(tc => tc.aiMessage['id'] === id);
+        },
+    };
+}
+// ── Private translation helpers (moved from to-agent.ts) ─────────────────────
+/**
+ * Build an Observable<AgentEvent> that bridges LangGraph's
+ * `Signal<CustomStreamEvent[]>` (append-only array) into a stream of newly
+ * emitted events. Each effect firing compares against a cursor tracking the
+ * previously-seen length and emits only the tail slice.
+ */
+function buildEvents$(customSig) {
+    const subject = new Subject();
+    let seen = 0;
+    effect(() => {
+        const all = customSig();
+        if (all.length < seen) {
+            // Stream reset (new session, thread switch, etc.). Rewind cursor.
+            seen = 0;
+        }
+        for (let i = seen; i < all.length; i++) {
+            subject.next(toAgentEvent(all[i]));
+        }
+        seen = all.length;
+    });
+    return subject.asObservable();
+}
+function toAgentEvent(e) {
+    if (e.name === 'state_update' && isRecord(e.data)) {
+        return { type: 'state_update', data: e.data };
+    }
+    return { type: 'custom', name: e.name, data: e.data };
+}
+function mapStatus(s) {
+    switch (s) {
+        case ResourceStatus.Error: return 'error';
+        case ResourceStatus.Loading:
+        case ResourceStatus.Reloading:
+            return 'running';
+        default:
+            return 'idle';
+    }
+}
+function toMessage(m, getReasoningDurationMs) {
+    const raw = m;
+    const typeVal = typeof m._getType === 'function'
+        ? m._getType()
+        : raw['type'] ?? 'ai';
+    const role = typeVal === 'human' ? 'user' :
+        typeVal === 'tool' ? 'tool' :
+            typeVal === 'system' ? 'system' :
+                'assistant';
+    const id = m.id ?? raw['id'] ?? randomId();
+    const reasoning = typeof raw['reasoning'] === 'string' && raw['reasoning'].length > 0
+        ? raw['reasoning']
+        : undefined;
+    const reasoningDurationMs = reasoning && getReasoningDurationMs
+        ? getReasoningDurationMs(id)
+        : undefined;
+    const result = {
+        id,
+        role,
+        content: extractTextContent(m.content),
+        toolCallId: raw['tool_call_id'],
+        name: raw['name'],
+        reasoning,
+        reasoningDurationMs,
+        extra: raw,
+    };
+    const citations = extractCitations(raw);
+    if (citations)
+        result.citations = citations;
+    if (role === 'assistant') {
+        const tcIds = getToolCallIds(m);
+        if (tcIds.length > 0)
+            result.toolCallIds = tcIds;
+    }
+    return result;
+}
+/**
+ * Extract user-visible text from a `BaseMessage.content` value.
+ *
+ * LangChain's `BaseMessage.content` is `string | MessageContentComplex[]`.
+ * Reasoning-capable models (OpenAI gpt-5/o-series, Anthropic) emit complex
+ * arrays of typed blocks: `{type: 'text', text}`, `{type: 'reasoning', ...}`,
+ * tool-use blocks, etc. We render only the visible text portions and skip
+ * anything else. JSON-stringifying the whole array (the previous behaviour)
+ * would dump raw `[{"type":"text",...}]` into the chat bubble.
+ */
+function extractTextContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    let out = '';
+    for (const block of content) {
+        if (typeof block === 'string') {
+            out += block;
+            continue;
+        }
+        if (!isRecord(block))
+            continue;
+        const t = block['type'];
+        // Common text-bearing block shapes across providers.
+        if (t === 'text' || t === 'output_text' || t === undefined) {
+            const text = block['text'];
+            if (typeof text === 'string')
+                out += text;
+        }
+        // Skip reasoning, tool_use, image, etc. — not chat-bubble content.
+    }
+    return out;
+}
+function toToolCall(tc) {
+    const stateMap = {
+        pending: 'pending',
+        completed: 'complete',
+        error: 'error',
+    };
+    const status = stateMap[tc.state] ?? 'running';
+    const result = tc.result;
+    return {
+        id: tc.id,
+        name: tc.call.name,
+        args: tc.call.args,
+        status,
+        result: result?.['content'],
+        error: tc.state === 'error' ? result?.['content'] : undefined,
+    };
+}
+function toInterrupt(ix) {
+    const raw = ix;
+    return {
+        id: raw['id'] ?? randomId(),
+        value: raw['value'] ?? ix,
+        resumable: true,
+    };
+}
+function toSubagent(sa) {
+    return {
+        toolCallId: sa.toolCallId,
+        name: sa.name,
+        status: sa.status,
+        messages: computed(() => sa.messages().map((m) => toMessage(m))),
+        state: sa.values,
+    };
+}
+function getToolCallIds(msg) {
+    const raw = msg;
+    const toolCalls = raw['tool_calls'];
+    if (!Array.isArray(toolCalls))
+        return [];
+    return toolCalls
+        .map(toolCall => isRecord(toolCall) && typeof toolCall['id'] === 'string' ? toolCall['id'] : undefined)
+        .filter((id) => id != null);
+}
+function buildSubmitRequest(input, opts) {
+    return {
+        payload: buildSubmitPayload(input),
+        options: normalizeSubmitOptions(input, opts),
+    };
+}
+function buildSubmitPayload(input) {
+    if (input == null)
+        return null;
+    if (input.resume !== undefined)
+        return null;
+    return buildSubmitUpdate(input) ?? {};
+}
+function normalizeSubmitOptions(input, opts) {
+    const inputResume = input?.resume;
+    const optionResume = opts?.resume;
+    const resume = inputResume !== undefined ? inputResume : optionResume;
+    if (resume === undefined)
+        return opts;
+    const next = { ...(opts ?? {}) };
+    delete next.resume;
+    const command = next.command;
+    const update = buildSubmitUpdate(input);
+    const commandUpdate = mergeCommandUpdate(command?.update, update);
+    return {
+        ...next,
+        command: {
+            ...command,
+            resume,
+            ...(commandUpdate === undefined ? {} : { update: commandUpdate }),
+        },
+    };
+}
+function buildSubmitUpdate(input) {
+    if (input == null)
+        return undefined;
+    if (input.message !== undefined) {
+        const content = typeof input.message === 'string'
+            ? input.message
+            : input.message.map((b) => (b.type === 'text' ? b.text : JSON.stringify(b))).join('');
+        // `type: 'human'` is what `toMessage()` reads via `_getType` || raw['type'];
+        // `role: 'human'` is what the LangGraph server expects in submit payloads.
+        // Include both so the optimistic local copy projects as a 'user' bubble
+        // (otherwise toMessage falls through to the 'ai' default and renders the
+        // user's question as an assistant message).
+        return { messages: [{ type: 'human', role: 'human', content }], ...(input.state ?? {}) };
+    }
+    return input.state;
+}
+function mergeCommandUpdate(existing, update) {
+    if (update === undefined)
+        return existing;
+    if (existing == null)
+        return update;
+    if (isRecord(existing))
+        return { ...existing, ...update };
+    if (Array.isArray(existing))
+        return [...existing, ...Object.entries(update)];
+    return update;
+}
+function randomId() {
+    return Math.random().toString(36).slice(2);
+}
+function toCheckpoint(state) {
+    return {
+        id: state.checkpoint?.checkpoint_id ?? undefined,
+        label: state.next?.[0] ?? undefined,
+        values: isRecord(state.values) ? state.values : {},
+    };
+}
+function isRecord(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+
+// SPDX-License-Identifier: MIT
+const AGENT_LIFECYCLE = new InjectionToken('AGENT_LIFECYCLE');
+
+/**
+ * Test transport for deterministic agent testing without a real LangGraph server.
+ *
+ * Script event batches upfront, then emit them manually or step through them
+ * in your test specs. Supports error injection and close control.
+ *
+ * @example
+ * ```typescript
+ * const transport = new MockAgentTransport([
+ *   [{ type: 'values', messages: [aiMsg('Hello')] }],
+ *   [{ type: 'values', messages: [aiMsg('Done')] }],
+ * ]);
+ * ```
+ */
+class MockAgentTransport {
+    history = [];
+    historyCalls = [];
+    streams = [];
+    createdQueuedRuns = [];
+    cancelledRuns = [];
+    joinedRuns = [];
+    script;
+    scriptIndex = 0;
+    streaming = false;
+    eventQueue = [];
+    // Each resolver simply wakes the stream loop to re-check state.
+    resolvers = [];
+    closed = false;
+    pendingError = null;
+    /** @param script - Array of event batches. Each batch is emitted as a group. */
+    constructor(script = []) {
+        this.script = script;
+    }
+    /** Advance to the next scripted batch. Pass the returned events to `emit()`. */
+    nextBatch() {
+        if (this.scriptIndex >= this.script.length)
+            return [];
+        return this.script[this.scriptIndex++];
+    }
+    /** Manually emit events into the stream. */
+    emit(events) {
+        this.eventQueue.push(...events);
+        this.flush();
+    }
+    /** Inject an error into the stream. */
+    emitError(err) {
+        this.pendingError = err;
+        this.flush();
+    }
+    /** Close the stream. Remaining queued events are drained before completion. */
+    close() {
+        this.closed = true;
+        this.flush();
+    }
+    /** Returns true if a stream is currently active. */
+    isStreaming() {
+        return this.streaming;
+    }
+    async *stream(_assistantId, _threadId, _payload, signal, options) {
+        this.streams.push({ threadId: _threadId, payload: _payload, options });
+        this.streaming = true;
+        try {
+            while (!this.closed && !signal.aborted) {
+                if (this.pendingError)
+                    throw this.pendingError;
+                if (this.eventQueue.length > 0) {
+                    const event = this.eventQueue.shift();
+                    if (event)
+                        yield event;
+                }
+                else {
+                    // Wait until flush() wakes us, then loop again to check state.
+                    await new Promise((resolve) => {
+                        if (signal.aborted) {
+                            resolve();
+                            return;
+                        }
+                        this.resolvers.push(resolve);
+                    });
+                }
+            }
+            if (signal.aborted)
+                return;
+            // Drain remaining events after close()
+            while (this.eventQueue.length > 0) {
+                const event = this.eventQueue.shift();
+                if (event)
+                    yield event;
+            }
+        }
+        finally {
+            this.streaming = false;
+        }
+    }
+    async createQueuedRun(_assistantId, threadId, payload, signal, options) {
+        void signal;
+        const entry = {
+            id: `queued-run-${this.createdQueuedRuns.length + 1}`,
+            threadId,
+            values: payload,
+            options: { ...options, multitaskStrategy: 'enqueue' },
+            createdAt: new Date(),
+        };
+        this.createdQueuedRuns.push(entry);
+        return entry;
+    }
+    async cancelRun(threadId, runId, signal) {
+        void signal;
+        this.cancelledRuns.push({ threadId, runId });
+    }
+    async getHistory(threadId, signal) {
+        void signal;
+        this.historyCalls.push(threadId);
+        return this.history;
+    }
+    async *joinStream(threadId, runId, lastEventId, signal) {
+        void lastEventId;
+        void signal;
+        this.joinedRuns.push({ threadId, runId });
+        yield { type: 'values', values: { queued: true } };
+    }
+    flush() {
+        const resolve = this.resolvers.shift();
+        if (resolve)
+            resolve();
+    }
+}
+
+// SPDX-License-Identifier: MIT
+/**
+ * Creates a mock LangGraphAgent with writable signals for testing.
+ * Control state by writing to the returned writable signals directly.
+ */
+function mockLangGraphAgent(initial = {}) {
+    const messages$ = signal(initial.messages ?? [], ...(ngDevMode ? [{ debugName: "messages$" }] : []));
+    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({
+        entries: [],
+        size: 0,
+        cancel: async () => false,
+        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$" }] : []));
+    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$,
+        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$,
+        langGraphToolCalls: langGraphToolCalls$,
+        langGraphHistory: langGraphHistory$,
+        experimentalBranchTree: experimentalBranchTree$,
+        // ── Other AgentRef fields preserved ──────────────────────────────────
+        value: value$,
+        hasValue: hasValue$,
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        reload: () => { },
+        toolProgress: toolProgress$,
+        queue: queue$,
+        activeSubagents: activeSubagents$,
+        getSubagent: (toolCallId) => activeSubagents$().find(subagent => subagent.toolCallId === toolCallId),
+        getSubagentsByType: (type) => activeSubagents$().filter(subagent => subagent.name === type),
+        getSubagentsByMessage: (msg) => {
+            const toolCalls = msg['tool_calls'];
+            if (!Array.isArray(toolCalls))
+                return [];
+            const ids = toolCalls
+                .map(toolCall => {
+                if (toolCall == null || typeof toolCall !== 'object' || Array.isArray(toolCall))
+                    return undefined;
+                const id = toolCall['id'];
+                return typeof id === 'string' ? id : undefined;
+            })
+                .filter((id) => id != null);
+            return activeSubagents$().filter(subagent => ids.includes(subagent.toolCallId));
+        },
+        customEvents: customEvents$,
+        branch: branch$,
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        setBranch: (_branch) => { },
+        isThreadLoading: isThreadLoading$,
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        switchThread: (_threadId) => { },
+        joinStream: (_runId, _lastEventId) => Promise.resolve(),
+        getMessagesMetadata: (_msg, _idx) => undefined,
+        getToolCalls: (_msg) => [],
+        lifecycle: {
+            streamStartedAt: signal(null),
+            streamErrorAt: signal(null),
+            interruptReceivedAt: signal(null),
+            interruptResolvedAt: signal(null),
+            threadCreatedAt: signal(null),
+            threadPersistedAt: signal(null),
+            toolCallStartedAt: signal(null),
+            toolCallCompletedAt: signal(null),
+        },
+    };
+    return mock;
+}
+
+// SPDX-License-Identifier: MIT
+const LANGGRAPH_THREADS_CONFIG = new InjectionToken('LANGGRAPH_THREADS_CONFIG');
+/** Optional adapter clients can pass an explicit Client (e.g. for
+ *  testing). When omitted, the adapter constructs one via
+ *  {@link createLangGraphClient}. */
+const LANGGRAPH_CLIENT = new InjectionToken('LANGGRAPH_CLIENT');
+/**
+ * SDK-backed thread store. Wraps `client.threads.*` and maps SDK
+ * threads to the framework's {@link Thread} type for direct use with
+ * `<chat-thread-list>` / `<chat-sidenav>`.
+ *
+ * Consumers wire the framework's `ThreadActionAdapter` to instance
+ * methods (rename/delete/archive/pin/...) so the right-click menu
+ * round-trips through the LangGraph SDK without per-app boilerplate.
+ *
+ * @example
+ * ```ts
+ * const svc = inject(LangGraphThreadsAdapter);
+ * const actions: ThreadActionAdapter = {
+ *   rename: (id, t) => svc.rename(id, t),
+ *   delete: (id) => svc.delete(id),
+ * };
+ * ```
+ */
+class LangGraphThreadsAdapter {
+    config = inject(LANGGRAPH_THREADS_CONFIG);
+    client = inject(LANGGRAPH_CLIENT, { optional: true })
+        ?? createLangGraphClient(this.config.apiUrl);
+    fallback = this.config.titleFallback ?? 'Untitled';
+    _threads = signal([], ...(ngDevMode ? [{ debugName: "_threads" }] : []));
+    _archived = signal([], ...(ngDevMode ? [{ debugName: "_archived" }] : []));
+    /** Active (non-archived) threads, sorted with pinned first. */
+    threads = this._threads.asReadonly();
+    /** Threads whose `metadata.archived === true`. */
+    archivedThreads = this._archived.asReadonly();
+    /** Fetch the latest thread list from the server. Failures are
+     *  logged via `console.error` (not swallowed silently — silent
+     *  catches have masked prod issues in the past).
+     *
+     *  Invocation and resolution are logged at `console.debug` so prod
+     *  inspection can distinguish "never called" from "called but
+     *  resolved empty" from "called and threw." This was prompted by a
+     *  demo.threadplane.ai cold-load bug where the sidenav stayed empty
+     *  with no visible signal. Tighten the log volume if it becomes
+     *  noisy. */
+    async refresh() {
+        console.debug('[LangGraphThreadsAdapter.refresh] invoked');
+        try {
+            const list = await this.client.threads.search({ limit: 50 });
+            console.debug('[LangGraphThreadsAdapter.refresh] resolved', list.length);
+            const mapped = list.map((t) => this.toThread(t));
+            this._threads.set(mapped
+                .filter((t) => t.status !== 'archived')
+                .sort((a, b) => {
+                const aP = a.pinned === true;
+                const bP = b.pinned === true;
+                if (aP !== bP)
+                    return Number(bP) - Number(aP);
+                if (aP && bP) {
+                    const aO = typeof a['pinnedOrder'] === 'number' ? a['pinnedOrder'] : Infinity;
+                    const bO = typeof b['pinnedOrder'] === 'number' ? b['pinnedOrder'] : Infinity;
+                    return aO - bO;
+                }
+                return 0;
+            }));
+            this._archived.set(mapped.filter((t) => t.status === 'archived'));
+        }
+        catch (e) {
+            console.error('[LangGraphThreadsAdapter.refresh] failed:', e);
+        }
+    }
+    /** Fetch a single thread by id. Returns `null` when the server
+     *  returns 404 (thread doesn't exist) so callers can distinguish
+     *  "missing" from "couldn't reach the server" — genuine network
+     *  errors rethrow. Used by URL-based thread routing to validate a
+     *  pasted/shared thread id before activating it. */
+    async getThread(threadId) {
+        try {
+            const t = await this.client.threads.get(threadId);
+            return this.toThread(t);
+        }
+        catch (e) {
+            // SDK throws HTTPError-like objects without a typed error class;
+            // sniff status on the error or its nested response. Treat both
+            // 404 (server says "no such thread") and 422 (server says "id
+            // isn't even a valid UUID") as "missing" — both warrant the
+            // same caller behavior (redirect to a fresh chat).
+            const status = e.status ??
+                e.response?.status;
+            if (status === 404 || status === 422)
+                return null;
+            throw e;
+        }
+    }
+    async create(metadata = {}) {
+        try {
+            const t = await this.client.threads.create({ metadata });
+            await this.refresh();
+            return t.thread_id;
+        }
+        catch (e) {
+            console.error('[LangGraphThreadsAdapter.create] failed:', e);
+            return null;
+        }
+    }
+    async delete(threadId) {
+        await this.client.threads.delete(threadId);
+        await this.refresh();
+    }
+    async rename(threadId, newTitle) {
+        await this.client.threads.update(threadId, { metadata: { title: newTitle } });
+        await this.refresh();
+    }
+    async archive(threadId) {
+        await this.client.threads.update(threadId, { metadata: { archived: true } });
+        await this.refresh();
+    }
+    async unarchive(threadId) {
+        await this.client.threads.update(threadId, { metadata: { archived: false } });
+        await this.refresh();
+    }
+    async pin(threadId) {
+        await this.client.threads.update(threadId, { metadata: { pinned: true } });
+        await this.refresh();
+    }
+    async unpin(threadId) {
+        await this.client.threads.update(threadId, { metadata: { pinned: false } });
+        await this.refresh();
+    }
+    async moveToProject(threadId, projectId) {
+        await this.client.threads.update(threadId, { metadata: { projectId } });
+        await this.refresh();
+    }
+    /** Re-stamp `metadata.pinnedOrder = 0,1,2,...` for the pinned slice
+     *  to reflect the new ordering. */
+    async reorderPinned(threadId, beforeId) {
+        const current = this._threads().filter((t) => t.pinned === true);
+        const moved = current.find((t) => t.id === threadId);
+        if (!moved)
+            return;
+        const rest = current.filter((t) => t.id !== threadId);
+        const next = [];
+        for (const t of rest) {
+            if (t.id === beforeId)
+                next.push(moved);
+            next.push(t);
+        }
+        if (beforeId === null)
+            next.push(moved);
+        await Promise.all(next.map((t, idx) => this.client.threads.update(t.id, { metadata: { pinnedOrder: idx } })));
+        await this.refresh();
+    }
+    toThread(t) {
+        const meta = (t.metadata ?? {});
+        const rawTitle = meta['title'];
+        const archived = meta['archived'] === true;
+        const pinned = meta['pinned'] === true;
+        const projectId = typeof meta['projectId'] === 'string' && meta['projectId'].length > 0
+            ? meta['projectId']
+            : null;
+        const pinnedOrder = typeof meta['pinnedOrder'] === 'number' ? meta['pinnedOrder'] : undefined;
+        return {
+            id: t.thread_id,
+            title: typeof rawTitle === 'string' && rawTitle.length > 0 ? rawTitle : this.fallback,
+            status: archived ? 'archived' : 'active',
+            pinned,
+            projectId,
+            pinnedOrder,
+            updatedAt: t.updated_at ? Date.parse(t.updated_at) : undefined,
+        };
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.1.6", ngImport: i0, type: LangGraphThreadsAdapter, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.1.6", ngImport: i0, type: LangGraphThreadsAdapter, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.1.6", ngImport: i0, type: LangGraphThreadsAdapter, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+// SPDX-License-Identifier: MIT
+/**
+ * Call `fn` whenever the agent's status transitions out of `'running'`
+ * (i.e. when a run completes — success, error, or interrupt). Useful
+ * for refreshing thread lists, telemetry, or any other state that
+ * lags the agent.
+ *
+ * Must be called within an injection context (constructor or
+ * `runInInjectionContext`) — uses Angular's `effect` under the hood.
+ *
+ * @example
+ * ```ts
+ * constructor() {
+ *   refreshOnRunEnd(this.agent, () => this.threads.refresh());
+ * }
+ * ```
+ */
+function refreshOnRunEnd(agent, fn) {
+    let lastStatus = agent.status();
+    effect(() => {
+        const status = agent.status();
+        if (lastStatus === 'running' && status !== 'running') {
+            void fn();
+        }
+        lastStatus = status;
+    });
+}
+/**
+ * Call `fn` whenever any of the watched signals transitions from a
+ * truthy "active" value to a non-active value. Generic version of
+ * {@link refreshOnRunEnd} for callers tracking custom state machines.
+ *
+ * Must be called within an injection context.
+ */
+function refreshOnTransition(watch, isActive, fn) {
+    let lastActive = isActive(watch());
+    effect(() => {
+        const active = isActive(watch());
+        if (lastActive && !active)
+            void fn();
+        lastActive = active;
+    });
+}
+
+// SPDX-License-Identifier: MIT
+// Primary function
+
+/**
+ * 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 };
+//# sourceMappingURL=threadplane-langgraph.mjs.map