@aramisfa/openclaw-a2a-outbound 0.1.1 → 0.2.0

package/dist/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,KAAK,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAOnE,eAAO,MAAM,sBAAsB,iBAAiB,CAAC;AACrD,eAAO,MAAM,oBAAoB,gEAMvB,CAAC;AAEX,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,oBAAoB,CAAC,CAAC,MAAM,CAAC,CAAC;AA6DtE,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mBAAmB,CAAC,EAAE,YAAY,EAAE,CAAC;CACtC;AAED,MAAM,WAAW,8BAA8B;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,WAAW,8BAA8B;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAED,MAAM,MAAM,0BAA0B,GAClC,8BAA8B,GAC9B,8BAA8B,CAAC;AAEnC,UAAU,oBAAoB;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC7C;AAED,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,cAAc,CAAC;CACxB;AAED,MAAM,WAAW,eAAgB,SAAQ,oBAAoB;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,0BAA0B,EAAE,CAAC;IAC3C,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,iBAAiB,CAAC,UAAU,CAAC,CAAC;CAC1C;AAED,MAAM,WAAW,gBAAiB,SAAQ,oBAAoB;IAC5D,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,iBAAkB,SAAQ,oBAAoB;IAC7D,MAAM,EAAE,QAAQ,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,iBAAkB,SAAQ,oBAAoB;IAC7D,MAAM,EAAE,QAAQ,CAAC;CAClB;AAED,MAAM,MAAM,oBAAoB,GAC5B,sBAAsB,GACtB,eAAe,GACf,gBAAgB,GAChB,iBAAiB,GACjB,iBAAiB,CAAC;AAEtB,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC;AA+GD,wBAAgB,gCAAgC,CAC9C,MAAM,EAAE,uBAAuB,GAC9B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAqEzB;AAED,wBAAgB,8BAA8B,CAC5C,MAAM,EAAE,uBAAuB,GAC9B,cAAc,CAOhB;AA2KD,MAAM,MAAM,yBAAyB,GAAG,CACtC,KAAK,EAAE,OAAO,KACX,oBAAoB,CAAC;AAE1B,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,uBAAuB,GAC9B,yBAAyB,CAwB3B;AAED,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BvB,CAAC"}

package/dist/schemas.js

@@ -1,315 +1,348 @@
 import { ALL_TRANSPORTS } from "./constants.js";
-import { createA2AOutboundAjv, toValidationError } from "./ajv-validator.js";
-const MESSAGE_ROLES = ["user", "agent"];
-const TARGET_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        baseUrl: {
-            type: "string",
-            minLength: 1,
-            format: "uri",
-            pattern: "^https?://",
-            description: "Target agent base URL.",
-        },
-        cardPath: {
-            type: "string",
-            minLength: 1,
-            description: "Optional override for the target agent-card path. Defaults from plugin config when omitted.",
-        },
-        preferredTransports: {
-            type: "array",
-            items: {
-                type: "string",
-                enum: ALL_TRANSPORTS,
-            },
-            description: "Optional transport preference override for this call. Defaults from plugin config when omitted.",
-        },
-    },
-    required: ["baseUrl"],
+import { createA2AOutboundAjv, toValidationError, } from "./ajv-validator.js";
+export const REMOTE_AGENT_TOOL_NAME = "remote_agent";
+export const REMOTE_AGENT_ACTIONS = [
+    "list_targets",
+    "send",
+    "watch",
+    "status",
+    "cancel",
+];
+const TASK_HANDLE_SCHEMA = {
+    type: "string",
+    minLength: 1,
+    pattern: "^rah_[A-Za-z0-9-]+$",
+    description: "Opaque task handle issued by this plugin. Handles are process-local and invalidated by restarts.",
 };
-const MESSAGE_PART_METADATA_SCHEMA = {
+const ATTACHMENT_METADATA_SCHEMA = {
     type: "object",
     additionalProperties: true,
 };
-const TEXT_PART_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        kind: { type: "string", enum: ["text"] },
-        text: { type: "string" },
-        metadata: MESSAGE_PART_METADATA_SCHEMA,
-    },
-    required: ["kind", "text"],
-};
-const FILE_PART_FILE_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        uri: { type: "string", minLength: 1 },
-        bytes: { type: "string", minLength: 1 },
-        name: { type: "string" },
-        mimeType: { type: "string" },
-    },
-    anyOf: [{ required: ["uri"] }, { required: ["bytes"] }],
-};
-const FILE_PART_SCHEMA = {
+const FILE_ATTACHMENT_SCHEMA = {
     type: "object",
     additionalProperties: false,
     properties: {
         kind: { type: "string", enum: ["file"] },
-        file: FILE_PART_FILE_SCHEMA,
-        metadata: MESSAGE_PART_METADATA_SCHEMA,
-    },
-    required: ["kind", "file"],
-};
-const DATA_PART_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        kind: { type: "string", enum: ["data"] },
-        data: { type: "object", additionalProperties: true },
-        metadata: MESSAGE_PART_METADATA_SCHEMA,
-    },
-    required: ["kind", "data"],
-};
-const PUSH_NOTIFICATION_AUTHENTICATION_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        schemes: {
-            type: "array",
-            items: { type: "string" },
-            description: "Authentication schemes for MessageSendParams.configuration.pushNotificationConfig.authentication.schemes.",
-        },
-        credentials: {
+        uri: {
             type: "string",
-            description: "Optional credentials for MessageSendParams.configuration.pushNotificationConfig.authentication.credentials.",
+            minLength: 1,
+            description: "Remote file URI for the attachment.",
         },
-    },
-    required: ["schemes"],
-};
-const PUSH_NOTIFICATION_CONFIG_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        url: {
+        bytes: {
             type: "string",
             minLength: 1,
-            description: "Callback URL for MessageSendParams.configuration.pushNotificationConfig.url.",
+            description: "Base64-encoded inline file content.",
         },
-        id: {
+        name: {
             type: "string",
-            description: "Optional identifier for MessageSendParams.configuration.pushNotificationConfig.id.",
+            minLength: 1,
+            description: "Optional filename.",
         },
-        token: {
+        mime_type: {
             type: "string",
-            description: "Optional token for MessageSendParams.configuration.pushNotificationConfig.token.",
-        },
-        authentication: {
-            ...PUSH_NOTIFICATION_AUTHENTICATION_SCHEMA,
-            description: "Optional MessageSendParams.configuration.pushNotificationConfig.authentication payload.",
-        },
-    },
-    required: ["url"],
-};
-const MESSAGE_SEND_CONFIGURATION_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        blocking: {
-            type: "boolean",
-            description: "Optional MessageSendParams.configuration.blocking passthrough.",
-        },
-        acceptedOutputModes: {
-            type: "array",
-            items: { type: "string" },
-            description: "Optional MessageSendParams.configuration.acceptedOutputModes passthrough.",
-        },
-        historyLength: {
-            type: "integer",
-            minimum: 0,
-            description: "Optional MessageSendParams.configuration.historyLength passthrough.",
-        },
-        pushNotificationConfig: {
-            ...PUSH_NOTIFICATION_CONFIG_SCHEMA,
-            description: "Optional MessageSendParams.configuration.pushNotificationConfig passthrough.",
+            minLength: 1,
+            description: "Optional MIME type.",
         },
+        metadata: ATTACHMENT_METADATA_SCHEMA,
     },
+    required: ["kind"],
+    anyOf: [{ required: ["uri"] }, { required: ["bytes"] }],
 };
-const MESSAGE_SCHEMA = {
+const DATA_ATTACHMENT_SCHEMA = {
     type: "object",
     additionalProperties: false,
     properties: {
-        kind: { type: "string", enum: ["message"] },
-        messageId: { type: "string", minLength: 1 },
-        role: { type: "string", enum: MESSAGE_ROLES },
-        parts: {
-            type: "array",
-            items: {
-                oneOf: [TEXT_PART_SCHEMA, FILE_PART_SCHEMA, DATA_PART_SCHEMA],
-            },
-        },
-        contextId: { type: "string", minLength: 1 },
-        taskId: { type: "string", minLength: 1 },
-        extensions: {
-            type: "array",
-            items: { type: "string" },
-        },
-        referenceTaskIds: {
-            type: "array",
-            items: { type: "string" },
-        },
-        metadata: {
+        kind: { type: "string", enum: ["data"] },
+        data: {
             type: "object",
             additionalProperties: true,
+            description: "Structured attachment payload.",
         },
+        metadata: ATTACHMENT_METADATA_SCHEMA,
     },
-    required: ["kind", "messageId", "role", "parts"],
+    required: ["kind", "data"],
 };
-export const DELEGATE_INPUT_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        target: TARGET_SCHEMA,
-        request: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-                message: {
-                    ...MESSAGE_SCHEMA,
-                    description: "A2A message payload passed as MessageSendParams.message.",
-                },
-                timeoutMs: {
-                    type: "integer",
-                    minimum: 1,
-                    description: "Optional timeout override for this operation.",
-                },
-                serviceParameters: {
-                    type: "object",
-                    additionalProperties: { type: "string" },
-                    description: "Optional service parameters for this operation.",
-                },
-                metadata: {
-                    type: "object",
-                    additionalProperties: true,
-                    description: "Optional MessageSendParams.metadata payload.",
-                },
-                configuration: {
-                    ...MESSAGE_SEND_CONFIGURATION_SCHEMA,
-                    description: "Optional MessageSendParams.configuration payload passed through unchanged.",
-                },
+const ACTION_ALLOWED_FIELDS = Object.freeze({
+    list_targets: new Set(["action"]),
+    send: new Set([
+        "action",
+        "target_alias",
+        "target_url",
+        "input",
+        "attachments",
+        "follow_updates",
+        "history_length",
+        "timeout_ms",
+        "service_parameters",
+        "metadata",
+    ]),
+    watch: new Set([
+        "action",
+        "target_alias",
+        "target_url",
+        "task_handle",
+        "task_id",
+        "timeout_ms",
+        "service_parameters",
+    ]),
+    status: new Set([
+        "action",
+        "target_alias",
+        "target_url",
+        "task_handle",
+        "task_id",
+        "history_length",
+        "timeout_ms",
+        "service_parameters",
+    ]),
+    cancel: new Set([
+        "action",
+        "target_alias",
+        "target_url",
+        "task_handle",
+        "task_id",
+        "timeout_ms",
+        "service_parameters",
+    ]),
+});
+function normalizeConfiguredBaseUrl(baseUrl, config) {
+    return config.policy.normalizeBaseUrl ? new URL(baseUrl).toString() : baseUrl;
+}
+function summarizeTargets(config) {
+    return {
+        aliases: config.targets.map((target) => target.alias),
+        configuredBaseUrls: new Set(config.targets.map((target) => normalizeConfiguredBaseUrl(target.baseUrl, config))),
+        hasDefaultTarget: config.targets.some((target) => target.default),
+    };
+}
+function configuredTargetSummaryText(config) {
+    const aliases = config.targets.map((target) => target.alias);
+    const defaultTarget = config.targets.find((target) => target.default);
+    if (aliases.length === 0) {
+        return config.policy.allowTargetUrlOverride
+            ? "No configured targets. Use target_url for explicit routing."
+            : "No configured targets. Add a default target or enable target_url overrides to route send/status/watch/cancel actions.";
+    }
+    const configured = `Configured targets: ${aliases.join(", ")}.`;
+    const defaultDescription = defaultTarget
+        ? ` Default target: ${defaultTarget.alias}.`
+        : " No default target is configured.";
+    const urlPolicy = config.policy.allowTargetUrlOverride
+        ? " Explicit target_url overrides are enabled."
+        : " Explicit target_url values must match configured targets.";
+    return `${configured}${defaultDescription}${urlPolicy}`;
+}
+function targetAliasSchema(config) {
+    const aliases = config.targets.map((target) => target.alias);
+    const defaultTarget = config.targets.find((target) => target.default);
+    return {
+        type: "string",
+        minLength: 1,
+        ...(aliases.length > 0 ? { enum: aliases } : {}),
+        description: defaultTarget
+            ? `Configured target alias. When omitted, the default target "${defaultTarget.alias}" is used when the action allows it.`
+            : "Configured target alias.",
+    };
+}
+export function buildRemoteAgentParametersSchema(config) {
+    return {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            action: {
+                type: "string",
+                enum: REMOTE_AGENT_ACTIONS,
+                description: "Action to perform: list_targets, send, watch, status, or cancel.",
             },
-            required: ["message"],
-        },
-    },
-    required: ["target", "request"],
-};
-export const STATUS_INPUT_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        target: TARGET_SCHEMA,
-        request: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-                taskId: {
-                    type: "string",
-                    minLength: 1,
-                    description: "Remote task id to query.",
-                },
-                historyLength: {
-                    type: "integer",
-                    minimum: 0,
-                    description: "Optional history window length.",
-                },
-                timeoutMs: {
-                    type: "integer",
-                    minimum: 1,
-                    description: "Optional timeout override for this operation.",
-                },
-                serviceParameters: {
-                    type: "object",
-                    additionalProperties: { type: "string" },
-                    description: "Optional service parameters for this operation.",
-                },
+            target_alias: targetAliasSchema(config),
+            target_url: {
+                type: "string",
+                minLength: 1,
+                format: "uri",
+                pattern: "^https?://",
+                description: "Explicit remote target base URL. When target URL overrides are disabled, the URL must match a configured target.",
             },
-            required: ["taskId"],
-        },
-    },
-    required: ["target", "request"],
-};
-export const CANCEL_INPUT_SCHEMA = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        target: TARGET_SCHEMA,
-        request: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-                taskId: {
-                    type: "string",
-                    minLength: 1,
-                    description: "Remote task id to cancel.",
-                },
-                timeoutMs: {
-                    type: "integer",
-                    minimum: 1,
-                    description: "Optional timeout override for this operation.",
-                },
-                serviceParameters: {
-                    type: "object",
-                    additionalProperties: { type: "string" },
-                    description: "Optional service parameters for this operation.",
+            input: {
+                type: "string",
+                minLength: 1,
+                description: "User text input for action=send. This becomes the single user text part.",
+            },
+            attachments: {
+                type: "array",
+                description: "Optional file/data attachments for action=send. Inline text attachments are not supported in phase 4; use input instead.",
+                items: {
+                    oneOf: [FILE_ATTACHMENT_SCHEMA, DATA_ATTACHMENT_SCHEMA],
                 },
             },
-            required: ["taskId"],
+            task_handle: TASK_HANDLE_SCHEMA,
+            task_id: {
+                type: "string",
+                minLength: 1,
+                description: "Remote task id for watch/status/cancel when no task_handle is available.",
+            },
+            follow_updates: {
+                type: "boolean",
+                description: "When true, action=send streams updates and returns the full event log.",
+            },
+            history_length: {
+                type: "integer",
+                minimum: 0,
+                description: "Optional history window for action=send and action=status.",
+            },
+            timeout_ms: {
+                type: "integer",
+                minimum: 1,
+                description: "Optional timeout override for the remote request.",
+            },
+            service_parameters: {
+                type: "object",
+                additionalProperties: { type: "string" },
+                description: "Optional request service parameters.",
+            },
+            metadata: {
+                type: "object",
+                additionalProperties: true,
+                description: "Optional metadata payload for action=send.",
+            },
         },
-    },
-    required: ["target", "request"],
-};
-export const TOOL_DEFINITIONS = {
-    a2a_delegate: {
-        name: "a2a_delegate",
-        label: "A2A Delegate",
-        description: "Delegate a request to an external A2A agent.",
-        parameters: DELEGATE_INPUT_SCHEMA,
-    },
-    a2a_task_status: {
-        name: "a2a_task_status",
-        label: "A2A Task Status",
-        description: "Fetch status for an external A2A task.",
-        parameters: STATUS_INPUT_SCHEMA,
-    },
-    a2a_task_cancel: {
-        name: "a2a_task_cancel",
-        label: "A2A Task Cancel",
-        description: "Request cancellation for an external A2A task.",
-        parameters: CANCEL_INPUT_SCHEMA,
-    },
-};
-const ajv = createA2AOutboundAjv();
-const validateDelegateSchema = ajv.compile(DELEGATE_INPUT_SCHEMA);
-const validateStatusSchema = ajv.compile(STATUS_INPUT_SCHEMA);
-const validateCancelSchema = ajv.compile(CANCEL_INPUT_SCHEMA);
-export function validateDelegateInput(input) {
-    if (!validateDelegateSchema(input)) {
-        toValidationError("a2a_delegate", [...validateDelegateSchema.errors]);
+        required: ["action"],
+    };
+}
+export function buildRemoteAgentToolDefinition(config) {
+    return {
+        name: REMOTE_AGENT_TOOL_NAME,
+        label: "Remote Agent",
+        description: `Route requests to remote A2A agents and manage delegated tasks. ${configuredTargetSummaryText(config)}`,
+        parameters: buildRemoteAgentParametersSchema(config),
+    };
+}
+function makeError(instancePath, keyword, message, params = {}) {
+    return {
+        instancePath,
+        schemaPath: `#/runtime/${keyword}`,
+        keyword,
+        params,
+        message,
+    };
+}
+function disallowedFieldErrors(action, input) {
+    const allowedFields = ACTION_ALLOWED_FIELDS[action];
+    const errors = [];
+    for (const property of Object.keys(input)) {
+        if (!allowedFields.has(property)) {
+            errors.push(makeError("", "not", `"${property}" is not supported for action=${action}`, {
+                property,
+                action,
+            }));
+        }
     }
-    return input;
+    return errors;
 }
-export function validateStatusInput(input) {
-    if (!validateStatusSchema(input)) {
-        toValidationError("a2a_task_status", [...validateStatusSchema.errors]);
+function validateExplicitTargetFields(input, summary, config) {
+    const errors = [];
+    if (input.target_alias !== undefined && !summary.aliases.includes(input.target_alias)) {
+        errors.push(makeError("/target_alias", "enum", "must match a configured target alias", {
+            allowedValues: summary.aliases,
+        }));
+    }
+    if (input.target_url !== undefined) {
+        const normalized = normalizeConfiguredBaseUrl(input.target_url, config);
+        const isResolvable = config.policy.allowTargetUrlOverride ||
+            summary.configuredBaseUrls.has(normalized);
+        if (!isResolvable) {
+            errors.push(makeError("/target_url", "anyOf", "must resolve to a configured target or be allowed by policy", {
+                allowTargetUrlOverride: config.policy.allowTargetUrlOverride,
+                configuredTargetAliases: summary.aliases,
+            }));
+        }
     }
-    return input;
+    return errors;
 }
-export function validateCancelInput(input) {
-    if (!validateCancelSchema(input)) {
-        toValidationError("a2a_task_cancel", [...validateCancelSchema.errors]);
+function validateSendInput(input, summary, config) {
+    const errors = validateExplicitTargetFields(input, summary, config);
+    if (input.input === undefined) {
+        errors.push(makeError("", "required", "send requires input", {
+            missingProperty: "input",
+        }));
     }
-    return input;
+    const hasExplicitTarget = input.target_alias !== undefined || input.target_url !== undefined;
+    if (!hasExplicitTarget && !summary.hasDefaultTarget) {
+        errors.push(makeError("", "anyOf", "send requires target_alias, target_url, or a configured default target"));
+    }
+    return errors;
 }
+function validateFollowUpInput(input, summary, config) {
+    const errors = validateExplicitTargetFields(input, summary, config);
+    const hasTaskHandle = input.task_handle !== undefined;
+    const hasTaskId = input.task_id !== undefined;
+    if (!hasTaskHandle && !hasTaskId) {
+        errors.push(makeError("", "anyOf", `${input.action} requires task_handle or task_id`));
+    }
+    if (!hasTaskHandle &&
+        hasTaskId &&
+        input.target_alias === undefined &&
+        input.target_url === undefined &&
+        !summary.hasDefaultTarget) {
+        errors.push(makeError("", "anyOf", `${input.action} requires target_alias, target_url, or a configured default target when task_id is used without task_handle`));
+    }
+    return errors;
+}
+function validateActionSpecificRules(input, summary, config) {
+    const recordInput = input;
+    const errors = disallowedFieldErrors(input.action, recordInput);
+    switch (input.action) {
+        case "list_targets":
+            return errors;
+        case "send":
+            return [...errors, ...validateSendInput(input, summary, config)];
+        case "watch":
+        case "status":
+        case "cancel":
+            return [...errors, ...validateFollowUpInput(input, summary, config)];
+    }
+}
+export function createRemoteAgentInputValidator(config) {
+    const ajv = createA2AOutboundAjv();
+    const schema = buildRemoteAgentParametersSchema(config);
+    const validateSchema = ajv.compile(schema);
+    const targetSummary = summarizeTargets(config);
+    return (input) => {
+        if (!validateSchema(input)) {
+            toValidationError(REMOTE_AGENT_TOOL_NAME, [...validateSchema.errors]);
+        }
+        const validated = input;
+        const customErrors = validateActionSpecificRules(validated, targetSummary, config);
+        if (customErrors.length > 0) {
+            toValidationError(REMOTE_AGENT_TOOL_NAME, customErrors);
+        }
+        return validated;
+    };
+}
+export const PUBLIC_TARGET_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        baseUrl: {
+            type: "string",
+            minLength: 1,
+            format: "uri",
+            pattern: "^https?://",
+            description: "Target agent base URL.",
+        },
+        cardPath: {
+            type: "string",
+            minLength: 1,
+            description: "Optional override for the target agent-card path. Defaults from plugin config when omitted.",
+        },
+        preferredTransports: {
+            type: "array",
+            items: {
+                type: "string",
+                enum: ALL_TRANSPORTS,
+            },
+            description: "Optional transport preference override for this call. Defaults from plugin config when omitted.",
+        },
+    },
+    required: ["baseUrl"],
+};
 //# sourceMappingURL=schemas.js.map