@amaster.ai/dsh-a2a 0.1.12 → 0.1.14

package/README.md

@@ -54,7 +54,9 @@ Disabled by default. Configure via the profile's `cordis.patch.yml`:
 
 ## Behavior notes
 
-- **One task = one dsh session.** The A2A `contextId` IS the dsh session id. A completed turn ends `input-required`, not `completed` — the task is a conversation and stays continuable; `CancelTask` and turn errors are terminal (`canceled` / `failed`), and the SDK rejects follow-ups addressed at a terminal `taskId` (send with only the `contextId` to continue the session under a fresh task id).
+- **One task = one dsh session.** The A2A `contextId` IS the dsh session id. By default, a completed turn ends `input-required`, not `completed` — the task is a conversation and stays continuable; `CancelTask` and turn errors are terminal (`canceled` / `failed`), and the SDK rejects follow-ups addressed at a terminal `taskId` (send with only the `contextId` to continue the session under a fresh task id).
+- **Same-task messages.** `ctx.on('a2a/working-task-message', async (detail) => { ... })` runs when another message targets an executing task, before waiting for that task's prior request. Its detail contains `agent`, `contextId`, `taskId`, the original `a2aMessage` (including its `messageId`), `requestHeaders`, and an abort `signal`; the host can use it to end or revise pending continuation. Failure rejects the new request without enqueueing it. The plugin still serializes agent follow-ups.
+- **Host admission and settlement.** `ctx.on('a2a/before-followup', async (detail) => { ... })` runs before every user message enters the agent inbox. Its detail contains `agent`, `contextId`, `taskId`, the original `a2aMessage`, `dshMessageId`, `requestHeaders`, and an abort `signal`; rejection fails the A2A task without enqueueing the message. A host may inspect its own A2A message metadata here; the plugin does not interpret it. The existing `a2a/message-admitted` event remains an observational tap after insertion. A host can register `ctx.on('a2a/task-settlement', async ({ agent, contextId, taskId, reason, signal }, next) => { await hostWork; return next(); })`. The hook starts after the first completed turn and may wait for any number of autonomous follow-ups, including none. The plugin streams their events under the same task ID and publishes the latest turn's final status when the hook resolves. Cancel, clear, and disposal abort the signal and release the waiter. Without this hook, the first completed turn settles as before. The host must end its wait when its work is done; the plugin does not infer that from product metadata.
 - **Agents are full preset citizens.** Each task's agent is created with the deployment's default model selection (`agentDefaultModel`) and mounts its agent preset (the web profile keeps all tools inside presets — without one the agent would see an empty tool catalog). `agent.preset` pins a specific preset.
 - **Streaming aggregation.** Text deltas of a turn share one `messageId`, so clients accumulate them into a single message; reasoning deltas ride a separate `messageId` and are marked `metadata.dshAgent.kind: 'thought'`. The turn-final event's message carries the full assembled text, so blocking `SendMessage` clients read the answer from `result.task.status.message`. Tool calls/results are data parts marked `tool-call` / `tool-result`; token usage lands in `metadata.usage` of the final event. A2A 1.0 has no `final` flag — terminal and interrupted states close the stream.
 - **Message parts beyond text.** File parts can carry inline bytes or a `url`; the plugin downloads URLs over http/https, bounded to 64 MiB and 30 s. Supported images use the composed attachment store (`ctx.attachments`, e.g. `@deepseek-ai/dsh-attachment-local`) to reach vision-capable models. Non-image files use a configured materializer or persist under `uploadsDir` (default `<OS temp>/dsh-a2a-uploads/<date>/`, names sanitized cross-platform, collisions suffixed), even when an attachment store exists. The prompt references the resulting readable path inside a `<document>` tag. Ensure the local directory is readable by the agent's tools. `data` parts become `<data>` JSON text. A turn never fails because a part kind is unsupported.
@@ -62,7 +64,7 @@ Disabled by default. Configure via the profile's `cordis.patch.yml`:
 - **Local execution files.** Without a remote materializer, inline and downloaded non-image FileParts persist under `uploadsDir`; the `<document>` envelope carries the path, source URL, media type, size, and original filename when sanitization or a collision changes it. Images still use native attachment handling.
 - **Tool approvals.** When the profile composes `@deepseek-ai/dsh-user-approval` with policy `ask`, A2A-owned agents answer `approval/request` by publishing `input-required` with a DataPart `{ requestId, toolName, reason?, callId? }`. Reply on the same `taskId`/`contextId` with one DataPart `{ requestId, callId?, outcome: "allowed-once" | "rejected" }`. The reply settles the waiting tool call inside the original dsh turn; it does not create another user message or billing turn. Invalid, duplicate, and withdrawn replies are rejected. `never` policy rejects inside dsh before the A2A answerer is called. The approval service is optional; without it, `ask` fails closed as usual.
 - **Custom approval payloads.** A deployment may register `ctx.provide('a2aApprovalCodec', codec)` before this plugin starts. The exported `A2aApprovalCodec` has `encode(request)` and `decode(message)` methods; `decode` returns `{ requestId?, callId?, outcome }` only for a supported one-shot decision. A unique `callId` can replace `requestId` for legacy clients. Reject unsupported outcomes in the decoder; never translate `proceed_always` into `allowed-once`. Other message types, including question, plan, and UI markup, remain outside this plugin.
-- **One in-flight user turn per task** is the supported flow (send the next user message after the turn-final event). Approval confirmations are the exception: they settle a pending decision in that same turn. dsh serializes queued follow-ups into successive turns, but concurrent unrelated requests share one event bus — a second in-flight request may resolve with the first turn's final event.
+- **Requests for one task execute in order.** Autonomous turns covered by a settlement hook finish before the next user request starts. Approval confirmations settle a pending decision inside its current turn.
 - **Restart**: persisted task shells survive in Redis/GCS. With `sessionPersistence` composed, a `contextId` already present on disk resumes its dsh session after restart; a new id creates a new session.
 - **Clear**: the same-process gateway can call `ctx.get('a2aTasks').clearContext(contextId)` before reporting `messages/clear` success. It cancels and drains the live turn, removes the binding and every TaskStore shell for that context, and returns the removed task IDs. The gateway owns the separate session-surface replacement and client-visible history-ID update.
 

package/lib/bridge.js

@@ -9,11 +9,9 @@
  * {@link SessionTranslator} onto the executing request's
  * {@link ExecutionEventBus}.
  *
- * Turn settlement: `agent.followup()` is fire-and-forget, so callers await a
- * FIFO waiter resolved by the session's next `turn/end` event (dsh's inbox
- * serializes queued follow-ups into successive turns, so waiter order matches
- * turn order). The final status-update is published before the waiter
- * resolves, so an execute() that returns always landed its events first.
+ * Turn settlement: `agent.followup()` is fire-and-forget. The default policy
+ * settles at the next `turn/end`; a host may keep the same task open for
+ * autonomous turns through `a2a/task-settlement`.
  */
 import { TaskState } from '@a2a-js/sdk';
 import { AgentEvent } from '@a2a-js/sdk/server';
@@ -81,13 +79,24 @@ export class A2aBridge {
             return { entry: existing, freshTask: false };
         const forContext = this.bySession.get(contextId);
         if (forContext) {
-            this.withdrawApprovals(forContext);
+            const staleTurn = forContext.staleTurn || forContext.turnActive;
+            this.settleEntry(forContext, 'Task superseded by a new request.');
+            forContext.staleTurn = staleTurn;
+            // The previous task may have queued autonomous work that has not started
+            // a turn yet. dsh-agent cancel clears that inbox work synchronously.
+            try {
+                forContext.handle.agent.cancel({ kind: 'user' });
+            }
+            catch (error) {
+                console.error('[dsh-a2a] rebind cancel failed:', error);
+            }
             this.tasks.delete(forContext.taskId);
             forContext.taskId = taskId;
             forContext.translator = new SessionTranslator(taskId, contextId, this.options.agentOptions?.model);
             // A turn still open from the previous binding (e.g. a cancel whose abort
             // is still propagating) must not emit events under the new task id.
-            forContext.staleTurn = forContext.turnActive;
+            forContext.interrupted = false;
+            forContext.terminalState = undefined;
             this.tasks.set(taskId, forContext);
             return { entry: forContext, freshTask: true };
         }
@@ -147,6 +156,10 @@ export class A2aBridge {
             staleTurn: false,
             settled: [],
             running: new Set(),
+            pendingMessageAborts: new Set(),
+            settlementAbort: new AbortController(),
+            settling: false,
+            interrupted: false,
         };
         this.tasks.set(taskId, entry);
         this.bySession.set(contextId, entry);
@@ -232,6 +245,38 @@ export class A2aBridge {
     async waitForTurn(entry) {
         await Promise.allSettled([...entry.running]);
     }
+    /** Inspect a message for a live task before the SDK starts its next request. */
+    async beforeWorkingTaskMessage(a2aMessage, requestHeaders) {
+        const entry = this.tasks.get(a2aMessage.taskId);
+        if (!entry ||
+            (a2aMessage.contextId && entry.sessionId !== a2aMessage.contextId) ||
+            entry.running.size === 0)
+            return;
+        const pending = new AbortController();
+        entry.pendingMessageAborts.add(pending);
+        try {
+            await Promise.race([
+                this.ctx.serial('a2a/working-task-message', {
+                    agent: entry.handle.agent,
+                    contextId: entry.sessionId,
+                    taskId: entry.taskId,
+                    a2aMessage,
+                    requestHeaders,
+                    signal: pending.signal,
+                }),
+                new Promise((_, reject) => {
+                    const abort = () => reject(new Error('A2A task was interrupted before message admission.'));
+                    if (pending.signal.aborted)
+                        abort();
+                    else
+                        pending.signal.addEventListener('abort', abort, { once: true });
+                }),
+            ]);
+        }
+        finally {
+            entry.pendingMessageAborts.delete(pending);
+        }
+    }
     /** Include content preparation in the work a context clear must drain. */
     async trackExecution(contextId, run) {
         const execution = run();
@@ -251,27 +296,84 @@ export class A2aBridge {
         }
     }
     /** Queue one user-message turn on the task's agent and await its `turn/end`. */
-    async runTurn(entry, content, bus, a2aMessageId, requestHeaders) {
-        if (this.clearing.has(entry.sessionId))
-            throw new Error('Context is being cleared.');
-        const running = this.runTurnInner(entry, content, bus, a2aMessageId, requestHeaders);
+    async runTurn(entry, content, bus, taskId, a2aMessage, requestHeaders) {
+        const previous = [...entry.running];
+        const running = (async () => {
+            if (entry.interrupted || entry.taskId !== taskId || this.tasks.get(taskId) !== entry) {
+                bus.publish(terminalStatusUpdate(taskId, entry.sessionId, 'canceled', 'Task interrupted.'));
+                return;
+            }
+            await Promise.allSettled(previous);
+            if (this.clearing.has(entry.sessionId))
+                throw new Error('Context is being cleared.');
+            if (entry.terminalState) {
+                bus.publish(terminalStatusUpdate(taskId, entry.sessionId, entry.terminalState, 'Task ended.'));
+                return;
+            }
+            if (entry.interrupted || entry.taskId !== taskId || this.tasks.get(taskId) !== entry) {
+                bus.publish(terminalStatusUpdate(taskId, entry.sessionId, 'canceled', 'Task interrupted.'));
+                return;
+            }
+            await this.runTurnInner(entry, content, bus, taskId, a2aMessage, requestHeaders);
+        })();
         entry.running.add(running);
         try {
             await running;
         }
+        catch (error) {
+            entry.terminalState = 'failed';
+            throw error;
+        }
         finally {
             entry.running.delete(running);
+            if (entry.running.size === 0)
+                entry.terminalState = undefined;
         }
     }
-    async runTurnInner(entry, content, bus, a2aMessageId, requestHeaders) {
+    async runTurnInner(entry, content, bus, taskId, a2aMessage, requestHeaders) {
         let resolveSettled;
         const settled = new Promise((resolve) => {
             resolveSettled = resolve;
         });
         entry.settled.push(resolveSettled);
         entry.bus = bus;
+        entry.settlementAbort = new AbortController();
+        entry.settling = false;
+        entry.lastFinal = undefined;
         try {
             const message = createUserMessage({ content, source: { kind: 'user' } });
+            const admission = new AbortController();
+            entry.admissionAbort = admission;
+            try {
+                await Promise.race([
+                    this.ctx.serial('a2a/before-followup', {
+                        agent: entry.handle.agent,
+                        contextId: entry.sessionId,
+                        taskId,
+                        a2aMessage,
+                        dshMessageId: message.id,
+                        requestHeaders,
+                        signal: admission.signal,
+                    }),
+                    new Promise((_, reject) => {
+                        const abort = () => reject(new Error('A2A task was interrupted before message admission.'));
+                        if (admission.signal.aborted)
+                            abort();
+                        else
+                            admission.signal.addEventListener('abort', abort, { once: true });
+                    }),
+                ]);
+            }
+            finally {
+                if (entry.admissionAbort === admission)
+                    entry.admissionAbort = undefined;
+            }
+            if (!entry.settled.includes(resolveSettled) ||
+                entry.interrupted ||
+                entry.taskId !== taskId ||
+                this.tasks.get(taskId) !== entry) {
+                return;
+            }
             // followup() inserts synchronously, then may claim the message before
             // returning. Observe that insertion so the mapping is both real and early.
             const stopListening = this.ctx.on('agent/inbox/inserted', ({ agent, message: inserted }) => {
@@ -281,8 +383,8 @@ export class A2aBridge {
                 void this.ctx
                     .parallel('a2a/message-admitted', {
                     contextId: entry.sessionId,
-                    taskId: entry.taskId,
-                    a2aMessageId,
+                    taskId,
+                    a2aMessageId: a2aMessage.messageId,
                     dshMessageId: message.id,
                     requestHeaders,
                 })
@@ -296,10 +398,14 @@ export class A2aBridge {
                 // unhandled rejection would crash the host process, and no turn/end
                 // would ever settle this waiter.
                 void Promise.resolve(result).catch((error) => {
+                    entry.terminalState = 'failed';
                     const message = error instanceof Error ? error.message : String(error);
                     console.error('[dsh-a2a] followup failed:', error);
+                    const index = entry.settled.indexOf(resolveSettled);
+                    if (index >= 0)
+                        entry.settled.splice(index, 1);
                     if (entry.bus === bus) {
-                        entry.bus.publish(terminalStatusUpdate(entry.taskId, entry.sessionId, 'failed', message));
+                        entry.bus.publish(terminalStatusUpdate(taskId, entry.sessionId, 'failed', message));
                     }
                     resolveSettled();
                 });
@@ -315,11 +421,15 @@ export class A2aBridge {
             const index = entry.settled.indexOf(resolveSettled);
             if (index >= 0)
                 entry.settled.splice(index, 1);
+            else
+                return; // cancellation/clear already published the terminal state
             throw error;
         }
         finally {
-            if (entry.bus === bus)
+            if (entry.bus === bus) {
+                entry.settlementAbort.abort();
                 entry.bus = null;
+            }
         }
     }
     /** Cancel and release the live binding before the caller deletes stored shells. */
@@ -331,12 +441,17 @@ export class A2aBridge {
             await Promise.allSettled([...(this.creating.get(contextId) ?? [])]);
             const entry = this.bySession.get(contextId);
             if (entry) {
-                this.withdrawApprovals(entry);
-                if (entry.turnActive || entry.running.size > 0) {
-                    await entry.handle.agent.cancel({ kind: 'user' });
+                const active = entry.turnActive || entry.running.size > 0;
+                this.settleEntry(entry, 'Context cleared.');
+                if (active) {
+                    try {
+                        await entry.handle.agent.cancel({ kind: 'user' });
+                    }
+                    catch (error) {
+                        console.error('[dsh-a2a] clear cancel failed:', error);
+                    }
                 }
                 await entry.handle.agent.whenIdle();
-                this.settleEntry(entry, 'Context cleared.');
                 await Promise.allSettled([...entry.running]);
                 this.tasks.delete(entry.taskId);
                 this.bySession.delete(contextId);
@@ -354,10 +469,17 @@ export class A2aBridge {
         const entry = this.tasks.get(taskId);
         if (!entry)
             return undefined;
-        this.withdrawApprovals(entry);
+        const staleTurn = entry.turnActive;
+        this.settleEntry(entry, 'Task canceled by request.');
+        entry.staleTurn ||= staleTurn;
         // cancel() is typed void; the guard keeps a mistyped async impl from
         // crashing the host (the caller already published its canceled final).
-        void Promise.resolve(entry.handle.agent.cancel({ kind: 'user' })).catch((error) => console.error('[dsh-a2a] cancel failed:', error));
+        try {
+            void Promise.resolve(entry.handle.agent.cancel({ kind: 'user' })).catch((error) => console.error('[dsh-a2a] cancel failed:', error));
+        }
+        catch (error) {
+            console.error('[dsh-a2a] cancel failed:', error);
+        }
         return entry.sessionId;
     }
     /** Dispose every owned agent (plugin unload / server shutdown). */
@@ -380,6 +502,11 @@ export class A2aBridge {
         const entry = this.bySession.get(session.id);
         if (!entry)
             return;
+        if (entry.staleTurn) {
+            if (event.type === 'turn/end')
+                entry.staleTurn = false;
+            return;
+        }
         if (event.type === 'approval/asked') {
             const queue = this.asked.get(session.id) ?? [];
             queue.push({ id: event.data.id, toolName: event.data.toolName, callId: event.data.callId });
@@ -387,29 +514,91 @@ export class A2aBridge {
         }
         if (event.type === 'turn/start')
             entry.turnActive = true;
-        // A turn carried over from a previous task binding (e.g. a canceled turn
-        // whose abort was still in flight when the context rebound): its turn/end
-        // belongs to the old task — settle waiters, but publish nothing under the
-        // new task id.
-        const stale = event.type === 'turn/end' && entry.staleTurn;
-        if (stale)
-            entry.staleTurn = false;
         // No-throw seam: translation errors must never reach the agent loop. The
         // turn/end waiter still resolves below, so a poisoned event cannot hang
         // an in-flight execute() either.
         try {
-            if (!stale)
-                for (const out of entry.translator.handle(event))
+            const outputs = entry.translator.handle(event);
+            if (event.type === 'turn/end' &&
+                (event.data.reason.kind === 'completed' || event.data.reason.kind === 'max-tokens') &&
+                entry.bus) {
+                const bus = entry.bus;
+                const taskId = entry.taskId;
+                entry.lastFinal = outputs[0];
+                if (!entry.settling) {
+                    entry.settling = true;
+                    const signal = entry.settlementAbort.signal;
+                    const complete = () => {
+                        if (signal.aborted || entry.bus !== bus || entry.taskId !== taskId)
+                            return;
+                        if (entry.lastFinal)
+                            bus.publish(entry.lastFinal);
+                        entry.bus = null;
+                        entry.settlementAbort.abort();
+                        entry.settled.shift()?.();
+                    };
+                    const wait = this.ctx.waterfall('a2a/task-settlement', {
+                        agent: entry.handle.agent,
+                        contextId: entry.sessionId,
+                        taskId,
+                        reason: event.data.reason,
+                        signal,
+                    }, () => { });
+                    if (!wait)
+                        complete();
+                    else
+                        void Promise.race([
+                            wait,
+                            new Promise((resolve) => {
+                                if (signal.aborted)
+                                    resolve();
+                                else
+                                    signal.addEventListener('abort', () => resolve(), { once: true });
+                            }),
+                        ])
+                            .then(complete)
+                            .catch((error) => {
+                            if (entry.bus !== bus || entry.taskId !== taskId)
+                                return;
+                            entry.terminalState = 'failed';
+                            const message = error instanceof Error ? error.message : String(error);
+                            console.error('[dsh-a2a] task settlement failed:', error);
+                            bus.publish(terminalStatusUpdate(taskId, entry.sessionId, 'failed', message));
+                            entry.bus = null;
+                            entry.settlementAbort.abort();
+                            entry.settled.shift()?.();
+                        });
+                }
+            }
+            else {
+                for (const out of outputs)
                     entry.bus?.publish(out);
+            }
         }
         catch (error) {
             console.error('[dsh-a2a] failed to translate session event:', error);
+            if (event.type === 'turn/end' &&
+                (event.data.reason.kind === 'completed' || event.data.reason.kind === 'max-tokens')) {
+                entry.terminalState = 'failed';
+                entry.bus?.publish(terminalStatusUpdate(entry.taskId, entry.sessionId, 'failed', 'Failed to translate agent turn.'));
+                entry.bus = null;
+                entry.settlementAbort.abort();
+                entry.settled.shift()?.();
+            }
         }
         if (event.type === 'turn/end') {
+            if (event.data.reason.kind === 'blocked' || event.data.reason.kind === 'error')
+                entry.terminalState = 'failed';
+            if (event.data.reason.kind === 'aborted')
+                entry.terminalState = 'canceled';
             this.withdrawApprovals(entry);
             this.asked.delete(session.id);
             entry.turnActive = false;
-            entry.settled.shift()?.();
+            if (event.data.reason.kind !== 'completed' && event.data.reason.kind !== 'max-tokens') {
+                entry.settlementAbort.abort();
+                entry.bus = null;
+                entry.settled.shift()?.();
+            }
         }
     }
     /**
@@ -418,7 +607,7 @@ export class A2aBridge {
      */
     onAssistantStream(agent, frame) {
         const entry = this.bySession.get(agent.session.id);
-        if (!entry)
+        if (!entry || entry.staleTurn)
             return;
         try {
             for (const out of entry.translator.handleStreamFrame(frame))
@@ -441,10 +630,16 @@ export class A2aBridge {
     }
     /** Close an in-flight stream honestly and release every turn waiter. */
     settleEntry(entry, message) {
+        entry.interrupted = true;
+        for (const pending of entry.pendingMessageAborts)
+            pending.abort();
+        entry.admissionAbort?.abort();
+        entry.settlementAbort.abort();
         this.withdrawApprovals(entry);
-        if (entry.turnActive && entry.bus) {
+        if (entry.bus && (entry.turnActive || entry.settled.length > 0)) {
             entry.bus.publish(terminalStatusUpdate(entry.taskId, entry.sessionId, 'canceled', message));
         }
+        entry.bus = null;
         entry.turnActive = false;
         for (const resolve of entry.settled.splice(0))
             resolve();

package/lib/executor.js

@@ -1,6 +1,6 @@
 /**
  * The @a2a-js/sdk {@link AgentExecutor} that drives dsh agents through the
- * bridge. One `execute()` = one user-message turn:
+ * bridge. One `execute()` starts one user message and may include host-owned follow-up turns:
  *
  *   1. map the message's parts onto dsh content blocks (file parts become
  *      execution-world paths with a materializer, local paths otherwise)
@@ -62,7 +62,7 @@ export class DshAgentExecutor {
                     taskEvent(taskId, contextId, TaskState.TASK_STATE_WORKING));
             anchored = true;
             const requestHeaders = requestContext.context.state.get(STATE_HEADERS_KEY);
-            await this.bridge.runTurn(entry, content, eventBus, userMessage.messageId, requestHeaders);
+            await this.bridge.runTurn(entry, content, eventBus, taskId, userMessage, requestHeaders);
         }
         catch (error) {
             if (error instanceof ApprovalReplyError)

package/lib/index.js

@@ -140,6 +140,7 @@ export function apply(ctx, config) {
             executor,
             taskStore: store,
             approvalGuard: (message) => bridge.reserveApprovalMessage(message),
+            beforeWorkingTaskMessage: (message, headers) => bridge.beforeWorkingTaskMessage(message, headers),
         });
         serverPort = server.port;
         console.log(`[dsh-a2a] A2A endpoint: http://${config.host}:${server.port}${config.basePath}/ ` +

package/lib/server.js

@@ -11,11 +11,12 @@
  * The SSE framing and error envelopes are the SDK's; this layer only binds
  * the server and builds the card.
  */
+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 { DefaultRequestHandler, ServerCallContext, } from '@a2a-js/sdk/server';
+import { DefaultExecutionEventBus, DefaultRequestHandler, ServerCallContext, STATE_HEADERS_KEY, } from '@a2a-js/sdk/server';
 import { agentCardHandler, jsonRpcHandler, UserBuilder } from '@a2a-js/sdk/server/express';
 import express from 'express';
 export async function startA2aServer(options) {
@@ -60,11 +61,71 @@ export async function startA2aServer(options) {
             throw new RequestMalformedError(error instanceof Error ? error.message : String(error));
         }
     };
+    // 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 taskBuses = new Map();
+    const busManager = {
+        createOrGetByTaskId(taskId) {
+            let task = taskBuses.get(taskId);
+            if (!task) {
+                const broadcast = new DefaultExecutionEventBus();
+                task = { broadcast, requests: new Set() };
+                taskBuses.set(taskId, task);
+                broadcast.on('event', (event) => {
+                    const state = event.kind === 'statusUpdate' ? event.data.status?.state : undefined;
+                    if (state !== undefined &&
+                        [
+                            TaskState.TASK_STATE_COMPLETED,
+                            TaskState.TASK_STATE_FAILED,
+                            TaskState.TASK_STATE_CANCELED,
+                            TaskState.TASK_STATE_REJECTED,
+                        ].includes(state))
+                        queueMicrotask(() => broadcast.finished());
+                });
+            }
+            if (approvalReply.getStore()) {
+                const active = task.requests.values().next().value;
+                if (active)
+                    return active;
+            }
+            const requestBus = new DefaultExecutionEventBus();
+            task.requests.add(requestBus);
+            requestBus.on('event', (event) => task.broadcast.publish(event));
+            requestBus.on('finished', () => task.requests.delete(requestBus));
+            return requestBus;
+        },
+        getByTaskId: (taskId) => taskBuses.get(taskId)?.broadcast,
+        cleanupByTaskId(taskId) {
+            const task = taskBuses.get(taskId);
+            task?.broadcast.finished();
+            task?.broadcast.removeAllListeners();
+            taskBuses.delete(taskId);
+        },
+    };
+    const beforeWorkingTaskMessage = async (message, context) => {
+        if (!message?.taskId)
+            return;
+        // Validate through the scoped store before a host hook can affect a live task.
+        const task = await options.taskStore.load(message.taskId, context);
+        if (!task ||
+            task.status?.state !== TaskState.TASK_STATE_WORKING ||
+            (message.contextId && message.contextId !== task.contextId))
+            return;
+        try {
+            await options.beforeWorkingTaskMessage?.(message, context.state.get(STATE_HEADERS_KEY));
+        }
+        catch (error) {
+            throw new RequestMalformedError(error instanceof Error ? error.message : String(error));
+        }
+    };
     const requestHandler = new (class extends DefaultRequestHandler {
         async sendMessage(...args) {
             const release = guardApproval(args[0].message);
             try {
-                return await super.sendMessage(...args);
+                if (!release)
+                    await beforeWorkingTaskMessage(args[0].message, args[1]);
+                return await approvalReply.run(Boolean(release), () => super.sendMessage(...args));
             }
             finally {
                 release?.();
@@ -73,13 +134,27 @@ export async function startA2aServer(options) {
         async *sendMessageStream(...args) {
             const release = guardApproval(args[0].message);
             try {
-                yield* super.sendMessageStream(...args);
+                if (!release)
+                    await beforeWorkingTaskMessage(args[0].message, args[1]);
+                const stream = super.sendMessageStream(...args);
+                try {
+                    if (release) {
+                        const first = await approvalReply.run(true, () => stream.next());
+                        if (!first.done)
+                            yield first.value;
+                    }
+                    yield* stream;
+                }
+                finally {
+                    if (release)
+                        await stream.return(undefined);
+                }
             }
             finally {
                 release?.();
             }
         }
-    })(card, options.taskStore, options.executor);
+    })(card, options.taskStore, options.executor, busManager);
     const app = express();
     // 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.

package/lib/types/bridge.d.ts

@@ -9,14 +9,12 @@
  * {@link SessionTranslator} onto the executing request's
  * {@link ExecutionEventBus}.
  *
- * Turn settlement: `agent.followup()` is fire-and-forget, so callers await a
- * FIFO waiter resolved by the session's next `turn/end` event (dsh's inbox
- * serializes queued follow-ups into successive turns, so waiter order matches
- * turn order). The final status-update is published before the waiter
- * resolves, so an execute() that returns always landed its events first.
+ * Turn settlement: `agent.followup()` is fire-and-forget. The default policy
+ * settles at the next `turn/end`; a host may keep the same task open for
+ * autonomous turns through `a2a/task-settlement`.
  */
 import { type Message } from '@a2a-js/sdk';
-import { type ExecutionEventBus } from '@a2a-js/sdk/server';
+import { type AgentExecutionEvent, type ExecutionEventBus } from '@a2a-js/sdk/server';
 import type { Context } from '@deepseek-ai/cordis';
 import type { AgentHandle } from '@deepseek-ai/dsh-agent';
 import type { ContentBlock } from '@deepseek-ai/dsh-llm/types';
@@ -46,10 +44,17 @@ export interface TaskEntry {
     turnActive: boolean;
     /** A turn still open from a previous task binding; its turn/end is stale. */
     staleTurn: boolean;
-    /** FIFO turn-end waiters, one per queued/running execute(). */
+    /** FIFO settlement waiters, one per queued/running execute(). */
     settled: Array<() => void>;
     /** Active execute() calls that must finish before task shells are deleted. */
     running: Set<Promise<void>>;
+    pendingMessageAborts: Set<AbortController>;
+    admissionAbort?: AbortController;
+    settlementAbort: AbortController;
+    settling: boolean;
+    lastFinal?: AgentExecutionEvent;
+    interrupted: boolean;
+    terminalState?: 'failed' | 'canceled';
 }
 export declare class A2aBridge {
     private readonly ctx;
@@ -89,10 +94,12 @@ export declare class A2aBridge {
     };
     private findApproval;
     waitForTurn(entry: TaskEntry): Promise<void>;
+    /** Inspect a message for a live task before the SDK starts its next request. */
+    beforeWorkingTaskMessage(a2aMessage: Message, requestHeaders: unknown): Promise<void>;
     /** Include content preparation in the work a context clear must drain. */
     trackExecution(contextId: string, run: () => Promise<void>): Promise<void>;
     /** Queue one user-message turn on the task's agent and await its `turn/end`. */
-    runTurn(entry: TaskEntry, content: ContentBlock[], bus: ExecutionEventBus, a2aMessageId: string, requestHeaders: unknown): Promise<void>;
+    runTurn(entry: TaskEntry, content: ContentBlock[], bus: ExecutionEventBus, taskId: string, a2aMessage: Message, requestHeaders: unknown): Promise<void>;
     private runTurnInner;
     /** Cancel and release the live binding before the caller deletes stored shells. */
     clearContext(contextId: string, clearStored?: (liveIds: string[]) => Promise<string[]>): Promise<string[]>;

package/lib/types/executor.d.ts

@@ -1,6 +1,6 @@
 /**
  * The @a2a-js/sdk {@link AgentExecutor} that drives dsh agents through the
- * bridge. One `execute()` = one user-message turn:
+ * bridge. One `execute()` starts one user message and may include host-owned follow-up turns:
  *
  *   1. map the message's parts onto dsh content blocks (file parts become
  *      execution-world paths with a materializer, local paths otherwise)

package/lib/types/index.d.ts

@@ -11,15 +11,47 @@
  *
  * @module dsh-a2a
  */
+import { type Message } from '@a2a-js/sdk';
 import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { TurnEndReason } from '@deepseek-ai/dsh-session';
 import Schema from '@deepseek-ai/schemastery';
 export type { A2aApproval, A2aApprovalCodec, A2aApprovalReply } from './approval.js';
 export { defaultApprovalCodec } from './approval.js';
 export type { A2aFileMaterializer } from './content.js';
 /** Event emitted when one A2A user message enters the dsh inbox. */
 export declare const A2A_MESSAGE_ADMITTED_EVENT: "a2a/message-admitted";
+export interface A2aTurnContext {
+    agent: Agent;
+    contextId: string;
+    taskId: string;
+    a2aMessage: Message;
+    dshMessageId: string;
+    requestHeaders: unknown;
+    signal: AbortSignal;
+}
+export interface A2aWorkingTaskMessageContext {
+    agent: Agent;
+    contextId: string;
+    taskId: string;
+    a2aMessage: Message;
+    requestHeaders: unknown;
+    signal: AbortSignal;
+}
 declare module '@deepseek-ai/cordis' {
     interface Events {
+        /** Awaited for a message targeting a running task, before waiting for its prior execution. */
+        'a2a/working-task-message'(detail: A2aWorkingTaskMessageContext): void;
+        /** Awaited before inbox insertion; failure rejects the A2A request. */
+        'a2a/before-followup'(detail: A2aTurnContext): void;
+        /** Await host-owned continuation work before closing this task. */
+        'a2a/task-settlement'(detail: {
+            agent: Agent;
+            contextId: string;
+            taskId: string;
+            reason: TurnEndReason;
+            signal: AbortSignal;
+        }, next: () => void | Promise<void>): Promise<void> | void;
         /** Link a protocol message to the dsh inbox message created for its turn. */
         'a2a/message-admitted'(detail: {
             contextId: string;

package/lib/types/server.d.ts

@@ -27,6 +27,7 @@ export interface A2aServerOptions {
     executor: AgentExecutor;
     taskStore: TaskStore;
     approvalGuard?: (message: Message) => undefined | (() => void);
+    beforeWorkingTaskMessage?: (message: Message, requestHeaders: unknown) => Promise<void>;
 }
 export interface A2aServer {
     /** The bound port (differs from options.port when 0). */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amaster.ai/dsh-a2a",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "A2A protocol (JSON-RPC + SSE) server plugin for DeepSeek Harness: expose dsh agents as A2A agents.",
   "type": "module",
   "main": "lib/index.js",