@amaster.ai/dsh-a2a 0.1.14 → 0.1.16

package/README.md

@@ -70,11 +70,13 @@ Disabled by default. Configure via the profile's `cordis.patch.yml`:
 
 ## Task stores
 
-A2A **task state** (status + metadata) is separate from conversation history — use [dsh-storage](../dsh-storage) for the latter. Every backend persists a sanitized metadata shell (history/artifacts stripped) and saves only on task-state transitions, so token-rate stream events never reach the backend.
+A2A task snapshots retain protocol history and artifacts; [dsh-storage](../dsh-storage) separately records the full conversation. Backends save on task-state transitions, including the complete reply at `input-required`, so token-rate stream events never reach Redis or GCS. While a task is working, in-process history accumulates text deltas for `GetTask` and resubscription; a restart before the next state change can lose those transient deltas.
 
 - `memory` (default) — in-process, lost on restart
-- `redis` — task JSON under `<keyPrefix>:tasks:<taskId>` with a TTL; requires the `ioredis` peer
-- `gcs` — gzipped task JSON at `<prefix>/<taskId>/metadata.json.gz` (same layout as the source project's `GCSTaskStore`); requires the `@google-cloud/storage` peer. `archiveWorkspace()` (tar of the workspace) exists but is not wired to the lifecycle yet.
+- `redis` — task JSON under `<keyPrefix>:tasks:<scope>:<taskId>` with a TTL; requires the `ioredis` peer
+- `gcs` — gzipped task JSON at `<prefix>/<scope>/<taskId>/metadata.json.gz`; requires the `@google-cloud/storage` peer. `archiveWorkspace()` (tar of the workspace) exists but is not wired to the lifecycle yet.
+
+`<scope>` is a hash of the A2A tenant and user. Older unscoped Redis/GCS task records are not read after this upgrade; migrate known records into their scope or let them expire before rollout.
 
 ## Security
 
@@ -82,7 +84,7 @@ dsh ships **no authentication or authorization**. The server binds `127.0.0.1` b
 
 ## 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,attachment}@0.1.7-rc.2` — the attachment store is an optional peer) — 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.2.0-rc.1` — the attachment store is an optional peer) — check the `TODO(verify)` markers in `src/` before upgrading dsh.
 
 ## License
 

package/lib/index.js

@@ -55,8 +55,8 @@ export const Config = Schema.object({
         publicUrl: Schema.string().default(''),
     }),
     /**
-     * A2A task state store (task metadata only — conversation history is
-     * dsh-storage's ai_messages, not this). 'memory' loses tasks on restart.
+     * A2A task snapshots, including protocol history. dsh-storage separately
+     * owns the full conversation log. 'memory' loses tasks on restart.
      */
     taskStore: Schema.union([
         Schema.const('memory'),

package/lib/server.js

@@ -70,10 +70,61 @@ export async function startA2aServer(options) {
             let task = taskBuses.get(taskId);
             if (!task) {
                 const broadcast = new DefaultExecutionEventBus();
-                task = { broadcast, requests: new Set() };
-                taskBuses.set(taskId, task);
+                const created = {
+                    broadcast,
+                    requests: new Set(),
+                    replay: [],
+                };
+                task = created;
+                taskBuses.set(taskId, created);
                 broadcast.on('event', (event) => {
+                    if (event.kind === 'task') {
+                        created.replay = [event];
+                    }
+                    else if (event.kind === 'statusUpdate') {
+                        const previous = created.replay.at(-1);
+                        const priorMessage = previous?.kind === 'statusUpdate' && previous.data.status?.message;
+                        const message = event.data.status?.message;
+                        const before = priorMessage ? priorMessage.parts[0]?.content : undefined;
+                        const delta = message?.parts[0]?.content;
+                        if (previous?.kind === 'statusUpdate' &&
+                            previous.data.status?.state === TaskState.TASK_STATE_WORKING &&
+                            event.data.status?.state === TaskState.TASK_STATE_WORKING &&
+                            priorMessage &&
+                            message &&
+                            priorMessage.messageId === message.messageId &&
+                            before?.$case === 'text' &&
+                            delta?.$case === 'text') {
+                            created.replay[created.replay.length - 1] = {
+                                ...event,
+                                data: {
+                                    ...event.data,
+                                    status: {
+                                        ...event.data.status,
+                                        message: {
+                                            ...message,
+                                            parts: [
+                                                {
+                                                    ...message.parts[0],
+                                                    content: { $case: 'text', value: before.value + delta.value },
+                                                },
+                                            ],
+                                        },
+                                    },
+                                },
+                            };
+                        }
+                        else
+                            created.replay.push(event);
+                    }
+                    else
+                        created.replay.push(event);
                     const state = event.kind === 'statusUpdate' ? event.data.status?.state : undefined;
+                    // Keep the settling event until the persisted snapshot catches up.
+                    if (state !== undefined &&
+                        state !== TaskState.TASK_STATE_WORKING &&
+                        state !== TaskState.TASK_STATE_SUBMITTED)
+                        created.replay = [event];
                     if (state !== undefined &&
                         [
                             TaskState.TASK_STATE_COMPLETED,
@@ -154,6 +205,99 @@ export async function startA2aServer(options) {
                 release?.();
             }
         }
+        async *resubscribe(...args) {
+            const task = taskBuses.get(args[0].id);
+            if (!task) {
+                yield* super.resubscribe(...args);
+                return;
+            }
+            const stream = super.resubscribe(...args);
+            try {
+                const replay = task.replay.slice();
+                const last = replay.at(-1);
+                const settledAtAttach = replay.length === 1 &&
+                    last?.kind === 'statusUpdate' &&
+                    last.data.status?.state !== TaskState.TASK_STATE_WORKING &&
+                    last.data.status?.state !== TaskState.TASK_STATE_SUBMITTED;
+                const during = [];
+                const record = (event) => during.push(event);
+                task.broadcast.on('event', record);
+                let first;
+                try {
+                    // The SDK attaches its live queue before awaiting the TaskStore load.
+                    first = await stream.next();
+                }
+                finally {
+                    task.broadcast.off('event', record);
+                }
+                if (first.done)
+                    return;
+                const payload = first.value.payload;
+                const queuedAnchor = during.find((event) => event.kind === 'task');
+                const anchor = queuedAnchor ?? replay.find((event) => event.kind === 'task');
+                const replayNeeded = (!settledAtAttach && !during.some((event) => event.kind === 'task')) ||
+                    (payload?.$case === 'task' &&
+                        payload.value.status?.state === TaskState.TASK_STATE_WORKING &&
+                        !during.some((event) => event.kind === 'task'));
+                const replayedIds = new Set((replayNeeded ? [...replay, ...during] : during).flatMap((event) => event.kind === 'statusUpdate' && event.data.status?.message
+                    ? [event.data.status.message.messageId]
+                    : []));
+                if (payload?.$case === 'task') {
+                    const initial = payload.value;
+                    const useAnchor = anchor?.kind === 'task' &&
+                        (initial.status?.state === TaskState.TASK_STATE_INPUT_REQUIRED ||
+                            (anchor.data.status?.timestamp &&
+                                initial.status?.timestamp &&
+                                Date.parse(anchor.data.status.timestamp) > Date.parse(initial.status.timestamp)));
+                    const history = initial.history?.filter((message) => !replayedIds.has(message.messageId)) ?? [];
+                    if (useAnchor && anchor.kind === 'task') {
+                        const ids = new Set(history.map((message) => message.messageId));
+                        for (const message of anchor.data.history ?? [])
+                            if (!ids.has(message.messageId))
+                                history.push(message);
+                    }
+                    yield {
+                        payload: {
+                            $case: 'task',
+                            value: {
+                                ...initial,
+                                history,
+                                status: useAnchor
+                                    ? anchor.data.status
+                                    : initial.status?.message && replayedIds.has(initial.status.message.messageId)
+                                        ? { ...initial.status, message: undefined }
+                                        : initial.status,
+                            },
+                        },
+                    };
+                }
+                else {
+                    yield first.value;
+                }
+                for (const event of replayNeeded ? replay : []) {
+                    if (event.kind === 'task')
+                        continue;
+                    if (event.kind === 'statusUpdate')
+                        yield { payload: { $case: 'statusUpdate', value: event.data } };
+                    else if (event.kind === 'artifactUpdate')
+                        yield { payload: { $case: 'artifactUpdate', value: event.data } };
+                }
+                let skipQueuedAnchor = Boolean(queuedAnchor);
+                for await (const value of stream) {
+                    if (skipQueuedAnchor &&
+                        queuedAnchor?.kind === 'task' &&
+                        value.payload?.$case === 'task' &&
+                        value.payload.value.status?.timestamp === queuedAnchor.data.status?.timestamp) {
+                        skipQueuedAnchor = false;
+                        continue;
+                    }
+                    yield value;
+                }
+            }
+            finally {
+                await stream.return(undefined);
+            }
+        }
     })(card, options.taskStore, options.executor, busManager);
     const app = express();
     // The SDK's jsonRpcHandler parses bodies with express.json()'s 100kb default;

package/lib/stores/gcs.js

@@ -2,9 +2,9 @@
  * GCS TaskStore for @a2a-js/sdk. `@google-cloud/storage` is an optional peer.
  *
  * Ported from the source project's packages/a2a-server/src/persistence/gcs.ts:
- *   tasks/{taskId}/metadata.json.gz  — gzipped task state (pre-sanitized by
- *                                      SanitizedTaskStore: no history)
- *   tasks/{taskId}/workspace.tar.gz  — tar of the task's workspace directory
+ *   tasks/{scope}/{taskId}/metadata.json.gz  — gzipped task snapshot (written on
+ *                                      state transitions)
+ *   tasks/{scope}/{taskId}/workspace.tar.gz  — tar of the task's workspace directory
  *
  * The workspace archive is written explicitly via `archiveWorkspace()` (not
  * wired to any lifecycle event yet — A2A tasks share one configured cwd, so a
@@ -18,7 +18,7 @@ import { join } from 'node:path';
 import { pipeline } from 'node:stream/promises';
 import { promisify } from 'node:util';
 import { gunzipSync, gzipSync } from 'node:zlib';
-import { listShells } from '../task-store.js';
+import { listShells, taskScopeKey } from '../task-store.js';
 export class GcsTaskStore {
     config;
     bucket = null;
@@ -32,39 +32,41 @@ export class GcsTaskStore {
         const storage = new mod.Storage(this.config.keyFilename ? { keyFilename: this.config.keyFilename } : undefined);
         this.bucket = storage.bucket(this.config.bucket);
     }
-    async save(task) {
+    async save(task, context) {
         if (!this.bucket)
             return;
         await this.bucket
-            .file(`${this.prefix}/${task.id}/metadata.json.gz`)
+            .file(`${this.prefix}/${taskScopeKey(context)}/${task.id}/metadata.json.gz`)
             .save(gzipSync(JSON.stringify(task)), { contentType: 'application/gzip', resumable: false });
     }
-    async load(taskId) {
+    async load(taskId, context) {
         if (!this.bucket)
             return undefined;
-        const file = this.bucket.file(`${this.prefix}/${taskId}/metadata.json.gz`);
+        const file = this.bucket.file(`${this.prefix}/${taskScopeKey(context)}/${taskId}/metadata.json.gz`);
         const [exists] = await file.exists();
         if (!exists)
             return undefined;
         const [buf] = await file.download();
         return JSON.parse(gunzipSync(buf).toString('utf8'));
     }
-    async delete(taskId) {
+    async delete(taskId, context) {
         if (!this.bucket)
             return;
         await Promise.all([
             this.bucket
-                .file(`${this.prefix}/${taskId}/metadata.json.gz`)
+                .file(`${this.prefix}/${taskScopeKey(context)}/${taskId}/metadata.json.gz`)
                 .delete({ ignoreNotFound: true }),
             this.bucket
-                .file(`${this.prefix}/${taskId}/workspace.tar.gz`)
+                .file(`${this.prefix}/${taskScopeKey(context)}/${taskId}/workspace.tar.gz`)
                 .delete({ ignoreNotFound: true }),
         ]);
     }
-    async list(params) {
+    async list(params, context) {
         if (!this.bucket)
             return { tasks: [], nextPageToken: '', pageSize: 0, totalSize: 0 };
-        const [files] = await this.bucket.getFiles({ prefix: `${this.prefix}/` });
+        const [files] = await this.bucket.getFiles({
+            prefix: `${this.prefix}/${taskScopeKey(context)}/`,
+        });
         const shells = [];
         for (const file of files) {
             if (!file.name.endsWith('/metadata.json.gz'))
@@ -75,18 +77,18 @@ export class GcsTaskStore {
         return listShells(shells, params);
     }
     /**
-     * Tar + gzip the workspace directory to `tasks/{taskId}/workspace.tar.gz`.
+     * Tar + gzip the workspace directory to `tasks/{scope}/{taskId}/workspace.tar.gz`.
      * TODO: replace the tar subprocess with a streaming tar library (e.g. `tar`)
      * to control inclusion and avoid shelling out.
      */
-    async archiveWorkspace(taskId, cwd) {
+    async archiveWorkspace(taskId, cwd, context) {
         if (!this.bucket)
             return;
         const dir = await mkdtemp(join(tmpdir(), 'dsh-a2a-archive-'));
         const tarball = join(dir, 'workspace.tar.gz');
         try {
             await promisify(execFile)('tar', ['-czf', tarball, '-C', cwd, '.']);
-            const dest = this.bucket.file(`${this.prefix}/${taskId}/workspace.tar.gz`);
+            const dest = this.bucket.file(`${this.prefix}/${taskScopeKey(context)}/${taskId}/workspace.tar.gz`);
             await pipeline(createReadStream(tarball), dest.createWriteStream());
         }
         finally {

package/lib/stores/redis.js

@@ -2,11 +2,11 @@
  * Redis TaskStore for @a2a-js/sdk. `ioredis` is an optional peer dependency.
  *
  * Ported from the source project's packages/a2a-server/src/persistence/redis.ts:
- * task state JSON under `a2a:tasks:{taskId}` with a TTL. Tasks arrive
- * pre-sanitized (metadata shell, no history) from SanitizedTaskStore —
- * conversation history is dsh-storage's job (ai_messages), not this store's.
+ * task state JSON under `a2a:tasks:{scope}:{taskId}` with a TTL. Task
+ * snapshots arrive from SanitizedTaskStore at state transitions;
+ * dsh-storage separately owns the full conversation log (ai_messages).
  */
-import { listShells } from '../task-store.js';
+import { listShells, taskScopeKey } from '../task-store.js';
 export class RedisTaskStore {
     config;
     redis = null;
@@ -21,31 +21,31 @@ export class RedisTaskStore {
         const mod = await import('ioredis');
         this.redis = new mod.Redis(this.config.url);
     }
-    taskKey(taskId) {
-        return `${this.prefix}:tasks:${taskId}`;
+    taskKey(taskId, context) {
+        return `${this.prefix}:tasks:${taskScopeKey(context)}:${taskId}`;
     }
-    async save(task) {
+    async save(task, context) {
         if (!this.redis)
             return;
-        await this.redis.set(this.taskKey(task.id), JSON.stringify(task), 'EX', this.ttl);
+        await this.redis.set(this.taskKey(task.id, context), JSON.stringify(task), 'EX', this.ttl);
     }
-    async load(taskId) {
+    async load(taskId, context) {
         if (!this.redis)
             return undefined;
-        const raw = await this.redis.get(this.taskKey(taskId));
+        const raw = await this.redis.get(this.taskKey(taskId, context));
         return raw ? JSON.parse(raw) : undefined;
     }
-    async delete(taskId) {
-        await this.redis?.del(this.taskKey(taskId));
+    async delete(taskId, context) {
+        await this.redis?.del(this.taskKey(taskId, context));
     }
-    async list(params) {
+    async list(params, context) {
         if (!this.redis)
             return { tasks: [], nextPageToken: '', pageSize: 0, totalSize: 0 };
         // Task shells are few and TTL-bound — a paged SCAN over the prefix is ample.
         const shells = [];
         let cursor = '0';
         do {
-            const [next, keys] = await this.redis.scan(cursor, 'MATCH', `${this.prefix}:tasks:*`, 'COUNT', 100);
+            const [next, keys] = await this.redis.scan(cursor, 'MATCH', `${this.prefix}:tasks:${taskScopeKey(context)}:*`, 'COUNT', 100);
             cursor = next;
             for (const key of keys) {
                 const raw = await this.redis.get(key);

package/lib/task-store.js

@@ -5,28 +5,32 @@
  * event — including each streamed text delta — and folds status messages into
  * `task.history`. Two constraints follow from this plugin's design:
  *
- * 1. A2A stores carry task STATE only (task metadata ≠ conversation history —
- *    history is dsh-storage's `ai_messages`). {@link sanitizeTask} strips
- *    `history`/`artifacts` before anything reaches a backend.
+ * 1. A2A task history is a protocol snapshot, separate from dsh-storage's
+ *    conversation log. Persist it at state changes so tasks survive restart.
  * 2. Token-rate saves would hammer Redis and put a GCS upload in the hot path
  *    of the SSE stream (ResultManager awaits every save). {@link
  *    SanitizedTaskStore} collapses saves to task-state CHANGES, which are the
- *    only transitions a `tasks/get` reader can act on anyway.
+ *    durable checkpoints; active deltas remain available from this process.
  *
  * 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 { createHash } from 'node:crypto';
+import { TaskState } from '@a2a-js/sdk';
 import { resolveUserScope } from '@a2a-js/sdk/server';
-/** The persistent shape: a metadata shell with empty history/artifacts. */
+/** Omit an unfinished current message from a WORKING snapshot. */
 export function sanitizeTask(task) {
-    return {
-        id: task.id,
-        contextId: task.contextId,
-        status: task.status,
-        metadata: task.metadata,
-        history: [],
-        artifacts: [],
-    };
+    const current = task.status?.state === TaskState.TASK_STATE_WORKING && task.status.message?.messageId;
+    return current
+        ? { ...task, history: task.history.filter((message) => message.messageId !== current) }
+        : task;
+}
+function scopeOf(context) {
+    return JSON.stringify([context?.tenant ?? '', context ? resolveUserScope(context) : 'unknown']);
+}
+/** A safe path/key segment for the SDK's tenant and owner scope. */
+export function taskScopeKey(context) {
+    return createHash('sha256').update(scopeOf(context)).digest('hex');
 }
 /** The SDK memory store has no delete operation; keep the same shell contract. */
 export class MemoryTaskStore {
@@ -54,11 +58,12 @@ export class MemoryTaskStore {
         this.bucket(context).delete(taskId);
     }
 }
-/** Strips history/artifacts and saves only on task-state transitions. */
+/** Saves task snapshots on state transitions while keeping active deltas in process. */
 export class SanitizedTaskStore {
     inner;
     lastState = new Map();
     writes = new Map();
+    liveHistory = new Map();
     // ponytail: deleted ids stay tombstoned until plugin unload; use expiring ids if clear volume grows.
     deleted = new Set();
     constructor(inner) {
@@ -68,11 +73,13 @@ export class SanitizedTaskStore {
         await this.inner.init?.();
     }
     async close() {
+        this.liveHistory.clear();
         await this.inner.close?.();
     }
     /** Drop SDK saves that may arrive after a clear rejects an in-flight request. */
     suppress(taskId) {
         this.deleted.add(taskId);
+        this.liveHistory.delete(taskId);
     }
     async delete(taskId, context) {
         this.suppress(taskId);
@@ -84,17 +91,67 @@ export class SanitizedTaskStore {
     async save(task, context) {
         if (this.deleted.has(task.id))
             return;
+        const history = structuredClone(task.history ?? []);
+        const current = task.status?.message;
+        if (task.status?.state === TaskState.TASK_STATE_WORKING && current) {
+            const previous = this.liveHistory
+                .get(task.id)
+                ?.history.find((message) => message.messageId === current.messageId);
+            const index = history.findIndex((message) => message.messageId === current.messageId);
+            const before = previous?.parts[0]?.content;
+            const delta = current.parts[0]?.content;
+            if (index >= 0 && before?.$case === 'text' && delta?.$case === 'text') {
+                history[index] = {
+                    ...history[index],
+                    parts: [
+                        {
+                            ...history[index].parts[0],
+                            content: { $case: 'text', value: before.value + delta.value },
+                        },
+                    ],
+                };
+            }
+        }
+        if (task.status?.state === TaskState.TASK_STATE_INPUT_REQUIRED && task.status.message) {
+            const final = structuredClone(task.status.message);
+            const index = history.findIndex((message) => message.messageId === final.messageId);
+            if (index >= 0)
+                history[index] = final;
+            else
+                history.push(final);
+        }
+        this.liveHistory.set(task.id, {
+            scope: scopeOf(context),
+            history,
+        });
         const state = task.status?.state;
         if (state !== undefined && this.lastState.get(task.id) === state)
             return;
-        if (state !== undefined)
-            this.lastState.set(task.id, state);
-        const write = (this.writes.get(task.id) ?? Promise.resolve()).then(() => this.inner.save(sanitizeTask(task), context));
+        const write = (this.writes.get(task.id) ?? Promise.resolve()).then(() => this.inner.save(sanitizeTask({ ...task, history }), context));
         this.writes.set(task.id, write.catch(() => { }));
         await write;
+        if (state === TaskState.TASK_STATE_WORKING || state === TaskState.TASK_STATE_SUBMITTED) {
+            this.lastState.set(task.id, state);
+        }
+        else {
+            this.lastState.delete(task.id);
+            this.writes.delete(task.id);
+            this.liveHistory.delete(task.id);
+        }
     }
-    load(taskId, context) {
-        return this.inner.load(taskId, context);
+    async load(taskId, context) {
+        const task = await this.inner.load(taskId, context);
+        const live = this.liveHistory.get(taskId);
+        if (!task || live?.scope !== scopeOf(context))
+            return task;
+        const history = structuredClone(live.history);
+        const current = task.status?.message;
+        const message = current && history.find((entry) => entry.messageId === current.messageId);
+        return {
+            ...task,
+            history,
+            status: message && task.status ? { ...task.status, message } : task.status,
+        };
     }
     list(params, context) {
         return this.inner.list(params, context);

package/lib/translator.js

@@ -5,11 +5,11 @@
  * deliberately free of cordis/HTTP concerns so the mapping is unit-testable
  * without a harness. The mapping ports the source project's
  * `packages/a2a-server/src/agent/task.ts` event switch onto dsh's
- * `SessionEventMap` (verified against @deepseek-ai/dsh-session@0.1.7-rc.2),
+ * `SessionEventMap` (verified against @deepseek-ai/dsh-session@0.2.0-rc.1),
  * emitting the A2A 1.0 data model (@a2a-js/sdk 1.1.0). As of the V3 session
  * format the durable log carries no incremental chunks — live text/reasoning
  * deltas arrive as `agent/assistant-stream` chunk frames
- * (@deepseek-ai/dsh-agent@0.1.7-rc.2) through {@link handleStreamFrame}:
+ * (@deepseek-ai/dsh-agent@0.2.0-rc.1) through {@link handleStreamFrame}:
  *
  *   turn/start                         → statusUpdate(WORKING), ids rotate
  *   stream chunk (text-delta)          → statusUpdate(WORKING, text part),

package/lib/types/index.d.ts

@@ -108,8 +108,8 @@ export declare const Config: Schema<Schemastery.ObjectS<{
         publicUrl: Schema<string, string>;
     }>>;
     /**
-     * A2A task state store (task metadata only — conversation history is
-     * dsh-storage's ai_messages, not this). 'memory' loses tasks on restart.
+     * A2A task snapshots, including protocol history. dsh-storage separately
+     * owns the full conversation log. 'memory' loses tasks on restart.
      */
     taskStore: Schema<"memory" | "redis" | "gcs", "memory" | "redis" | "gcs">;
     redis: Schema<Schemastery.ObjectS<{
@@ -173,8 +173,8 @@ export declare const Config: Schema<Schemastery.ObjectS<{
         publicUrl: Schema<string, string>;
     }>>;
     /**
-     * A2A task state store (task metadata only — conversation history is
-     * dsh-storage's ai_messages, not this). 'memory' loses tasks on restart.
+     * A2A task snapshots, including protocol history. dsh-storage separately
+     * owns the full conversation log. 'memory' loses tasks on restart.
      */
     taskStore: Schema<"memory" | "redis" | "gcs", "memory" | "redis" | "gcs">;
     redis: Schema<Schemastery.ObjectS<{

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

@@ -2,19 +2,20 @@
  * GCS TaskStore for @a2a-js/sdk. `@google-cloud/storage` is an optional peer.
  *
  * Ported from the source project's packages/a2a-server/src/persistence/gcs.ts:
- *   tasks/{taskId}/metadata.json.gz  — gzipped task state (pre-sanitized by
- *                                      SanitizedTaskStore: no history)
- *   tasks/{taskId}/workspace.tar.gz  — tar of the task's workspace directory
+ *   tasks/{scope}/{taskId}/metadata.json.gz  — gzipped task snapshot (written on
+ *                                      state transitions)
+ *   tasks/{scope}/{taskId}/workspace.tar.gz  — tar of the task's workspace directory
  *
  * The workspace archive is written explicitly via `archiveWorkspace()` (not
  * wired to any lifecycle event yet — A2A tasks share one configured cwd, so a
  * per-task snapshot needs a per-task workspace story first).
  */
 import type { ListTasksRequest, ListTasksResponse, Task } from '@a2a-js/sdk';
+import type { ServerCallContext } 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). */
+    /** Object key prefix, default 'tasks'. */
     prefix?: string;
     /** Path to a service-account key file; omit to use ADC. */
     keyFilename?: string;
@@ -25,14 +26,14 @@ export declare class GcsTaskStore implements ManagedTaskStore {
     private prefix;
     constructor(config: GcsTaskStoreConfig);
     init(): Promise<void>;
-    save(task: Task): Promise<void>;
-    load(taskId: string): Promise<Task | undefined>;
-    delete(taskId: string): Promise<void>;
-    list(params: ListTasksRequest): Promise<ListTasksResponse>;
+    save(task: Task, context: ServerCallContext): Promise<void>;
+    load(taskId: string, context: ServerCallContext): Promise<Task | undefined>;
+    delete(taskId: string, context: ServerCallContext): Promise<void>;
+    list(params: ListTasksRequest, context: ServerCallContext): Promise<ListTasksResponse>;
     /**
-     * Tar + gzip the workspace directory to `tasks/{taskId}/workspace.tar.gz`.
+     * Tar + gzip the workspace directory to `tasks/{scope}/{taskId}/workspace.tar.gz`.
      * TODO: replace the tar subprocess with a streaming tar library (e.g. `tar`)
      * to control inclusion and avoid shelling out.
      */
-    archiveWorkspace(taskId: string, cwd: string): Promise<void>;
+    archiveWorkspace(taskId: string, cwd: string, context: ServerCallContext): Promise<void>;
 }

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

@@ -2,11 +2,12 @@
  * Redis TaskStore for @a2a-js/sdk. `ioredis` is an optional peer dependency.
  *
  * Ported from the source project's packages/a2a-server/src/persistence/redis.ts:
- * task state JSON under `a2a:tasks:{taskId}` with a TTL. Tasks arrive
- * pre-sanitized (metadata shell, no history) from SanitizedTaskStore —
- * conversation history is dsh-storage's job (ai_messages), not this store's.
+ * task state JSON under `a2a:tasks:{scope}:{taskId}` with a TTL. Task
+ * snapshots arrive from SanitizedTaskStore at state transitions;
+ * dsh-storage separately owns the full conversation log (ai_messages).
  */
 import type { ListTasksRequest, ListTasksResponse, Task } from '@a2a-js/sdk';
+import type { ServerCallContext } from '@a2a-js/sdk/server';
 import { type ManagedTaskStore } from '../task-store.js';
 export interface RedisTaskStoreConfig {
     url: string;
@@ -21,9 +22,9 @@ export declare class RedisTaskStore implements ManagedTaskStore {
     constructor(config: RedisTaskStoreConfig);
     init(): Promise<void>;
     private taskKey;
-    save(task: Task): Promise<void>;
-    load(taskId: string): Promise<Task | undefined>;
-    delete(taskId: string): Promise<void>;
-    list(params: ListTasksRequest): Promise<ListTasksResponse>;
+    save(task: Task, context: ServerCallContext): Promise<void>;
+    load(taskId: string, context: ServerCallContext): Promise<Task | undefined>;
+    delete(taskId: string, context: ServerCallContext): Promise<void>;
+    list(params: ListTasksRequest, context: ServerCallContext): Promise<ListTasksResponse>;
     close(): Promise<void>;
 }

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

@@ -5,20 +5,19 @@
  * event — including each streamed text delta — and folds status messages into
  * `task.history`. Two constraints follow from this plugin's design:
  *
- * 1. A2A stores carry task STATE only (task metadata ≠ conversation history —
- *    history is dsh-storage's `ai_messages`). {@link sanitizeTask} strips
- *    `history`/`artifacts` before anything reaches a backend.
+ * 1. A2A task history is a protocol snapshot, separate from dsh-storage's
+ *    conversation log. Persist it at state changes so tasks survive restart.
  * 2. Token-rate saves would hammer Redis and put a GCS upload in the hot path
  *    of the SSE stream (ResultManager awaits every save). {@link
  *    SanitizedTaskStore} collapses saves to task-state CHANGES, which are the
- *    only transitions a `tasks/get` reader can act on anyway.
+ *    durable checkpoints; active deltas remain available from this process.
  *
  * 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 type { ListTasksRequest, ListTasksResponse, Task } from '@a2a-js/sdk';
+import { type ListTasksRequest, type ListTasksResponse, type Task } from '@a2a-js/sdk';
 import { type ServerCallContext, type TaskStore } from '@a2a-js/sdk/server';
-/** The persistent shape: a metadata shell with empty history/artifacts. */
+/** Omit an unfinished current message from a WORKING snapshot. */
 export declare function sanitizeTask(task: Task): Task;
 /** TaskStore with the optional lifecycle our backends add. */
 export interface ManagedTaskStore extends TaskStore {
@@ -26,6 +25,8 @@ export interface ManagedTaskStore extends TaskStore {
     delete(taskId: string, context: ServerCallContext): Promise<void>;
     close?(): Promise<void>;
 }
+/** A safe path/key segment for the SDK's tenant and owner scope. */
+export declare function taskScopeKey(context: ServerCallContext): string;
 /** The SDK memory store has no delete operation; keep the same shell contract. */
 export declare class MemoryTaskStore implements ManagedTaskStore {
     private readonly scopes;
@@ -35,11 +36,12 @@ export declare class MemoryTaskStore implements ManagedTaskStore {
     list(params: ListTasksRequest, context: ServerCallContext): Promise<ListTasksResponse>;
     delete(taskId: string, context: ServerCallContext): Promise<void>;
 }
-/** Strips history/artifacts and saves only on task-state transitions. */
+/** Saves task snapshots on state transitions while keeping active deltas in process. */
 export declare class SanitizedTaskStore implements ManagedTaskStore {
     private readonly inner;
     private readonly lastState;
     private readonly writes;
+    private readonly liveHistory;
     private readonly deleted;
     constructor(inner: ManagedTaskStore);
     init(): Promise<void>;

package/lib/types/translator.d.ts

@@ -5,11 +5,11 @@
  * deliberately free of cordis/HTTP concerns so the mapping is unit-testable
  * without a harness. The mapping ports the source project's
  * `packages/a2a-server/src/agent/task.ts` event switch onto dsh's
- * `SessionEventMap` (verified against @deepseek-ai/dsh-session@0.1.7-rc.2),
+ * `SessionEventMap` (verified against @deepseek-ai/dsh-session@0.2.0-rc.1),
  * emitting the A2A 1.0 data model (@a2a-js/sdk 1.1.0). As of the V3 session
  * format the durable log carries no incremental chunks — live text/reasoning
  * deltas arrive as `agent/assistant-stream` chunk frames
- * (@deepseek-ai/dsh-agent@0.1.7-rc.2) through {@link handleStreamFrame}:
+ * (@deepseek-ai/dsh-agent@0.2.0-rc.1) through {@link handleStreamFrame}:
  *
  *   turn/start                         → statusUpdate(WORKING), ids rotate
  *   stream chunk (text-delta)          → statusUpdate(WORKING, text part),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amaster.ai/dsh-a2a",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "A2A protocol (JSON-RPC + SSE) server plugin for DeepSeek Harness: expose dsh agents as A2A agents.",
   "type": "module",
   "main": "lib/index.js",
@@ -38,11 +38,11 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-agent": ">=0.1.5-rc.1 || >=0.1.6-alpha.1 || >=0.1.7-alpha.1",
-    "@deepseek-ai/dsh-attachment": ">=0.1.5-rc.1 || >=0.1.6-alpha.1 || >=0.1.7-alpha.1",
-    "@deepseek-ai/dsh-llm": ">=0.1.5-rc.1 || >=0.1.6-alpha.1 || >=0.1.7-alpha.1",
-    "@deepseek-ai/dsh-session": ">=0.1.5-rc.1 || >=0.1.6-alpha.1 || >=0.1.7-alpha.1",
-    "@deepseek-ai/dsh-user-approval": ">=0.1.6-alpha.2 || >=0.1.7-alpha.1",
+    "@deepseek-ai/dsh-agent": ">=0.1.5-rc.1 || >=0.1.6-alpha.1 || >=0.1.7-alpha.1 || >=0.2.0-rc.1",
+    "@deepseek-ai/dsh-attachment": ">=0.1.5-rc.1 || >=0.1.6-alpha.1 || >=0.1.7-alpha.1 || >=0.2.0-rc.1",
+    "@deepseek-ai/dsh-llm": ">=0.1.5-rc.1 || >=0.1.6-alpha.1 || >=0.1.7-alpha.1 || >=0.2.0-rc.1",
+    "@deepseek-ai/dsh-session": ">=0.1.5-rc.1 || >=0.1.6-alpha.1 || >=0.1.7-alpha.1 || >=0.2.0-rc.1",
+    "@deepseek-ai/dsh-user-approval": ">=0.1.6-alpha.2 || >=0.1.7-alpha.1 || >=0.2.0-rc.1",
     "@google-cloud/storage": "^7.0.0",
     "ioredis": "^5.0.0"
   },
@@ -62,12 +62,12 @@
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.4",
-    "@deepseek-ai/dsh-agent": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-attachment": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-llm": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-session": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-session-projection": "0.1.7-rc.2",
-    "@deepseek-ai/dsh-user-approval": "0.1.7-rc.2",
+    "@deepseek-ai/dsh-agent": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-attachment": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-llm": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-session": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-session-projection": "0.2.0-rc.1",
+    "@deepseek-ai/dsh-user-approval": "0.2.0-rc.1",
     "@google-cloud/storage": "^7.0.0",
     "@types/express": "^4.17.21",
     "@types/node": "^22.0.0",