@aramisfa/openclaw-a2a-outbound 0.1.2 → 0.2.1

package/README.md

@@ -2,16 +2,18 @@
 
 Native OpenClaw outbound A2A delegation plugin.
 
-This package registers three optional tools in OpenClaw:
-
-- `a2a_delegate`
-- `a2a_task_status`
-- `a2a_task_cancel`
+This package registers exactly one optional OpenClaw tool, `remote_agent`. The tool exposes five actions: `list_targets`, `send`, `watch`, `status`, and `cancel`.
 
 ## Installation
 
 ```bash
-npm install @aramisfa/openclaw-a2a-outbound
+openclaw plugins install @aramisfa/openclaw-a2a-outbound
+```
+
+Pin the exact published version if you want reproducible installs:
+
+```bash
+openclaw plugins install @aramisfa/openclaw-a2a-outbound --pin
 ```
 
 ## Requirements
@@ -21,7 +23,7 @@ npm install @aramisfa/openclaw-a2a-outbound
 
 ## OpenClaw Plugin Config
 
-`@aramisfa/openclaw-a2a-outbound` is disabled by default. Enable it in your plugin config:
+The plugin installs through the OpenClaw CLI, but the tool stays disabled until you set `"enabled": true` for plugin id `openclaw-a2a-outbound` in your OpenClaw plugin config:
 
 ```json
 {
@@ -32,33 +34,263 @@ npm install @aramisfa/openclaw-a2a-outbound
     "preferredTransports": ["JSONRPC", "HTTP+JSON"],
     "serviceParameters": {}
   },
+  "targets": [
+    {
+      "alias": "support",
+      "baseUrl": "https://support.example",
+      "description": "Primary support lane",
+      "tags": ["support"],
+      "examples": ["Summarize this incident and propose next steps."],
+      "default": true
+    }
+  ],
+  "taskHandles": {
+    "ttlMs": 86400000,
+    "maxEntries": 1000
+  },
   "policy": {
     "acceptedOutputModes": [],
     "normalizeBaseUrl": true,
-    "enforceSupportedTransports": true
+    "enforceSupportedTransports": true,
+    "allowTargetUrlOverride": false
+  }
+}
+```
+
+Call `list_targets` first to discover configured aliases and refreshed target-card metadata. Prefer `target_alias` over `target_url`; use `target_url` only when policy allows direct URL routing.
+
+## Unified Tool Contract
+
+`remote_agent` accepts a flattened request object with top-level fields:
+
+- `action`: required for every request.
+- `target_alias`: preferred routing key for `send`, `watch`, `status`, and `cancel`.
+- `target_url`: explicit remote base URL when policy allows it or when it matches a configured target.
+- `input`: required for `send`; becomes the single user text part sent to the peer.
+- `attachments`: optional file or data attachments for `send`.
+- `task_handle`: opaque follow-up handle returned after delegated tasks are created.
+- `task_id`: fallback follow-up key when no live `task_handle` is available.
+- `follow_updates`: stream live updates during `send`.
+- `history_length`: optional history window for `send` and `status`.
+- `timeout_ms`: per-request timeout override.
+- `service_parameters`: optional outbound service parameters.
+- `metadata`: optional metadata payload for `send`.
+
+Action-specific validation rejects unsupported fields for each action, so keep requests flat and action-focused.
+
+## Actions
+
+- `list_targets`: discover configured targets, aliases, examples, and hydrated card metadata.
+- `send`: send user input to a remote agent selected by `target_alias`, `target_url`, or a configured default target.
+- `watch`: resubscribe to a running delegated task and stream updates.
+- `status`: fetch the latest task snapshot.
+- `cancel`: request cancellation for a delegated task.
+
+For follow-up actions, prefer `task_handle` first. If the handle is expired or unavailable, fall back to `target_alias` + `task_id`.
+
+## Examples
+
+### Discover Available Targets
+
+```json
+{ "action": "list_targets" }
+```
+
+```json
+{
+  "ok": true,
+  "operation": "remote_agent",
+  "action": "list_targets",
+  "summary": {
+    "targets": [
+      {
+        "target_alias": "support",
+        "target_url": "https://support.example/",
+        "default": true,
+        "tags": ["support"],
+        "examples": ["Summarize this incident and propose next steps."],
+        "target_name": "Support Agent",
+        "description": "Primary support lane",
+        "streaming_supported": true,
+        "skills": [
+          {
+            "id": "triage",
+            "name": "Incident Triage",
+            "description": "Summarize incidents and propose next actions.",
+            "tags": ["support"],
+            "examples": ["Summarize this incident and propose next steps."]
+          }
+        ]
+      }
+    ]
+  },
+  "raw": [
+    {
+      "default": true,
+      "tags": ["support"],
+      "examples": ["Summarize this incident and propose next steps."]
+    }
+  ]
+}
+```
+
+### Send To An Explicit `target_alias`
+
+```json
+{
+  "action": "send",
+  "target_alias": "support",
+  "input": "Summarize this bug report for triage.",
+  "metadata": {
+    "ticket_id": "INC-42"
+  }
+}
+```
+
+```json
+{
+  "ok": true,
+  "operation": "remote_agent",
+  "action": "send",
+  "summary": {
+    "target_alias": "support",
+    "target_url": "https://support.example/",
+    "message_text": "Triage summary: reproduce, collect logs, and notify the on-call engineer."
+  },
+  "raw": {
+    "kind": "message"
+  }
+}
+```
+
+### Send Using The Configured Default Target
+
+If one target is marked `"default": true`, `send` can omit `target_alias`:
+
+```json
+{
+  "action": "send",
+  "input": "Draft a reply to the customer update.",
+  "follow_updates": true
+}
+```
+
+```json
+{
+  "ok": true,
+  "operation": "remote_agent",
+  "action": "send",
+  "summary": {
+    "target_alias": "support",
+    "target_url": "https://support.example/",
+    "task_handle": "rah_0a3ff8c2-4a6d-48cb-a57d-4ae6f3c589d0",
+    "task_id": "task-456",
+    "status": "completed",
+    "can_watch": true
+  },
+  "raw": {
+    "events": [
+      {
+        "kind": "task",
+        "id": "task-456",
+        "status": {
+          "state": "submitted"
+        }
+      },
+      {
+        "kind": "status-update",
+        "taskId": "task-456",
+        "status": {
+          "state": "completed"
+        },
+        "final": true
+      }
+    ],
+    "finalEvent": {
+      "kind": "status-update",
+      "taskId": "task-456",
+      "status": {
+        "state": "completed"
+      },
+      "final": true
+    }
   }
 }
 ```
 
-## Validation Errors
+### Check Task Status With `task_handle`
+
+```json
+{
+  "action": "status",
+  "task_handle": "rah_0a3ff8c2-4a6d-48cb-a57d-4ae6f3c589d0",
+  "history_length": 2
+}
+```
+
+```json
+{
+  "ok": true,
+  "operation": "remote_agent",
+  "action": "status",
+  "summary": {
+    "target_alias": "support",
+    "target_url": "https://support.example/",
+    "task_handle": "rah_0a3ff8c2-4a6d-48cb-a57d-4ae6f3c589d0",
+    "task_id": "task-456",
+    "status": "completed",
+    "can_watch": true
+  },
+  "raw": {
+    "kind": "task",
+    "id": "task-456",
+    "status": {
+      "state": "completed"
+    }
+  }
+}
+```
 
-Tool input validation is powered by [Ajv](https://ajv.js.org/) in strict mode. When validation fails, the error envelope contains native Ajv error objects:
+When a handle is expired or unavailable, retry with `target_alias` + `task_id`:
+
+```json
+{
+  "action": "status",
+  "target_alias": "support",
+  "task_id": "task-456"
+}
+```
+
+`watch` and `cancel` use the same follow-up targeting rules:
+
+```json
+{ "action": "watch", "task_handle": "rah_0a3ff8c2-4a6d-48cb-a57d-4ae6f3c589d0" }
+```
+
+```json
+{ "action": "cancel", "task_handle": "rah_0a3ff8c2-4a6d-48cb-a57d-4ae6f3c589d0" }
+```
+
+## Validation And Actionable Errors
+
+Tool input validation uses Ajv in strict mode. Validation failures use `operation: "remote_agent"` and include native-style Ajv error objects:
 
 ```json
 {
   "ok": false,
-  "operation": "a2a_delegate",
+  "operation": "remote_agent",
+  "action": "send",
   "error": {
     "code": "VALIDATION_ERROR",
-    "message": "a2a_delegate input validation failed",
+    "message": "remote_agent input validation failed",
     "details": {
       "source": "ajv",
-      "tool": "a2a_delegate",
+      "tool": "remote_agent",
       "errors": [
         {
-          "keyword": "required",
-          "instancePath": "/request/message",
-          "params": { "missingProperty": "kind" }
+          "keyword": "anyOf",
+          "instancePath": "",
+          "message": "send requires target_alias, target_url, or a configured default target"
         }
       ]
     }
@@ -66,7 +298,26 @@ Tool input validation is powered by [Ajv](https://ajv.js.org/) in strict mode. W
 }
 ```
 
-The `error.details.errors` array contains Ajv `ErrorObject` entries. See the [Ajv error documentation](https://ajv.js.org/api.html#error-objects) for the full shape.
+Expired handles return an actionable recovery envelope:
+
+```json
+{
+  "ok": false,
+  "operation": "remote_agent",
+  "action": "status",
+  "error": {
+    "code": "EXPIRED_TASK_HANDLE",
+    "message": "task handle \"rah_0a3ff8c2-4a6d-48cb-a57d-4ae6f3c589d0\" has expired",
+    "details": {
+      "taskHandle": "rah_0a3ff8c2-4a6d-48cb-a57d-4ae6f3c589d0",
+      "retryHint": "Retry with explicit target plus taskId, or resend the original request after a restart to obtain a new handle.",
+      "restartInvalidatesHandles": true,
+      "suggested_actions": ["status", "send"],
+      "hint": "Retry with target_alias + task_id, or send a new request."
+    }
+  }
+}
+```
 
 ## Development
 

package/dist/config.d.ts

@@ -6,14 +6,31 @@ export interface A2AOutboundDefaultsConfig {
     preferredTransports: A2ATransport[];
     serviceParameters: Record<string, string>;
 }
+export interface A2AOutboundTargetConfig {
+    alias: string;
+    baseUrl: string;
+    description?: string;
+    tags: string[];
+    cardPath: string;
+    preferredTransports: A2ATransport[];
+    examples: string[];
+    default: boolean;
+}
+export interface A2AOutboundTaskHandlesConfig {
+    ttlMs: number;
+    maxEntries: number;
+}
 export interface A2AOutboundPolicyConfig {
     acceptedOutputModes: string[];
     normalizeBaseUrl: boolean;
     enforceSupportedTransports: boolean;
+    allowTargetUrlOverride: boolean;
 }
 export interface A2AOutboundPluginConfig {
     enabled: boolean;
     defaults: A2AOutboundDefaultsConfig;
+    targets: A2AOutboundTargetConfig[];
+    taskHandles: A2AOutboundTaskHandlesConfig;
     policy: A2AOutboundPolicyConfig;
 }
 export declare const A2A_OUTBOUND_DEFAULT_CONFIG: A2AOutboundPluginConfig;

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACtE,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAC;AAExB,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,mBAAmB,EAAE,YAAY,EAAE,CAAC;IACpC,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C;AAED,MAAM,WAAW,uBAAuB;IACtC,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,gBAAgB,EAAE,OAAO,CAAC;IAC1B,0BAA0B,EAAE,OAAO,CAAC;CACrC;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,yBAAyB,CAAC;IACpC,MAAM,EAAE,uBAAuB,CAAC;CACjC;AAED,eAAO,MAAM,2BAA2B,EAAE,uBAazC,CAAC;AAEF,eAAO,MAAM,+BAA+B,EAAE,WAAW,CACvD,0BAA0B,CAAC,YAAY,CAAC,CAyDzC,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,WAAW,CACpD,0BAA0B,CAAC,SAAS,CAAC,CA0CtC,CAAC;AAuFF,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,OAAO,GACb,uBAAuB,CA4CzB;AAED,eAAO,MAAM,mCAAmC,EAAE,0BAO/C,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACtE,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,gBAAgB,CAAC;AAExB,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,mBAAmB,EAAE,YAAY,EAAE,CAAC;IACpC,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C;AAED,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,mBAAmB,EAAE,YAAY,EAAE,CAAC;IACpC,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,4BAA4B;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,uBAAuB;IACtC,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,gBAAgB,EAAE,OAAO,CAAC;IAC1B,0BAA0B,EAAE,OAAO,CAAC;IACpC,sBAAsB,EAAE,OAAO,CAAC;CACjC;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,yBAAyB,CAAC;IACpC,OAAO,EAAE,uBAAuB,EAAE,CAAC;IACnC,WAAW,EAAE,4BAA4B,CAAC;IAC1C,MAAM,EAAE,uBAAuB,CAAC;CACjC;AAED,eAAO,MAAM,2BAA2B,EAAE,uBAmBzC,CAAC;AAEF,eAAO,MAAM,+BAA+B,EAAE,WAAW,CACvD,0BAA0B,CAAC,YAAY,CAAC,CAkIzC,CAAC;AAEF,eAAO,MAAM,4BAA4B,EAAE,WAAW,CACpD,0BAA0B,CAAC,SAAS,CAAC,CA6DtC,CAAC;AAsPF,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,OAAO,GACb,uBAAuB,CA+DzB;AAED,eAAO,MAAM,mCAAmC,EAAE,0BAMjD,CAAC"}

package/dist/config.js

@@ -7,10 +7,16 @@ export const A2A_OUTBOUND_DEFAULT_CONFIG = {
         preferredTransports: [...SUPPORTED_TRANSPORTS],
         serviceParameters: {},
     },
+    targets: [],
+    taskHandles: {
+        ttlMs: 86400000,
+        maxEntries: 1000,
+    },
     policy: {
         acceptedOutputModes: [],
         normalizeBaseUrl: true,
         enforceSupportedTransports: true,
+        allowTargetUrlOverride: false,
     },
 };
 export const A2A_OUTBOUND_CONFIG_JSON_SCHEMA = {
@@ -40,12 +46,80 @@ export const A2A_OUTBOUND_CONFIG_JSON_SCHEMA = {
                         type: "string",
                         enum: [...ALL_TRANSPORTS],
                     },
-                    default: [...A2A_OUTBOUND_DEFAULT_CONFIG.defaults.preferredTransports],
+                    default: [
+                        ...A2A_OUTBOUND_DEFAULT_CONFIG.defaults.preferredTransports,
+                    ],
                 },
                 serviceParameters: {
                     type: "object",
                     additionalProperties: { type: "string" },
-                    default: { ...A2A_OUTBOUND_DEFAULT_CONFIG.defaults.serviceParameters },
+                    default: {
+                        ...A2A_OUTBOUND_DEFAULT_CONFIG.defaults.serviceParameters,
+                    },
+                },
+            },
+        },
+        targets: {
+            type: "array",
+            default: [],
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["alias", "baseUrl"],
+                properties: {
+                    alias: {
+                        type: "string",
+                    },
+                    baseUrl: {
+                        type: "string",
+                    },
+                    description: {
+                        type: "string",
+                    },
+                    tags: {
+                        type: "array",
+                        items: { type: "string" },
+                        default: [],
+                    },
+                    cardPath: {
+                        type: "string",
+                        default: A2A_OUTBOUND_DEFAULT_CONFIG.defaults.cardPath,
+                    },
+                    preferredTransports: {
+                        type: "array",
+                        items: {
+                            type: "string",
+                            enum: [...ALL_TRANSPORTS],
+                        },
+                        default: [
+                            ...A2A_OUTBOUND_DEFAULT_CONFIG.defaults.preferredTransports,
+                        ],
+                    },
+                    examples: {
+                        type: "array",
+                        items: { type: "string" },
+                        default: [],
+                    },
+                    default: {
+                        type: "boolean",
+                        default: false,
+                    },
+                },
+            },
+        },
+        taskHandles: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                ttlMs: {
+                    type: "integer",
+                    minimum: 1,
+                    default: A2A_OUTBOUND_DEFAULT_CONFIG.taskHandles.ttlMs,
+                },
+                maxEntries: {
+                    type: "integer",
+                    minimum: 1,
+                    default: A2A_OUTBOUND_DEFAULT_CONFIG.taskHandles.maxEntries,
                 },
             },
         },
@@ -66,6 +140,10 @@ export const A2A_OUTBOUND_CONFIG_JSON_SCHEMA = {
                     type: "boolean",
                     default: A2A_OUTBOUND_DEFAULT_CONFIG.policy.enforceSupportedTransports,
                 },
+                allowTargetUrlOverride: {
+                    type: "boolean",
+                    default: A2A_OUTBOUND_DEFAULT_CONFIG.policy.allowTargetUrlOverride,
+                },
             },
         },
     },
@@ -96,6 +174,20 @@ export const A2A_OUTBOUND_CONFIG_UI_HINTS = {
         help: "Default headers or provider-specific request parameters.",
         advanced: true,
     },
+    targets: {
+        label: "Named Targets",
+        help: "Registry of reusable outbound A2A targets for future routing phases.",
+    },
+    "taskHandles.ttlMs": {
+        label: "Task Handle TTL (ms)",
+        help: "Retention window for cached delegated task handles.",
+        advanced: true,
+    },
+    "taskHandles.maxEntries": {
+        label: "Task Handle Cache Size",
+        help: "Maximum number of delegated task handles retained locally.",
+        advanced: true,
+    },
     "policy.acceptedOutputModes": {
         label: "Accepted Output Modes",
         help: "Allowed response media types for outbound client requests.",
@@ -111,7 +203,26 @@ export const A2A_OUTBOUND_CONFIG_UI_HINTS = {
         help: "Rejects targets requesting transports unsupported by this build.",
         advanced: true,
     },
+    "policy.allowTargetUrlOverride": {
+        label: "Allow Target URL Override",
+        help: "Permits explicit request URLs to bypass the named target registry.",
+        advanced: true,
+    },
 };
+function cloneTargetConfig(target) {
+    return {
+        alias: target.alias,
+        baseUrl: target.baseUrl,
+        ...(target.description !== undefined
+            ? { description: target.description }
+            : {}),
+        tags: [...target.tags],
+        cardPath: target.cardPath,
+        preferredTransports: [...target.preferredTransports],
+        examples: [...target.examples],
+        default: target.default,
+    };
+}
 function cloneConfig(config) {
     return {
         enabled: config.enabled,
@@ -121,10 +232,16 @@ function cloneConfig(config) {
             preferredTransports: [...config.defaults.preferredTransports],
             serviceParameters: { ...config.defaults.serviceParameters },
         },
+        targets: config.targets.map(cloneTargetConfig),
+        taskHandles: {
+            ttlMs: config.taskHandles.ttlMs,
+            maxEntries: config.taskHandles.maxEntries,
+        },
         policy: {
             acceptedOutputModes: [...config.policy.acceptedOutputModes],
             normalizeBaseUrl: config.policy.normalizeBaseUrl,
             enforceSupportedTransports: config.policy.enforceSupportedTransports,
+            allowTargetUrlOverride: config.policy.allowTargetUrlOverride,
         },
     };
 }
@@ -146,10 +263,33 @@ function normalizeStringArray(value, fallback = []) {
     }
     return normalized;
 }
+function normalizeTrimmedStringArray(value, fallback = []) {
+    if (!Array.isArray(value)) {
+        return [...fallback];
+    }
+    const normalized = [];
+    for (const entry of value) {
+        if (typeof entry !== "string") {
+            continue;
+        }
+        const trimmed = entry.trim();
+        if (trimmed === "") {
+            continue;
+        }
+        if (!normalized.includes(trimmed)) {
+            normalized.push(trimmed);
+        }
+    }
+    return normalized;
+}
 function normalizeTransports(value, fallback) {
     const normalized = normalizeStringArray(value).filter((entry) => ALL_TRANSPORTS.includes(entry));
     return normalized.length > 0 ? normalized : [...fallback];
 }
+function normalizeTrimmedTransports(value, fallback) {
+    const normalized = normalizeTrimmedStringArray(value).filter((entry) => ALL_TRANSPORTS.includes(entry));
+    return normalized.length > 0 ? normalized : [...fallback];
+}
 function normalizeStringMap(value, fallback = {}) {
     if (!isPlainObject(value)) {
         return { ...fallback };
@@ -170,27 +310,101 @@ function readPositiveInteger(value, fallback) {
         ? value
         : fallback;
 }
+function readString(value, fallback) {
+    return typeof value === "string" && value.trim() !== "" ? value : fallback;
+}
+function readTrimmedString(value, fallback) {
+    if (typeof value !== "string") {
+        return fallback;
+    }
+    const trimmed = value.trim();
+    return trimmed !== "" ? trimmed : fallback;
+}
+function readOptionalTrimmedString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed !== "" ? trimmed : undefined;
+}
+function invalidConfig(message) {
+    return new TypeError(`Invalid openclaw-a2a-outbound config: ${message}`);
+}
+function normalizeTargets(value, defaults) {
+    if (value === undefined) {
+        return A2A_OUTBOUND_DEFAULT_CONFIG.targets.map(cloneTargetConfig);
+    }
+    if (!Array.isArray(value)) {
+        throw invalidConfig("targets must be an array");
+    }
+    const aliases = new Set();
+    let defaultTargetAlias;
+    return value.map((entry, index) => {
+        if (!isPlainObject(entry)) {
+            throw invalidConfig(`targets[${index}] must be an object`);
+        }
+        const alias = typeof entry.alias === "string" ? entry.alias.trim() : "";
+        if (alias === "") {
+            throw invalidConfig(`targets[${index}].alias must be a non-empty string`);
+        }
+        const baseUrl = typeof entry.baseUrl === "string" ? entry.baseUrl.trim() : "";
+        if (baseUrl === "") {
+            throw invalidConfig(`targets[${index}].baseUrl must be a non-empty string`);
+        }
+        if (aliases.has(alias)) {
+            throw invalidConfig(`targets contains duplicate alias "${alias}"`);
+        }
+        aliases.add(alias);
+        const normalizedTarget = {
+            alias,
+            baseUrl,
+            tags: normalizeTrimmedStringArray(entry.tags),
+            cardPath: readTrimmedString(entry.cardPath, defaults.cardPath.trim()),
+            preferredTransports: normalizeTrimmedTransports(entry.preferredTransports, defaults.preferredTransports),
+            examples: normalizeTrimmedStringArray(entry.examples),
+            default: readBoolean(entry.default, false),
+        };
+        const description = readOptionalTrimmedString(entry.description);
+        if (description !== undefined) {
+            normalizedTarget.description = description;
+        }
+        if (normalizedTarget.default) {
+            if (defaultTargetAlias !== undefined) {
+                throw invalidConfig(`targets contains multiple default entries ("${defaultTargetAlias}" and "${alias}")`);
+            }
+            defaultTargetAlias = alias;
+        }
+        return normalizedTarget;
+    });
+}
 export function parseA2AOutboundPluginConfig(input) {
     if (!isPlainObject(input)) {
         return cloneConfig(A2A_OUTBOUND_DEFAULT_CONFIG);
     }
     const rawDefaults = isPlainObject(input.defaults) ? input.defaults : {};
+    const normalizedDefaults = {
+        timeoutMs: readPositiveInteger(rawDefaults.timeoutMs, A2A_OUTBOUND_DEFAULT_CONFIG.defaults.timeoutMs),
+        cardPath: readString(rawDefaults.cardPath, A2A_OUTBOUND_DEFAULT_CONFIG.defaults.cardPath),
+        preferredTransports: normalizeTransports(rawDefaults.preferredTransports, A2A_OUTBOUND_DEFAULT_CONFIG.defaults.preferredTransports),
+        serviceParameters: normalizeStringMap(rawDefaults.serviceParameters, A2A_OUTBOUND_DEFAULT_CONFIG.defaults.serviceParameters),
+    };
+    const rawTaskHandles = isPlainObject(input.taskHandles)
+        ? input.taskHandles
+        : {};
     const rawPolicy = isPlainObject(input.policy) ? input.policy : {};
     return {
         enabled: readBoolean(input.enabled, A2A_OUTBOUND_DEFAULT_CONFIG.enabled),
-        defaults: {
-            timeoutMs: readPositiveInteger(rawDefaults.timeoutMs, A2A_OUTBOUND_DEFAULT_CONFIG.defaults.timeoutMs),
-            cardPath: typeof rawDefaults.cardPath === "string" &&
-                rawDefaults.cardPath.trim() !== ""
-                ? rawDefaults.cardPath
-                : A2A_OUTBOUND_DEFAULT_CONFIG.defaults.cardPath,
-            preferredTransports: normalizeTransports(rawDefaults.preferredTransports, A2A_OUTBOUND_DEFAULT_CONFIG.defaults.preferredTransports),
-            serviceParameters: normalizeStringMap(rawDefaults.serviceParameters, A2A_OUTBOUND_DEFAULT_CONFIG.defaults.serviceParameters),
+        defaults: normalizedDefaults,
+        targets: normalizeTargets(input.targets, normalizedDefaults),
+        taskHandles: {
+            ttlMs: readPositiveInteger(rawTaskHandles.ttlMs, A2A_OUTBOUND_DEFAULT_CONFIG.taskHandles.ttlMs),
+            maxEntries: readPositiveInteger(rawTaskHandles.maxEntries, A2A_OUTBOUND_DEFAULT_CONFIG.taskHandles.maxEntries),
         },
         policy: {
             acceptedOutputModes: normalizeStringArray(rawPolicy.acceptedOutputModes, A2A_OUTBOUND_DEFAULT_CONFIG.policy.acceptedOutputModes),
             normalizeBaseUrl: readBoolean(rawPolicy.normalizeBaseUrl, A2A_OUTBOUND_DEFAULT_CONFIG.policy.normalizeBaseUrl),
             enforceSupportedTransports: readBoolean(rawPolicy.enforceSupportedTransports, A2A_OUTBOUND_DEFAULT_CONFIG.policy.enforceSupportedTransports),
+            allowTargetUrlOverride: readBoolean(rawPolicy.allowTargetUrlOverride, A2A_OUTBOUND_DEFAULT_CONFIG.policy.allowTargetUrlOverride),
         },
     };
 }