@amaster.ai/dsh-a2a 0.1.0

package/lib/stores/gcs.js

@@ -0,0 +1,84 @@
+/**
+ * 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
+ *
+ * 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 { execFile } from 'node:child_process';
+import { createReadStream } from 'node:fs';
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+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';
+export class GcsTaskStore {
+    config;
+    bucket = null;
+    prefix;
+    constructor(config) {
+        this.config = config;
+        this.prefix = config.prefix ?? 'tasks';
+    }
+    async init() {
+        const mod = await import('@google-cloud/storage');
+        const storage = new mod.Storage(this.config.keyFilename ? { keyFilename: this.config.keyFilename } : undefined);
+        this.bucket = storage.bucket(this.config.bucket);
+    }
+    async save(task) {
+        if (!this.bucket)
+            return;
+        await this.bucket
+            .file(`${this.prefix}/${task.id}/metadata.json.gz`)
+            .save(gzipSync(JSON.stringify(task)), { contentType: 'application/gzip', resumable: false });
+    }
+    async load(taskId) {
+        if (!this.bucket)
+            return undefined;
+        const file = this.bucket.file(`${this.prefix}/${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 list(params) {
+        if (!this.bucket)
+            return { tasks: [], nextPageToken: '', pageSize: 0, totalSize: 0 };
+        const [files] = await this.bucket.getFiles({ prefix: `${this.prefix}/` });
+        const shells = [];
+        for (const file of files) {
+            if (!file.name.endsWith('/metadata.json.gz'))
+                continue;
+            const [buf] = await file.download();
+            shells.push(JSON.parse(gunzipSync(buf).toString('utf8')));
+        }
+        return listShells(shells, params);
+    }
+    /**
+     * Tar + gzip the workspace directory to `tasks/{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) {
+        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`);
+            await pipeline(createReadStream(tarball), dest.createWriteStream());
+        }
+        finally {
+            await rm(dir, { recursive: true, force: true });
+        }
+    }
+}

package/lib/stores/redis.js

@@ -0,0 +1,58 @@
+/**
+ * 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.
+ */
+import { listShells } from '../task-store.js';
+export class RedisTaskStore {
+    config;
+    redis = null;
+    prefix;
+    ttl;
+    constructor(config) {
+        this.config = config;
+        this.prefix = config.keyPrefix ?? 'a2a';
+        this.ttl = config.ttlSeconds ?? 86_400;
+    }
+    async init() {
+        const mod = await import('ioredis');
+        this.redis = new mod.Redis(this.config.url);
+    }
+    taskKey(taskId) {
+        return `${this.prefix}:tasks:${taskId}`;
+    }
+    async save(task) {
+        if (!this.redis)
+            return;
+        await this.redis.set(this.taskKey(task.id), JSON.stringify(task), 'EX', this.ttl);
+    }
+    async load(taskId) {
+        if (!this.redis)
+            return undefined;
+        const raw = await this.redis.get(this.taskKey(taskId));
+        return raw ? JSON.parse(raw) : undefined;
+    }
+    async list(params) {
+        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);
+            cursor = next;
+            for (const key of keys) {
+                const raw = await this.redis.get(key);
+                if (raw)
+                    shells.push(JSON.parse(raw));
+            }
+        } while (cursor !== '0');
+        return listShells(shells, params);
+    }
+    async close() {
+        await this.redis?.quit?.();
+    }
+}

package/lib/task-store.js

@@ -0,0 +1,111 @@
+/**
+ * TaskStore boundary for the SDK's DefaultRequestHandler.
+ *
+ * The SDK's ResultManager calls `taskStore.save()` on EVERY task/statusUpdate
+ * 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.
+ * 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.
+ *
+ * A2A 1.0 added `list()` to the TaskStore contract; {@link listShells} holds
+ * the shared filter/sort/paginate logic so the backends only enumerate shells.
+ */
+/** The persistent shape: a metadata shell with empty history/artifacts. */
+export function sanitizeTask(task) {
+    return {
+        id: task.id,
+        contextId: task.contextId,
+        status: task.status,
+        metadata: task.metadata,
+        history: [],
+        artifacts: [],
+    };
+}
+/** Strips history/artifacts and saves only on task-state transitions. */
+export class SanitizedTaskStore {
+    inner;
+    lastState = new Map();
+    constructor(inner) {
+        this.inner = inner;
+    }
+    async init() {
+        await this.inner.init?.();
+    }
+    async close() {
+        await this.inner.close?.();
+    }
+    async save(task, context) {
+        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);
+    }
+    load(taskId, context) {
+        return this.inner.load(taskId, context);
+    }
+    list(params, context) {
+        return this.inner.list(params, context);
+    }
+}
+/**
+ * Shared `listTasks` semantics for the backends: filter by contextId / status /
+ * statusTimestampAfter (strictly greater), newest status first, cursor-paginated
+ * (base64 "timestamp|id"; a well-formed but unknown cursor yields an empty page,
+ * a malformed token throws). Follows the SDK's InMemoryTaskStore.
+ */
+export function listShells(shells, params) {
+    const filtered = shells.filter((task) => {
+        if (params.contextId && task.contextId !== params.contextId)
+            return false;
+        if (params.status && task.status?.state !== params.status)
+            return false;
+        if (params.statusTimestampAfter) {
+            const timestamp = task.status?.timestamp;
+            // Strictly-greater mirrors the SDK's InMemoryTaskStore.
+            if (!timestamp || Date.parse(timestamp) <= Date.parse(params.statusTimestampAfter)) {
+                return false;
+            }
+        }
+        return true;
+    });
+    filtered.sort((a, b) => {
+        const at = a.status?.timestamp ?? '';
+        const bt = b.status?.timestamp ?? '';
+        return bt.localeCompare(at) || b.id.localeCompare(a.id);
+    });
+    const pageSize = Math.min(Math.max(params.pageSize ?? 50, 1), 100);
+    let start = 0;
+    if (params.pageToken) {
+        const decoded = Buffer.from(params.pageToken, 'base64').toString('utf8');
+        const sep = decoded.indexOf('|');
+        if (sep < 0)
+            throw new Error('invalid page token');
+        const timestamp = decoded.slice(0, sep);
+        const id = decoded.slice(sep + 1);
+        // A well-formed cursor pointing at nothing (expired/rotated) is an empty page.
+        const index = filtered.findIndex((task) => (task.status?.timestamp ?? '') === timestamp && task.id === id);
+        if (index >= 0)
+            start = index + 1;
+        else
+            return { tasks: [], nextPageToken: '', pageSize, totalSize: filtered.length };
+    }
+    const page = filtered.slice(start, start + pageSize);
+    const last = page.at(-1);
+    const hasMore = start + pageSize < filtered.length;
+    return {
+        tasks: page.map((task) => (params.includeArtifacts ? task : { ...task, artifacts: [] })),
+        nextPageToken: hasMore && last
+            ? Buffer.from(`${last.status?.timestamp ?? ''}|${last.id}`).toString('base64')
+            : '',
+        pageSize,
+        totalSize: filtered.length,
+    };
+}

package/lib/translator.js

@@ -0,0 +1,244 @@
+/**
+ * Pure translation layer: dsh session events → A2A protocol events.
+ *
+ * One {@link SessionTranslator} serves one A2A task (one dsh session). It is
+ * 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.0-rc.7),
+ * emitting the A2A 1.0 data model (@a2a-js/sdk 1.1.0):
+ *
+ *   turn/start                         → statusUpdate(WORKING), ids rotate
+ *   assistant/chunk (text-delta)       → statusUpdate(WORKING, text part),
+ *                                        reusing the turn's messageId so
+ *                                        clients aggregate deltas into one message
+ *   assistant/chunk (reasoning-delta)  → statusUpdate(WORKING, thought metadata)
+ *   assistant/message                  → no event; text + usage captured for the
+ *                                        turn-final message (blocking `SendMessage`
+ *                                        clients read the answer from the final
+ *                                        task status, not from streamed deltas)
+ *   tool/call                          → statusUpdate(WORKING, data part)
+ *   tool/result                        → statusUpdate(WORKING, data part)
+ *   turn/end completed | max-tokens    → statusUpdate(INPUT_REQUIRED) — the task
+ *                                        is a conversation and stays continuable
+ *                                        (COMPLETED is terminal in A2A and the SDK
+ *                                        refuses follow-ups to terminal tasks)
+ *   turn/end aborted                   → statusUpdate(CANCELED)
+ *   turn/end blocked | error           → statusUpdate(FAILED)
+ *   everything else                    → no event
+ *
+ * A2A 1.0 removed the `final` flag: the SDK's event queue stops on terminal
+ * and interrupted (input-required) states, which is exactly the set above.
+ *
+ * dsh rc.7 has no approval/`input-required` mid-turn seam (the unpublished
+ * dsh-user-approval package is not installed anywhere; `tools/pre-execute`'s
+ * `ask` degrades to deny without an approval service), so no approval bridge
+ * exists here. TODO(verify) when dsh ships one.
+ */
+import { randomUUID } from 'node:crypto';
+import { Role, TaskState } from '@a2a-js/sdk';
+import { AgentEvent } from '@a2a-js/sdk/server';
+/** One text part in the 1.0 wire model. */
+function textPart(text) {
+    return {
+        content: { $case: 'text', value: text },
+        metadata: undefined,
+        filename: '',
+        mediaType: 'text/plain',
+    };
+}
+/** One structured-data part in the 1.0 wire model. */
+function dataPart(data) {
+    return {
+        content: { $case: 'data', value: data },
+        metadata: undefined,
+        filename: '',
+        mediaType: 'application/json',
+    };
+}
+/** One agent-role text message — the single construction site for the plugin's message payloads. */
+export function agentTextMessage(taskId, contextId, text, messageId = randomUUID()) {
+    return {
+        messageId,
+        contextId,
+        taskId,
+        role: Role.ROLE_AGENT,
+        parts: [textPart(text)],
+        metadata: undefined,
+        extensions: [],
+        referenceTaskIds: [],
+    };
+}
+/** A terminal (stream-closing) statusUpdate — shared by the bridge's settle path and the executor's failure/cancel paths. */
+export function terminalStatusUpdate(taskId, contextId, state, text) {
+    return AgentEvent.statusUpdate({
+        taskId,
+        contextId,
+        status: {
+            state: state === 'canceled' ? TaskState.TASK_STATE_CANCELED : TaskState.TASK_STATE_FAILED,
+            message: agentTextMessage(taskId, contextId, text),
+            timestamp: new Date().toISOString(),
+        },
+        metadata: { dshAgent: { kind: 'state-change', reason: state } },
+    });
+}
+export class SessionTranslator {
+    taskId;
+    contextId;
+    model;
+    /** messageId shared by this turn's streamed text deltas (client-side aggregation key). */
+    textMessageId = randomUUID();
+    thoughtMessageId = randomUUID();
+    /** Authoritative turn text, assembled from `assistant/message` events. */
+    turnText = '';
+    /** Fallback turn text, accumulated from `text-delta` chunks. */
+    deltaText = '';
+    sawAssistantMessage = false;
+    usage;
+    /** callId → tool name, for naming `tool/result` payloads. */
+    toolNames = new Map();
+    constructor(taskId, contextId, model) {
+        this.taskId = taskId;
+        this.contextId = contextId;
+        this.model = model;
+    }
+    /** Translate one session event into zero or more A2A events. Never throws on unknown types. */
+    handle(event) {
+        switch (event.type) {
+            case 'turn/start': {
+                this.textMessageId = randomUUID();
+                this.thoughtMessageId = randomUUID();
+                this.turnText = '';
+                this.deltaText = '';
+                this.sawAssistantMessage = false;
+                this.usage = undefined;
+                return [this.status(TaskState.TASK_STATE_WORKING, { kind: 'state-change' })];
+            }
+            case 'assistant/chunk': {
+                const chunk = event.data.chunk;
+                if (chunk.type === 'text-delta') {
+                    this.deltaText += chunk.text;
+                    return [
+                        this.status(TaskState.TASK_STATE_WORKING, { kind: 'text-content' }, agentTextMessage(this.taskId, this.contextId, chunk.text, this.textMessageId)),
+                    ];
+                }
+                if (chunk.type === 'reasoning-delta') {
+                    return [
+                        this.status(TaskState.TASK_STATE_WORKING, { kind: 'thought' }, agentTextMessage(this.taskId, this.contextId, chunk.text, this.thoughtMessageId)),
+                    ];
+                }
+                return [];
+            }
+            case 'assistant/message': {
+                this.sawAssistantMessage = true;
+                for (const block of event.data.message.content) {
+                    if (block.type === 'text')
+                        this.turnText += block.text;
+                }
+                const usage = event.data.usage;
+                if (usage)
+                    this.usage = this.usage ? addUsage(this.usage, usage) : { ...usage };
+                return [];
+            }
+            case 'tool/call': {
+                const { callId, name, arguments: args } = event.data;
+                this.toolNames.set(callId, name);
+                return [
+                    this.status(TaskState.TASK_STATE_WORKING, { kind: 'tool-call' }, this.dataMessage({ callId, name, arguments: args })),
+                ];
+            }
+            case 'tool/result': {
+                const { message, error, meta } = event.data;
+                // ToolResultMessage.content is a single tool-result block.
+                const block = message.content[0];
+                const callId = block?.type === 'tool-result' ? block.toolCallId : undefined;
+                return [
+                    this.status(TaskState.TASK_STATE_WORKING, { kind: 'tool-result' }, this.dataMessage({
+                        callId,
+                        name: callId ? this.toolNames.get(callId) : undefined,
+                        result: block?.type === 'tool-result'
+                            ? flattenContent(block.content)
+                            : flattenContent(message.content),
+                        isError: (block?.type === 'tool-result' && block.isError === true) || error !== undefined,
+                        ...(error ? { error: `${error.name}: ${error.code}` } : {}),
+                        ...(meta !== undefined ? { meta } : {}),
+                    })),
+                ];
+            }
+            case 'turn/end': {
+                const final = this.turnEnd(event.data.reason);
+                return final ? [final] : [];
+            }
+            default:
+                return [];
+        }
+    }
+    turnEnd(reason) {
+        const text = this.sawAssistantMessage ? this.turnText : this.deltaText;
+        const finalMessage = text
+            ? agentTextMessage(this.taskId, this.contextId, text, this.textMessageId)
+            : undefined;
+        switch (reason.kind) {
+            case 'completed':
+            case 'max-tokens':
+                // The task stays continuable; the reason records which ceiling hit.
+                return this.status(TaskState.TASK_STATE_INPUT_REQUIRED, { kind: 'state-change', reason: reason.kind }, finalMessage);
+            case 'aborted':
+                return this.status(TaskState.TASK_STATE_CANCELED, { kind: 'state-change', reason: 'aborted' }, undefined);
+            case 'blocked':
+                return this.status(TaskState.TASK_STATE_FAILED, { kind: 'state-change', reason: 'blocked' }, undefined);
+            case 'error': {
+                const message = reason.error.message || 'Agent turn failed.';
+                return this.status(TaskState.TASK_STATE_FAILED, { kind: 'state-change', reason: 'error' }, agentTextMessage(this.taskId, this.contextId, message), message);
+            }
+            default:
+                // 'interrupted' closes crash-orphaned turns on reload; the live loop
+                // never emits it, and unknown merge extensions are ignored too.
+                return undefined;
+        }
+    }
+    status(state, dshAgent, message, error) {
+        const metadata = { dshAgent };
+        if (this.model)
+            metadata.model = this.model;
+        const terminal = state !== TaskState.TASK_STATE_WORKING;
+        if (terminal && this.usage)
+            metadata.usage = this.usage;
+        if (error)
+            metadata.error = error;
+        return AgentEvent.statusUpdate({
+            taskId: this.taskId,
+            contextId: this.contextId,
+            status: { state, message, timestamp: new Date().toISOString() },
+            metadata,
+        });
+    }
+    dataMessage(data) {
+        return {
+            messageId: randomUUID(),
+            contextId: this.contextId,
+            taskId: this.taskId,
+            role: Role.ROLE_AGENT,
+            parts: [dataPart(data)],
+            metadata: undefined,
+            extensions: [],
+            referenceTaskIds: [],
+        };
+    }
+}
+function addUsage(a, b) {
+    const sum = (x, y) => x === undefined && y === undefined ? undefined : (x ?? 0) + (y ?? 0);
+    return {
+        inputTokens: a.inputTokens + b.inputTokens,
+        outputTokens: a.outputTokens + b.outputTokens,
+        cacheReadTokens: sum(a.cacheReadTokens, b.cacheReadTokens),
+        cacheWriteTokens: sum(a.cacheWriteTokens, b.cacheWriteTokens),
+        reasoningTokens: sum(a.reasoningTokens, b.reasoningTokens),
+    };
+}
+/** Flatten tool-result content blocks to display text; non-text blocks serialize as JSON. */
+function flattenContent(content) {
+    return content
+        .map((block) => (block.type === 'text' ? block.text : JSON.stringify(block)))
+        .join('');
+}

package/lib/types/bridge.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Bridges A2A tasks to dsh agents.
+ *
+ * One A2A task maps to one dsh session/agent; the A2A `contextId` IS the dsh
+ * sessionId. The bridge owns every agent it creates (the consumer-handle
+ * pattern dsh's own ACP bridge uses) and routes the durable `session/event`
+ * stream through a per-task {@link SessionTranslator} onto the executing
+ * request's {@link ExecutionEventBus}.
+ *
+ * Turn settlement: `agent.followup()` is fire-and-forget, so callers await a
+ * FIFO waiter resolved by the session's next `turn/end` event (dsh's inbox
+ * serializes queued follow-ups into successive turns, so waiter order matches
+ * turn order). The final status-update is published before the waiter
+ * resolves, so an execute() that returns always landed its events first.
+ */
+import type { ExecutionEventBus } from '@a2a-js/sdk/server';
+import type { Context } from '@deepseek-ai/cordis';
+import type { AgentHandle } from '@deepseek-ai/dsh-agent';
+import { SessionId } from '@deepseek-ai/dsh-session/types';
+import { SessionTranslator } from './translator.js';
+export interface BridgeOptions {
+    /** Absolute working directory for spawned agents. */
+    cwd: string;
+    /** Optional provider/model overrides for created agents. */
+    agentOptions?: {
+        provider?: string;
+        model?: string;
+    };
+    /** Agent preset id; empty/absent = the deployment default (when a roster exists). */
+    preset?: string;
+}
+export interface TaskEntry {
+    taskId: string;
+    sessionId: SessionId;
+    handle: AgentHandle;
+    translator: SessionTranslator;
+    /** The in-flight execute()'s bus; null between turns. */
+    bus: ExecutionEventBus | null;
+    /** Between turn/start and turn/end. */
+    turnActive: boolean;
+    /** FIFO turn-end waiters, one per queued/running execute(). */
+    settled: Array<() => void>;
+}
+export declare class A2aBridge {
+    private readonly ctx;
+    private readonly options;
+    private readonly tasks;
+    private readonly bySession;
+    constructor(ctx: Context, options: BridgeOptions);
+    /**
+     * Resolve the live task entry, creating the session/agent when needed.
+     * `freshTask` tells the executor to anchor the SDK's ResultManager with an
+     * initial Task event (status-updates for a task id the store never saw are
+     * dropped by it). Rebinding by bare contextId counts as fresh: the SDK mints
+     * a new task id for `message/send` calls that omit `taskId`.
+     */
+    ensureTask(taskId: string, contextId: string): Promise<{
+        entry: TaskEntry;
+        freshTask: boolean;
+    }>;
+    /** Queue one user-message turn on the task's agent and await its `turn/end`. */
+    runTurn(entry: TaskEntry, text: string, bus: ExecutionEventBus): Promise<void>;
+    /** 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). */
+    dispose(): Promise<void>;
+    private onSessionEvent;
+    private onSessionDisposed;
+    /** Close an in-flight stream honestly and release every turn waiter. */
+    private settleEntry;
+    /**
+     * Config override wins per field; otherwise the deployment default read from
+     * the `agentDefaultModel` service (the entry-point contract — the loop
+     * itself does not apply it). Undefined when neither source has a pair
+     * (persona-less minimal compositions stay valid).
+     */
+    private resolveSelection;
+}

package/lib/types/executor.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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)
+ *   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
+ *      follow-up turns on a known task (the ResultManager merges it with the
+ *      stored task; fresh tasks get the submitted anchor carrying the user
+ *      message, continuing tasks get a working snapshot)
+ *   4. run the turn; session events stream onto the bus via the bridge
+ *   5. on failure publish a failed statusUpdate (plus a failed task anchor if
+ *      none went out yet) instead of rethrowing — clients get the terminal
+ *      state in band on both blocking and streaming paths
+ *
+ * `cancelTask` is an arrow property because the SDK destructures it.
+ */
+import type { AgentExecutor, ExecutionEventBus, RequestContext } from '@a2a-js/sdk/server';
+import type { A2aBridge } from './bridge.js';
+export declare class DshAgentExecutor implements AgentExecutor {
+    private readonly bridge;
+    constructor(bridge: A2aBridge);
+    execute(requestContext: RequestContext, eventBus: ExecutionEventBus): Promise<void>;
+    cancelTask: (taskId: string, eventBus: ExecutionEventBus) => Promise<void>;
+}