@amaster.ai/dsh-a2a 0.1.34 → 0.1.35

package/lib/index.js

@@ -32,12 +32,24 @@ export const inject = ['agents'];
 export const Config = Schema.object({
     inbox: Schema.object({
         enabled: Schema.boolean().default(false),
+        notifications: Schema.boolean()
+            .default(false)
+            .description('Publish checkpointed inbox invalidations to same-process host observers; SSE subscriptions also activate their own feed.'),
         shutdown: Schema.union([Schema.const('cancel'), Schema.const('retain-pending')]).default('cancel'),
     }).description('Use the official DSH inbox for queued turns and steering.'),
     enabled: Schema.boolean().default(false),
     host: Schema.string().default('127.0.0.1'),
     port: Schema.natural().default(41241),
     basePath: Schema.string().default('/a2a'),
+    rest: Schema.boolean().default(false),
+    grpc: Schema.object({
+        enabled: Schema.boolean().default(false),
+        port: Schema.natural().max(65535).default(41242),
+        publicUrl: Schema.string().default(''),
+    }),
+    pushNotifications: Schema.boolean()
+        .default(false)
+        .description('Enable standard A2A task webhook configuration and delivery through the SDK.'),
     heartbeat: Schema.object({
         enabled: Schema.boolean().default(false),
         intervalMs: Schema.natural().min(1).max(2_147_483_647).default(15_000),
@@ -49,6 +61,12 @@ export const Config = Schema.object({
      * below it). Empty = <OS temp>/dsh-a2a-uploads.
      */
     uploadsDir: Schema.string().default(''),
+    urlDownloads: Schema.object({
+        allowPrivate: Schema.boolean()
+            .default(false)
+            .description('allow every private/loopback URL host in a trusted intranet'),
+        allowedHosts: Schema.array(Schema.string()).default([]),
+    }).description('URL downloads; private hosts require allowPrivate or an allowedHosts entry.'),
     subagentTools: Schema.object({
         enabled: Schema.boolean().default(false),
     }),
@@ -99,9 +117,10 @@ export function apply(ctx, config) {
     // covers the bind.
     let ready;
     let serverPort = 0;
+    let grpcPort;
     ctx.effect(() => {
         const startup = start();
-        ready = startup.then(() => ({ port: serverPort }));
+        ready = startup.then(() => ({ port: serverPort, grpcPort }));
         return startup;
     });
     return ready;
@@ -109,6 +128,8 @@ export function apply(ctx, config) {
         const bridge = new A2aBridge(ctx, {
             cwd: config.cwd,
             uploadsDir: config.uploadsDir || undefined,
+            downloadAllowPrivate: config.urlDownloads?.allowPrivate,
+            downloadAllowedHosts: config.urlDownloads?.allowedHosts,
             agentOptions: {
                 provider: config.agent.provider || undefined,
                 model: config.agent.model || undefined,
@@ -118,7 +139,7 @@ export function apply(ctx, config) {
         });
         const store = createTaskStore(config);
         const inbox = config.inbox?.enabled
-            ? new NativeInbox(ctx, bridge, store, config.inbox.shutdown === 'retain-pending')
+            ? new NativeInbox(ctx, bridge, store, config.inbox.shutdown === 'retain-pending', config.inbox.notifications)
             : undefined;
         await store.init?.();
         if (inbox)
@@ -150,20 +171,27 @@ export function apply(ctx, config) {
         });
         const executor = new DshAgentExecutor(bridge, (taskId) => store.suppress(taskId));
         const server = await startA2aServer({
+            inbox,
             extensions: inbox
                 ? [
                     {
                         uri: INBOX_EXTENSION,
-                        description: 'Native inbox steering and parked admission',
+                        description: 'Native inbox management, steering and checkpointed invalidation',
                         required: false,
-                        params: undefined,
+                        params: {
+                            documentationUrl: 'https://github.com/TGYD-helige/dsh-plugins/blob/main/packages/dsh-a2a/README.md#native-inbox-extension-v1',
+                        },
                     },
                 ]
                 : [],
             host: config.host,
             port: config.port,
             basePath: config.basePath,
+            rest: config.rest,
+            grpc: config.grpc,
+            extendedAgentCard: ctx.get('a2aExtendedCard'),
             heartbeat: config.heartbeat,
+            pushNotifications: config.pushNotifications,
             card: {
                 name: config.card.name,
                 description: config.card.description,
@@ -180,6 +208,7 @@ export function apply(ctx, config) {
             beforeWorkingTaskMessage: (message, headers) => bridge.beforeWorkingTaskMessage(message, headers),
         });
         serverPort = server.port;
+        grpcPort = server.grpcPort;
         if (inbox)
             inbox.server = server;
         console.log(`[dsh-a2a] A2A endpoint: http://${config.host}:${server.port}${config.basePath}/ ` +

package/lib/legacy-stream.js

@@ -32,6 +32,11 @@ export function legacyStreamHandler(requestHandler) {
                 return;
             }
             const stream = response;
+            const resubscribing = req.body.method === 'tasks/resubscribe';
+            let closed;
+            const close = new Promise((resolve) => (closed = resolve));
+            if (resubscribing)
+                res.once('close', closed);
             try {
                 const startStream = () => {
                     if (context.activatedExtensions)
@@ -42,9 +47,12 @@ export function legacyStreamHandler(requestHandler) {
                     res.flushHeaders();
                 };
                 // The SDK always streams resubscribe errors; sends validate before SSE headers.
-                if (req.body.method === 'tasks/resubscribe')
+                if (resubscribing)
                     startStream();
-                const first = await stream.next();
+                const next = () => (resubscribing ? Promise.race([stream.next(), close]) : stream.next());
+                const first = await next();
+                if (!first)
+                    return;
                 if (!res.headersSent)
                     startStream();
                 let last;
@@ -60,10 +68,15 @@ export function legacyStreamHandler(requestHandler) {
                 };
                 if (!first.done && write(first.value))
                     return;
-                for await (const event of stream) {
+                while (true) {
+                    const nextEvent = await next();
+                    if (!nextEvent || nextEvent.done)
+                        break;
+                    if (res.destroyed && !resubscribing)
+                        continue; // Sends still drain for persistence.
                     if (res.destroyed)
-                        continue; // Keep the SDK consuming results after its client leaves.
-                    if (write(event))
+                        break;
+                    if (write(nextEvent.value))
                         return;
                 }
                 // A cold subscription has no live bus: the SDK ends after the snapshot.
@@ -82,6 +95,8 @@ export function legacyStreamHandler(requestHandler) {
                     });
             }
             finally {
+                if (resubscribing)
+                    res.off('close', closed);
                 await stream.return(undefined);
             }
         }

package/lib/server.js

@@ -15,11 +15,15 @@ import { AsyncLocalStorage } from 'node:async_hooks';
 import { createServer } from 'node:http';
 import { A2A_PROTOCOL_VERSION, AGENT_CARD_PATH, TaskState, } from '@a2a-js/sdk';
 import { duplicateInterfacesForLegacy } from '@a2a-js/sdk/compat/v0_3';
-import { RequestMalformedError } from '@a2a-js/sdk/errors';
-import { DefaultExecutionEventBus, DefaultRequestHandler, ExecutionEventQueue, ResultManager, ServerCallContext, STATE_HEADERS_KEY, } from '@a2a-js/sdk/server';
-import { agentCardHandler, jsonRpcHandler, UserBuilder } from '@a2a-js/sdk/server/express';
+import { createLegacyAwarePushNotificationSender } from '@a2a-js/sdk/compat/v0_3/server';
+import { RequestMalformedError, UnsupportedOperationError } from '@a2a-js/sdk/errors';
+import { DefaultExecutionEventBus, DefaultRequestHandler, ExecutionEventQueue, InMemoryPushNotificationStore, ResultManager, ServerCallContext, STATE_HEADERS_KEY, } from '@a2a-js/sdk/server';
+import { agentCardHandler, jsonRpcHandler, restHandler, UserBuilder, } from '@a2a-js/sdk/server/express';
 import express from 'express';
+import { AdmissionGate } from './admission.js';
+import { inboxRpcHandler } from './inbox-api.js';
 import { legacyStreamHandler } from './legacy-stream.js';
+import { connectedRequestHandler, subscriptionBus, withStreamConnection, } from './stream-connection.js';
 export async function startA2aServer(options) {
     const intervalMs = options.heartbeat?.intervalMs ?? 15_000;
     if (!Number.isInteger(intervalMs) || intervalMs < 1 || intervalMs > 2_147_483_647) {
@@ -48,19 +52,25 @@ export async function startA2aServer(options) {
             protocolVersion: A2A_PROTOCOL_VERSION,
         },
     ];
+    if (options.rest)
+        interfaces.push({
+            ...interfaces[0],
+            url: `${publicUrl}${base}/rest`,
+            protocolBinding: 'HTTP+JSON',
+        });
     const card = {
         name: options.card.name,
         description: options.card.description,
         version: options.card.version,
         // The v0.3 mirror entries let pre-1.0 clients keep working through the
         // legacyCompat layer (they discover the card without an A2A-Version header).
-        supportedInterfaces: duplicateInterfacesForLegacy(interfaces, ['JSONRPC']),
+        supportedInterfaces: duplicateInterfacesForLegacy(interfaces, ['JSONRPC', 'HTTP+JSON']),
         provider: undefined,
         capabilities: {
             streaming: true,
-            pushNotifications: false,
+            pushNotifications: options.pushNotifications ?? false,
             extensions: options.extensions ?? [],
-            extendedAgentCard: false,
+            extendedAgentCard: !!options.extendedAgentCard,
         },
         securitySchemes: {},
         securityRequirements: [],
@@ -82,9 +92,25 @@ export async function startA2aServer(options) {
     // SDK's default manager gives concurrent sends one bus. Give each send its
     // own bus while forwarding events to a stable task bus for resubscribe/cancel.
     const approvalReply = new AsyncLocalStorage();
+    const admissionReply = new AsyncLocalStorage();
+    const admissions = new AdmissionGate();
+    async function acquireAdmission(message) {
+        const key = message?.taskId || message?.contextId || message?.messageId || '';
+        const admission = admissions.acquire(key);
+        await admission.ready;
+        const state = { release: admission.release, expectedSaves: message?.taskId ? 2 : 1, saves: 0 };
+        return {
+            release: admission.release,
+            run: (work) => admissionReply.run(state, work),
+        };
+    }
     const taskBuses = new Map();
+    const ownedTasks = new Set();
     const busManager = {
         createOrGetByTaskId(taskId) {
+            // restoreTask also creates buses, but only message admission proves ownership.
+            if (admissionReply.getStore())
+                ownedTasks.add(taskId);
             let task = taskBuses.get(taskId);
             if (!task) {
                 const broadcast = new DefaultExecutionEventBus();
@@ -113,6 +139,7 @@ export async function startA2aServer(options) {
                             priorMessage.messageId === message.messageId &&
                             before?.$case === 'text' &&
                             delta?.$case === 'text') {
+                            // shortcut: replay compaction joins text per delta; use chunks if long streams make this measurable.
                             created.replay[created.replay.length - 1] = {
                                 ...event,
                                 data: {
@@ -164,12 +191,13 @@ export async function startA2aServer(options) {
             requestBus.on('finished', () => task.requests.delete(requestBus));
             return requestBus;
         },
-        getByTaskId: (taskId) => taskBuses.get(taskId)?.broadcast,
+        getByTaskId: (taskId) => subscriptionBus(taskBuses.get(taskId)?.broadcast),
         cleanupByTaskId(taskId) {
             const task = taskBuses.get(taskId);
             task?.broadcast.finished();
             task?.broadcast.removeAllListeners();
             taskBuses.delete(taskId);
+            ownedTasks.delete(taskId);
         },
     };
     const beforeWorkingTaskMessage = async (message, context) => {
@@ -188,7 +216,20 @@ export async function startA2aServer(options) {
             throw new RequestMalformedError(error instanceof Error ? error.message : String(error));
         }
     };
-    const requestHandler = new (class extends DefaultRequestHandler {
+    const admissionStore = {
+        save: async (task, context) => {
+            await options.taskStore.save(task, context);
+            const admission = admissionReply.getStore();
+            if (admission && ++admission.saves >= admission.expectedSaves)
+                admission.release();
+        },
+        load: (taskId, context) => options.taskStore.load(taskId, context),
+        list: (params, context) => options.taskStore.list(params, context),
+    };
+    const pushStore = options.pushNotifications ? new InMemoryPushNotificationStore() : undefined;
+    const pushSender = pushStore ? createLegacyAwarePushNotificationSender(pushStore) : undefined;
+    const restoredPushFailed = (error) => console.error('[dsh-a2a] restored task push failed:', error);
+    const handler = new (class extends DefaultRequestHandler {
         async beforeMessage(message, context) {
             if (!message)
                 return;
@@ -201,34 +242,35 @@ export async function startA2aServer(options) {
         }
         async sendMessage(...args) {
             const release = guardApproval(args[0].message);
+            const admission = await acquireAdmission(args[0].message);
             let releaseAdmission;
             try {
                 if (!release)
                     await beforeWorkingTaskMessage(args[0].message, args[1]);
                 if (!release)
                     releaseAdmission = await this.beforeMessage(args[0].message, args[1]);
-                return await approvalReply.run(Boolean(release), () => super.sendMessage(...args));
+                return await approvalReply.run(Boolean(release), () => admission.run(() => super.sendMessage(...args)));
             }
             finally {
+                admission.release();
                 releaseAdmission?.();
                 release?.();
             }
         }
         async *sendMessageStream(...args) {
             const release = guardApproval(args[0].message);
+            const admission = await acquireAdmission(args[0].message);
             let releaseAdmission;
             try {
                 if (!release)
                     await beforeWorkingTaskMessage(args[0].message, args[1]);
                 if (!release)
                     releaseAdmission = await this.beforeMessage(args[0].message, args[1]);
-                const stream = observeTask(super.sendMessageStream(...args));
+                const stream = admission.run(() => observeTask(super.sendMessageStream(...args)));
                 try {
-                    if (release) {
-                        const first = await approvalReply.run(true, () => stream.next());
-                        if (!first.done)
-                            yield first.value;
-                    }
+                    const first = await admission.run(() => approvalReply.run(Boolean(release), () => stream.next()));
+                    if (!first.done)
+                        yield first.value;
                     yield* stream;
                 }
                 finally {
@@ -237,12 +279,21 @@ export async function startA2aServer(options) {
                 }
             }
             finally {
+                admission.release();
                 releaseAdmission?.();
                 release?.();
             }
         }
         async cancelTask(...args) {
+            // A cold native task must reattach before ownership is decided: its restored
+            // bus proves this worker can cancel it, while an unattached remote task still fails closed.
             await options.beforeTask?.(args[0].id, args[1]);
+            const task = await options.taskStore.load(args[0].id, args[1]);
+            if (task?.status?.state === TaskState.TASK_STATE_WORKING &&
+                !ownedTasks.has(task.id) &&
+                !taskBuses.has(task.id)) {
+                throw new UnsupportedOperationError('Working task is owned by another worker; route cancellation to its owner.');
+            }
             return super.cancelTask(...args);
         }
         async *resubscribe(...args) {
@@ -339,14 +390,17 @@ export async function startA2aServer(options) {
                 await stream.return(undefined);
             }
         }
-    })(card, options.taskStore, options.executor, busManager);
+    })(card, admissionStore, options.executor, busManager, pushStore, pushSender, options.extendedAgentCard);
+    const requestHandler = connectedRequestHandler(handler);
     const app = express();
+    app.use((_req, res, next) => withStreamConnection(res, next));
     // The SDK's jsonRpcHandler parses bodies with express.json()'s 100kb default;
     // raise the ceiling here — body-parser skips re-parsing an already-read body.
-    app.use(express.json({ limit: '16mb' }));
+    app.use(express.json({ limit: '16mb', type: ['application/json', 'application/a2a+json'] }));
     if (options.heartbeat?.enabled) {
         app.use((req, res, next) => {
             const task = {};
+            const rest = options.rest && req.path.startsWith(`${base}/rest/`);
             const legacy = req.body?.method === 'message/stream' || req.body?.method === 'tasks/resubscribe';
             const flushHeaders = res.flushHeaders;
             // Wait for the SDK to commit SSE headers: validation errors stay JSON.
@@ -370,13 +424,16 @@ export async function startA2aServer(options) {
                             append: false,
                             lastChunk: false,
                         };
-                        res.write(`data: ${JSON.stringify({
-                            jsonrpc: '2.0',
-                            id: req.body.id ?? null,
-                            result: legacy
-                                ? { kind: 'artifact-update', ...update }
-                                : { artifactUpdate: update },
-                        })}\n\n`);
+                        const result = legacy
+                            ? { kind: 'artifact-update', ...update }
+                            : { artifactUpdate: update };
+                        res.write(`data: ${JSON.stringify(rest
+                            ? result
+                            : {
+                                jsonrpc: '2.0',
+                                id: req.body.id ?? null,
+                                result,
+                            })}\n\n`);
                     }
                     catch (error) {
                         stop();
@@ -407,6 +464,12 @@ export async function startA2aServer(options) {
     app.use(`/${AGENT_CARD_PATH}`, cardHandler);
     // Pre-1.0 discovery path, kept as a convenience alias.
     app.use('/.well-known/agent.json', cardHandler);
+    if (options.rest)
+        app.use(`${base}/rest`, restHandler({
+            requestHandler,
+            userBuilder: UserBuilder.noAuthentication,
+            legacyCompat: { enabled: true },
+        }));
     const contextLookup = async (req, res, next) => {
         const body = req.body;
         const params = body?.params;
@@ -461,12 +524,63 @@ export async function startA2aServer(options) {
                 res.sendStatus(404);
         }, contextLookup, rpcHandler);
     }
+    if (options.inbox)
+        app.post(base || '/', inboxRpcHandler(options.inbox, card));
     app.use(base, contextLookup, legacyStreamHandler(requestHandler), rpcHandler);
     const server = createServer(app);
     await new Promise((resolve, reject) => {
         server.once('error', reject);
         server.listen(options.port, options.host, () => resolve());
     });
+    const actualPort = server.address().port;
+    if (options.port === 0 && options.card.publicUrl === undefined) {
+        const actualBase = `http://${options.host}:${actualPort}`;
+        for (const endpoint of card.supportedInterfaces)
+            endpoint.url = endpoint.url.replace(publicUrl, actualBase);
+    }
+    let grpcServer;
+    let grpcPort;
+    if (options.grpc?.enabled) {
+        try {
+            const [grpc, sdk, legacy] = await Promise.all([
+                import('@grpc/grpc-js'),
+                import('@a2a-js/sdk/server/grpc'),
+                import('@a2a-js/sdk/compat/v0_3/server/grpc'),
+            ]);
+            grpcServer = new grpc.Server();
+            const handlers = { requestHandler, userBuilder: sdk.UserBuilder.noAuthentication };
+            for (const [descriptor, service] of [
+                [sdk.A2AService, sdk.grpcService(handlers)],
+                [legacy.LegacyA2AService, legacy.legacyGrpcService(handlers)],
+            ]) {
+                for (const [method, definition] of Object.entries(descriptor)) {
+                    if (!definition.responseStream)
+                        continue;
+                    const stream = service[method];
+                    service[method] = (call) => withStreamConnection(call, () => stream(call));
+                }
+                grpcServer.addService(descriptor, service);
+            }
+            const listener = grpcServer;
+            grpcPort = await new Promise((resolve, reject) => {
+                listener.bindAsync(`${options.host}:${options.grpc.port}`, grpc.ServerCredentials.createInsecure(), (error, port) => (error ? reject(error) : resolve(port)));
+            });
+            card.supportedInterfaces.push(...duplicateInterfacesForLegacy([
+                {
+                    url: options.grpc.publicUrl || `${options.host}:${grpcPort}`,
+                    protocolBinding: 'GRPC',
+                    protocolVersion: A2A_PROTOCOL_VERSION,
+                    tenant: '',
+                },
+            ], ['GRPC']));
+        }
+        catch (error) {
+            grpcServer?.forceShutdown();
+            server.closeAllConnections();
+            await new Promise((resolve) => server.close(() => resolve()));
+            throw error;
+        }
+    }
     return {
         restoreTask(task, context) {
             const bus = busManager.createOrGetByTaskId(task.id);
@@ -474,8 +588,25 @@ export async function startA2aServer(options) {
             const result = new ResultManager(options.taskStore, context);
             void (async () => {
                 try {
-                    for await (const event of queue.events())
+                    for await (const event of queue.events()) {
                         await result.processEvent(event);
+                        if (pushSender) {
+                            try {
+                                const snapshot = structuredClone(result.getCurrentTask());
+                                // SDK execution-event kinds match the StreamResponse oneof cases.
+                                const response = {
+                                    payload: {
+                                        $case: event.kind,
+                                        value: event.kind === 'task' ? (snapshot ?? event.data) : event.data,
+                                    },
+                                };
+                                void pushSender.send(response, context, snapshot).catch(restoredPushFailed);
+                            }
+                            catch (error) {
+                                restoredPushFailed(error);
+                            }
+                        }
+                    }
                 }
                 catch (error) {
                     console.error('[dsh-a2a] restored task persistence failed:', error);
@@ -486,10 +617,12 @@ export async function startA2aServer(options) {
             })();
             return bus;
         },
-        port: server.address().port,
+        port: actualPort,
+        grpcPort,
         close: () => new Promise((resolve) => {
             for (const stop of stopHeartbeats)
                 stop();
+            grpcServer?.forceShutdown();
             server.closeAllConnections?.();
             server.close(() => resolve());
         }),

package/lib/stores/gcs.js

@@ -68,11 +68,12 @@ export class GcsTaskStore {
             prefix: `${this.prefix}/${taskScopeKey(context)}/`,
         });
         const shells = [];
-        for (const file of files) {
-            if (!file.name.endsWith('/metadata.json.gz'))
-                continue;
-            const [buf] = await file.download();
-            shells.push(JSON.parse(gunzipSync(buf).toString('utf8')));
+        const metadata = files.filter((file) => file.name.endsWith('/metadata.json.gz'));
+        // Bound in-flight downloads while avoiding one network round-trip per task.
+        for (let start = 0; start < metadata.length; start += 16) {
+            const buffers = await Promise.all(metadata.slice(start, start + 16).map((file) => file.download()));
+            for (const [buf] of buffers)
+                shells.push(JSON.parse(gunzipSync(buf).toString('utf8')));
         }
         return listShells(shells, params);
     }

package/lib/stores/redis.js

@@ -47,10 +47,11 @@ export class RedisTaskStore {
         do {
             const [next, keys] = await this.redis.scan(cursor, 'MATCH', `${this.prefix}:tasks:${taskScopeKey(context)}:*`, 'COUNT', 100);
             cursor = next;
-            for (const key of keys) {
-                const raw = await this.redis.get(key);
-                if (raw)
-                    shells.push(JSON.parse(raw));
+            if (keys.length) {
+                const raws = await this.redis.mget(...keys);
+                for (const raw of raws)
+                    if (raw)
+                        shells.push(JSON.parse(raw));
             }
         } while (cursor !== '0');
         return listShells(shells, params);

package/lib/stream-connection.js

@@ -0,0 +1,75 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { DefaultExecutionEventBus } from '@a2a-js/sdk/server';
+const connections = new AsyncLocalStorage();
+/** SDK transports do not end their pending iterators on connection close. */
+export function withStreamConnection(output, run) {
+    const controller = new AbortController();
+    const connection = { signal: controller.signal, subscription: false };
+    let backlogLimit;
+    const drained = () => {
+        backlogLimit = undefined;
+    };
+    const close = () => {
+        controller.abort();
+        output.off('close', close).off('finish', close).off('cancelled', close).off('drain', drained);
+    };
+    output.once('close', close).once('finish', close).once('cancelled', close);
+    const write = output.write;
+    output.write = ((...args) => {
+        const accepted = write.apply(output, args);
+        if (!accepted && !controller.signal.aborted) {
+            if (backlogLimit === undefined) {
+                // Allow one large frame, then at most 1 MiB or 16 additional gRPC messages.
+                backlogLimit = output.writableLength + (output.writableObjectMode ? 16 : 1024 * 1024);
+                output.once('drain', drained);
+            }
+            else if (output.writableLength >= backlogLimit) {
+                close();
+                output.destroy();
+            }
+        }
+        return accepted;
+    });
+    return connections.run(connection, run);
+}
+/** A disconnected subscriber stops only its SDK queue, never the task bus. */
+export function subscriptionBus(source) {
+    const connection = connections.getStore();
+    if (!source || !connection?.subscription)
+        return source;
+    if (connection.signal.aborted)
+        return undefined;
+    const mirror = new DefaultExecutionEventBus();
+    const forward = (event) => mirror.publish(event);
+    const finish = () => {
+        source.off('event', forward).off('finished', finish);
+        connection.signal.removeEventListener('abort', finish);
+        mirror.finished();
+    };
+    source.on('event', forward).on('finished', finish);
+    connection.signal.addEventListener('abort', finish, { once: true });
+    return mirror;
+}
+async function* connectedStream(stream, subscription) {
+    const connection = connections.getStore();
+    if (connection)
+        connection.subscription = subscription;
+    for await (const event of stream) {
+        // Disconnected sends still drain the SDK ResultManager for persistence.
+        if (!connection?.signal.aborted)
+            yield event;
+    }
+}
+/** Keep SDK parsing, serialization and errors; adapt only stream consumption. */
+export function connectedRequestHandler(handler) {
+    return new Proxy(handler, {
+        get(target, key) {
+            if (key === 'sendMessageStream')
+                return (...args) => connectedStream(target.sendMessageStream(...args), false);
+            if (key === 'resubscribe')
+                return (...args) => connectedStream(target.resubscribe(...args), true);
+            const value = Reflect.get(target, key, target);
+            return typeof value === 'function' ? value.bind(target) : value;
+        },
+    });
+}