@amaster.ai/dsh-a2a 0.1.25 → 0.1.27

package/README.md

@@ -12,6 +12,16 @@ A2A protocol server plugin for [DeepSeek Harness (dsh)](https://github.com/deeps
 dsh plugin --profile my-agent add @amaster.ai/dsh-a2a
 ```
 
+## Native inbox execution
+
+`inbox.enabled: true` uses the official DSH inbox (`Agent.send`) for ordinary `next-turn` input and `next-step` steering. Tested with the unmodified npm runtime `0.2.1-rc.2`; no core patch is required. The queue and its durable projection belong to DSH. The plugin only materializes messages, attaches A2A task identities, and translates execution events.
+
+Standard `SendMessage` / `SendStreamingMessage`, task queries, cancellation and subscriptions remain the wire interface. The negotiated [inbox extension](../../docs/protocol/inbox-v1.md) forwards `target` and `wakeup` to DSH. `wakeup: false` leaves an idle driver parked; it does not prevent an active driver from consuming pending input. A later real waking message releases pending input.
+
+The same-process `a2aInbox` service exposes `resolve(contextId)`, `content(message, contextId)`, `enqueue(taskId, message, { target?, wakeup? })`, and `cancel(taskId)`. There is no separate pause, wake-only, resume, or retained-task restart operation. Cancellation is terminal and removes that task's pending input. Other tasks' input is retained according to official DSH cancellation semantics, and may wait for the next waking message. Clearing a context discards all its pending work.
+
+`a2a/before-followup` validates admission; `a2a/before-step` runs at the official pre-step boundary, after system-prompt assembly and before model execution. It cannot change the already assembled system prompt. Original request headers remain process-local. DSH persistence restores its own pending projection; the plugin does not replay splice logs or recover consumed claims. Graceful disposal follows the official runtime's cancellation behavior. Durable A2A task snapshots still require a Redis or GCS TaskStore; an in-memory store is sufficient without restart requirements.
+
 ## Configuration
 
 Disabled by default. Configure via the profile's `cordis.patch.yml`:

package/lib/bridge.js

@@ -14,6 +14,7 @@
  * autonomous turns through `a2a/task-settlement`.
  */
 import { AsyncLocalStorage } from 'node:async_hooks';
+import { randomUUID } from 'node:crypto';
 import { TaskState } from '@a2a-js/sdk';
 import { AgentEvent } from '@a2a-js/sdk/server';
 // installModelSelection is a root-module runtime import: the dsh-agent index
@@ -30,6 +31,7 @@ import { agentTextMessage, SessionTranslator, terminalStatusUpdate } from './tra
 export class A2aBridge {
     ctx;
     options;
+    inbox;
     tasks = new Map(); // taskId → entry
     bySession = new Map(); // sessionId (== contextId) → entry
     clearing = new Set();
@@ -117,8 +119,8 @@ export class A2aBridge {
                 this.creating.delete(contextId);
         }
     }
-    async ensureTaskInner(taskId, contextId) {
-        if (this.clearing.has(contextId))
+    async ensureTaskInner(taskId, contextId, clearing = false) {
+        if (this.clearing.has(contextId) && !clearing)
             throw new Error('Context is being cleared.');
         const existing = this.tasks.get(taskId);
         if (existing)
@@ -185,7 +187,11 @@ export class A2aBridge {
         const persistence = this.ctx.get('sessionPersistence');
         const persisted = await persistence?.stat(sessionId);
         const handle = persisted
-            ? await this.ctx.agents.resume({ resumeSessionId: sessionId, agentOptions, setup })
+            ? await this.ctx.agents.resume({
+                resumeSessionId: sessionId,
+                agentOptions,
+                setup,
+            })
             : await this.ctx.agents.create({
                 sessionId,
                 meta: { cwd: this.options.cwd, ...(agentPreset ? { agentPreset } : {}) },
@@ -291,6 +297,19 @@ export class A2aBridge {
     async waitForTurn(entry) {
         await Promise.allSettled([...entry.running]);
     }
+    /** The official inbox claim selects the task that owns the next model step. */
+    bindInboxTask(entry, taskId, translator, bus, completion, controller) {
+        this.tasks.delete(entry.taskId);
+        entry.taskId = taskId;
+        entry.translator = translator;
+        entry.bus = bus;
+        entry.interrupted = false;
+        entry.settlementAbort = controller;
+        entry.running.clear();
+        entry.running.add(completion);
+        void completion.then(() => entry.running.delete(completion));
+        this.tasks.set(taskId, entry);
+    }
     /** 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);
@@ -484,9 +503,16 @@ export class A2aBridge {
             throw new Error('Context is already being cleared.');
         this.clearing.add(contextId);
         try {
+            await this.inbox?.clear(contextId);
             await Promise.allSettled([...(this.creating.get(contextId) ?? [])]);
+            if (this.inbox && !this.bySession.has(contextId)) {
+                const persistence = this.ctx.get('sessionPersistence');
+                if (await persistence?.stat(SessionId(contextId)))
+                    await this.ensureTaskInner(randomUUID(), contextId, true);
+            }
             const entry = this.bySession.get(contextId);
             if (entry) {
+                entry.handle.agent.inbox?.clear();
                 const active = entry.turnActive || entry.running.size > 0;
                 this.settleEntry(entry, 'Context cleared.');
                 if (active) {
@@ -530,6 +556,12 @@ export class A2aBridge {
     }
     /** Dispose every owned agent (plugin unload / server shutdown). */
     async dispose() {
+        try {
+            await this.inbox?.shutdown();
+        }
+        catch (error) {
+            console.error('[dsh-a2a] native inbox shutdown failed:', error);
+        }
         const entries = [...this.tasks.values()];
         this.tasks.clear();
         this.bySession.clear();
@@ -575,6 +607,14 @@ export class A2aBridge {
         }
         if (event.type === 'turn/start')
             entry.turnActive = true;
+        if (this.inbox?.onSessionEvent(session, event)) {
+            if (event.type === 'turn/end') {
+                this.withdrawApprovals(entry);
+                this.asked.delete(session.id);
+                entry.turnActive = false;
+            }
+            return;
+        }
         // 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.
@@ -667,6 +707,8 @@ export class A2aBridge {
      * `assistant/message` events). Same no-throw seam as the session feed.
      */
     onAssistantStream(agent, frame) {
+        if (this.inbox?.onAssistantStream(agent, frame))
+            return;
         const entry = this.bySession.get(agent.session.id);
         if (!entry || entry.staleTurn)
             return;
@@ -679,6 +721,7 @@ export class A2aBridge {
         }
     }
     onSessionDisposed(session) {
+        this.inbox?.onDisposed(session);
         this.children.delete(session);
         const entry = this.bySession.get(session.id);
         if (!entry)

package/lib/executor.js

@@ -29,6 +29,9 @@ export class DshAgentExecutor {
         this.suppressTask = suppressTask;
     }
     async execute(requestContext, eventBus) {
+        if (this.bridge.inbox && !this.bridge.validateApprovalMessage(requestContext.userMessage)) {
+            return this.bridge.trackExecution(requestContext.contextId, () => this.bridge.inbox.execute(requestContext, eventBus));
+        }
         if (this.bridge.isClearing(requestContext.contextId)) {
             this.suppressTask?.(requestContext.taskId);
         }
@@ -87,7 +90,8 @@ export class DshAgentExecutor {
         // canceled statusUpdate via the translator — a harmless duplicate); the
         // published event moves the persisted shell to canceled through the
         // handler's ResultManager either way.
-        const contextId = this.bridge.cancel(taskId) ?? '';
+        const contextId = (this.bridge.inbox ? await this.bridge.inbox.cancel(taskId) : this.bridge.cancel(taskId)) ??
+            '';
         eventBus.publish(terminalStatusUpdate(taskId, contextId, 'canceled', 'Task canceled by request.'));
     };
 }