@threadplane/langgraph 0.0.50 → 0.0.51

package/fesm2022/threadplane-langgraph.mjs

@@ -5,7 +5,7 @@ import { takeUntil, Subject, BehaviorSubject, of, throttleTime, asyncScheduler }
 import { takeUntil as takeUntil$1 } from 'rxjs/operators';
 import { Client } from '@langchain/langgraph-sdk';
 import { getToolCallsWithResults } from '@langchain/langgraph-sdk/utils';
-import { mockAgent } from '@threadplane/chat';
+import { toAgentError, isAbortError, AgentError, AGENT_ERROR_MESSAGES, mockAgent } from '@threadplane/chat';
 
 // SPDX-License-Identifier: MIT
 /**
@@ -537,6 +537,8 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
     let abortController = null;
     let historyAbortController = null;
     let hasSeenThreadId = false;
+    /** True when the current abort was user-initiated (via stop()). Reset at the start of every new runStream(). */
+    let userAbortRequested = false;
     const toolProgressMap = new Map();
     const queuedRuns = [];
     let drainingQueue = false;
@@ -570,7 +572,7 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
         subjects.toolCalls$.next([]);
         subjects.messageMetadata$.next(new Map());
         subjects.subagents$.next(new Map());
-        void cancelQueueEntries(takeQueuedRuns()).catch(err => subjects.error$.next(err));
+        void cancelQueueEntries(takeQueuedRuns()).catch(err => subjects.error$.next(toAgentError(err)));
         publishQueue();
         subjects.custom$.next([]);
         subjects.isThreadLoading$.next(false);
@@ -647,7 +649,7 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
         }
         catch (err) {
             if (!controller.signal.aborted && err?.name !== 'AbortError') {
-                subjects.error$.next(err);
+                subjects.error$.next(toAgentError(err));
             }
         }
         finally {
@@ -759,7 +761,7 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
             }
         }
         catch (err) {
-            subjects.error$.next(err);
+            subjects.error$.next(toAgentError(err));
             subjects.status$.next(ResourceStatus.Error);
             captureAgentRuntimeTelemetry(options.telemetry, 'ngaf:stream_errored', {
                 ...telemetryProperties,
@@ -771,6 +773,7 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
     async function runStream(payload, opts, requestType = 'submit') {
         abortController?.abort();
         abortController = new AbortController();
+        userAbortRequested = false;
         const startedAt = Date.now();
         captureRuntimeRequestTelemetry(requestType);
         captureAgentRuntimeTelemetry(options.telemetry, 'ngaf:stream_started', telemetryProperties);
@@ -781,6 +784,10 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
         toolProgressMap.clear();
         lastPayload = payload;
         lastOptions = opts;
+        // Tracks whether at least one stream event has been processed this run.
+        // Used to distinguish a mid-stream network interruption (kind:'interrupted')
+        // from a fresh connect failure (falls through to toAgentError classification).
+        let streamingStarted = false;
         // 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
@@ -804,6 +811,7 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
             for await (const event of iter) {
                 if (abortController.signal.aborted)
                     break;
+                streamingStarted = true;
                 processEvent(event);
             }
             if (!abortController.signal.aborted) {
@@ -819,11 +827,26 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
             }
         }
         catch (err) {
-            if (err?.name === 'AbortError') {
-                subjects.status$.next(ResourceStatus.Resolved);
+            if (isAbortError(err) && userAbortRequested) {
+                // User explicitly called stop() — treat as graceful idle, not an error.
+                subjects.status$.next(ResourceStatus.Idle);
+            }
+            else if (isAbortError(err)) {
+                // A non-user-requested abort: interrupted if a stream had started, else a
+                // connect-phase failure. Never "aborted" (that's reserved for user stop).
+                const e = streamingStarted
+                    ? new AgentError({ kind: 'interrupted', message: AGENT_ERROR_MESSAGES.interrupted, retryable: true, cause: err })
+                    : new AgentError({ kind: 'connection', message: AGENT_ERROR_MESSAGES.connection, retryable: true, cause: err });
+                subjects.error$.next(e);
+                subjects.status$.next(ResourceStatus.Error);
+                captureAgentRuntimeTelemetry(options.telemetry, 'ngaf:stream_errored', {
+                    ...telemetryProperties,
+                    durationMs: Date.now() - startedAt,
+                    errorClass: agentRuntimeTelemetryErrorClass(err),
+                });
             }
             else {
-                subjects.error$.next(err);
+                subjects.error$.next(toAgentError(err));
                 subjects.status$.next(ResourceStatus.Error);
                 captureAgentRuntimeTelemetry(options.telemetry, 'ngaf:stream_errored', {
                     ...telemetryProperties,
@@ -958,7 +981,7 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
                 break;
             }
             case 'error':
-                subjects.error$.next(event['error']);
+                subjects.error$.next(toAgentError(event['error']));
                 subjects.status$.next(ResourceStatus.Error);
                 break;
             case 'interrupt':
@@ -1102,9 +1125,16 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
             await runStream(payload, opts);
         },
         stop: async () => {
+            userAbortRequested = true;
             abortController?.abort();
             await clearQueue();
-            subjects.status$.next(ResourceStatus.Resolved);
+            // Note: status is set to Idle by the runStream() catch when it sees
+            // isAbortError && userAbortRequested. The explicit set here handles
+            // the case where stop() is called when no stream is active (so the
+            // catch never fires) or when clearQueue() raised an error.
+            if (subjects.status$.value !== ResourceStatus.Idle) {
+                subjects.status$.next(ResourceStatus.Idle);
+            }
         },
         switchThread: (id) => {
             setThreadId(id, true);
@@ -1136,7 +1166,7 @@ function createStreamManagerBridge({ options, subjects, threadId$, destroy$ }) {
                 });
             }
             catch (err) {
-                subjects.error$.next(err);
+                subjects.error$.next(toAgentError(err));
                 subjects.status$.next(ResourceStatus.Error);
                 captureAgentRuntimeTelemetry(options.telemetry, 'ngaf:stream_errored', {
                     ...telemetryProperties,
@@ -2218,6 +2248,9 @@ function agent(options) {
     // CD anyway.
     const rawMessages = toSignal(messages$, { initialValue: [] });
     const statusSig = toSignal(status$, { initialValue: ResourceStatus.Idle });
+    // Cast justified: error$ accepts only AgentError | undefined (bridge catch normalizes all errors via
+    // toAgentError before calling next(); resetDerivedThreadState passes undefined). The BehaviorSubject
+    // is typed unknown to satisfy StreamSubjects<unknown> invariance at the subjects-bag assignment.
     const errorSig = toSignal(error$, { initialValue: undefined });
     const hasValueSig = toSignal(hasValue$, { initialValue: false });
     const interruptSig = toSignal(interrupt$, { initialValue: undefined });
@@ -2314,6 +2347,12 @@ function agent(options) {
             return manager.submit(payload, request.options);
         },
         stop: () => manager.stop(),
+        retry: async () => {
+            if (isLoading())
+                return; // no-op while a run is in flight
+            error$.next(undefined); // clear the error before re-running
+            await manager.resubmitLast();
+        },
         clientTools: clientToolsCap,
         regenerate: async (assistantMessageIndex) => {
             if (isLoading()) {
@@ -2655,81 +2694,53 @@ const AGENT_CONFIG = new InjectionToken('AGENT_CONFIG');
  * @internal — exported for spec access only. Consumers must use `injectAgent()`.
  */
 const AGENT = new InjectionToken('AGENT');
-/**
- * Wire the LangGraph adapter into Angular's dependency injection.
- *
- * Registers a singleton `LangGraphAgent` constructed from `config`. Retrieve it
- * in any component with `injectAgent()`. Provide this at the application root
- * (`app.config.ts`) for an app-wide agent.
- *
- * To use a different agent in a component subtree, re-provide
- * `provideAgent({...})` in that component's `providers: []` array —
- * Angular's hierarchical DI scopes the singleton accordingly.
- *
- * **Static vs factory config.** Pass a plain `AgentConfig` object when the
- * config is known up front. Pass a `() => AgentConfig` factory when the config
- * depends on runtime/DI state — the factory runs inside an Angular injection
- * context, so it may call `inject()` to read services, route params, or
- * component-scoped signals:
- *
- * ```ts
- * providers: [
- *   provideAgent(() => {
- *     const route = inject(ActivatedRoute);
- *     return { assistantId: 'chat', threadId: toSignal(route.paramMap) };
- *   }),
- * ];
- * ```
- */
-function provideAgent(configOrFactory) {
+/** @internal — shared factory that reads AGENT_CONFIG and constructs the singleton. */
+function agentFactory() {
+    // useFactory runs in an injection context, so the legacy `agent()`
+    // factory's `inject(DestroyRef)` calls work.
+    const config = inject(AGENT_CONFIG);
+    if (config.assistantId === undefined) {
+        throw new Error('provideAgent: `assistantId` is required to construct the AGENT singleton.');
+    }
+    return agent({
+        assistantId: config.assistantId,
+        ...(config.apiUrl !== undefined ? { apiUrl: config.apiUrl } : {}),
+        ...(config.threadId !== undefined ? { threadId: config.threadId } : {}),
+        ...(config.onThreadId !== undefined ? { onThreadId: config.onThreadId } : {}),
+        ...(config.initialValues !== undefined ? { initialValues: config.initialValues } : {}),
+        ...(config.throttle !== undefined ? { throttle: config.throttle } : {}),
+        ...(config.toMessage !== undefined ? { toMessage: config.toMessage } : {}),
+        ...(config.transport !== undefined ? { transport: config.transport } : {}),
+        ...(config.clientOptions !== undefined ? { clientOptions: config.clientOptions } : {}),
+        ...(config.telemetry !== undefined ? { telemetry: config.telemetry } : {}),
+        ...(config.filterSubagentMessages !== undefined ? { filterSubagentMessages: config.filterSubagentMessages } : {}),
+        ...(config.subagentToolNames !== undefined ? { subagentToolNames: config.subagentToolNames } : {}),
+    });
+}
+function isAgentRef(x) {
+    return typeof x === 'object' && x !== null && 'token' in x;
+}
+function provideAgent(refOrConfig, maybeConfig) {
+    const ref = isAgentRef(refOrConfig) ? refOrConfig : undefined;
+    const configOrFactory = (ref ? maybeConfig : refOrConfig);
     // Resolve the factory (if any) lazily, inside the injection context of the
     // AGENT_CONFIG useFactory below — never at decoration time.
     const resolveConfig = () => typeof configOrFactory === 'function' ? configOrFactory() : configOrFactory;
-    return [
+    const providers = [
         // AGENT_CONFIG resolves the config once (running the factory in an
         // injection context if a factory was passed). AGENT reads the resolved
         // config from here, so the factory is invoked exactly once.
         { provide: AGENT_CONFIG, useFactory: resolveConfig },
-        {
-            provide: AGENT,
-            useFactory: () => {
-                // useFactory runs in an injection context, so the legacy `agent()`
-                // factory's `inject(DestroyRef)` calls work.
-                const config = inject(AGENT_CONFIG);
-                if (config.assistantId === undefined) {
-                    throw new Error('provideAgent: `assistantId` is required to construct the AGENT singleton.');
-                }
-                return agent({
-                    assistantId: config.assistantId,
-                    ...(config.apiUrl !== undefined ? { apiUrl: config.apiUrl } : {}),
-                    ...(config.threadId !== undefined ? { threadId: config.threadId } : {}),
-                    ...(config.onThreadId !== undefined ? { onThreadId: config.onThreadId } : {}),
-                    ...(config.initialValues !== undefined ? { initialValues: config.initialValues } : {}),
-                    ...(config.throttle !== undefined ? { throttle: config.throttle } : {}),
-                    ...(config.toMessage !== undefined ? { toMessage: config.toMessage } : {}),
-                    ...(config.transport !== undefined ? { transport: config.transport } : {}),
-                    ...(config.clientOptions !== undefined ? { clientOptions: config.clientOptions } : {}),
-                    ...(config.telemetry !== undefined ? { telemetry: config.telemetry } : {}),
-                    ...(config.filterSubagentMessages !== undefined ? { filterSubagentMessages: config.filterSubagentMessages } : {}),
-                    ...(config.subagentToolNames !== undefined ? { subagentToolNames: config.subagentToolNames } : {}),
-                });
-            },
-        },
+        { provide: AGENT, useFactory: (agentFactory) },
     ];
+    if (ref)
+        providers.push({ provide: ref.token, useExisting: AGENT });
+    return providers;
 }
 
 // SPDX-License-Identifier: MIT
-/**
- * Retrieve the LangGraph-backed Agent from the current Angular injection context.
- *
- * Mirrors `@threadplane/ag-ui`'s `injectAgent()` so consumer code is identical
- * regardless of which adapter is wired in `app.config.ts`. The agent is a
- * singleton scoped to the injector that called `provideAgent()` — re-provide
- * in a child component's `providers: []` to scope a different agent to that
- * subtree (Angular's hierarchical DI handles the rest).
- */
-function injectAgent() {
-    return inject(AGENT);
+function injectAgent(ref) {
+    return inject(ref ? ref.token : AGENT);
 }
 
 // SPDX-License-Identifier: MIT