nexus-ai-pro 2.17.0 → 2.18.0

package/API_STABILITY.md

@@ -41,6 +41,41 @@ Both are covered by this policy:
 Deep imports into `dist`, `dist-cjs`, or `src` are not supported. Import only from `nexus-ai-pro` or
 one of its explicit subpaths.
 
+## 2.18 stage (2.18.0)
+
+Everything 2.18 adds is stable from the start and additive, unless this section says otherwise.
+
+New and stable:
+- in `nexus-ai-pro/tracing`: `RunEvent`, `RunLink`, `RunAttributeValue`, `RunEventInput`, `RunLinkInput`,
+  `Run.events`, `droppedEvents`, and `links`, `Tracer.event()`, `RunHandle.event()` and `link()`,
+  `StartRunOptions.links`, `FinishRunOptions.events` and `links`, `TracerOptions.maxEventsPerRun`, and
+  the event names `retry`, `failover`, `progress`, `guardrail`, `cache`, and `capability_warning`;
+- in `nexus-ai-pro/tracing/otlp`: `OtlpSpanEvent`, `OtlpSpanLink`, and `OtlpSpan.events`,
+  `droppedEventsCount`, and `links`;
+- in the root: `ResponseAttempt` and `ResponseMeta.failedAttempts`;
+- in `nexus-ai-pro/evaluate/media`: `readMediaDuration()` and `MediaDuration`;
+- in `nexus-ai-pro/video`, experimental with the family: `VideoModelCapabilities.maxInputVideoSeconds`;
+- in `nexus-ai-pro/server/regions`: `RegionalGatewayOptions.lists`, `RegionListGap`, and a merged
+  list's `regions`, `incomplete`, and `nextCursor`;
+- in `nexus-ai-pro/server`: `ListPage`, `RunManager.listThreads()` and `listRuns()`, and the lists'
+  `cursor` and `nextCursor`;
+- in `nexus-ai-pro/mcp`: `McpClientOptions.reconnect`, `McpClient.onToolsChanged()`, and
+  `SseClientOptions.reopen`;
+- in `nexus-ai-pro/video`, experimental with the family: `VideoGenerateRequest.referenceVideos` and
+  `VideoProviderRequest.referenceVideos`, the `reference-videos` input kind,
+  `VideoModelCapabilities.maxReferenceVideos` and `referenceVideoSeconds`, and
+  `VideoConformanceOptions.referenceVideo`;
+- in `nexus-ai-pro/video/google`, experimental with the family:
+  `GoogleVideoProviderConfig.interactionsBaseUrl`, and Gemini Omni Flash on Vertex AI.
+
+Changed on purpose:
+- a list through the regional gateway is merged from every region the tenant may reach;
+  `lists: 'home'` keeps the earlier answer;
+- an agent server's lists are ordered by last write, then id, and a `limit` that is not a whole
+  number above 0 is refused;
+- `McpServer` says `tools.listChanged`, and `register()` sends the notification;
+- `VideoInputKind` widens with `reference-videos`.
+
 ## 2.17 stage (2.17.0)
 
 Everything 2.17 adds is stable from the start and additive, unless this section says otherwise.

package/CHANGELOG.md

@@ -4,6 +4,82 @@ Notable changes to this project are recorded here. The format follows [Keep a Ch
 
 ## [Unreleased]
 
+## [2.18.0] - 2026-10-22
+
+Span events and links, media that knows its length, a tenant's threads and runs listed and paged
+across all of its regions, MCP servers that reconnect and change their tools mid-session, and videos
+made after reference videos.
+
+### Added
+
+- **Span events and links.** A run records what happened inside it as `RunEvent` values, each at its
+  time, and the runs it came from beside its parent as `RunLink` values. `Tracer.event()` records on
+  the run in scope, `RunHandle.event()` and `link()` on one run; `StartRunOptions.links` take a link
+  or a W3C `traceparent`, and `FinishRunOptions` take the `events` and `links` a run learns as it
+  ends. `maxEventsPerRun` (128) keeps a run's events bounded, counting the rest as `droppedEvents`.
+  Both reach OTLP as span events and links, in JSON, in protobuf, and over gRPC. The studio shows them
+  on a run, each link opening the run it names, and `#/traces/<trace>/<run>` opens one run of a trace.
+- **Events where they happen.** A graph's retry is a `retry` event of its task's run, a tool's
+  progress a `progress` event of the tool's, and a task after a step of several, such as a fan-out's
+  join, links to each of them. A model run has the attempts that failed before its answer, as `retry`
+  and `failover` at the times they failed, and its guardrails, cache answer, and capability warnings.
+- **Failed attempts on the response.** `ResponseMeta.failedAttempts` lists each `ResponseAttempt` that
+  failed before the answer: its provider, model, error, category, and time; a stream's last chunk
+  carries them too.
+- **Media that knows its length.** `readMediaDuration()`, on `nexus-ai-pro/evaluate/media`, reads the
+  length of WAV, MP4 and MOV (fragmented MP4 included), WebM and Matroska, MP3, Ogg Vorbis and Opus,
+  and FLAC from their own headers, with no dependency. `mediaChecks()` holds audio and video to a
+  `durationMs` range with it, and a video model's `maxInputVideoSeconds` refuses a longer video before
+  it is sent: 10 seconds on Gemini Omni Flash, 30 on Veo.
+- **Lists across regions.** The regional gateway answers `GET /threads` and `GET /runs` from every
+  region the tenant may reach, merged newest first and cut to the limit, naming the regions that
+  answered and, as `RegionListGap` values under `incomplete`, those that were down or failed. A
+  refusal every region gives is the answer. `lists: 'home'` keeps the home region's list alone.
+- **Lists that page.** An agent server's `GET /threads`, `GET /runs`, and `GET /threads/:id/runs`
+  take a `cursor` and answer with a `nextCursor` while more follow; `RunManager.listThreads()` and
+  `listRuns()` return a `ListPage`. A cursor names a place in the order every region lists by, so the
+  regional gateway pages a merged list with it too, each record once, in order, however the records
+  fall between regions. A region that does not page by it contributes only what comes after it.
+- **MCP that reconnects.** With `McpClientOptions.reconnect`, a client whose connection closed opens
+  it again at the next request and greets the server again: an SSE stream that ended, with
+  `SseClientOptions.reopen`, or a stdio server that exited, started again. A stream that cannot open,
+  or names no endpoint in time, is let go at once, so the next request tries again.
+- **Tools that change.** `McpClient.onToolsChanged()` hears a server's
+  `notifications/tools/list_changed`. `McpServer.register()` sends one to a connected client, and the
+  server says it will. The editor bridge reconnects an editor's SSE servers within a session and lists
+  a server's tools again before the turn after it says they changed, keeping the last list when that
+  fails.
+- **Reference videos.** `VideoGenerateRequest.referenceVideos` gives a model videos to take after.
+  Models declare `reference-videos` among their inputs, with `maxReferenceVideos` and
+  `referenceVideoSeconds`, each and together, read from a video's headers before it is sent. Gemini
+  Omni Flash takes three of three seconds each, as does Runway's `gemini_omni_flash_1.1`; Runway's
+  Seedance 2 models, `hailuo3`, and `wan3` take 15 seconds together, beside reference images. The
+  conformance suite checks them with `referenceVideo`.
+- **Gemini Omni Flash on Vertex AI.** `GoogleVideoProvider` serves `gemini-omni-1.1-flash-preview` on
+  Vertex AI's Interactions API, at the global location for the project its `baseUrl` names, or at
+  `interactionsBaseUrl`.
+
+### Changed
+
+- A list of threads or runs through the regional gateway comes from every region the tenant may
+  reach, not its home region alone; `RegionalGatewayOptions.lists: 'home'` keeps the 2.17 answer.
+- An agent server lists threads and runs by when each was last written, then by id, the order its
+  cursor pages by. A `limit` that is not a whole number above 0 is refused with a 400.
+- `McpServer` says its tools change, as `tools.listChanged`, and `register()` tells a connected
+  client.
+- `VideoInputKind` has `reference-videos`; a `switch` over it that names every kind needs the new one.
+- Tested on Node.js 26 as well as 22 and 24: CI runs the release gate on each, on the newest patch of
+  its line, so a Node.js security release, such as 2026-10-21's, is what the package is tested and
+  published on the day it ships.
+
+### Fixed
+
+- A tenant's threads and runs on a server several tenants share: a list read the newest records of
+  every tenant and then kept the tenant's, so another tenant's newer ones could crowd its page out,
+  down to an empty one. A list now reads until the tenant's page is full.
+- The studio showed a run's metadata, its feedback, and a tool's progress as
+  `[object HTMLHeadingElement]` rather than their content.
+
 ## [2.17.0] - 2026-10-21
 
 The editor's MCP servers over every transport, decided by what their servers say they do; and video
@@ -3103,7 +3179,8 @@ shared policy vocabulary is in place for a future release that revisits this.
 - URL fetching rejects unsafe private-network targets and limits response reads.
 - CLI and audit findings no longer disclose detected secret values.
 
-[Unreleased]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v2.17.0...HEAD
+[Unreleased]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v2.18.0...HEAD
+[2.18.0]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v2.17.0...v2.18.0
 [2.17.0]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v2.16.0...v2.17.0
 [2.16.0]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v2.15.1...v2.16.0
 [2.15.1]: https://github.com/mkhitar-abrahamyan/nexus-ai/compare/v2.15.0...v2.15.1

package/README.md

@@ -327,12 +327,16 @@ Shipped so far:
   as it is written;
 - 2.17 the editor's MCP servers over every transport, and video you can extend or edit: an ACP agent
   connects stdio, HTTP, and SSE servers and decides each tool by what its server says it does, and a
-  video is extended from its own job or edited on Gemini Omni Flash, Veo, and Runway.
+  video is extended from its own job or edited on Gemini Omni Flash, Veo, and Runway;
+- 2.18 span events and links, as OpenTelemetry has them, media that knows its length from its own
+  headers, a tenant's threads and runs listed and paged across all of its regions, MCP servers that
+  reconnect and change their tools within a session, and videos made after reference videos.
 
 Upgrading from 1.x: `npx nexus migrate src --write` moves your imports, and
 [MIGRATING.md](https://github.com/mkhitar-abrahamyan/nexus-ai/blob/main/MIGRATING.md) covers the rest.
-Next, 2.18 records events and links on spans, as OpenTelemetry has them, and reads the length of
-compressed audio and video, so an evaluation holds a clip to its duration. Pinecone, images, the Gemini
+Next, 2.19 reads a service's own API description into emulated tools, and lets an emulator hold
+what a whole evaluation did, so examples that build on each other are evaluated with nothing sent.
+Pinecone, images, the Gemini
 embedding batch tier, media understanding, video, Gemini Live, SIP, and both phone providers
 graduate once the live workflow passes against each. The
 [roadmap](https://github.com/mkhitar-abrahamyan/nexus-ai/blob/main/ROADMAP.md) lists what comes after, in the order

package/dist/evaluate/media.d.ts

@@ -5,6 +5,7 @@
  */
 import { type JudgeClient } from '../evals/judge.js';
 import type { EvaluationContext, Evaluator, MediaPart } from '../types/evaluate.js';
+export { type MediaDuration, readMediaDuration } from '../utils/media-duration.js';
 /** What kind of medium something is. */
 export type MediaSubjectKind = 'image' | 'audio' | 'video' | 'document' | 'other';
 /** A medium read for judging: what it is, and as much of it as could be read. */
@@ -27,7 +28,10 @@ export interface ResolvedMedia {
     width?: number;
     /** Height in pixels. */
     height?: number;
-    /** Duration in milliseconds, read from a WAV header. */
+    /**
+     * Duration in milliseconds, read from the file's own headers: WAV, MP4 and MOV, WebM and Matroska,
+     * MP3, Ogg (Vorbis and Opus), and FLAC.
+     */
     durationMs?: number;
     /** Why its bytes could not be read, when they could not. */
     unreadable?: string;
@@ -93,7 +97,7 @@ export interface MediaCheckOptions extends MediaResolveOptions, MediaSelection {
         ratio: number;
         tolerance?: number;
     };
-    /** The duration in milliseconds allowed, for audio whose header says it. */
+    /** The duration in milliseconds allowed, for audio or video whose headers say it. */
     durationMs?: MediaRange;
     /** A medium whose measurement could not be read passes or fails that check. Defaults to `fail`. */
     unknown?: 'pass' | 'fail';

package/dist/evaluate/media.js

@@ -4,6 +4,8 @@ import { decodeBase64, encodeBase64 } from '../utils/base64.js';
 import { sha256Hex } from '../utils/sha256.js';
 import { withProvenance } from './provenance.js';
 import { asMediaPart, mediaParts } from './trace.js';
+import { readMediaDuration } from '../utils/media-duration.js';
+export { readMediaDuration } from '../utils/media-duration.js';
 export function mediaOf(context, from = 'output') {
     const traced = (direction) => (context.trace?.media ?? []).filter((item) => item.direction === direction).map((item) => item.part);
     const output = () => {
@@ -65,11 +67,11 @@ export async function resolveMedia(part, options = {}) {
             resolved.kind = 'document';
         }
         else {
-            const wav = wavDuration(bytes);
-            if (wav !== undefined) {
-                resolved.mimeType = 'audio/wav';
-                resolved.kind = 'audio';
-                resolved.durationMs = wav;
+            const read = readMediaDuration(bytes);
+            if (read) {
+                resolved.mimeType = read.mimeType;
+                resolved.kind = read.kind;
+                resolved.durationMs = read.durationMs;
             }
         }
     }
@@ -410,22 +412,6 @@ function mimeMatches(pattern, mimeType) {
         return mimeType.startsWith(pattern.slice(0, -1));
     return pattern === mimeType;
 }
-function wavDuration(bytes) {
-    if (!startsWith(bytes, 'RIFF') || ascii(bytes, 8, 4) !== 'WAVE')
-        return undefined;
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    let byteRate;
-    for (let at = 12; at + 8 <= bytes.length;) {
-        const id = ascii(bytes, at, 4);
-        const size = view.getUint32(at + 4, true);
-        if (id === 'fmt ' && at + 16 <= bytes.length)
-            byteRate = view.getUint32(at + 16, true);
-        if (id === 'data')
-            return byteRate ? Math.round((size / byteRate) * 1000) : undefined;
-        at += 8 + size + (size % 2);
-    }
-    return undefined;
-}
 function startsWith(bytes, text) {
     return ascii(bytes, 0, text.length) === text;
 }

package/dist/index.d.ts

@@ -20,7 +20,7 @@ export { tool, toolOutput } from './agent/tool.js';
 export type { CacheHint, CompletionRequest, Message, MessageRole, ContentPart, PromptCacheConfig, ReasoningConfig, TextContent, ImageContent, AudioContent, BinaryBuffer, VideoContent, AssetContent, ToolChoice, ToolDefinition, ToolCallResult, ToolOutput, } from './types/messages.js';
 export type { CapabilityConfig, CapabilityPolicy, CapabilityWarning, CapabilityWarningAction, } from './types/capabilities.js';
 export type { CostEstimate, NexusPlan, } from './types/planning.js';
-export type { NexusResponse, NexusStream, ResponseCost, ResponseMeta, StreamChunk, TokenUsage, ToolCall, } from './types/response.js';
+export type { NexusResponse, NexusStream, ResponseAttempt, ResponseCost, ResponseMeta, StreamChunk, TokenUsage, ToolCall, } from './types/response.js';
 export type { NexusAIConfig, ProvidersConfig, OpenAIProviderConfig, AnthropicProviderConfig, GoogleProviderConfig, OllamaProviderConfig, GroqProviderConfig, MistralProviderConfig, CohereProviderConfig, CustomProviderConfig, DeepSeekProviderConfig, AzureOpenAIProviderConfig, LMStudioProviderConfig, LlamaCppProviderConfig, RoutingConfig, RoutingRule, RoutingStrategy, FallbackConfig, ResponseFormatConfig, RetryConfig, CostBudgetConfig, AuditLogConfig, AuditLogEvent, LoggerConfig, LogEvent, LogLevel, RateLimitConfig, } from './types/config.js';
 export type { ContextSummaryConfig, ContextSummaryInput, ContextSummaryMode, ContextSummarizer, ContextWindowConfig, ContextWindowResult, ContextWindowStrategy, ContextWindowUsage, } from './types/context-window.js';
 export type { AliasMetadata, AliasStage, CacheTtl, InputModality, ModelCapabilities, ModelEndpoint, ModelStatus, OutputModality, PromptCachingCapability, ProviderCapabilities, ReasoningEffort, RoutingModelPreference, } from './types/providers.js';

package/dist/mcp/client.d.ts

@@ -91,6 +91,14 @@ export interface McpClientOptions {
     };
     /** How long a request waits before failing. Defaults to 30 seconds. */
     timeoutMs?: number;
+    /**
+     * When the transport closes, as an SSE stream that ends or a server process that exits does, the
+     * next request opens it again and repeats the handshake, since the server's session went with it.
+     * Requests in flight still fail, and a client closed with `close()` stays closed. Needs a transport
+     * that can open again: `createStdioTransport` starts a new process, `createSseTransport` with
+     * `reopen` a new stream.
+     */
+    reconnect?: boolean;
 }
 /**
  * Talks to an MCP server.
@@ -109,7 +117,15 @@ export declare class McpClient {
     private initialized;
     private connecting;
     private serverInfo;
+    /** Who hears that the server's tools changed. */
+    private readonly toolsChanged;
+    private stopped;
     constructor(transport: McpTransport, options?: McpClientOptions);
+    /**
+     * Hears each `notifications/tools/list_changed` the server sends: its tools are no longer what
+     * `listTools()` returned. Returns a function that stops hearing.
+     */
+    onToolsChanged(handler: () => void): () => void;
     /**
      * Performs the handshake and returns the server's name and version. Called automatically by the
      * first request that needs it; requests made together share one handshake.
@@ -190,7 +206,8 @@ export declare function serverEnvironment(source: Record<string, string | undefi
  * Runs an MCP server as a child process and speaks to it over its stdin and stdout.
  *
  * The transport most MCP servers ship with. `node:child_process` is imported lazily, so a browser
- * or edge build that only uses the HTTP transport never reaches for it.
+ * or edge build that only uses the HTTP transport never reaches for it. When the process exits, the
+ * transport closes; started again, it runs a new one.
  */
 export declare function createStdioTransport(options: StdioClientOptions): McpTransport;
 /** Connects to a remote MCP server over HTTP. */
@@ -219,11 +236,17 @@ export interface SseClientOptions {
     fetch?: typeof globalThis.fetch;
     /** How long to wait for the server to name where messages go, in milliseconds. Defaults to 10 seconds. */
     timeoutMs?: number;
+    /**
+     * Opens a new stream when the next message is sent after the stream ended, rather than staying
+     * closed. The server starts a new session on it, so an `McpClient` with `reconnect` greets it again.
+     */
+    reopen?: boolean;
 }
 /**
  * Speaks to an MCP server over HTTP with Server-Sent Events, as MCP's 2024-11-05 transport: one
  * long `GET` the server answers on, and a `POST` per message to the endpoint the stream names
  * first. The endpoint must be on the stream's own origin, so a server cannot send the messages, and
- * their headers, anywhere else. When the stream ends, the transport closes.
+ * their headers, anywhere else. When the stream ends, the transport closes; with `reopen`, the next
+ * message opens a new one.
  */
 export declare function createSseTransport(options: SseClientOptions): McpTransport;

package/dist/mcp/client.js

@@ -15,11 +15,23 @@ export class McpClient {
     initialized = false;
     connecting;
     serverInfo = {};
+    toolsChanged = new Set();
+    stopped = false;
     constructor(transport, options = {}) {
         this.transport = transport;
         this.options = options;
         transport.onMessage((message) => this.receive(message));
-        transport.onClose?.(() => this.failAll(new McpError('The MCP connection closed')));
+        transport.onClose?.(() => {
+            this.failAll(new McpError('The MCP connection closed'));
+            if (this.options.reconnect && !this.stopped)
+                this.initialized = false;
+        });
+    }
+    onToolsChanged(handler) {
+        this.toolsChanged.add(handler);
+        return () => {
+            this.toolsChanged.delete(handler);
+        };
     }
     async connect() {
         if (this.initialized)
@@ -116,6 +128,7 @@ export class McpClient {
         });
     }
     async close() {
+        this.stopped = true;
         this.failAll(new McpError('The MCP client was closed'));
         await this.transport.close();
     }
@@ -141,6 +154,16 @@ export class McpClient {
             this.settle(message.id, message.result, message.error ? new McpError(message.error.message, message.error.code, message.error.data) : undefined);
             return;
         }
+        if (isNotification(message) && message.method === 'notifications/tools/list_changed') {
+            for (const handler of this.toolsChanged) {
+                try {
+                    handler();
+                }
+                catch {
+                }
+            }
+            return;
+        }
         if (isNotification(message) && message.method === 'notifications/progress') {
             const params = (message.params ?? {});
             const report = this.progress.get(String(params.progressToken));
@@ -235,11 +258,11 @@ export function serverEnvironment(source, options = {}) {
 }
 export function createStdioTransport(options) {
     let child;
-    const decoder = new LineDecoder();
     let onMessage = () => undefined;
     let onClose = () => undefined;
     return {
         async start() {
+            const decoder = new LineDecoder();
             const { spawn } = await import('node:child_process');
             const spawned = spawn(options.command, options.args ?? [], {
                 cwd: options.cwd,
@@ -323,62 +346,73 @@ export function createSseTransport(options) {
     let endpoint;
     let opening;
     let closed = false;
-    const stream = new AbortController();
-    const ended = () => {
-        if (closed)
+    let stopped = false;
+    let stream = new AbortController();
+    const ended = (from) => {
+        if (closed || from !== stream)
             return;
         closed = true;
         for (const handler of onClose)
             handler();
     };
     const open = async () => {
-        const response = await fetchImplementation(options.url, {
-            headers: { accept: 'text/event-stream', ...options.headers },
-            signal: stream.signal,
-        });
-        if (!response.ok || !response.body)
-            throw new McpError(`MCP SSE transport failed with ${response.status}`);
-        const reader = response.body.getReader();
-        await new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                reject(new McpError(`The MCP server named no endpoint within ${options.timeoutMs ?? 10_000}ms`));
-                stream.abort();
-            }, options.timeoutMs ?? 10_000);
-            const event = (name, data) => {
-                if (name === 'endpoint') {
-                    if (endpoint)
-                        return;
-                    const target = new URL(data.trim(), options.url);
-                    if (target.origin !== new URL(options.url).origin) {
+        const own = new AbortController();
+        stream = own;
+        try {
+            const response = await fetchImplementation(options.url, {
+                headers: { accept: 'text/event-stream', ...options.headers },
+                signal: own.signal,
+            });
+            if (!response.ok || !response.body)
+                throw new McpError(`MCP SSE transport failed with ${response.status}`);
+            const reader = response.body.getReader();
+            await new Promise((resolve, reject) => {
+                const timer = setTimeout(() => reject(new McpError(`The MCP server named no endpoint within ${options.timeoutMs ?? 10_000}ms`)), options.timeoutMs ?? 10_000);
+                const event = (name, data) => {
+                    if (name === 'endpoint') {
+                        if (endpoint)
+                            return;
+                        const target = new URL(data.trim(), options.url);
+                        if (target.origin !== new URL(options.url).origin) {
+                            clearTimeout(timer);
+                            reject(new McpError(`The MCP server named an endpoint on another origin, ${target.origin}`));
+                            return;
+                        }
+                        endpoint = target.href;
                         clearTimeout(timer);
-                        reject(new McpError(`The MCP server named an endpoint on another origin, ${target.origin}`));
-                        stream.abort();
-                        return;
+                        resolve();
                     }
-                    endpoint = target.href;
-                    clearTimeout(timer);
-                    resolve();
-                }
-                else if (name === 'message') {
-                    try {
-                        onMessage(JSON.parse(data));
+                    else if (name === 'message') {
+                        try {
+                            onMessage(JSON.parse(data));
+                        }
+                        catch {
+                        }
                     }
-                    catch {
-                    }
-                }
-            };
-            void readEvents(reader, event).then(() => {
-                clearTimeout(timer);
-                reject(new McpError('The MCP event stream ended'));
-                ended();
-            }, (error) => {
-                clearTimeout(timer);
-                reject(error instanceof McpError ? error : new McpError(`The MCP event stream failed: ${String(error)}`));
-                ended();
+                };
+                void readEvents(reader, event).then(() => {
+                    clearTimeout(timer);
+                    reject(new McpError('The MCP event stream ended'));
+                    ended(own);
+                }, (error) => {
+                    clearTimeout(timer);
+                    reject(error instanceof McpError ? error : new McpError(`The MCP event stream failed: ${String(error)}`));
+                    ended(own);
+                });
             });
-        });
+        }
+        catch (error) {
+            own.abort();
+            ended(own);
+            throw error;
+        }
     };
     const started = () => {
+        if (closed && options.reopen && !stopped) {
+            closed = false;
+            endpoint = undefined;
+            opening = undefined;
+        }
         opening ??= open();
         return opening;
     };
@@ -404,8 +438,9 @@ export function createSseTransport(options) {
             onClose.push(handler);
         },
         close() {
+            stopped = true;
             stream.abort();
-            ended();
+            ended(stream);
         },
     };
 }

package/dist/mcp/server.d.ts

@@ -41,7 +41,7 @@ export declare class McpServer {
     private readonly tools;
     private transport;
     constructor(options?: McpServerOptions);
-    /** Adds a tool. Returns the server, for chaining. */
+    /** Adds a tool, and tells a connected client its tools changed. Returns the server, for chaining. */
     register(tool: ToolDefinition): this;
     /** Starts serving requests over a transport. */
     connect(transport: McpTransport): Promise<void>;

package/dist/mcp/server.js

@@ -25,6 +25,9 @@ export class McpServer {
     }
     register(tool) {
         this.tools.set(tool.name, tool);
+        if (this.transport) {
+            void Promise.resolve(this.transport.send({ jsonrpc: '2.0', method: 'notifications/tools/list_changed' })).catch(() => undefined);
+        }
         return this;
     }
     async connect(transport) {
@@ -63,7 +66,7 @@ export class McpServer {
                 return {
                     protocolVersion: MCP_PROTOCOL_VERSION,
                     capabilities: {
-                        tools: { listChanged: false },
+                        tools: { listChanged: true },
                         ...(this.options.resources?.length ? { resources: { listChanged: false } } : {}),
                     },
                     serverInfo: { name: this.options.name ?? 'nexus-ai-pro', version: this.options.version ?? '1.x' },

package/dist/protocols/acp-editor.js

@@ -7,8 +7,7 @@ export function acpEditor(options = {}) {
         let connected = servers.get(session.id);
         if (!connected) {
             connected = (async () => {
-                const clients = [];
-                const tools = [];
+                const entries = [];
                 const declare = options.mcpToolCapabilities ?? true;
                 for (const offered of session.mcpServers) {
                     const name = String(offered.name ?? 'mcp');
@@ -21,6 +20,7 @@ export function acpEditor(options = {}) {
                                 ...(options.mcpFetch ? { fetch: options.mcpFetch } : {}),
                             }
                             : undefined;
+                        const sse = remote && offered.type === 'sse';
                         const transport = offered.command
                             ? createStdioTransport({
                                 command: offered.command,
@@ -28,26 +28,40 @@ export function acpEditor(options = {}) {
                                 env: Object.fromEntries((offered.env ?? []).map((item) => [item.name, item.value])),
                                 ...(session.cwd ? { cwd: session.cwd } : {}),
                             })
-                            : remote && offered.type === 'sse'
-                                ? createSseTransport({ ...remote, timeoutMs: options.mcpTimeoutMs ?? 30_000 })
+                            : sse
+                                ?
+                                    createSseTransport({ ...remote, timeoutMs: options.mcpTimeoutMs ?? 30_000, reopen: true })
                                 : remote && (offered.type === 'http' || offered.type === undefined)
                                     ? createHttpTransport(remote)
                                     : undefined;
                         if (!transport)
                             throw new Error(`MCP server "${name}" uses a transport this agent does not speak`);
-                        const client = new McpClient(transport, { timeoutMs: options.mcpTimeoutMs ?? 30_000 });
-                        clients.push(client);
-                        tools.push(...(await client.toNexusTools({
-                            prefix,
-                            server: prefix,
-                            capabilities: typeof declare === 'function' ? (tool) => declare(tool, prefix) : declare,
-                        })));
+                        const client = new McpClient(transport, {
+                            timeoutMs: options.mcpTimeoutMs ?? 30_000,
+                            ...(sse ? { reconnect: true } : {}),
+                        });
+                        const entry = {
+                            name,
+                            client,
+                            tools: [],
+                            stale: false,
+                            list: () => client.toNexusTools({
+                                prefix,
+                                server: prefix,
+                                capabilities: typeof declare === 'function' ? (tool) => declare(tool, prefix) : declare,
+                            }),
+                        };
+                        entries.push(entry);
+                        client.onToolsChanged(() => {
+                            entry.stale = true;
+                        });
+                        entry.tools = await entry.list();
                     }
                     catch (error) {
                         options.onError?.(error, name);
                     }
                 }
-                return { clients, tools };
+                return entries;
             })();
             servers.set(session.id, connected);
         }
@@ -155,13 +169,26 @@ export function acpEditor(options = {}) {
             const own = tools(session);
             if (options.mcp === false || session.mcpServers.length === 0)
                 return own;
-            return [...own, ...(await mcpTools(session)).tools];
+            const entries = await mcpTools(session);
+            await Promise.all(entries
+                .filter((entry) => entry.stale)
+                .map(async (entry) => {
+                entry.stale = false;
+                try {
+                    entry.tools = await entry.list();
+                }
+                catch (error) {
+                    entry.stale = true;
+                    options.onError?.(error, entry.name);
+                }
+            }));
+            return [...own, ...entries.flatMap((entry) => entry.tools)];
         },
         async close() {
             const connected = [...servers.values()];
             servers.clear();
-            for (const { clients } of await Promise.all(connected)) {
-                await Promise.all(clients.map((client) => client.close().catch(() => undefined)));
+            for (const entries of await Promise.all(connected)) {
+                await Promise.all(entries.map((entry) => entry.client.close().catch(() => undefined)));
             }
         },
     };