@nelsonlongxiang/dsh-open-a2a-net 0.6.42 → 0.7.0

package/lib/followup-delivery.js

@@ -0,0 +1,89 @@
+import { SessionId } from '@deepseek-ai/dsh-session';
+import { MessageId } from '@deepseek-ai/dsh-llm';
+import { AdmittedBookkeepingError } from "./admitted-bookkeeping.js";
+import { deliveryFingerprint } from "./task-delivery.js";
+import { createHash } from 'node:crypto';
+export class FollowupDelivery {
+    d;
+    constructor(d) {
+        this.d = d;
+    }
+    deliver(agent, text, sender, localFrom, taskId, callerKey, taskExpected = false) {
+        // Missing capability is a refusal, never a reason to call steer.
+        if (typeof agent.followup !== 'function')
+            throw Error('A2A requires Agent.followup; target runtime lacks sourced next-turn delivery');
+        const sessionId = String(agent.id), fingerprint = deliveryFingerprint(sessionId, text, sender, localFrom);
+        const messageId = MessageId('a2a-followup-' + createHash('sha256').update(taskId === undefined ? fingerprint + ':' + Date.now() + ':' + Math.random() : sessionId + ':' + taskId).digest('hex'));
+        if (taskId) {
+            const existing = this.d.ledger.deliveryFor(taskId);
+            if (existing) {
+                if (existing.sessionId !== sessionId || existing.fingerprint !== fingerprint || existing.callerKey !== callerKey)
+                    throw Error('task delivery identity conflict');
+                if (existing.state === 'cancelled' || existing.state === 'failed')
+                    throw Error('task delivery correspondence is terminal; no replay');
+                if (existing.state === 'reserved')
+                    throw Error('task delivery acceptance uncertain; reconcile the existing MessageId rather than redeliver');
+                if (this.d.ledger.orphanDelivery(taskId))
+                    throw new AdmittedBookkeepingError(undefined);
+                return;
+            }
+            this.d.ledger.reserveDelivery({ version: 1, taskId, messageId, sessionId, fingerprint, ...(taskExpected ? { taskExpected: true } : {}), ...(callerKey ? { callerKey } : {}), createdAt: Date.now(), state: 'reserved' });
+        }
+        const source = { kind: 'a2a-relay', form: 'relay', ...(sender === undefined ? {} : { senderSessionId: sender }), ...(localFrom === undefined ? {} : { localSender: localFrom }), ...(taskId === undefined ? {} : { taskId }) };
+        const message = { id: messageId, role: 'user', content: [{ type: 'text', text }], source };
+        this.d.taint(agent, localFrom);
+        try {
+            agent.followup(message);
+        }
+        catch (error) {
+            // The host may throw after durable insertion; preserve reserved/unknown, never blind replay.
+            this.d.warn('FOLLOWUP_ADMISSION_FAILED');
+            throw error;
+        }
+        if (taskId)
+            try {
+                if (this.d.ledger.deliveryFor(taskId)?.state === 'reserved')
+                    this.d.ledger.updateDelivery(taskId, 'enqueued');
+            }
+            catch {
+                this.d.warn('FOLLOWUP_ACCEPTED_COMMIT_FAILED');
+            }
+    }
+    /** Only called after the existing cancel authorization has identified the original task. */
+    async withdraw(taskId, controller, resolve) {
+        const record = this.d.ledger.deliveryFor(taskId);
+        if (!record)
+            return 'legacy';
+        if (record.state === 'cancelled')
+            return 'removed';
+        if (record.state === 'claimed')
+            return 'claimed';
+        if (typeof controller?.updateQueue !== 'function')
+            throw Error('SessionController.updateQueue unavailable; queued cancellation refused');
+        try {
+            await controller.updateQueue({ sessionId: SessionId(record.sessionId), itemId: MessageId(record.messageId), action: { kind: 'remove' } });
+            this.d.ledger.updateDelivery(taskId, 'cancelled');
+            return 'removed';
+        }
+        catch (error) {
+            const code = error?.code;
+            if (code === 'session/queue-item-not-found') {
+                this.d.ledger.updateDelivery(taskId, 'claimed');
+                return 'claimed';
+            }
+            throw error;
+        }
+    }
+    claimed(agent, messageId) {
+        // Called by the owned event boundary; failure must not exit the host.
+        try {
+            const record = this.d.ledger.deliveryByMessage(String(agent.id), messageId);
+            if (record && record.state !== 'cancelled') {
+                this.d.ledger.updateDelivery(record.taskId, 'claimed');
+            }
+        }
+        catch {
+            this.d.warn('FOLLOWUP_CLAIM_COMMIT_FAILED');
+        }
+    }
+}

package/lib/idempotency-store.js

@@ -167,6 +167,14 @@ export class IdempotencyStore {
      * Unknown or already-settled ids answer `false`. Never throws.
      * @returns whether the outcome was recorded.
      */
+    /** Release only an unchanged, uncompleted receipt attempt whose settlement did not commit. */
+    releaseUncompleted(taskId, fingerprint) {
+        const row = this.rows.get(taskId);
+        if (row?.fingerprint !== fingerprint || row.outcome !== undefined)
+            return;
+        this.rows.delete(taskId);
+        this.persist();
+    }
     recordOutcome(taskId, outcome, settledAt = this.now()) {
         if (taskId === '')
             return false;

package/lib/inbound-verification.js

@@ -0,0 +1,23 @@
+import { ORIGIN_CLAIM_VERIFY_MS } from "./origin-claim.js";
+export const WIRE_ERROR_INBOUND_VERIFICATION = -32011;
+export function hasOriginClaimFields(req) {
+    return Object.keys(req.headers).some(name => name.toLowerCase().startsWith('x-a2a-caller') || name.toLowerCase() === 'x-a2a-body-sha256');
+}
+export async function completeInboundVerification(work, timeoutMs = ORIGIN_CLAIM_VERIFY_MS) {
+    let timer;
+    const deadline = Date.now() + timeoutMs;
+    try {
+        const expired = new Promise(resolve => { timer = setTimeout(() => resolve({ ok: false, reason: 'verification-timeout' }), timeoutMs); });
+        const result = await Promise.race([Promise.resolve().then(work).catch(() => ({ ok: false, reason: 'no-card' })), expired]);
+        return Date.now() >= deadline ? { ok: false, reason: 'verification-timeout' } : result;
+    }
+    finally {
+        if (timer !== undefined)
+            clearTimeout(timer);
+    }
+}
+export function verifiedInboundAdmission(claim, present, requireBound, admit) {
+    if (present && (!claim.ok || (requireBound && !claim.bound)))
+        return { ok: false, reason: claim.ok ? 'bound-verification-required' : claim.reason === 'absent' ? 'incomplete-verification' : claim.reason };
+    return { ok: true, admission: admit(claim.ok ? claim.card.publicKey : undefined) };
+}