@envarai/envarpay 0.2.0-alpha.9 → 2026.1027.1

package/node_modules/@a2a-js/sdk/dist/compat/v0_3/server/express/index.cjs

@@ -0,0 +1,3891 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/compat/v0_3/server/express/index.ts
+var express_exports = {};
+__export(express_exports, {
+  legacyAgentCardRouter: () => legacyAgentCardRouter,
+  legacyRestRouter: () => legacyRestRouter
+});
+module.exports = __toCommonJS(express_exports);
+
+// src/compat/v0_3/server/express/agent_card_handler.ts
+var import_crypto = __toESM(require("crypto"), 1);
+var import_express = __toESM(require("express"), 1);
+
+// src/constants.ts
+var HTTP_EXTENSION_HEADER = "A2A-Extensions";
+var A2A_VERSION_HEADER = "A2A-Version";
+var A2A_PROTOCOL_VERSION = "1.0";
+var A2A_LEGACY_PROTOCOL_VERSION = "0.3";
+
+// src/errors/base.ts
+var A2A_ERROR_DOMAIN = "a2a-protocol.org";
+var ERROR_INFO_TYPE = "type.googleapis.com/google.rpc.ErrorInfo";
+var A2A_ERROR_BRAND = /* @__PURE__ */ Symbol.for("@a2a-js/sdk.A2AError");
+var A2AError = class _A2AError extends Error {
+  /** UPPER_SNAKE_CASE reason from `google.rpc.ErrorInfo` (§10.6 / §11.6). */
+  reason = "INTERNAL_ERROR";
+  /** Optional `google.rpc.ErrorInfo.metadata`. */
+  metadata;
+  /**
+   * Makes `instanceof` immune to this module being duplicated across
+   * entry-point bundles: the brand stands in for constructor identity.
+   *
+   * Inherited by every subclass, so `err instanceof TaskNotFoundError`
+   * stays exact — subclasses are matched by name up the prototype
+   * chain, the same identity `error.name` and the registry tables below
+   * already key on. Their names come from the runtime strings in
+   * `specs`, so a bundler cannot rename them; the base class, whose
+   * name *is* a renameable binding, is answered by the brand alone.
+   */
+  static [Symbol.hasInstance](value) {
+    if (typeof value !== "object" || value === null || !(A2A_ERROR_BRAND in value)) return false;
+    if (this === _A2AError) return true;
+    for (let proto = Object.getPrototypeOf(value); proto !== null; proto = Object.getPrototypeOf(proto)) {
+      if (proto.constructor?.name === this.name) {
+        return true;
+      }
+    }
+    return false;
+  }
+  constructor(options) {
+    const opts = typeof options === "string" ? { message: options } : options;
+    super(
+      opts?.message ?? "An unexpected error occurred.",
+      opts?.cause !== void 0 ? { cause: opts.cause } : void 0
+    );
+    this.name = new.target.name;
+    if (opts?.metadata && Object.keys(opts.metadata).length > 0) {
+      this.metadata = opts.metadata;
+    }
+  }
+  /** Builds `google.rpc.ErrorInfo` from this error. */
+  toErrorInfo() {
+    return {
+      "@type": ERROR_INFO_TYPE,
+      reason: this.reason,
+      domain: A2A_ERROR_DOMAIN,
+      ...this.metadata ? { metadata: this.metadata } : {}
+    };
+  }
+};
+Object.defineProperty(A2AError.prototype, A2A_ERROR_BRAND, { value: true });
+var specs = [
+  { name: "TaskNotFoundError", reason: "TASK_NOT_FOUND", defaultMessage: "Task not found" },
+  {
+    name: "TaskNotCancelableError",
+    reason: "TASK_NOT_CANCELABLE",
+    defaultMessage: "Task cannot be canceled"
+  },
+  {
+    name: "PushNotificationNotSupportedError",
+    reason: "PUSH_NOTIFICATION_NOT_SUPPORTED",
+    defaultMessage: "Push Notification is not supported"
+  },
+  {
+    name: "UnsupportedOperationError",
+    reason: "UNSUPPORTED_OPERATION",
+    defaultMessage: "This operation is not supported"
+  },
+  {
+    name: "ContentTypeNotSupportedError",
+    reason: "CONTENT_TYPE_NOT_SUPPORTED",
+    defaultMessage: "Incompatible content types"
+  },
+  {
+    name: "InvalidAgentResponseError",
+    reason: "INVALID_AGENT_RESPONSE",
+    defaultMessage: "Invalid agent response type"
+  },
+  {
+    name: "ExtendedAgentCardNotConfiguredError",
+    reason: "EXTENDED_AGENT_CARD_NOT_CONFIGURED",
+    defaultMessage: "Extended Agent Card not configured"
+  },
+  {
+    name: "ExtensionSupportRequiredError",
+    reason: "EXTENSION_SUPPORT_REQUIRED",
+    defaultMessage: "Extension support required"
+  },
+  {
+    name: "VersionNotSupportedError",
+    reason: "VERSION_NOT_SUPPORTED",
+    defaultMessage: "Version not supported"
+  },
+  {
+    name: "RequestMalformedError",
+    reason: "INVALID_PARAMS",
+    defaultMessage: "Request malformed"
+  }
+];
+var A2A_ERROR_SPECS = Object.freeze(
+  Object.fromEntries(specs.map((s) => [s.name, s]))
+);
+var A2A_ERROR_SPECS_BY_REASON = Object.freeze(
+  Object.fromEntries(specs.map((s) => [s.reason, s]))
+);
+function makeSemantic(spec) {
+  const cls = {
+    [spec.name]: class extends A2AError {
+      reason = spec.reason;
+      constructor(options) {
+        if (options === void 0) super({ message: spec.defaultMessage });
+        else if (typeof options === "string") super({ message: options });
+        else super({ message: spec.defaultMessage, ...options });
+      }
+    }
+  }[spec.name];
+  return cls;
+}
+var TaskNotFoundError = makeSemantic(A2A_ERROR_SPECS.TaskNotFoundError);
+var TaskNotCancelableError = makeSemantic(A2A_ERROR_SPECS.TaskNotCancelableError);
+var PushNotificationNotSupportedError = makeSemantic(
+  A2A_ERROR_SPECS.PushNotificationNotSupportedError
+);
+var UnsupportedOperationError = makeSemantic(A2A_ERROR_SPECS.UnsupportedOperationError);
+var ContentTypeNotSupportedError = makeSemantic(
+  A2A_ERROR_SPECS.ContentTypeNotSupportedError
+);
+var InvalidAgentResponseError = makeSemantic(A2A_ERROR_SPECS.InvalidAgentResponseError);
+var ExtendedAgentCardNotConfiguredError = makeSemantic(
+  A2A_ERROR_SPECS.ExtendedAgentCardNotConfiguredError
+);
+var ExtensionSupportRequiredError = makeSemantic(
+  A2A_ERROR_SPECS.ExtensionSupportRequiredError
+);
+var VersionNotSupportedError = makeSemantic(A2A_ERROR_SPECS.VersionNotSupportedError);
+var RequestMalformedError = makeSemantic(A2A_ERROR_SPECS.RequestMalformedError);
+var A2A_ERROR_CLASSES = Object.freeze({
+  TaskNotFoundError,
+  TaskNotCancelableError,
+  PushNotificationNotSupportedError,
+  UnsupportedOperationError,
+  ContentTypeNotSupportedError,
+  InvalidAgentResponseError,
+  ExtendedAgentCardNotConfiguredError,
+  ExtensionSupportRequiredError,
+  VersionNotSupportedError,
+  RequestMalformedError
+});
+
+// src/errors/rest.ts
+var HTTP_STATUS = {
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  NOT_FOUND: 404,
+  CONFLICT: 409,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501
+};
+var REST_STATUS_NAME = {
+  OK: "OK",
+  CANCELLED: "CANCELLED",
+  UNKNOWN: "UNKNOWN",
+  INVALID_ARGUMENT: "INVALID_ARGUMENT",
+  DEADLINE_EXCEEDED: "DEADLINE_EXCEEDED",
+  NOT_FOUND: "NOT_FOUND",
+  ALREADY_EXISTS: "ALREADY_EXISTS",
+  PERMISSION_DENIED: "PERMISSION_DENIED",
+  RESOURCE_EXHAUSTED: "RESOURCE_EXHAUSTED",
+  FAILED_PRECONDITION: "FAILED_PRECONDITION",
+  ABORTED: "ABORTED",
+  OUT_OF_RANGE: "OUT_OF_RANGE",
+  UNIMPLEMENTED: "UNIMPLEMENTED",
+  INTERNAL: "INTERNAL",
+  UNAVAILABLE: "UNAVAILABLE",
+  DATA_LOSS: "DATA_LOSS",
+  UNAUTHENTICATED: "UNAUTHENTICATED"
+};
+var REST_ERROR_HTTP_STATUS = Object.freeze({
+  TaskNotFoundError: HTTP_STATUS.NOT_FOUND,
+  TaskNotCancelableError: HTTP_STATUS.BAD_REQUEST,
+  PushNotificationNotSupportedError: HTTP_STATUS.BAD_REQUEST,
+  UnsupportedOperationError: HTTP_STATUS.BAD_REQUEST,
+  ContentTypeNotSupportedError: HTTP_STATUS.BAD_REQUEST,
+  InvalidAgentResponseError: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+  ExtendedAgentCardNotConfiguredError: HTTP_STATUS.BAD_REQUEST,
+  ExtensionSupportRequiredError: HTTP_STATUS.BAD_REQUEST,
+  VersionNotSupportedError: HTTP_STATUS.BAD_REQUEST,
+  RequestMalformedError: HTTP_STATUS.BAD_REQUEST
+});
+var REST_ERROR_STATUS_NAME = Object.freeze({
+  TaskNotFoundError: REST_STATUS_NAME.NOT_FOUND,
+  TaskNotCancelableError: REST_STATUS_NAME.FAILED_PRECONDITION,
+  PushNotificationNotSupportedError: REST_STATUS_NAME.FAILED_PRECONDITION,
+  UnsupportedOperationError: REST_STATUS_NAME.FAILED_PRECONDITION,
+  ContentTypeNotSupportedError: REST_STATUS_NAME.INVALID_ARGUMENT,
+  InvalidAgentResponseError: REST_STATUS_NAME.INTERNAL,
+  ExtendedAgentCardNotConfiguredError: REST_STATUS_NAME.FAILED_PRECONDITION,
+  ExtensionSupportRequiredError: REST_STATUS_NAME.FAILED_PRECONDITION,
+  VersionNotSupportedError: REST_STATUS_NAME.FAILED_PRECONDITION,
+  RequestMalformedError: REST_STATUS_NAME.INVALID_ARGUMENT
+});
+function isRestError(err) {
+  return err instanceof A2AError && err.transport === "rest";
+}
+function makeRest(name) {
+  const Base = A2A_ERROR_CLASSES[name];
+  const defaultStatus = REST_ERROR_HTTP_STATUS[name] ?? HTTP_STATUS.INTERNAL_SERVER_ERROR;
+  const cls = {
+    [`Rest${name}`]: class extends Base {
+      transport = "rest";
+      statusCode;
+      headers;
+      constructor(options) {
+        super(options);
+        this.name = name;
+        this.statusCode = options?.statusCode ?? defaultStatus;
+        if (options?.headers) this.headers = options.headers;
+      }
+    }
+  }[`Rest${name}`];
+  return cls;
+}
+var RestTaskNotFoundError = makeRest("TaskNotFoundError");
+var RestTaskNotCancelableError = makeRest("TaskNotCancelableError");
+var RestPushNotificationNotSupportedError = makeRest("PushNotificationNotSupportedError");
+var RestUnsupportedOperationError = makeRest("UnsupportedOperationError");
+var RestContentTypeNotSupportedError = makeRest("ContentTypeNotSupportedError");
+var RestInvalidAgentResponseError = makeRest("InvalidAgentResponseError");
+var RestExtendedAgentCardNotConfiguredError = makeRest(
+  "ExtendedAgentCardNotConfiguredError"
+);
+var RestExtensionSupportRequiredError = makeRest("ExtensionSupportRequiredError");
+var RestVersionNotSupportedError = makeRest("VersionNotSupportedError");
+var RestRequestMalformedError = makeRest("RequestMalformedError");
+var REST_ERROR_CLASSES = Object.freeze({
+  TaskNotFoundError: RestTaskNotFoundError,
+  TaskNotCancelableError: RestTaskNotCancelableError,
+  PushNotificationNotSupportedError: RestPushNotificationNotSupportedError,
+  UnsupportedOperationError: RestUnsupportedOperationError,
+  ContentTypeNotSupportedError: RestContentTypeNotSupportedError,
+  InvalidAgentResponseError: RestInvalidAgentResponseError,
+  ExtendedAgentCardNotConfiguredError: RestExtendedAgentCardNotConfiguredError,
+  ExtensionSupportRequiredError: RestExtensionSupportRequiredError,
+  VersionNotSupportedError: RestVersionNotSupportedError,
+  RequestMalformedError: RestRequestMalformedError
+});
+function restStatusFor(error) {
+  if (isRestError(error)) return error.statusCode;
+  if (error instanceof A2AError) return REST_ERROR_HTTP_STATUS[error.name] ?? 500;
+  return HTTP_STATUS.INTERNAL_SERVER_ERROR;
+}
+
+// src/errors/json_rpc.ts
+var A2A_ERROR_CODE = {
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  TASK_NOT_FOUND: -32001,
+  TASK_NOT_CANCELABLE: -32002,
+  PUSH_NOTIFICATION_NOT_SUPPORTED: -32003,
+  UNSUPPORTED_OPERATION: -32004,
+  CONTENT_TYPE_NOT_SUPPORTED: -32005,
+  INVALID_AGENT_RESPONSE: -32006,
+  EXTENDED_CARD_NOT_CONFIGURED: -32007,
+  EXTENSION_SUPPORT_REQUIRED: -32008,
+  VERSION_NOT_SUPPORTED: -32009
+};
+var JSON_RPC_ERROR_CODE = Object.freeze({
+  TaskNotFoundError: A2A_ERROR_CODE.TASK_NOT_FOUND,
+  TaskNotCancelableError: A2A_ERROR_CODE.TASK_NOT_CANCELABLE,
+  PushNotificationNotSupportedError: A2A_ERROR_CODE.PUSH_NOTIFICATION_NOT_SUPPORTED,
+  UnsupportedOperationError: A2A_ERROR_CODE.UNSUPPORTED_OPERATION,
+  ContentTypeNotSupportedError: A2A_ERROR_CODE.CONTENT_TYPE_NOT_SUPPORTED,
+  InvalidAgentResponseError: A2A_ERROR_CODE.INVALID_AGENT_RESPONSE,
+  ExtendedAgentCardNotConfiguredError: A2A_ERROR_CODE.EXTENDED_CARD_NOT_CONFIGURED,
+  ExtensionSupportRequiredError: A2A_ERROR_CODE.EXTENSION_SUPPORT_REQUIRED,
+  VersionNotSupportedError: A2A_ERROR_CODE.VERSION_NOT_SUPPORTED,
+  RequestMalformedError: A2A_ERROR_CODE.INVALID_PARAMS
+});
+var JSON_RPC_CODE_TO_ERROR = Object.freeze(
+  Object.fromEntries(Object.entries(JSON_RPC_ERROR_CODE).map(([name, code]) => [code, name]))
+);
+function isJsonRpcError(err) {
+  return err instanceof A2AError && err.transport === "jsonrpc";
+}
+function makeJsonRpc(name) {
+  const Base = A2A_ERROR_CLASSES[name];
+  const defaultCode = JSON_RPC_ERROR_CODE[name] ?? A2A_ERROR_CODE.INTERNAL_ERROR;
+  const cls = {
+    [`JsonRpc${name}`]: class extends Base {
+      transport = "jsonrpc";
+      envelopeCode;
+      data;
+      constructor(options) {
+        super(options);
+        this.name = name;
+        this.envelopeCode = options?.envelopeCode ?? defaultCode;
+        if (options?.data !== void 0) this.data = options.data;
+      }
+    }
+  }[`JsonRpc${name}`];
+  return cls;
+}
+var JsonRpcTaskNotFoundError = makeJsonRpc("TaskNotFoundError");
+var JsonRpcTaskNotCancelableError = makeJsonRpc("TaskNotCancelableError");
+var JsonRpcPushNotificationNotSupportedError = makeJsonRpc(
+  "PushNotificationNotSupportedError"
+);
+var JsonRpcUnsupportedOperationError = makeJsonRpc("UnsupportedOperationError");
+var JsonRpcContentTypeNotSupportedError = makeJsonRpc("ContentTypeNotSupportedError");
+var JsonRpcInvalidAgentResponseError = makeJsonRpc("InvalidAgentResponseError");
+var JsonRpcExtendedAgentCardNotConfiguredError = makeJsonRpc(
+  "ExtendedAgentCardNotConfiguredError"
+);
+var JsonRpcExtensionSupportRequiredError = makeJsonRpc("ExtensionSupportRequiredError");
+var JsonRpcVersionNotSupportedError = makeJsonRpc("VersionNotSupportedError");
+var JsonRpcRequestMalformedError = makeJsonRpc("RequestMalformedError");
+var JSON_RPC_ERROR_CLASSES = Object.freeze({
+  TaskNotFoundError: JsonRpcTaskNotFoundError,
+  TaskNotCancelableError: JsonRpcTaskNotCancelableError,
+  PushNotificationNotSupportedError: JsonRpcPushNotificationNotSupportedError,
+  UnsupportedOperationError: JsonRpcUnsupportedOperationError,
+  ContentTypeNotSupportedError: JsonRpcContentTypeNotSupportedError,
+  InvalidAgentResponseError: JsonRpcInvalidAgentResponseError,
+  ExtendedAgentCardNotConfiguredError: JsonRpcExtendedAgentCardNotConfiguredError,
+  ExtensionSupportRequiredError: JsonRpcExtensionSupportRequiredError,
+  VersionNotSupportedError: JsonRpcVersionNotSupportedError,
+  RequestMalformedError: JsonRpcRequestMalformedError
+});
+var JsonRpcTransportError = class extends A2AError {
+  transport = "jsonrpc";
+  envelopeCode;
+  data;
+  errorResponse;
+  constructor(envelope) {
+    super({ message: envelope.error.message });
+    this.name = "JsonRpcTransportError";
+    this.envelopeCode = envelope.error.code;
+    if (envelope.error.data !== void 0) this.data = envelope.error.data;
+    this.errorResponse = envelope;
+  }
+};
+var RESERVED_CODE_TO_SEMANTIC = {
+  [A2A_ERROR_CODE.PARSE_ERROR]: "RequestMalformedError",
+  [A2A_ERROR_CODE.INVALID_REQUEST]: "RequestMalformedError",
+  [A2A_ERROR_CODE.METHOD_NOT_FOUND]: "RequestMalformedError"
+};
+
+// src/compat/v0_3/server/error.ts
+function makeA2AError(code, message, data) {
+  const name = JSON_RPC_CODE_TO_ERROR[code];
+  if (name) {
+    return data === void 0 ? new A2A_ERROR_CLASSES[name]({ message }) : new JSON_RPC_ERROR_CLASSES[name]({ message, envelopeCode: code, data });
+  }
+  if (code === A2A_ERROR_CODE.METHOD_NOT_FOUND) {
+    return new JsonRpcUnsupportedOperationError({
+      message,
+      envelopeCode: code,
+      data
+    });
+  }
+  if (code === A2A_ERROR_CODE.PARSE_ERROR || code === A2A_ERROR_CODE.INVALID_REQUEST) {
+    return new JsonRpcRequestMalformedError({
+      message,
+      envelopeCode: code,
+      data
+    });
+  }
+  return new JsonRpcTransportError({
+    jsonrpc: "2.0",
+    id: null,
+    error: { code, message, data }
+  });
+}
+var A2AError2 = makeA2AError;
+Object.defineProperty(A2AError2, Symbol.hasInstance, {
+  value: (v) => v instanceof A2AError
+});
+A2AError2.parseError = (message, data) => new JsonRpcRequestMalformedError({
+  message,
+  envelopeCode: A2A_ERROR_CODE.PARSE_ERROR,
+  data
+});
+A2AError2.invalidRequest = (message, data) => new JsonRpcRequestMalformedError({
+  message,
+  envelopeCode: A2A_ERROR_CODE.INVALID_REQUEST,
+  data
+});
+A2AError2.methodNotFound = (method) => new JsonRpcUnsupportedOperationError({
+  message: `Method not found: ${method}`,
+  envelopeCode: A2A_ERROR_CODE.METHOD_NOT_FOUND
+});
+A2AError2.invalidParams = (message, data) => data === void 0 ? new RequestMalformedError({ message }) : new JsonRpcRequestMalformedError({
+  message,
+  envelopeCode: A2A_ERROR_CODE.INVALID_PARAMS,
+  data
+});
+A2AError2.internalError = (message, data) => new JsonRpcTransportError({
+  jsonrpc: "2.0",
+  id: null,
+  error: {
+    code: A2A_ERROR_CODE.INTERNAL_ERROR,
+    message,
+    ...data !== void 0 ? { data } : {}
+  }
+});
+A2AError2.taskNotFound = (taskId) => new TaskNotFoundError({ message: `Task not found: ${taskId}` });
+A2AError2.taskNotCancelable = (taskId) => new TaskNotCancelableError({ message: `Task not cancelable: ${taskId}` });
+A2AError2.pushNotificationNotSupported = () => new PushNotificationNotSupportedError();
+A2AError2.unsupportedOperation = (operation) => new UnsupportedOperationError({ message: `Unsupported operation: ${operation}` });
+A2AError2.authenticatedExtendedCardNotConfigured = () => new ExtendedAgentCardNotConfiguredError({ message: "Extended card not configured." });
+
+// src/compat/v0_3/constants.ts
+var LEGACY_HTTP_EXTENSION_HEADER = "X-A2A-Extensions";
+var LEGACY_JSON_CONTENT_TYPE = "application/json";
+var LEGACY_METHOD_MESSAGE_SEND = "message/send";
+var LEGACY_METHOD_MESSAGE_STREAM = "message/stream";
+var LEGACY_METHOD_TASKS_GET = "tasks/get";
+var LEGACY_METHOD_TASKS_CANCEL = "tasks/cancel";
+var LEGACY_METHOD_TASKS_RESUBSCRIBE = "tasks/resubscribe";
+var LEGACY_METHOD_PUSH_NOTIFICATION_CONFIG_SET = "tasks/pushNotificationConfig/set";
+var LEGACY_METHOD_PUSH_NOTIFICATION_CONFIG_GET = "tasks/pushNotificationConfig/get";
+var LEGACY_METHOD_PUSH_NOTIFICATION_CONFIG_LIST = "tasks/pushNotificationConfig/list";
+var LEGACY_METHOD_PUSH_NOTIFICATION_CONFIG_DELETE = "tasks/pushNotificationConfig/delete";
+var LEGACY_METHOD_GET_AUTHENTICATED_EXTENDED_CARD = "agent/getAuthenticatedExtendedCard";
+var LEGACY_JSONRPC_TO_V1 = Object.freeze({
+  [LEGACY_METHOD_MESSAGE_SEND]: "SendMessage",
+  [LEGACY_METHOD_MESSAGE_STREAM]: "SendStreamingMessage",
+  [LEGACY_METHOD_TASKS_GET]: "GetTask",
+  [LEGACY_METHOD_TASKS_CANCEL]: "CancelTask",
+  [LEGACY_METHOD_TASKS_RESUBSCRIBE]: "SubscribeToTask",
+  [LEGACY_METHOD_PUSH_NOTIFICATION_CONFIG_SET]: "CreateTaskPushNotificationConfig",
+  [LEGACY_METHOD_PUSH_NOTIFICATION_CONFIG_GET]: "GetTaskPushNotificationConfig",
+  [LEGACY_METHOD_PUSH_NOTIFICATION_CONFIG_LIST]: "ListTaskPushNotificationConfigs",
+  [LEGACY_METHOD_PUSH_NOTIFICATION_CONFIG_DELETE]: "DeleteTaskPushNotificationConfig",
+  [LEGACY_METHOD_GET_AUTHENTICATED_EXTENDED_CARD]: "GetExtendedAgentCard"
+});
+var V1_TO_LEGACY_JSONRPC = Object.freeze(
+  Object.fromEntries(Object.entries(LEGACY_JSONRPC_TO_V1).map(([k, v]) => [v, k]))
+);
+var LEGACY_JSONRPC_TO_LEGACY_GRPC = Object.freeze({
+  [LEGACY_METHOD_MESSAGE_SEND]: "SendMessage",
+  [LEGACY_METHOD_MESSAGE_STREAM]: "SendStreamingMessage",
+  [LEGACY_METHOD_TASKS_GET]: "GetTask",
+  [LEGACY_METHOD_TASKS_CANCEL]: "CancelTask",
+  [LEGACY_METHOD_TASKS_RESUBSCRIBE]: "TaskSubscription",
+  [LEGACY_METHOD_PUSH_NOTIFICATION_CONFIG_SET]: "CreateTaskPushNotificationConfig",
+  [LEGACY_METHOD_PUSH_NOTIFICATION_CONFIG_GET]: "GetTaskPushNotificationConfig",
+  [LEGACY_METHOD_PUSH_NOTIFICATION_CONFIG_LIST]: "ListTaskPushNotificationConfig",
+  [LEGACY_METHOD_PUSH_NOTIFICATION_CONFIG_DELETE]: "DeleteTaskPushNotificationConfig",
+  [LEGACY_METHOD_GET_AUTHENTICATED_EXTENDED_CARD]: "GetAgentCard"
+});
+var LEGACY_GRPC_TO_LEGACY_JSONRPC = Object.freeze(
+  Object.fromEntries(Object.entries(LEGACY_JSONRPC_TO_LEGACY_GRPC).map(([k, v]) => [v, k]))
+);
+var LEGACY_GRPC_TO_V1 = Object.freeze(
+  Object.fromEntries(
+    Object.entries(LEGACY_JSONRPC_TO_LEGACY_GRPC).map(([jsonRpc, grpc]) => [
+      grpc,
+      LEGACY_JSONRPC_TO_V1[jsonRpc]
+    ])
+  )
+);
+var V1_TO_LEGACY_GRPC = Object.freeze(
+  Object.fromEntries(Object.entries(LEGACY_GRPC_TO_V1).map(([k, v]) => [v, k]))
+);
+
+// src/version_utils.ts
+var PROTOCOL_VERSION_0_3 = A2A_LEGACY_PROTOCOL_VERSION;
+var PROTOCOL_VERSION_1_0 = A2A_PROTOCOL_VERSION;
+function parseVersion(version) {
+  const trimmed = version.trim();
+  if (trimmed === "") return void 0;
+  const segments = trimmed.split(".");
+  if (segments.length === 0) return void 0;
+  const major = Number.parseInt(segments[0], 10);
+  if (!Number.isFinite(major) || major < 0) return void 0;
+  const minorRaw = segments[1];
+  const minor = minorRaw === void 0 ? 0 : Number.parseInt(minorRaw, 10);
+  if (!Number.isFinite(minor) || minor < 0) return void 0;
+  return { major, minor };
+}
+function compareVersions(a, b) {
+  if (a.major !== b.major) return a.major - b.major;
+  return a.minor - b.minor;
+}
+function isLegacyVersion(version) {
+  if (!version || version.trim() === "") return true;
+  const v = parseVersion(version);
+  if (!v) return false;
+  const lower = parseVersion(PROTOCOL_VERSION_0_3);
+  const upper = parseVersion(PROTOCOL_VERSION_1_0);
+  if (!lower || !upper) return false;
+  return compareVersions(v, lower) >= 0 && compareVersions(v, upper) < 0;
+}
+
+// src/compat/v0_3/translate/security.ts
+function nonEmpty(value) {
+  return value !== void 0 && value !== "" ? value : void 0;
+}
+function toCompatSecurityRequirement(core) {
+  return Object.fromEntries(
+    Object.entries(core.schemes).map(([scheme, stringList]) => [scheme, [...stringList.list]])
+  );
+}
+function buildCompatApiKey(core) {
+  const result = {
+    type: "apiKey",
+    name: core.name,
+    // v1.0 widens `location` to a free-form string; narrow to the v0.3
+    // union, defaulting unknown values to `'header'` (OpenAPI default).
+    in: core.location === "cookie" || core.location === "query" ? core.location : "header"
+  };
+  const description = nonEmpty(core.description);
+  if (description !== void 0) result.description = description;
+  return result;
+}
+function buildCompatHttp(core) {
+  const result = { type: "http", scheme: core.scheme };
+  const description = nonEmpty(core.description);
+  if (description !== void 0) result.description = description;
+  const bearerFormat = nonEmpty(core.bearerFormat);
+  if (bearerFormat !== void 0) result.bearerFormat = bearerFormat;
+  return result;
+}
+function buildCompatMtls(core) {
+  const result = { type: "mutualTLS" };
+  const description = nonEmpty(core.description);
+  if (description !== void 0) result.description = description;
+  return result;
+}
+function buildCompatOauth2(core) {
+  if (!core.flows) {
+    throw A2AError2.invalidParams("OAuth2 security scheme missing flows");
+  }
+  const result = {
+    type: "oauth2",
+    flows: toCompatOAuthFlows(core.flows)
+  };
+  const description = nonEmpty(core.description);
+  if (description !== void 0) result.description = description;
+  const meta = nonEmpty(core.oauth2MetadataUrl);
+  if (meta !== void 0) result.oauth2MetadataUrl = meta;
+  return result;
+}
+function buildCompatOidc(core) {
+  const result = {
+    type: "openIdConnect",
+    openIdConnectUrl: core.openIdConnectUrl
+  };
+  const description = nonEmpty(core.description);
+  if (description !== void 0) result.description = description;
+  return result;
+}
+function toCompatSecurityScheme(core) {
+  const scheme = core.scheme;
+  if (!scheme) {
+    throw A2AError2.invalidParams("Invalid v1.0 SecurityScheme: missing inner scheme");
+  }
+  switch (scheme.$case) {
+    case "apiKeySecurityScheme":
+      return buildCompatApiKey(scheme.value);
+    case "httpAuthSecurityScheme":
+      return buildCompatHttp(scheme.value);
+    case "mtlsSecurityScheme":
+      return buildCompatMtls(scheme.value);
+    case "oauth2SecurityScheme":
+      return buildCompatOauth2(scheme.value);
+    case "openIdConnectSecurityScheme":
+      return buildCompatOidc(scheme.value);
+    default:
+      throw A2AError2.invalidParams(
+        `Unsupported v1.0 SecurityScheme $case: ${scheme.$case ?? "unknown"}`
+      );
+  }
+}
+function toCompatOAuthFlows(core) {
+  const result = {};
+  const flow = core.flow;
+  if (!flow) return result;
+  switch (flow.$case) {
+    case "authorizationCode": {
+      const v = flow.value;
+      result.authorizationCode = {
+        authorizationUrl: v.authorizationUrl,
+        tokenUrl: v.tokenUrl,
+        scopes: { ...v.scopes }
+      };
+      const refresh = nonEmpty(v.refreshUrl);
+      if (refresh !== void 0) result.authorizationCode.refreshUrl = refresh;
+      break;
+    }
+    case "clientCredentials": {
+      const v = flow.value;
+      result.clientCredentials = {
+        tokenUrl: v.tokenUrl,
+        scopes: { ...v.scopes }
+      };
+      const refresh = nonEmpty(v.refreshUrl);
+      if (refresh !== void 0) result.clientCredentials.refreshUrl = refresh;
+      break;
+    }
+    case "implicit": {
+      const v = flow.value;
+      result.implicit = {
+        authorizationUrl: v.authorizationUrl,
+        scopes: { ...v.scopes }
+      };
+      const refresh = nonEmpty(v.refreshUrl);
+      if (refresh !== void 0) result.implicit.refreshUrl = refresh;
+      break;
+    }
+    case "password": {
+      const v = flow.value;
+      result.password = {
+        tokenUrl: v.tokenUrl,
+        scopes: { ...v.scopes }
+      };
+      const refresh = nonEmpty(v.refreshUrl);
+      if (refresh !== void 0) result.password.refreshUrl = refresh;
+      break;
+    }
+    case "deviceCode":
+    default:
+      break;
+  }
+  return result;
+}
+
+// src/compat/v0_3/translate/_clone.ts
+function deepCloneMetadata(metadata) {
+  return metadata === void 0 ? void 0 : structuredClone(metadata);
+}
+
+// src/compat/v0_3/translate/_validate.ts
+function requireArray(value, path) {
+  if (!Array.isArray(value)) {
+    throw A2AError2.invalidParams(`${path} is required and must be an array`);
+  }
+  return value;
+}
+
+// src/compat/v0_3/translate/agent_card.ts
+function nonEmpty2(value) {
+  return value !== void 0 && value !== "" ? value : void 0;
+}
+function toCompatAgentInterface(core) {
+  return { url: core.url, transport: core.protocolBinding };
+}
+function toCompatAgentProvider(core) {
+  return { url: core.url, organization: core.organization };
+}
+function toCompatAgentExtension(core) {
+  const result = { uri: core.uri };
+  const description = nonEmpty2(core.description);
+  if (description !== void 0) result.description = description;
+  result.required = core.required;
+  const params = deepCloneMetadata(core.params);
+  if (params !== void 0) result.params = params;
+  return result;
+}
+function toCompatAgentCapabilities(core) {
+  const result = {};
+  if (core.streaming !== void 0) result.streaming = core.streaming;
+  if (core.pushNotifications !== void 0) result.pushNotifications = core.pushNotifications;
+  if (core.extensions && core.extensions.length > 0) {
+    result.extensions = core.extensions.map(toCompatAgentExtension);
+  }
+  return result;
+}
+function toCompatAgentSkill(core) {
+  const result = {
+    id: core.id,
+    name: core.name,
+    description: core.description,
+    tags: [...requireArray(core.tags, "skill.tags")]
+  };
+  if (core.examples && core.examples.length > 0) result.examples = [...core.examples];
+  if (core.inputModes && core.inputModes.length > 0) result.inputModes = [...core.inputModes];
+  if (core.outputModes && core.outputModes.length > 0) result.outputModes = [...core.outputModes];
+  if (core.securityRequirements && core.securityRequirements.length > 0) {
+    result.security = core.securityRequirements.map(toCompatSecurityRequirement);
+  }
+  return result;
+}
+function toCompatAgentCardSignature(core) {
+  const result = {
+    protected: core.protected,
+    signature: core.signature
+  };
+  const header = deepCloneMetadata(core.header);
+  if (header !== void 0) result.header = header;
+  return result;
+}
+function toCompatAgentCard(core, options) {
+  const allInterfaces = core.supportedInterfaces ?? [];
+  const compatInterfaces = allInterfaces.filter(
+    (intf) => !intf.protocolVersion || isLegacyVersion(intf.protocolVersion)
+  );
+  if (compatInterfaces.length === 0) {
+    throw new VersionNotSupportedError(
+      "AgentCard must have at least one interface with a protocol version in [0.3, 1.0)."
+    );
+  }
+  const primary = compatInterfaces[0];
+  const additionalInterfaces = compatInterfaces.slice(1).map(toCompatAgentInterface);
+  const capabilities = core.capabilities ? toCompatAgentCapabilities(core.capabilities) : {};
+  const supportsExtendedCard = core.capabilities && core.capabilities.extendedAgentCard !== void 0 ? core.capabilities.extendedAgentCard : void 0;
+  const securitySchemes = core.securitySchemes && Object.keys(core.securitySchemes).length > 0 ? Object.fromEntries(
+    Object.entries(core.securitySchemes).map(([key, scheme]) => [
+      key,
+      toCompatSecurityScheme(scheme)
+    ])
+  ) : void 0;
+  const emittedProtocolVersion = primary.protocolVersion || PROTOCOL_VERSION_0_3;
+  const result = {
+    name: core.name,
+    description: core.description,
+    version: core.version,
+    url: primary.url,
+    preferredTransport: primary.protocolBinding,
+    protocolVersion: emittedProtocolVersion,
+    capabilities,
+    defaultInputModes: [...requireArray(core.defaultInputModes, "agentCard.defaultInputModes")],
+    defaultOutputModes: [...requireArray(core.defaultOutputModes, "agentCard.defaultOutputModes")],
+    skills: requireArray(core.skills, "agentCard.skills").map(toCompatAgentSkill)
+  };
+  if (additionalInterfaces.length > 0) {
+    result.additionalInterfaces = additionalInterfaces;
+  }
+  if (core.provider) result.provider = toCompatAgentProvider(core.provider);
+  if (core.documentationUrl !== void 0 && core.documentationUrl !== "") {
+    result.documentationUrl = core.documentationUrl;
+  }
+  if (core.iconUrl !== void 0 && core.iconUrl !== "") result.iconUrl = core.iconUrl;
+  if (supportsExtendedCard !== void 0) {
+    result.supportsAuthenticatedExtendedCard = supportsExtendedCard;
+  }
+  if (securitySchemes !== void 0) result.securitySchemes = securitySchemes;
+  if (core.securityRequirements && core.securityRequirements.length > 0) {
+    result.security = core.securityRequirements.map(toCompatSecurityRequirement);
+  }
+  if (core.signatures && core.signatures.length > 0) {
+    result.signatures = core.signatures.map(toCompatAgentCardSignature);
+  }
+  if (options?.embedV1Interfaces && allInterfaces.length > 0) {
+    result.supportedInterfaces = structuredClone(allInterfaces);
+  }
+  return result;
+}
+
+// src/compat/v0_3/translate/errors.ts
+function toCompatErrorBody(error) {
+  if (isJsonRpcError(error)) {
+    return {
+      code: error.envelopeCode,
+      message: error.message,
+      ...error.data !== void 0 ? { data: error.data } : {}
+    };
+  }
+  if (error instanceof A2AError) {
+    const code = JSON_RPC_ERROR_CODE[error.name] ?? A2A_ERROR_CODE.INTERNAL_ERROR;
+    return { code, message: error.message };
+  }
+  const message = error instanceof Error && error.message || "An unexpected error occurred.";
+  return { code: A2A_ERROR_CODE.INTERNAL_ERROR, message };
+}
+
+// src/compat/v0_3/translate/enums.ts
+var TASK_STATE_COMPAT_TO_CORE = Object.freeze({
+  unknown: 0 /* TASK_STATE_UNSPECIFIED */,
+  submitted: 1 /* TASK_STATE_SUBMITTED */,
+  working: 2 /* TASK_STATE_WORKING */,
+  completed: 3 /* TASK_STATE_COMPLETED */,
+  failed: 4 /* TASK_STATE_FAILED */,
+  canceled: 5 /* TASK_STATE_CANCELED */,
+  "input-required": 6 /* TASK_STATE_INPUT_REQUIRED */,
+  rejected: 7 /* TASK_STATE_REJECTED */,
+  "auth-required": 8 /* TASK_STATE_AUTH_REQUIRED */
+});
+var TASK_STATE_CORE_TO_COMPAT = new Map(
+  Object.entries(TASK_STATE_COMPAT_TO_CORE).map(
+    ([literal, enumValue]) => [enumValue, literal]
+  )
+);
+function toCompatTaskState(state) {
+  return TASK_STATE_CORE_TO_COMPAT.get(state) ?? "unknown";
+}
+function toCoreRole(role) {
+  if (role === "user") return 1 /* ROLE_USER */;
+  if (role === "agent") return 2 /* ROLE_AGENT */;
+  return 0 /* ROLE_UNSPECIFIED */;
+}
+function toCompatRole(role) {
+  return role === 1 /* ROLE_USER */ ? "user" : "agent";
+}
+
+// src/compat/v0_3/translate/parts.ts
+var DATA_PART_COMPAT_FLAG = "data_part_compat";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !Buffer.isBuffer(value);
+}
+function isCompatWrappableDataValue(value) {
+  if (value === null) return true;
+  if (Array.isArray(value)) return true;
+  const t = typeof value;
+  return t === "string" || t === "number" || t === "boolean";
+}
+function toCorePart(compatPart) {
+  if (typeof compatPart !== "object" || compatPart === null || Array.isArray(compatPart)) {
+    throw A2AError2.invalidParams("Each part must be an object");
+  }
+  if (compatPart.kind === "text") {
+    return {
+      content: { $case: "text", value: compatPart.text },
+      metadata: deepCloneMetadata(compatPart.metadata),
+      filename: "",
+      mediaType: ""
+    };
+  }
+  if (compatPart.kind === "file") {
+    const file = compatPart.file;
+    const mediaType = file.mimeType ?? "";
+    const filename = file.name ?? "";
+    const metadata = deepCloneMetadata(compatPart.metadata);
+    if ("bytes" in file) {
+      return {
+        content: { $case: "raw", value: Buffer.from(file.bytes, "base64") },
+        metadata,
+        filename,
+        mediaType
+      };
+    }
+    if ("uri" in file) {
+      return {
+        content: { $case: "url", value: file.uri },
+        metadata,
+        filename,
+        mediaType
+      };
+    }
+    throw A2AError2.invalidParams("Invalid file part: missing `bytes` or `uri`");
+  }
+  if (compatPart.kind === "data") {
+    const metadata = deepCloneMetadata(compatPart.metadata);
+    let value = compatPart.data;
+    let outMetadata = metadata;
+    if (metadata !== void 0 && metadata[DATA_PART_COMPAT_FLAG] === true) {
+      if (isPlainObject(compatPart.data) && "value" in compatPart.data) {
+        value = compatPart.data.value;
+      }
+      delete metadata[DATA_PART_COMPAT_FLAG];
+      outMetadata = Object.keys(metadata).length > 0 ? metadata : void 0;
+    }
+    return {
+      content: { $case: "data", value },
+      metadata: outMetadata,
+      filename: "",
+      mediaType: ""
+    };
+  }
+  throw A2AError2.invalidParams(
+    `Invalid v0.3 part kind: ${compatPart.kind ?? "undefined"}`
+  );
+}
+function toCompatPart(corePart) {
+  const content = corePart.content;
+  const metadata = deepCloneMetadata(corePart.metadata);
+  if (!content) {
+    throw A2AError2.invalidParams("Invalid v1.0 part: missing content");
+  }
+  if (content.$case === "text") {
+    const result = { kind: "text", text: content.value };
+    if (metadata !== void 0) result.metadata = metadata;
+    return result;
+  }
+  if (content.$case === "raw" || content.$case === "url") {
+    const mimeType = corePart.mediaType !== "" ? corePart.mediaType : void 0;
+    const name = corePart.filename !== "" ? corePart.filename : void 0;
+    let file;
+    if (content.$case === "raw") {
+      const bytesBuffer = Buffer.isBuffer(content.value) ? content.value : Buffer.from(content.value);
+      const fileWithBytes = { bytes: bytesBuffer.toString("base64") };
+      if (mimeType !== void 0) fileWithBytes.mimeType = mimeType;
+      if (name !== void 0) fileWithBytes.name = name;
+      file = fileWithBytes;
+    } else {
+      const fileWithUri = { uri: content.value };
+      if (mimeType !== void 0) fileWithUri.mimeType = mimeType;
+      if (name !== void 0) fileWithUri.name = name;
+      file = fileWithUri;
+    }
+    const result = { kind: "file", file };
+    if (metadata !== void 0) result.metadata = metadata;
+    return result;
+  }
+  if (content.$case === "data") {
+    const value = content.value;
+    if (isPlainObject(value)) {
+      const result = { kind: "data", data: value };
+      if (metadata !== void 0) result.metadata = metadata;
+      return result;
+    }
+    if (isCompatWrappableDataValue(value)) {
+      const data = { value };
+      const outMetadata = metadata ?? {};
+      outMetadata[DATA_PART_COMPAT_FLAG] = true;
+      const result = { kind: "data", data, metadata: outMetadata };
+      return result;
+    }
+    throw A2AError2.invalidParams(
+      "Cannot translate v1 data part to v0.3: value is neither a plain object nor a wrap-eligible primitive / array / null (e.g., Symbol, function, bigint, undefined, Buffer). Primitives, arrays, and null are wrapped as { value: ... } with data_part_compat=true; all other non-plain-object values are rejected."
+    );
+  }
+  throw A2AError2.invalidParams(
+    `Invalid v1.0 part content type: ${content.$case ?? "unknown"}`
+  );
+}
+
+// src/compat/v0_3/translate/messages.ts
+function nonEmptyString(value) {
+  return value == null || value === "" ? void 0 : value;
+}
+function nonEmptyArray(value) {
+  return value == null || value.length === 0 ? void 0 : [...value];
+}
+function toCoreMessage(compatMsg) {
+  if (typeof compatMsg !== "object" || compatMsg === null) {
+    throw A2AError2.invalidParams("message must be an object");
+  }
+  if (typeof compatMsg.messageId !== "string" || compatMsg.messageId === "") {
+    throw A2AError2.invalidParams("message.messageId is required");
+  }
+  if (compatMsg.role !== "user" && compatMsg.role !== "agent") {
+    throw A2AError2.invalidParams('message.role must be "user" or "agent"');
+  }
+  if (!Array.isArray(compatMsg.parts)) {
+    throw A2AError2.invalidParams("message.parts must be an array");
+  }
+  return {
+    messageId: compatMsg.messageId,
+    contextId: compatMsg.contextId ?? "",
+    taskId: compatMsg.taskId ?? "",
+    role: toCoreRole(compatMsg.role),
+    parts: compatMsg.parts.map(toCorePart),
+    metadata: deepCloneMetadata(compatMsg.metadata),
+    extensions: compatMsg.extensions ? [...compatMsg.extensions] : [],
+    referenceTaskIds: compatMsg.referenceTaskIds ? [...compatMsg.referenceTaskIds] : []
+  };
+}
+function toCompatMessage(coreMsg) {
+  const result = {
+    kind: "message",
+    messageId: coreMsg.messageId,
+    role: toCompatRole(coreMsg.role),
+    parts: requireArray(coreMsg.parts, "message.parts").map(toCompatPart)
+  };
+  const contextId = nonEmptyString(coreMsg.contextId);
+  if (contextId !== void 0) result.contextId = contextId;
+  const taskId = nonEmptyString(coreMsg.taskId);
+  if (taskId !== void 0) result.taskId = taskId;
+  const metadata = deepCloneMetadata(coreMsg.metadata);
+  if (metadata !== void 0) result.metadata = metadata;
+  const extensions = nonEmptyArray(coreMsg.extensions);
+  if (extensions !== void 0) result.extensions = extensions;
+  const referenceTaskIds = nonEmptyArray(coreMsg.referenceTaskIds);
+  if (referenceTaskIds !== void 0) result.referenceTaskIds = referenceTaskIds;
+  return result;
+}
+
+// src/compat/v0_3/translate/push_notifications.ts
+function nonEmpty3(value) {
+  return value !== void 0 && value !== "" ? value : void 0;
+}
+function toCoreAuthenticationInfo(compat) {
+  if (compat.schemes && compat.schemes.length > 1) {
+    console.warn(
+      `toCoreAuthenticationInfo: Lossy conversion from v0.3 PushNotificationAuthenticationInfo to v1.0 AuthenticationInfo. Multiple schemes declared (${compat.schemes.join(", ")}), but only the first one ('${compat.schemes[0]}') will be kept.`
+    );
+  }
+  return {
+    scheme: compat.schemes && compat.schemes.length > 0 ? compat.schemes[0] : "",
+    credentials: compat.credentials ?? ""
+  };
+}
+function toCompatAuthenticationInfo(core) {
+  const result = {
+    schemes: core.scheme !== "" ? [core.scheme] : []
+  };
+  const credentials = nonEmpty3(core.credentials);
+  if (credentials !== void 0) result.credentials = credentials;
+  return result;
+}
+function toCorePushNotificationConfig(compat, tenant = "") {
+  return {
+    tenant,
+    taskId: "",
+    id: compat.id ?? "",
+    url: compat.url,
+    token: compat.token ?? "",
+    authentication: compat.authentication ? toCoreAuthenticationInfo(compat.authentication) : void 0
+  };
+}
+function toCompatPushNotificationConfig(core) {
+  const result = { url: core.url };
+  const id = nonEmpty3(core.id);
+  if (id !== void 0) result.id = id;
+  const token = nonEmpty3(core.token);
+  if (token !== void 0) result.token = token;
+  if (core.authentication) {
+    result.authentication = toCompatAuthenticationInfo(core.authentication);
+  }
+  return result;
+}
+function toCoreTaskPushNotificationConfig(compat, tenant = "") {
+  return {
+    tenant,
+    taskId: compat.taskId,
+    id: compat.pushNotificationConfig.id ?? "",
+    url: compat.pushNotificationConfig.url,
+    token: compat.pushNotificationConfig.token ?? "",
+    authentication: compat.pushNotificationConfig.authentication ? toCoreAuthenticationInfo(compat.pushNotificationConfig.authentication) : void 0
+  };
+}
+function toCompatTaskPushNotificationConfig(core) {
+  return {
+    taskId: core.taskId,
+    pushNotificationConfig: toCompatPushNotificationConfig(core)
+  };
+}
+
+// src/compat/v0_3/translate/artifacts.ts
+function nonEmptyString2(value) {
+  return value == null || value === "" ? void 0 : value;
+}
+function nonEmptyArray2(value) {
+  return value == null || value.length === 0 ? void 0 : [...value];
+}
+function toCompatArtifact(coreArtifact) {
+  const result = {
+    artifactId: coreArtifact.artifactId,
+    parts: requireArray(coreArtifact.parts, "artifact.parts").map(toCompatPart)
+  };
+  const name = nonEmptyString2(coreArtifact.name);
+  if (name !== void 0) result.name = name;
+  const description = nonEmptyString2(coreArtifact.description);
+  if (description !== void 0) result.description = description;
+  const metadata = deepCloneMetadata(coreArtifact.metadata);
+  if (metadata !== void 0) result.metadata = metadata;
+  const extensions = nonEmptyArray2(coreArtifact.extensions);
+  if (extensions !== void 0) result.extensions = extensions;
+  return result;
+}
+
+// src/compat/v0_3/translate/tasks.ts
+var FINAL_LEGACY_STATES = /* @__PURE__ */ new Set([
+  "completed",
+  "canceled",
+  "failed",
+  "rejected"
+]);
+function toCompatTaskStatus(coreStatus) {
+  const result = { state: toCompatTaskState(coreStatus.state) };
+  if (coreStatus.message) {
+    result.message = toCompatMessage(coreStatus.message);
+  }
+  if (coreStatus.timestamp !== void 0 && coreStatus.timestamp !== "") {
+    result.timestamp = coreStatus.timestamp;
+  }
+  return result;
+}
+function toCompatTask(coreTask) {
+  const result = {
+    kind: "task",
+    id: coreTask.id,
+    contextId: coreTask.contextId,
+    status: coreTask.status ? toCompatTaskStatus(coreTask.status) : { state: "unknown" }
+  };
+  if (coreTask.history && coreTask.history.length > 0) {
+    result.history = coreTask.history.map(toCompatMessage);
+  }
+  if (coreTask.artifacts && coreTask.artifacts.length > 0) {
+    result.artifacts = coreTask.artifacts.map(toCompatArtifact);
+  }
+  const metadata = deepCloneMetadata(coreTask.metadata);
+  if (metadata !== void 0) result.metadata = metadata;
+  return result;
+}
+function toCompatTaskStatusUpdateEvent(coreEvent) {
+  const status = coreEvent.status ? toCompatTaskStatus(coreEvent.status) : { state: "unknown" };
+  const result = {
+    kind: "status-update",
+    taskId: coreEvent.taskId,
+    contextId: coreEvent.contextId,
+    status,
+    final: FINAL_LEGACY_STATES.has(status.state)
+  };
+  const metadata = deepCloneMetadata(coreEvent.metadata);
+  if (metadata !== void 0) result.metadata = metadata;
+  return result;
+}
+function toCompatTaskArtifactUpdateEvent(coreEvent) {
+  if (!coreEvent.artifact) {
+    throw A2AError2.invalidParams("Invalid TaskArtifactUpdateEvent: missing artifact");
+  }
+  const result = {
+    kind: "artifact-update",
+    taskId: coreEvent.taskId,
+    contextId: coreEvent.contextId,
+    artifact: toCompatArtifact(coreEvent.artifact),
+    append: coreEvent.append,
+    lastChunk: coreEvent.lastChunk
+  };
+  const metadata = deepCloneMetadata(coreEvent.metadata);
+  if (metadata !== void 0) result.metadata = metadata;
+  return result;
+}
+
+// src/compat/v0_3/translate/requests.ts
+function toCoreSendMessageConfiguration(compat) {
+  return {
+    acceptedOutputModes: compat.acceptedOutputModes ? [...compat.acceptedOutputModes] : [],
+    taskPushNotificationConfig: compat.pushNotificationConfig ? toCorePushNotificationConfig(compat.pushNotificationConfig) : void 0,
+    historyLength: compat.historyLength,
+    returnImmediately: compat.blocking === void 0 ? true : !compat.blocking
+  };
+}
+function toCoreSendMessageRequest(compat, tenant = "") {
+  return {
+    tenant,
+    message: toCoreMessage(compat.params.message),
+    configuration: compat.params.configuration ? toCoreSendMessageConfiguration(compat.params.configuration) : void 0,
+    metadata: deepCloneMetadata(compat.params.metadata)
+  };
+}
+function toCompatStreamResponse(core, requestId = null) {
+  const payload = core.payload;
+  if (!payload) {
+    throw A2AError2.internalError("StreamResponse missing payload");
+  }
+  let result;
+  switch (payload.$case) {
+    case "message":
+      result = toCompatMessage(payload.value);
+      break;
+    case "task":
+      result = toCompatTask(payload.value);
+      break;
+    case "statusUpdate":
+      result = toCompatTaskStatusUpdateEvent(payload.value);
+      break;
+    case "artifactUpdate":
+      result = toCompatTaskArtifactUpdateEvent(payload.value);
+      break;
+    default:
+      throw A2AError2.internalError("StreamResponse has unknown payload case");
+  }
+  return { id: requestId, jsonrpc: "2.0", result };
+}
+
+// src/compat/v0_3/server/transports/rest/rest_transport_handler.ts
+var LEGACY_CODE_TO_HTTP_STATUS = {
+  [-32700]: HTTP_STATUS.BAD_REQUEST,
+  // Parse error
+  [-32600]: HTTP_STATUS.BAD_REQUEST,
+  // Invalid Request
+  [-32601]: HTTP_STATUS.NOT_IMPLEMENTED,
+  // Method not found
+  [-32602]: HTTP_STATUS.BAD_REQUEST,
+  // Invalid params
+  [-32603]: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+  // Internal error
+  [-32001]: HTTP_STATUS.NOT_FOUND,
+  // Task not found
+  [-32002]: HTTP_STATUS.BAD_REQUEST,
+  // Task not cancelable
+  [-32003]: HTTP_STATUS.BAD_REQUEST,
+  // Push notification not supported
+  [-32004]: HTTP_STATUS.BAD_REQUEST,
+  // Unsupported operation
+  [-32005]: HTTP_STATUS.BAD_REQUEST,
+  // Content-Type not supported
+  [-32006]: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+  // Invalid agent response
+  [-32007]: HTTP_STATUS.BAD_REQUEST
+  // Extended card not configured
+};
+function mapErrorToStatus(error) {
+  if (isJsonRpcError(error)) {
+    const override = LEGACY_CODE_TO_HTTP_STATUS[error.envelopeCode];
+    if (override !== void 0) return override;
+  }
+  return restStatusFor(error);
+}
+function toLegacyHTTPError(error) {
+  return toCompatErrorBody(error);
+}
+var LegacyRestTransportHandler = class _LegacyRestTransportHandler {
+  requestHandler;
+  constructor(requestHandler) {
+    this.requestHandler = requestHandler;
+  }
+  async getAgentCard() {
+    return this.requestHandler.getAgentCard();
+  }
+  async getAuthenticatedExtendedAgentCard(context) {
+    const core = await this.requestHandler.getAuthenticatedExtendedAgentCard(
+      { tenant: context.tenant ?? "" },
+      context
+    );
+    return toCompatAgentCard(core);
+  }
+  validateMessageSendParams(params) {
+    if (!params.message) {
+      throw A2AError2.invalidParams("message is required");
+    }
+    if (!params.message.messageId) {
+      throw A2AError2.invalidParams("message.messageId is required");
+    }
+  }
+  async sendMessage(params, context) {
+    this.validateMessageSendParams(params);
+    const coreReq = toCoreSendMessageRequest(
+      buildLegacySendRequest(params, "message/send"),
+      context.tenant ?? ""
+    );
+    const result = await this.requestHandler.sendMessage(coreReq, context);
+    return "messageId" in result ? toCompatMessage(result) : toCompatTask(result);
+  }
+  /** Throws `unsupportedOperation` if the agent does not advertise streaming. */
+  async sendMessageStream(params, context) {
+    await this.requireCapability("streaming");
+    this.validateMessageSendParams(params);
+    const coreReq = toCoreSendMessageRequest(
+      buildLegacySendRequest(params, "message/stream"),
+      context.tenant ?? ""
+    );
+    const stream = this.requestHandler.sendMessageStream(coreReq, context);
+    return _LegacyRestTransportHandler.translateStream(stream);
+  }
+  /**
+   * Leave `historyLength` absent when the caller didn't supply it:
+   * `undefined` means "no client limit, return full history". Coercing
+   * to `0` would silently change the semantics to "return no history".
+   */
+  async getTask(taskId, context, historyLength) {
+    const params = {
+      id: taskId,
+      tenant: context.tenant ?? ""
+    };
+    if (historyLength !== void 0) {
+      params.historyLength = this.parseHistoryLength(historyLength);
+    }
+    const core = await this.requestHandler.getTask(params, context);
+    return toCompatTask(core);
+  }
+  async cancelTask(taskId, context) {
+    const core = await this.requestHandler.cancelTask(
+      { id: taskId, tenant: context.tenant ?? "", metadata: {} },
+      context
+    );
+    return toCompatTask(core);
+  }
+  /** Throws `unsupportedOperation` if the agent does not advertise streaming. */
+  async resubscribe(taskId, context) {
+    await this.requireCapability("streaming");
+    const stream = this.requestHandler.resubscribe(
+      { id: taskId, tenant: context.tenant ?? "" },
+      context
+    );
+    return _LegacyRestTransportHandler.translateStream(stream);
+  }
+  /** v0.3 calls this "set". Throws if push notifications are not supported. */
+  async setTaskPushNotificationConfig(config, context) {
+    await this.requireCapability("pushNotifications");
+    if (!config.taskId) {
+      throw A2AError2.invalidParams("taskId is required");
+    }
+    if (!config.pushNotificationConfig) {
+      throw A2AError2.invalidParams("pushNotificationConfig is required");
+    }
+    const core = toCoreTaskPushNotificationConfig(config, context.tenant ?? "");
+    const result = await this.requestHandler.createTaskPushNotificationConfig(core, context);
+    return toCompatTaskPushNotificationConfig(result);
+  }
+  async listTaskPushNotificationConfigs(taskId, context) {
+    const result = await this.requestHandler.listTaskPushNotificationConfigs(
+      { taskId, pageSize: 0, pageToken: "", tenant: context.tenant ?? "" },
+      context
+    );
+    return result.configs.map((cfg) => toCompatTaskPushNotificationConfig(cfg));
+  }
+  async getTaskPushNotificationConfig(taskId, configId, context) {
+    const result = await this.requestHandler.getTaskPushNotificationConfig(
+      { taskId, id: configId, tenant: context.tenant ?? "" },
+      context
+    );
+    return toCompatTaskPushNotificationConfig(result);
+  }
+  async deleteTaskPushNotificationConfig(taskId, configId, context) {
+    await this.requestHandler.deleteTaskPushNotificationConfig(
+      { taskId, id: configId, tenant: context.tenant ?? "" },
+      context
+    );
+  }
+  /**
+   * Translates each event via `toCompatStreamResponse` and unwraps the
+   * JSON-RPC envelope — REST SSE carries only `.result`.
+   */
+  static async *translateStream(stream) {
+    for await (const event of stream) {
+      const envelope = toCompatStreamResponse(event, null);
+      yield envelope.result;
+    }
+  }
+  static CAPABILITY_ERRORS = {
+    streaming: () => A2AError2.unsupportedOperation("Agent does not support streaming"),
+    pushNotifications: () => A2AError2.pushNotificationNotSupported()
+  };
+  async requireCapability(capability) {
+    const agentCard = await this.getAgentCard();
+    if (!agentCard.capabilities?.[capability]) {
+      throw _LegacyRestTransportHandler.CAPABILITY_ERRORS[capability]();
+    }
+  }
+  parseHistoryLength(value) {
+    if (value === void 0 || value === null) {
+      throw A2AError2.invalidParams("historyLength is required");
+    }
+    const parsed = parseInt(String(value), 10);
+    if (isNaN(parsed)) {
+      throw A2AError2.invalidParams("historyLength must be a valid integer");
+    }
+    if (parsed < 0) {
+      throw A2AError2.invalidParams("historyLength must be non-negative");
+    }
+    return parsed;
+  }
+  /** Same as `toLegacyHTTPError`, exposed for the Express layer. */
+  static mapToLegacyHTTPError(error) {
+    return toLegacyHTTPError(error);
+  }
+};
+function buildLegacySendRequest(params, method) {
+  return { jsonrpc: "2.0", id: 0, method, params };
+}
+
+// src/compat/v0_3/server/express/agent_card_handler.ts
+function computeETag(json) {
+  const hash = import_crypto.default.createHash("sha256").update(json).digest("hex").slice(0, 16);
+  return `W/"${hash}"`;
+}
+function legacyAgentCardRouter(options) {
+  const router = import_express.default.Router();
+  const maxAge = options.cache?.maxAge ?? 3600;
+  const provider = typeof options.agentCardProvider === "function" ? options.agentCardProvider : options.agentCardProvider.getAgentCard.bind(options.agentCardProvider);
+  router.use((req, _res, next) => {
+    const requestedVersion = req.header(A2A_VERSION_HEADER) || A2A_LEGACY_PROTOCOL_VERSION;
+    if (isLegacyVersion(requestedVersion)) {
+      next();
+    } else {
+      next("router");
+    }
+  });
+  router.get("/", async (req, res) => {
+    try {
+      const coreCard = await provider();
+      let compatCard;
+      try {
+        compatCard = toCompatAgentCard(coreCard, {
+          embedV1Interfaces: true
+        });
+      } catch (error) {
+        if (error instanceof VersionNotSupportedError) {
+          res.append("Vary", A2A_VERSION_HEADER);
+          res.status(HTTP_STATUS.BAD_REQUEST).setHeader("Content-Type", LEGACY_JSON_CONTENT_TYPE).json(toLegacyHTTPError(error));
+          return;
+        }
+        throw error;
+      }
+      const body = JSON.stringify(compatCard);
+      const etag = computeETag(body);
+      res.setHeader("ETag", etag);
+      res.append("Vary", A2A_VERSION_HEADER);
+      if (maxAge > 0) {
+        res.setHeader("Cache-Control", `public, max-age=${maxAge}`);
+      } else {
+        res.setHeader("Cache-Control", "no-cache");
+      }
+      if (req.fresh) {
+        res.status(304).end();
+        return;
+      }
+      res.setHeader("Content-Type", LEGACY_JSON_CONTENT_TYPE);
+      res.status(HTTP_STATUS.OK).send(body);
+    } catch (error) {
+      console.error("Error fetching legacy agent card:", error);
+      res.append("Vary", A2A_VERSION_HEADER);
+      res.status(500).setHeader("Content-Type", LEGACY_JSON_CONTENT_TYPE).json({ error: "Failed to retrieve agent card" });
+    }
+  });
+  return router;
+}
+
+// src/compat/v0_3/server/express/rest_handler.ts
+var import_express2 = __toESM(require("express"), 1);
+
+// src/extensions.ts
+var Extensions = {
+  /**
+   * Creates new {@link Extensions} from `current` and `additional`.
+   * If `current` already contains `additional` it is returned unmodified.
+   */
+  createFrom: (current, additional) => {
+    if (current?.includes(additional)) {
+      return current;
+    }
+    return [...current ?? [], additional];
+  },
+  /**
+   * Creates {@link Extensions} from comma separated extensions identifiers as per
+   * https://a2a-protocol.org/latest/specification/#326-service-parameters.
+   * Parses the output of `toServiceParameter`.
+   */
+  parseServiceParameter: (value) => {
+    if (!value) {
+      return [];
+    }
+    const unique = new Set(
+      value.split(",").map((ext) => ext.trim()).filter((ext) => ext.length > 0)
+    );
+    return Array.from(unique);
+  },
+  /**
+   * Converts {@link Extensions} to comma separated extensions identifiers as per
+   * https://a2a-protocol.org/latest/specification/#326-service-parameters.
+   */
+  toServiceParameter: (value) => {
+    return value.join(",");
+  }
+};
+
+// src/server/context.ts
+var ABSENT_HEADER_VERSION = "0.3";
+var STATE_HEADERS_KEY = "headers";
+var defaultServerCallContextBuilder = ({
+  extensions,
+  user,
+  headers,
+  requestedVersion,
+  tenant
+}) => {
+  const state = /* @__PURE__ */ new Map([[STATE_HEADERS_KEY, headers]]);
+  return new ServerCallContext({
+    requestedExtensions: extensions,
+    user,
+    state,
+    requestedVersion,
+    tenant
+  });
+};
+var ServerCallContext = class {
+  _requestedExtensions;
+  _user;
+  _requestedVersion;
+  _tenant;
+  _activatedExtensions;
+  _state;
+  constructor(options) {
+    this._requestedExtensions = options?.requestedExtensions;
+    this._user = options?.user;
+    this._tenant = options?.tenant;
+    this._requestedVersion = options?.requestedVersion || ABSENT_HEADER_VERSION;
+    this._state = options?.state ?? /* @__PURE__ */ new Map();
+  }
+  get tenant() {
+    return this._tenant;
+  }
+  /**
+   * Sets the tenant resolved by a transport without replacing this context.
+   * Keeping the instance preserves custom state, subclasses, and extension
+   * activations observed by the response layer.
+   *
+   * @throws {Error} If a tenant has already been set, including by the constructor.
+   */
+  setTenant(tenant) {
+    if (this._tenant !== void 0) {
+      throw new Error("Tenant is already set.");
+    }
+    this._tenant = tenant;
+  }
+  get user() {
+    return this._user;
+  }
+  get activatedExtensions() {
+    return this._activatedExtensions;
+  }
+  get requestedExtensions() {
+    return this._requestedExtensions;
+  }
+  get requestedVersion() {
+    return this._requestedVersion;
+  }
+  /**
+   * Arbitrary key/value state bag, equivalent to the `state` field on the
+   * Python A2A SDK's `ServerCallContext`. Use this to carry custom data
+   * (e.g. request headers, tenant IDs) through the call pipeline.
+   */
+  get state() {
+    return this._state;
+  }
+  addActivatedExtension(uri) {
+    this._activatedExtensions = Extensions.createFrom(this._activatedExtensions, uri);
+  }
+  /**
+   * Replaces the requested-extensions set. Mutated in place rather than
+   * via a fresh context because the transport layer holds a reference
+   * to this object and reads `activatedExtensions` off it after dispatch
+   * to populate the response `A2A-Extensions` header.
+   */
+  setRequestedExtensions(extensions) {
+    this._requestedExtensions = extensions;
+  }
+};
+
+// src/server/express/common.ts
+async function* delegateAsyncIterator(it) {
+  let nextThrew = false;
+  try {
+    while (true) {
+      let result;
+      try {
+        result = await it.next();
+      } catch (err) {
+        nextThrew = true;
+        throw err;
+      }
+      if (result.done) return;
+      yield result.value;
+    }
+  } finally {
+    if (!nextThrew) {
+      await it.return?.();
+    }
+  }
+}
+
+// src/sse_utils.ts
+var SSE_HEADERS = {
+  "Content-Type": "text/event-stream",
+  "Cache-Control": "no-cache",
+  Connection: "keep-alive",
+  "X-Accel-Buffering": "no"
+  // Disable buffering in nginx
+};
+function formatSSEEvent(event) {
+  return `data: ${JSON.stringify(event)}
+
+`;
+}
+function formatSSEErrorEvent(error) {
+  return `event: error
+data: ${JSON.stringify(error)}
+
+`;
+}
+var DEFAULT_MAX_SSE_EVENT_SIZE_BYTES = 4 * 1024 * 1024;
+
+// src/server/version.ts
+function getSupportedVersions(agentCard, protocolBinding) {
+  const versions = /* @__PURE__ */ new Set();
+  for (const agentInterface of agentCard.supportedInterfaces ?? []) {
+    if (protocolBinding && agentInterface.protocolBinding !== protocolBinding) {
+      continue;
+    }
+    if (agentInterface.protocolVersion) {
+      versions.add(agentInterface.protocolVersion);
+    }
+  }
+  return versions;
+}
+function validateVersion(requestedVersion, agentCard, protocolBinding) {
+  const supported = getSupportedVersions(agentCard, protocolBinding);
+  if (!supported.has(requestedVersion)) {
+    throw new VersionNotSupportedError(
+      `The requested A2A protocol version '${requestedVersion}' is not supported. Supported versions: ${[...supported].join(", ")}`
+    );
+  }
+}
+
+// src/compat/v0_3/types/pb/a2a.ts
+function taskStateFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "TASK_STATE_UNSPECIFIED":
+      return 0 /* TASK_STATE_UNSPECIFIED */;
+    case 1:
+    case "TASK_STATE_SUBMITTED":
+      return 1 /* TASK_STATE_SUBMITTED */;
+    case 2:
+    case "TASK_STATE_WORKING":
+      return 2 /* TASK_STATE_WORKING */;
+    case 3:
+    case "TASK_STATE_COMPLETED":
+      return 3 /* TASK_STATE_COMPLETED */;
+    case 4:
+    case "TASK_STATE_FAILED":
+      return 4 /* TASK_STATE_FAILED */;
+    case 5:
+    case "TASK_STATE_CANCELLED":
+      return 5 /* TASK_STATE_CANCELLED */;
+    case 6:
+    case "TASK_STATE_INPUT_REQUIRED":
+      return 6 /* TASK_STATE_INPUT_REQUIRED */;
+    case 7:
+    case "TASK_STATE_REJECTED":
+      return 7 /* TASK_STATE_REJECTED */;
+    case 8:
+    case "TASK_STATE_AUTH_REQUIRED":
+      return 8 /* TASK_STATE_AUTH_REQUIRED */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
+  }
+}
+function taskStateToJSON(object) {
+  switch (object) {
+    case 0 /* TASK_STATE_UNSPECIFIED */:
+      return "TASK_STATE_UNSPECIFIED";
+    case 1 /* TASK_STATE_SUBMITTED */:
+      return "TASK_STATE_SUBMITTED";
+    case 2 /* TASK_STATE_WORKING */:
+      return "TASK_STATE_WORKING";
+    case 3 /* TASK_STATE_COMPLETED */:
+      return "TASK_STATE_COMPLETED";
+    case 4 /* TASK_STATE_FAILED */:
+      return "TASK_STATE_FAILED";
+    case 5 /* TASK_STATE_CANCELLED */:
+      return "TASK_STATE_CANCELLED";
+    case 6 /* TASK_STATE_INPUT_REQUIRED */:
+      return "TASK_STATE_INPUT_REQUIRED";
+    case 7 /* TASK_STATE_REJECTED */:
+      return "TASK_STATE_REJECTED";
+    case 8 /* TASK_STATE_AUTH_REQUIRED */:
+      return "TASK_STATE_AUTH_REQUIRED";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+function roleFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "ROLE_UNSPECIFIED":
+      return 0 /* ROLE_UNSPECIFIED */;
+    case 1:
+    case "ROLE_USER":
+      return 1 /* ROLE_USER */;
+    case 2:
+    case "ROLE_AGENT":
+      return 2 /* ROLE_AGENT */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
+  }
+}
+function roleToJSON(object) {
+  switch (object) {
+    case 0 /* ROLE_UNSPECIFIED */:
+      return "ROLE_UNSPECIFIED";
+    case 1 /* ROLE_USER */:
+      return "ROLE_USER";
+    case 2 /* ROLE_AGENT */:
+      return "ROLE_AGENT";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+var SendMessageConfiguration = {
+  fromJSON(object) {
+    return {
+      acceptedOutputModes: globalThis.Array.isArray(object?.acceptedOutputModes) ? object.acceptedOutputModes.map((e) => globalThis.String(e)) : globalThis.Array.isArray(object?.accepted_output_modes) ? object.accepted_output_modes.map(
+        (e) => globalThis.String(e)
+      ) : [],
+      pushNotification: isSet(object.pushNotification) ? PushNotificationConfig.fromJSON(object.pushNotification) : isSet(object.push_notification) ? PushNotificationConfig.fromJSON(object.push_notification) : void 0,
+      historyLength: isSet(object.historyLength) ? globalThis.Number(object.historyLength) : isSet(object.history_length) ? globalThis.Number(object.history_length) : 0,
+      blocking: isSet(object.blocking) ? globalThis.Boolean(object.blocking) : false
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.acceptedOutputModes?.length) {
+      obj.acceptedOutputModes = message.acceptedOutputModes;
+    }
+    if (message.pushNotification !== void 0) {
+      obj.pushNotification = PushNotificationConfig.toJSON(message.pushNotification);
+    }
+    if (message.historyLength !== 0) {
+      obj.historyLength = Math.round(message.historyLength);
+    }
+    if (message.blocking !== false) {
+      obj.blocking = message.blocking;
+    }
+    return obj;
+  }
+};
+var Task = {
+  fromJSON(object) {
+    return {
+      id: isSet(object.id) ? globalThis.String(object.id) : "",
+      contextId: isSet(object.contextId) ? globalThis.String(object.contextId) : isSet(object.context_id) ? globalThis.String(object.context_id) : "",
+      status: isSet(object.status) ? TaskStatus.fromJSON(object.status) : void 0,
+      artifacts: globalThis.Array.isArray(object?.artifacts) ? object.artifacts.map((e) => Artifact.fromJSON(e)) : [],
+      history: globalThis.Array.isArray(object?.history) ? object.history.map((e) => Message.fromJSON(e)) : [],
+      metadata: isObject(object.metadata) ? object.metadata : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.id !== "") {
+      obj.id = message.id;
+    }
+    if (message.contextId !== "") {
+      obj.contextId = message.contextId;
+    }
+    if (message.status !== void 0) {
+      obj.status = TaskStatus.toJSON(message.status);
+    }
+    if (message.artifacts?.length) {
+      obj.artifacts = message.artifacts.map((e) => Artifact.toJSON(e));
+    }
+    if (message.history?.length) {
+      obj.history = message.history.map((e) => Message.toJSON(e));
+    }
+    if (message.metadata !== void 0) {
+      obj.metadata = message.metadata;
+    }
+    return obj;
+  }
+};
+var TaskStatus = {
+  fromJSON(object) {
+    return {
+      state: isSet(object.state) ? taskStateFromJSON(object.state) : 0,
+      update: isSet(object.message) ? Message.fromJSON(object.message) : isSet(object.update) ? Message.fromJSON(object.update) : void 0,
+      timestamp: isSet(object.timestamp) ? globalThis.String(object.timestamp) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.state !== 0) {
+      obj.state = taskStateToJSON(message.state);
+    }
+    if (message.update !== void 0) {
+      obj.message = Message.toJSON(message.update);
+    }
+    if (message.timestamp !== void 0) {
+      obj.timestamp = message.timestamp;
+    }
+    return obj;
+  }
+};
+var Part = {
+  fromJSON(object) {
+    return {
+      part: isSet(object.text) ? { $case: "text", value: globalThis.String(object.text) } : isSet(object.file) ? { $case: "file", value: FilePart.fromJSON(object.file) } : isSet(object.data) ? { $case: "data", value: DataPart.fromJSON(object.data) } : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.part?.$case === "text") {
+      obj.text = message.part.value;
+    } else if (message.part?.$case === "file") {
+      obj.file = FilePart.toJSON(message.part.value);
+    } else if (message.part?.$case === "data") {
+      obj.data = DataPart.toJSON(message.part.value);
+    }
+    return obj;
+  }
+};
+var FilePart = {
+  fromJSON(object) {
+    return {
+      file: isSet(object.fileWithUri) ? { $case: "fileWithUri", value: globalThis.String(object.fileWithUri) } : isSet(object.file_with_uri) ? { $case: "fileWithUri", value: globalThis.String(object.file_with_uri) } : isSet(object.fileWithBytes) ? { $case: "fileWithBytes", value: Buffer.from(bytesFromBase64(object.fileWithBytes)) } : isSet(object.file_with_bytes) ? { $case: "fileWithBytes", value: Buffer.from(bytesFromBase64(object.file_with_bytes)) } : void 0,
+      mimeType: isSet(object.mimeType) ? globalThis.String(object.mimeType) : isSet(object.mime_type) ? globalThis.String(object.mime_type) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.file?.$case === "fileWithUri") {
+      obj.fileWithUri = message.file.value;
+    } else if (message.file?.$case === "fileWithBytes") {
+      obj.fileWithBytes = base64FromBytes(message.file.value);
+    }
+    if (message.mimeType !== "") {
+      obj.mimeType = message.mimeType;
+    }
+    return obj;
+  }
+};
+var DataPart = {
+  fromJSON(object) {
+    return { data: isObject(object.data) ? object.data : void 0 };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.data !== void 0) {
+      obj.data = message.data;
+    }
+    return obj;
+  }
+};
+var Message = {
+  fromJSON(object) {
+    return {
+      messageId: isSet(object.messageId) ? globalThis.String(object.messageId) : isSet(object.message_id) ? globalThis.String(object.message_id) : "",
+      contextId: isSet(object.contextId) ? globalThis.String(object.contextId) : isSet(object.context_id) ? globalThis.String(object.context_id) : "",
+      taskId: isSet(object.taskId) ? globalThis.String(object.taskId) : isSet(object.task_id) ? globalThis.String(object.task_id) : "",
+      role: isSet(object.role) ? roleFromJSON(object.role) : 0,
+      content: globalThis.Array.isArray(object?.content) ? object.content.map((e) => Part.fromJSON(e)) : [],
+      metadata: isObject(object.metadata) ? object.metadata : void 0,
+      extensions: globalThis.Array.isArray(object?.extensions) ? object.extensions.map((e) => globalThis.String(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.messageId !== "") {
+      obj.messageId = message.messageId;
+    }
+    if (message.contextId !== "") {
+      obj.contextId = message.contextId;
+    }
+    if (message.taskId !== "") {
+      obj.taskId = message.taskId;
+    }
+    if (message.role !== 0) {
+      obj.role = roleToJSON(message.role);
+    }
+    if (message.content?.length) {
+      obj.content = message.content.map((e) => Part.toJSON(e));
+    }
+    if (message.metadata !== void 0) {
+      obj.metadata = message.metadata;
+    }
+    if (message.extensions?.length) {
+      obj.extensions = message.extensions;
+    }
+    return obj;
+  }
+};
+var Artifact = {
+  fromJSON(object) {
+    return {
+      artifactId: isSet(object.artifactId) ? globalThis.String(object.artifactId) : isSet(object.artifact_id) ? globalThis.String(object.artifact_id) : "",
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+      description: isSet(object.description) ? globalThis.String(object.description) : "",
+      parts: globalThis.Array.isArray(object?.parts) ? object.parts.map((e) => Part.fromJSON(e)) : [],
+      metadata: isObject(object.metadata) ? object.metadata : void 0,
+      extensions: globalThis.Array.isArray(object?.extensions) ? object.extensions.map((e) => globalThis.String(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.artifactId !== "") {
+      obj.artifactId = message.artifactId;
+    }
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    if (message.parts?.length) {
+      obj.parts = message.parts.map((e) => Part.toJSON(e));
+    }
+    if (message.metadata !== void 0) {
+      obj.metadata = message.metadata;
+    }
+    if (message.extensions?.length) {
+      obj.extensions = message.extensions;
+    }
+    return obj;
+  }
+};
+var TaskStatusUpdateEvent = {
+  fromJSON(object) {
+    return {
+      taskId: isSet(object.taskId) ? globalThis.String(object.taskId) : isSet(object.task_id) ? globalThis.String(object.task_id) : "",
+      contextId: isSet(object.contextId) ? globalThis.String(object.contextId) : isSet(object.context_id) ? globalThis.String(object.context_id) : "",
+      status: isSet(object.status) ? TaskStatus.fromJSON(object.status) : void 0,
+      final: isSet(object.final) ? globalThis.Boolean(object.final) : false,
+      metadata: isObject(object.metadata) ? object.metadata : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.taskId !== "") {
+      obj.taskId = message.taskId;
+    }
+    if (message.contextId !== "") {
+      obj.contextId = message.contextId;
+    }
+    if (message.status !== void 0) {
+      obj.status = TaskStatus.toJSON(message.status);
+    }
+    if (message.final !== false) {
+      obj.final = message.final;
+    }
+    if (message.metadata !== void 0) {
+      obj.metadata = message.metadata;
+    }
+    return obj;
+  }
+};
+var TaskArtifactUpdateEvent = {
+  fromJSON(object) {
+    return {
+      taskId: isSet(object.taskId) ? globalThis.String(object.taskId) : isSet(object.task_id) ? globalThis.String(object.task_id) : "",
+      contextId: isSet(object.contextId) ? globalThis.String(object.contextId) : isSet(object.context_id) ? globalThis.String(object.context_id) : "",
+      artifact: isSet(object.artifact) ? Artifact.fromJSON(object.artifact) : void 0,
+      append: isSet(object.append) ? globalThis.Boolean(object.append) : false,
+      lastChunk: isSet(object.lastChunk) ? globalThis.Boolean(object.lastChunk) : isSet(object.last_chunk) ? globalThis.Boolean(object.last_chunk) : false,
+      metadata: isObject(object.metadata) ? object.metadata : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.taskId !== "") {
+      obj.taskId = message.taskId;
+    }
+    if (message.contextId !== "") {
+      obj.contextId = message.contextId;
+    }
+    if (message.artifact !== void 0) {
+      obj.artifact = Artifact.toJSON(message.artifact);
+    }
+    if (message.append !== false) {
+      obj.append = message.append;
+    }
+    if (message.lastChunk !== false) {
+      obj.lastChunk = message.lastChunk;
+    }
+    if (message.metadata !== void 0) {
+      obj.metadata = message.metadata;
+    }
+    return obj;
+  }
+};
+var PushNotificationConfig = {
+  fromJSON(object) {
+    return {
+      id: isSet(object.id) ? globalThis.String(object.id) : "",
+      url: isSet(object.url) ? globalThis.String(object.url) : "",
+      token: isSet(object.token) ? globalThis.String(object.token) : "",
+      authentication: isSet(object.authentication) ? AuthenticationInfo.fromJSON(object.authentication) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.id !== "") {
+      obj.id = message.id;
+    }
+    if (message.url !== "") {
+      obj.url = message.url;
+    }
+    if (message.token !== "") {
+      obj.token = message.token;
+    }
+    if (message.authentication !== void 0) {
+      obj.authentication = AuthenticationInfo.toJSON(message.authentication);
+    }
+    return obj;
+  }
+};
+var AuthenticationInfo = {
+  fromJSON(object) {
+    return {
+      schemes: globalThis.Array.isArray(object?.schemes) ? object.schemes.map((e) => globalThis.String(e)) : [],
+      credentials: isSet(object.credentials) ? globalThis.String(object.credentials) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.schemes?.length) {
+      obj.schemes = message.schemes;
+    }
+    if (message.credentials !== "") {
+      obj.credentials = message.credentials;
+    }
+    return obj;
+  }
+};
+var AgentInterface = {
+  fromJSON(object) {
+    return {
+      url: isSet(object.url) ? globalThis.String(object.url) : "",
+      transport: isSet(object.transport) ? globalThis.String(object.transport) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.url !== "") {
+      obj.url = message.url;
+    }
+    if (message.transport !== "") {
+      obj.transport = message.transport;
+    }
+    return obj;
+  }
+};
+var AgentCard = {
+  fromJSON(object) {
+    return {
+      protocolVersion: isSet(object.protocolVersion) ? globalThis.String(object.protocolVersion) : isSet(object.protocol_version) ? globalThis.String(object.protocol_version) : "",
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+      description: isSet(object.description) ? globalThis.String(object.description) : "",
+      url: isSet(object.url) ? globalThis.String(object.url) : "",
+      preferredTransport: isSet(object.preferredTransport) ? globalThis.String(object.preferredTransport) : isSet(object.preferred_transport) ? globalThis.String(object.preferred_transport) : "",
+      additionalInterfaces: globalThis.Array.isArray(object?.additionalInterfaces) ? object.additionalInterfaces.map((e) => AgentInterface.fromJSON(e)) : globalThis.Array.isArray(object?.additional_interfaces) ? object.additional_interfaces.map((e) => AgentInterface.fromJSON(e)) : [],
+      provider: isSet(object.provider) ? AgentProvider.fromJSON(object.provider) : void 0,
+      version: isSet(object.version) ? globalThis.String(object.version) : "",
+      documentationUrl: isSet(object.documentationUrl) ? globalThis.String(object.documentationUrl) : isSet(object.documentation_url) ? globalThis.String(object.documentation_url) : "",
+      capabilities: isSet(object.capabilities) ? AgentCapabilities.fromJSON(object.capabilities) : void 0,
+      securitySchemes: isObject(object.securitySchemes) ? globalThis.Object.entries(object.securitySchemes).reduce(
+        (acc, [key, value]) => {
+          acc[key] = SecurityScheme.fromJSON(value);
+          return acc;
+        },
+        {}
+      ) : isObject(object.security_schemes) ? globalThis.Object.entries(object.security_schemes).reduce(
+        (acc, [key, value]) => {
+          acc[key] = SecurityScheme.fromJSON(value);
+          return acc;
+        },
+        {}
+      ) : {},
+      security: globalThis.Array.isArray(object?.security) ? object.security.map((e) => Security.fromJSON(e)) : [],
+      defaultInputModes: globalThis.Array.isArray(object?.defaultInputModes) ? object.defaultInputModes.map((e) => globalThis.String(e)) : globalThis.Array.isArray(object?.default_input_modes) ? object.default_input_modes.map((e) => globalThis.String(e)) : [],
+      defaultOutputModes: globalThis.Array.isArray(object?.defaultOutputModes) ? object.defaultOutputModes.map((e) => globalThis.String(e)) : globalThis.Array.isArray(object?.default_output_modes) ? object.default_output_modes.map((e) => globalThis.String(e)) : [],
+      skills: globalThis.Array.isArray(object?.skills) ? object.skills.map((e) => AgentSkill.fromJSON(e)) : [],
+      supportsAuthenticatedExtendedCard: isSet(object.supportsAuthenticatedExtendedCard) ? globalThis.Boolean(object.supportsAuthenticatedExtendedCard) : isSet(object.supports_authenticated_extended_card) ? globalThis.Boolean(object.supports_authenticated_extended_card) : false,
+      signatures: globalThis.Array.isArray(object?.signatures) ? object.signatures.map((e) => AgentCardSignature.fromJSON(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.protocolVersion !== "") {
+      obj.protocolVersion = message.protocolVersion;
+    }
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    if (message.url !== "") {
+      obj.url = message.url;
+    }
+    if (message.preferredTransport !== "") {
+      obj.preferredTransport = message.preferredTransport;
+    }
+    if (message.additionalInterfaces?.length) {
+      obj.additionalInterfaces = message.additionalInterfaces.map((e) => AgentInterface.toJSON(e));
+    }
+    if (message.provider !== void 0) {
+      obj.provider = AgentProvider.toJSON(message.provider);
+    }
+    if (message.version !== "") {
+      obj.version = message.version;
+    }
+    if (message.documentationUrl !== "") {
+      obj.documentationUrl = message.documentationUrl;
+    }
+    if (message.capabilities !== void 0) {
+      obj.capabilities = AgentCapabilities.toJSON(message.capabilities);
+    }
+    if (message.securitySchemes) {
+      const entries = globalThis.Object.entries(message.securitySchemes);
+      if (entries.length > 0) {
+        obj.securitySchemes = {};
+        entries.forEach(([k, v]) => {
+          obj.securitySchemes[k] = SecurityScheme.toJSON(v);
+        });
+      }
+    }
+    if (message.security?.length) {
+      obj.security = message.security.map((e) => Security.toJSON(e));
+    }
+    if (message.defaultInputModes?.length) {
+      obj.defaultInputModes = message.defaultInputModes;
+    }
+    if (message.defaultOutputModes?.length) {
+      obj.defaultOutputModes = message.defaultOutputModes;
+    }
+    if (message.skills?.length) {
+      obj.skills = message.skills.map((e) => AgentSkill.toJSON(e));
+    }
+    if (message.supportsAuthenticatedExtendedCard !== false) {
+      obj.supportsAuthenticatedExtendedCard = message.supportsAuthenticatedExtendedCard;
+    }
+    if (message.signatures?.length) {
+      obj.signatures = message.signatures.map((e) => AgentCardSignature.toJSON(e));
+    }
+    return obj;
+  }
+};
+var AgentProvider = {
+  fromJSON(object) {
+    return {
+      url: isSet(object.url) ? globalThis.String(object.url) : "",
+      organization: isSet(object.organization) ? globalThis.String(object.organization) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.url !== "") {
+      obj.url = message.url;
+    }
+    if (message.organization !== "") {
+      obj.organization = message.organization;
+    }
+    return obj;
+  }
+};
+var AgentCapabilities = {
+  fromJSON(object) {
+    return {
+      streaming: isSet(object.streaming) ? globalThis.Boolean(object.streaming) : false,
+      pushNotifications: isSet(object.pushNotifications) ? globalThis.Boolean(object.pushNotifications) : isSet(object.push_notifications) ? globalThis.Boolean(object.push_notifications) : false,
+      extensions: globalThis.Array.isArray(object?.extensions) ? object.extensions.map((e) => AgentExtension.fromJSON(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.streaming !== false) {
+      obj.streaming = message.streaming;
+    }
+    if (message.pushNotifications !== false) {
+      obj.pushNotifications = message.pushNotifications;
+    }
+    if (message.extensions?.length) {
+      obj.extensions = message.extensions.map((e) => AgentExtension.toJSON(e));
+    }
+    return obj;
+  }
+};
+var AgentExtension = {
+  fromJSON(object) {
+    return {
+      uri: isSet(object.uri) ? globalThis.String(object.uri) : "",
+      description: isSet(object.description) ? globalThis.String(object.description) : "",
+      required: isSet(object.required) ? globalThis.Boolean(object.required) : false,
+      params: isObject(object.params) ? object.params : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.uri !== "") {
+      obj.uri = message.uri;
+    }
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    if (message.required !== false) {
+      obj.required = message.required;
+    }
+    if (message.params !== void 0) {
+      obj.params = message.params;
+    }
+    return obj;
+  }
+};
+var AgentSkill = {
+  fromJSON(object) {
+    return {
+      id: isSet(object.id) ? globalThis.String(object.id) : "",
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+      description: isSet(object.description) ? globalThis.String(object.description) : "",
+      tags: globalThis.Array.isArray(object?.tags) ? object.tags.map((e) => globalThis.String(e)) : [],
+      examples: globalThis.Array.isArray(object?.examples) ? object.examples.map((e) => globalThis.String(e)) : [],
+      inputModes: globalThis.Array.isArray(object?.inputModes) ? object.inputModes.map((e) => globalThis.String(e)) : globalThis.Array.isArray(object?.input_modes) ? object.input_modes.map((e) => globalThis.String(e)) : [],
+      outputModes: globalThis.Array.isArray(object?.outputModes) ? object.outputModes.map((e) => globalThis.String(e)) : globalThis.Array.isArray(object?.output_modes) ? object.output_modes.map((e) => globalThis.String(e)) : [],
+      security: globalThis.Array.isArray(object?.security) ? object.security.map((e) => Security.fromJSON(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.id !== "") {
+      obj.id = message.id;
+    }
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    if (message.tags?.length) {
+      obj.tags = message.tags;
+    }
+    if (message.examples?.length) {
+      obj.examples = message.examples;
+    }
+    if (message.inputModes?.length) {
+      obj.inputModes = message.inputModes;
+    }
+    if (message.outputModes?.length) {
+      obj.outputModes = message.outputModes;
+    }
+    if (message.security?.length) {
+      obj.security = message.security.map((e) => Security.toJSON(e));
+    }
+    return obj;
+  }
+};
+var AgentCardSignature = {
+  fromJSON(object) {
+    return {
+      protected: isSet(object.protected) ? globalThis.String(object.protected) : "",
+      signature: isSet(object.signature) ? globalThis.String(object.signature) : "",
+      header: isObject(object.header) ? object.header : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.protected !== "") {
+      obj.protected = message.protected;
+    }
+    if (message.signature !== "") {
+      obj.signature = message.signature;
+    }
+    if (message.header !== void 0) {
+      obj.header = message.header;
+    }
+    return obj;
+  }
+};
+var TaskPushNotificationConfig = {
+  fromJSON(object) {
+    return {
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+      pushNotificationConfig: isSet(object.pushNotificationConfig) ? PushNotificationConfig.fromJSON(object.pushNotificationConfig) : isSet(object.push_notification_config) ? PushNotificationConfig.fromJSON(object.push_notification_config) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.pushNotificationConfig !== void 0) {
+      obj.pushNotificationConfig = PushNotificationConfig.toJSON(message.pushNotificationConfig);
+    }
+    return obj;
+  }
+};
+var StringList = {
+  fromJSON(object) {
+    return { list: globalThis.Array.isArray(object?.list) ? object.list.map((e) => globalThis.String(e)) : [] };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.list?.length) {
+      obj.list = message.list;
+    }
+    return obj;
+  }
+};
+var Security = {
+  fromJSON(object) {
+    return {
+      schemes: isObject(object.schemes) ? globalThis.Object.entries(object.schemes).reduce(
+        (acc, [key, value]) => {
+          acc[key] = StringList.fromJSON(value);
+          return acc;
+        },
+        {}
+      ) : {}
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.schemes) {
+      const entries = globalThis.Object.entries(message.schemes);
+      if (entries.length > 0) {
+        obj.schemes = {};
+        entries.forEach(([k, v]) => {
+          obj.schemes[k] = StringList.toJSON(v);
+        });
+      }
+    }
+    return obj;
+  }
+};
+var SecurityScheme = {
+  fromJSON(object) {
+    return {
+      scheme: isSet(object.apiKeySecurityScheme) ? { $case: "apiKeySecurityScheme", value: APIKeySecurityScheme.fromJSON(object.apiKeySecurityScheme) } : isSet(object.api_key_security_scheme) ? { $case: "apiKeySecurityScheme", value: APIKeySecurityScheme.fromJSON(object.api_key_security_scheme) } : isSet(object.httpAuthSecurityScheme) ? { $case: "httpAuthSecurityScheme", value: HTTPAuthSecurityScheme.fromJSON(object.httpAuthSecurityScheme) } : isSet(object.http_auth_security_scheme) ? { $case: "httpAuthSecurityScheme", value: HTTPAuthSecurityScheme.fromJSON(object.http_auth_security_scheme) } : isSet(object.oauth2SecurityScheme) ? { $case: "oauth2SecurityScheme", value: OAuth2SecurityScheme.fromJSON(object.oauth2SecurityScheme) } : isSet(object.oauth2_security_scheme) ? { $case: "oauth2SecurityScheme", value: OAuth2SecurityScheme.fromJSON(object.oauth2_security_scheme) } : isSet(object.openIdConnectSecurityScheme) ? {
+        $case: "openIdConnectSecurityScheme",
+        value: OpenIdConnectSecurityScheme.fromJSON(object.openIdConnectSecurityScheme)
+      } : isSet(object.open_id_connect_security_scheme) ? {
+        $case: "openIdConnectSecurityScheme",
+        value: OpenIdConnectSecurityScheme.fromJSON(object.open_id_connect_security_scheme)
+      } : isSet(object.mtlsSecurityScheme) ? { $case: "mtlsSecurityScheme", value: MutualTlsSecurityScheme.fromJSON(object.mtlsSecurityScheme) } : isSet(object.mtls_security_scheme) ? { $case: "mtlsSecurityScheme", value: MutualTlsSecurityScheme.fromJSON(object.mtls_security_scheme) } : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.scheme?.$case === "apiKeySecurityScheme") {
+      obj.apiKeySecurityScheme = APIKeySecurityScheme.toJSON(message.scheme.value);
+    } else if (message.scheme?.$case === "httpAuthSecurityScheme") {
+      obj.httpAuthSecurityScheme = HTTPAuthSecurityScheme.toJSON(message.scheme.value);
+    } else if (message.scheme?.$case === "oauth2SecurityScheme") {
+      obj.oauth2SecurityScheme = OAuth2SecurityScheme.toJSON(message.scheme.value);
+    } else if (message.scheme?.$case === "openIdConnectSecurityScheme") {
+      obj.openIdConnectSecurityScheme = OpenIdConnectSecurityScheme.toJSON(message.scheme.value);
+    } else if (message.scheme?.$case === "mtlsSecurityScheme") {
+      obj.mtlsSecurityScheme = MutualTlsSecurityScheme.toJSON(message.scheme.value);
+    }
+    return obj;
+  }
+};
+var APIKeySecurityScheme = {
+  fromJSON(object) {
+    return {
+      description: isSet(object.description) ? globalThis.String(object.description) : "",
+      location: isSet(object.location) ? globalThis.String(object.location) : "",
+      name: isSet(object.name) ? globalThis.String(object.name) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    if (message.location !== "") {
+      obj.location = message.location;
+    }
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    return obj;
+  }
+};
+var HTTPAuthSecurityScheme = {
+  fromJSON(object) {
+    return {
+      description: isSet(object.description) ? globalThis.String(object.description) : "",
+      scheme: isSet(object.scheme) ? globalThis.String(object.scheme) : "",
+      bearerFormat: isSet(object.bearerFormat) ? globalThis.String(object.bearerFormat) : isSet(object.bearer_format) ? globalThis.String(object.bearer_format) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    if (message.scheme !== "") {
+      obj.scheme = message.scheme;
+    }
+    if (message.bearerFormat !== "") {
+      obj.bearerFormat = message.bearerFormat;
+    }
+    return obj;
+  }
+};
+var OAuth2SecurityScheme = {
+  fromJSON(object) {
+    return {
+      description: isSet(object.description) ? globalThis.String(object.description) : "",
+      flows: isSet(object.flows) ? OAuthFlows.fromJSON(object.flows) : void 0,
+      oauth2MetadataUrl: isSet(object.oauth2MetadataUrl) ? globalThis.String(object.oauth2MetadataUrl) : isSet(object.oauth2_metadata_url) ? globalThis.String(object.oauth2_metadata_url) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    if (message.flows !== void 0) {
+      obj.flows = OAuthFlows.toJSON(message.flows);
+    }
+    if (message.oauth2MetadataUrl !== "") {
+      obj.oauth2MetadataUrl = message.oauth2MetadataUrl;
+    }
+    return obj;
+  }
+};
+var OpenIdConnectSecurityScheme = {
+  fromJSON(object) {
+    return {
+      description: isSet(object.description) ? globalThis.String(object.description) : "",
+      openIdConnectUrl: isSet(object.openIdConnectUrl) ? globalThis.String(object.openIdConnectUrl) : isSet(object.open_id_connect_url) ? globalThis.String(object.open_id_connect_url) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    if (message.openIdConnectUrl !== "") {
+      obj.openIdConnectUrl = message.openIdConnectUrl;
+    }
+    return obj;
+  }
+};
+var MutualTlsSecurityScheme = {
+  fromJSON(object) {
+    return { description: isSet(object.description) ? globalThis.String(object.description) : "" };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    return obj;
+  }
+};
+var OAuthFlows = {
+  fromJSON(object) {
+    return {
+      flow: isSet(object.authorizationCode) ? { $case: "authorizationCode", value: AuthorizationCodeOAuthFlow.fromJSON(object.authorizationCode) } : isSet(object.authorization_code) ? { $case: "authorizationCode", value: AuthorizationCodeOAuthFlow.fromJSON(object.authorization_code) } : isSet(object.clientCredentials) ? { $case: "clientCredentials", value: ClientCredentialsOAuthFlow.fromJSON(object.clientCredentials) } : isSet(object.client_credentials) ? { $case: "clientCredentials", value: ClientCredentialsOAuthFlow.fromJSON(object.client_credentials) } : isSet(object.implicit) ? { $case: "implicit", value: ImplicitOAuthFlow.fromJSON(object.implicit) } : isSet(object.password) ? { $case: "password", value: PasswordOAuthFlow.fromJSON(object.password) } : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.flow?.$case === "authorizationCode") {
+      obj.authorizationCode = AuthorizationCodeOAuthFlow.toJSON(message.flow.value);
+    } else if (message.flow?.$case === "clientCredentials") {
+      obj.clientCredentials = ClientCredentialsOAuthFlow.toJSON(message.flow.value);
+    } else if (message.flow?.$case === "implicit") {
+      obj.implicit = ImplicitOAuthFlow.toJSON(message.flow.value);
+    } else if (message.flow?.$case === "password") {
+      obj.password = PasswordOAuthFlow.toJSON(message.flow.value);
+    }
+    return obj;
+  }
+};
+var AuthorizationCodeOAuthFlow = {
+  fromJSON(object) {
+    return {
+      authorizationUrl: isSet(object.authorizationUrl) ? globalThis.String(object.authorizationUrl) : isSet(object.authorization_url) ? globalThis.String(object.authorization_url) : "",
+      tokenUrl: isSet(object.tokenUrl) ? globalThis.String(object.tokenUrl) : isSet(object.token_url) ? globalThis.String(object.token_url) : "",
+      refreshUrl: isSet(object.refreshUrl) ? globalThis.String(object.refreshUrl) : isSet(object.refresh_url) ? globalThis.String(object.refresh_url) : "",
+      scopes: isObject(object.scopes) ? globalThis.Object.entries(object.scopes).reduce(
+        (acc, [key, value]) => {
+          acc[key] = globalThis.String(value);
+          return acc;
+        },
+        {}
+      ) : {}
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.authorizationUrl !== "") {
+      obj.authorizationUrl = message.authorizationUrl;
+    }
+    if (message.tokenUrl !== "") {
+      obj.tokenUrl = message.tokenUrl;
+    }
+    if (message.refreshUrl !== "") {
+      obj.refreshUrl = message.refreshUrl;
+    }
+    if (message.scopes) {
+      const entries = globalThis.Object.entries(message.scopes);
+      if (entries.length > 0) {
+        obj.scopes = {};
+        entries.forEach(([k, v]) => {
+          obj.scopes[k] = v;
+        });
+      }
+    }
+    return obj;
+  }
+};
+var ClientCredentialsOAuthFlow = {
+  fromJSON(object) {
+    return {
+      tokenUrl: isSet(object.tokenUrl) ? globalThis.String(object.tokenUrl) : isSet(object.token_url) ? globalThis.String(object.token_url) : "",
+      refreshUrl: isSet(object.refreshUrl) ? globalThis.String(object.refreshUrl) : isSet(object.refresh_url) ? globalThis.String(object.refresh_url) : "",
+      scopes: isObject(object.scopes) ? globalThis.Object.entries(object.scopes).reduce(
+        (acc, [key, value]) => {
+          acc[key] = globalThis.String(value);
+          return acc;
+        },
+        {}
+      ) : {}
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.tokenUrl !== "") {
+      obj.tokenUrl = message.tokenUrl;
+    }
+    if (message.refreshUrl !== "") {
+      obj.refreshUrl = message.refreshUrl;
+    }
+    if (message.scopes) {
+      const entries = globalThis.Object.entries(message.scopes);
+      if (entries.length > 0) {
+        obj.scopes = {};
+        entries.forEach(([k, v]) => {
+          obj.scopes[k] = v;
+        });
+      }
+    }
+    return obj;
+  }
+};
+var ImplicitOAuthFlow = {
+  fromJSON(object) {
+    return {
+      authorizationUrl: isSet(object.authorizationUrl) ? globalThis.String(object.authorizationUrl) : isSet(object.authorization_url) ? globalThis.String(object.authorization_url) : "",
+      refreshUrl: isSet(object.refreshUrl) ? globalThis.String(object.refreshUrl) : isSet(object.refresh_url) ? globalThis.String(object.refresh_url) : "",
+      scopes: isObject(object.scopes) ? globalThis.Object.entries(object.scopes).reduce(
+        (acc, [key, value]) => {
+          acc[key] = globalThis.String(value);
+          return acc;
+        },
+        {}
+      ) : {}
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.authorizationUrl !== "") {
+      obj.authorizationUrl = message.authorizationUrl;
+    }
+    if (message.refreshUrl !== "") {
+      obj.refreshUrl = message.refreshUrl;
+    }
+    if (message.scopes) {
+      const entries = globalThis.Object.entries(message.scopes);
+      if (entries.length > 0) {
+        obj.scopes = {};
+        entries.forEach(([k, v]) => {
+          obj.scopes[k] = v;
+        });
+      }
+    }
+    return obj;
+  }
+};
+var PasswordOAuthFlow = {
+  fromJSON(object) {
+    return {
+      tokenUrl: isSet(object.tokenUrl) ? globalThis.String(object.tokenUrl) : isSet(object.token_url) ? globalThis.String(object.token_url) : "",
+      refreshUrl: isSet(object.refreshUrl) ? globalThis.String(object.refreshUrl) : isSet(object.refresh_url) ? globalThis.String(object.refresh_url) : "",
+      scopes: isObject(object.scopes) ? globalThis.Object.entries(object.scopes).reduce(
+        (acc, [key, value]) => {
+          acc[key] = globalThis.String(value);
+          return acc;
+        },
+        {}
+      ) : {}
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.tokenUrl !== "") {
+      obj.tokenUrl = message.tokenUrl;
+    }
+    if (message.refreshUrl !== "") {
+      obj.refreshUrl = message.refreshUrl;
+    }
+    if (message.scopes) {
+      const entries = globalThis.Object.entries(message.scopes);
+      if (entries.length > 0) {
+        obj.scopes = {};
+        entries.forEach(([k, v]) => {
+          obj.scopes[k] = v;
+        });
+      }
+    }
+    return obj;
+  }
+};
+var SendMessageRequest = {
+  fromJSON(object) {
+    return {
+      request: isSet(object.message) ? Message.fromJSON(object.message) : isSet(object.request) ? Message.fromJSON(object.request) : void 0,
+      configuration: isSet(object.configuration) ? SendMessageConfiguration.fromJSON(object.configuration) : void 0,
+      metadata: isObject(object.metadata) ? object.metadata : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.request !== void 0) {
+      obj.message = Message.toJSON(message.request);
+    }
+    if (message.configuration !== void 0) {
+      obj.configuration = SendMessageConfiguration.toJSON(message.configuration);
+    }
+    if (message.metadata !== void 0) {
+      obj.metadata = message.metadata;
+    }
+    return obj;
+  }
+};
+var SendMessageResponse = {
+  fromJSON(object) {
+    return {
+      payload: isSet(object.task) ? { $case: "task", value: Task.fromJSON(object.task) } : isSet(object.message) ? { $case: "msg", value: Message.fromJSON(object.message) } : isSet(object.msg) ? { $case: "msg", value: Message.fromJSON(object.msg) } : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.payload?.$case === "task") {
+      obj.task = Task.toJSON(message.payload.value);
+    } else if (message.payload?.$case === "msg") {
+      obj.message = Message.toJSON(message.payload.value);
+    }
+    return obj;
+  }
+};
+var StreamResponse = {
+  fromJSON(object) {
+    return {
+      payload: isSet(object.task) ? { $case: "task", value: Task.fromJSON(object.task) } : isSet(object.message) ? { $case: "msg", value: Message.fromJSON(object.message) } : isSet(object.msg) ? { $case: "msg", value: Message.fromJSON(object.msg) } : isSet(object.statusUpdate) ? { $case: "statusUpdate", value: TaskStatusUpdateEvent.fromJSON(object.statusUpdate) } : isSet(object.status_update) ? { $case: "statusUpdate", value: TaskStatusUpdateEvent.fromJSON(object.status_update) } : isSet(object.artifactUpdate) ? { $case: "artifactUpdate", value: TaskArtifactUpdateEvent.fromJSON(object.artifactUpdate) } : isSet(object.artifact_update) ? { $case: "artifactUpdate", value: TaskArtifactUpdateEvent.fromJSON(object.artifact_update) } : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.payload?.$case === "task") {
+      obj.task = Task.toJSON(message.payload.value);
+    } else if (message.payload?.$case === "msg") {
+      obj.message = Message.toJSON(message.payload.value);
+    } else if (message.payload?.$case === "statusUpdate") {
+      obj.statusUpdate = TaskStatusUpdateEvent.toJSON(message.payload.value);
+    } else if (message.payload?.$case === "artifactUpdate") {
+      obj.artifactUpdate = TaskArtifactUpdateEvent.toJSON(message.payload.value);
+    }
+    return obj;
+  }
+};
+var ListTaskPushNotificationConfigResponse = {
+  fromJSON(object) {
+    return {
+      configs: globalThis.Array.isArray(object?.configs) ? object.configs.map((e) => TaskPushNotificationConfig.fromJSON(e)) : [],
+      nextPageToken: isSet(object.nextPageToken) ? globalThis.String(object.nextPageToken) : isSet(object.next_page_token) ? globalThis.String(object.next_page_token) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.configs?.length) {
+      obj.configs = message.configs.map((e) => TaskPushNotificationConfig.toJSON(e));
+    }
+    if (message.nextPageToken !== "") {
+      obj.nextPageToken = message.nextPageToken;
+    }
+    return obj;
+  }
+};
+function bytesFromBase64(b64) {
+  return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+}
+function base64FromBytes(arr) {
+  return globalThis.Buffer.from(arr).toString("base64");
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isSet(value) {
+  return value !== null && value !== void 0;
+}
+
+// src/compat/v0_3/types/converters/id_decoding.ts
+var CONFIG_REGEX = /^tasks\/([^/]+)\/pushNotificationConfigs\/([^/]+)$/;
+var TASK_ONLY_REGEX = /^tasks\/([^/]+)(?:\/|$)/;
+var extractTaskId = (name) => {
+  const match = name.match(TASK_ONLY_REGEX);
+  if (!match) {
+    throw A2AError2.invalidParams(`Invalid or missing task ID in: "${name}"`);
+  }
+  return match[1];
+};
+var generateTaskName = (taskId) => {
+  return `tasks/${taskId}`;
+};
+var extractTaskAndPushNotificationConfigId = (name) => {
+  const match = name.match(CONFIG_REGEX);
+  if (!match) {
+    throw A2AError2.invalidParams(`Invalid or missing config ID in: "${name}"`);
+  }
+  return { taskId: match[1], configId: match[2] };
+};
+var generatePushNotificationConfigName = (taskId, configId) => {
+  return `tasks/${taskId}/pushNotificationConfigs/${configId}`;
+};
+
+// src/compat/v0_3/types/converters/from_proto.ts
+var FromProto = class _FromProto {
+  static taskQueryParams(request) {
+    return {
+      id: extractTaskId(request.name),
+      historyLength: request.historyLength
+    };
+  }
+  static taskIdParams(request) {
+    return {
+      id: extractTaskId(request.name)
+    };
+  }
+  static getTaskPushNotificationConfigParams(request) {
+    const { taskId, configId } = extractTaskAndPushNotificationConfigId(request.name);
+    return {
+      id: taskId,
+      pushNotificationConfigId: configId
+    };
+  }
+  static listTaskPushNotificationConfigParams(request) {
+    return {
+      id: extractTaskId(request.parent)
+    };
+  }
+  static createTaskPushNotificationConfig(request) {
+    if (!request.config?.pushNotificationConfig) {
+      throw A2AError2.invalidParams(
+        "Request must include a `config` object with a `pushNotificationConfig`"
+      );
+    }
+    return {
+      taskId: extractTaskId(request.parent),
+      pushNotificationConfig: _FromProto.pushNotificationConfig(
+        request.config.pushNotificationConfig
+      )
+    };
+  }
+  static deleteTaskPushNotificationConfigParams(request) {
+    const { taskId, configId } = extractTaskAndPushNotificationConfigId(request.name);
+    return {
+      id: taskId,
+      pushNotificationConfigId: configId
+    };
+  }
+  static message(message) {
+    if (!message) {
+      return void 0;
+    }
+    return {
+      kind: "message",
+      messageId: message.messageId,
+      parts: message.content.map((p) => _FromProto.part(p)),
+      contextId: message.contextId || void 0,
+      taskId: message.taskId || void 0,
+      role: _FromProto.role(message.role),
+      metadata: message.metadata,
+      extensions: message.extensions
+    };
+  }
+  static role(role) {
+    switch (role) {
+      case 2 /* ROLE_AGENT */:
+        return "agent";
+      case 1 /* ROLE_USER */:
+        return "user";
+      default:
+        throw A2AError2.invalidParams(`Invalid role: ${role}`);
+    }
+  }
+  static messageSendConfiguration(configuration) {
+    if (!configuration) {
+      return void 0;
+    }
+    return {
+      blocking: configuration.blocking,
+      acceptedOutputModes: configuration.acceptedOutputModes,
+      pushNotificationConfig: _FromProto.pushNotificationConfig(configuration.pushNotification)
+    };
+  }
+  static pushNotificationConfig(config) {
+    if (!config) {
+      return void 0;
+    }
+    return {
+      id: config.id,
+      url: config.url,
+      token: config.token || void 0,
+      authentication: _FromProto.pushNotificationAuthenticationInfo(config.authentication)
+    };
+  }
+  static pushNotificationAuthenticationInfo(authInfo) {
+    if (!authInfo) {
+      return void 0;
+    }
+    return {
+      schemes: authInfo.schemes,
+      credentials: authInfo.credentials
+    };
+  }
+  static part(part) {
+    if (part.part?.$case === "text") {
+      return {
+        kind: "text",
+        text: part.part.value
+      };
+    }
+    if (part.part?.$case === "file") {
+      const filePart = part.part.value;
+      if (filePart.file?.$case === "fileWithUri") {
+        return {
+          kind: "file",
+          file: {
+            uri: filePart.file.value,
+            mimeType: filePart.mimeType
+          }
+        };
+      } else if (filePart.file?.$case === "fileWithBytes") {
+        return {
+          kind: "file",
+          file: {
+            bytes: Buffer.from(filePart.file.value).toString("base64"),
+            mimeType: filePart.mimeType
+          }
+        };
+      }
+      throw A2AError2.invalidParams("Invalid file part type");
+    }
+    if (part.part?.$case === "data") {
+      return {
+        kind: "data",
+        data: part.part.value.data ?? {}
+      };
+    }
+    throw A2AError2.invalidParams("Invalid part type");
+  }
+  static messageSendParams(request) {
+    if (!request.request) {
+      throw A2AError2.invalidParams("SendMessageRequest missing message");
+    }
+    return {
+      message: _FromProto.message(request.request),
+      configuration: _FromProto.messageSendConfiguration(request.configuration),
+      metadata: request.metadata
+    };
+  }
+  static sendMessageResult(response) {
+    if (response.payload?.$case === "task") {
+      return _FromProto.task(response.payload.value);
+    } else if (response.payload?.$case === "msg") {
+      return _FromProto.message(response.payload.value);
+    }
+    throw A2AError2.invalidParams("Invalid SendMessageResponse: missing result");
+  }
+  static task(task) {
+    if (!task.status) {
+      throw A2AError2.internalError("Task missing status");
+    }
+    return {
+      kind: "task",
+      id: task.id,
+      status: _FromProto.taskStatus(task.status),
+      contextId: task.contextId,
+      artifacts: task.artifacts?.map((a) => _FromProto.artifact(a)),
+      history: task.history?.map((h) => _FromProto.message(h)),
+      metadata: task.metadata
+    };
+  }
+  static taskStatus(status) {
+    return {
+      message: _FromProto.message(status.update),
+      state: _FromProto.taskState(status.state),
+      timestamp: status.timestamp
+    };
+  }
+  static taskState(state) {
+    switch (state) {
+      case 1 /* TASK_STATE_SUBMITTED */:
+        return "submitted";
+      case 2 /* TASK_STATE_WORKING */:
+        return "working";
+      case 6 /* TASK_STATE_INPUT_REQUIRED */:
+        return "input-required";
+      case 3 /* TASK_STATE_COMPLETED */:
+        return "completed";
+      case 5 /* TASK_STATE_CANCELLED */:
+        return "canceled";
+      case 4 /* TASK_STATE_FAILED */:
+        return "failed";
+      case 7 /* TASK_STATE_REJECTED */:
+        return "rejected";
+      case 8 /* TASK_STATE_AUTH_REQUIRED */:
+        return "auth-required";
+      case 0 /* TASK_STATE_UNSPECIFIED */:
+        return "unknown";
+      default:
+        throw A2AError2.invalidParams(`Invalid task state: ${state}`);
+    }
+  }
+  static artifact(artifact) {
+    return {
+      artifactId: artifact.artifactId,
+      name: artifact.name || void 0,
+      description: artifact.description || void 0,
+      parts: artifact.parts.map((p) => _FromProto.part(p)),
+      metadata: artifact.metadata
+    };
+  }
+  static taskPushNotificationConfig(request) {
+    if (!request.pushNotificationConfig) {
+      throw A2AError2.invalidParams("TaskPushNotificationConfig missing pushNotificationConfig");
+    }
+    return {
+      taskId: extractTaskId(request.name),
+      pushNotificationConfig: _FromProto.pushNotificationConfig(request.pushNotificationConfig)
+    };
+  }
+  static listTaskPushNotificationConfig(request) {
+    return request.configs.map((c) => _FromProto.taskPushNotificationConfig(c));
+  }
+  static agentCard(agentCard) {
+    return {
+      additionalInterfaces: agentCard.additionalInterfaces?.map((i) => _FromProto.agentInterface(i)),
+      capabilities: agentCard.capabilities ? _FromProto.agentCapabilities(agentCard.capabilities) : {},
+      defaultInputModes: agentCard.defaultInputModes,
+      defaultOutputModes: agentCard.defaultOutputModes,
+      description: agentCard.description,
+      documentationUrl: agentCard.documentationUrl || void 0,
+      name: agentCard.name,
+      preferredTransport: agentCard.preferredTransport,
+      provider: agentCard.provider ? _FromProto.agentProvider(agentCard.provider) : void 0,
+      protocolVersion: agentCard.protocolVersion,
+      security: agentCard.security?.map((s) => _FromProto.security(s)),
+      securitySchemes: agentCard.securitySchemes ? Object.fromEntries(
+        Object.entries(agentCard.securitySchemes).map(([key, value]) => [
+          key,
+          _FromProto.securityScheme(value)
+        ])
+      ) : {},
+      skills: agentCard.skills.map((s) => _FromProto.skills(s)),
+      signatures: agentCard.signatures?.map((s) => _FromProto.agentCardSignature(s)),
+      supportsAuthenticatedExtendedCard: agentCard.supportsAuthenticatedExtendedCard,
+      url: agentCard.url,
+      version: agentCard.version
+    };
+  }
+  static agentCapabilities(capabilities) {
+    return {
+      extensions: capabilities.extensions?.map((e) => _FromProto.agentExtension(e)),
+      pushNotifications: capabilities.pushNotifications,
+      streaming: capabilities.streaming
+    };
+  }
+  static agentExtension(extension) {
+    return {
+      uri: extension.uri,
+      description: extension.description || void 0,
+      required: extension.required,
+      params: extension.params
+    };
+  }
+  static agentInterface(intf) {
+    return {
+      transport: intf.transport,
+      url: intf.url
+    };
+  }
+  static agentProvider(provider) {
+    return {
+      organization: provider.organization,
+      url: provider.url
+    };
+  }
+  static security(security) {
+    return Object.fromEntries(
+      Object.entries(security.schemes)?.map(([key, value]) => [key, value.list])
+    );
+  }
+  static securityScheme(securitySchemes) {
+    switch (securitySchemes.scheme?.$case) {
+      case "apiKeySecurityScheme":
+        return {
+          type: "apiKey",
+          name: securitySchemes.scheme.value.name,
+          in: securitySchemes.scheme.value.location,
+          description: securitySchemes.scheme.value.description || void 0
+        };
+      case "httpAuthSecurityScheme":
+        return {
+          type: "http",
+          scheme: securitySchemes.scheme.value.scheme,
+          bearerFormat: securitySchemes.scheme.value.bearerFormat || void 0,
+          description: securitySchemes.scheme.value.description || void 0
+        };
+      case "mtlsSecurityScheme":
+        return {
+          type: "mutualTLS",
+          description: securitySchemes.scheme.value.description || void 0
+        };
+      case "oauth2SecurityScheme":
+        if (!securitySchemes.scheme.value.flows) {
+          throw A2AError2.internalError("OAuth2 security scheme missing flows");
+        }
+        return {
+          type: "oauth2",
+          description: securitySchemes.scheme.value.description || void 0,
+          flows: _FromProto.oauthFlows(securitySchemes.scheme.value.flows),
+          oauth2MetadataUrl: securitySchemes.scheme.value.oauth2MetadataUrl || void 0
+        };
+      case "openIdConnectSecurityScheme":
+        return {
+          type: "openIdConnect",
+          description: securitySchemes.scheme.value.description || void 0,
+          openIdConnectUrl: securitySchemes.scheme.value.openIdConnectUrl
+        };
+      default:
+        throw A2AError2.internalError(`Unsupported security scheme type`);
+    }
+  }
+  static oauthFlows(flows) {
+    switch (flows.flow?.$case) {
+      case "implicit":
+        return {
+          implicit: {
+            authorizationUrl: flows.flow.value.authorizationUrl,
+            scopes: flows.flow.value.scopes,
+            refreshUrl: flows.flow.value.refreshUrl || void 0
+          }
+        };
+      case "password":
+        return {
+          password: {
+            refreshUrl: flows.flow.value.refreshUrl || void 0,
+            scopes: flows.flow.value.scopes,
+            tokenUrl: flows.flow.value.tokenUrl
+          }
+        };
+      case "authorizationCode":
+        return {
+          authorizationCode: {
+            refreshUrl: flows.flow.value.refreshUrl || void 0,
+            authorizationUrl: flows.flow.value.authorizationUrl,
+            scopes: flows.flow.value.scopes,
+            tokenUrl: flows.flow.value.tokenUrl
+          }
+        };
+      case "clientCredentials":
+        return {
+          clientCredentials: {
+            refreshUrl: flows.flow.value.refreshUrl || void 0,
+            scopes: flows.flow.value.scopes,
+            tokenUrl: flows.flow.value.tokenUrl
+          }
+        };
+      default:
+        throw A2AError2.internalError(`Unsupported OAuth flows`);
+    }
+  }
+  static skills(skill) {
+    return {
+      id: skill.id,
+      name: skill.name,
+      description: skill.description,
+      tags: skill.tags,
+      examples: skill.examples,
+      inputModes: skill.inputModes,
+      outputModes: skill.outputModes,
+      security: skill.security?.map((s) => _FromProto.security(s))
+    };
+  }
+  static agentCardSignature(signatures) {
+    return {
+      protected: signatures.protected,
+      signature: signatures.signature,
+      header: signatures.header
+    };
+  }
+  static taskStatusUpdateEvent(event) {
+    if (!event.status) {
+      throw A2AError2.invalidParams("Invalid TaskStatusUpdateEvent: missing status");
+    }
+    return {
+      kind: "status-update",
+      taskId: event.taskId,
+      status: _FromProto.taskStatus(event.status),
+      contextId: event.contextId,
+      metadata: event.metadata,
+      final: event.final
+    };
+  }
+  static taskArtifactUpdateEvent(event) {
+    if (!event.artifact) {
+      throw A2AError2.invalidParams("Invalid TaskArtifactUpdateEvent: missing artifact");
+    }
+    return {
+      kind: "artifact-update",
+      taskId: event.taskId,
+      artifact: _FromProto.artifact(event.artifact),
+      contextId: event.contextId,
+      metadata: event.metadata,
+      lastChunk: event.lastChunk
+    };
+  }
+  static messageStreamResult(event) {
+    switch (event.payload?.$case) {
+      case "msg":
+        return _FromProto.message(event.payload.value);
+      case "task":
+        return _FromProto.task(event.payload.value);
+      case "statusUpdate":
+        return _FromProto.taskStatusUpdateEvent(event.payload.value);
+      case "artifactUpdate":
+        return _FromProto.taskArtifactUpdateEvent(event.payload.value);
+      default:
+        throw A2AError2.internalError("Invalid event type in StreamResponse");
+    }
+  }
+};
+
+// src/compat/v0_3/types/converters/to_proto.ts
+var ToProto = class _ToProto {
+  static agentCard(agentCard) {
+    return {
+      protocolVersion: agentCard.protocolVersion,
+      name: agentCard.name,
+      description: agentCard.description,
+      url: agentCard.url,
+      preferredTransport: agentCard.preferredTransport ?? "",
+      additionalInterfaces: agentCard.additionalInterfaces?.map((i) => _ToProto.agentInterface(i)) ?? [],
+      provider: _ToProto.agentProvider(agentCard.provider),
+      version: agentCard.version,
+      documentationUrl: agentCard.documentationUrl ?? "",
+      capabilities: _ToProto.agentCapabilities(agentCard.capabilities),
+      securitySchemes: agentCard.securitySchemes ? Object.fromEntries(
+        Object.entries(agentCard.securitySchemes).map(([key, value]) => [
+          key,
+          _ToProto.securityScheme(value)
+        ])
+      ) : {},
+      security: agentCard.security?.map((s) => _ToProto.security(s)) ?? [],
+      defaultInputModes: agentCard.defaultInputModes,
+      defaultOutputModes: agentCard.defaultOutputModes,
+      skills: agentCard.skills.map((s) => _ToProto.agentSkill(s)),
+      supportsAuthenticatedExtendedCard: agentCard.supportsAuthenticatedExtendedCard ?? false,
+      signatures: agentCard.signatures?.map((s) => _ToProto.agentCardSignature(s)) ?? []
+    };
+  }
+  static agentCardSignature(signatures) {
+    return {
+      protected: signatures.protected,
+      signature: signatures.signature,
+      header: signatures.header
+    };
+  }
+  static agentSkill(skill) {
+    return {
+      id: skill.id,
+      name: skill.name,
+      description: skill.description,
+      tags: skill.tags ?? [],
+      examples: skill.examples ?? [],
+      inputModes: skill.inputModes ?? [],
+      outputModes: skill.outputModes ?? [],
+      security: skill.security ? skill.security.map((s) => _ToProto.security(s)) : []
+    };
+  }
+  static security(security) {
+    return {
+      schemes: Object.fromEntries(
+        Object.entries(security).map(([key, value]) => {
+          return [key, { list: value }];
+        })
+      )
+    };
+  }
+  static securityScheme(scheme) {
+    switch (scheme.type) {
+      case "apiKey":
+        return {
+          scheme: {
+            $case: "apiKeySecurityScheme",
+            value: {
+              name: scheme.name,
+              location: scheme.in,
+              description: scheme.description ?? ""
+            }
+          }
+        };
+      case "http":
+        return {
+          scheme: {
+            $case: "httpAuthSecurityScheme",
+            value: {
+              description: scheme.description ?? "",
+              scheme: scheme.scheme,
+              bearerFormat: scheme.bearerFormat ?? ""
+            }
+          }
+        };
+      case "mutualTLS":
+        return {
+          scheme: {
+            $case: "mtlsSecurityScheme",
+            value: {
+              description: scheme.description ?? ""
+            }
+          }
+        };
+      case "oauth2":
+        return {
+          scheme: {
+            $case: "oauth2SecurityScheme",
+            value: {
+              description: scheme.description ?? "",
+              flows: _ToProto.oauthFlows(scheme.flows),
+              oauth2MetadataUrl: scheme.oauth2MetadataUrl ?? ""
+            }
+          }
+        };
+      case "openIdConnect":
+        return {
+          scheme: {
+            $case: "openIdConnectSecurityScheme",
+            value: {
+              description: scheme.description ?? "",
+              openIdConnectUrl: scheme.openIdConnectUrl
+            }
+          }
+        };
+      default:
+        throw A2AError2.internalError(`Unsupported security scheme type`);
+    }
+  }
+  static oauthFlows(flows) {
+    if (flows.implicit) {
+      return {
+        flow: {
+          $case: "implicit",
+          value: {
+            authorizationUrl: flows.implicit.authorizationUrl,
+            scopes: flows.implicit.scopes,
+            refreshUrl: flows.implicit.refreshUrl ?? ""
+          }
+        }
+      };
+    } else if (flows.password) {
+      return {
+        flow: {
+          $case: "password",
+          value: {
+            tokenUrl: flows.password.tokenUrl,
+            scopes: flows.password.scopes,
+            refreshUrl: flows.password.refreshUrl ?? ""
+          }
+        }
+      };
+    } else if (flows.clientCredentials) {
+      return {
+        flow: {
+          $case: "clientCredentials",
+          value: {
+            tokenUrl: flows.clientCredentials.tokenUrl,
+            scopes: flows.clientCredentials.scopes,
+            refreshUrl: flows.clientCredentials.refreshUrl ?? ""
+          }
+        }
+      };
+    } else if (flows.authorizationCode) {
+      return {
+        flow: {
+          $case: "authorizationCode",
+          value: {
+            authorizationUrl: flows.authorizationCode.authorizationUrl,
+            tokenUrl: flows.authorizationCode.tokenUrl,
+            scopes: flows.authorizationCode.scopes,
+            refreshUrl: flows.authorizationCode.refreshUrl ?? ""
+          }
+        }
+      };
+    } else {
+      throw A2AError2.internalError(`Unsupported OAuth flows`);
+    }
+  }
+  static agentInterface(agentInterface) {
+    return {
+      transport: agentInterface.transport,
+      url: agentInterface.url
+    };
+  }
+  static agentProvider(agentProvider) {
+    if (!agentProvider) {
+      return void 0;
+    }
+    return {
+      url: agentProvider.url,
+      organization: agentProvider.organization
+    };
+  }
+  static agentCapabilities(capabilities) {
+    if (!capabilities) {
+      return { streaming: false, pushNotifications: false, extensions: [] };
+    }
+    return {
+      streaming: capabilities.streaming ?? false,
+      pushNotifications: capabilities.pushNotifications ?? false,
+      extensions: capabilities.extensions ? capabilities.extensions.map((e) => _ToProto.agentExtension(e)) : []
+    };
+  }
+  static agentExtension(extension) {
+    return {
+      uri: extension.uri,
+      description: extension.description ?? "",
+      required: extension.required ?? false,
+      params: extension.params
+    };
+  }
+  static listTaskPushNotificationConfig(config) {
+    return {
+      configs: config.map((c) => _ToProto.taskPushNotificationConfig(c)),
+      nextPageToken: ""
+    };
+  }
+  static getTaskPushNotificationConfigParams(config) {
+    return {
+      name: generatePushNotificationConfigName(config.id, config.pushNotificationConfigId ?? "")
+    };
+  }
+  static listTaskPushNotificationConfigParams(config) {
+    return {
+      parent: generateTaskName(config.id),
+      pageToken: "",
+      pageSize: 0
+    };
+  }
+  static deleteTaskPushNotificationConfigParams(config) {
+    return {
+      name: generatePushNotificationConfigName(config.id, config.pushNotificationConfigId)
+    };
+  }
+  static taskPushNotificationConfig(config) {
+    return {
+      name: generatePushNotificationConfigName(
+        config.taskId,
+        config.pushNotificationConfig.id ?? ""
+      ),
+      pushNotificationConfig: _ToProto.pushNotificationConfig(config.pushNotificationConfig)
+    };
+  }
+  static taskPushNotificationConfigCreate(config) {
+    return {
+      parent: generateTaskName(config.taskId),
+      config: _ToProto.taskPushNotificationConfig(config),
+      configId: config.pushNotificationConfig.id ?? ""
+    };
+  }
+  static pushNotificationConfig(config) {
+    if (!config) {
+      return void 0;
+    }
+    return {
+      id: config.id ?? "",
+      url: config.url,
+      token: config.token ?? "",
+      authentication: _ToProto.pushNotificationAuthenticationInfo(config.authentication)
+    };
+  }
+  static pushNotificationAuthenticationInfo(authInfo) {
+    if (!authInfo) {
+      return void 0;
+    }
+    return {
+      schemes: authInfo.schemes,
+      credentials: authInfo.credentials ?? ""
+    };
+  }
+  static messageStreamResult(event) {
+    if (event.kind === "message") {
+      return {
+        payload: {
+          $case: "msg",
+          value: _ToProto.message(event)
+        }
+      };
+    } else if (event.kind === "task") {
+      return {
+        payload: {
+          $case: "task",
+          value: _ToProto.task(event)
+        }
+      };
+    } else if (event.kind === "status-update") {
+      return {
+        payload: {
+          $case: "statusUpdate",
+          value: _ToProto.taskStatusUpdateEvent(event)
+        }
+      };
+    } else if (event.kind === "artifact-update") {
+      return {
+        payload: {
+          $case: "artifactUpdate",
+          value: _ToProto.taskArtifactUpdateEvent(event)
+        }
+      };
+    } else {
+      throw A2AError2.internalError("Invalid event type");
+    }
+  }
+  static taskStatusUpdateEvent(event) {
+    return {
+      taskId: event.taskId,
+      status: _ToProto.taskStatus(event.status),
+      contextId: event.contextId,
+      metadata: event.metadata,
+      final: event.final
+    };
+  }
+  static taskArtifactUpdateEvent(event) {
+    return {
+      taskId: event.taskId,
+      artifact: _ToProto.artifact(event.artifact),
+      contextId: event.contextId,
+      metadata: event.metadata,
+      append: event.append ?? false,
+      lastChunk: event.lastChunk ?? false
+    };
+  }
+  static messageSendResult(params) {
+    if (!params.kind) {
+      return void 0;
+    }
+    if (params.kind === "message") {
+      return {
+        payload: {
+          $case: "msg",
+          value: _ToProto.message(params)
+        }
+      };
+    } else if (params.kind === "task") {
+      return {
+        payload: {
+          $case: "task",
+          value: _ToProto.task(params)
+        }
+      };
+    }
+  }
+  static message(message) {
+    if (!message) {
+      return void 0;
+    }
+    return {
+      messageId: message.messageId,
+      content: message.parts.map((p) => _ToProto.part(p)),
+      contextId: message.contextId ?? "",
+      taskId: message.taskId ?? "",
+      role: _ToProto.role(message.role),
+      metadata: message.metadata,
+      extensions: message.extensions ?? []
+    };
+  }
+  static role(role) {
+    switch (role) {
+      case "agent":
+        return 2 /* ROLE_AGENT */;
+      case "user":
+        return 1 /* ROLE_USER */;
+      default:
+        throw A2AError2.internalError(`Invalid role`);
+    }
+  }
+  static task(task) {
+    return {
+      id: task.id,
+      contextId: task.contextId,
+      status: _ToProto.taskStatus(task.status),
+      artifacts: task.artifacts?.map((a) => _ToProto.artifact(a)) ?? [],
+      history: task.history?.map((m) => _ToProto.message(m)).filter((m) => !!m) ?? [],
+      metadata: task.metadata
+    };
+  }
+  static taskStatus(status) {
+    return {
+      state: _ToProto.taskState(status.state),
+      update: _ToProto.message(status.message),
+      timestamp: status.timestamp
+    };
+  }
+  static artifact(artifact) {
+    return {
+      artifactId: artifact.artifactId,
+      name: artifact.name ?? "",
+      description: artifact.description ?? "",
+      parts: artifact.parts.map((p) => _ToProto.part(p)),
+      metadata: artifact.metadata,
+      extensions: artifact.extensions ? artifact.extensions : []
+    };
+  }
+  static taskState(state) {
+    switch (state) {
+      case "submitted":
+        return 1 /* TASK_STATE_SUBMITTED */;
+      case "working":
+        return 2 /* TASK_STATE_WORKING */;
+      case "input-required":
+        return 6 /* TASK_STATE_INPUT_REQUIRED */;
+      case "rejected":
+        return 7 /* TASK_STATE_REJECTED */;
+      case "auth-required":
+        return 8 /* TASK_STATE_AUTH_REQUIRED */;
+      case "completed":
+        return 3 /* TASK_STATE_COMPLETED */;
+      case "failed":
+        return 4 /* TASK_STATE_FAILED */;
+      case "canceled":
+        return 5 /* TASK_STATE_CANCELLED */;
+      case "unknown":
+        return 0 /* TASK_STATE_UNSPECIFIED */;
+      default:
+        return -1 /* UNRECOGNIZED */;
+    }
+  }
+  static part(part) {
+    if (part.kind === "text") {
+      return {
+        part: { $case: "text", value: part.text }
+      };
+    }
+    if (part.kind === "file") {
+      let filePart;
+      if ("uri" in part.file) {
+        filePart = {
+          file: { $case: "fileWithUri", value: part.file.uri },
+          mimeType: part.file.mimeType ?? ""
+        };
+      } else if ("bytes" in part.file) {
+        filePart = {
+          file: { $case: "fileWithBytes", value: Buffer.from(part.file.bytes, "base64") },
+          mimeType: part.file.mimeType ?? ""
+        };
+      } else {
+        throw A2AError2.internalError("Invalid file part");
+      }
+      return {
+        part: { $case: "file", value: filePart }
+      };
+    }
+    if (part.kind === "data") {
+      return {
+        part: { $case: "data", value: { data: part.data } }
+      };
+    }
+    throw A2AError2.internalError("Invalid part type");
+  }
+  static messageSendParams(params) {
+    return {
+      request: _ToProto.message(params.message),
+      configuration: _ToProto.configuration(params.configuration),
+      metadata: params.metadata
+    };
+  }
+  static configuration(configuration) {
+    if (!configuration) {
+      return void 0;
+    }
+    return {
+      blocking: configuration.blocking ?? false,
+      acceptedOutputModes: configuration.acceptedOutputModes ?? [],
+      pushNotification: _ToProto.pushNotificationConfig(configuration.pushNotificationConfig),
+      historyLength: configuration.historyLength ?? 0
+    };
+  }
+  static taskQueryParams(params) {
+    return {
+      name: generateTaskName(params.id),
+      historyLength: params.historyLength ?? 0
+    };
+  }
+  static cancelTaskRequest(params) {
+    return {
+      name: generateTaskName(params.id)
+    };
+  }
+  static taskIdParams(params) {
+    return {
+      name: generateTaskName(params.id)
+    };
+  }
+  static getAgentCardRequest() {
+    return {};
+  }
+};
+
+// src/compat/v0_3/server/express/rest_handler.ts
+var legacyRestErrorHandler = (err, _req, res, next) => {
+  if (err instanceof SyntaxError && "body" in err) {
+    return res.status(HTTP_STATUS.BAD_REQUEST).json(toLegacyHTTPError(A2AError2.parseError("Invalid JSON payload.")));
+  }
+  next(err);
+};
+function legacyRestRouter(options) {
+  const router = import_express2.default.Router();
+  const transportHandler = new LegacyRestTransportHandler(options.requestHandler);
+  router.use((req, _res, next) => {
+    const requestedVersion = req.header(A2A_VERSION_HEADER) || A2A_LEGACY_PROTOCOL_VERSION;
+    if (isLegacyVersion(requestedVersion)) {
+      next();
+    } else {
+      next("router");
+    }
+  });
+  router.use(
+    (_req, res, next) => {
+      res.setHeader("Content-Type", LEGACY_JSON_CONTENT_TYPE);
+      next();
+    },
+    // `strict: false` so the parser accepts top-level JSON primitives.
+    // The v0.3 reference clients (a2a-go, a2a-python) issue empty
+    // POSTs by marshaling `nil` to literal `null`; strict mode would
+    // reject that 4-byte body with a 400 SyntaxError.
+    import_express2.default.json({ type: LEGACY_JSON_CONTENT_TYPE, strict: false }),
+    legacyRestErrorHandler
+  );
+  const buildContext = async (req) => {
+    const user = await options.userBuilder(req);
+    const requestedVersion = req.header(A2A_VERSION_HEADER) || A2A_LEGACY_PROTOCOL_VERSION;
+    const ctxBuilder = options.contextBuilder ?? defaultServerCallContextBuilder;
+    const context = ctxBuilder({
+      extensions: Extensions.parseServiceParameter(
+        req.header(LEGACY_HTTP_EXTENSION_HEADER) ?? req.header(HTTP_EXTENSION_HEADER)
+      ),
+      user,
+      headers: req.headers,
+      requestedVersion,
+      tenant: req.params.tenant || void 0
+    });
+    const agentCard = await transportHandler.getAgentCard();
+    validateVersion(context.requestedVersion, agentCard, "HTTP+JSON");
+    return context;
+  };
+  const setExtensionsHeader = (res, context) => {
+    if (context.activatedExtensions) {
+      res.setHeader(LEGACY_HTTP_EXTENSION_HEADER, Array.from(context.activatedExtensions));
+    }
+  };
+  const sendResponse = (res, statusCode, context, body) => {
+    setExtensionsHeader(res, context);
+    res.status(statusCode);
+    if (statusCode === HTTP_STATUS.NO_CONTENT) {
+      res.end();
+    } else {
+      res.json(body);
+    }
+  };
+  const encodeSendMessageResult = (result) => {
+    const protoResult = ToProto.messageSendResult(result);
+    if (!protoResult) {
+      throw A2AError2.internalError("sendMessage produced no result.");
+    }
+    return SendMessageResponse.toJSON(protoResult);
+  };
+  const encodeTask = (task) => {
+    return Task.toJSON(ToProto.task(task));
+  };
+  const encodeTaskPushNotificationConfig = (cfg) => {
+    return TaskPushNotificationConfig.toJSON(ToProto.taskPushNotificationConfig(cfg));
+  };
+  const encodeAgentCard = (card) => {
+    return AgentCard.toJSON(ToProto.agentCard(card));
+  };
+  const encodeListTaskPushNotificationConfigs = (configs) => {
+    return ListTaskPushNotificationConfigResponse.toJSON({
+      configs: configs.map((c) => ToProto.taskPushNotificationConfig(c)),
+      nextPageToken: ""
+    });
+  };
+  const decodeSendMessageRequest = (rawBody) => {
+    const proto = SendMessageRequest.fromJSON(rawBody ?? {});
+    return FromProto.messageSendParams(proto);
+  };
+  const decodeTaskPushNotificationConfig = (rawBody) => {
+    const proto = TaskPushNotificationConfig.fromJSON(rawBody ?? {});
+    return FromProto.taskPushNotificationConfig(proto);
+  };
+  const encodeStreamEvent = (event) => {
+    const proto = ToProto.messageStreamResult(event);
+    if (!proto) {
+      throw A2AError2.internalError("Stream produced an unrepresentable event.");
+    }
+    return StreamResponse.toJSON(proto);
+  };
+  const sendStreamResponse = async (res, stream, context) => {
+    const iterator = stream[Symbol.asyncIterator]();
+    let firstResult;
+    try {
+      firstResult = await iterator.next();
+    } catch (error) {
+      setExtensionsHeader(res, context);
+      const statusCode = mapErrorToStatus(error);
+      res.status(statusCode).json(toLegacyHTTPError(error));
+      return;
+    }
+    Object.entries(SSE_HEADERS).forEach(([key, value]) => {
+      res.setHeader(key, value);
+    });
+    setExtensionsHeader(res, context);
+    res.flushHeaders();
+    try {
+      if (!firstResult.done) {
+        res.write(formatSSEEvent(encodeStreamEvent(firstResult.value)));
+      }
+      for await (const event of delegateAsyncIterator(iterator)) {
+        res.write(formatSSEEvent(encodeStreamEvent(event)));
+      }
+    } catch (streamError) {
+      console.error("Legacy SSE streaming error:", streamError);
+      if (!res.writableEnded) {
+        res.write(formatSSEErrorEvent(toLegacyHTTPError(streamError)));
+      }
+    } finally {
+      if (!res.writableEnded) {
+        res.end();
+      }
+    }
+  };
+  const handleError = (res, error) => {
+    if (res.headersSent) {
+      if (!res.writableEnded) {
+        res.end();
+      }
+      return;
+    }
+    const statusCode = mapErrorToStatus(error);
+    res.status(statusCode).json(toLegacyHTTPError(error));
+  };
+  const asyncHandler = (handler) => {
+    return async (req, res) => {
+      try {
+        await handler(req, res);
+      } catch (error) {
+        handleError(res, error);
+      }
+    };
+  };
+  router.get(
+    "/v1/card",
+    asyncHandler(async (req, res) => {
+      const context = await buildContext(req);
+      const result = await transportHandler.getAuthenticatedExtendedAgentCard(context);
+      sendResponse(res, HTTP_STATUS.OK, context, encodeAgentCard(result));
+    })
+  );
+  router.post(
+    "/v1/message\\:send",
+    asyncHandler(async (req, res) => {
+      const context = await buildContext(req);
+      const params = decodeSendMessageRequest(req.body);
+      const result = await transportHandler.sendMessage(params, context);
+      sendResponse(res, HTTP_STATUS.CREATED, context, encodeSendMessageResult(result));
+    })
+  );
+  router.post(
+    "/v1/message\\:stream",
+    asyncHandler(async (req, res) => {
+      const context = await buildContext(req);
+      const params = decodeSendMessageRequest(req.body);
+      const stream = await transportHandler.sendMessageStream(params, context);
+      await sendStreamResponse(res, stream, context);
+    })
+  );
+  router.post(
+    "/v1/tasks/:taskId\\:cancel",
+    asyncHandler(async (req, res) => {
+      const context = await buildContext(req);
+      const result = await transportHandler.cancelTask(req.params.taskId, context);
+      sendResponse(res, HTTP_STATUS.OK, context, encodeTask(result));
+    })
+  );
+  const resubscribeHandler = asyncHandler(async (req, res) => {
+    const context = await buildContext(req);
+    const stream = await transportHandler.resubscribe(req.params.taskId, context);
+    await sendStreamResponse(res, stream, context);
+  });
+  router.get("/v1/tasks/:taskId\\:subscribe", resubscribeHandler);
+  router.post("/v1/tasks/:taskId\\:subscribe", resubscribeHandler);
+  router.get(
+    "/v1/tasks/:taskId",
+    asyncHandler(async (req, res) => {
+      const context = await buildContext(req);
+      const historyLength = req.query.historyLength ?? req.query.history_length;
+      const result = await transportHandler.getTask(req.params.taskId, context, historyLength);
+      sendResponse(res, HTTP_STATUS.OK, context, encodeTask(result));
+    })
+  );
+  router.post(
+    "/v1/tasks/:taskId/pushNotificationConfigs",
+    asyncHandler(async (req, res) => {
+      const context = await buildContext(req);
+      const params = decodeTaskPushNotificationConfig(req.body);
+      const result = await transportHandler.setTaskPushNotificationConfig(params, context);
+      sendResponse(res, HTTP_STATUS.CREATED, context, encodeTaskPushNotificationConfig(result));
+    })
+  );
+  router.get(
+    "/v1/tasks/:taskId/pushNotificationConfigs",
+    asyncHandler(async (req, res) => {
+      const context = await buildContext(req);
+      const result = await transportHandler.listTaskPushNotificationConfigs(
+        req.params.taskId,
+        context
+      );
+      sendResponse(res, HTTP_STATUS.OK, context, encodeListTaskPushNotificationConfigs(result));
+    })
+  );
+  router.get(
+    "/v1/tasks/:taskId/pushNotificationConfigs/:configId",
+    asyncHandler(async (req, res) => {
+      const context = await buildContext(req);
+      const result = await transportHandler.getTaskPushNotificationConfig(
+        req.params.taskId,
+        req.params.configId,
+        context
+      );
+      sendResponse(res, HTTP_STATUS.OK, context, encodeTaskPushNotificationConfig(result));
+    })
+  );
+  router.delete(
+    "/v1/tasks/:taskId/pushNotificationConfigs/:configId",
+    asyncHandler(async (req, res) => {
+      const context = await buildContext(req);
+      await transportHandler.deleteTaskPushNotificationConfig(
+        req.params.taskId,
+        req.params.configId,
+        context
+      );
+      sendResponse(res, HTTP_STATUS.NO_CONTENT, context);
+    })
+  );
+  return router;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  legacyAgentCardRouter,
+  legacyRestRouter
+});