@aramisfa/openclaw-a2a-outbound 1.0.0 → 3.0.0

package/dist/service.js

@@ -1,9 +1,11 @@
+import { isDeepStrictEqual } from "node:util";
 import { UnsupportedOperationError } from "@a2a-js/sdk/client";
+import { evaluateSendCompatibility, } from "./capability-diagnostics.js";
 import { parseA2AOutboundPluginConfig, } from "./config.js";
 import { A2AOutboundError, ERROR_CODES, toToolError, } from "./errors.js";
 import { log, startSpan } from "./logging.js";
-import { cancelSuccess, listTargetsSuccess, remoteAgentFailure, sendStreamSuccess, sendSuccess, statusSuccess, streamUpdate, summarizeStreamEvent, watchSuccess, } from "./result-shape.js";
-import { buildRequestOptions, normalizePlainIntentRequest, } from "./request-normalization.js";
+import { cancelSuccess, listTargetsSuccess, remoteAgentFailure, sendStreamSuccess, sendSuccess, statusSuccess, streamUpdate, summarizeStreamEvents, watchSuccess, } from "./result-shape.js";
+import { buildRequestOptions, normalizeSendRequest, normalizeStrictTaskCreationSendRequest, } from "./request-normalization.js";
 import { createClientPool, } from "./sdk-client-pool.js";
 import { buildRemoteAgentToolDefinition, createRemoteAgentInputValidator, } from "./schemas.js";
 import { createTargetCatalog, } from "./target-catalog.js";
@@ -32,22 +34,59 @@ function targetSummary(target) {
         ...(target.alias !== undefined ? { alias: target.alias } : {}),
     };
 }
-function firstStreamTaskId(events) {
-    for (const event of events) {
-        switch (event.kind) {
-            case "message":
-                if (event.taskId !== undefined) {
-                    return event.taskId;
-                }
-                break;
-            case "task":
-                return event.id;
-            case "status-update":
-            case "artifact-update":
-                return event.taskId;
+function taskContextFromMessage(message) {
+    return {
+        ...(message.taskId !== undefined ? { taskId: message.taskId } : {}),
+        ...(message.contextId !== undefined ? { contextId: message.contextId } : {}),
+    };
+}
+function taskContextFromTask(task) {
+    return {
+        taskId: task.id,
+        ...(task.contextId !== undefined ? { contextId: task.contextId } : {}),
+    };
+}
+function taskContextFromStatusUpdate(event) {
+    return {
+        ...(event.taskId !== undefined ? { taskId: event.taskId } : {}),
+        ...(event.contextId !== undefined ? { contextId: event.contextId } : {}),
+    };
+}
+function taskContextFromArtifactUpdate(event) {
+    return {
+        ...(event.taskId !== undefined ? { taskId: event.taskId } : {}),
+        ...(event.contextId !== undefined ? { contextId: event.contextId } : {}),
+    };
+}
+function taskContextFromEvent(event) {
+    switch (event.kind) {
+        case "message":
+            return taskContextFromMessage(event);
+        case "task":
+            return taskContextFromTask(event);
+        case "status-update":
+            return taskContextFromStatusUpdate(event);
+        case "artifact-update":
+            return taskContextFromArtifactUpdate(event);
+    }
+}
+function mergeTaskContext(...contexts) {
+    const merged = {};
+    for (const context of contexts) {
+        if (!context) {
+            continue;
+        }
+        if (context.taskId !== undefined) {
+            merged.taskId = context.taskId;
+        }
+        if (context.contextId !== undefined) {
+            merged.contextId = context.contextId;
+        }
+        if (context.taskHandle !== undefined) {
+            merged.taskHandle = context.taskHandle;
         }
     }
-    return undefined;
+    return merged;
 }
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -90,12 +129,22 @@ function taskHandleTaskIdMismatchError(taskHandle, handleTaskId, explicitTaskId)
         explicit_task_id: explicitTaskId,
     });
 }
+function taskHandleContextIdMismatchError(taskHandle, handleContextId, explicitContextId) {
+    return new A2AOutboundError(ERROR_CODES.VALIDATION_ERROR, `task_handle "${taskHandle}" does not match context_id "${explicitContextId}"`, {
+        task_handle: taskHandle,
+        handle_context_id: handleContextId,
+        explicit_context_id: explicitContextId,
+    });
+}
 function missingTargetContextError(action) {
     const message = action === "send"
-        ? "send requires target_alias, target_url, or a configured default target"
+        ? "send requires task_handle, target_alias, target_url, or a configured default target"
         : `${action} requires task_handle, or task_id plus target_alias/target_url, or a configured default target`;
     return new A2AOutboundError(ERROR_CODES.VALIDATION_ERROR, message);
 }
+function conversationOnlyLifecycleContinuationError(action) {
+    return new A2AOutboundError(ERROR_CODES.VALIDATION_ERROR, `${action} requires task continuity; summary.continuation.conversation.context_id is send-only`);
+}
 function streamingNotSupportedError(target, taskId) {
     return new A2AOutboundError(ERROR_CODES.A2A_SDK_ERROR, `streaming updates are not available for task ${taskId}; retry with action=status`, {
         task_id: taskId,
@@ -107,11 +156,65 @@ function streamingNotSupportedError(target, taskId) {
         suggested_action: "status",
     });
 }
-async function consumeStream(stream, action, target, state, onUpdate) {
+function isTerminalTaskStatus(status) {
+    return (status === "completed" ||
+        status === "failed" ||
+        status === "canceled" ||
+        status === "rejected");
+}
+function isStrictTaskRequirement(input) {
+    return input.task_requirement === "required";
+}
+function taskRequiredButMessageReturnedError(message) {
+    return new A2AOutboundError(ERROR_CODES.TASK_REQUIRED_BUT_MESSAGE_RETURNED, 'task_requirement="required" expected a Task response, but the peer returned only a Message', {
+        ...(message.contextId !== undefined ? { context_id: message.contextId } : {}),
+        ...(message.messageId !== undefined ? { message_id: message.messageId } : {}),
+        response_kind: "message",
+    });
+}
+function taskSnapshotIdentity(task) {
+    return {
+        id: task.id,
+        ...(task.contextId !== undefined ? { contextId: task.contextId } : {}),
+        status: structuredClone(task.status),
+        ...(task.history !== undefined ? { history: structuredClone(task.history) } : {}),
+        ...(task.artifacts !== undefined
+            ? { artifacts: structuredClone(task.artifacts) }
+            : {}),
+    };
+}
+function equivalentTaskSnapshots(initialTask, event) {
+    return (event.kind === "task" &&
+        isDeepStrictEqual(taskSnapshotIdentity(initialTask), taskSnapshotIdentity(event)));
+}
+function withRecoverableStatusSuggestion(error, taskContext) {
+    return withErrorDetails(error, {
+        task_id: taskContext.taskId,
+        ...(taskContext.taskHandle !== undefined
+            ? { task_handle: taskContext.taskHandle }
+            : {}),
+        ...(taskContext.contextId !== undefined
+            ? { context_id: taskContext.contextId }
+            : {}),
+        suggested_action: "status",
+    });
+}
+function appendStreamEvent(action, target, state, event, onUpdate) {
+    state.events.push(event);
+    state.taskContext = mergeTaskContext(state.taskContext, taskContextFromEvent(event));
+    state.latestSummary = summarizeStreamEvents(target, state.events, state.taskContext);
+    onUpdate?.(streamUpdate(action, target, state.events, state.taskContext));
+}
+async function consumeStream(stream, action, target, state, onEvent, onUpdate, shouldSkipEvent) {
+    let index = 0;
     for await (const event of stream) {
-        state.events.push(event);
-        state.latestSummary = summarizeStreamEvent(target, event);
-        onUpdate?.(streamUpdate(action, target, event));
+        if (shouldSkipEvent?.(event, index)) {
+            index += 1;
+            continue;
+        }
+        index += 1;
+        onEvent?.(event);
+        appendStreamEvent(action, target, state, event, onUpdate);
     }
 }
 function requestedAction(input) {
@@ -142,7 +245,6 @@ export class A2AOutboundService {
                 createClientPool({
                     defaultCardPath: this.config.defaults.cardPath,
                     preferredTransports: this.config.defaults.preferredTransports,
-                    acceptedOutputModes: this.config.policy.acceptedOutputModes,
                     normalizeBaseUrl: this.config.policy.normalizeBaseUrl,
                     enforceSupportedTransports: this.config.policy.enforceSupportedTransports,
                 });
@@ -203,8 +305,19 @@ export class A2AOutboundService {
     }
     async resolveClient(target) {
         const clientEntry = await this.clientPool.get(target);
+        let resolvedTarget = target;
+        try {
+            const card = await clientEntry.client.getAgentCard();
+            resolvedTarget = this.targetCatalog.recordAgentCard(target, card);
+        }
+        catch (error) {
+            log(this.logger, "warn", "a2a.remote_agent.target_card.refresh_error", {
+                target,
+                error: toToolError(error, fallbackErrorCode(error)),
+            });
+        }
         return {
-            target,
+            target: resolvedTarget,
             clientEntry,
         };
     }
@@ -219,15 +332,83 @@ export class A2AOutboundService {
         }
         return undefined;
     }
-    async resolveSendTarget(input) {
-        const explicitTarget = this.resolveExplicitTarget(input);
-        const target = explicitTarget ?? this.targetCatalog.resolveDefaultTarget();
-        if (!target) {
-            throw missingTargetContextError("send");
-        }
-        return this.resolveClient(target);
+    resolveTrustedContinuationTarget(target) {
+        return this.clientPool.normalizeTarget({
+            baseUrl: target.target_url,
+            cardPath: target.card_path,
+            preferredTransports: target.preferred_transports,
+            ...(target.target_alias !== undefined
+                ? { alias: target.target_alias }
+                : {}),
+        });
     }
     async resolveTaskContext(input) {
+        if (input.continuation !== undefined) {
+            const continuationTarget = this.resolveTrustedContinuationTarget(input.continuation.target);
+            const continuationTask = input.continuation.task;
+            const continuationContextId = input.continuation.conversation?.context_id;
+            if (input.action !== "send" &&
+                continuationTask === undefined &&
+                continuationContextId !== undefined) {
+                throw conversationOnlyLifecycleContinuationError(input.action);
+            }
+            if (continuationTask?.task_handle !== undefined) {
+                try {
+                    const handleRecord = this.taskHandleRegistry.resolve(continuationTask.task_handle);
+                    if (continuationTask.task_id !== handleRecord.taskId) {
+                        throw taskHandleTaskIdMismatchError(continuationTask.task_handle, handleRecord.taskId, continuationTask.task_id);
+                    }
+                    if (targetIdentity(continuationTarget) !==
+                        targetIdentity(handleRecord.target)) {
+                        throw taskHandleTargetMismatchError(continuationTask.task_handle, handleRecord.target, continuationTarget);
+                    }
+                    if (continuationContextId !== undefined &&
+                        handleRecord.contextId !== undefined &&
+                        continuationContextId !== handleRecord.contextId) {
+                        throw taskHandleContextIdMismatchError(continuationTask.task_handle, handleRecord.contextId, continuationContextId);
+                    }
+                    const clientResolution = await this.resolveClient(handleRecord.target);
+                    return {
+                        target: clientResolution.target,
+                        clientEntry: clientResolution.clientEntry,
+                        taskId: handleRecord.taskId,
+                        ...(continuationContextId !== undefined
+                            ? { contextId: continuationContextId }
+                            : handleRecord.contextId !== undefined
+                                ? { contextId: handleRecord.contextId }
+                                : {}),
+                        taskHandle: continuationTask.task_handle,
+                    };
+                }
+                catch (error) {
+                    if (error instanceof A2AOutboundError &&
+                        (error.code === ERROR_CODES.UNKNOWN_TASK_HANDLE ||
+                            error.code === ERROR_CODES.EXPIRED_TASK_HANDLE)) {
+                        const clientResolution = await this.resolveClient(continuationTarget);
+                        return {
+                            target: clientResolution.target,
+                            clientEntry: clientResolution.clientEntry,
+                            taskId: continuationTask.task_id,
+                            ...(continuationContextId !== undefined
+                                ? { contextId: continuationContextId }
+                                : {}),
+                        };
+                    }
+                    throw error;
+                }
+            }
+            const clientResolution = await this.resolveClient(continuationTarget);
+            return {
+                target: clientResolution.target,
+                clientEntry: clientResolution.clientEntry,
+                ...(continuationTask !== undefined
+                    ? { taskId: continuationTask.task_id }
+                    : {}),
+                ...(continuationContextId !== undefined
+                    ? { contextId: continuationContextId }
+                    : {}),
+            };
+        }
         if (input.task_handle !== undefined) {
             const handleRecord = this.taskHandleRegistry.resolve(input.task_handle);
             if (input.task_id !== undefined && input.task_id !== handleRecord.taskId) {
@@ -238,40 +419,117 @@ export class A2AOutboundService {
                 targetIdentity(explicitTarget) !== targetIdentity(handleRecord.target)) {
                 throw taskHandleTargetMismatchError(input.task_handle, handleRecord.target, explicitTarget);
             }
-            const clientEntry = await this.clientPool.get(handleRecord.target);
+            if ("context_id" in input &&
+                typeof input.context_id === "string" &&
+                handleRecord.contextId !== undefined &&
+                input.context_id !== handleRecord.contextId) {
+                throw taskHandleContextIdMismatchError(input.task_handle, handleRecord.contextId, input.context_id);
+            }
+            const clientResolution = await this.resolveClient(handleRecord.target);
             return {
-                target: handleRecord.target,
-                clientEntry,
+                target: clientResolution.target,
+                clientEntry: clientResolution.clientEntry,
                 taskId: handleRecord.taskId,
+                ...("context_id" in input && input.context_id !== undefined
+                    ? { contextId: input.context_id }
+                    : handleRecord.contextId !== undefined
+                        ? { contextId: handleRecord.contextId }
+                        : {}),
                 taskHandle: input.task_handle,
             };
         }
-        if (input.task_id === undefined) {
-            throw missingTargetContextError(input.action);
-        }
         const target = this.resolveExplicitTarget(input) ?? this.targetCatalog.resolveDefaultTarget();
         if (!target) {
             throw missingTargetContextError(input.action);
         }
-        const clientEntry = await this.clientPool.get(target);
-        return {
-            target,
-            clientEntry,
-            taskId: input.task_id,
-        };
+        const clientResolution = await this.resolveClient(target);
+        if (input.task_id !== undefined) {
+            return {
+                target: clientResolution.target,
+                clientEntry: clientResolution.clientEntry,
+                taskId: input.task_id,
+                ...("context_id" in input && input.context_id !== undefined
+                    ? { contextId: input.context_id }
+                    : {}),
+            };
+        }
+        if (input.action === "send") {
+            return {
+                target: clientResolution.target,
+                clientEntry: clientResolution.clientEntry,
+                ...("context_id" in input && input.context_id !== undefined
+                    ? { contextId: input.context_id }
+                    : {}),
+            };
+        }
+        throw missingTargetContextError(input.action);
     }
-    bindTaskHandle(target, taskId, taskHandle) {
+    bindTaskHandle(target, taskId, taskHandle, contextId) {
         if (taskHandle !== undefined) {
-            return this.taskHandleRegistry.refresh(taskHandle, { target, taskId })
+            return this.taskHandleRegistry.refresh(taskHandle, {
+                target,
+                taskId,
+                ...(contextId !== undefined ? { contextId } : {}),
+            })
                 .taskHandle;
         }
-        return this.taskHandleRegistry.create({ target, taskId }).taskHandle;
+        return this.taskHandleRegistry.create({
+            target,
+            taskId,
+            ...(contextId !== undefined ? { contextId } : {}),
+        }).taskHandle;
     }
-    bindStreamTaskHandle(target, events, taskHandle) {
-        const taskId = firstStreamTaskId(events);
-        return taskId !== undefined
-            ? this.bindTaskHandle(target, taskId, taskHandle)
-            : undefined;
+    bindTaskContext(target, taskContext) {
+        if (taskContext.taskId === undefined) {
+            return taskContext;
+        }
+        return {
+            ...taskContext,
+            taskHandle: this.bindTaskHandle(target, taskContext.taskId, taskContext.taskHandle, taskContext.contextId),
+        };
+    }
+    prepareSend(input, options, requestBuilder = normalizeSendRequest) {
+        return this.resolveTaskContext(input).then((resolved) => {
+            const normalized = requestBuilder({
+                ...input,
+                ...(resolved.taskId !== undefined ? { task_id: resolved.taskId } : {}),
+                ...(resolved.contextId !== undefined
+                    ? { context_id: resolved.contextId }
+                    : {}),
+            }, {
+                defaultTimeoutMs: this.config.defaults.timeoutMs,
+                defaultServiceParameters: this.config.defaults.serviceParameters,
+                defaultAcceptedOutputModes: this.config.policy.acceptedOutputModes,
+                signal: options.signal,
+            });
+            const capabilityDiagnostics = evaluateSendCompatibility(input, normalized.sendParams.configuration?.acceptedOutputModes ?? [], this.targetCatalog.getCardSnapshot(resolved.target.baseUrl));
+            return {
+                resolved,
+                normalized,
+                capabilityDiagnostics,
+            };
+        });
+    }
+    taskQueryOptions(input, signal) {
+        return buildRequestOptions(input.timeout_ms, this.config.defaults.timeoutMs, this.config.defaults.serviceParameters, input.service_parameters, signal);
+    }
+    async consumeResubscribeStream(action, resolved, input, state, options, dedupeInitialTask) {
+        if (resolved.taskId === undefined) {
+            throw missingTargetContextError("watch");
+        }
+        const peerCard = this.targetCatalog.getCardSnapshot(resolved.target.baseUrl);
+        if (peerCard?.capabilities.streaming === false ||
+            (peerCard === undefined && resolved.target.streamingSupported === false)) {
+            throw streamingNotSupportedError(resolved.target, resolved.taskId);
+        }
+        const params = {
+            id: resolved.taskId,
+        };
+        await consumeStream(resolved.clientEntry.client.resubscribeTask(params, this.taskQueryOptions(input, options.signal)), action, resolved.target, state, () => {
+            state.taskContext = this.bindTaskContext(resolved.target, state.taskContext);
+        }, options.onUpdate, (event, index) => index === 0 &&
+            dedupeInitialTask !== undefined &&
+            equivalentTaskSnapshots(dedupeInitialTask, event));
     }
     async listTargets() {
         const span = startSpan(this.tracer, "a2a.remote_agent.list_targets");
@@ -293,20 +551,31 @@ export class A2AOutboundService {
     async send(input, options) {
         const span = startSpan(this.tracer, "a2a.remote_agent.send");
         let target;
+        let capabilityDiagnostics;
         try {
-            const resolved = await this.resolveSendTarget(input);
-            target = resolved.target;
-            const normalized = normalizePlainIntentRequest(input, {
-                defaultTimeoutMs: this.config.defaults.timeoutMs,
-                defaultServiceParameters: this.config.defaults.serviceParameters,
-                signal: options.signal,
-            });
-            const raw = await resolved.clientEntry.client.sendMessage(normalized.sendParams, normalized.requestOptions);
-            const taskHandle = raw.kind === "task" ? this.bindTaskHandle(target, raw.id) : undefined;
-            return sendSuccess(target, raw, taskHandle);
+            const prepared = await this.prepareSend(input, options, isStrictTaskRequirement(input)
+                ? normalizeStrictTaskCreationSendRequest
+                : normalizeSendRequest);
+            target = prepared.resolved.target;
+            capabilityDiagnostics = prepared.capabilityDiagnostics;
+            const raw = await prepared.resolved.clientEntry.client.sendMessage(prepared.normalized.sendParams, prepared.normalized.requestOptions);
+            if (isStrictTaskRequirement(input)) {
+                if (raw.kind !== "task") {
+                    throw taskRequiredButMessageReturnedError(raw);
+                }
+                return sendSuccess(target, raw, this.bindTaskContext(target, mergeTaskContext(prepared.resolved, taskContextFromTask(raw))));
+            }
+            return sendSuccess(target, raw, this.bindTaskContext(target, mergeTaskContext(prepared.resolved, raw.kind === "task"
+                ? taskContextFromTask(raw)
+                : taskContextFromMessage(raw))));
         }
         catch (error) {
-            const toolError = toToolError(error, fallbackErrorCode(error));
+            let toolError = toToolError(error, fallbackErrorCode(error));
+            if (capabilityDiagnostics !== undefined) {
+                toolError = withErrorDetails(toolError, {
+                    capability_diagnostics: capabilityDiagnostics,
+                });
+            }
             log(this.logger, "error", "a2a.remote_agent.send.error", {
                 target,
                 error: toolError,
@@ -320,25 +589,83 @@ export class A2AOutboundService {
     async sendStream(input, options) {
         const span = startSpan(this.tracer, "a2a.remote_agent.send_stream");
         let target;
+        let capabilityDiagnostics;
         const state = {
             events: [],
+            taskContext: {},
         };
         try {
-            const resolved = await this.resolveSendTarget(input);
-            target = resolved.target;
-            const normalized = normalizePlainIntentRequest(input, {
-                defaultTimeoutMs: this.config.defaults.timeoutMs,
-                defaultServiceParameters: this.config.defaults.serviceParameters,
-                signal: options.signal,
-            });
-            await consumeStream(resolved.clientEntry.client.sendMessageStream(normalized.sendParams, normalized.requestOptions), "send", target, state, options.onUpdate);
+            if (isStrictTaskRequirement(input)) {
+                const prepared = await this.prepareSend(input, options, normalizeStrictTaskCreationSendRequest);
+                target = prepared.resolved.target;
+                capabilityDiagnostics = prepared.capabilityDiagnostics;
+                const raw = await prepared.resolved.clientEntry.client.sendMessage(prepared.normalized.sendParams, prepared.normalized.requestOptions);
+                if (raw.kind !== "task") {
+                    throw taskRequiredButMessageReturnedError(raw);
+                }
+                const createdTaskContext = this.bindTaskContext(target, mergeTaskContext(prepared.resolved, taskContextFromTask(raw)));
+                state.taskContext = mergeTaskContext(state.taskContext, createdTaskContext);
+                appendStreamEvent("send", target, state, raw, options.onUpdate);
+                if (isTerminalTaskStatus(raw.status.state)) {
+                    return sendStreamSuccess(target, state.events, state.taskContext);
+                }
+                try {
+                    await this.consumeResubscribeStream("send", {
+                        ...prepared.resolved,
+                        ...createdTaskContext,
+                    }, input, state, options, raw);
+                    if (state.events.length === 1) {
+                        throw new A2AOutboundError(ERROR_CODES.A2A_SDK_ERROR, "stream ended without watch events");
+                    }
+                }
+                catch (error) {
+                    let effectiveError = error;
+                    if (effectiveError instanceof UnsupportedOperationError) {
+                        effectiveError = streamingNotSupportedError(target, raw.id);
+                    }
+                    let toolError = toToolError(effectiveError, fallbackErrorCode(effectiveError));
+                    toolError = withRecoverableStatusSuggestion(toolError, createdTaskContext);
+                    if (capabilityDiagnostics !== undefined) {
+                        toolError = withErrorDetails(toolError, {
+                            capability_diagnostics: capabilityDiagnostics,
+                        });
+                    }
+                    if (state.events.length > 0 && state.latestSummary) {
+                        toolError = withErrorDetails(toolError, {
+                            partial_event_count: state.events.length,
+                            latest_event_summary: state.latestSummary,
+                        });
+                    }
+                    log(this.logger, "error", "a2a.remote_agent.send_stream.error", {
+                        target,
+                        error: toolError,
+                    });
+                    return remoteAgentFailure("send", toolError);
+                }
+                if (state.events.length === 0) {
+                    throw new A2AOutboundError(ERROR_CODES.A2A_SDK_ERROR, "stream ended without events");
+                }
+                return sendStreamSuccess(target, state.events, state.taskContext);
+            }
+            const prepared = await this.prepareSend(input, options);
+            target = prepared.resolved.target;
+            capabilityDiagnostics = prepared.capabilityDiagnostics;
+            state.taskContext = mergeTaskContext(state.taskContext, prepared.resolved);
+            await consumeStream(prepared.resolved.clientEntry.client.sendMessageStream(prepared.normalized.sendParams, prepared.normalized.requestOptions), "send", target, state, (event) => {
+                state.taskContext = this.bindTaskContext(prepared.resolved.target, mergeTaskContext(state.taskContext, taskContextFromEvent(event)));
+            }, options.onUpdate);
             if (state.events.length === 0) {
                 throw new A2AOutboundError(ERROR_CODES.A2A_SDK_ERROR, "stream ended without events");
             }
-            return sendStreamSuccess(target, state.events, this.bindStreamTaskHandle(target, state.events));
+            return sendStreamSuccess(target, state.events, this.bindTaskContext(target, state.taskContext));
         }
         catch (error) {
             let toolError = toToolError(error, fallbackErrorCode(error));
+            if (capabilityDiagnostics !== undefined) {
+                toolError = withErrorDetails(toolError, {
+                    capability_diagnostics: capabilityDiagnostics,
+                });
+            }
             if (state.events.length > 0 && state.latestSummary) {
                 toolError = withErrorDetails(toolError, {
                     partial_event_count: state.events.length,
@@ -363,6 +690,9 @@ export class A2AOutboundService {
             const resolved = await this.resolveTaskContext(input);
             target = resolved.target;
             taskId = resolved.taskId;
+            if (resolved.taskId === undefined) {
+                throw missingTargetContextError("status");
+            }
             const params = {
                 id: resolved.taskId,
                 ...(input.history_length !== undefined
@@ -370,7 +700,7 @@ export class A2AOutboundService {
                     : {}),
             };
             const raw = await resolved.clientEntry.client.getTask(params, buildRequestOptions(input.timeout_ms, this.config.defaults.timeoutMs, this.config.defaults.serviceParameters, input.service_parameters, options.signal));
-            return statusSuccess(target, raw, this.bindTaskHandle(target, raw.id, resolved.taskHandle));
+            return statusSuccess(target, raw, this.bindTaskContext(target, mergeTaskContext(resolved, taskContextFromTask(raw))));
         }
         catch (error) {
             const toolError = toToolError(error, fallbackErrorCode(error));
@@ -391,22 +721,21 @@ export class A2AOutboundService {
         let taskId;
         const state = {
             events: [],
+            taskContext: {},
         };
         try {
             const resolved = await this.resolveTaskContext(input);
             target = resolved.target;
             taskId = resolved.taskId;
-            if (resolved.target.streamingSupported === false) {
-                throw streamingNotSupportedError(resolved.target, resolved.taskId);
+            if (resolved.taskId === undefined) {
+                throw missingTargetContextError("watch");
             }
-            const params = {
-                id: resolved.taskId,
-            };
-            await consumeStream(resolved.clientEntry.client.resubscribeTask(params, buildRequestOptions(input.timeout_ms, this.config.defaults.timeoutMs, this.config.defaults.serviceParameters, input.service_parameters, options.signal)), "watch", target, state, options.onUpdate);
+            state.taskContext = mergeTaskContext(state.taskContext, resolved);
+            await this.consumeResubscribeStream("watch", resolved, input, state, options);
             if (state.events.length === 0) {
                 throw new A2AOutboundError(ERROR_CODES.A2A_SDK_ERROR, "stream ended without events");
             }
-            return watchSuccess(target, state.events, this.bindStreamTaskHandle(target, state.events, resolved.taskHandle));
+            return watchSuccess(target, state.events, this.bindTaskContext(target, state.taskContext));
         }
         catch (error) {
             let effectiveError = error;
@@ -441,11 +770,14 @@ export class A2AOutboundService {
             const resolved = await this.resolveTaskContext(input);
             target = resolved.target;
             taskId = resolved.taskId;
+            if (resolved.taskId === undefined) {
+                throw missingTargetContextError("cancel");
+            }
             const params = {
                 id: resolved.taskId,
             };
             const raw = await resolved.clientEntry.client.cancelTask(params, buildRequestOptions(input.timeout_ms, this.config.defaults.timeoutMs, this.config.defaults.serviceParameters, input.service_parameters, options.signal));
-            return cancelSuccess(target, raw, this.bindTaskHandle(target, raw.id, resolved.taskHandle));
+            return cancelSuccess(target, raw, this.bindTaskContext(target, mergeTaskContext(resolved, taskContextFromTask(raw))));
         }
         catch (error) {
             const toolError = toToolError(error, fallbackErrorCode(error));