@amaster.ai/dsh-a2a 0.1.5 → 0.1.7

package/README.md

@@ -26,6 +26,7 @@ Disabled by default. Configure via the profile's `cordis.patch.yml`:
         port: 41241
         basePath: /a2a
         cwd: /srv/agent-workspaces
+        uploadsDir: ''         # file-part upload root; empty = <OS temp>/dsh-a2a-uploads/<date>
         agent:
           provider: ''       # dsh provider/model for A2A sessions; empty = profile default
           model: ''
@@ -49,17 +50,19 @@ Disabled by default. Configure via the profile's `cordis.patch.yml`:
 ## Endpoints
 
 - `GET /.well-known/agent-card.json` — agent card: A2A 1.0 shape for `A2A-Version: 1.0` clients, the 0.3 shape for headerless clients (the legacy `/.well-known/agent.json` path is served as an alias)
-- `POST <basePath>/` — JSON-RPC. v1 methods: `SendMessage` (blocking by default, `configuration.returnImmediately: true` returns after the first event), `SendStreamingMessage` (SSE), `GetTask`, `ListTasks` (filter + cursor pagination), `CancelTask`, `SubscribeToTask` (the current task is the first event; the bus stays alive while the task is interrupted, so interrupted tasks can be re-followed live). v0.3 spellings (`message/send`, `message/stream`, `tasks/get`, `tasks/cancel`, `tasks/resubscribe`) keep working through the compat layer.
+- `POST <basePath>/` — JSON-RPC. v1 methods: `SendMessage` (blocking by default, `configuration.returnImmediately: true` returns after the first event), `SendStreamingMessage` (SSE), `GetTask`, `ListTasks` (filter + cursor pagination), `CancelTask`, `SubscribeToTask` (the current task is the first event; the bus stays alive while the task is interrupted, so interrupted tasks can be re-followed live). v0.3 spellings (`message/send`, `message/stream`, `tasks/get`, `tasks/cancel`, `tasks/resubscribe`) keep working through the compat layer. Legacy `tasks/get` also accepts `contextId` without `id` on this path or root `/`, returning the latest stored task or `result: null` when absent.
 
 ## 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).
 - **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.
-- **Text-only boundary** for now: `SendMessage` rejects messages with non-text parts (file/url/data) with a failed task.
+- **Message parts beyond text.** File parts (inline bytes or a `url` — the plugin downloads those over http/https, bounded to 64 MiB and 30 s) use the composed attachment store (`ctx.attachments`, e.g. `@deepseek-ai/dsh-attachment-local`) unless a non-image materializer is configured: images reach vision-capable models natively, and stored files project to deterministic handle text with a read-only path when dsh can map one into the execution world. Without a store or materializer, files persist under the configured `uploadsDir` (default `<OS temp>/dsh-a2a-uploads/<date>/`, names sanitized cross-platform, collisions suffixed) and the prompt references them by absolute path inside a `<document>` tag. Ensure that directory is readable by the agent's tools. `data` parts become `<data>` JSON text. A turn never fails because a part kind is unsupported.
+- **Remote execution files.** A deployment can register `ctx.provide('a2aFileMaterializer', { materializeFile })`, using the exported `A2aFileMaterializer` type. The callback receives `{ contextId, bytes, filename, mediaType }` (with a sanitized basename) and returns `{ readablePath }`, a path readable by that context's file/shell tools. When configured, non-image FileParts use the materializer instead of `ctx.attachments.saveFile()`; the model receives the returned `<document path="...">`. Images keep the existing attachment handling. A failed callback yields a delivery note, never a host-path fallback. The deployment owns sandbox selection, upload, and lifetime; no E2B SDK is required by this plugin.
 - **No approval bridge**: dsh ships the mid-turn approval seam only as the optional `dsh-user-approval` package, which headless profiles do not compose, so tools that would ask are governed by the profile's own approval setup; the A2A side never enters a mid-turn `input-required`.
 - **One in-flight message per task** is the supported flow (send the next message after the turn-final event). dsh serializes queued follow-ups into successive turns, but concurrent requests share one event bus — a second in-flight request may resolve with the first turn's final event.
-- **Restart**: persisted task shells survive in Redis/GCS, but live agents do not — continuing after a restart starts a fresh session (a client-supplied `contextId` names it).
+- **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.
 
 ## Task stores
 
@@ -71,11 +74,11 @@ A2A **task state** (status + metadata) is separate from conversation history —
 
 ## Security
 
-dsh ships **no authentication or authorization**. The server binds `127.0.0.1` by default; if you expose it, put an authenticated reverse proxy in front and treat every agent as running with the host process's OS privileges.
+dsh ships **no authentication or authorization**. The server binds `127.0.0.1` by default; if you expose it, put an authenticated reverse proxy in front and treat every agent as running with the host process's OS privileges. File parts carrying a `url` are fetched server-side (http/https only, bounded) — another reason to keep the endpoint off untrusted networks.
 
 ## Compatibility
 
-Pinned dsh/cordis versions live in the [root compat matrix](../../README.md#compatibility). Event payloads ride pre-release dsh APIs (`@deepseek-ai/dsh-{agent,session,llm}@0.1.6-alpha.2`) — check the `TODO(verify)` markers in `src/` before upgrading dsh.
+Pinned dsh/cordis versions live in the [root compat matrix](../../README.md#compatibility). Event payloads ride pre-release dsh APIs (`@deepseek-ai/dsh-{agent,session,llm,attachment}@0.1.6-alpha.2` — the attachment store is an optional peer) — check the `TODO(verify)` markers in `src/` before upgrading dsh.
 
 ## License
 

package/lib/bridge.js

@@ -23,12 +23,16 @@ import { installModelSelection } from '@deepseek-ai/dsh-agent';
 // modules import packages that are not on npm yet (dsh-timeout, dsh-scope).
 import { createUserMessage } from '@deepseek-ai/dsh-llm/message';
 import { SessionId } from '@deepseek-ai/dsh-session/types';
+import { buildMessageContent, uploadsDir } from './content.js';
 import { SessionTranslator, terminalStatusUpdate } from './translator.js';
 export class A2aBridge {
     ctx;
     options;
     tasks = new Map(); // taskId → entry
     bySession = new Map(); // sessionId (== contextId) → entry
+    clearing = new Set();
+    creating = new Map();
+    executing = new Map();
     constructor(ctx, options) {
         this.ctx = ctx;
         this.options = options;
@@ -44,6 +48,25 @@ export class A2aBridge {
      * a new task id for `message/send` calls that omit `taskId`.
      */
     async ensureTask(taskId, contextId) {
+        const creation = this.ensureTaskInner(taskId, contextId);
+        let pending = this.creating.get(contextId);
+        if (!pending) {
+            pending = new Set();
+            this.creating.set(contextId, pending);
+        }
+        pending.add(creation);
+        try {
+            return await creation;
+        }
+        finally {
+            pending.delete(creation);
+            if (pending.size === 0)
+                this.creating.delete(contextId);
+        }
+    }
+    async ensureTaskInner(taskId, contextId) {
+        if (this.clearing.has(contextId))
+            throw new Error('Context is being cleared.');
         const existing = this.tasks.get(taskId);
         if (existing)
             return { entry: existing, freshTask: false };
@@ -52,12 +75,12 @@ export class A2aBridge {
             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;
             this.tasks.set(taskId, forContext);
             return { entry: forContext, freshTask: true };
         }
-        // TODO(verify): resuming a persisted session (agents.resume) after a
-        // restart — needs dsh's sessionPersistence service composed. For now a
-        // client-supplied contextId simply names the fresh session.
         const sessionId = SessionId(contextId);
         const selection = this.resolveSelection();
         // The web profile disables the host-plane tool plugins — agents get tools
@@ -70,32 +93,40 @@ export class A2aBridge {
         if (presets) {
             agentPreset = (await presets.resolve(this.options.preset || undefined)).id;
         }
-        const handle = await this.ctx.agents.create({
-            sessionId,
-            meta: { cwd: this.options.cwd, ...(agentPreset ? { agentPreset } : {}) },
-            agentOptions: selection
-                ? { provider: selection.provider, model: selection.model }
-                : undefined,
-            // The loop's `{{model}}` prompt variable and request routing resolve from
-            // the agent's installed model selection (dsh-agent-loop's variables read
-            // agent.options; the scoped waterfalls wire provider/model into prompt
-            // assembly and the request config). Verified against
-            // @deepseek-ai/dsh-headless@0.1.6-alpha.2's run() — entry points are
-            // expected to resolve the deployment default themselves.
-            setup: selection || agentPreset
-                ? async (agentCtx) => {
-                    if (selection) {
-                        // Statement, deliberately not returned: a returned disposer would
-                        // be invoked as the setup commit and immediately unwired. Likewise
-                        // the mount result must not escape — setup's return value is
-                        // commit()-shaped to the factory.
-                        installModelSelection(agentCtx, { current: selection, assembled: undefined });
-                    }
-                    if (agentPreset)
-                        await presets.mount(agentCtx, agentPreset);
+        const agentOptions = selection
+            ? { provider: selection.provider, model: selection.model }
+            : undefined;
+        // The loop's `{{model}}` prompt variable and request routing resolve from
+        // the agent's installed model selection (dsh-agent-loop's variables read
+        // agent.options; the scoped waterfalls wire provider/model into prompt
+        // assembly and the request config). Verified against
+        // @deepseek-ai/dsh-headless@0.1.6-alpha.2's run() — entry points are
+        // expected to resolve the deployment default themselves.
+        const setup = selection || agentPreset
+            ? async (agentCtx) => {
+                if (selection) {
+                    // Statement, deliberately not returned: a returned disposer would
+                    // be invoked as the setup commit and immediately unwired. Likewise
+                    // the mount result must not escape — setup's return value is
+                    // commit()-shaped to the factory.
+                    installModelSelection(agentCtx, { current: selection, assembled: undefined });
                 }
-                : undefined,
-        });
+                if (agentPreset)
+                    await presets.mount(agentCtx, agentPreset);
+            }
+            : undefined;
+        // Persistence is optional in minimal compositions. A stat failure is not
+        // absence: let it fail instead of trying create() against an existing id.
+        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.create({
+                sessionId,
+                meta: { cwd: this.options.cwd, ...(agentPreset ? { agentPreset } : {}) },
+                agentOptions,
+                setup,
+            });
         const entry = {
             taskId,
             sessionId,
@@ -103,14 +134,55 @@ export class A2aBridge {
             translator: new SessionTranslator(taskId, contextId, this.options.agentOptions?.model),
             bus: null,
             turnActive: false,
+            staleTurn: false,
             settled: [],
+            running: new Set(),
         };
         this.tasks.set(taskId, entry);
         this.bySession.set(contextId, entry);
         return { entry, freshTask: true };
     }
+    /** A2A parts → dsh content blocks; throws only when no part is usable. */
+    async buildContent(message, contextId) {
+        const attachments = this.ctx.get('attachments');
+        const materializer = this.ctx.get('a2aFileMaterializer');
+        return buildMessageContent(message.parts, attachments, uploadsDir(this.options.uploadsDir), materializer ? { contextId, materializer } : undefined);
+    }
+    isClearing(contextId) {
+        return this.clearing.has(contextId);
+    }
+    /** Include content preparation in the work a context clear must drain. */
+    async trackExecution(contextId, run) {
+        const execution = run();
+        let pending = this.executing.get(contextId);
+        if (!pending) {
+            pending = new Set();
+            this.executing.set(contextId, pending);
+        }
+        pending.add(execution);
+        try {
+            await execution;
+        }
+        finally {
+            pending.delete(execution);
+            if (pending.size === 0)
+                this.executing.delete(contextId);
+        }
+    }
     /** Queue one user-message turn on the task's agent and await its `turn/end`. */
-    async runTurn(entry, text, bus) {
+    async runTurn(entry, content, bus) {
+        if (this.clearing.has(entry.sessionId))
+            throw new Error('Context is being cleared.');
+        const running = this.runTurnInner(entry, content, bus);
+        entry.running.add(running);
+        try {
+            await running;
+        }
+        finally {
+            entry.running.delete(running);
+        }
+    }
+    async runTurnInner(entry, content, bus) {
         let resolveSettled;
         const settled = new Promise((resolve) => {
             resolveSettled = resolve;
@@ -119,7 +191,7 @@ export class A2aBridge {
         entry.bus = bus;
         try {
             const result = entry.handle.agent.followup(createUserMessage({
-                content: [{ type: 'text', text }],
+                content,
                 source: { kind: 'user' },
             }));
             // followup() is typed void; guard a mistyped async impl anyway — an
@@ -150,6 +222,32 @@ export class A2aBridge {
                 entry.bus = null;
         }
     }
+    /** Cancel and release the live binding before the caller deletes stored shells. */
+    async clearContext(contextId, clearStored = async (ids) => ids) {
+        if (this.clearing.has(contextId))
+            throw new Error('Context is already being cleared.');
+        this.clearing.add(contextId);
+        try {
+            await Promise.allSettled([...(this.creating.get(contextId) ?? [])]);
+            const entry = this.bySession.get(contextId);
+            if (entry) {
+                if (entry.turnActive || entry.running.size > 0) {
+                    await entry.handle.agent.cancel({ kind: 'user' });
+                }
+                await entry.handle.agent.whenIdle();
+                this.settleEntry(entry, 'Context cleared.');
+                await Promise.allSettled([...entry.running]);
+                this.tasks.delete(entry.taskId);
+                this.bySession.delete(contextId);
+                await entry.handle.dispose();
+            }
+            await Promise.allSettled([...(this.executing.get(contextId) ?? [])]);
+            return await clearStored(entry ? [entry.taskId] : []);
+        }
+        finally {
+            this.clearing.delete(contextId);
+        }
+    }
     /** Abort the task's active turn; returns the contextId when the task is live. */
     cancel(taskId) {
         const entry = this.tasks.get(taskId);
@@ -181,12 +279,20 @@ export class A2aBridge {
             return;
         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 {
-            for (const out of entry.translator.handle(event))
-                entry.bus?.publish(out);
+            if (!stale)
+                for (const out of entry.translator.handle(event))
+                    entry.bus?.publish(out);
         }
         catch (error) {
             console.error('[dsh-a2a] failed to translate session event:', error);

package/lib/content.js

@@ -0,0 +1,244 @@
+/**
+ * Maps A2A message parts onto dsh content blocks. A turn never fails over
+ * part kinds:
+ *
+ *   - `text` parts stay text;
+ *   - file parts (inline `raw` bytes or a `url`) use the composed attachment
+ *     store unless a non-image materializer is configured; url parts are
+ *     downloaded by the plugin (http/https only, size- and time-bounded);
+ *   - an optional deployment materializer puts non-image files into the
+ *     active execution world instead of saving a host attachment;
+ *   - without a materializer, files with no store (or refused by a store)
+ *     persist under the configured upload root (default `<OS temp>/
+ *     dsh-a2a-uploads/<date>/`) and the prompt references them by path;
+ *   - `data` parts become JSON text.
+ *
+ * The SDK's admission helpers (admitEncodedFile/admitPromptContent) are not
+ * used: they take base64 wire uploads and throw on refusal — this path holds
+ * raw bytes and must degrade, never fail.
+ */
+import { mkdir, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+/** Cap on one url part download. */
+const MAX_DOWNLOAD_BYTES = 64 * 1024 * 1024;
+const DOWNLOAD_TIMEOUT_MS = 30_000;
+// TODO(verify): the confirmation data-part protocol ({callId, outcome}) maps
+// onto the optional dsh-user-approval service (0.1.2+, asks carry the exact
+// tool call) — bridge it once a deployment composes that service.
+export async function buildMessageContent(parts, attachments, dir, materialization) {
+    const content = [];
+    for (const part of parts) {
+        const c = part.content;
+        if (!c)
+            continue;
+        switch (c.$case) {
+            case 'text':
+                if (c.value.trim())
+                    content.push({ type: 'text', text: c.value });
+                break;
+            case 'data':
+                content.push({ type: 'text', text: dataText(c.value) });
+                break;
+            case 'raw':
+            case 'url':
+                content.push(await fileContent(c, part, attachments, dir, materialization));
+                break;
+            default:
+                // A part kind this SDK version predates: keep it visible, never drop.
+                content.push(note(part, part.mediaType, undefined, `unsupported part kind "${c.$case}"`));
+        }
+    }
+    if (content.length === 0) {
+        throw new Error('dsh-a2a: message must contain at least one usable part');
+    }
+    return content;
+}
+/** The directory file parts persist into when they are not attachments. */
+export function uploadsDir(root) {
+    // 'sv-SE' renders YYYY-MM-DD; the bucket is local time.
+    const segment = new Date().toLocaleDateString('sv-SE').replaceAll('-', '');
+    return path.join(root || path.join(os.tmpdir(), 'dsh-a2a-uploads'), segment);
+}
+/** Log and degrade one file-part failure to a metadata note. */
+function failNote(part, mediaType, uri, label, error) {
+    console.error(`[dsh-a2a] ${label}:`, error);
+    return note(part, mediaType, uri, error instanceof Error ? error.message : String(error));
+}
+/** Resolve one file part to an attachment block or a workspace file. */
+async function fileContent(c, part, attachments, dir, materialization) {
+    let bytes;
+    let mediaType = part.mediaType;
+    let uri;
+    try {
+        if (c.$case === 'url') {
+            uri = c.value;
+            const got = await download(uri);
+            bytes = got.bytes;
+            mediaType ||= got.mediaType ?? '';
+        }
+        else {
+            bytes = c.value;
+        }
+    }
+    catch (error) {
+        return failNote(part, mediaType, uri, 'failed to read a file part', error);
+    }
+    const image = attachments?.imageLimits.mediaTypes.includes(mediaType.toLowerCase());
+    if (attachments && (!materialization || image)) {
+        const block = await saveAttachment(attachments, bytes, mediaType, part.filename);
+        if (block)
+            return block;
+    }
+    if (materialization && !image) {
+        try {
+            const { readablePath } = await materialization.materializer.materializeFile({
+                contextId: materialization.contextId,
+                bytes,
+                filename: sanitizeUploadFileName(part.filename),
+                mediaType,
+            });
+            if (!readablePath)
+                throw new Error('materializer returned no readable path');
+            return documentBlock(uri, mediaType, bytes.byteLength, readablePath);
+        }
+        catch (error) {
+            console.error('[dsh-a2a] failed to materialize a file part:', error);
+            return note(part, mediaType, uri, 'file materialization failed');
+        }
+    }
+    try {
+        const name = sanitizeUploadFileName(part.filename);
+        const filePath = await persistUpload(dir, name, bytes);
+        return documentBlock(uri, mediaType, bytes.byteLength, filePath);
+    }
+    catch (error) {
+        return failNote(part, mediaType, uri, 'failed to persist a file part', error);
+    }
+}
+/** Commit part bytes to the store: image path first, verbatim file on refusal. */
+async function saveAttachment(attachments, bytes, mediaType, filename) {
+    const name = filename || undefined;
+    if (attachments.imageLimits.mediaTypes.includes(mediaType.toLowerCase())) {
+        try {
+            const attachment = await attachments.saveImage({
+                data: bytes,
+                mediaType: mediaType,
+                name,
+            });
+            return { type: 'image', attachment };
+        }
+        catch (error) {
+            console.error('[dsh-a2a] image admission failed; storing the bytes as a file:', error);
+        }
+    }
+    try {
+        const attachment = await attachments.saveFile({ data: bytes, name });
+        return { type: 'file', attachment };
+    }
+    catch (error) {
+        console.error('[dsh-a2a] failed to store an attachment:', error);
+        return undefined;
+    }
+}
+/** Save one upload under the upload dir; returns the absolute path. */
+async function persistUpload(dir, name, bytes) {
+    await mkdir(dir, { recursive: true });
+    const { name: stem, ext } = path.parse(name);
+    for (let attempt = 0;; attempt++) {
+        const candidate = path.join(dir, attempt === 0 ? name : `${stem}-${attempt}${ext}`);
+        try {
+            await writeFile(candidate, bytes, { flag: 'wx' });
+            return candidate;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+        }
+    }
+}
+// Windows refuses these device stems regardless of extension.
+const WINDOWS_RESERVED_STEMS = new Set('CON PRN AUX NUL COM1 COM2 COM3 COM4 COM5 COM6 COM7 COM8 COM9 LPT1 LPT2 LPT3 LPT4 LPT5 LPT6 LPT7 LPT8 LPT9'.split(' '));
+/**
+ * Cross-platform basename with control and Windows-illegal characters
+ * stripped; the trailing-dot/space strip also collapses '.' and '..'.
+ */
+function sanitizeUploadFileName(name) {
+    const cleaned = path.win32
+        .basename(name)
+        // biome-ignore lint/suspicious/noControlCharactersInRegex: stripping control chars is the point
+        .replace(/[<>:"|?*\x00-\x1f\x7f]/g, '')
+        .trim()
+        .replace(/[. ]+$/, '');
+    const stem = cleaned.split('.')[0].toUpperCase();
+    return !cleaned || WINDOWS_RESERVED_STEMS.has(stem) ? 'unnamed-file' : cleaned;
+}
+/** Tool-readable path stand-in for a file part. */
+function documentBlock(uri, mediaType, bytes, filePath) {
+    const attrs = [
+        // The basename of the final path, so name= always matches the file on
+        // disk — including collision suffixes.
+        `name="${attr(path.win32.basename(filePath))}"`,
+        uri && `uri="${attr(uri)}"`,
+        mediaType && `type="${attr(mediaType)}"`,
+        `size="${bytes}"`,
+        `path="${attr(filePath)}"`,
+    ]
+        .filter(Boolean)
+        .join(' ');
+    return {
+        type: 'text',
+        text: `<document ${attrs}>\nThe file is saved at the path above; read or process it with your tools.\n</document>`,
+    };
+}
+function note(part, mediaType, uri, reason) {
+    const desc = [
+        part.filename && `"${part.filename}"`,
+        mediaType && `(${mediaType})`,
+        uri && `at ${uri}`,
+    ]
+        .filter(Boolean)
+        .join(' ');
+    return { type: 'text', text: `[attachment ${desc || 'file'} not delivered: ${reason}]` };
+}
+/** JSON text stand-in for a structured data part. */
+function dataText(value) {
+    try {
+        return `<data>\n${JSON.stringify(value, null, 2) ?? String(value)}\n</data>`;
+    }
+    catch {
+        return `<data>\n${String(value)}\n</data>`;
+    }
+}
+/** Strip characters that would break attribute position. */
+function attr(value) {
+    return value.replace(/["\r\n<>]/g, ' ');
+}
+/** Fetch one url part's bytes over http(s), bounded in size and time. */
+async function download(uri) {
+    const scheme = new URL(uri).protocol;
+    if (scheme !== 'http:' && scheme !== 'https:') {
+        throw new Error(`unsupported scheme "${scheme}"`);
+    }
+    const response = await fetch(uri, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) });
+    if (!response.ok)
+        throw new Error(`HTTP ${response.status}`);
+    const declared = Number(response.headers.get('content-length'));
+    if (declared > MAX_DOWNLOAD_BYTES) {
+        throw new Error(`exceeds the ${MAX_DOWNLOAD_BYTES}-byte download limit`);
+    }
+    const chunks = [];
+    let total = 0;
+    if (response.body) {
+        // Throwing out of the loop cancels the stream via the iterator's return.
+        for await (const chunk of response.body) {
+            total += chunk.byteLength;
+            if (total > MAX_DOWNLOAD_BYTES) {
+                throw new Error(`exceeds the ${MAX_DOWNLOAD_BYTES}-byte download limit`);
+            }
+            chunks.push(chunk);
+        }
+    }
+    const mediaType = response.headers.get('content-type')?.split(';')[0].trim() || undefined;
+    return { bytes: Buffer.concat(chunks, total), mediaType };
+}

package/lib/executor.js

@@ -2,7 +2,8 @@
  * The @a2a-js/sdk {@link AgentExecutor} that drives dsh agents through the
  * bridge. One `execute()` = one user-message turn:
  *
- *   1. extract the text prompt (v1 is text-only)
+ *   1. map the message's parts onto dsh content blocks (file parts become
+ *      execution-world paths with a materializer, attachments or local files otherwise)
  *   2. ensure the task's session/agent exists (creating it on first contact)
  *   3. publish a `task` event first — A2A 1.0 stream ordering REQUIRES the
  *      first event of every execute to be a task or message, including
@@ -21,14 +22,22 @@ import { AgentEvent } from '@a2a-js/sdk/server';
 import { agentTextMessage, terminalStatusUpdate } from './translator.js';
 export class DshAgentExecutor {
     bridge;
-    constructor(bridge) {
+    suppressTask;
+    constructor(bridge, suppressTask) {
         this.bridge = bridge;
+        this.suppressTask = suppressTask;
     }
     async execute(requestContext, eventBus) {
+        if (this.bridge.isClearing(requestContext.contextId)) {
+            this.suppressTask?.(requestContext.taskId);
+        }
+        return this.bridge.trackExecution(requestContext.contextId, () => this.executeInner(requestContext, eventBus));
+    }
+    async executeInner(requestContext, eventBus) {
         const { userMessage, taskId, contextId } = requestContext;
         let anchored = false;
         try {
-            const text = extractText(userMessage);
+            const content = await this.bridge.buildContent(userMessage, contextId);
             const { entry, freshTask } = await this.bridge.ensureTask(taskId, contextId);
             eventBus.publish(freshTask
                 ? // First contact: the submitted anchor carries the user message
@@ -39,9 +48,11 @@ export class DshAgentExecutor {
                     // stored task (history/artifacts preserved).
                     taskEvent(taskId, contextId, TaskState.TASK_STATE_WORKING));
             anchored = true;
-            await this.bridge.runTurn(entry, text, eventBus);
+            await this.bridge.runTurn(entry, content, eventBus);
         }
         catch (error) {
+            if (this.bridge.isClearing(contextId))
+                this.suppressTask?.(taskId);
             const message = error instanceof Error ? error.message : String(error);
             if (!anchored) {
                 eventBus.publish(taskEvent(taskId, contextId, TaskState.TASK_STATE_FAILED, {
@@ -80,20 +91,3 @@ function taskEvent(taskId, contextId, state, extra = {}) {
     };
     return AgentEvent.task(task);
 }
-// TODO(verify): non-text parts (file/raw/url/data) — dsh supports image
-// content blocks; map them when a client needs it. The confirmation data-part
-// protocol ({callId, outcome}) maps onto the optional dsh-user-approval
-// service (0.1.2+, asks carry the exact tool call) — bridge it once a
-// deployment composes that service.
-function extractText(message) {
-    const nonText = message.parts.filter((part) => part.content?.$case !== 'text');
-    if (nonText.length > 0) {
-        throw new Error(`dsh-a2a: unsupported part kind(s): ${nonText.map((part) => part.content?.$case ?? 'unknown').join(', ')} (text-only)`);
-    }
-    const text = message.parts
-        .map((part) => (part.content?.$case === 'text' ? part.content.value : ''))
-        .join('');
-    if (!text.trim())
-        throw new Error('dsh-a2a: message must contain at least one text part');
-    return text;
-}

package/lib/index.js

@@ -11,14 +11,15 @@
  *
  * @module dsh-a2a
  */
-import { InMemoryTaskStore } from '@a2a-js/sdk/server';
+import { TaskState } from '@a2a-js/sdk';
+import { ServerCallContext } from '@a2a-js/sdk/server';
 import Schema from '@deepseek-ai/schemastery';
 import { A2aBridge } from './bridge.js';
 import { DshAgentExecutor } from './executor.js';
 import { startA2aServer } from './server.js';
 import { GcsTaskStore } from './stores/gcs.js';
 import { RedisTaskStore } from './stores/redis.js';
-import { SanitizedTaskStore } from './task-store.js';
+import { MemoryTaskStore, SanitizedTaskStore } from './task-store.js';
 export const name = 'dsh-a2a';
 /** The bridge creates and owns agents through the registry service. */
 export const inject = ['agents'];
@@ -29,6 +30,11 @@ export const Config = Schema.object({
     basePath: Schema.string().default('/a2a'),
     /** Working directory for agents spawned by A2A tasks. Must be absolute. */
     cwd: Schema.string().default(process.cwd()),
+    /**
+     * Root directory file parts persist into when no attachment store is
+     * composed (date-layered below it). Empty = <OS temp>/dsh-a2a-uploads.
+     */
+    uploadsDir: Schema.string().default(''),
     agent: Schema.object({
         provider: Schema.string().default(''),
         model: Schema.string().default(''),
@@ -83,6 +89,7 @@ export function apply(ctx, config) {
     async function start() {
         const bridge = new A2aBridge(ctx, {
             cwd: config.cwd,
+            uploadsDir: config.uploadsDir || undefined,
             agentOptions: {
                 provider: config.agent.provider || undefined,
                 model: config.agent.model || undefined,
@@ -91,7 +98,32 @@ export function apply(ctx, config) {
         });
         const store = createTaskStore(config);
         await store.init?.();
-        const executor = new DshAgentExecutor(bridge);
+        ctx.provide('a2aTasks', {
+            async clearContext(contextId, tenant = '') {
+                const call = new ServerCallContext({ tenant });
+                return bridge.clearContext(contextId, async (liveIds) => {
+                    const ids = new Set(liveIds);
+                    let pageToken = '';
+                    do {
+                        const page = await store.list({
+                            tenant: '',
+                            contextId,
+                            pageSize: 100,
+                            pageToken,
+                            status: TaskState.TASK_STATE_UNSPECIFIED,
+                            statusTimestampAfter: undefined,
+                        }, call);
+                        for (const task of page.tasks)
+                            ids.add(task.id);
+                        pageToken = page.nextPageToken;
+                    } while (pageToken);
+                    for (const id of ids)
+                        await store.delete(id, call);
+                    return [...ids];
+                });
+            },
+        });
+        const executor = new DshAgentExecutor(bridge, (taskId) => store.suppress(taskId));
         const server = await startA2aServer({
             host: config.host,
             port: config.port,
@@ -125,6 +157,6 @@ function createTaskStore(config) {
             }
             return new SanitizedTaskStore(new GcsTaskStore(config.gcs));
         default:
-            return new SanitizedTaskStore(new InMemoryTaskStore());
+            return new SanitizedTaskStore(new MemoryTaskStore());
     }
 }

package/lib/server.js

@@ -12,9 +12,9 @@
  * the server and builds the card.
  */
 import { createServer } from 'node:http';
-import { A2A_PROTOCOL_VERSION, AGENT_CARD_PATH, } from '@a2a-js/sdk';
+import { A2A_PROTOCOL_VERSION, AGENT_CARD_PATH, TaskState, } from '@a2a-js/sdk';
 import { duplicateInterfacesForLegacy } from '@a2a-js/sdk/compat/v0_3';
-import { DefaultRequestHandler } from '@a2a-js/sdk/server';
+import { DefaultRequestHandler, ServerCallContext, } from '@a2a-js/sdk/server';
 import { agentCardHandler, jsonRpcHandler, UserBuilder } from '@a2a-js/sdk/server/express';
 import express from 'express';
 export async function startA2aServer(options) {
@@ -61,12 +61,61 @@ 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);
-    // dsh ships no authn/authz — the loopback default binding is the boundary.
-    app.use(base, jsonRpcHandler({
+    const contextLookup = async (req, res, next) => {
+        const body = req.body;
+        const params = body?.params;
+        if (body?.method !== 'tasks/get' ||
+            typeof params?.contextId !== 'string' ||
+            !params.contextId ||
+            params.id) {
+            next();
+            return;
+        }
+        try {
+            const contextId = params.contextId;
+            const tenant = typeof params.tenant === 'string' ? params.tenant : '';
+            const page = await options.taskStore.list({
+                tenant,
+                contextId,
+                pageSize: 1,
+                pageToken: '',
+                status: TaskState.TASK_STATE_UNSPECIFIED,
+                statusTimestampAfter: undefined,
+            }, new ServerCallContext({ tenant }));
+            const task = page.tasks[0];
+            if (!task) {
+                res.json({ jsonrpc: '2.0', id: body.id ?? null, result: null });
+                return;
+            }
+            const { contextId: _contextId, ...rest } = params;
+            req.body = { ...body, params: { ...rest, id: task.id } };
+            next(); // Let the SDK load and serialize the task on the v0.3 wire.
+        }
+        catch (error) {
+            console.error('[dsh-a2a] context task lookup failed:', error);
+            res.status(500).json({
+                jsonrpc: '2.0',
+                id: body.id ?? null,
+                error: { code: -32603, message: 'Task lookup failed' },
+            });
+        }
+    };
+    const rpcHandler = jsonRpcHandler({
         requestHandler,
         userBuilder: UserBuilder.noAuthentication,
         legacyCompat: { enabled: true },
-    }));
+    });
+    // dsh ships no authn/authz — the loopback default binding is the boundary.
+    if (base) {
+        app.post('/', (req, res, next) => {
+            const body = req.body;
+            if (body?.method === 'tasks/get' && body.params?.contextId && !body.params.id)
+                next();
+            else
+                res.sendStatus(404);
+        }, contextLookup, rpcHandler);
+    }
+    app.use(base, contextLookup, rpcHandler);
     const server = createServer(app);
     await new Promise((resolve, reject) => {
         server.once('error', reject);

package/lib/stores/gcs.js

@@ -49,6 +49,18 @@ export class GcsTaskStore {
         const [buf] = await file.download();
         return JSON.parse(gunzipSync(buf).toString('utf8'));
     }
+    async delete(taskId) {
+        if (!this.bucket)
+            return;
+        await Promise.all([
+            this.bucket
+                .file(`${this.prefix}/${taskId}/metadata.json.gz`)
+                .delete({ ignoreNotFound: true }),
+            this.bucket
+                .file(`${this.prefix}/${taskId}/workspace.tar.gz`)
+                .delete({ ignoreNotFound: true }),
+        ]);
+    }
     async list(params) {
         if (!this.bucket)
             return { tasks: [], nextPageToken: '', pageSize: 0, totalSize: 0 };

package/lib/stores/redis.js

@@ -35,6 +35,9 @@ export class RedisTaskStore {
         const raw = await this.redis.get(this.taskKey(taskId));
         return raw ? JSON.parse(raw) : undefined;
     }
+    async delete(taskId) {
+        await this.redis?.del(this.taskKey(taskId));
+    }
     async list(params) {
         if (!this.redis)
             return { tasks: [], nextPageToken: '', pageSize: 0, totalSize: 0 };

package/lib/task-store.js

@@ -16,6 +16,7 @@
  * A2A 1.0 added `list()` to the TaskStore contract; {@link listShells} holds
  * the shared filter/sort/paginate logic so the backends only enumerate shells.
  */
+import { resolveUserScope } from '@a2a-js/sdk/server';
 /** The persistent shape: a metadata shell with empty history/artifacts. */
 export function sanitizeTask(task) {
     return {
@@ -27,10 +28,39 @@ export function sanitizeTask(task) {
         artifacts: [],
     };
 }
+/** The SDK memory store has no delete operation; keep the same shell contract. */
+export class MemoryTaskStore {
+    scopes = new Map();
+    bucket(context) {
+        const scope = JSON.stringify([context.tenant ?? '', resolveUserScope(context)]);
+        let tasks = this.scopes.get(scope);
+        if (!tasks) {
+            tasks = new Map();
+            this.scopes.set(scope, tasks);
+        }
+        return tasks;
+    }
+    async save(task, context) {
+        this.bucket(context).set(task.id, structuredClone(task));
+    }
+    async load(taskId, context) {
+        const task = this.bucket(context).get(taskId);
+        return task && structuredClone(task);
+    }
+    async list(params, context) {
+        return listShells([...this.bucket(context).values()], params);
+    }
+    async delete(taskId, context) {
+        this.bucket(context).delete(taskId);
+    }
+}
 /** Strips history/artifacts and saves only on task-state transitions. */
 export class SanitizedTaskStore {
     inner;
     lastState = new Map();
+    writes = new Map();
+    // ponytail: deleted ids stay tombstoned until plugin unload; use expiring ids if clear volume grows.
+    deleted = new Set();
     constructor(inner) {
         this.inner = inner;
     }
@@ -40,13 +70,28 @@ export class SanitizedTaskStore {
     async close() {
         await this.inner.close?.();
     }
+    /** Drop SDK saves that may arrive after a clear rejects an in-flight request. */
+    suppress(taskId) {
+        this.deleted.add(taskId);
+    }
+    async delete(taskId, context) {
+        this.suppress(taskId);
+        await this.writes.get(taskId);
+        await this.inner.delete(taskId, context);
+        this.lastState.delete(taskId);
+        this.writes.delete(taskId);
+    }
     async save(task, context) {
+        if (this.deleted.has(task.id))
+            return;
         const state = task.status?.state;
         if (state !== undefined && this.lastState.get(task.id) === state)
             return;
         if (state !== undefined)
             this.lastState.set(task.id, state);
-        await this.inner.save(sanitizeTask(task), context);
+        const write = (this.writes.get(task.id) ?? Promise.resolve()).then(() => this.inner.save(sanitizeTask(task), context));
+        this.writes.set(task.id, write.catch(() => { }));
+        await write;
     }
     load(taskId, context) {
         return this.inner.load(taskId, context);

package/lib/types/bridge.d.ts

@@ -15,14 +15,18 @@
  * turn order). The final status-update is published before the waiter
  * resolves, so an execute() that returns always landed its events first.
  */
+import type { Message } from '@a2a-js/sdk';
 import 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';
 import { SessionId } from '@deepseek-ai/dsh-session/types';
 import { SessionTranslator } from './translator.js';
 export interface BridgeOptions {
     /** Absolute working directory for spawned agents. */
     cwd: string;
+    /** Upload root for persisted file parts; absent = the OS temp dir. */
+    uploadsDir?: string;
     /** Optional provider/model overrides for created agents. */
     agentOptions?: {
         provider?: string;
@@ -40,14 +44,21 @@ export interface TaskEntry {
     bus: ExecutionEventBus | null;
     /** Between turn/start and turn/end. */
     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(). */
     settled: Array<() => void>;
+    /** Active execute() calls that must finish before task shells are deleted. */
+    running: Set<Promise<void>>;
 }
 export declare class A2aBridge {
     private readonly ctx;
     private readonly options;
     private readonly tasks;
     private readonly bySession;
+    private readonly clearing;
+    private readonly creating;
+    private readonly executing;
     constructor(ctx: Context, options: BridgeOptions);
     /**
      * Resolve the live task entry, creating the session/agent when needed.
@@ -60,8 +71,17 @@ export declare class A2aBridge {
         entry: TaskEntry;
         freshTask: boolean;
     }>;
+    private ensureTaskInner;
+    /** A2A parts → dsh content blocks; throws only when no part is usable. */
+    buildContent(message: Message, contextId: string): Promise<ContentBlock[]>;
+    isClearing(contextId: string): boolean;
+    /** 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, text: string, bus: ExecutionEventBus): Promise<void>;
+    runTurn(entry: TaskEntry, content: ContentBlock[], bus: ExecutionEventBus): 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[]>;
     /** Abort the task's active turn; returns the contextId when the task is live. */
     cancel(taskId: string): string | undefined;
     /** Dispose every owned agent (plugin unload / server shutdown). */

package/lib/types/content.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Maps A2A message parts onto dsh content blocks. A turn never fails over
+ * part kinds:
+ *
+ *   - `text` parts stay text;
+ *   - file parts (inline `raw` bytes or a `url`) use the composed attachment
+ *     store unless a non-image materializer is configured; url parts are
+ *     downloaded by the plugin (http/https only, size- and time-bounded);
+ *   - an optional deployment materializer puts non-image files into the
+ *     active execution world instead of saving a host attachment;
+ *   - without a materializer, files with no store (or refused by a store)
+ *     persist under the configured upload root (default `<OS temp>/
+ *     dsh-a2a-uploads/<date>/`) and the prompt references them by path;
+ *   - `data` parts become JSON text.
+ *
+ * The SDK's admission helpers (admitEncodedFile/admitPromptContent) are not
+ * used: they take base64 wire uploads and throw on refusal — this path holds
+ * raw bytes and must degrade, never fail.
+ */
+import type { Part } from '@a2a-js/sdk';
+import type { AttachmentStore } from '@deepseek-ai/dsh-attachment';
+import type { ContentBlock } from '@deepseek-ai/dsh-llm/types';
+/** Deployment-owned writer for files read by an agent's active tools. */
+export interface A2aFileMaterializer {
+    materializeFile(input: {
+        contextId: string;
+        bytes: Uint8Array;
+        filename: string;
+        mediaType: string;
+    }): Promise<{
+        readablePath: string;
+    }>;
+}
+interface Materialization {
+    contextId: string;
+    materializer: A2aFileMaterializer;
+}
+export declare function buildMessageContent(parts: readonly Part[], attachments: AttachmentStore | undefined, dir: string, materialization?: Materialization): Promise<ContentBlock[]>;
+/** The directory file parts persist into when they are not attachments. */
+export declare function uploadsDir(root?: string): string;
+export {};

package/lib/types/executor.d.ts

@@ -2,7 +2,8 @@
  * The @a2a-js/sdk {@link AgentExecutor} that drives dsh agents through the
  * bridge. One `execute()` = one user-message turn:
  *
- *   1. extract the text prompt (v1 is text-only)
+ *   1. map the message's parts onto dsh content blocks (file parts become
+ *      execution-world paths with a materializer, attachments or local files otherwise)
  *   2. ensure the task's session/agent exists (creating it on first contact)
  *   3. publish a `task` event first — A2A 1.0 stream ordering REQUIRES the
  *      first event of every execute to be a task or message, including
@@ -20,7 +21,9 @@ import type { AgentExecutor, ExecutionEventBus, RequestContext } from '@a2a-js/s
 import type { A2aBridge } from './bridge.js';
 export declare class DshAgentExecutor implements AgentExecutor {
     private readonly bridge;
-    constructor(bridge: A2aBridge);
+    private readonly suppressTask?;
+    constructor(bridge: A2aBridge, suppressTask?: ((taskId: string) => void) | undefined);
     execute(requestContext: RequestContext, eventBus: ExecutionEventBus): Promise<void>;
+    private executeInner;
     cancelTask: (taskId: string, eventBus: ExecutionEventBus) => Promise<void>;
 }

package/lib/types/index.d.ts

@@ -13,6 +13,7 @@
  */
 import type { Context } from '@deepseek-ai/cordis';
 import Schema from '@deepseek-ai/schemastery';
+export type { A2aFileMaterializer } from './content.js';
 export declare const name = "dsh-a2a";
 /** The bridge creates and owns agents through the registry service. */
 export declare const inject: string[];
@@ -23,6 +24,11 @@ export declare const Config: Schema<Schemastery.ObjectS<{
     basePath: Schema<string, string>;
     /** Working directory for agents spawned by A2A tasks. Must be absolute. */
     cwd: Schema<string, string>;
+    /**
+     * Root directory file parts persist into when no attachment store is
+     * composed (date-layered below it). Empty = <OS temp>/dsh-a2a-uploads.
+     */
+    uploadsDir: Schema<string, string>;
     agent: Schema<Schemastery.ObjectS<{
         provider: Schema<string, string>;
         model: Schema<string, string>;
@@ -83,6 +89,11 @@ export declare const Config: Schema<Schemastery.ObjectS<{
     basePath: Schema<string, string>;
     /** Working directory for agents spawned by A2A tasks. Must be absolute. */
     cwd: Schema<string, string>;
+    /**
+     * Root directory file parts persist into when no attachment store is
+     * composed (date-layered below it). Empty = <OS temp>/dsh-a2a-uploads.
+     */
+    uploadsDir: Schema<string, string>;
     agent: Schema<Schemastery.ObjectS<{
         provider: Schema<string, string>;
         model: Schema<string, string>;
@@ -143,6 +154,7 @@ export interface A2aPluginConfig {
     port: number;
     basePath: string;
     cwd: string;
+    uploadsDir: string;
     agent: {
         provider: string;
         model: string;
@@ -166,6 +178,10 @@ export interface A2aPluginConfig {
         keyFilename: string;
     };
 }
+/** Same-process gateway contract for messages/clear. */
+export interface A2aTasks {
+    clearContext(contextId: string, tenant?: string): Promise<string[]>;
+}
 export declare function apply(ctx: Context, config: A2aPluginConfig): Promise<{
     port: number;
 }> | undefined;

package/lib/types/stores/gcs.d.ts

@@ -11,7 +11,7 @@
  * per-task snapshot needs a per-task workspace story first).
  */
 import type { ListTasksRequest, ListTasksResponse, Task } from '@a2a-js/sdk';
-import type { TaskStore } from '@a2a-js/sdk/server';
+import { type ManagedTaskStore } from '../task-store.js';
 export interface GcsTaskStoreConfig {
     bucket: string;
     /** Object key prefix, default 'tasks' (matches the source layout). */
@@ -19,7 +19,7 @@ export interface GcsTaskStoreConfig {
     /** Path to a service-account key file; omit to use ADC. */
     keyFilename?: string;
 }
-export declare class GcsTaskStore implements TaskStore {
+export declare class GcsTaskStore implements ManagedTaskStore {
     private config;
     private bucket;
     private prefix;
@@ -27,6 +27,7 @@ export declare class GcsTaskStore implements TaskStore {
     init(): Promise<void>;
     save(task: Task): Promise<void>;
     load(taskId: string): Promise<Task | undefined>;
+    delete(taskId: string): Promise<void>;
     list(params: ListTasksRequest): Promise<ListTasksResponse>;
     /**
      * Tar + gzip the workspace directory to `tasks/{taskId}/workspace.tar.gz`.

package/lib/types/stores/redis.d.ts

@@ -7,13 +7,13 @@
  * conversation history is dsh-storage's job (ai_messages), not this store's.
  */
 import type { ListTasksRequest, ListTasksResponse, Task } from '@a2a-js/sdk';
-import type { TaskStore } from '@a2a-js/sdk/server';
+import { type ManagedTaskStore } from '../task-store.js';
 export interface RedisTaskStoreConfig {
     url: string;
     keyPrefix?: string;
     ttlSeconds?: number;
 }
-export declare class RedisTaskStore implements TaskStore {
+export declare class RedisTaskStore implements ManagedTaskStore {
     private readonly config;
     private redis;
     private readonly prefix;
@@ -23,6 +23,7 @@ export declare class RedisTaskStore implements TaskStore {
     private taskKey;
     save(task: Task): Promise<void>;
     load(taskId: string): Promise<Task | undefined>;
+    delete(taskId: string): Promise<void>;
     list(params: ListTasksRequest): Promise<ListTasksResponse>;
     close(): Promise<void>;
 }

package/lib/types/task-store.d.ts

@@ -17,21 +17,36 @@
  * the shared filter/sort/paginate logic so the backends only enumerate shells.
  */
 import type { ListTasksRequest, ListTasksResponse, Task } from '@a2a-js/sdk';
-import type { ServerCallContext, TaskStore } from '@a2a-js/sdk/server';
+import { type ServerCallContext, type TaskStore } from '@a2a-js/sdk/server';
 /** The persistent shape: a metadata shell with empty history/artifacts. */
 export declare function sanitizeTask(task: Task): Task;
 /** TaskStore with the optional lifecycle our backends add. */
 export interface ManagedTaskStore extends TaskStore {
     init?(): Promise<void>;
+    delete(taskId: string, context: ServerCallContext): Promise<void>;
     close?(): Promise<void>;
 }
+/** The SDK memory store has no delete operation; keep the same shell contract. */
+export declare class MemoryTaskStore implements ManagedTaskStore {
+    private readonly scopes;
+    private bucket;
+    save(task: Task, context: ServerCallContext): Promise<void>;
+    load(taskId: string, context: ServerCallContext): Promise<Task | undefined>;
+    list(params: ListTasksRequest, context: ServerCallContext): Promise<ListTasksResponse>;
+    delete(taskId: string, context: ServerCallContext): Promise<void>;
+}
 /** Strips history/artifacts and saves only on task-state transitions. */
 export declare class SanitizedTaskStore implements ManagedTaskStore {
     private readonly inner;
     private readonly lastState;
+    private readonly writes;
+    private readonly deleted;
     constructor(inner: ManagedTaskStore);
     init(): Promise<void>;
     close(): Promise<void>;
+    /** Drop SDK saves that may arrive after a clear rejects an in-flight request. */
+    suppress(taskId: string): void;
+    delete(taskId: string, context: ServerCallContext): Promise<void>;
     save(task: Task, context: ServerCallContext): Promise<void>;
     load(taskId: string, context: ServerCallContext): Promise<Task | undefined>;
     list(params: ListTasksRequest, context: ServerCallContext): Promise<ListTasksResponse>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amaster.ai/dsh-a2a",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "A2A protocol (JSON-RPC + SSE) server plugin for DeepSeek Harness: expose dsh agents as A2A agents.",
   "type": "module",
   "main": "lib/index.js",
@@ -39,12 +39,16 @@
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-agent": ">=0.1.5-rc.1 || >=0.1.6-alpha.1",
+    "@deepseek-ai/dsh-attachment": ">=0.1.5-rc.1 || >=0.1.6-alpha.1",
     "@deepseek-ai/dsh-llm": ">=0.1.5-rc.1 || >=0.1.6-alpha.1",
     "@deepseek-ai/dsh-session": ">=0.1.5-rc.1 || >=0.1.6-alpha.1",
     "@google-cloud/storage": "^7.0.0",
     "ioredis": "^5.0.0"
   },
   "peerDependenciesMeta": {
+    "@deepseek-ai/dsh-attachment": {
+      "optional": true
+    },
     "@google-cloud/storage": {
       "optional": true
     },
@@ -55,6 +59,7 @@
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
     "@deepseek-ai/dsh-agent": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-attachment": "0.1.6-alpha.2",
     "@deepseek-ai/dsh-llm": "0.1.6-alpha.2",
     "@deepseek-ai/dsh-session": "0.1.6-alpha.2",
     "@google-cloud/storage": "^7.0.0",