@envarai/connect 0.0.0-stage → 2026.1029.1

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

@@ -0,0 +1,4670 @@
+"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/server/grpc/index.ts
+var grpc_exports = {};
+__export(grpc_exports, {
+  A2AService: () => A2AServiceService,
+  UserBuilder: () => UserBuilder,
+  grpcService: () => grpcService
+});
+module.exports = __toCommonJS(grpc_exports);
+
+// src/server/grpc/grpc_service.ts
+var grpc = __toESM(require("@grpc/grpc-js"), 1);
+
+// 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 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 RESERVED_CODE_TO_SEMANTIC = {
+  [A2A_ERROR_CODE.PARSE_ERROR]: "RequestMalformedError",
+  [A2A_ERROR_CODE.INVALID_REQUEST]: "RequestMalformedError",
+  [A2A_ERROR_CODE.METHOD_NOT_FOUND]: "RequestMalformedError"
+};
+
+// src/types/converters/to_proto.ts
+var ToProto = class {
+  static messageSendResult(params) {
+    if ("messageId" in params) {
+      return {
+        payload: {
+          $case: "message",
+          value: params
+        }
+      };
+    } else if ("artifacts" in params) {
+      return {
+        payload: {
+          $case: "task",
+          value: params
+        }
+      };
+    }
+    throw new A2AError("Invalid SendMessageResult type");
+  }
+};
+
+// 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/constants.ts
+var HTTP_EXTENSION_HEADER = "A2A-Extensions";
+var A2A_VERSION_HEADER = "A2A-Version";
+
+// src/grpc/pb/google/rpc/error_details.ts
+var import_wire2 = require("@bufbuild/protobuf/wire");
+
+// src/grpc/pb/google/protobuf/duration.ts
+var import_wire = require("@bufbuild/protobuf/wire");
+
+// src/grpc/pb/google/rpc/error_details.ts
+function createBaseErrorInfo() {
+  return { reason: "", domain: "", metadata: {} };
+}
+var ErrorInfo = {
+  encode(message, writer = new import_wire2.BinaryWriter()) {
+    if (message.reason !== "") {
+      writer.uint32(10).string(message.reason);
+    }
+    if (message.domain !== "") {
+      writer.uint32(18).string(message.domain);
+    }
+    Object.entries(message.metadata).forEach(([key, value]) => {
+      ErrorInfo_MetadataEntry.encode({ key, value }, writer.uint32(26).fork()).join();
+    });
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire2.BinaryReader ? input : new import_wire2.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseErrorInfo();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.reason = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.domain = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          const entry3 = ErrorInfo_MetadataEntry.decode(reader, reader.uint32());
+          if (entry3.value !== void 0) {
+            message.metadata[entry3.key] = entry3.value;
+          }
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseErrorInfo_MetadataEntry() {
+  return { key: "", value: "" };
+}
+var ErrorInfo_MetadataEntry = {
+  encode(message, writer = new import_wire2.BinaryWriter()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire2.BinaryReader ? input : new import_wire2.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseErrorInfo_MetadataEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+
+// src/grpc/pb/google/rpc/status.ts
+var import_wire4 = require("@bufbuild/protobuf/wire");
+
+// src/grpc/pb/google/protobuf/any.ts
+var import_wire3 = require("@bufbuild/protobuf/wire");
+function createBaseAny() {
+  return { typeUrl: "", value: Buffer.alloc(0) };
+}
+var Any = {
+  encode(message, writer = new import_wire3.BinaryWriter()) {
+    if (message.typeUrl !== "") {
+      writer.uint32(10).string(message.typeUrl);
+    }
+    if (message.value.length !== 0) {
+      writer.uint32(18).bytes(message.value);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire3.BinaryReader ? input : new import_wire3.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseAny();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.typeUrl = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = Buffer.from(reader.bytes());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+
+// src/grpc/pb/google/rpc/status.ts
+function createBaseStatus() {
+  return { code: 0, message: "", details: [] };
+}
+var Status = {
+  encode(message, writer = new import_wire4.BinaryWriter()) {
+    if (message.code !== 0) {
+      writer.uint32(8).int32(message.code);
+    }
+    if (message.message !== "") {
+      writer.uint32(18).string(message.message);
+    }
+    for (const v of message.details) {
+      Any.encode(v, writer.uint32(26).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire4.BinaryReader ? input : new import_wire4.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseStatus();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.code = reader.int32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.message = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.details.push(Any.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+
+// src/errors/grpc/grpc.ts
+var GRPC_STATUS_DETAILS_BIN = "grpc-status-details-bin";
+var GRPC_STATUS_CODE = {
+  OK: 0,
+  CANCELLED: 1,
+  UNKNOWN: 2,
+  INVALID_ARGUMENT: 3,
+  DEADLINE_EXCEEDED: 4,
+  NOT_FOUND: 5,
+  ALREADY_EXISTS: 6,
+  PERMISSION_DENIED: 7,
+  RESOURCE_EXHAUSTED: 8,
+  FAILED_PRECONDITION: 9,
+  ABORTED: 10,
+  OUT_OF_RANGE: 11,
+  UNIMPLEMENTED: 12,
+  INTERNAL: 13,
+  UNAVAILABLE: 14,
+  DATA_LOSS: 15,
+  UNAUTHENTICATED: 16
+};
+var GRPC_ERROR_STATUS = Object.freeze({
+  TaskNotFoundError: GRPC_STATUS_CODE.NOT_FOUND,
+  TaskNotCancelableError: GRPC_STATUS_CODE.FAILED_PRECONDITION,
+  PushNotificationNotSupportedError: GRPC_STATUS_CODE.FAILED_PRECONDITION,
+  UnsupportedOperationError: GRPC_STATUS_CODE.FAILED_PRECONDITION,
+  ContentTypeNotSupportedError: GRPC_STATUS_CODE.INVALID_ARGUMENT,
+  InvalidAgentResponseError: GRPC_STATUS_CODE.INTERNAL,
+  ExtendedAgentCardNotConfiguredError: GRPC_STATUS_CODE.FAILED_PRECONDITION,
+  ExtensionSupportRequiredError: GRPC_STATUS_CODE.FAILED_PRECONDITION,
+  VersionNotSupportedError: GRPC_STATUS_CODE.FAILED_PRECONDITION,
+  RequestMalformedError: GRPC_STATUS_CODE.INVALID_ARGUMENT
+});
+function isGrpcError(err) {
+  return err instanceof A2AError && err.transport === "grpc";
+}
+function makeGrpc(name) {
+  const Base = A2A_ERROR_CLASSES[name];
+  const defaultStatus = GRPC_ERROR_STATUS[name] ?? GRPC_STATUS_CODE.INTERNAL;
+  const cls = {
+    [`Grpc${name}`]: class extends Base {
+      transport = "grpc";
+      status;
+      statusDetailsBin;
+      constructor(options) {
+        super(options);
+        this.name = name;
+        this.status = options?.status ?? defaultStatus;
+        if (options?.statusDetailsBin) this.statusDetailsBin = options.statusDetailsBin;
+      }
+    }
+  }[`Grpc${name}`];
+  return cls;
+}
+var GrpcTaskNotFoundError = makeGrpc("TaskNotFoundError");
+var GrpcTaskNotCancelableError = makeGrpc("TaskNotCancelableError");
+var GrpcPushNotificationNotSupportedError = makeGrpc("PushNotificationNotSupportedError");
+var GrpcUnsupportedOperationError = makeGrpc("UnsupportedOperationError");
+var GrpcContentTypeNotSupportedError = makeGrpc("ContentTypeNotSupportedError");
+var GrpcInvalidAgentResponseError = makeGrpc("InvalidAgentResponseError");
+var GrpcExtendedAgentCardNotConfiguredError = makeGrpc(
+  "ExtendedAgentCardNotConfiguredError"
+);
+var GrpcExtensionSupportRequiredError = makeGrpc("ExtensionSupportRequiredError");
+var GrpcVersionNotSupportedError = makeGrpc("VersionNotSupportedError");
+var GrpcRequestMalformedError = makeGrpc("RequestMalformedError");
+var GRPC_ERROR_CLASSES = Object.freeze({
+  TaskNotFoundError: GrpcTaskNotFoundError,
+  TaskNotCancelableError: GrpcTaskNotCancelableError,
+  PushNotificationNotSupportedError: GrpcPushNotificationNotSupportedError,
+  UnsupportedOperationError: GrpcUnsupportedOperationError,
+  ContentTypeNotSupportedError: GrpcContentTypeNotSupportedError,
+  InvalidAgentResponseError: GrpcInvalidAgentResponseError,
+  ExtendedAgentCardNotConfiguredError: GrpcExtendedAgentCardNotConfiguredError,
+  ExtensionSupportRequiredError: GrpcExtensionSupportRequiredError,
+  VersionNotSupportedError: GrpcVersionNotSupportedError,
+  RequestMalformedError: GrpcRequestMalformedError
+});
+function grpcStatusFor(error) {
+  if (isGrpcError(error)) return error.status;
+  if (error instanceof A2AError) return GRPC_ERROR_STATUS[error.name] ?? GRPC_STATUS_CODE.UNKNOWN;
+  return GRPC_STATUS_CODE.UNKNOWN;
+}
+function encodeGrpcStatusDetails(status, message, reason, metadata) {
+  const errorInfoBytes = Buffer.from(
+    ErrorInfo.encode({ reason, domain: A2A_ERROR_DOMAIN, metadata: metadata ?? {} }).finish()
+  );
+  return Buffer.from(
+    Status.encode({
+      code: status,
+      message,
+      details: [{ typeUrl: ERROR_INFO_TYPE, value: errorInfoBytes }]
+    }).finish()
+  );
+}
+function buildGrpcErrorMetadata(Metadata3, error) {
+  if (!(error instanceof A2AError)) return void 0;
+  const spec = A2A_ERROR_SPECS[error.name];
+  if (!spec) return void 0;
+  const blob = encodeGrpcStatusDetails(
+    grpcStatusFor(error),
+    error.message,
+    spec.reason,
+    error.metadata
+  );
+  const md = new Metadata3();
+  md.set(GRPC_STATUS_DETAILS_BIN, blob);
+  return md;
+}
+
+// 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/server/grpc/grpc_service.ts
+function grpcService(options) {
+  const requestHandler = options.requestHandler;
+  const wrapUnaryWithConverter = async (call, callback, handler, converter) => {
+    try {
+      const context = await _buildContext(
+        call,
+        options.userBuilder,
+        requestHandler,
+        options.contextBuilder
+      );
+      const result = await handler(call.request, context);
+      call.sendMetadata(buildMetadata(context));
+      callback(null, converter(result));
+    } catch (error) {
+      callback(mapToError(error), null);
+    }
+  };
+  const wrapUnary = async (call, callback, handler) => {
+    return wrapUnaryWithConverter(call, callback, handler, (res) => res);
+  };
+  const wrapStreaming = async (call, handler) => {
+    try {
+      const context = await _buildContext(
+        call,
+        options.userBuilder,
+        requestHandler,
+        options.contextBuilder
+      );
+      const stream = await handler(call.request, context);
+      call.sendMetadata(buildMetadata(context));
+      for await (const responsePart of stream) {
+        call.write(responsePart);
+      }
+    } catch (error) {
+      call.emit("error", mapToError(error));
+    } finally {
+      call.end();
+    }
+  };
+  return {
+    sendMessage(call, callback) {
+      return wrapUnaryWithConverter(
+        call,
+        callback,
+        requestHandler.sendMessage.bind(requestHandler),
+        ToProto.messageSendResult
+      );
+    },
+    sendStreamingMessage(call) {
+      return wrapStreaming(call, requestHandler.sendMessageStream.bind(requestHandler));
+    },
+    subscribeToTask(call) {
+      return wrapStreaming(call, requestHandler.resubscribe.bind(requestHandler));
+    },
+    deleteTaskPushNotificationConfig(call, callback) {
+      return wrapUnaryWithConverter(
+        call,
+        callback,
+        requestHandler.deleteTaskPushNotificationConfig.bind(requestHandler),
+        () => ({})
+      );
+    },
+    listTaskPushNotificationConfigs(call, callback) {
+      return wrapUnary(
+        call,
+        callback,
+        requestHandler.listTaskPushNotificationConfigs.bind(requestHandler)
+      );
+    },
+    createTaskPushNotificationConfig(call, callback) {
+      return wrapUnary(
+        call,
+        callback,
+        requestHandler.createTaskPushNotificationConfig.bind(requestHandler)
+      );
+    },
+    getTaskPushNotificationConfig(call, callback) {
+      return wrapUnary(
+        call,
+        callback,
+        requestHandler.getTaskPushNotificationConfig.bind(requestHandler)
+      );
+    },
+    getTask(call, callback) {
+      return wrapUnary(call, callback, requestHandler.getTask.bind(requestHandler));
+    },
+    cancelTask(call, callback) {
+      return wrapUnary(call, callback, requestHandler.cancelTask.bind(requestHandler));
+    },
+    getExtendedAgentCard(call, callback) {
+      return wrapUnary(
+        call,
+        callback,
+        (params, context) => requestHandler.getAuthenticatedExtendedAgentCard(params, context)
+      );
+    },
+    listTasks(call, callback) {
+      return wrapUnary(call, callback, requestHandler.listTasks.bind(requestHandler));
+    }
+  };
+}
+var mapToError = (error) => {
+  const code = error instanceof A2AError ? grpcStatusFor(error) : GRPC_STATUS_CODE.UNKNOWN;
+  const message = error instanceof Error ? error.message : "Internal server error";
+  const result = { code, details: message };
+  const md = buildGrpcErrorMetadata(grpc.Metadata, error);
+  if (md) result.metadata = md;
+  return result;
+};
+var _buildContext = async (call, userBuilder, requestHandler, contextBuilder) => {
+  const user = await userBuilder(call);
+  const extensionHeaders = call.metadata.get(HTTP_EXTENSION_HEADER);
+  const extensionString = extensionHeaders.map((v) => v.toString()).join(",");
+  const headers = {};
+  for (const [key, value] of Object.entries(call.metadata.getMap())) {
+    headers[key] = value.toString();
+  }
+  const versionHeaders = call.metadata.get(A2A_VERSION_HEADER.toLowerCase());
+  const requestedVersion = versionHeaders.length > 0 ? versionHeaders[0].toString() : void 0;
+  const tenant = call.request?.tenant;
+  const ctxBuilder = contextBuilder ?? defaultServerCallContextBuilder;
+  const context = ctxBuilder({
+    extensions: Extensions.parseServiceParameter(extensionString),
+    user,
+    headers,
+    requestedVersion,
+    tenant
+  });
+  const agentCard = await requestHandler.getAgentCard();
+  validateVersion(context.requestedVersion, agentCard, "GRPC");
+  return context;
+};
+var buildMetadata = (context) => {
+  const metadata = new grpc.Metadata();
+  if (context.activatedExtensions?.length) {
+    metadata.set(HTTP_EXTENSION_HEADER, context.activatedExtensions.join(","));
+  }
+  return metadata;
+};
+
+// src/grpc/pb/a2a.ts
+var import_wire8 = require("@bufbuild/protobuf/wire");
+var import_grpc_js = require("@grpc/grpc-js");
+
+// src/grpc/pb/google/protobuf/empty.ts
+var import_wire5 = require("@bufbuild/protobuf/wire");
+function createBaseEmpty() {
+  return {};
+}
+var Empty = {
+  encode(_, writer = new import_wire5.BinaryWriter()) {
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire5.BinaryReader ? input : new import_wire5.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseEmpty();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+
+// src/grpc/pb/google/protobuf/struct.ts
+var import_wire6 = require("@bufbuild/protobuf/wire");
+function createBaseStruct() {
+  return { fields: {} };
+}
+var Struct = {
+  encode(message, writer = new import_wire6.BinaryWriter()) {
+    globalThis.Object.entries(message.fields).forEach(([key, value]) => {
+      if (value !== void 0) {
+        Struct_FieldsEntry.encode({ key, value }, writer.uint32(10).fork()).join();
+      }
+    });
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire6.BinaryReader ? input : new import_wire6.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseStruct();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          const entry1 = Struct_FieldsEntry.decode(reader, reader.uint32());
+          if (entry1.value !== void 0) {
+            message.fields[entry1.key] = entry1.value;
+          }
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  wrap(object) {
+    const struct = createBaseStruct();
+    if (object !== void 0) {
+      for (const key of globalThis.Object.keys(object)) {
+        struct.fields[key] = object[key];
+      }
+    }
+    return struct;
+  },
+  unwrap(message) {
+    const object = {};
+    if (message.fields) {
+      for (const key of globalThis.Object.keys(message.fields)) {
+        object[key] = message.fields[key];
+      }
+    }
+    return object;
+  }
+};
+function createBaseStruct_FieldsEntry() {
+  return { key: "", value: void 0 };
+}
+var Struct_FieldsEntry = {
+  encode(message, writer = new import_wire6.BinaryWriter()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== void 0) {
+      Value.encode(Value.wrap(message.value), writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire6.BinaryReader ? input : new import_wire6.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseStruct_FieldsEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = Value.unwrap(Value.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseValue() {
+  return { kind: void 0 };
+}
+var Value = {
+  encode(message, writer = new import_wire6.BinaryWriter()) {
+    switch (message.kind?.$case) {
+      case "nullValue":
+        writer.uint32(8).int32(message.kind.value);
+        break;
+      case "numberValue":
+        writer.uint32(17).double(message.kind.value);
+        break;
+      case "stringValue":
+        writer.uint32(26).string(message.kind.value);
+        break;
+      case "boolValue":
+        writer.uint32(32).bool(message.kind.value);
+        break;
+      case "structValue":
+        Struct.encode(Struct.wrap(message.kind.value), writer.uint32(42).fork()).join();
+        break;
+      case "listValue":
+        ListValue.encode(ListValue.wrap(message.kind.value), writer.uint32(50).fork()).join();
+        break;
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire6.BinaryReader ? input : new import_wire6.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseValue();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.kind = { $case: "nullValue", value: reader.int32() };
+          continue;
+        }
+        case 2: {
+          if (tag !== 17) {
+            break;
+          }
+          message.kind = { $case: "numberValue", value: reader.double() };
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.kind = { $case: "stringValue", value: reader.string() };
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+          message.kind = { $case: "boolValue", value: reader.bool() };
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.kind = { $case: "structValue", value: Struct.unwrap(Struct.decode(reader, reader.uint32())) };
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.kind = { $case: "listValue", value: ListValue.unwrap(ListValue.decode(reader, reader.uint32())) };
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  wrap(value) {
+    const result = createBaseValue();
+    if (value === null) {
+      result.kind = { $case: "nullValue", value: 0 /* NULL_VALUE */ };
+    } else if (typeof value === "boolean") {
+      result.kind = { $case: "boolValue", value };
+    } else if (typeof value === "number") {
+      result.kind = { $case: "numberValue", value };
+    } else if (typeof value === "string") {
+      result.kind = { $case: "stringValue", value };
+    } else if (globalThis.Array.isArray(value)) {
+      result.kind = { $case: "listValue", value };
+    } else if (typeof value === "object") {
+      result.kind = { $case: "structValue", value };
+    } else if (typeof value !== "undefined") {
+      throw new globalThis.Error("Unsupported any value type: " + typeof value);
+    }
+    return result;
+  },
+  unwrap(message) {
+    return message.kind?.$case === "nullValue" ? null : message.kind?.value;
+  }
+};
+function createBaseListValue() {
+  return { values: [] };
+}
+var ListValue = {
+  encode(message, writer = new import_wire6.BinaryWriter()) {
+    for (const v of message.values) {
+      Value.encode(Value.wrap(v), writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire6.BinaryReader ? input : new import_wire6.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseListValue();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.values.push(Value.unwrap(Value.decode(reader, reader.uint32())));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  wrap(array) {
+    const result = createBaseListValue();
+    result.values = array ?? [];
+    return result;
+  },
+  unwrap(message) {
+    if (message?.hasOwnProperty("values") && globalThis.Array.isArray(message.values)) {
+      return message.values;
+    } else {
+      return message;
+    }
+  }
+};
+
+// src/grpc/pb/google/protobuf/timestamp.ts
+var import_wire7 = require("@bufbuild/protobuf/wire");
+function createBaseTimestamp() {
+  return { seconds: 0, nanos: 0 };
+}
+var Timestamp = {
+  encode(message, writer = new import_wire7.BinaryWriter()) {
+    if (message.seconds !== 0) {
+      writer.uint32(8).int64(message.seconds);
+    }
+    if (message.nanos !== 0) {
+      writer.uint32(16).int32(message.nanos);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire7.BinaryReader ? input : new import_wire7.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTimestamp();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.seconds = longToNumber(reader.int64());
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.nanos = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function longToNumber(int64) {
+  const num = globalThis.Number(int64.toString());
+  if (num > globalThis.Number.MAX_SAFE_INTEGER) {
+    throw new globalThis.Error("Value is larger than Number.MAX_SAFE_INTEGER");
+  }
+  if (num < globalThis.Number.MIN_SAFE_INTEGER) {
+    throw new globalThis.Error("Value is smaller than Number.MIN_SAFE_INTEGER");
+  }
+  return num;
+}
+
+// src/grpc/pb/a2a.ts
+function createBaseSendMessageConfiguration() {
+  return {
+    acceptedOutputModes: [],
+    taskPushNotificationConfig: void 0,
+    historyLength: void 0,
+    returnImmediately: false
+  };
+}
+var SendMessageConfiguration = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    for (const v of message.acceptedOutputModes) {
+      writer.uint32(10).string(v);
+    }
+    if (message.taskPushNotificationConfig !== void 0) {
+      TaskPushNotificationConfig.encode(message.taskPushNotificationConfig, writer.uint32(18).fork()).join();
+    }
+    if (message.historyLength !== void 0) {
+      writer.uint32(24).int32(message.historyLength);
+    }
+    if (message.returnImmediately !== false) {
+      writer.uint32(32).bool(message.returnImmediately);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSendMessageConfiguration();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.acceptedOutputModes.push(reader.string());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.taskPushNotificationConfig = TaskPushNotificationConfig.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+          message.historyLength = reader.int32();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+          message.returnImmediately = reader.bool();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseTask() {
+  return { id: "", contextId: "", status: void 0, artifacts: [], history: [], metadata: void 0 };
+}
+var Task = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    if (message.contextId !== "") {
+      writer.uint32(18).string(message.contextId);
+    }
+    if (message.status !== void 0) {
+      TaskStatus.encode(message.status, writer.uint32(26).fork()).join();
+    }
+    for (const v of message.artifacts) {
+      Artifact.encode(v, writer.uint32(34).fork()).join();
+    }
+    for (const v of message.history) {
+      Message.encode(v, writer.uint32(42).fork()).join();
+    }
+    if (message.metadata !== void 0) {
+      Struct.encode(Struct.wrap(message.metadata), writer.uint32(50).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTask();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.id = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.contextId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.status = TaskStatus.decode(reader, reader.uint32());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.artifacts.push(Artifact.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.history.push(Message.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.metadata = Struct.unwrap(Struct.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseTaskStatus() {
+  return { state: 0, message: void 0, timestamp: void 0 };
+}
+var TaskStatus = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.state !== 0) {
+      writer.uint32(8).int32(message.state);
+    }
+    if (message.message !== void 0) {
+      Message.encode(message.message, writer.uint32(18).fork()).join();
+    }
+    if (message.timestamp !== void 0) {
+      Timestamp.encode(toTimestamp(message.timestamp), writer.uint32(26).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTaskStatus();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.state = reader.int32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.message = Message.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.timestamp = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBasePart() {
+  return { content: void 0, metadata: void 0, filename: "", mediaType: "" };
+}
+var Part = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    switch (message.content?.$case) {
+      case "text":
+        writer.uint32(10).string(message.content.value);
+        break;
+      case "raw":
+        writer.uint32(18).bytes(message.content.value);
+        break;
+      case "url":
+        writer.uint32(26).string(message.content.value);
+        break;
+      case "data":
+        Value.encode(Value.wrap(message.content.value), writer.uint32(34).fork()).join();
+        break;
+    }
+    if (message.metadata !== void 0) {
+      Struct.encode(Struct.wrap(message.metadata), writer.uint32(42).fork()).join();
+    }
+    if (message.filename !== "") {
+      writer.uint32(50).string(message.filename);
+    }
+    if (message.mediaType !== "") {
+      writer.uint32(58).string(message.mediaType);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBasePart();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.content = { $case: "text", value: reader.string() };
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.content = { $case: "raw", value: Buffer.from(reader.bytes()) };
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.content = { $case: "url", value: reader.string() };
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.content = { $case: "data", value: Value.unwrap(Value.decode(reader, reader.uint32())) };
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.metadata = Struct.unwrap(Struct.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.filename = reader.string();
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+          message.mediaType = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseMessage() {
+  return {
+    messageId: "",
+    contextId: "",
+    taskId: "",
+    role: 0,
+    parts: [],
+    metadata: void 0,
+    extensions: [],
+    referenceTaskIds: []
+  };
+}
+var Message = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.messageId !== "") {
+      writer.uint32(10).string(message.messageId);
+    }
+    if (message.contextId !== "") {
+      writer.uint32(18).string(message.contextId);
+    }
+    if (message.taskId !== "") {
+      writer.uint32(26).string(message.taskId);
+    }
+    if (message.role !== 0) {
+      writer.uint32(32).int32(message.role);
+    }
+    for (const v of message.parts) {
+      Part.encode(v, writer.uint32(42).fork()).join();
+    }
+    if (message.metadata !== void 0) {
+      Struct.encode(Struct.wrap(message.metadata), writer.uint32(50).fork()).join();
+    }
+    for (const v of message.extensions) {
+      writer.uint32(58).string(v);
+    }
+    for (const v of message.referenceTaskIds) {
+      writer.uint32(66).string(v);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMessage();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.messageId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.contextId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.taskId = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+          message.role = reader.int32();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.parts.push(Part.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.metadata = Struct.unwrap(Struct.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+          message.extensions.push(reader.string());
+          continue;
+        }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+          message.referenceTaskIds.push(reader.string());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseArtifact() {
+  return { artifactId: "", name: "", description: "", parts: [], metadata: void 0, extensions: [] };
+}
+var Artifact = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.artifactId !== "") {
+      writer.uint32(10).string(message.artifactId);
+    }
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+    if (message.description !== "") {
+      writer.uint32(26).string(message.description);
+    }
+    for (const v of message.parts) {
+      Part.encode(v, writer.uint32(34).fork()).join();
+    }
+    if (message.metadata !== void 0) {
+      Struct.encode(Struct.wrap(message.metadata), writer.uint32(42).fork()).join();
+    }
+    for (const v of message.extensions) {
+      writer.uint32(50).string(v);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseArtifact();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.artifactId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.name = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.description = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.parts.push(Part.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.metadata = Struct.unwrap(Struct.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.extensions.push(reader.string());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseTaskStatusUpdateEvent() {
+  return { taskId: "", contextId: "", status: void 0, metadata: void 0 };
+}
+var TaskStatusUpdateEvent = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.taskId !== "") {
+      writer.uint32(10).string(message.taskId);
+    }
+    if (message.contextId !== "") {
+      writer.uint32(18).string(message.contextId);
+    }
+    if (message.status !== void 0) {
+      TaskStatus.encode(message.status, writer.uint32(26).fork()).join();
+    }
+    if (message.metadata !== void 0) {
+      Struct.encode(Struct.wrap(message.metadata), writer.uint32(34).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTaskStatusUpdateEvent();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.taskId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.contextId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.status = TaskStatus.decode(reader, reader.uint32());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.metadata = Struct.unwrap(Struct.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseTaskArtifactUpdateEvent() {
+  return { taskId: "", contextId: "", artifact: void 0, append: false, lastChunk: false, metadata: void 0 };
+}
+var TaskArtifactUpdateEvent = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.taskId !== "") {
+      writer.uint32(10).string(message.taskId);
+    }
+    if (message.contextId !== "") {
+      writer.uint32(18).string(message.contextId);
+    }
+    if (message.artifact !== void 0) {
+      Artifact.encode(message.artifact, writer.uint32(26).fork()).join();
+    }
+    if (message.append !== false) {
+      writer.uint32(32).bool(message.append);
+    }
+    if (message.lastChunk !== false) {
+      writer.uint32(40).bool(message.lastChunk);
+    }
+    if (message.metadata !== void 0) {
+      Struct.encode(Struct.wrap(message.metadata), writer.uint32(50).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTaskArtifactUpdateEvent();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.taskId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.contextId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.artifact = Artifact.decode(reader, reader.uint32());
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+          message.append = reader.bool();
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+          message.lastChunk = reader.bool();
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.metadata = Struct.unwrap(Struct.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseAuthenticationInfo() {
+  return { scheme: "", credentials: "" };
+}
+var AuthenticationInfo = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.scheme !== "") {
+      writer.uint32(10).string(message.scheme);
+    }
+    if (message.credentials !== "") {
+      writer.uint32(18).string(message.credentials);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseAuthenticationInfo();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.scheme = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.credentials = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseAgentInterface() {
+  return { url: "", protocolBinding: "", tenant: "", protocolVersion: "" };
+}
+var AgentInterface = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.url !== "") {
+      writer.uint32(10).string(message.url);
+    }
+    if (message.protocolBinding !== "") {
+      writer.uint32(18).string(message.protocolBinding);
+    }
+    if (message.tenant !== "") {
+      writer.uint32(26).string(message.tenant);
+    }
+    if (message.protocolVersion !== "") {
+      writer.uint32(34).string(message.protocolVersion);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseAgentInterface();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.url = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.protocolBinding = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.tenant = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.protocolVersion = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseAgentCard() {
+  return {
+    name: "",
+    description: "",
+    supportedInterfaces: [],
+    provider: void 0,
+    version: "",
+    documentationUrl: void 0,
+    capabilities: void 0,
+    securitySchemes: {},
+    securityRequirements: [],
+    defaultInputModes: [],
+    defaultOutputModes: [],
+    skills: [],
+    signatures: [],
+    iconUrl: void 0
+  };
+}
+var AgentCard = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+    if (message.description !== "") {
+      writer.uint32(18).string(message.description);
+    }
+    for (const v of message.supportedInterfaces) {
+      AgentInterface.encode(v, writer.uint32(26).fork()).join();
+    }
+    if (message.provider !== void 0) {
+      AgentProvider.encode(message.provider, writer.uint32(34).fork()).join();
+    }
+    if (message.version !== "") {
+      writer.uint32(42).string(message.version);
+    }
+    if (message.documentationUrl !== void 0) {
+      writer.uint32(50).string(message.documentationUrl);
+    }
+    if (message.capabilities !== void 0) {
+      AgentCapabilities.encode(message.capabilities, writer.uint32(58).fork()).join();
+    }
+    Object.entries(message.securitySchemes).forEach(([key, value]) => {
+      AgentCard_SecuritySchemesEntry.encode({ key, value }, writer.uint32(66).fork()).join();
+    });
+    for (const v of message.securityRequirements) {
+      SecurityRequirement.encode(v, writer.uint32(74).fork()).join();
+    }
+    for (const v of message.defaultInputModes) {
+      writer.uint32(82).string(v);
+    }
+    for (const v of message.defaultOutputModes) {
+      writer.uint32(90).string(v);
+    }
+    for (const v of message.skills) {
+      AgentSkill.encode(v, writer.uint32(98).fork()).join();
+    }
+    for (const v of message.signatures) {
+      AgentCardSignature.encode(v, writer.uint32(106).fork()).join();
+    }
+    if (message.iconUrl !== void 0) {
+      writer.uint32(114).string(message.iconUrl);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseAgentCard();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.name = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.description = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.supportedInterfaces.push(AgentInterface.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.provider = AgentProvider.decode(reader, reader.uint32());
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.version = reader.string();
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.documentationUrl = reader.string();
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+          message.capabilities = AgentCapabilities.decode(reader, reader.uint32());
+          continue;
+        }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+          const entry8 = AgentCard_SecuritySchemesEntry.decode(reader, reader.uint32());
+          if (entry8.value !== void 0) {
+            message.securitySchemes[entry8.key] = entry8.value;
+          }
+          continue;
+        }
+        case 9: {
+          if (tag !== 74) {
+            break;
+          }
+          message.securityRequirements.push(SecurityRequirement.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 10: {
+          if (tag !== 82) {
+            break;
+          }
+          message.defaultInputModes.push(reader.string());
+          continue;
+        }
+        case 11: {
+          if (tag !== 90) {
+            break;
+          }
+          message.defaultOutputModes.push(reader.string());
+          continue;
+        }
+        case 12: {
+          if (tag !== 98) {
+            break;
+          }
+          message.skills.push(AgentSkill.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 13: {
+          if (tag !== 106) {
+            break;
+          }
+          message.signatures.push(AgentCardSignature.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 14: {
+          if (tag !== 114) {
+            break;
+          }
+          message.iconUrl = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseAgentCard_SecuritySchemesEntry() {
+  return { key: "", value: void 0 };
+}
+var AgentCard_SecuritySchemesEntry = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== void 0) {
+      SecurityScheme.encode(message.value, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseAgentCard_SecuritySchemesEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = SecurityScheme.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseAgentProvider() {
+  return { url: "", organization: "" };
+}
+var AgentProvider = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.url !== "") {
+      writer.uint32(10).string(message.url);
+    }
+    if (message.organization !== "") {
+      writer.uint32(18).string(message.organization);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseAgentProvider();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.url = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.organization = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseAgentCapabilities() {
+  return { streaming: void 0, pushNotifications: void 0, extensions: [], extendedAgentCard: void 0 };
+}
+var AgentCapabilities = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.streaming !== void 0) {
+      writer.uint32(8).bool(message.streaming);
+    }
+    if (message.pushNotifications !== void 0) {
+      writer.uint32(16).bool(message.pushNotifications);
+    }
+    for (const v of message.extensions) {
+      AgentExtension.encode(v, writer.uint32(26).fork()).join();
+    }
+    if (message.extendedAgentCard !== void 0) {
+      writer.uint32(32).bool(message.extendedAgentCard);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseAgentCapabilities();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.streaming = reader.bool();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.pushNotifications = reader.bool();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.extensions.push(AgentExtension.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+          message.extendedAgentCard = reader.bool();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseAgentExtension() {
+  return { uri: "", description: "", required: false, params: void 0 };
+}
+var AgentExtension = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.uri !== "") {
+      writer.uint32(10).string(message.uri);
+    }
+    if (message.description !== "") {
+      writer.uint32(18).string(message.description);
+    }
+    if (message.required !== false) {
+      writer.uint32(24).bool(message.required);
+    }
+    if (message.params !== void 0) {
+      Struct.encode(Struct.wrap(message.params), writer.uint32(34).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseAgentExtension();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.uri = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.description = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+          message.required = reader.bool();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.params = Struct.unwrap(Struct.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseAgentSkill() {
+  return {
+    id: "",
+    name: "",
+    description: "",
+    tags: [],
+    examples: [],
+    inputModes: [],
+    outputModes: [],
+    securityRequirements: []
+  };
+}
+var AgentSkill = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.id !== "") {
+      writer.uint32(10).string(message.id);
+    }
+    if (message.name !== "") {
+      writer.uint32(18).string(message.name);
+    }
+    if (message.description !== "") {
+      writer.uint32(26).string(message.description);
+    }
+    for (const v of message.tags) {
+      writer.uint32(34).string(v);
+    }
+    for (const v of message.examples) {
+      writer.uint32(42).string(v);
+    }
+    for (const v of message.inputModes) {
+      writer.uint32(50).string(v);
+    }
+    for (const v of message.outputModes) {
+      writer.uint32(58).string(v);
+    }
+    for (const v of message.securityRequirements) {
+      SecurityRequirement.encode(v, writer.uint32(66).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseAgentSkill();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.id = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.name = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.description = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.tags.push(reader.string());
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.examples.push(reader.string());
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.inputModes.push(reader.string());
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+          message.outputModes.push(reader.string());
+          continue;
+        }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+          message.securityRequirements.push(SecurityRequirement.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseAgentCardSignature() {
+  return { protected: "", signature: "", header: void 0 };
+}
+var AgentCardSignature = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.protected !== "") {
+      writer.uint32(10).string(message.protected);
+    }
+    if (message.signature !== "") {
+      writer.uint32(18).string(message.signature);
+    }
+    if (message.header !== void 0) {
+      Struct.encode(Struct.wrap(message.header), writer.uint32(26).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseAgentCardSignature();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.protected = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.signature = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.header = Struct.unwrap(Struct.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseTaskPushNotificationConfig() {
+  return { tenant: "", id: "", taskId: "", url: "", token: "", authentication: void 0 };
+}
+var TaskPushNotificationConfig = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.tenant !== "") {
+      writer.uint32(10).string(message.tenant);
+    }
+    if (message.id !== "") {
+      writer.uint32(18).string(message.id);
+    }
+    if (message.taskId !== "") {
+      writer.uint32(26).string(message.taskId);
+    }
+    if (message.url !== "") {
+      writer.uint32(34).string(message.url);
+    }
+    if (message.token !== "") {
+      writer.uint32(42).string(message.token);
+    }
+    if (message.authentication !== void 0) {
+      AuthenticationInfo.encode(message.authentication, writer.uint32(50).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseTaskPushNotificationConfig();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.tenant = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.id = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.taskId = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.url = reader.string();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.token = reader.string();
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.authentication = AuthenticationInfo.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseStringList() {
+  return { list: [] };
+}
+var StringList = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    for (const v of message.list) {
+      writer.uint32(10).string(v);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseStringList();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.list.push(reader.string());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseSecurityRequirement() {
+  return { schemes: {} };
+}
+var SecurityRequirement = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    Object.entries(message.schemes).forEach(([key, value]) => {
+      SecurityRequirement_SchemesEntry.encode({ key, value }, writer.uint32(10).fork()).join();
+    });
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSecurityRequirement();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          const entry1 = SecurityRequirement_SchemesEntry.decode(reader, reader.uint32());
+          if (entry1.value !== void 0) {
+            message.schemes[entry1.key] = entry1.value;
+          }
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseSecurityRequirement_SchemesEntry() {
+  return { key: "", value: void 0 };
+}
+var SecurityRequirement_SchemesEntry = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== void 0) {
+      StringList.encode(message.value, writer.uint32(18).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSecurityRequirement_SchemesEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = StringList.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseSecurityScheme() {
+  return { scheme: void 0 };
+}
+var SecurityScheme = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    switch (message.scheme?.$case) {
+      case "apiKeySecurityScheme":
+        APIKeySecurityScheme.encode(message.scheme.value, writer.uint32(10).fork()).join();
+        break;
+      case "httpAuthSecurityScheme":
+        HTTPAuthSecurityScheme.encode(message.scheme.value, writer.uint32(18).fork()).join();
+        break;
+      case "oauth2SecurityScheme":
+        OAuth2SecurityScheme.encode(message.scheme.value, writer.uint32(26).fork()).join();
+        break;
+      case "openIdConnectSecurityScheme":
+        OpenIdConnectSecurityScheme.encode(message.scheme.value, writer.uint32(34).fork()).join();
+        break;
+      case "mtlsSecurityScheme":
+        MutualTlsSecurityScheme.encode(message.scheme.value, writer.uint32(42).fork()).join();
+        break;
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSecurityScheme();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.scheme = {
+            $case: "apiKeySecurityScheme",
+            value: APIKeySecurityScheme.decode(reader, reader.uint32())
+          };
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.scheme = {
+            $case: "httpAuthSecurityScheme",
+            value: HTTPAuthSecurityScheme.decode(reader, reader.uint32())
+          };
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.scheme = {
+            $case: "oauth2SecurityScheme",
+            value: OAuth2SecurityScheme.decode(reader, reader.uint32())
+          };
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.scheme = {
+            $case: "openIdConnectSecurityScheme",
+            value: OpenIdConnectSecurityScheme.decode(reader, reader.uint32())
+          };
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.scheme = {
+            $case: "mtlsSecurityScheme",
+            value: MutualTlsSecurityScheme.decode(reader, reader.uint32())
+          };
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseAPIKeySecurityScheme() {
+  return { description: "", location: "", name: "" };
+}
+var APIKeySecurityScheme = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.description !== "") {
+      writer.uint32(10).string(message.description);
+    }
+    if (message.location !== "") {
+      writer.uint32(18).string(message.location);
+    }
+    if (message.name !== "") {
+      writer.uint32(26).string(message.name);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseAPIKeySecurityScheme();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.description = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.location = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.name = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseHTTPAuthSecurityScheme() {
+  return { description: "", scheme: "", bearerFormat: "" };
+}
+var HTTPAuthSecurityScheme = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.description !== "") {
+      writer.uint32(10).string(message.description);
+    }
+    if (message.scheme !== "") {
+      writer.uint32(18).string(message.scheme);
+    }
+    if (message.bearerFormat !== "") {
+      writer.uint32(26).string(message.bearerFormat);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseHTTPAuthSecurityScheme();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.description = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.scheme = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.bearerFormat = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseOAuth2SecurityScheme() {
+  return { description: "", flows: void 0, oauth2MetadataUrl: "" };
+}
+var OAuth2SecurityScheme = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.description !== "") {
+      writer.uint32(10).string(message.description);
+    }
+    if (message.flows !== void 0) {
+      OAuthFlows.encode(message.flows, writer.uint32(18).fork()).join();
+    }
+    if (message.oauth2MetadataUrl !== "") {
+      writer.uint32(26).string(message.oauth2MetadataUrl);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseOAuth2SecurityScheme();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.description = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.flows = OAuthFlows.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.oauth2MetadataUrl = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseOpenIdConnectSecurityScheme() {
+  return { description: "", openIdConnectUrl: "" };
+}
+var OpenIdConnectSecurityScheme = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.description !== "") {
+      writer.uint32(10).string(message.description);
+    }
+    if (message.openIdConnectUrl !== "") {
+      writer.uint32(18).string(message.openIdConnectUrl);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseOpenIdConnectSecurityScheme();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.description = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.openIdConnectUrl = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseMutualTlsSecurityScheme() {
+  return { description: "" };
+}
+var MutualTlsSecurityScheme = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.description !== "") {
+      writer.uint32(10).string(message.description);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseMutualTlsSecurityScheme();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.description = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseOAuthFlows() {
+  return { flow: void 0 };
+}
+var OAuthFlows = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    switch (message.flow?.$case) {
+      case "authorizationCode":
+        AuthorizationCodeOAuthFlow.encode(message.flow.value, writer.uint32(10).fork()).join();
+        break;
+      case "clientCredentials":
+        ClientCredentialsOAuthFlow.encode(message.flow.value, writer.uint32(18).fork()).join();
+        break;
+      case "implicit":
+        ImplicitOAuthFlow.encode(message.flow.value, writer.uint32(26).fork()).join();
+        break;
+      case "password":
+        PasswordOAuthFlow.encode(message.flow.value, writer.uint32(34).fork()).join();
+        break;
+      case "deviceCode":
+        DeviceCodeOAuthFlow.encode(message.flow.value, writer.uint32(42).fork()).join();
+        break;
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseOAuthFlows();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.flow = {
+            $case: "authorizationCode",
+            value: AuthorizationCodeOAuthFlow.decode(reader, reader.uint32())
+          };
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.flow = {
+            $case: "clientCredentials",
+            value: ClientCredentialsOAuthFlow.decode(reader, reader.uint32())
+          };
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.flow = { $case: "implicit", value: ImplicitOAuthFlow.decode(reader, reader.uint32()) };
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.flow = { $case: "password", value: PasswordOAuthFlow.decode(reader, reader.uint32()) };
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.flow = { $case: "deviceCode", value: DeviceCodeOAuthFlow.decode(reader, reader.uint32()) };
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseAuthorizationCodeOAuthFlow() {
+  return { authorizationUrl: "", tokenUrl: "", refreshUrl: "", scopes: {}, pkceRequired: false };
+}
+var AuthorizationCodeOAuthFlow = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.authorizationUrl !== "") {
+      writer.uint32(10).string(message.authorizationUrl);
+    }
+    if (message.tokenUrl !== "") {
+      writer.uint32(18).string(message.tokenUrl);
+    }
+    if (message.refreshUrl !== "") {
+      writer.uint32(26).string(message.refreshUrl);
+    }
+    Object.entries(message.scopes).forEach(([key, value]) => {
+      AuthorizationCodeOAuthFlow_ScopesEntry.encode({ key, value }, writer.uint32(34).fork()).join();
+    });
+    if (message.pkceRequired !== false) {
+      writer.uint32(40).bool(message.pkceRequired);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseAuthorizationCodeOAuthFlow();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.authorizationUrl = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.tokenUrl = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.refreshUrl = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          const entry4 = AuthorizationCodeOAuthFlow_ScopesEntry.decode(reader, reader.uint32());
+          if (entry4.value !== void 0) {
+            message.scopes[entry4.key] = entry4.value;
+          }
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+          message.pkceRequired = reader.bool();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseAuthorizationCodeOAuthFlow_ScopesEntry() {
+  return { key: "", value: "" };
+}
+var AuthorizationCodeOAuthFlow_ScopesEntry = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseAuthorizationCodeOAuthFlow_ScopesEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseClientCredentialsOAuthFlow() {
+  return { tokenUrl: "", refreshUrl: "", scopes: {} };
+}
+var ClientCredentialsOAuthFlow = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.tokenUrl !== "") {
+      writer.uint32(10).string(message.tokenUrl);
+    }
+    if (message.refreshUrl !== "") {
+      writer.uint32(18).string(message.refreshUrl);
+    }
+    Object.entries(message.scopes).forEach(([key, value]) => {
+      ClientCredentialsOAuthFlow_ScopesEntry.encode({ key, value }, writer.uint32(26).fork()).join();
+    });
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseClientCredentialsOAuthFlow();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.tokenUrl = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.refreshUrl = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          const entry3 = ClientCredentialsOAuthFlow_ScopesEntry.decode(reader, reader.uint32());
+          if (entry3.value !== void 0) {
+            message.scopes[entry3.key] = entry3.value;
+          }
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseClientCredentialsOAuthFlow_ScopesEntry() {
+  return { key: "", value: "" };
+}
+var ClientCredentialsOAuthFlow_ScopesEntry = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseClientCredentialsOAuthFlow_ScopesEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseImplicitOAuthFlow() {
+  return { authorizationUrl: "", refreshUrl: "", scopes: {} };
+}
+var ImplicitOAuthFlow = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.authorizationUrl !== "") {
+      writer.uint32(10).string(message.authorizationUrl);
+    }
+    if (message.refreshUrl !== "") {
+      writer.uint32(18).string(message.refreshUrl);
+    }
+    Object.entries(message.scopes).forEach(([key, value]) => {
+      ImplicitOAuthFlow_ScopesEntry.encode({ key, value }, writer.uint32(26).fork()).join();
+    });
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseImplicitOAuthFlow();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.authorizationUrl = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.refreshUrl = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          const entry3 = ImplicitOAuthFlow_ScopesEntry.decode(reader, reader.uint32());
+          if (entry3.value !== void 0) {
+            message.scopes[entry3.key] = entry3.value;
+          }
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseImplicitOAuthFlow_ScopesEntry() {
+  return { key: "", value: "" };
+}
+var ImplicitOAuthFlow_ScopesEntry = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseImplicitOAuthFlow_ScopesEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBasePasswordOAuthFlow() {
+  return { tokenUrl: "", refreshUrl: "", scopes: {} };
+}
+var PasswordOAuthFlow = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.tokenUrl !== "") {
+      writer.uint32(10).string(message.tokenUrl);
+    }
+    if (message.refreshUrl !== "") {
+      writer.uint32(18).string(message.refreshUrl);
+    }
+    Object.entries(message.scopes).forEach(([key, value]) => {
+      PasswordOAuthFlow_ScopesEntry.encode({ key, value }, writer.uint32(26).fork()).join();
+    });
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBasePasswordOAuthFlow();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.tokenUrl = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.refreshUrl = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          const entry3 = PasswordOAuthFlow_ScopesEntry.decode(reader, reader.uint32());
+          if (entry3.value !== void 0) {
+            message.scopes[entry3.key] = entry3.value;
+          }
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBasePasswordOAuthFlow_ScopesEntry() {
+  return { key: "", value: "" };
+}
+var PasswordOAuthFlow_ScopesEntry = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBasePasswordOAuthFlow_ScopesEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseDeviceCodeOAuthFlow() {
+  return { deviceAuthorizationUrl: "", tokenUrl: "", refreshUrl: "", scopes: {} };
+}
+var DeviceCodeOAuthFlow = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.deviceAuthorizationUrl !== "") {
+      writer.uint32(10).string(message.deviceAuthorizationUrl);
+    }
+    if (message.tokenUrl !== "") {
+      writer.uint32(18).string(message.tokenUrl);
+    }
+    if (message.refreshUrl !== "") {
+      writer.uint32(26).string(message.refreshUrl);
+    }
+    Object.entries(message.scopes).forEach(([key, value]) => {
+      DeviceCodeOAuthFlow_ScopesEntry.encode({ key, value }, writer.uint32(34).fork()).join();
+    });
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseDeviceCodeOAuthFlow();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.deviceAuthorizationUrl = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.tokenUrl = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.refreshUrl = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          const entry4 = DeviceCodeOAuthFlow_ScopesEntry.decode(reader, reader.uint32());
+          if (entry4.value !== void 0) {
+            message.scopes[entry4.key] = entry4.value;
+          }
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseDeviceCodeOAuthFlow_ScopesEntry() {
+  return { key: "", value: "" };
+}
+var DeviceCodeOAuthFlow_ScopesEntry = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseDeviceCodeOAuthFlow_ScopesEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.value = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseSendMessageRequest() {
+  return { tenant: "", message: void 0, configuration: void 0, metadata: void 0 };
+}
+var SendMessageRequest = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.tenant !== "") {
+      writer.uint32(10).string(message.tenant);
+    }
+    if (message.message !== void 0) {
+      Message.encode(message.message, writer.uint32(18).fork()).join();
+    }
+    if (message.configuration !== void 0) {
+      SendMessageConfiguration.encode(message.configuration, writer.uint32(26).fork()).join();
+    }
+    if (message.metadata !== void 0) {
+      Struct.encode(Struct.wrap(message.metadata), writer.uint32(34).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSendMessageRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.tenant = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.message = Message.decode(reader, reader.uint32());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.configuration = SendMessageConfiguration.decode(reader, reader.uint32());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.metadata = Struct.unwrap(Struct.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseGetTaskRequest() {
+  return { tenant: "", id: "", historyLength: void 0 };
+}
+var GetTaskRequest = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.tenant !== "") {
+      writer.uint32(10).string(message.tenant);
+    }
+    if (message.id !== "") {
+      writer.uint32(18).string(message.id);
+    }
+    if (message.historyLength !== void 0) {
+      writer.uint32(24).int32(message.historyLength);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseGetTaskRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.tenant = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.id = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+          message.historyLength = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseListTasksRequest() {
+  return {
+    tenant: "",
+    contextId: "",
+    status: 0,
+    pageSize: void 0,
+    pageToken: "",
+    historyLength: void 0,
+    statusTimestampAfter: void 0,
+    includeArtifacts: void 0
+  };
+}
+var ListTasksRequest = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.tenant !== "") {
+      writer.uint32(10).string(message.tenant);
+    }
+    if (message.contextId !== "") {
+      writer.uint32(18).string(message.contextId);
+    }
+    if (message.status !== 0) {
+      writer.uint32(24).int32(message.status);
+    }
+    if (message.pageSize !== void 0) {
+      writer.uint32(32).int32(message.pageSize);
+    }
+    if (message.pageToken !== "") {
+      writer.uint32(42).string(message.pageToken);
+    }
+    if (message.historyLength !== void 0) {
+      writer.uint32(48).int32(message.historyLength);
+    }
+    if (message.statusTimestampAfter !== void 0) {
+      Timestamp.encode(toTimestamp(message.statusTimestampAfter), writer.uint32(58).fork()).join();
+    }
+    if (message.includeArtifacts !== void 0) {
+      writer.uint32(64).bool(message.includeArtifacts);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseListTasksRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.tenant = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.contextId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+          message.status = reader.int32();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+          message.pageSize = reader.int32();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+          message.pageToken = reader.string();
+          continue;
+        }
+        case 6: {
+          if (tag !== 48) {
+            break;
+          }
+          message.historyLength = reader.int32();
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+          message.statusTimestampAfter = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 8: {
+          if (tag !== 64) {
+            break;
+          }
+          message.includeArtifacts = reader.bool();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseListTasksResponse() {
+  return { tasks: [], nextPageToken: "", pageSize: 0, totalSize: 0 };
+}
+var ListTasksResponse = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    for (const v of message.tasks) {
+      Task.encode(v, writer.uint32(10).fork()).join();
+    }
+    if (message.nextPageToken !== "") {
+      writer.uint32(18).string(message.nextPageToken);
+    }
+    if (message.pageSize !== 0) {
+      writer.uint32(24).int32(message.pageSize);
+    }
+    if (message.totalSize !== 0) {
+      writer.uint32(32).int32(message.totalSize);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseListTasksResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.tasks.push(Task.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.nextPageToken = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+          message.pageSize = reader.int32();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+          message.totalSize = reader.int32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseCancelTaskRequest() {
+  return { tenant: "", id: "", metadata: void 0 };
+}
+var CancelTaskRequest = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.tenant !== "") {
+      writer.uint32(10).string(message.tenant);
+    }
+    if (message.id !== "") {
+      writer.uint32(18).string(message.id);
+    }
+    if (message.metadata !== void 0) {
+      Struct.encode(Struct.wrap(message.metadata), writer.uint32(26).fork()).join();
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseCancelTaskRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.tenant = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.id = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.metadata = Struct.unwrap(Struct.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseGetTaskPushNotificationConfigRequest() {
+  return { tenant: "", taskId: "", id: "" };
+}
+var GetTaskPushNotificationConfigRequest = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.tenant !== "") {
+      writer.uint32(10).string(message.tenant);
+    }
+    if (message.taskId !== "") {
+      writer.uint32(18).string(message.taskId);
+    }
+    if (message.id !== "") {
+      writer.uint32(26).string(message.id);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseGetTaskPushNotificationConfigRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.tenant = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.taskId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.id = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseDeleteTaskPushNotificationConfigRequest() {
+  return { tenant: "", taskId: "", id: "" };
+}
+var DeleteTaskPushNotificationConfigRequest = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.tenant !== "") {
+      writer.uint32(10).string(message.tenant);
+    }
+    if (message.taskId !== "") {
+      writer.uint32(18).string(message.taskId);
+    }
+    if (message.id !== "") {
+      writer.uint32(26).string(message.id);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseDeleteTaskPushNotificationConfigRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.tenant = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.taskId = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.id = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseSubscribeToTaskRequest() {
+  return { tenant: "", id: "" };
+}
+var SubscribeToTaskRequest = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.tenant !== "") {
+      writer.uint32(10).string(message.tenant);
+    }
+    if (message.id !== "") {
+      writer.uint32(18).string(message.id);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSubscribeToTaskRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.tenant = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.id = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseListTaskPushNotificationConfigsRequest() {
+  return { tenant: "", taskId: "", pageSize: 0, pageToken: "" };
+}
+var ListTaskPushNotificationConfigsRequest = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.tenant !== "") {
+      writer.uint32(34).string(message.tenant);
+    }
+    if (message.taskId !== "") {
+      writer.uint32(10).string(message.taskId);
+    }
+    if (message.pageSize !== 0) {
+      writer.uint32(16).int32(message.pageSize);
+    }
+    if (message.pageToken !== "") {
+      writer.uint32(26).string(message.pageToken);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseListTaskPushNotificationConfigsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.tenant = reader.string();
+          continue;
+        }
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.taskId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+          message.pageSize = reader.int32();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.pageToken = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseGetExtendedAgentCardRequest() {
+  return { tenant: "" };
+}
+var GetExtendedAgentCardRequest = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    if (message.tenant !== "") {
+      writer.uint32(10).string(message.tenant);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseGetExtendedAgentCardRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.tenant = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseSendMessageResponse() {
+  return { payload: void 0 };
+}
+var SendMessageResponse = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    switch (message.payload?.$case) {
+      case "task":
+        Task.encode(message.payload.value, writer.uint32(10).fork()).join();
+        break;
+      case "message":
+        Message.encode(message.payload.value, writer.uint32(18).fork()).join();
+        break;
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseSendMessageResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.payload = { $case: "task", value: Task.decode(reader, reader.uint32()) };
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.payload = { $case: "message", value: Message.decode(reader, reader.uint32()) };
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseStreamResponse() {
+  return { payload: void 0 };
+}
+var StreamResponse = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    switch (message.payload?.$case) {
+      case "task":
+        Task.encode(message.payload.value, writer.uint32(10).fork()).join();
+        break;
+      case "message":
+        Message.encode(message.payload.value, writer.uint32(18).fork()).join();
+        break;
+      case "statusUpdate":
+        TaskStatusUpdateEvent.encode(message.payload.value, writer.uint32(26).fork()).join();
+        break;
+      case "artifactUpdate":
+        TaskArtifactUpdateEvent.encode(message.payload.value, writer.uint32(34).fork()).join();
+        break;
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseStreamResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.payload = { $case: "task", value: Task.decode(reader, reader.uint32()) };
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.payload = { $case: "message", value: Message.decode(reader, reader.uint32()) };
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.payload = { $case: "statusUpdate", value: TaskStatusUpdateEvent.decode(reader, reader.uint32()) };
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.payload = { $case: "artifactUpdate", value: TaskArtifactUpdateEvent.decode(reader, reader.uint32()) };
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+function createBaseListTaskPushNotificationConfigsResponse() {
+  return { configs: [], nextPageToken: "" };
+}
+var ListTaskPushNotificationConfigsResponse = {
+  encode(message, writer = new import_wire8.BinaryWriter()) {
+    for (const v of message.configs) {
+      TaskPushNotificationConfig.encode(v, writer.uint32(10).fork()).join();
+    }
+    if (message.nextPageToken !== "") {
+      writer.uint32(18).string(message.nextPageToken);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire8.BinaryReader ? input : new import_wire8.BinaryReader(input);
+    let end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseListTaskPushNotificationConfigsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.configs.push(TaskPushNotificationConfig.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.nextPageToken = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  }
+};
+var A2AServiceService = {
+  /** Sends a message to an agent. */
+  sendMessage: {
+    path: "/lf.a2a.v1.A2AService/SendMessage",
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => Buffer.from(SendMessageRequest.encode(value).finish()),
+    requestDeserialize: (value) => SendMessageRequest.decode(value),
+    responseSerialize: (value) => Buffer.from(SendMessageResponse.encode(value).finish()),
+    responseDeserialize: (value) => SendMessageResponse.decode(value)
+  },
+  /**
+   * Sends a streaming message to an agent, allowing for real-time interaction and status updates.
+   * Streaming version of `SendMessage`
+   */
+  sendStreamingMessage: {
+    path: "/lf.a2a.v1.A2AService/SendStreamingMessage",
+    requestStream: false,
+    responseStream: true,
+    requestSerialize: (value) => Buffer.from(SendMessageRequest.encode(value).finish()),
+    requestDeserialize: (value) => SendMessageRequest.decode(value),
+    responseSerialize: (value) => Buffer.from(StreamResponse.encode(value).finish()),
+    responseDeserialize: (value) => StreamResponse.decode(value)
+  },
+  /** Gets the latest state of a task. */
+  getTask: {
+    path: "/lf.a2a.v1.A2AService/GetTask",
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => Buffer.from(GetTaskRequest.encode(value).finish()),
+    requestDeserialize: (value) => GetTaskRequest.decode(value),
+    responseSerialize: (value) => Buffer.from(Task.encode(value).finish()),
+    responseDeserialize: (value) => Task.decode(value)
+  },
+  /** Lists tasks that match the specified filter. */
+  listTasks: {
+    path: "/lf.a2a.v1.A2AService/ListTasks",
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => Buffer.from(ListTasksRequest.encode(value).finish()),
+    requestDeserialize: (value) => ListTasksRequest.decode(value),
+    responseSerialize: (value) => Buffer.from(ListTasksResponse.encode(value).finish()),
+    responseDeserialize: (value) => ListTasksResponse.decode(value)
+  },
+  /** Cancels a task in progress. */
+  cancelTask: {
+    path: "/lf.a2a.v1.A2AService/CancelTask",
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => Buffer.from(CancelTaskRequest.encode(value).finish()),
+    requestDeserialize: (value) => CancelTaskRequest.decode(value),
+    responseSerialize: (value) => Buffer.from(Task.encode(value).finish()),
+    responseDeserialize: (value) => Task.decode(value)
+  },
+  /**
+   * Subscribes to task updates for tasks not in a terminal state.
+   * Returns `UnsupportedOperationError` if the task is already in a terminal state (completed, failed, canceled, rejected).
+   */
+  subscribeToTask: {
+    path: "/lf.a2a.v1.A2AService/SubscribeToTask",
+    requestStream: false,
+    responseStream: true,
+    requestSerialize: (value) => Buffer.from(SubscribeToTaskRequest.encode(value).finish()),
+    requestDeserialize: (value) => SubscribeToTaskRequest.decode(value),
+    responseSerialize: (value) => Buffer.from(StreamResponse.encode(value).finish()),
+    responseDeserialize: (value) => StreamResponse.decode(value)
+  },
+  /**
+   * (-- api-linter: client-libraries::4232::required-fields=disabled
+   *     api-linter: core::0133::method-signature=disabled
+   *     api-linter: core::0133::request-message-name=disabled
+   *     aip.dev/not-precedent: method_signature preserved for backwards compatibility --)
+   * Creates a push notification config for a task.
+   */
+  createTaskPushNotificationConfig: {
+    path: "/lf.a2a.v1.A2AService/CreateTaskPushNotificationConfig",
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => Buffer.from(TaskPushNotificationConfig.encode(value).finish()),
+    requestDeserialize: (value) => TaskPushNotificationConfig.decode(value),
+    responseSerialize: (value) => Buffer.from(TaskPushNotificationConfig.encode(value).finish()),
+    responseDeserialize: (value) => TaskPushNotificationConfig.decode(value)
+  },
+  /** Gets a push notification config for a task. */
+  getTaskPushNotificationConfig: {
+    path: "/lf.a2a.v1.A2AService/GetTaskPushNotificationConfig",
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => Buffer.from(GetTaskPushNotificationConfigRequest.encode(value).finish()),
+    requestDeserialize: (value) => GetTaskPushNotificationConfigRequest.decode(value),
+    responseSerialize: (value) => Buffer.from(TaskPushNotificationConfig.encode(value).finish()),
+    responseDeserialize: (value) => TaskPushNotificationConfig.decode(value)
+  },
+  /** Get a list of push notifications configured for a task. */
+  listTaskPushNotificationConfigs: {
+    path: "/lf.a2a.v1.A2AService/ListTaskPushNotificationConfigs",
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => Buffer.from(ListTaskPushNotificationConfigsRequest.encode(value).finish()),
+    requestDeserialize: (value) => ListTaskPushNotificationConfigsRequest.decode(value),
+    responseSerialize: (value) => Buffer.from(ListTaskPushNotificationConfigsResponse.encode(value).finish()),
+    responseDeserialize: (value) => ListTaskPushNotificationConfigsResponse.decode(value)
+  },
+  /** Gets the extended agent card for the authenticated agent. */
+  getExtendedAgentCard: {
+    path: "/lf.a2a.v1.A2AService/GetExtendedAgentCard",
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => Buffer.from(GetExtendedAgentCardRequest.encode(value).finish()),
+    requestDeserialize: (value) => GetExtendedAgentCardRequest.decode(value),
+    responseSerialize: (value) => Buffer.from(AgentCard.encode(value).finish()),
+    responseDeserialize: (value) => AgentCard.decode(value)
+  },
+  /** Deletes a push notification config for a task. */
+  deleteTaskPushNotificationConfig: {
+    path: "/lf.a2a.v1.A2AService/DeleteTaskPushNotificationConfig",
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value) => Buffer.from(DeleteTaskPushNotificationConfigRequest.encode(value).finish()),
+    requestDeserialize: (value) => DeleteTaskPushNotificationConfigRequest.decode(value),
+    responseSerialize: (value) => Buffer.from(Empty.encode(value).finish()),
+    responseDeserialize: (value) => Empty.decode(value)
+  }
+};
+var A2AServiceClient = (0, import_grpc_js.makeGenericClientConstructor)(A2AServiceService, "lf.a2a.v1.A2AService");
+function toTimestamp(dateStr) {
+  const date = new globalThis.Date(dateStr);
+  const seconds = Math.trunc(date.getTime() / 1e3);
+  const nanos = date.getTime() % 1e3 * 1e6;
+  return { seconds, nanos };
+}
+function fromTimestamp(t) {
+  let millis = (t.seconds || 0) * 1e3;
+  millis += (t.nanos || 0) / 1e6;
+  return new globalThis.Date(millis).toISOString();
+}
+
+// src/server/authentication/user.ts
+var UnauthenticatedUser = class {
+  get isAuthenticated() {
+    return false;
+  }
+  get userName() {
+    return "";
+  }
+};
+
+// src/server/grpc/common.ts
+var UserBuilder = {
+  noAuthentication: () => Promise.resolve(new UnauthenticatedUser())
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  A2AService,
+  UserBuilder,
+  grpcService
+});