@envarai/envarpay 0.2.0-alpha.9 → 2026.1027.1

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

@@ -0,0 +1,2209 @@
+"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/index.ts
+var server_exports = {};
+__export(server_exports, {
+  LegacyA2AError: () => A2AError2,
+  LegacyJsonRpcTransportHandler: () => LegacyJsonRpcTransportHandler,
+  LegacyRestTransportHandler: () => LegacyRestTransportHandler,
+  V03PushNotificationSerializer: () => V03PushNotificationSerializer,
+  createLegacyAwarePushNotificationSender: () => createLegacyAwarePushNotificationSender,
+  toLegacyHTTPError: () => toLegacyHTTPError
+});
+module.exports = __toCommonJS(server_exports);
+
+// 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 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
+});
+
+// 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/constants.ts
+var A2A_PROTOCOL_VERSION = "1.0";
+var A2A_LEGACY_PROTOCOL_VERSION = "0.3";
+var A2A_CONTENT_TYPE = "application/a2a+json";
+
+// 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/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/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 };
+}
+function toCoreGetTaskRequest(compat, tenant = "") {
+  return {
+    tenant,
+    id: compat.params.id,
+    historyLength: compat.params.historyLength
+  };
+}
+function toCoreCancelTaskRequest(compat, tenant = "") {
+  return {
+    tenant,
+    id: compat.params.id,
+    metadata: deepCloneMetadata(compat.params.metadata)
+  };
+}
+function toCoreSubscribeToTaskRequest(compat, tenant = "") {
+  return { tenant, id: compat.params.id };
+}
+function toCoreCreateTaskPushNotificationConfigRequest(compat, tenant = "") {
+  return toCoreTaskPushNotificationConfig(compat.params, tenant);
+}
+function toCoreGetTaskPushNotificationConfigRequest(compat, tenant = "") {
+  const params = compat.params;
+  const configId = "pushNotificationConfigId" in params ? params.pushNotificationConfigId : void 0;
+  return { tenant, taskId: params.id, id: configId ?? "" };
+}
+function toCoreDeleteTaskPushNotificationConfigRequest(compat, tenant = "") {
+  return {
+    tenant,
+    taskId: compat.params.id,
+    id: compat.params.pushNotificationConfigId
+  };
+}
+function toCoreListTaskPushNotificationConfigsRequest(compat, tenant = "") {
+  return { tenant, taskId: compat.params.id, pageSize: 0, pageToken: "" };
+}
+function toCompatListTaskPushNotificationConfigSuccessResponse(core, requestId = null) {
+  return {
+    id: requestId,
+    jsonrpc: "2.0",
+    result: core.configs.map((cfg) => toCompatTaskPushNotificationConfig(cfg))
+  };
+}
+function toCoreGetExtendedAgentCardRequest(_compat, tenant = "") {
+  return { tenant };
+}
+
+// src/compat/v0_3/server/transports/jsonrpc/jsonrpc_transport_handler.ts
+var LegacyJsonRpcTransportHandler = class _LegacyJsonRpcTransportHandler {
+  requestHandler;
+  constructor(requestHandler) {
+    this.requestHandler = requestHandler;
+  }
+  /**
+   * Handles an incoming v0.3 JSON-RPC request. Streaming methods
+   * (`message/stream`, `tasks/resubscribe`) return an `AsyncGenerator`
+   * of envelopes; non-streaming methods return a single envelope.
+   */
+  async handle(requestBody, context) {
+    let rpcRequest = { jsonrpc: "2.0", method: "" };
+    try {
+      if (typeof requestBody === "string") {
+        rpcRequest = JSON.parse(requestBody);
+      } else if (typeof requestBody === "object" && requestBody !== null) {
+        rpcRequest = requestBody;
+      } else {
+        throw A2AError2.invalidRequest("Invalid request body type.");
+      }
+      if (!this.isRequestValid(rpcRequest)) {
+        throw A2AError2.invalidRequest("Invalid JSON-RPC Request.");
+      }
+    } catch (error) {
+      const mappedError = _LegacyJsonRpcTransportHandler.mapToLegacyJSONRPCError(
+        error instanceof SyntaxError ? A2AError2.invalidRequest(error.message || "Failed to parse JSON request.") : error
+      );
+      return {
+        jsonrpc: "2.0",
+        id: rpcRequest.id ?? null,
+        error: mappedError
+      };
+    }
+    const { method, id: requestId = null } = rpcRequest;
+    try {
+      if (method !== "agent/getAuthenticatedExtendedCard" && !this.paramsAreValid(rpcRequest.params)) {
+        throw A2AError2.invalidParams("Invalid method parameters.");
+      }
+      if (method === "message/stream" || method === "tasks/resubscribe") {
+        const agentCard = await this.requestHandler.getAgentCard();
+        if (!agentCard.capabilities?.streaming) {
+          throw A2AError2.unsupportedOperation(`Method ${method} requires streaming capability.`);
+        }
+        const agentEventStream = method === "message/stream" ? this.requestHandler.sendMessageStream(
+          toCoreSendMessageRequest(rpcRequest),
+          context
+        ) : this.requestHandler.resubscribe(
+          toCoreSubscribeToTaskRequest(rpcRequest),
+          context
+        );
+        return (async function* legacyJsonRpcEventStream() {
+          for await (const event of agentEventStream) {
+            yield toCompatStreamResponse(event, requestId);
+          }
+        })();
+      }
+      let result;
+      switch (method) {
+        case "message/send": {
+          const messageOrTask = await this.requestHandler.sendMessage(
+            toCoreSendMessageRequest(rpcRequest),
+            context
+          );
+          result = "messageId" in messageOrTask ? toCompatMessage(messageOrTask) : toCompatTask(messageOrTask);
+          break;
+        }
+        case "tasks/get":
+          result = toCompatTask(
+            await this.requestHandler.getTask(
+              toCoreGetTaskRequest(rpcRequest),
+              context
+            )
+          );
+          break;
+        case "tasks/cancel":
+          result = toCompatTask(
+            await this.requestHandler.cancelTask(
+              toCoreCancelTaskRequest(rpcRequest),
+              context
+            )
+          );
+          break;
+        case "tasks/pushNotificationConfig/set":
+          result = toCompatTaskPushNotificationConfig(
+            await this.requestHandler.createTaskPushNotificationConfig(
+              toCoreCreateTaskPushNotificationConfigRequest(
+                rpcRequest
+              ),
+              context
+            )
+          );
+          break;
+        case "tasks/pushNotificationConfig/get":
+          result = toCompatTaskPushNotificationConfig(
+            await this.requestHandler.getTaskPushNotificationConfig(
+              toCoreGetTaskPushNotificationConfigRequest(
+                rpcRequest
+              ),
+              context
+            )
+          );
+          break;
+        case "tasks/pushNotificationConfig/list": {
+          const listResponse = toCompatListTaskPushNotificationConfigSuccessResponse(
+            await this.requestHandler.listTaskPushNotificationConfigs(
+              toCoreListTaskPushNotificationConfigsRequest(
+                rpcRequest
+              ),
+              context
+            ),
+            requestId
+          );
+          result = listResponse.result;
+          break;
+        }
+        case "tasks/pushNotificationConfig/delete":
+          await this.requestHandler.deleteTaskPushNotificationConfig(
+            toCoreDeleteTaskPushNotificationConfigRequest(
+              rpcRequest
+            ),
+            context
+          );
+          result = null;
+          break;
+        case "agent/getAuthenticatedExtendedCard":
+          result = toCompatAgentCard(
+            await this.requestHandler.getAuthenticatedExtendedAgentCard(
+              toCoreGetExtendedAgentCardRequest(
+                rpcRequest
+              ),
+              context
+            )
+          );
+          break;
+        default:
+          throw A2AError2.methodNotFound(method);
+      }
+      return {
+        jsonrpc: "2.0",
+        id: requestId,
+        result
+      };
+    } catch (error) {
+      return {
+        jsonrpc: "2.0",
+        id: requestId,
+        error: _LegacyJsonRpcTransportHandler.mapToLegacyJSONRPCError(error)
+      };
+    }
+  }
+  isRequestValid(rpcRequest) {
+    if (rpcRequest.jsonrpc !== "2.0") {
+      return false;
+    }
+    if ("id" in rpcRequest) {
+      const id = rpcRequest.id;
+      const isString = typeof id === "string";
+      const isInteger = typeof id === "number" && Number.isInteger(id);
+      const isNull = id === null;
+      if (!isString && !isInteger && !isNull) {
+        return false;
+      }
+    }
+    if (!rpcRequest.method || typeof rpcRequest.method !== "string") {
+      return false;
+    }
+    return true;
+  }
+  paramsAreValid(params) {
+    if (typeof params !== "object" || params === null || Array.isArray(params)) {
+      return false;
+    }
+    for (const key of Object.keys(params)) {
+      if (key === "") {
+        return false;
+      }
+    }
+    return true;
+  }
+  /** Maps an error to a v0.3-shaped `JSONRPCError`. */
+  static mapToLegacyJSONRPCError(error) {
+    return toCompatErrorBody(error);
+  }
+};
+
+// 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 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/types/protojson.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_CANCELED":
+      return 5 /* TASK_STATE_CANCELED */;
+    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_CANCELED */:
+      return "TASK_STATE_CANCELED";
+    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 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,
+      message: isSet(object.message) ? Message.fromJSON(object.message) : 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.message !== void 0) {
+      obj.message = Message.toJSON(message.message);
+    }
+    if (message.timestamp !== void 0) {
+      obj.timestamp = message.timestamp;
+    }
+    return obj;
+  }
+};
+var Part = {
+  fromJSON(object) {
+    return {
+      content: isSet(object.text) ? { $case: "text", value: globalThis.String(object.text) } : isSet(object.raw) ? { $case: "raw", value: Buffer.from(bytesFromBase64(object.raw)) } : isSet(object.url) ? { $case: "url", value: globalThis.String(object.url) } : isSet(object.data) ? { $case: "data", value: object.data } : void 0,
+      metadata: isObject(object.metadata) ? object.metadata : void 0,
+      filename: isSet(object.filename) ? globalThis.String(object.filename) : "",
+      mediaType: isSet(object.mediaType) ? globalThis.String(object.mediaType) : isSet(object.media_type) ? globalThis.String(object.media_type) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.content?.$case === "text") {
+      obj.text = message.content.value;
+    } else if (message.content?.$case === "raw") {
+      obj.raw = base64FromBytes(message.content.value);
+    } else if (message.content?.$case === "url") {
+      obj.url = message.content.value;
+    } else if (message.content?.$case === "data") {
+      obj.data = message.content.value;
+    }
+    if (message.metadata !== void 0) {
+      obj.metadata = message.metadata;
+    }
+    if (message.filename !== "") {
+      obj.filename = message.filename;
+    }
+    if (message.mediaType !== "") {
+      obj.mediaType = message.mediaType;
+    }
+    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,
+      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)) : [],
+      referenceTaskIds: globalThis.Array.isArray(object?.referenceTaskIds) ? object.referenceTaskIds.map((e) => globalThis.String(e)) : globalThis.Array.isArray(object?.reference_task_ids) ? object.reference_task_ids.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.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;
+    }
+    if (message.referenceTaskIds?.length) {
+      obj.referenceTaskIds = message.referenceTaskIds;
+    }
+    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,
+      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.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 StreamResponse = {
+  fromJSON(object) {
+    return {
+      payload: isSet(object.task) ? { $case: "task", value: Task.fromJSON(object.task) } : isSet(object.message) ? { $case: "message", value: Message.fromJSON(object.message) } : 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 === "message") {
+      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;
+  }
+};
+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/signature.ts
+var jose = __toESM(require("jose"), 1);
+
+// src/sse_utils.ts
+var DEFAULT_MAX_SSE_EVENT_SIZE_BYTES = 4 * 1024 * 1024;
+
+// src/server/push_notification/push_notification_serializer.ts
+var V1PushNotificationSerializer = class {
+  serialize(streamResponse, _task) {
+    return {
+      body: JSON.stringify(StreamResponse.toJSON(streamResponse)),
+      contentType: A2A_CONTENT_TYPE
+    };
+  }
+};
+
+// src/server/push_notification/default_push_notification_sender.ts
+var DefaultPushNotificationSender = class {
+  pushNotificationStore;
+  notificationChain;
+  options;
+  serializers;
+  fallbackSerializer;
+  // Avoid log spam when many notifications target the same unknown version.
+  warnedMissingSerializers = /* @__PURE__ */ new Set();
+  constructor(pushNotificationStore, options = {}) {
+    this.pushNotificationStore = pushNotificationStore;
+    this.notificationChain = /* @__PURE__ */ new Map();
+    this.options = {
+      timeout: options.timeout ?? 5e3,
+      tokenHeaderName: options.tokenHeaderName ?? "X-A2A-Notification-Token"
+    };
+    const builtinV1 = new V1PushNotificationSerializer();
+    this.serializers = /* @__PURE__ */ new Map([
+      ["1.0" /* V1_0 */, builtinV1]
+    ]);
+    if (options.serializers) {
+      for (const [version, serializer] of Object.entries(options.serializers)) {
+        if (serializer) {
+          this.serializers.set(version, serializer);
+        }
+      }
+    }
+    this.fallbackSerializer = this.serializers.get("1.0" /* V1_0 */) ?? builtinV1;
+  }
+  async send(streamResponse, context, task) {
+    const taskId = this._getTaskId(streamResponse);
+    if (!taskId) {
+      return;
+    }
+    const storedConfigs = await this._loadStoredConfigs(taskId, context);
+    if (!storedConfigs || storedConfigs.length === 0) {
+      return;
+    }
+    const lastPromise = this.notificationChain.get(taskId) ?? Promise.resolve();
+    const newPromise = lastPromise.catch(() => {
+    }).then(async () => {
+      const dispatches = storedConfigs.map(async (storedConfig) => {
+        try {
+          await this._dispatchNotification(streamResponse, storedConfig, taskId, task);
+        } catch (error) {
+          console.error(
+            `Error sending push notification for task_id=${taskId} to URL: ${storedConfig.config.url}. Error:`,
+            error
+          );
+        }
+      });
+      await Promise.all(dispatches);
+    });
+    this.notificationChain.set(taskId, newPromise);
+    return newPromise.finally(() => {
+      if (this.notificationChain.get(taskId) === newPromise) {
+        this.notificationChain.delete(taskId);
+      }
+    });
+  }
+  /**
+   * Returns the task id associated with a {@link StreamResponse}.
+   * Returns an empty string for stand-alone messages with no task
+   * association; the sender skips dispatch in that case.
+   */
+  _getTaskId(streamResponse) {
+    const payload = streamResponse.payload;
+    if (!payload) {
+      throw new Error("StreamResponse payload is undefined");
+    }
+    switch (payload.$case) {
+      case "task":
+        return payload.value.id;
+      case "statusUpdate":
+      case "artifactUpdate":
+      case "message":
+        return payload.value.taskId;
+      default: {
+        const _exhaustive = payload;
+        throw new Error(`Unknown payload case: ${_exhaustive.$case}`);
+      }
+    }
+  }
+  /**
+   * Resolves stored configs from the {@link PushNotificationStore},
+   * preferring the wire-version-aware
+   * {@link PushNotificationStore.loadWithMetadata} when available.
+   *
+   * Stores that only implement the canonical {@link PushNotificationStore.load}
+   * are silently lifted into the wrapped shape by tagging every entry
+   * with the wire version of the *triggering* request. See
+   * `src/compat/v0_3/README.md` for the implication on v1.0 deployments
+   * with v0.3 compat opted in.
+   */
+  async _loadStoredConfigs(taskId, context) {
+    if (this.pushNotificationStore.loadWithMetadata) {
+      return await this.pushNotificationStore.loadWithMetadata(taskId, context);
+    }
+    const plain = await this.pushNotificationStore.load(taskId, context);
+    const fallbackVersion = context.requestedVersion || A2A_LEGACY_PROTOCOL_VERSION;
+    return plain.map((config) => ({ config, wireVersion: fallbackVersion }));
+  }
+  /**
+   * Resolves the serializer registered for the given wire version,
+   * falling back to v1.0 (with a one-time warning) when no entry is
+   * registered.
+   */
+  _resolveSerializer(wireVersion) {
+    const serializer = this.serializers.get(wireVersion);
+    if (serializer) {
+      return serializer;
+    }
+    if (!this.warnedMissingSerializers.has(wireVersion)) {
+      this.warnedMissingSerializers.add(wireVersion);
+      console.warn(
+        `No push notification serializer registered for wire version '${wireVersion}'; falling back to '${A2A_PROTOCOL_VERSION}'. Register one via DefaultPushNotificationSenderOptions.serializers to silence this warning.`
+      );
+    }
+    return this.fallbackSerializer;
+  }
+  /**
+   * Builds the auth headers for a push notification request. Priority:
+   * `pushConfig.authentication` (scheme + credentials) → `Authorization`
+   * header; otherwise `pushConfig.token` → legacy token header.
+   */
+  _buildAuthHeaders(pushConfig) {
+    const headers = {};
+    if (pushConfig.authentication?.scheme && pushConfig.authentication?.credentials) {
+      headers["Authorization"] = `${pushConfig.authentication.scheme} ${pushConfig.authentication.credentials}`;
+    } else if (pushConfig.token) {
+      headers[this.options.tokenHeaderName] = pushConfig.token;
+    }
+    return headers;
+  }
+  async _dispatchNotification(streamResponse, storedConfig, taskId, task) {
+    const { config: pushConfig, wireVersion } = storedConfig;
+    const url = pushConfig.url;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.options.timeout);
+    try {
+      const serializer = this._resolveSerializer(wireVersion);
+      const { body, contentType } = serializer.serialize(streamResponse, task);
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": contentType,
+          ...this._buildAuthHeaders(pushConfig)
+        },
+        body,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      console.info(`Push notification sent for task_id=${taskId} to URL: ${url}`);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+
+// src/compat/v0_3/constants.ts
+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/compat/v0_3/server/push_notification/v03_push_notification_serializer.ts
+var V03PushNotificationSerializer = class {
+  serialize(streamResponse, task) {
+    const payload = streamResponse.payload;
+    if (!payload) {
+      throw new Error("StreamResponse payload is undefined");
+    }
+    let legacyEvent;
+    switch (payload.$case) {
+      case "task":
+        legacyEvent = toCompatTask(task || payload.value);
+        break;
+      case "message":
+        legacyEvent = toCompatMessage(payload.value);
+        break;
+      case "statusUpdate":
+        if (task !== void 0) {
+          legacyEvent = toCompatTask(task);
+        } else {
+          legacyEvent = toCompatTaskStatusUpdateEvent(payload.value);
+        }
+        break;
+      case "artifactUpdate":
+        if (task !== void 0) {
+          legacyEvent = toCompatTask(task);
+        } else {
+          legacyEvent = toCompatTaskArtifactUpdateEvent(payload.value);
+        }
+        break;
+      default: {
+        const _exhaustive = payload;
+        throw new Error(`Unknown payload case: ${_exhaustive.$case}`);
+      }
+    }
+    return {
+      body: JSON.stringify(legacyEvent),
+      contentType: LEGACY_JSON_CONTENT_TYPE
+    };
+  }
+};
+
+// src/compat/v0_3/server/push_notification/index.ts
+function createLegacyAwarePushNotificationSender(pushNotificationStore, options = {}) {
+  return new DefaultPushNotificationSender(pushNotificationStore, {
+    ...options,
+    serializers: {
+      ["0.3" /* V0_3 */]: new V03PushNotificationSerializer(),
+      ...options.serializers ?? {}
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LegacyA2AError,
+  LegacyJsonRpcTransportHandler,
+  LegacyRestTransportHandler,
+  V03PushNotificationSerializer,
+  createLegacyAwarePushNotificationSender,
+  toLegacyHTTPError
+});