@amaster.ai/dsh-a2a 0.1.8 → 0.1.9

package/lib/bridge.js

@@ -170,10 +170,10 @@ export class A2aBridge {
         }
     }
     /** Queue one user-message turn on the task's agent and await its `turn/end`. */
-    async runTurn(entry, content, bus) {
+    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);
+        const running = this.runTurnInner(entry, content, bus, a2aMessageId, requestHeaders);
         entry.running.add(running);
         try {
             await running;
@@ -182,7 +182,7 @@ export class A2aBridge {
             entry.running.delete(running);
         }
     }
-    async runTurnInner(entry, content, bus) {
+    async runTurnInner(entry, content, bus, a2aMessageId, requestHeaders) {
         let resolveSettled;
         const settled = new Promise((resolve) => {
             resolveSettled = resolve;
@@ -190,26 +190,45 @@ export class A2aBridge {
         entry.settled.push(resolveSettled);
         entry.bus = bus;
         try {
-            const result = entry.handle.agent.followup(createUserMessage({
-                content,
-                source: { kind: 'user' },
-            }));
-            // followup() is typed void; guard a mistyped async impl anyway — an
-            // unhandled rejection would crash the host process, and no turn/end
-            // would ever settle this waiter.
-            void Promise.resolve(result).catch((error) => {
-                const message = error instanceof Error ? error.message : String(error);
-                console.error('[dsh-a2a] followup failed:', error);
-                if (entry.bus === bus) {
-                    entry.bus.publish(terminalStatusUpdate(entry.taskId, entry.sessionId, 'failed', message));
-                }
-                resolveSettled();
+            const message = createUserMessage({ content, source: { kind: 'user' } });
+            // 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 }) => {
+                if (agent !== entry.handle.agent || inserted.id !== message.id)
+                    return;
+                stopListening();
+                void this.ctx
+                    .parallel('a2a/message-admitted', {
+                    contextId: entry.sessionId,
+                    taskId: entry.taskId,
+                    a2aMessageId,
+                    dshMessageId: message.id,
+                    requestHeaders,
+                })
+                    .catch((error) => {
+                    console.error('[dsh-a2a] message-admitted listener failed:', error);
+                });
             });
-            // Never rejects: waiters only resolve. A synchronous followup() throw is
-            // the one failure path — it means no turn ever started, so pull this
-            // waiter back out of the FIFO before it can be settled by the NEXT
-            // turn's turn/end (which would resolve one execute() too early).
-            await settled;
+            try {
+                const result = entry.handle.agent.followup(message);
+                // followup() is typed void; guard a mistyped async impl anyway — an
+                // unhandled rejection would crash the host process, and no turn/end
+                // would ever settle this waiter.
+                void Promise.resolve(result).catch((error) => {
+                    const message = error instanceof Error ? error.message : String(error);
+                    console.error('[dsh-a2a] followup failed:', error);
+                    if (entry.bus === bus) {
+                        entry.bus.publish(terminalStatusUpdate(entry.taskId, entry.sessionId, 'failed', message));
+                    }
+                    resolveSettled();
+                });
+                // Never rejects: waiters only resolve. A synchronous followup() throw
+                // means no turn started, so pull its waiter from the FIFO below.
+                await settled;
+            }
+            finally {
+                stopListening();
+            }
         }
         catch (error) {
             const index = entry.settled.indexOf(resolveSettled);

package/lib/executor.js

@@ -18,7 +18,7 @@
  * `cancelTask` is an arrow property because the SDK destructures it.
  */
 import { TaskState } from '@a2a-js/sdk';
-import { AgentEvent } from '@a2a-js/sdk/server';
+import { AgentEvent, STATE_HEADERS_KEY } from '@a2a-js/sdk/server';
 import { agentTextMessage, terminalStatusUpdate } from './translator.js';
 export class DshAgentExecutor {
     bridge;
@@ -48,7 +48,8 @@ export class DshAgentExecutor {
                     // stored task (history/artifacts preserved).
                     taskEvent(taskId, contextId, TaskState.TASK_STATE_WORKING));
             anchored = true;
-            await this.bridge.runTurn(entry, content, eventBus);
+            const requestHeaders = requestContext.context.state.get(STATE_HEADERS_KEY);
+            await this.bridge.runTurn(entry, content, eventBus, userMessage.messageId, requestHeaders);
         }
         catch (error) {
             if (this.bridge.isClearing(contextId))

package/lib/index.js

@@ -20,6 +20,8 @@ import { startA2aServer } from './server.js';
 import { GcsTaskStore } from './stores/gcs.js';
 import { RedisTaskStore } from './stores/redis.js';
 import { MemoryTaskStore, SanitizedTaskStore } from './task-store.js';
+/** Event emitted when one A2A user message enters the dsh inbox. */
+export const A2A_MESSAGE_ADMITTED_EVENT = 'a2a/message-admitted';
 export const name = 'dsh-a2a';
 /** The bridge creates and owns agents through the registry service. */
 export const inject = ['agents'];

package/lib/types/bridge.d.ts

@@ -78,7 +78,7 @@ export declare class A2aBridge {
     /** 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): Promise<void>;
+    runTurn(entry: TaskEntry, content: ContentBlock[], bus: ExecutionEventBus, a2aMessageId: string, 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/index.d.ts

@@ -14,6 +14,20 @@
 import type { Context } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
 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";
+declare module '@deepseek-ai/cordis' {
+    interface Events {
+        /** Link a protocol message to the dsh inbox message created for its turn. */
+        'a2a/message-admitted'(detail: {
+            contextId: string;
+            taskId: string;
+            a2aMessageId: string;
+            dshMessageId: string;
+            requestHeaders: unknown;
+        }): void;
+    }
+}
 export declare const name = "dsh-a2a";
 /** The bridge creates and owns agents through the registry service. */
 export declare const inject: string[];

package/package.json

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