@envarai/connect 0.0.0-stage → 2026.1029.1

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

@@ -0,0 +1,3884 @@
+// src/server/agent_execution/request_context.ts
+var RequestContext = class {
+  request;
+  taskId;
+  contextId;
+  context;
+  task;
+  referenceTasks;
+  constructor(request, taskId, contextId, context, task, referenceTasks) {
+    if (!request.message) {
+      throw new Error("RequestContext requires request.message to be set.");
+    }
+    this.request = structuredClone(request);
+    this.taskId = taskId;
+    this.contextId = contextId;
+    this.context = context;
+    this.task = task;
+    this.referenceTasks = referenceTasks;
+  }
+  get userMessage() {
+    return this.request.message;
+  }
+};
+
+// src/server/events/execution_event_bus.ts
+var AgentEvent = {
+  message: (data) => ({ kind: "message", data }),
+  task: (data) => ({ kind: "task", data }),
+  statusUpdate: (data) => ({
+    kind: "statusUpdate",
+    data
+  }),
+  artifactUpdate: (data) => ({
+    kind: "artifactUpdate",
+    data
+  })
+};
+function assertUnreachableEvent(event) {
+  throw new Error(`Unhandled event kind: ${event.kind}`);
+}
+var CustomEventImpl = typeof CustomEvent !== "undefined" ? CustomEvent : class CustomEventPolyfill extends Event {
+  detail;
+  constructor(type, eventInitDict) {
+    super(type, eventInitDict);
+    this.detail = eventInitDict?.detail ?? null;
+  }
+};
+function isAgentExecutionCustomEvent(e) {
+  return e instanceof CustomEventImpl;
+}
+var DefaultExecutionEventBus = class extends EventTarget {
+  // Separate storage so each event type can hold listeners of its own
+  // signature: 'event' listeners receive a payload, 'finished' listeners
+  // are invoked with no arguments.
+  eventListeners = /* @__PURE__ */ new Map();
+  finishedListeners = /* @__PURE__ */ new Map();
+  publish(event) {
+    this.dispatchEvent(new CustomEventImpl("event", { detail: event }));
+  }
+  finished() {
+    this.dispatchEvent(new Event("finished"));
+  }
+  on(eventName, listener) {
+    if (eventName === "event") {
+      this.addEventListenerInternal(listener);
+    } else {
+      this.addFinishedListenerInternal(listener);
+    }
+    return this;
+  }
+  off(eventName, listener) {
+    if (eventName === "event") {
+      this.removeEventListenerInternal(listener);
+    } else {
+      this.removeFinishedListenerInternal(listener);
+    }
+    return this;
+  }
+  once(eventName, listener) {
+    if (eventName === "event") {
+      this.addEventListenerOnceInternal(listener);
+    } else {
+      this.addFinishedListenerOnceInternal(listener);
+    }
+    return this;
+  }
+  removeAllListeners(eventName) {
+    if (eventName === void 0 || eventName === "event") {
+      for (const wrappedListeners of this.eventListeners.values()) {
+        for (const wrapped of wrappedListeners) {
+          this.removeEventListener("event", wrapped);
+        }
+      }
+      this.eventListeners.clear();
+    }
+    if (eventName === void 0 || eventName === "finished") {
+      for (const wrappedListeners of this.finishedListeners.values()) {
+        for (const wrapped of wrappedListeners) {
+          this.removeEventListener("finished", wrapped);
+        }
+      }
+      this.finishedListeners.clear();
+    }
+    return this;
+  }
+  // Listener tracking helpers.
+  trackListener(listenerMap, listener, wrapped) {
+    const existing = listenerMap.get(listener);
+    if (existing) {
+      existing.push(wrapped);
+    } else {
+      listenerMap.set(listener, [wrapped]);
+    }
+  }
+  untrackWrappedListener(listenerMap, listener, wrapped) {
+    const wrappedList = listenerMap.get(listener);
+    if (wrappedList && wrappedList.length > 0) {
+      const index = wrappedList.indexOf(wrapped);
+      if (index !== -1) {
+        wrappedList.splice(index, 1);
+        if (wrappedList.length === 0) {
+          listenerMap.delete(listener);
+        }
+      }
+    }
+  }
+  // 'event' listeners.
+  addEventListenerInternal(listener) {
+    const wrapped = (e) => {
+      if (!isAgentExecutionCustomEvent(e)) {
+        throw new Error('Internal error: expected CustomEvent for "event" type');
+      }
+      listener.call(this, e.detail);
+    };
+    this.trackListener(this.eventListeners, listener, wrapped);
+    this.addEventListener("event", wrapped);
+  }
+  removeEventListenerInternal(listener) {
+    const wrappedList = this.eventListeners.get(listener);
+    if (wrappedList && wrappedList.length > 0) {
+      const wrapped = wrappedList.pop();
+      if (wrappedList.length === 0) {
+        this.eventListeners.delete(listener);
+      }
+      this.removeEventListener("event", wrapped);
+    }
+  }
+  addEventListenerOnceInternal(listener) {
+    const wrapped = (e) => {
+      if (!isAgentExecutionCustomEvent(e)) {
+        throw new Error('Internal error: expected CustomEvent for "event" type');
+      }
+      this.untrackWrappedListener(this.eventListeners, listener, wrapped);
+      listener.call(this, e.detail);
+    };
+    this.trackListener(this.eventListeners, listener, wrapped);
+    this.addEventListener("event", wrapped, { once: true });
+  }
+  // 'finished' listeners. Invoked with no arguments; the interface
+  // declares them as `FinishedListener` so callers get a precise type.
+  addFinishedListenerInternal(listener) {
+    const wrapped = () => {
+      listener.call(this);
+    };
+    this.trackListener(this.finishedListeners, listener, wrapped);
+    this.addEventListener("finished", wrapped);
+  }
+  removeFinishedListenerInternal(listener) {
+    const wrappedList = this.finishedListeners.get(listener);
+    if (wrappedList && wrappedList.length > 0) {
+      const wrapped = wrappedList.pop();
+      if (wrappedList.length === 0) {
+        this.finishedListeners.delete(listener);
+      }
+      this.removeEventListener("finished", wrapped);
+    }
+  }
+  addFinishedListenerOnceInternal(listener) {
+    const wrapped = () => {
+      this.untrackWrappedListener(this.finishedListeners, listener, wrapped);
+      listener.call(this);
+    };
+    this.trackListener(this.finishedListeners, listener, wrapped);
+    this.addEventListener("finished", wrapped, { once: true });
+  }
+};
+
+// src/extensions.ts
+var Extensions = {
+  /**
+   * Creates new {@link Extensions} from `current` and `additional`.
+   * If `current` already contains `additional` it is returned unmodified.
+   */
+  createFrom: (current, additional) => {
+    if (current?.includes(additional)) {
+      return current;
+    }
+    return [...current ?? [], additional];
+  },
+  /**
+   * Creates {@link Extensions} from comma separated extensions identifiers as per
+   * https://a2a-protocol.org/latest/specification/#326-service-parameters.
+   * Parses the output of `toServiceParameter`.
+   */
+  parseServiceParameter: (value) => {
+    if (!value) {
+      return [];
+    }
+    const unique = new Set(
+      value.split(",").map((ext) => ext.trim()).filter((ext) => ext.length > 0)
+    );
+    return Array.from(unique);
+  },
+  /**
+   * Converts {@link Extensions} to comma separated extensions identifiers as per
+   * https://a2a-protocol.org/latest/specification/#326-service-parameters.
+   */
+  toServiceParameter: (value) => {
+    return value.join(",");
+  }
+};
+
+// src/server/context.ts
+var ABSENT_HEADER_VERSION = "0.3";
+var STATE_HEADERS_KEY = "headers";
+var defaultServerCallContextBuilder = ({
+  extensions,
+  user,
+  headers,
+  requestedVersion,
+  tenant
+}) => {
+  const state = /* @__PURE__ */ new Map([[STATE_HEADERS_KEY, headers]]);
+  return new ServerCallContext({
+    requestedExtensions: extensions,
+    user,
+    state,
+    requestedVersion,
+    tenant
+  });
+};
+var ServerCallContext = class {
+  _requestedExtensions;
+  _user;
+  _requestedVersion;
+  _tenant;
+  _activatedExtensions;
+  _state;
+  constructor(options) {
+    this._requestedExtensions = options?.requestedExtensions;
+    this._user = options?.user;
+    this._tenant = options?.tenant;
+    this._requestedVersion = options?.requestedVersion || ABSENT_HEADER_VERSION;
+    this._state = options?.state ?? /* @__PURE__ */ new Map();
+  }
+  get tenant() {
+    return this._tenant;
+  }
+  /**
+   * Sets the tenant resolved by a transport without replacing this context.
+   * Keeping the instance preserves custom state, subclasses, and extension
+   * activations observed by the response layer.
+   *
+   * @throws {Error} If a tenant has already been set, including by the constructor.
+   */
+  setTenant(tenant) {
+    if (this._tenant !== void 0) {
+      throw new Error("Tenant is already set.");
+    }
+    this._tenant = tenant;
+  }
+  get user() {
+    return this._user;
+  }
+  get activatedExtensions() {
+    return this._activatedExtensions;
+  }
+  get requestedExtensions() {
+    return this._requestedExtensions;
+  }
+  get requestedVersion() {
+    return this._requestedVersion;
+  }
+  /**
+   * Arbitrary key/value state bag, equivalent to the `state` field on the
+   * Python A2A SDK's `ServerCallContext`. Use this to carry custom data
+   * (e.g. request headers, tenant IDs) through the call pipeline.
+   */
+  get state() {
+    return this._state;
+  }
+  addActivatedExtension(uri) {
+    this._activatedExtensions = Extensions.createFrom(this._activatedExtensions, uri);
+  }
+  /**
+   * Replaces the requested-extensions set. Mutated in place rather than
+   * via a fresh context because the transport layer holds a reference
+   * to this object and reads `activatedExtensions` off it after dispatch
+   * to populate the response `A2A-Extensions` header.
+   */
+  setRequestedExtensions(extensions) {
+    this._requestedExtensions = extensions;
+  }
+};
+
+// src/server/owner_resolver.ts
+function resolveUserScope(context) {
+  return context.user?.userName || "unknown";
+}
+
+// src/types/protojson.ts
+function taskStateFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "TASK_STATE_UNSPECIFIED":
+      return 0 /* TASK_STATE_UNSPECIFIED */;
+    case 1:
+    case "TASK_STATE_SUBMITTED":
+      return 1 /* TASK_STATE_SUBMITTED */;
+    case 2:
+    case "TASK_STATE_WORKING":
+      return 2 /* TASK_STATE_WORKING */;
+    case 3:
+    case "TASK_STATE_COMPLETED":
+      return 3 /* TASK_STATE_COMPLETED */;
+    case 4:
+    case "TASK_STATE_FAILED":
+      return 4 /* TASK_STATE_FAILED */;
+    case 5:
+    case "TASK_STATE_CANCELED":
+      return 5 /* TASK_STATE_CANCELED */;
+    case 6:
+    case "TASK_STATE_INPUT_REQUIRED":
+      return 6 /* TASK_STATE_INPUT_REQUIRED */;
+    case 7:
+    case "TASK_STATE_REJECTED":
+      return 7 /* TASK_STATE_REJECTED */;
+    case 8:
+    case "TASK_STATE_AUTH_REQUIRED":
+      return 8 /* TASK_STATE_AUTH_REQUIRED */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
+  }
+}
+function taskStateToJSON(object) {
+  switch (object) {
+    case 0 /* TASK_STATE_UNSPECIFIED */:
+      return "TASK_STATE_UNSPECIFIED";
+    case 1 /* TASK_STATE_SUBMITTED */:
+      return "TASK_STATE_SUBMITTED";
+    case 2 /* TASK_STATE_WORKING */:
+      return "TASK_STATE_WORKING";
+    case 3 /* TASK_STATE_COMPLETED */:
+      return "TASK_STATE_COMPLETED";
+    case 4 /* TASK_STATE_FAILED */:
+      return "TASK_STATE_FAILED";
+    case 5 /* TASK_STATE_CANCELED */:
+      return "TASK_STATE_CANCELED";
+    case 6 /* TASK_STATE_INPUT_REQUIRED */:
+      return "TASK_STATE_INPUT_REQUIRED";
+    case 7 /* TASK_STATE_REJECTED */:
+      return "TASK_STATE_REJECTED";
+    case 8 /* TASK_STATE_AUTH_REQUIRED */:
+      return "TASK_STATE_AUTH_REQUIRED";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+function roleFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "ROLE_UNSPECIFIED":
+      return 0 /* ROLE_UNSPECIFIED */;
+    case 1:
+    case "ROLE_USER":
+      return 1 /* ROLE_USER */;
+    case 2:
+    case "ROLE_AGENT":
+      return 2 /* ROLE_AGENT */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
+  }
+}
+function roleToJSON(object) {
+  switch (object) {
+    case 0 /* ROLE_UNSPECIFIED */:
+      return "ROLE_UNSPECIFIED";
+    case 1 /* ROLE_USER */:
+      return "ROLE_USER";
+    case 2 /* ROLE_AGENT */:
+      return "ROLE_AGENT";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+var SendMessageConfiguration = {
+  fromJSON(object) {
+    return {
+      acceptedOutputModes: globalThis.Array.isArray(object?.acceptedOutputModes) ? object.acceptedOutputModes.map((e) => globalThis.String(e)) : globalThis.Array.isArray(object?.accepted_output_modes) ? object.accepted_output_modes.map((e) => globalThis.String(e)) : [],
+      taskPushNotificationConfig: isSet(object.taskPushNotificationConfig) ? TaskPushNotificationConfig.fromJSON(object.taskPushNotificationConfig) : isSet(object.task_push_notification_config) ? TaskPushNotificationConfig.fromJSON(object.task_push_notification_config) : void 0,
+      historyLength: isSet(object.historyLength) ? globalThis.Number(object.historyLength) : isSet(object.history_length) ? globalThis.Number(object.history_length) : void 0,
+      returnImmediately: isSet(object.returnImmediately) ? globalThis.Boolean(object.returnImmediately) : isSet(object.return_immediately) ? globalThis.Boolean(object.return_immediately) : false
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.acceptedOutputModes?.length) {
+      obj.acceptedOutputModes = message.acceptedOutputModes;
+    }
+    if (message.taskPushNotificationConfig !== void 0) {
+      obj.taskPushNotificationConfig = TaskPushNotificationConfig.toJSON(
+        message.taskPushNotificationConfig
+      );
+    }
+    if (message.historyLength !== void 0) {
+      obj.historyLength = Math.round(message.historyLength);
+    }
+    if (message.returnImmediately !== false) {
+      obj.returnImmediately = message.returnImmediately;
+    }
+    return obj;
+  }
+};
+var Task = {
+  fromJSON(object) {
+    return {
+      id: isSet(object.id) ? globalThis.String(object.id) : "",
+      contextId: isSet(object.contextId) ? globalThis.String(object.contextId) : isSet(object.context_id) ? globalThis.String(object.context_id) : "",
+      status: isSet(object.status) ? TaskStatus.fromJSON(object.status) : void 0,
+      artifacts: globalThis.Array.isArray(object?.artifacts) ? object.artifacts.map((e) => Artifact.fromJSON(e)) : [],
+      history: globalThis.Array.isArray(object?.history) ? object.history.map((e) => Message.fromJSON(e)) : [],
+      metadata: isObject(object.metadata) ? object.metadata : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.id !== "") {
+      obj.id = message.id;
+    }
+    if (message.contextId !== "") {
+      obj.contextId = message.contextId;
+    }
+    if (message.status !== void 0) {
+      obj.status = TaskStatus.toJSON(message.status);
+    }
+    if (message.artifacts?.length) {
+      obj.artifacts = message.artifacts.map((e) => Artifact.toJSON(e));
+    }
+    if (message.history?.length) {
+      obj.history = message.history.map((e) => Message.toJSON(e));
+    }
+    if (message.metadata !== void 0) {
+      obj.metadata = message.metadata;
+    }
+    return obj;
+  }
+};
+var TaskStatus = {
+  fromJSON(object) {
+    return {
+      state: isSet(object.state) ? taskStateFromJSON(object.state) : 0,
+      message: isSet(object.message) ? Message.fromJSON(object.message) : void 0,
+      timestamp: isSet(object.timestamp) ? globalThis.String(object.timestamp) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.state !== 0) {
+      obj.state = taskStateToJSON(message.state);
+    }
+    if (message.message !== void 0) {
+      obj.message = Message.toJSON(message.message);
+    }
+    if (message.timestamp !== void 0) {
+      obj.timestamp = message.timestamp;
+    }
+    return obj;
+  }
+};
+var Part = {
+  fromJSON(object) {
+    return {
+      content: isSet(object.text) ? { $case: "text", value: globalThis.String(object.text) } : isSet(object.raw) ? { $case: "raw", value: Buffer.from(bytesFromBase64(object.raw)) } : isSet(object.url) ? { $case: "url", value: globalThis.String(object.url) } : isSet(object.data) ? { $case: "data", value: object.data } : void 0,
+      metadata: isObject(object.metadata) ? object.metadata : void 0,
+      filename: isSet(object.filename) ? globalThis.String(object.filename) : "",
+      mediaType: isSet(object.mediaType) ? globalThis.String(object.mediaType) : isSet(object.media_type) ? globalThis.String(object.media_type) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.content?.$case === "text") {
+      obj.text = message.content.value;
+    } else if (message.content?.$case === "raw") {
+      obj.raw = base64FromBytes(message.content.value);
+    } else if (message.content?.$case === "url") {
+      obj.url = message.content.value;
+    } else if (message.content?.$case === "data") {
+      obj.data = message.content.value;
+    }
+    if (message.metadata !== void 0) {
+      obj.metadata = message.metadata;
+    }
+    if (message.filename !== "") {
+      obj.filename = message.filename;
+    }
+    if (message.mediaType !== "") {
+      obj.mediaType = message.mediaType;
+    }
+    return obj;
+  }
+};
+var Message = {
+  fromJSON(object) {
+    return {
+      messageId: isSet(object.messageId) ? globalThis.String(object.messageId) : isSet(object.message_id) ? globalThis.String(object.message_id) : "",
+      contextId: isSet(object.contextId) ? globalThis.String(object.contextId) : isSet(object.context_id) ? globalThis.String(object.context_id) : "",
+      taskId: isSet(object.taskId) ? globalThis.String(object.taskId) : isSet(object.task_id) ? globalThis.String(object.task_id) : "",
+      role: isSet(object.role) ? roleFromJSON(object.role) : 0,
+      parts: globalThis.Array.isArray(object?.parts) ? object.parts.map((e) => Part.fromJSON(e)) : [],
+      metadata: isObject(object.metadata) ? object.metadata : void 0,
+      extensions: globalThis.Array.isArray(object?.extensions) ? object.extensions.map((e) => globalThis.String(e)) : [],
+      referenceTaskIds: globalThis.Array.isArray(object?.referenceTaskIds) ? object.referenceTaskIds.map((e) => globalThis.String(e)) : globalThis.Array.isArray(object?.reference_task_ids) ? object.reference_task_ids.map((e) => globalThis.String(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.messageId !== "") {
+      obj.messageId = message.messageId;
+    }
+    if (message.contextId !== "") {
+      obj.contextId = message.contextId;
+    }
+    if (message.taskId !== "") {
+      obj.taskId = message.taskId;
+    }
+    if (message.role !== 0) {
+      obj.role = roleToJSON(message.role);
+    }
+    if (message.parts?.length) {
+      obj.parts = message.parts.map((e) => Part.toJSON(e));
+    }
+    if (message.metadata !== void 0) {
+      obj.metadata = message.metadata;
+    }
+    if (message.extensions?.length) {
+      obj.extensions = message.extensions;
+    }
+    if (message.referenceTaskIds?.length) {
+      obj.referenceTaskIds = message.referenceTaskIds;
+    }
+    return obj;
+  }
+};
+var Artifact = {
+  fromJSON(object) {
+    return {
+      artifactId: isSet(object.artifactId) ? globalThis.String(object.artifactId) : isSet(object.artifact_id) ? globalThis.String(object.artifact_id) : "",
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+      description: isSet(object.description) ? globalThis.String(object.description) : "",
+      parts: globalThis.Array.isArray(object?.parts) ? object.parts.map((e) => Part.fromJSON(e)) : [],
+      metadata: isObject(object.metadata) ? object.metadata : void 0,
+      extensions: globalThis.Array.isArray(object?.extensions) ? object.extensions.map((e) => globalThis.String(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.artifactId !== "") {
+      obj.artifactId = message.artifactId;
+    }
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    if (message.parts?.length) {
+      obj.parts = message.parts.map((e) => Part.toJSON(e));
+    }
+    if (message.metadata !== void 0) {
+      obj.metadata = message.metadata;
+    }
+    if (message.extensions?.length) {
+      obj.extensions = message.extensions;
+    }
+    return obj;
+  }
+};
+var TaskStatusUpdateEvent = {
+  fromJSON(object) {
+    return {
+      taskId: isSet(object.taskId) ? globalThis.String(object.taskId) : isSet(object.task_id) ? globalThis.String(object.task_id) : "",
+      contextId: isSet(object.contextId) ? globalThis.String(object.contextId) : isSet(object.context_id) ? globalThis.String(object.context_id) : "",
+      status: isSet(object.status) ? TaskStatus.fromJSON(object.status) : void 0,
+      metadata: isObject(object.metadata) ? object.metadata : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.taskId !== "") {
+      obj.taskId = message.taskId;
+    }
+    if (message.contextId !== "") {
+      obj.contextId = message.contextId;
+    }
+    if (message.status !== void 0) {
+      obj.status = TaskStatus.toJSON(message.status);
+    }
+    if (message.metadata !== void 0) {
+      obj.metadata = message.metadata;
+    }
+    return obj;
+  }
+};
+var TaskArtifactUpdateEvent = {
+  fromJSON(object) {
+    return {
+      taskId: isSet(object.taskId) ? globalThis.String(object.taskId) : isSet(object.task_id) ? globalThis.String(object.task_id) : "",
+      contextId: isSet(object.contextId) ? globalThis.String(object.contextId) : isSet(object.context_id) ? globalThis.String(object.context_id) : "",
+      artifact: isSet(object.artifact) ? Artifact.fromJSON(object.artifact) : void 0,
+      append: isSet(object.append) ? globalThis.Boolean(object.append) : false,
+      lastChunk: isSet(object.lastChunk) ? globalThis.Boolean(object.lastChunk) : isSet(object.last_chunk) ? globalThis.Boolean(object.last_chunk) : false,
+      metadata: isObject(object.metadata) ? object.metadata : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.taskId !== "") {
+      obj.taskId = message.taskId;
+    }
+    if (message.contextId !== "") {
+      obj.contextId = message.contextId;
+    }
+    if (message.artifact !== void 0) {
+      obj.artifact = Artifact.toJSON(message.artifact);
+    }
+    if (message.append !== false) {
+      obj.append = message.append;
+    }
+    if (message.lastChunk !== false) {
+      obj.lastChunk = message.lastChunk;
+    }
+    if (message.metadata !== void 0) {
+      obj.metadata = message.metadata;
+    }
+    return obj;
+  }
+};
+var AuthenticationInfo = {
+  fromJSON(object) {
+    return {
+      scheme: isSet(object.scheme) ? globalThis.String(object.scheme) : "",
+      credentials: isSet(object.credentials) ? globalThis.String(object.credentials) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.scheme !== "") {
+      obj.scheme = message.scheme;
+    }
+    if (message.credentials !== "") {
+      obj.credentials = message.credentials;
+    }
+    return obj;
+  }
+};
+var AgentInterface = {
+  fromJSON(object) {
+    return {
+      url: isSet(object.url) ? globalThis.String(object.url) : "",
+      protocolBinding: isSet(object.protocolBinding) ? globalThis.String(object.protocolBinding) : isSet(object.protocol_binding) ? globalThis.String(object.protocol_binding) : "",
+      tenant: isSet(object.tenant) ? globalThis.String(object.tenant) : "",
+      protocolVersion: isSet(object.protocolVersion) ? globalThis.String(object.protocolVersion) : isSet(object.protocol_version) ? globalThis.String(object.protocol_version) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.url !== "") {
+      obj.url = message.url;
+    }
+    if (message.protocolBinding !== "") {
+      obj.protocolBinding = message.protocolBinding;
+    }
+    if (message.tenant !== "") {
+      obj.tenant = message.tenant;
+    }
+    if (message.protocolVersion !== "") {
+      obj.protocolVersion = message.protocolVersion;
+    }
+    return obj;
+  }
+};
+var AgentCard = {
+  fromJSON(object) {
+    return {
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+      description: isSet(object.description) ? globalThis.String(object.description) : "",
+      supportedInterfaces: globalThis.Array.isArray(object?.supportedInterfaces) ? object.supportedInterfaces.map((e) => AgentInterface.fromJSON(e)) : globalThis.Array.isArray(object?.supported_interfaces) ? object.supported_interfaces.map((e) => AgentInterface.fromJSON(e)) : [],
+      provider: isSet(object.provider) ? AgentProvider.fromJSON(object.provider) : void 0,
+      version: isSet(object.version) ? globalThis.String(object.version) : "",
+      documentationUrl: isSet(object.documentationUrl) ? globalThis.String(object.documentationUrl) : isSet(object.documentation_url) ? globalThis.String(object.documentation_url) : void 0,
+      capabilities: isSet(object.capabilities) ? AgentCapabilities.fromJSON(object.capabilities) : void 0,
+      securitySchemes: isObject(object.securitySchemes) ? globalThis.Object.entries(object.securitySchemes).reduce(
+        (acc, [key, value]) => {
+          acc[key] = SecurityScheme.fromJSON(value);
+          return acc;
+        },
+        {}
+      ) : isObject(object.security_schemes) ? globalThis.Object.entries(object.security_schemes).reduce(
+        (acc, [key, value]) => {
+          acc[key] = SecurityScheme.fromJSON(value);
+          return acc;
+        },
+        {}
+      ) : {},
+      securityRequirements: globalThis.Array.isArray(object?.securityRequirements) ? object.securityRequirements.map((e) => SecurityRequirement.fromJSON(e)) : globalThis.Array.isArray(object?.security_requirements) ? object.security_requirements.map((e) => SecurityRequirement.fromJSON(e)) : [],
+      defaultInputModes: globalThis.Array.isArray(object?.defaultInputModes) ? object.defaultInputModes.map((e) => globalThis.String(e)) : globalThis.Array.isArray(object?.default_input_modes) ? object.default_input_modes.map((e) => globalThis.String(e)) : [],
+      defaultOutputModes: globalThis.Array.isArray(object?.defaultOutputModes) ? object.defaultOutputModes.map((e) => globalThis.String(e)) : globalThis.Array.isArray(object?.default_output_modes) ? object.default_output_modes.map((e) => globalThis.String(e)) : [],
+      skills: globalThis.Array.isArray(object?.skills) ? object.skills.map((e) => AgentSkill.fromJSON(e)) : [],
+      signatures: globalThis.Array.isArray(object?.signatures) ? object.signatures.map((e) => AgentCardSignature.fromJSON(e)) : [],
+      iconUrl: isSet(object.iconUrl) ? globalThis.String(object.iconUrl) : isSet(object.icon_url) ? globalThis.String(object.icon_url) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    if (message.supportedInterfaces?.length) {
+      obj.supportedInterfaces = message.supportedInterfaces.map((e) => AgentInterface.toJSON(e));
+    }
+    if (message.provider !== void 0) {
+      obj.provider = AgentProvider.toJSON(message.provider);
+    }
+    if (message.version !== "") {
+      obj.version = message.version;
+    }
+    if (message.documentationUrl !== void 0) {
+      obj.documentationUrl = message.documentationUrl;
+    }
+    if (message.capabilities !== void 0) {
+      obj.capabilities = AgentCapabilities.toJSON(message.capabilities);
+    }
+    if (message.securitySchemes) {
+      const entries = globalThis.Object.entries(message.securitySchemes);
+      if (entries.length > 0) {
+        const securitySchemes = {};
+        entries.forEach(([k, v]) => {
+          securitySchemes[k] = SecurityScheme.toJSON(v);
+        });
+        obj.securitySchemes = securitySchemes;
+      }
+    }
+    if (message.securityRequirements?.length) {
+      obj.securityRequirements = message.securityRequirements.map(
+        (e) => SecurityRequirement.toJSON(e)
+      );
+    }
+    if (message.defaultInputModes?.length) {
+      obj.defaultInputModes = message.defaultInputModes;
+    }
+    if (message.defaultOutputModes?.length) {
+      obj.defaultOutputModes = message.defaultOutputModes;
+    }
+    if (message.skills?.length) {
+      obj.skills = message.skills.map((e) => AgentSkill.toJSON(e));
+    }
+    if (message.signatures?.length) {
+      obj.signatures = message.signatures.map((e) => AgentCardSignature.toJSON(e));
+    }
+    if (message.iconUrl !== void 0) {
+      obj.iconUrl = message.iconUrl;
+    }
+    return obj;
+  }
+};
+var AgentProvider = {
+  fromJSON(object) {
+    return {
+      url: isSet(object.url) ? globalThis.String(object.url) : "",
+      organization: isSet(object.organization) ? globalThis.String(object.organization) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.url !== "") {
+      obj.url = message.url;
+    }
+    if (message.organization !== "") {
+      obj.organization = message.organization;
+    }
+    return obj;
+  }
+};
+var AgentCapabilities = {
+  fromJSON(object) {
+    return {
+      streaming: isSet(object.streaming) ? globalThis.Boolean(object.streaming) : void 0,
+      pushNotifications: isSet(object.pushNotifications) ? globalThis.Boolean(object.pushNotifications) : isSet(object.push_notifications) ? globalThis.Boolean(object.push_notifications) : void 0,
+      extensions: globalThis.Array.isArray(object?.extensions) ? object.extensions.map((e) => AgentExtension.fromJSON(e)) : [],
+      extendedAgentCard: isSet(object.extendedAgentCard) ? globalThis.Boolean(object.extendedAgentCard) : isSet(object.extended_agent_card) ? globalThis.Boolean(object.extended_agent_card) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.streaming !== void 0) {
+      obj.streaming = message.streaming;
+    }
+    if (message.pushNotifications !== void 0) {
+      obj.pushNotifications = message.pushNotifications;
+    }
+    if (message.extensions?.length) {
+      obj.extensions = message.extensions.map((e) => AgentExtension.toJSON(e));
+    }
+    if (message.extendedAgentCard !== void 0) {
+      obj.extendedAgentCard = message.extendedAgentCard;
+    }
+    return obj;
+  }
+};
+var AgentExtension = {
+  fromJSON(object) {
+    return {
+      uri: isSet(object.uri) ? globalThis.String(object.uri) : "",
+      description: isSet(object.description) ? globalThis.String(object.description) : "",
+      required: isSet(object.required) ? globalThis.Boolean(object.required) : false,
+      params: isObject(object.params) ? object.params : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.uri !== "") {
+      obj.uri = message.uri;
+    }
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    if (message.required !== false) {
+      obj.required = message.required;
+    }
+    if (message.params !== void 0) {
+      obj.params = message.params;
+    }
+    return obj;
+  }
+};
+var AgentSkill = {
+  fromJSON(object) {
+    return {
+      id: isSet(object.id) ? globalThis.String(object.id) : "",
+      name: isSet(object.name) ? globalThis.String(object.name) : "",
+      description: isSet(object.description) ? globalThis.String(object.description) : "",
+      tags: globalThis.Array.isArray(object?.tags) ? object.tags.map((e) => globalThis.String(e)) : [],
+      examples: globalThis.Array.isArray(object?.examples) ? object.examples.map((e) => globalThis.String(e)) : [],
+      inputModes: globalThis.Array.isArray(object?.inputModes) ? object.inputModes.map((e) => globalThis.String(e)) : globalThis.Array.isArray(object?.input_modes) ? object.input_modes.map((e) => globalThis.String(e)) : [],
+      outputModes: globalThis.Array.isArray(object?.outputModes) ? object.outputModes.map((e) => globalThis.String(e)) : globalThis.Array.isArray(object?.output_modes) ? object.output_modes.map((e) => globalThis.String(e)) : [],
+      securityRequirements: globalThis.Array.isArray(object?.securityRequirements) ? object.securityRequirements.map((e) => SecurityRequirement.fromJSON(e)) : globalThis.Array.isArray(object?.security_requirements) ? object.security_requirements.map((e) => SecurityRequirement.fromJSON(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.id !== "") {
+      obj.id = message.id;
+    }
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    if (message.tags?.length) {
+      obj.tags = message.tags;
+    }
+    if (message.examples?.length) {
+      obj.examples = message.examples;
+    }
+    if (message.inputModes?.length) {
+      obj.inputModes = message.inputModes;
+    }
+    if (message.outputModes?.length) {
+      obj.outputModes = message.outputModes;
+    }
+    if (message.securityRequirements?.length) {
+      obj.securityRequirements = message.securityRequirements.map(
+        (e) => SecurityRequirement.toJSON(e)
+      );
+    }
+    return obj;
+  }
+};
+var AgentCardSignature = {
+  fromJSON(object) {
+    return {
+      protected: isSet(object.protected) ? globalThis.String(object.protected) : "",
+      signature: isSet(object.signature) ? globalThis.String(object.signature) : "",
+      header: isObject(object.header) ? object.header : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.protected !== "") {
+      obj.protected = message.protected;
+    }
+    if (message.signature !== "") {
+      obj.signature = message.signature;
+    }
+    if (message.header !== void 0) {
+      obj.header = message.header;
+    }
+    return obj;
+  }
+};
+var TaskPushNotificationConfig = {
+  fromJSON(object) {
+    return {
+      tenant: isSet(object.tenant) ? globalThis.String(object.tenant) : "",
+      id: isSet(object.id) ? globalThis.String(object.id) : "",
+      taskId: isSet(object.taskId) ? globalThis.String(object.taskId) : isSet(object.task_id) ? globalThis.String(object.task_id) : "",
+      url: isSet(object.url) ? globalThis.String(object.url) : "",
+      token: isSet(object.token) ? globalThis.String(object.token) : "",
+      authentication: isSet(object.authentication) ? AuthenticationInfo.fromJSON(object.authentication) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.tenant !== "") {
+      obj.tenant = message.tenant;
+    }
+    if (message.id !== "") {
+      obj.id = message.id;
+    }
+    if (message.taskId !== "") {
+      obj.taskId = message.taskId;
+    }
+    if (message.url !== "") {
+      obj.url = message.url;
+    }
+    if (message.token !== "") {
+      obj.token = message.token;
+    }
+    if (message.authentication !== void 0) {
+      obj.authentication = AuthenticationInfo.toJSON(message.authentication);
+    }
+    return obj;
+  }
+};
+var StringList = {
+  fromJSON(object) {
+    return {
+      list: globalThis.Array.isArray(object?.list) ? object.list.map((e) => globalThis.String(e)) : []
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.list?.length) {
+      obj.list = message.list;
+    }
+    return obj;
+  }
+};
+var SecurityRequirement = {
+  fromJSON(object) {
+    return {
+      schemes: isObject(object.schemes) ? globalThis.Object.entries(object.schemes).reduce(
+        (acc, [key, value]) => {
+          acc[key] = StringList.fromJSON(value);
+          return acc;
+        },
+        {}
+      ) : {}
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.schemes) {
+      const entries = globalThis.Object.entries(message.schemes);
+      if (entries.length > 0) {
+        const schemes = {};
+        entries.forEach(([k, v]) => {
+          schemes[k] = StringList.toJSON(v);
+        });
+        obj.schemes = schemes;
+      }
+    }
+    return obj;
+  }
+};
+var SecurityScheme = {
+  fromJSON(object) {
+    return {
+      scheme: isSet(object.apiKeySecurityScheme) ? {
+        $case: "apiKeySecurityScheme",
+        value: APIKeySecurityScheme.fromJSON(object.apiKeySecurityScheme)
+      } : isSet(object.api_key_security_scheme) ? {
+        $case: "apiKeySecurityScheme",
+        value: APIKeySecurityScheme.fromJSON(object.api_key_security_scheme)
+      } : isSet(object.httpAuthSecurityScheme) ? {
+        $case: "httpAuthSecurityScheme",
+        value: HTTPAuthSecurityScheme.fromJSON(object.httpAuthSecurityScheme)
+      } : isSet(object.http_auth_security_scheme) ? {
+        $case: "httpAuthSecurityScheme",
+        value: HTTPAuthSecurityScheme.fromJSON(object.http_auth_security_scheme)
+      } : isSet(object.oauth2SecurityScheme) ? {
+        $case: "oauth2SecurityScheme",
+        value: OAuth2SecurityScheme.fromJSON(object.oauth2SecurityScheme)
+      } : isSet(object.oauth2_security_scheme) ? {
+        $case: "oauth2SecurityScheme",
+        value: OAuth2SecurityScheme.fromJSON(object.oauth2_security_scheme)
+      } : isSet(object.openIdConnectSecurityScheme) ? {
+        $case: "openIdConnectSecurityScheme",
+        value: OpenIdConnectSecurityScheme.fromJSON(
+          object.openIdConnectSecurityScheme
+        )
+      } : isSet(object.open_id_connect_security_scheme) ? {
+        $case: "openIdConnectSecurityScheme",
+        value: OpenIdConnectSecurityScheme.fromJSON(
+          object.open_id_connect_security_scheme
+        )
+      } : isSet(object.mtlsSecurityScheme) ? {
+        $case: "mtlsSecurityScheme",
+        value: MutualTlsSecurityScheme.fromJSON(object.mtlsSecurityScheme)
+      } : isSet(object.mtls_security_scheme) ? {
+        $case: "mtlsSecurityScheme",
+        value: MutualTlsSecurityScheme.fromJSON(object.mtls_security_scheme)
+      } : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.scheme?.$case === "apiKeySecurityScheme") {
+      obj.apiKeySecurityScheme = APIKeySecurityScheme.toJSON(message.scheme.value);
+    } else if (message.scheme?.$case === "httpAuthSecurityScheme") {
+      obj.httpAuthSecurityScheme = HTTPAuthSecurityScheme.toJSON(message.scheme.value);
+    } else if (message.scheme?.$case === "oauth2SecurityScheme") {
+      obj.oauth2SecurityScheme = OAuth2SecurityScheme.toJSON(message.scheme.value);
+    } else if (message.scheme?.$case === "openIdConnectSecurityScheme") {
+      obj.openIdConnectSecurityScheme = OpenIdConnectSecurityScheme.toJSON(message.scheme.value);
+    } else if (message.scheme?.$case === "mtlsSecurityScheme") {
+      obj.mtlsSecurityScheme = MutualTlsSecurityScheme.toJSON(message.scheme.value);
+    }
+    return obj;
+  }
+};
+var APIKeySecurityScheme = {
+  fromJSON(object) {
+    return {
+      description: isSet(object.description) ? globalThis.String(object.description) : "",
+      location: isSet(object.location) ? globalThis.String(object.location) : "",
+      name: isSet(object.name) ? globalThis.String(object.name) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    if (message.location !== "") {
+      obj.location = message.location;
+    }
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    return obj;
+  }
+};
+var HTTPAuthSecurityScheme = {
+  fromJSON(object) {
+    return {
+      description: isSet(object.description) ? globalThis.String(object.description) : "",
+      scheme: isSet(object.scheme) ? globalThis.String(object.scheme) : "",
+      bearerFormat: isSet(object.bearerFormat) ? globalThis.String(object.bearerFormat) : isSet(object.bearer_format) ? globalThis.String(object.bearer_format) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    if (message.scheme !== "") {
+      obj.scheme = message.scheme;
+    }
+    if (message.bearerFormat !== "") {
+      obj.bearerFormat = message.bearerFormat;
+    }
+    return obj;
+  }
+};
+var OAuth2SecurityScheme = {
+  fromJSON(object) {
+    return {
+      description: isSet(object.description) ? globalThis.String(object.description) : "",
+      flows: isSet(object.flows) ? OAuthFlows.fromJSON(object.flows) : void 0,
+      oauth2MetadataUrl: isSet(object.oauth2MetadataUrl) ? globalThis.String(object.oauth2MetadataUrl) : isSet(object.oauth2_metadata_url) ? globalThis.String(object.oauth2_metadata_url) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    if (message.flows !== void 0) {
+      obj.flows = OAuthFlows.toJSON(message.flows);
+    }
+    if (message.oauth2MetadataUrl !== "") {
+      obj.oauth2MetadataUrl = message.oauth2MetadataUrl;
+    }
+    return obj;
+  }
+};
+var OpenIdConnectSecurityScheme = {
+  fromJSON(object) {
+    return {
+      description: isSet(object.description) ? globalThis.String(object.description) : "",
+      openIdConnectUrl: isSet(object.openIdConnectUrl) ? globalThis.String(object.openIdConnectUrl) : isSet(object.open_id_connect_url) ? globalThis.String(object.open_id_connect_url) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    if (message.openIdConnectUrl !== "") {
+      obj.openIdConnectUrl = message.openIdConnectUrl;
+    }
+    return obj;
+  }
+};
+var MutualTlsSecurityScheme = {
+  fromJSON(object) {
+    return { description: isSet(object.description) ? globalThis.String(object.description) : "" };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.description !== "") {
+      obj.description = message.description;
+    }
+    return obj;
+  }
+};
+var OAuthFlows = {
+  fromJSON(object) {
+    return {
+      flow: isSet(object.authorizationCode) ? {
+        $case: "authorizationCode",
+        value: AuthorizationCodeOAuthFlow.fromJSON(object.authorizationCode)
+      } : isSet(object.authorization_code) ? {
+        $case: "authorizationCode",
+        value: AuthorizationCodeOAuthFlow.fromJSON(object.authorization_code)
+      } : isSet(object.clientCredentials) ? {
+        $case: "clientCredentials",
+        value: ClientCredentialsOAuthFlow.fromJSON(object.clientCredentials)
+      } : isSet(object.client_credentials) ? {
+        $case: "clientCredentials",
+        value: ClientCredentialsOAuthFlow.fromJSON(object.client_credentials)
+      } : isSet(object.implicit) ? { $case: "implicit", value: ImplicitOAuthFlow.fromJSON(object.implicit) } : isSet(object.password) ? { $case: "password", value: PasswordOAuthFlow.fromJSON(object.password) } : isSet(object.deviceCode) ? {
+        $case: "deviceCode",
+        value: DeviceCodeOAuthFlow.fromJSON(object.deviceCode)
+      } : isSet(object.device_code) ? {
+        $case: "deviceCode",
+        value: DeviceCodeOAuthFlow.fromJSON(object.device_code)
+      } : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.flow?.$case === "authorizationCode") {
+      obj.authorizationCode = AuthorizationCodeOAuthFlow.toJSON(message.flow.value);
+    } else if (message.flow?.$case === "clientCredentials") {
+      obj.clientCredentials = ClientCredentialsOAuthFlow.toJSON(message.flow.value);
+    } else if (message.flow?.$case === "implicit") {
+      obj.implicit = ImplicitOAuthFlow.toJSON(message.flow.value);
+    } else if (message.flow?.$case === "password") {
+      obj.password = PasswordOAuthFlow.toJSON(message.flow.value);
+    } else if (message.flow?.$case === "deviceCode") {
+      obj.deviceCode = DeviceCodeOAuthFlow.toJSON(message.flow.value);
+    }
+    return obj;
+  }
+};
+var AuthorizationCodeOAuthFlow = {
+  fromJSON(object) {
+    return {
+      authorizationUrl: isSet(object.authorizationUrl) ? globalThis.String(object.authorizationUrl) : isSet(object.authorization_url) ? globalThis.String(object.authorization_url) : "",
+      tokenUrl: isSet(object.tokenUrl) ? globalThis.String(object.tokenUrl) : isSet(object.token_url) ? globalThis.String(object.token_url) : "",
+      refreshUrl: isSet(object.refreshUrl) ? globalThis.String(object.refreshUrl) : isSet(object.refresh_url) ? globalThis.String(object.refresh_url) : "",
+      scopes: isObject(object.scopes) ? globalThis.Object.entries(object.scopes).reduce(
+        (acc, [key, value]) => {
+          acc[key] = globalThis.String(value);
+          return acc;
+        },
+        {}
+      ) : {},
+      pkceRequired: isSet(object.pkceRequired) ? globalThis.Boolean(object.pkceRequired) : isSet(object.pkce_required) ? globalThis.Boolean(object.pkce_required) : false
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.authorizationUrl !== "") {
+      obj.authorizationUrl = message.authorizationUrl;
+    }
+    if (message.tokenUrl !== "") {
+      obj.tokenUrl = message.tokenUrl;
+    }
+    if (message.refreshUrl !== "") {
+      obj.refreshUrl = message.refreshUrl;
+    }
+    if (message.scopes) {
+      const entries = globalThis.Object.entries(message.scopes);
+      if (entries.length > 0) {
+        const scopes = {};
+        entries.forEach(([k, v]) => {
+          scopes[k] = v;
+        });
+        obj.scopes = scopes;
+      }
+    }
+    if (message.pkceRequired !== false) {
+      obj.pkceRequired = message.pkceRequired;
+    }
+    return obj;
+  }
+};
+var ClientCredentialsOAuthFlow = {
+  fromJSON(object) {
+    return {
+      tokenUrl: isSet(object.tokenUrl) ? globalThis.String(object.tokenUrl) : isSet(object.token_url) ? globalThis.String(object.token_url) : "",
+      refreshUrl: isSet(object.refreshUrl) ? globalThis.String(object.refreshUrl) : isSet(object.refresh_url) ? globalThis.String(object.refresh_url) : "",
+      scopes: isObject(object.scopes) ? globalThis.Object.entries(object.scopes).reduce(
+        (acc, [key, value]) => {
+          acc[key] = globalThis.String(value);
+          return acc;
+        },
+        {}
+      ) : {}
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.tokenUrl !== "") {
+      obj.tokenUrl = message.tokenUrl;
+    }
+    if (message.refreshUrl !== "") {
+      obj.refreshUrl = message.refreshUrl;
+    }
+    if (message.scopes) {
+      const entries = globalThis.Object.entries(message.scopes);
+      if (entries.length > 0) {
+        const scopes = {};
+        entries.forEach(([k, v]) => {
+          scopes[k] = v;
+        });
+        obj.scopes = scopes;
+      }
+    }
+    return obj;
+  }
+};
+var ImplicitOAuthFlow = {
+  fromJSON(object) {
+    return {
+      authorizationUrl: isSet(object.authorizationUrl) ? globalThis.String(object.authorizationUrl) : isSet(object.authorization_url) ? globalThis.String(object.authorization_url) : "",
+      refreshUrl: isSet(object.refreshUrl) ? globalThis.String(object.refreshUrl) : isSet(object.refresh_url) ? globalThis.String(object.refresh_url) : "",
+      scopes: isObject(object.scopes) ? globalThis.Object.entries(object.scopes).reduce(
+        (acc, [key, value]) => {
+          acc[key] = globalThis.String(value);
+          return acc;
+        },
+        {}
+      ) : {}
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.authorizationUrl !== "") {
+      obj.authorizationUrl = message.authorizationUrl;
+    }
+    if (message.refreshUrl !== "") {
+      obj.refreshUrl = message.refreshUrl;
+    }
+    if (message.scopes) {
+      const entries = globalThis.Object.entries(message.scopes);
+      if (entries.length > 0) {
+        const scopes = {};
+        entries.forEach(([k, v]) => {
+          scopes[k] = v;
+        });
+        obj.scopes = scopes;
+      }
+    }
+    return obj;
+  }
+};
+var PasswordOAuthFlow = {
+  fromJSON(object) {
+    return {
+      tokenUrl: isSet(object.tokenUrl) ? globalThis.String(object.tokenUrl) : isSet(object.token_url) ? globalThis.String(object.token_url) : "",
+      refreshUrl: isSet(object.refreshUrl) ? globalThis.String(object.refreshUrl) : isSet(object.refresh_url) ? globalThis.String(object.refresh_url) : "",
+      scopes: isObject(object.scopes) ? globalThis.Object.entries(object.scopes).reduce(
+        (acc, [key, value]) => {
+          acc[key] = globalThis.String(value);
+          return acc;
+        },
+        {}
+      ) : {}
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.tokenUrl !== "") {
+      obj.tokenUrl = message.tokenUrl;
+    }
+    if (message.refreshUrl !== "") {
+      obj.refreshUrl = message.refreshUrl;
+    }
+    if (message.scopes) {
+      const entries = globalThis.Object.entries(message.scopes);
+      if (entries.length > 0) {
+        const scopes = {};
+        entries.forEach(([k, v]) => {
+          scopes[k] = v;
+        });
+        obj.scopes = scopes;
+      }
+    }
+    return obj;
+  }
+};
+var DeviceCodeOAuthFlow = {
+  fromJSON(object) {
+    return {
+      deviceAuthorizationUrl: isSet(object.deviceAuthorizationUrl) ? globalThis.String(object.deviceAuthorizationUrl) : isSet(object.device_authorization_url) ? globalThis.String(object.device_authorization_url) : "",
+      tokenUrl: isSet(object.tokenUrl) ? globalThis.String(object.tokenUrl) : isSet(object.token_url) ? globalThis.String(object.token_url) : "",
+      refreshUrl: isSet(object.refreshUrl) ? globalThis.String(object.refreshUrl) : isSet(object.refresh_url) ? globalThis.String(object.refresh_url) : "",
+      scopes: isObject(object.scopes) ? globalThis.Object.entries(object.scopes).reduce(
+        (acc, [key, value]) => {
+          acc[key] = globalThis.String(value);
+          return acc;
+        },
+        {}
+      ) : {}
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.deviceAuthorizationUrl !== "") {
+      obj.deviceAuthorizationUrl = message.deviceAuthorizationUrl;
+    }
+    if (message.tokenUrl !== "") {
+      obj.tokenUrl = message.tokenUrl;
+    }
+    if (message.refreshUrl !== "") {
+      obj.refreshUrl = message.refreshUrl;
+    }
+    if (message.scopes) {
+      const entries = globalThis.Object.entries(message.scopes);
+      if (entries.length > 0) {
+        const scopes = {};
+        entries.forEach(([k, v]) => {
+          scopes[k] = v;
+        });
+        obj.scopes = scopes;
+      }
+    }
+    return obj;
+  }
+};
+var SendMessageRequest = {
+  fromJSON(object) {
+    return {
+      tenant: isSet(object.tenant) ? globalThis.String(object.tenant) : "",
+      message: isSet(object.message) ? Message.fromJSON(object.message) : void 0,
+      configuration: isSet(object.configuration) ? SendMessageConfiguration.fromJSON(object.configuration) : void 0,
+      metadata: isObject(object.metadata) ? object.metadata : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.tenant !== "") {
+      obj.tenant = message.tenant;
+    }
+    if (message.message !== void 0) {
+      obj.message = Message.toJSON(message.message);
+    }
+    if (message.configuration !== void 0) {
+      obj.configuration = SendMessageConfiguration.toJSON(message.configuration);
+    }
+    if (message.metadata !== void 0) {
+      obj.metadata = message.metadata;
+    }
+    return obj;
+  }
+};
+var GetTaskRequest = {
+  fromJSON(object) {
+    return {
+      tenant: isSet(object.tenant) ? globalThis.String(object.tenant) : "",
+      id: isSet(object.id) ? globalThis.String(object.id) : "",
+      historyLength: isSet(object.historyLength) ? globalThis.Number(object.historyLength) : isSet(object.history_length) ? globalThis.Number(object.history_length) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.tenant !== "") {
+      obj.tenant = message.tenant;
+    }
+    if (message.id !== "") {
+      obj.id = message.id;
+    }
+    if (message.historyLength !== void 0) {
+      obj.historyLength = Math.round(message.historyLength);
+    }
+    return obj;
+  }
+};
+var ListTasksRequest = {
+  fromJSON(object) {
+    return {
+      tenant: isSet(object.tenant) ? globalThis.String(object.tenant) : "",
+      contextId: isSet(object.contextId) ? globalThis.String(object.contextId) : isSet(object.context_id) ? globalThis.String(object.context_id) : "",
+      status: isSet(object.status) ? taskStateFromJSON(object.status) : 0,
+      pageSize: isSet(object.pageSize) ? globalThis.Number(object.pageSize) : isSet(object.page_size) ? globalThis.Number(object.page_size) : void 0,
+      pageToken: isSet(object.pageToken) ? globalThis.String(object.pageToken) : isSet(object.page_token) ? globalThis.String(object.page_token) : "",
+      historyLength: isSet(object.historyLength) ? globalThis.Number(object.historyLength) : isSet(object.history_length) ? globalThis.Number(object.history_length) : void 0,
+      statusTimestampAfter: isSet(object.statusTimestampAfter) ? globalThis.String(object.statusTimestampAfter) : isSet(object.status_timestamp_after) ? globalThis.String(object.status_timestamp_after) : void 0,
+      includeArtifacts: isSet(object.includeArtifacts) ? globalThis.Boolean(object.includeArtifacts) : isSet(object.include_artifacts) ? globalThis.Boolean(object.include_artifacts) : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.tenant !== "") {
+      obj.tenant = message.tenant;
+    }
+    if (message.contextId !== "") {
+      obj.contextId = message.contextId;
+    }
+    if (message.status !== 0) {
+      obj.status = taskStateToJSON(message.status);
+    }
+    if (message.pageSize !== void 0) {
+      obj.pageSize = Math.round(message.pageSize);
+    }
+    if (message.pageToken !== "") {
+      obj.pageToken = message.pageToken;
+    }
+    if (message.historyLength !== void 0) {
+      obj.historyLength = Math.round(message.historyLength);
+    }
+    if (message.statusTimestampAfter !== void 0) {
+      obj.statusTimestampAfter = message.statusTimestampAfter;
+    }
+    if (message.includeArtifacts !== void 0) {
+      obj.includeArtifacts = message.includeArtifacts;
+    }
+    return obj;
+  }
+};
+var ListTasksResponse = {
+  fromJSON(object) {
+    return {
+      tasks: globalThis.Array.isArray(object?.tasks) ? object.tasks.map((e) => Task.fromJSON(e)) : [],
+      nextPageToken: isSet(object.nextPageToken) ? globalThis.String(object.nextPageToken) : isSet(object.next_page_token) ? globalThis.String(object.next_page_token) : "",
+      pageSize: isSet(object.pageSize) ? globalThis.Number(object.pageSize) : isSet(object.page_size) ? globalThis.Number(object.page_size) : 0,
+      totalSize: isSet(object.totalSize) ? globalThis.Number(object.totalSize) : isSet(object.total_size) ? globalThis.Number(object.total_size) : 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.tasks?.length) {
+      obj.tasks = message.tasks.map((e) => Task.toJSON(e));
+    }
+    if (message.nextPageToken !== "") {
+      obj.nextPageToken = message.nextPageToken;
+    }
+    if (message.pageSize !== 0) {
+      obj.pageSize = Math.round(message.pageSize);
+    }
+    if (message.totalSize !== 0) {
+      obj.totalSize = Math.round(message.totalSize);
+    }
+    return obj;
+  }
+};
+var CancelTaskRequest = {
+  fromJSON(object) {
+    return {
+      tenant: isSet(object.tenant) ? globalThis.String(object.tenant) : "",
+      id: isSet(object.id) ? globalThis.String(object.id) : "",
+      metadata: isObject(object.metadata) ? object.metadata : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.tenant !== "") {
+      obj.tenant = message.tenant;
+    }
+    if (message.id !== "") {
+      obj.id = message.id;
+    }
+    if (message.metadata !== void 0) {
+      obj.metadata = message.metadata;
+    }
+    return obj;
+  }
+};
+var GetTaskPushNotificationConfigRequest = {
+  fromJSON(object) {
+    return {
+      tenant: isSet(object.tenant) ? globalThis.String(object.tenant) : "",
+      taskId: isSet(object.taskId) ? globalThis.String(object.taskId) : isSet(object.task_id) ? globalThis.String(object.task_id) : "",
+      id: isSet(object.id) ? globalThis.String(object.id) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.tenant !== "") {
+      obj.tenant = message.tenant;
+    }
+    if (message.taskId !== "") {
+      obj.taskId = message.taskId;
+    }
+    if (message.id !== "") {
+      obj.id = message.id;
+    }
+    return obj;
+  }
+};
+var DeleteTaskPushNotificationConfigRequest = {
+  fromJSON(object) {
+    return {
+      tenant: isSet(object.tenant) ? globalThis.String(object.tenant) : "",
+      taskId: isSet(object.taskId) ? globalThis.String(object.taskId) : isSet(object.task_id) ? globalThis.String(object.task_id) : "",
+      id: isSet(object.id) ? globalThis.String(object.id) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.tenant !== "") {
+      obj.tenant = message.tenant;
+    }
+    if (message.taskId !== "") {
+      obj.taskId = message.taskId;
+    }
+    if (message.id !== "") {
+      obj.id = message.id;
+    }
+    return obj;
+  }
+};
+var SubscribeToTaskRequest = {
+  fromJSON(object) {
+    return {
+      tenant: isSet(object.tenant) ? globalThis.String(object.tenant) : "",
+      id: isSet(object.id) ? globalThis.String(object.id) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.tenant !== "") {
+      obj.tenant = message.tenant;
+    }
+    if (message.id !== "") {
+      obj.id = message.id;
+    }
+    return obj;
+  }
+};
+var ListTaskPushNotificationConfigsRequest = {
+  fromJSON(object) {
+    return {
+      tenant: isSet(object.tenant) ? globalThis.String(object.tenant) : "",
+      taskId: isSet(object.taskId) ? globalThis.String(object.taskId) : isSet(object.task_id) ? globalThis.String(object.task_id) : "",
+      pageSize: isSet(object.pageSize) ? globalThis.Number(object.pageSize) : isSet(object.page_size) ? globalThis.Number(object.page_size) : 0,
+      pageToken: isSet(object.pageToken) ? globalThis.String(object.pageToken) : isSet(object.page_token) ? globalThis.String(object.page_token) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.tenant !== "") {
+      obj.tenant = message.tenant;
+    }
+    if (message.taskId !== "") {
+      obj.taskId = message.taskId;
+    }
+    if (message.pageSize !== 0) {
+      obj.pageSize = Math.round(message.pageSize);
+    }
+    if (message.pageToken !== "") {
+      obj.pageToken = message.pageToken;
+    }
+    return obj;
+  }
+};
+var GetExtendedAgentCardRequest = {
+  fromJSON(object) {
+    return { tenant: isSet(object.tenant) ? globalThis.String(object.tenant) : "" };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.tenant !== "") {
+      obj.tenant = message.tenant;
+    }
+    return obj;
+  }
+};
+var StreamResponse = {
+  fromJSON(object) {
+    return {
+      payload: isSet(object.task) ? { $case: "task", value: Task.fromJSON(object.task) } : isSet(object.message) ? { $case: "message", value: Message.fromJSON(object.message) } : isSet(object.statusUpdate) ? { $case: "statusUpdate", value: TaskStatusUpdateEvent.fromJSON(object.statusUpdate) } : isSet(object.status_update) ? {
+        $case: "statusUpdate",
+        value: TaskStatusUpdateEvent.fromJSON(object.status_update)
+      } : isSet(object.artifactUpdate) ? {
+        $case: "artifactUpdate",
+        value: TaskArtifactUpdateEvent.fromJSON(object.artifactUpdate)
+      } : isSet(object.artifact_update) ? {
+        $case: "artifactUpdate",
+        value: TaskArtifactUpdateEvent.fromJSON(object.artifact_update)
+      } : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.payload?.$case === "task") {
+      obj.task = Task.toJSON(message.payload.value);
+    } else if (message.payload?.$case === "message") {
+      obj.message = Message.toJSON(message.payload.value);
+    } else if (message.payload?.$case === "statusUpdate") {
+      obj.statusUpdate = TaskStatusUpdateEvent.toJSON(message.payload.value);
+    } else if (message.payload?.$case === "artifactUpdate") {
+      obj.artifactUpdate = TaskArtifactUpdateEvent.toJSON(message.payload.value);
+    }
+    return obj;
+  }
+};
+var ListTaskPushNotificationConfigsResponse = {
+  fromJSON(object) {
+    return {
+      configs: globalThis.Array.isArray(object?.configs) ? object.configs.map((e) => TaskPushNotificationConfig.fromJSON(e)) : [],
+      nextPageToken: isSet(object.nextPageToken) ? globalThis.String(object.nextPageToken) : isSet(object.next_page_token) ? globalThis.String(object.next_page_token) : ""
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.configs?.length) {
+      obj.configs = message.configs.map((e) => TaskPushNotificationConfig.toJSON(e));
+    }
+    if (message.nextPageToken !== "") {
+      obj.nextPageToken = message.nextPageToken;
+    }
+    return obj;
+  }
+};
+function bytesFromBase64(b64) {
+  return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+}
+function base64FromBytes(arr) {
+  return globalThis.Buffer.from(arr).toString("base64");
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isSet(value) {
+  return value !== null && value !== void 0;
+}
+
+// src/constants.ts
+var A2A_PROTOCOL_VERSION = "1.0";
+var A2A_LEGACY_PROTOCOL_VERSION = "0.3";
+var A2A_CONTENT_TYPE = "application/a2a+json";
+var DEFAULT_PAGE_SIZE = 50;
+
+// src/signature.ts
+import * as jose from "jose";
+
+// src/sse_utils.ts
+var DEFAULT_MAX_SSE_EVENT_SIZE_BYTES = 4 * 1024 * 1024;
+
+// src/server/utils.ts
+var TERMINAL_STATE_LIST = [
+  3 /* TASK_STATE_COMPLETED */,
+  4 /* TASK_STATE_FAILED */,
+  5 /* TASK_STATE_CANCELED */,
+  7 /* TASK_STATE_REJECTED */
+];
+var VALID_TASK_STATE_LIST = [
+  0 /* TASK_STATE_UNSPECIFIED */,
+  1 /* TASK_STATE_SUBMITTED */,
+  2 /* TASK_STATE_WORKING */,
+  3 /* TASK_STATE_COMPLETED */,
+  4 /* TASK_STATE_FAILED */,
+  5 /* TASK_STATE_CANCELED */,
+  6 /* TASK_STATE_INPUT_REQUIRED */,
+  7 /* TASK_STATE_REJECTED */,
+  8 /* TASK_STATE_AUTH_REQUIRED */
+];
+var INPUT_REQUIRED_STATE_LIST = [6 /* TASK_STATE_INPUT_REQUIRED */];
+var AUTH_REQUIRED_STATE_LIST = [8 /* TASK_STATE_AUTH_REQUIRED */];
+var INTERRUPTED_STATE_LIST = [
+  ...INPUT_REQUIRED_STATE_LIST,
+  ...AUTH_REQUIRED_STATE_LIST
+];
+function isTask(result) {
+  return "status" in result;
+}
+var ScopedStore = class {
+  _store = /* @__PURE__ */ new Map();
+  _ownerResolver;
+  constructor(ownerResolver) {
+    this._ownerResolver = ownerResolver;
+  }
+  _tenantKey(context) {
+    return context.tenant ?? "";
+  }
+  _ownerKey(context) {
+    return this._ownerResolver(context);
+  }
+  /** Returns the owner-scoped bucket, or `undefined` if absent. */
+  getBucket(context) {
+    return this._store.get(this._tenantKey(context))?.get(this._ownerKey(context));
+  }
+  /** Returns the owner-scoped bucket, creating intermediate maps as needed. */
+  getOrCreateBucket(context) {
+    const tenantKey = this._tenantKey(context);
+    let tenantBucket = this._store.get(tenantKey);
+    if (!tenantBucket) {
+      tenantBucket = /* @__PURE__ */ new Map();
+      this._store.set(tenantKey, tenantBucket);
+    }
+    const ownerKey = this._ownerKey(context);
+    let ownerBucket = tenantBucket.get(ownerKey);
+    if (!ownerBucket) {
+      ownerBucket = /* @__PURE__ */ new Map();
+      tenantBucket.set(ownerKey, ownerBucket);
+    }
+    return ownerBucket;
+  }
+};
+
+// src/server/events/execution_event_bus_manager.ts
+var UNSCOPED_CONTEXT = new ServerCallContext();
+var DefaultExecutionEventBusManager = class {
+  _scopedBuses;
+  constructor(ownerResolver = resolveUserScope) {
+    this._scopedBuses = new ScopedStore(ownerResolver);
+  }
+  createOrGetByTaskId(taskId, context) {
+    const bucket = this._scopedBuses.getOrCreateBucket(context ?? UNSCOPED_CONTEXT);
+    let bus = bucket.get(taskId);
+    if (!bus) {
+      bus = new DefaultExecutionEventBus();
+      bucket.set(taskId, bus);
+    }
+    return bus;
+  }
+  getByTaskId(taskId, context) {
+    return this._scopedBuses.getBucket(context ?? UNSCOPED_CONTEXT)?.get(taskId);
+  }
+  /** Removes the bus for the task. Call when the execution flow ends. */
+  cleanupByTaskId(taskId, context) {
+    const bucket = this._scopedBuses.getBucket(context ?? UNSCOPED_CONTEXT);
+    bucket?.get(taskId)?.removeAllListeners();
+    bucket?.delete(taskId);
+  }
+};
+
+// src/server/events/execution_event_queue.ts
+var ExecutionEventQueue = class {
+  eventBus;
+  eventQueue = [];
+  resolvePromise;
+  stopped = false;
+  constructor(eventBus) {
+    this.eventBus = eventBus;
+    this.eventBus.on("event", this.handleEvent);
+    this.eventBus.on("finished", this.handleFinished);
+  }
+  handleEvent = (event) => {
+    if (this.stopped) return;
+    this.eventQueue.push(event);
+    if (this.resolvePromise) {
+      this.resolvePromise();
+      this.resolvePromise = void 0;
+    }
+  };
+  handleFinished = () => {
+    this.stop();
+  };
+  /**
+   * Async generator yielding events from the bus. Terminates on Message,
+   * terminal Task status, or INPUT_REQUIRED. AUTH_REQUIRED is deliberately
+   * NOT in the stop set: the executor resumes publishing on the same bus
+   * after the out-of-band credential injection, so the queue must stay
+   * drainable. Blocking callers return a snapshot at AUTH_REQUIRED via a
+   * separate code path and a background consumer keeps draining until a
+   * terminal state is reached.
+   */
+  async *events() {
+    while (!this.stopped || this.eventQueue.length > 0) {
+      if (this.eventQueue.length > 0) {
+        const event = this.eventQueue.shift();
+        yield event;
+        if (event.kind === "message" || event.kind === "statusUpdate" && event.data.status && (TERMINAL_STATE_LIST.includes(event.data.status.state) || INPUT_REQUIRED_STATE_LIST.includes(event.data.status.state))) {
+          this.handleFinished();
+          break;
+        }
+      } else if (!this.stopped) {
+        await new Promise((resolve) => {
+          this.resolvePromise = resolve;
+        });
+      }
+    }
+  }
+  stop() {
+    this.stopped = true;
+    if (this.resolvePromise) {
+      this.resolvePromise();
+      this.resolvePromise = void 0;
+    }
+    this.eventBus.off("event", this.handleEvent);
+    this.eventBus.off("finished", this.handleFinished);
+  }
+};
+
+// 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
+});
+function extractErrorMessage(err) {
+  if (err instanceof Error) return err.message;
+  if (err === null || err === void 0) return String(err);
+  if (typeof err === "string") return err;
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+
+// src/errors/rest.ts
+var HTTP_STATUS = {
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  NOT_FOUND: 404,
+  CONFLICT: 409,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501
+};
+var REST_STATUS_NAME = {
+  OK: "OK",
+  CANCELLED: "CANCELLED",
+  UNKNOWN: "UNKNOWN",
+  INVALID_ARGUMENT: "INVALID_ARGUMENT",
+  DEADLINE_EXCEEDED: "DEADLINE_EXCEEDED",
+  NOT_FOUND: "NOT_FOUND",
+  ALREADY_EXISTS: "ALREADY_EXISTS",
+  PERMISSION_DENIED: "PERMISSION_DENIED",
+  RESOURCE_EXHAUSTED: "RESOURCE_EXHAUSTED",
+  FAILED_PRECONDITION: "FAILED_PRECONDITION",
+  ABORTED: "ABORTED",
+  OUT_OF_RANGE: "OUT_OF_RANGE",
+  UNIMPLEMENTED: "UNIMPLEMENTED",
+  INTERNAL: "INTERNAL",
+  UNAVAILABLE: "UNAVAILABLE",
+  DATA_LOSS: "DATA_LOSS",
+  UNAUTHENTICATED: "UNAUTHENTICATED"
+};
+var REST_ERROR_HTTP_STATUS = Object.freeze({
+  TaskNotFoundError: HTTP_STATUS.NOT_FOUND,
+  TaskNotCancelableError: HTTP_STATUS.BAD_REQUEST,
+  PushNotificationNotSupportedError: HTTP_STATUS.BAD_REQUEST,
+  UnsupportedOperationError: HTTP_STATUS.BAD_REQUEST,
+  ContentTypeNotSupportedError: HTTP_STATUS.BAD_REQUEST,
+  InvalidAgentResponseError: HTTP_STATUS.INTERNAL_SERVER_ERROR,
+  ExtendedAgentCardNotConfiguredError: HTTP_STATUS.BAD_REQUEST,
+  ExtensionSupportRequiredError: HTTP_STATUS.BAD_REQUEST,
+  VersionNotSupportedError: HTTP_STATUS.BAD_REQUEST,
+  RequestMalformedError: HTTP_STATUS.BAD_REQUEST
+});
+var REST_ERROR_STATUS_NAME = Object.freeze({
+  TaskNotFoundError: REST_STATUS_NAME.NOT_FOUND,
+  TaskNotCancelableError: REST_STATUS_NAME.FAILED_PRECONDITION,
+  PushNotificationNotSupportedError: REST_STATUS_NAME.FAILED_PRECONDITION,
+  UnsupportedOperationError: REST_STATUS_NAME.FAILED_PRECONDITION,
+  ContentTypeNotSupportedError: REST_STATUS_NAME.INVALID_ARGUMENT,
+  InvalidAgentResponseError: REST_STATUS_NAME.INTERNAL,
+  ExtendedAgentCardNotConfiguredError: REST_STATUS_NAME.FAILED_PRECONDITION,
+  ExtensionSupportRequiredError: REST_STATUS_NAME.FAILED_PRECONDITION,
+  VersionNotSupportedError: REST_STATUS_NAME.FAILED_PRECONDITION,
+  RequestMalformedError: REST_STATUS_NAME.INVALID_ARGUMENT
+});
+function makeRest(name) {
+  const Base = A2A_ERROR_CLASSES[name];
+  const defaultStatus = REST_ERROR_HTTP_STATUS[name] ?? HTTP_STATUS.INTERNAL_SERVER_ERROR;
+  const cls = {
+    [`Rest${name}`]: class extends Base {
+      transport = "rest";
+      statusCode;
+      headers;
+      constructor(options) {
+        super(options);
+        this.name = name;
+        this.statusCode = options?.statusCode ?? defaultStatus;
+        if (options?.headers) this.headers = options.headers;
+      }
+    }
+  }[`Rest${name}`];
+  return cls;
+}
+var RestTaskNotFoundError = makeRest("TaskNotFoundError");
+var RestTaskNotCancelableError = makeRest("TaskNotCancelableError");
+var RestPushNotificationNotSupportedError = makeRest("PushNotificationNotSupportedError");
+var RestUnsupportedOperationError = makeRest("UnsupportedOperationError");
+var RestContentTypeNotSupportedError = makeRest("ContentTypeNotSupportedError");
+var RestInvalidAgentResponseError = makeRest("InvalidAgentResponseError");
+var RestExtendedAgentCardNotConfiguredError = makeRest(
+  "ExtendedAgentCardNotConfiguredError"
+);
+var RestExtensionSupportRequiredError = makeRest("ExtensionSupportRequiredError");
+var RestVersionNotSupportedError = makeRest("VersionNotSupportedError");
+var RestRequestMalformedError = makeRest("RequestMalformedError");
+var REST_ERROR_CLASSES = Object.freeze({
+  TaskNotFoundError: RestTaskNotFoundError,
+  TaskNotCancelableError: RestTaskNotCancelableError,
+  PushNotificationNotSupportedError: RestPushNotificationNotSupportedError,
+  UnsupportedOperationError: RestUnsupportedOperationError,
+  ContentTypeNotSupportedError: RestContentTypeNotSupportedError,
+  InvalidAgentResponseError: RestInvalidAgentResponseError,
+  ExtendedAgentCardNotConfiguredError: RestExtendedAgentCardNotConfiguredError,
+  ExtensionSupportRequiredError: RestExtensionSupportRequiredError,
+  VersionNotSupportedError: RestVersionNotSupportedError,
+  RequestMalformedError: RestRequestMalformedError
+});
+
+// src/errors/json_rpc.ts
+var A2A_ERROR_CODE = {
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  TASK_NOT_FOUND: -32001,
+  TASK_NOT_CANCELABLE: -32002,
+  PUSH_NOTIFICATION_NOT_SUPPORTED: -32003,
+  UNSUPPORTED_OPERATION: -32004,
+  CONTENT_TYPE_NOT_SUPPORTED: -32005,
+  INVALID_AGENT_RESPONSE: -32006,
+  EXTENDED_CARD_NOT_CONFIGURED: -32007,
+  EXTENSION_SUPPORT_REQUIRED: -32008,
+  VERSION_NOT_SUPPORTED: -32009
+};
+var JSON_RPC_ERROR_CODE = Object.freeze({
+  TaskNotFoundError: A2A_ERROR_CODE.TASK_NOT_FOUND,
+  TaskNotCancelableError: A2A_ERROR_CODE.TASK_NOT_CANCELABLE,
+  PushNotificationNotSupportedError: A2A_ERROR_CODE.PUSH_NOTIFICATION_NOT_SUPPORTED,
+  UnsupportedOperationError: A2A_ERROR_CODE.UNSUPPORTED_OPERATION,
+  ContentTypeNotSupportedError: A2A_ERROR_CODE.CONTENT_TYPE_NOT_SUPPORTED,
+  InvalidAgentResponseError: A2A_ERROR_CODE.INVALID_AGENT_RESPONSE,
+  ExtendedAgentCardNotConfiguredError: A2A_ERROR_CODE.EXTENDED_CARD_NOT_CONFIGURED,
+  ExtensionSupportRequiredError: A2A_ERROR_CODE.EXTENSION_SUPPORT_REQUIRED,
+  VersionNotSupportedError: A2A_ERROR_CODE.VERSION_NOT_SUPPORTED,
+  RequestMalformedError: A2A_ERROR_CODE.INVALID_PARAMS
+});
+var JSON_RPC_CODE_TO_ERROR = Object.freeze(
+  Object.fromEntries(Object.entries(JSON_RPC_ERROR_CODE).map(([name, code]) => [code, name]))
+);
+function isJsonRpcError(err) {
+  return err instanceof A2AError && err.transport === "jsonrpc";
+}
+function makeJsonRpc(name) {
+  const Base = A2A_ERROR_CLASSES[name];
+  const defaultCode = JSON_RPC_ERROR_CODE[name] ?? A2A_ERROR_CODE.INTERNAL_ERROR;
+  const cls = {
+    [`JsonRpc${name}`]: class extends Base {
+      transport = "jsonrpc";
+      envelopeCode;
+      data;
+      constructor(options) {
+        super(options);
+        this.name = name;
+        this.envelopeCode = options?.envelopeCode ?? defaultCode;
+        if (options?.data !== void 0) this.data = options.data;
+      }
+    }
+  }[`JsonRpc${name}`];
+  return cls;
+}
+var JsonRpcTaskNotFoundError = makeJsonRpc("TaskNotFoundError");
+var JsonRpcTaskNotCancelableError = makeJsonRpc("TaskNotCancelableError");
+var JsonRpcPushNotificationNotSupportedError = makeJsonRpc(
+  "PushNotificationNotSupportedError"
+);
+var JsonRpcUnsupportedOperationError = makeJsonRpc("UnsupportedOperationError");
+var JsonRpcContentTypeNotSupportedError = makeJsonRpc("ContentTypeNotSupportedError");
+var JsonRpcInvalidAgentResponseError = makeJsonRpc("InvalidAgentResponseError");
+var JsonRpcExtendedAgentCardNotConfiguredError = makeJsonRpc(
+  "ExtendedAgentCardNotConfiguredError"
+);
+var JsonRpcExtensionSupportRequiredError = makeJsonRpc("ExtensionSupportRequiredError");
+var JsonRpcVersionNotSupportedError = makeJsonRpc("VersionNotSupportedError");
+var JsonRpcRequestMalformedError = makeJsonRpc("RequestMalformedError");
+var JSON_RPC_ERROR_CLASSES = Object.freeze({
+  TaskNotFoundError: JsonRpcTaskNotFoundError,
+  TaskNotCancelableError: JsonRpcTaskNotCancelableError,
+  PushNotificationNotSupportedError: JsonRpcPushNotificationNotSupportedError,
+  UnsupportedOperationError: JsonRpcUnsupportedOperationError,
+  ContentTypeNotSupportedError: JsonRpcContentTypeNotSupportedError,
+  InvalidAgentResponseError: JsonRpcInvalidAgentResponseError,
+  ExtendedAgentCardNotConfiguredError: JsonRpcExtendedAgentCardNotConfiguredError,
+  ExtensionSupportRequiredError: JsonRpcExtensionSupportRequiredError,
+  VersionNotSupportedError: JsonRpcVersionNotSupportedError,
+  RequestMalformedError: JsonRpcRequestMalformedError
+});
+function toJsonRpcError(error) {
+  if (isJsonRpcError(error)) {
+    const spec = A2A_ERROR_SPECS[error.name];
+    return {
+      code: error.envelopeCode,
+      message: error.message,
+      ...spec ? { data: [error.toErrorInfo()] } : {}
+    };
+  }
+  if (error instanceof A2AError) {
+    const code = JSON_RPC_ERROR_CODE[error.name] ?? A2A_ERROR_CODE.INTERNAL_ERROR;
+    return { code, message: error.message, data: [error.toErrorInfo()] };
+  }
+  const message = error instanceof Error && error.message || "An unexpected error occurred.";
+  return { code: A2A_ERROR_CODE.INTERNAL_ERROR, message };
+}
+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/server/result_manager.ts
+var taskWriteLocks = /* @__PURE__ */ new Map();
+function lockKey(context, taskId) {
+  const tenant = context.tenant ?? "";
+  const owner = context.user?.userName ?? "";
+  return `${tenant}\0${owner}\0${taskId}`;
+}
+async function serializeByScope(key, fn) {
+  const prev = taskWriteLocks.get(key) ?? Promise.resolve();
+  const next = prev.then(fn, fn);
+  taskWriteLocks.set(key, next);
+  const evict = () => {
+    if (taskWriteLocks.get(key) === next) {
+      taskWriteLocks.delete(key);
+    }
+  };
+  void next.then(evict, evict);
+  return next;
+}
+var ResultManager = class {
+  taskStore;
+  serverCallContext;
+  currentTask;
+  latestUserMessage;
+  finalMessageResult;
+  // taskId of the last event processed under the lock, used to warn if
+  // an executor switches tasks mid-stream on the same RM.
+  lastSeenTaskId;
+  constructor(taskStore, serverCallContext) {
+    this.taskStore = taskStore;
+    this.serverCallContext = serverCallContext;
+  }
+  setContext(latestUserMessage) {
+    this.latestUserMessage = structuredClone(latestUserMessage);
+  }
+  /**
+   * Processes an agent execution event and updates the task store.
+   * Store-touching branches run under a per-(tenant, owner, taskId) lock
+   * so concurrent RMs linearize their load-merge-save sequences. The
+   * `message` branch is in-memory only and intentionally unlocked.
+   */
+  async processEvent(event) {
+    switch (event.kind) {
+      case "message": {
+        this.finalMessageResult = structuredClone(event.data);
+        break;
+      }
+      case "task": {
+        const taskEvent = event.data;
+        if (!taskEvent.id) {
+          await this.processTaskEventLocked(taskEvent);
+          break;
+        }
+        await serializeByScope(
+          lockKey(this.serverCallContext, taskEvent.id),
+          () => this.processTaskEventLocked(taskEvent)
+        );
+        break;
+      }
+      case "statusUpdate": {
+        const updateEvent = event.data;
+        if (!updateEvent.taskId) {
+          await this.applyStatusUpdate(updateEvent);
+          break;
+        }
+        await serializeByScope(
+          lockKey(this.serverCallContext, updateEvent.taskId),
+          () => this.applyStatusUpdate(updateEvent)
+        );
+        break;
+      }
+      case "artifactUpdate": {
+        const artifactEvent = event.data;
+        if (!artifactEvent.taskId) {
+          await this.applyArtifactUpdate(artifactEvent);
+          break;
+        }
+        await serializeByScope(
+          lockKey(this.serverCallContext, artifactEvent.taskId),
+          () => this.applyArtifactUpdate(artifactEvent)
+        );
+        break;
+      }
+      default:
+        assertUnreachableEvent(event);
+    }
+  }
+  /**
+   * Warns when the executor publishes an event for a different `taskId`
+   * than the previous event this RM observed. A single RM is scoped to
+   * one request, so a mismatch indicates an executor bug.
+   */
+  notePersistedTaskId(taskId) {
+    if (!taskId) return;
+    if (this.lastSeenTaskId && this.lastSeenTaskId !== taskId) {
+      console.warn(
+        `ResultManager: event for task ${taskId} arrived after processing events for ${this.lastSeenTaskId}. This indicates the executor switched tasks mid-stream, which is not expected in normal operation.`
+      );
+    }
+    this.lastSeenTaskId = taskId;
+  }
+  /**
+   * Handles a `task` event under the per-taskId write lock. Always
+   * re-loads from the store (no cached state) so a sibling RM's write
+   * between our previous event and this one is observed by our merge.
+   */
+  async processTaskEventLocked(taskEvent) {
+    this.notePersistedTaskId(taskEvent.id);
+    const persistedTask = taskEvent.id ? await this.taskStore.load(taskEvent.id, this.serverCallContext) : void 0;
+    const mergedTask = structuredClone(taskEvent);
+    if (persistedTask && persistedTask.id === taskEvent.id) {
+      if ((!mergedTask.history || mergedTask.history.length === 0) && persistedTask.history) {
+        mergedTask.history = structuredClone(persistedTask.history);
+      }
+      mergedTask.artifacts = this.mergeArtifacts(persistedTask.artifacts, taskEvent.artifacts);
+      if (persistedTask.metadata || taskEvent.metadata) {
+        mergedTask.metadata = {
+          ...structuredClone(persistedTask.metadata ?? {}),
+          ...structuredClone(taskEvent.metadata ?? {})
+        };
+      }
+    }
+    if (this.latestUserMessage) {
+      const latest = this.latestUserMessage;
+      if (!mergedTask.history?.find((msg) => msg.messageId === latest.messageId)) {
+        mergedTask.history = [structuredClone(latest), ...mergedTask.history || []];
+      }
+    }
+    this.currentTask = mergedTask;
+    await this.saveCurrentTask();
+  }
+  /**
+   * Loads the task fresh from the store, warning if it doesn't exist.
+   * Doesn't mutate `this.currentTask` so callers retain TypeScript
+   * flow-narrowing on the result.
+   */
+  async loadPersistedTask(taskId, eventName) {
+    if (!taskId) return void 0;
+    const loaded = await this.taskStore.load(taskId, this.serverCallContext);
+    if (!loaded) {
+      console.warn(`ResultManager: Received ${eventName} for unknown task ${taskId}`);
+    }
+    return loaded;
+  }
+  async applyStatusUpdate(updateEvent) {
+    this.notePersistedTaskId(updateEvent.taskId);
+    const task = await this.loadPersistedTask(updateEvent.taskId, "status update");
+    if (!task || task.id !== updateEvent.taskId) {
+      this.currentTask = task;
+      return;
+    }
+    const persistedState = task.status?.state;
+    if (persistedState !== void 0 && TERMINAL_STATE_LIST.includes(persistedState) && updateEvent.status?.state !== persistedState) {
+      console.warn(
+        `ResultManager: ignoring status update ${updateEvent.status?.state} for terminal task ${task.id} (${persistedState})`
+      );
+      this.currentTask = task;
+      return;
+    }
+    task.status = structuredClone(updateEvent.status);
+    if (updateEvent.metadata) {
+      task.metadata = {
+        ...task.metadata,
+        ...structuredClone(updateEvent.metadata)
+      };
+    }
+    const update = updateEvent.status?.message;
+    if (update) {
+      if (!task.history?.find((msg) => msg.messageId === update.messageId)) {
+        task.history = [...task.history || [], structuredClone(update)];
+      }
+    }
+    this.currentTask = task;
+    await this.saveCurrentTask();
+  }
+  async applyArtifactUpdate(artifactEvent) {
+    const artifact = artifactEvent.artifact;
+    if (!artifact) return;
+    this.notePersistedTaskId(artifactEvent.taskId);
+    const task = await this.loadPersistedTask(artifactEvent.taskId, "artifact update");
+    if (!task || task.id !== artifactEvent.taskId) {
+      this.currentTask = task;
+      return;
+    }
+    if (!task.artifacts) {
+      task.artifacts = [];
+    }
+    const existingArtifactIndex = task.artifacts.findIndex(
+      (art) => art.artifactId === artifact.artifactId
+    );
+    if (existingArtifactIndex !== -1) {
+      if (artifactEvent.append) {
+        const existingArtifact = task.artifacts[existingArtifactIndex];
+        existingArtifact.parts = [
+          ...existingArtifact.parts || [],
+          ...structuredClone(artifact.parts || [])
+        ];
+        if (artifact.description) existingArtifact.description = artifact.description;
+        if (artifact.name) existingArtifact.name = artifact.name;
+        if (artifact.metadata)
+          existingArtifact.metadata = {
+            ...existingArtifact.metadata,
+            ...structuredClone(artifact.metadata)
+          };
+      } else {
+        task.artifacts[existingArtifactIndex] = structuredClone(artifact);
+      }
+    } else {
+      task.artifacts.push(structuredClone(artifact));
+    }
+    if (artifactEvent.metadata) {
+      task.metadata = {
+        ...task.metadata,
+        ...structuredClone(artifactEvent.metadata)
+      };
+    }
+    this.currentTask = task;
+    await this.saveCurrentTask();
+  }
+  /**
+   * Merges artifact arrays, deduplicating by `artifactId`. Persisted
+   * artifacts are retained and overlaid by any incoming artifact with
+   * the same id; artifacts only in the incoming list are appended.
+   * Every entry in the returned array is a fresh deep copy.
+   */
+  mergeArtifacts(persisted, incoming) {
+    if (!persisted || persisted.length === 0) {
+      return incoming ? structuredClone(incoming) : [];
+    }
+    if (!incoming || incoming.length === 0) {
+      return structuredClone(persisted);
+    }
+    const incomingById = /* @__PURE__ */ new Map();
+    for (const art of incoming) {
+      incomingById.set(art.artifactId, art);
+    }
+    const merged = persisted.map(
+      (art) => structuredClone(incomingById.get(art.artifactId) ?? art)
+    );
+    const seenIds = new Set(persisted.map((art) => art.artifactId));
+    for (const art of incoming) {
+      if (!seenIds.has(art.artifactId)) {
+        merged.push(structuredClone(art));
+      }
+    }
+    return merged;
+  }
+  async saveCurrentTask() {
+    if (this.currentTask) {
+      await this.taskStore.save(this.currentTask, this.serverCallContext);
+    }
+  }
+  /**
+   * Returns the final result (Message or Task) after the event stream
+   * has been fully processed. Returns the internally-tracked object
+   * directly (not a clone) so downstream callers can apply in-place
+   * edits; safe because RMs are scoped to a single request and discarded
+   * immediately after.
+   */
+  getFinalResult() {
+    if (this.finalMessageResult) {
+      return this.finalMessageResult;
+    }
+    return this.currentTask;
+  }
+  /**
+   * Returns the task currently being managed (created during, or started
+   * with, agent execution). See {@link getFinalResult} for why this is
+   * the internal reference rather than a clone.
+   */
+  getCurrentTask() {
+    return this.currentTask;
+  }
+};
+
+// src/server/push_notification/push_notification_store.ts
+var InMemoryPushNotificationStore = class {
+  _scopedStore;
+  constructor(ownerResolver = resolveUserScope) {
+    this._scopedStore = new ScopedStore(ownerResolver);
+  }
+  async save(taskId, context, pushNotificationConfig) {
+    const bucket = this._scopedStore.getOrCreateBucket(context);
+    const entries = bucket.get(taskId) || [];
+    if (!pushNotificationConfig.id) {
+      pushNotificationConfig.id = crypto.randomUUID();
+    }
+    const wireVersion = context.requestedVersion || A2A_LEGACY_PROTOCOL_VERSION;
+    const existingIndex = entries.findIndex(
+      (entry) => entry.config.id === pushNotificationConfig.id
+    );
+    if (existingIndex !== -1) {
+      entries.splice(existingIndex, 1);
+    }
+    entries.push({ config: structuredClone(pushNotificationConfig), wireVersion });
+    bucket.set(taskId, entries);
+  }
+  async load(taskId, context) {
+    const entries = this._scopedStore.getBucket(context)?.get(taskId);
+    return entries ? entries.map((e) => structuredClone(e.config)) : [];
+  }
+  async loadWithMetadata(taskId, context) {
+    const entries = this._scopedStore.getBucket(context)?.get(taskId);
+    return entries ? entries.map((e) => structuredClone(e)) : [];
+  }
+  async delete(taskId, context, configId) {
+    if (configId === void 0) {
+      configId = taskId;
+    }
+    const bucket = this._scopedStore.getBucket(context);
+    if (!bucket) {
+      return;
+    }
+    const entries = bucket.get(taskId);
+    if (!entries) {
+      return;
+    }
+    const entryIndex = entries.findIndex((entry) => entry.config.id === configId);
+    if (entryIndex !== -1) {
+      entries.splice(entryIndex, 1);
+    }
+    if (entries.length === 0) {
+      bucket.delete(taskId);
+    }
+  }
+};
+
+// src/server/push_notification/push_notification_serializer.ts
+var V1PushNotificationSerializer = class {
+  serialize(streamResponse, _task) {
+    return {
+      body: JSON.stringify(StreamResponse.toJSON(streamResponse)),
+      contentType: A2A_CONTENT_TYPE
+    };
+  }
+};
+
+// src/server/push_notification/default_push_notification_sender.ts
+var DefaultPushNotificationSender = class {
+  pushNotificationStore;
+  notificationChain;
+  options;
+  serializers;
+  fallbackSerializer;
+  // Avoid log spam when many notifications target the same unknown version.
+  warnedMissingSerializers = /* @__PURE__ */ new Set();
+  constructor(pushNotificationStore, options = {}) {
+    this.pushNotificationStore = pushNotificationStore;
+    this.notificationChain = /* @__PURE__ */ new Map();
+    this.options = {
+      timeout: options.timeout ?? 5e3,
+      tokenHeaderName: options.tokenHeaderName ?? "X-A2A-Notification-Token"
+    };
+    const builtinV1 = new V1PushNotificationSerializer();
+    this.serializers = /* @__PURE__ */ new Map([
+      ["1.0" /* V1_0 */, builtinV1]
+    ]);
+    if (options.serializers) {
+      for (const [version, serializer] of Object.entries(options.serializers)) {
+        if (serializer) {
+          this.serializers.set(version, serializer);
+        }
+      }
+    }
+    this.fallbackSerializer = this.serializers.get("1.0" /* V1_0 */) ?? builtinV1;
+  }
+  async send(streamResponse, context, task) {
+    const taskId = this._getTaskId(streamResponse);
+    if (!taskId) {
+      return;
+    }
+    const storedConfigs = await this._loadStoredConfigs(taskId, context);
+    if (!storedConfigs || storedConfigs.length === 0) {
+      return;
+    }
+    const lastPromise = this.notificationChain.get(taskId) ?? Promise.resolve();
+    const newPromise = lastPromise.catch(() => {
+    }).then(async () => {
+      const dispatches = storedConfigs.map(async (storedConfig) => {
+        try {
+          await this._dispatchNotification(streamResponse, storedConfig, taskId, task);
+        } catch (error) {
+          console.error(
+            `Error sending push notification for task_id=${taskId} to URL: ${storedConfig.config.url}. Error:`,
+            error
+          );
+        }
+      });
+      await Promise.all(dispatches);
+    });
+    this.notificationChain.set(taskId, newPromise);
+    return newPromise.finally(() => {
+      if (this.notificationChain.get(taskId) === newPromise) {
+        this.notificationChain.delete(taskId);
+      }
+    });
+  }
+  /**
+   * Returns the task id associated with a {@link StreamResponse}.
+   * Returns an empty string for stand-alone messages with no task
+   * association; the sender skips dispatch in that case.
+   */
+  _getTaskId(streamResponse) {
+    const payload = streamResponse.payload;
+    if (!payload) {
+      throw new Error("StreamResponse payload is undefined");
+    }
+    switch (payload.$case) {
+      case "task":
+        return payload.value.id;
+      case "statusUpdate":
+      case "artifactUpdate":
+      case "message":
+        return payload.value.taskId;
+      default: {
+        const _exhaustive = payload;
+        throw new Error(`Unknown payload case: ${_exhaustive.$case}`);
+      }
+    }
+  }
+  /**
+   * Resolves stored configs from the {@link PushNotificationStore},
+   * preferring the wire-version-aware
+   * {@link PushNotificationStore.loadWithMetadata} when available.
+   *
+   * Stores that only implement the canonical {@link PushNotificationStore.load}
+   * are silently lifted into the wrapped shape by tagging every entry
+   * with the wire version of the *triggering* request. See
+   * `src/compat/v0_3/README.md` for the implication on v1.0 deployments
+   * with v0.3 compat opted in.
+   */
+  async _loadStoredConfigs(taskId, context) {
+    if (this.pushNotificationStore.loadWithMetadata) {
+      return await this.pushNotificationStore.loadWithMetadata(taskId, context);
+    }
+    const plain = await this.pushNotificationStore.load(taskId, context);
+    const fallbackVersion = context.requestedVersion || A2A_LEGACY_PROTOCOL_VERSION;
+    return plain.map((config) => ({ config, wireVersion: fallbackVersion }));
+  }
+  /**
+   * Resolves the serializer registered for the given wire version,
+   * falling back to v1.0 (with a one-time warning) when no entry is
+   * registered.
+   */
+  _resolveSerializer(wireVersion) {
+    const serializer = this.serializers.get(wireVersion);
+    if (serializer) {
+      return serializer;
+    }
+    if (!this.warnedMissingSerializers.has(wireVersion)) {
+      this.warnedMissingSerializers.add(wireVersion);
+      console.warn(
+        `No push notification serializer registered for wire version '${wireVersion}'; falling back to '${A2A_PROTOCOL_VERSION}'. Register one via DefaultPushNotificationSenderOptions.serializers to silence this warning.`
+      );
+    }
+    return this.fallbackSerializer;
+  }
+  /**
+   * Builds the auth headers for a push notification request. Priority:
+   * `pushConfig.authentication` (scheme + credentials) → `Authorization`
+   * header; otherwise `pushConfig.token` → legacy token header.
+   */
+  _buildAuthHeaders(pushConfig) {
+    const headers = {};
+    if (pushConfig.authentication?.scheme && pushConfig.authentication?.credentials) {
+      headers["Authorization"] = `${pushConfig.authentication.scheme} ${pushConfig.authentication.credentials}`;
+    } else if (pushConfig.token) {
+      headers[this.options.tokenHeaderName] = pushConfig.token;
+    }
+    return headers;
+  }
+  async _dispatchNotification(streamResponse, storedConfig, taskId, task) {
+    const { config: pushConfig, wireVersion } = storedConfig;
+    const url = pushConfig.url;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.options.timeout);
+    try {
+      const serializer = this._resolveSerializer(wireVersion);
+      const { body, contentType } = serializer.serialize(streamResponse, task);
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": contentType,
+          ...this._buildAuthHeaders(pushConfig)
+        },
+        body,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      console.info(`Push notification sent for task_id=${taskId} to URL: ${url}`);
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+
+// src/server/request_handler/default_request_handler.ts
+var DefaultRequestHandler = class {
+  agentCard;
+  taskStore;
+  agentExecutor;
+  eventBusManager;
+  pushNotificationStore;
+  pushNotificationSender;
+  extendedAgentCardProvider;
+  agentCardSignatureGenerator;
+  keepBusAliveStates;
+  validateInputModes;
+  constructor(agentCard, taskStore, agentExecutor, eventBusManager = new DefaultExecutionEventBusManager(), pushNotificationStore, pushNotificationSender, extendedAgentCardProvider, agentCardSignatureGenerator, options = {}) {
+    this.agentCard = agentCard;
+    this.taskStore = taskStore;
+    this.agentExecutor = agentExecutor;
+    this.eventBusManager = eventBusManager;
+    this.extendedAgentCardProvider = extendedAgentCardProvider;
+    this.agentCardSignatureGenerator = agentCardSignatureGenerator;
+    this.keepBusAliveStates = new Set(options.keepBusAliveStates ?? INTERRUPTED_STATE_LIST);
+    this.validateInputModes = options.validateInputModes ?? false;
+    if (agentCard.capabilities?.pushNotifications) {
+      this.pushNotificationStore = pushNotificationStore || new InMemoryPushNotificationStore();
+      this.pushNotificationSender = pushNotificationSender || new DefaultPushNotificationSender(this.pushNotificationStore);
+    }
+  }
+  async getAgentCard() {
+    if (this.agentCardSignatureGenerator) {
+      return this.agentCardSignatureGenerator(this.agentCard);
+    }
+    return this.agentCard;
+  }
+  async getAuthenticatedExtendedAgentCard(_params, context) {
+    if (!this.agentCard.capabilities?.extendedAgentCard) {
+      throw new UnsupportedOperationError("Agent does not support authenticated extended card.");
+    }
+    if (!this.extendedAgentCardProvider) {
+      throw new ExtendedAgentCardNotConfiguredError();
+    }
+    let agentCard;
+    if (typeof this.extendedAgentCardProvider === "function") {
+      agentCard = await this.extendedAgentCardProvider(context);
+    } else if (context.user?.isAuthenticated) {
+      agentCard = this.extendedAgentCardProvider;
+    } else {
+      agentCard = this.agentCard;
+    }
+    if (this.agentCardSignatureGenerator) {
+      return this.agentCardSignatureGenerator(agentCard);
+    }
+    return agentCard;
+  }
+  _validateInputModes(message, agentCard) {
+    const supportedModes = agentCard.defaultInputModes ?? [];
+    if (!this.validateInputModes || supportedModes.length === 0) {
+      return;
+    }
+    for (const part of message.parts ?? []) {
+      if (part.mediaType && !supportedModes.includes(part.mediaType)) {
+        throw new ContentTypeNotSupportedError(
+          `Media type '${part.mediaType}' is not supported. Supported media types: ${supportedModes.join(", ")}.`
+        );
+      }
+    }
+  }
+  async _createRequestContext(request, context) {
+    const incomingMessage = request.message;
+    if (!incomingMessage) {
+      throw new RequestMalformedError("request.message is required.");
+    }
+    let task;
+    let referenceTasks;
+    const agentCard = await this.getAgentCard();
+    this._validateInputModes(incomingMessage, agentCard);
+    const agentExtensions = agentCard.capabilities?.extensions ?? [];
+    const requestedSet = new Set(context.requestedExtensions ?? []);
+    const missingRequired = agentExtensions.filter((ext) => ext.required && !requestedSet.has(ext.uri)).map((ext) => ext.uri);
+    if (missingRequired.length > 0) {
+      throw new ExtensionSupportRequiredError(
+        `Client must declare support for required extensions: ${missingRequired.join(", ")}`
+      );
+    }
+    if (incomingMessage.taskId) {
+      this._requireValidTaskId(incomingMessage.taskId);
+      task = await this.taskStore.load(incomingMessage.taskId, context);
+      if (!task) {
+        throw new TaskNotFoundError(`Task not found: ${incomingMessage.taskId}`);
+      }
+      if (task.status?.state !== void 0 && TERMINAL_STATE_LIST.includes(task.status.state)) {
+        throw new UnsupportedOperationError(
+          `Task ${task.id} is in a terminal state (${task.status.state}) and cannot be modified.`
+        );
+      }
+      if (incomingMessage.contextId && task.contextId && incomingMessage.contextId !== task.contextId) {
+        throw new RequestMalformedError(
+          `contextId mismatch: message contextId '${incomingMessage.contextId}' does not match task '${task.id}' contextId '${task.contextId}'`
+        );
+      }
+      task.history = [...task.history || [], incomingMessage];
+      await this.taskStore.save(task, context);
+    }
+    const taskId = incomingMessage.taskId || crypto.randomUUID();
+    const referenceTaskIds = incomingMessage.referenceTaskIds || [];
+    if (referenceTaskIds.length > 0) {
+      referenceTasks = [];
+      for (const refId of referenceTaskIds) {
+        const refTask = await this.taskStore.load(refId, context);
+        if (refTask) {
+          referenceTasks.push(refTask);
+        } else {
+          console.warn(`Reference task ${refId} not found.`);
+        }
+      }
+    }
+    const contextId = incomingMessage.contextId || task?.contextId || crypto.randomUUID();
+    if (context.requestedExtensions) {
+      const exposedExtensions = new Set(agentExtensions.map((ext) => ext.uri));
+      context.setRequestedExtensions(
+        context.requestedExtensions.filter((extension) => exposedExtensions.has(extension))
+      );
+    }
+    const messageForContext = {
+      ...incomingMessage,
+      contextId,
+      taskId
+    };
+    const resolvedRequest = {
+      ...request,
+      message: messageForContext
+    };
+    return new RequestContext(resolvedRequest, taskId, contextId, context, task, referenceTasks);
+  }
+  async _processEvents(taskId, resultManager, eventQueue, context, options) {
+    let firstResultSent = false;
+    let authRequiredSnapshotSent = false;
+    try {
+      for await (const event of eventQueue.events()) {
+        await resultManager.processEvent(event);
+        try {
+          const streamResponse = await this._mapEventToStreamResponse(event, context);
+          await this._sendPushNotificationIfNeeded(
+            context,
+            streamResponse,
+            structuredClone(resultManager.getCurrentTask())
+          );
+        } catch (error) {
+          console.error(`Error sending push notification: ${error}`);
+        }
+        if (options?.firstResultResolver && !firstResultSent) {
+          let firstResult;
+          if (event.kind === "message") {
+            firstResult = event.data;
+          } else if (event.kind === "task") {
+            firstResult = event.data;
+          } else {
+            const finalResult = resultManager.getFinalResult();
+            if (finalResult && ("messageId" in finalResult || "id" in finalResult)) {
+              firstResult = finalResult;
+            }
+          }
+          if (firstResult) {
+            options.firstResultResolver(firstResult);
+            firstResultSent = true;
+          }
+        }
+        if (options?.authRequiredSnapshotResolver && !authRequiredSnapshotSent && event.kind === "statusUpdate" && event.data.status && AUTH_REQUIRED_STATE_LIST.includes(event.data.status.state)) {
+          const currentTask = resultManager.getCurrentTask();
+          if (currentTask) {
+            options.authRequiredSnapshotResolver(structuredClone(currentTask));
+            authRequiredSnapshotSent = true;
+            firstResultSent = true;
+          }
+        }
+      }
+      if (options?.firstResultResolver && options?.firstResultRejector && !firstResultSent) {
+        options.firstResultRejector(
+          new RequestMalformedError("Execution finished before a message or task was produced.")
+        );
+      }
+    } catch (error) {
+      console.error(`Event processing loop failed for task ${taskId}:`, error);
+      await this._handleProcessingError(
+        error,
+        resultManager,
+        firstResultSent,
+        taskId,
+        options?.firstResultRejector
+      );
+    } finally {
+      eventQueue.stop();
+    }
+  }
+  /**
+   * Background drain helper used by the blocking `sendMessage` path
+   * after an AUTH_REQUIRED snapshot has been returned to the caller.
+   * Attaches a `.catch` so a thrown error in the unattended drain is
+   * logged instead of surfacing as a Node `unhandledRejection`.
+   */
+  _continueDraining(taskId, pending) {
+    pending.catch((error) => {
+      console.error(
+        `Background AUTH_REQUIRED drain failed for task ${taskId}:`,
+        error instanceof Error ? error.message : error
+      );
+    });
+  }
+  /**
+   * Runs the executor for a blocking `sendMessage` call and ties the
+   * event bus lifecycle to the executor's settlement. On rejection,
+   * publishes a synthetic Task + statusUpdate(FAILED) so the consumer's
+   * event loop terminates with a usable final result and any concurrent
+   * resubscribers see the failure on the same wire.
+   */
+  _runExecutor(taskId, eventBus, requestContext, finalMessageForAgent) {
+    const stateTracker = trackLatestTaskState(eventBus);
+    this.agentExecutor.execute(requestContext, eventBus).catch((err) => {
+      const errorMessage = extractErrorMessage(err);
+      console.error(`Agent execution failed for message ${finalMessageForAgent.messageId}:`, err);
+      const errorTask = {
+        id: requestContext.taskId,
+        contextId: finalMessageForAgent.contextId,
+        status: {
+          state: 4 /* TASK_STATE_FAILED */,
+          message: {
+            role: 2 /* ROLE_AGENT */,
+            messageId: crypto.randomUUID(),
+            taskId: requestContext.taskId,
+            contextId: finalMessageForAgent.contextId,
+            parts: [
+              {
+                content: { $case: "text", value: `Agent execution error: ${errorMessage}` },
+                mediaType: "text/plain",
+                filename: "",
+                metadata: {}
+              }
+            ],
+            metadata: {},
+            extensions: [],
+            referenceTaskIds: []
+          },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        artifacts: [],
+        history: requestContext.task?.history ? [...requestContext.task.history] : [],
+        metadata: {}
+      };
+      if (finalMessageForAgent && !errorTask.history?.find((m) => m.messageId === finalMessageForAgent.messageId)) {
+        errorTask.history?.push(finalMessageForAgent);
+      }
+      eventBus.publish(AgentEvent.task(errorTask));
+      eventBus.publish(
+        AgentEvent.statusUpdate({
+          taskId: errorTask.id,
+          contextId: errorTask.contextId,
+          status: errorTask.status,
+          metadata: {}
+        })
+      );
+    }).finally(() => {
+      this._settleBus(taskId, eventBus, stateTracker(), requestContext.context);
+    });
+  }
+  /**
+   * Settles the event bus once the executor returns. Terminal states
+   * (and the bare-Message stream pattern) close the bus immediately;
+   * states configured in `keepBusAliveStates` keep it alive so follow-up
+   * sends and resubscribers can still attach.
+   *
+   * A bus manager implementing
+   * {@link ExecutionEventBusManager.settleByTaskId} is offered the decision
+   * first and takes ownership of the bus by returning `true`, in which case we
+   * do nothing further. That seam exists for buses whose delivery is deferred,
+   * where `lastState` is still `undefined` when the executor returns and no
+   * state-based policy can work. A manager that declines — or has no opinion
+   * on this particular task — returns `false`, and the policy below applies as
+   * usual.
+   */
+  _settleBus(taskId, eventBus, lastState, context) {
+    if (this.eventBusManager.settleByTaskId?.(taskId, eventBus, lastState, context)) {
+      return;
+    }
+    if (lastState !== void 0 && this.keepBusAliveStates.has(lastState)) {
+      return;
+    }
+    eventBus.finished();
+    this.eventBusManager.cleanupByTaskId(taskId, context);
+  }
+  /**
+   * Streaming variant of {@link _runExecutor}. If the executor threw
+   * before publishing any Task event, synthesizes both the Task and a
+   * statusUpdate(FAILED) so the SSE consumer sees a well-formed
+   * task-lifecycle stream that terminates in FAILED. If a Task was
+   * already published, only the statusUpdate is synthesized to avoid
+   * violating the task-lifecycle ordering.
+   */
+  _runStreamExecutor(taskId, eventBus, requestContext) {
+    const finalMessageForAgent = requestContext.userMessage;
+    const snapshotTracker = trackLatestTaskAndState(eventBus);
+    this.agentExecutor.execute(requestContext, eventBus).catch((err) => {
+      const errorMessage = extractErrorMessage(err);
+      console.error(
+        `Agent execution failed for stream message ${finalMessageForAgent.messageId}:`,
+        err
+      );
+      const latestTask = snapshotTracker().task;
+      const errorTaskId = latestTask?.id ?? requestContext.taskId;
+      const errorContextId = latestTask?.contextId ?? finalMessageForAgent.contextId;
+      if (!latestTask) {
+        const errorTask = {
+          id: requestContext.taskId,
+          contextId: finalMessageForAgent.contextId,
+          status: {
+            state: 4 /* TASK_STATE_FAILED */,
+            message: {
+              role: 2 /* ROLE_AGENT */,
+              messageId: crypto.randomUUID(),
+              taskId: requestContext.taskId,
+              contextId: finalMessageForAgent.contextId,
+              parts: [
+                {
+                  content: { $case: "text", value: `Agent execution error: ${errorMessage}` },
+                  mediaType: "text/plain",
+                  filename: "",
+                  metadata: {}
+                }
+              ],
+              metadata: {},
+              extensions: [],
+              referenceTaskIds: []
+            },
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          artifacts: [],
+          history: requestContext.task?.history ? [...requestContext.task.history] : [],
+          metadata: {}
+        };
+        if (finalMessageForAgent && !errorTask.history?.find((m) => m.messageId === finalMessageForAgent.messageId)) {
+          errorTask.history?.push(finalMessageForAgent);
+        }
+        eventBus.publish(AgentEvent.task(errorTask));
+      }
+      const errorTaskStatus = {
+        taskId: errorTaskId,
+        contextId: errorContextId,
+        status: {
+          state: 4 /* TASK_STATE_FAILED */,
+          message: {
+            role: 2 /* ROLE_AGENT */,
+            messageId: crypto.randomUUID(),
+            taskId: errorTaskId,
+            contextId: errorContextId,
+            parts: [
+              {
+                content: { $case: "text", value: `Agent execution error: ${errorMessage}` },
+                mediaType: "text/plain",
+                filename: "",
+                metadata: {}
+              }
+            ],
+            metadata: {},
+            extensions: [],
+            referenceTaskIds: []
+          },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        metadata: {}
+      };
+      eventBus.publish(AgentEvent.statusUpdate(errorTaskStatus));
+    }).finally(() => {
+      this._settleBus(taskId, eventBus, snapshotTracker().state, requestContext.context);
+    });
+  }
+  async sendMessage(params, context) {
+    const incomingMessage = params.message;
+    if (!incomingMessage?.messageId) {
+      throw new RequestMalformedError("message.messageId is required.");
+    }
+    const isBlocking = params.configuration?.returnImmediately !== true;
+    const resultManager = new ResultManager(this.taskStore, context);
+    resultManager.setContext(incomingMessage);
+    const requestContext = await this._createRequestContext(params, context);
+    const taskId = requestContext.taskId;
+    const finalMessageForAgent = requestContext.userMessage;
+    if (params.configuration?.taskPushNotificationConfig && this.agentCard.capabilities?.pushNotifications) {
+      const pushConfig = structuredClone(params.configuration.taskPushNotificationConfig);
+      pushConfig.taskId = taskId;
+      await this.pushNotificationStore?.save(taskId, context, pushConfig);
+    }
+    const eventBus = this.eventBusManager.createOrGetByTaskId(taskId, context);
+    const eventQueue = new ExecutionEventQueue(eventBus);
+    this._runExecutor(taskId, eventBus, requestContext, finalMessageForAgent);
+    const historyLengthConfig = params.configuration;
+    if (isBlocking) {
+      return new Promise((resolve, reject) => {
+        const pending = this._processEvents(taskId, resultManager, eventQueue, context, {
+          authRequiredSnapshotResolver: (snapshot) => {
+            this._applyHistoryLengthSemantics(snapshot, historyLengthConfig ?? {});
+            resolve(snapshot);
+            this._continueDraining(taskId, pending);
+          },
+          // Pre-AUTH_REQUIRED drain errors reject the outer promise so
+          // `await sendMessage(...)` throws. Post-AUTH_REQUIRED drain
+          // errors fall into `_handleProcessingError`'s "first result
+          // already sent" branch (persisting FAILED via ResultManager)
+          // and the `reject` call here becomes a no-op because Promise
+          // settlement is one-shot.
+          firstResultRejector: reject
+        });
+        pending.then(() => {
+          const finalResult = resultManager.getFinalResult();
+          if (!finalResult) {
+            reject(
+              new A2AError(
+                "Agent execution finished without a result, and no task context found."
+              )
+            );
+            return;
+          }
+          if (isTask(finalResult)) {
+            this._applyHistoryLengthSemantics(finalResult, historyLengthConfig ?? {});
+          }
+          resolve(finalResult);
+        }).catch(reject);
+      });
+    } else {
+      return new Promise((resolve, reject) => {
+        this._processEvents(taskId, resultManager, eventQueue, context, {
+          firstResultResolver: (result) => {
+            if (isTask(result)) {
+              this._applyHistoryLengthSemantics(result, historyLengthConfig ?? {});
+            }
+            resolve(result);
+          },
+          firstResultRejector: reject
+        });
+      });
+    }
+  }
+  async *sendMessageStream(params, context) {
+    if (!this.agentCard.capabilities?.streaming) {
+      throw new UnsupportedOperationError("Streaming is not supported.");
+    }
+    const incomingMessage = params.message;
+    if (!incomingMessage?.messageId) {
+      throw new RequestMalformedError("message.messageId is required for streaming.");
+    }
+    const resultManager = new ResultManager(this.taskStore, context);
+    resultManager.setContext(incomingMessage);
+    const requestContext = await this._createRequestContext(params, context);
+    const taskId = requestContext.taskId;
+    const eventBus = this.eventBusManager.createOrGetByTaskId(taskId, context);
+    const eventQueue = new ExecutionEventQueue(eventBus);
+    if (params.configuration?.taskPushNotificationConfig && this.agentCard.capabilities?.pushNotifications) {
+      const pushConfig = structuredClone(params.configuration.taskPushNotificationConfig);
+      pushConfig.taskId = taskId;
+      await this.pushNotificationStore?.save(taskId, context, pushConfig);
+    }
+    this._runStreamExecutor(taskId, eventBus, requestContext);
+    let streamPattern = "undetermined" /* UNDETERMINED */;
+    try {
+      for await (const event of eventQueue.events()) {
+        streamPattern = this._advanceStreamPattern(event, streamPattern);
+        await resultManager.processEvent(event);
+        const streamResponse = await this._mapEventToStreamResponse(event, context);
+        if (streamResponse.payload?.$case === "task") {
+          this._applyHistoryLengthSemantics(
+            streamResponse.payload.value,
+            params.configuration ?? {}
+          );
+        }
+        await this._sendPushNotificationIfNeeded(
+          context,
+          streamResponse,
+          resultManager.getCurrentTask()
+        );
+        yield streamResponse;
+      }
+    } finally {
+      eventQueue.stop();
+    }
+  }
+  async getTask(params, context) {
+    const taskId = params.id;
+    this._requireValidTaskId(taskId);
+    const task = await this.taskStore.load(taskId, context);
+    if (!task) {
+      throw new TaskNotFoundError(`Task not found: ${params.id}`);
+    }
+    this._applyHistoryLengthSemantics(task, params);
+    return task;
+  }
+  async listTasks(params, context) {
+    const pageSize = params.pageSize ?? DEFAULT_PAGE_SIZE;
+    if (!Number.isInteger(pageSize) || pageSize < 1 || pageSize > 100) {
+      throw new RequestMalformedError("pageSize must be between 1 and 100");
+    }
+    if (params.status !== void 0 && !VALID_TASK_STATE_LIST.includes(params.status)) {
+      throw new RequestMalformedError(`Invalid status filter: ${String(params.status)}`);
+    }
+    if (params.statusTimestampAfter && isNaN(Date.parse(params.statusTimestampAfter))) {
+      throw new RequestMalformedError("statusTimestampAfter must be a valid ISO 8601 date string");
+    }
+    const response = await this.taskStore.list({ ...params, pageSize }, context);
+    for (const task of response.tasks) {
+      this._applyHistoryLengthSemantics(task, params);
+    }
+    return response;
+  }
+  async cancelTask(params, context) {
+    const taskId = params.id;
+    this._requireValidTaskId(taskId);
+    const task = await this.taskStore.load(taskId, context);
+    if (!task) {
+      throw new TaskNotFoundError(`Task not found: ${params.id}`);
+    }
+    const currentState = task.status?.state;
+    if (currentState === 5 /* TASK_STATE_CANCELED */) {
+      return task;
+    }
+    if (currentState !== void 0 && TERMINAL_STATE_LIST.includes(currentState)) {
+      throw new TaskNotCancelableError(`Task not cancelable: ${params.id}`);
+    }
+    const eventBus = this.eventBusManager.getByTaskId(taskId, context);
+    if (eventBus) {
+      const eventQueue = new ExecutionEventQueue(eventBus);
+      await this.agentExecutor.cancelTask(taskId, eventBus);
+      await this._processEvents(
+        taskId,
+        new ResultManager(this.taskStore, context),
+        eventQueue,
+        context
+      );
+    } else {
+      const cancelMessage = {
+        role: 2 /* ROLE_AGENT */,
+        messageId: crypto.randomUUID(),
+        taskId: task.id,
+        contextId: task.contextId,
+        parts: [
+          {
+            content: { $case: "text", value: "Task cancellation requested by user." },
+            mediaType: "text/plain",
+            filename: "",
+            metadata: {}
+          }
+        ],
+        metadata: {},
+        extensions: [],
+        referenceTaskIds: []
+      };
+      await new ResultManager(this.taskStore, context).processEvent(
+        AgentEvent.statusUpdate({
+          taskId: task.id,
+          contextId: task.contextId,
+          status: {
+            state: 5 /* TASK_STATE_CANCELED */,
+            message: cancelMessage,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          metadata: {}
+        })
+      );
+    }
+    const latestTask = await this.taskStore.load(taskId, context);
+    if (!latestTask) {
+      throw new A2AError(`Task ${params.id} not found after cancellation.`);
+    }
+    if (latestTask.status.state != 5 /* TASK_STATE_CANCELED */) {
+      throw new TaskNotCancelableError(`Task not cancelable: ${params.id}`);
+    }
+    return latestTask;
+  }
+  async createTaskPushNotificationConfig(params, context) {
+    if (!this.agentCard.capabilities?.pushNotifications) {
+      throw new PushNotificationNotSupportedError();
+    }
+    const taskId = params.taskId;
+    this._requireValidTaskId(taskId);
+    const task = await this.taskStore.load(taskId, context);
+    if (!task) {
+      throw new TaskNotFoundError(`Task not found: ${taskId}`);
+    }
+    await this.pushNotificationStore?.save(taskId, context, params);
+    return structuredClone(params);
+  }
+  async getTaskPushNotificationConfig(params, context) {
+    if (!this.agentCard.capabilities?.pushNotifications) {
+      throw new PushNotificationNotSupportedError();
+    }
+    const taskId = params.taskId;
+    this._requireValidTaskId(taskId);
+    const task = await this.taskStore.load(taskId, context);
+    if (!task) {
+      throw new TaskNotFoundError(`Task not found: ${taskId}`);
+    }
+    const configs = await this.pushNotificationStore?.load(taskId, context) || [];
+    if (configs.length === 0) {
+      throw new TaskNotFoundError(`Push notification config not found for task ${taskId}.`);
+    }
+    const config = configs.find((c) => c.id === params.id);
+    if (!config) {
+      throw new TaskNotFoundError(
+        `Push notification config with id '${params.id}' not found for task ${taskId}.`
+      );
+    }
+    return config;
+  }
+  async listTaskPushNotificationConfigs(params, context) {
+    if (!this.agentCard.capabilities?.pushNotifications) {
+      throw new PushNotificationNotSupportedError();
+    }
+    const taskId = params.taskId;
+    this._requireValidTaskId(taskId);
+    const task = await this.taskStore.load(taskId, context);
+    if (!task) {
+      throw new TaskNotFoundError(`Task not found: ${taskId}`);
+    }
+    return {
+      configs: await this.pushNotificationStore?.load(taskId, context) || [],
+      nextPageToken: ""
+    };
+  }
+  async deleteTaskPushNotificationConfig(params, context) {
+    if (!this.agentCard.capabilities?.pushNotifications) {
+      throw new PushNotificationNotSupportedError();
+    }
+    const taskId = params.taskId;
+    this._requireValidTaskId(taskId);
+    const task = await this.taskStore.load(taskId, context);
+    if (!task) {
+      throw new TaskNotFoundError(`Task not found: ${taskId}`);
+    }
+    await this.pushNotificationStore?.delete(taskId, context, params.id);
+  }
+  async *resubscribe(params, context) {
+    if (!this.agentCard.capabilities?.streaming) {
+      throw new UnsupportedOperationError("Streaming (and thus resubscription) is not supported.");
+    }
+    const taskId = params.id;
+    this._requireValidTaskId(taskId);
+    const eventBus = this.eventBusManager.getByTaskId(taskId, context);
+    const eventQueue = eventBus ? new ExecutionEventQueue(eventBus) : void 0;
+    try {
+      const task = await this.taskStore.load(taskId, context);
+      if (!task) {
+        throw new TaskNotFoundError(`Task not found: ${taskId}`);
+      }
+      if (task.status?.state !== void 0 && TERMINAL_STATE_LIST.includes(task.status.state)) {
+        throw new UnsupportedOperationError(
+          `Task ${taskId} is in a terminal state (${task.status.state}) and cannot be subscribed to.`
+        );
+      }
+      yield { payload: { $case: "task", value: task } };
+      if (!eventQueue) {
+        return;
+      }
+      for await (const event of eventQueue.events()) {
+        switch (event.kind) {
+          case "statusUpdate":
+            if (event.data.taskId === taskId) {
+              yield { payload: { $case: "statusUpdate", value: event.data } };
+            }
+            break;
+          case "artifactUpdate":
+            if (event.data.taskId === taskId) {
+              yield { payload: { $case: "artifactUpdate", value: event.data } };
+            }
+            break;
+          case "task":
+            if (event.data.id === taskId) {
+              yield { payload: { $case: "task", value: event.data } };
+            }
+            break;
+          case "message":
+            break;
+          default:
+            assertUnreachableEvent(event);
+        }
+      }
+    } finally {
+      eventQueue?.stop();
+    }
+  }
+  /**
+   * Maps an {@link AgentExecutionEvent} to a `StreamResponse`. For Task
+   * events the full task is loaded from the store to include accumulated
+   * history and artifacts.
+   */
+  async _mapEventToStreamResponse(event, context) {
+    switch (event.kind) {
+      case "task": {
+        const taskId = event.data.id;
+        const fullTask = await this.taskStore.load(taskId, context).catch((error) => {
+          console.warn("Failed to load full task from store, falling back to event data:", error);
+          return null;
+        });
+        return { payload: { $case: "task", value: fullTask || event.data } };
+      }
+      case "message":
+        return { payload: { $case: "message", value: event.data } };
+      case "statusUpdate":
+        return { payload: { $case: "statusUpdate", value: event.data } };
+      case "artifactUpdate":
+        return { payload: { $case: "artifactUpdate", value: event.data } };
+      default:
+        assertUnreachableEvent(event);
+    }
+  }
+  /**
+   * Fire-and-forget push notification dispatch. Delivery must not block
+   * the stream or response; errors are logged but do not propagate. The
+   * sender silently skips stand-alone Messages that carry no task
+   * association (no push config can be registered for them).
+   */
+  async _sendPushNotificationIfNeeded(context, streamResponse, task) {
+    if (this.agentCard.capabilities?.pushNotifications && this.pushNotificationSender) {
+      this.pushNotificationSender.send(streamResponse, context, task).catch((error) => {
+        console.error(`Failed to send push notification:`, error);
+      });
+    }
+  }
+  async _handleProcessingError(error, resultManager, firstResultSent, taskId, firstResultRejector) {
+    if (firstResultRejector && !firstResultSent) {
+      firstResultRejector(error);
+      return;
+    }
+    if (!firstResultRejector) {
+      throw error;
+    }
+    const currentTask = resultManager.getCurrentTask();
+    const errorMessage = error instanceof Error && error.message || "Unknown error";
+    if (currentTask) {
+      const statusUpdateFailed = {
+        taskId: currentTask.id,
+        contextId: currentTask.contextId,
+        status: {
+          state: 4 /* TASK_STATE_FAILED */,
+          message: {
+            role: 2 /* ROLE_AGENT */,
+            messageId: crypto.randomUUID(),
+            taskId: currentTask.id,
+            contextId: currentTask.contextId,
+            parts: [
+              {
+                content: { $case: "text", value: `Event processing loop failed: ${errorMessage}` },
+                mediaType: "text/plain",
+                filename: "",
+                metadata: {}
+              }
+            ],
+            metadata: {},
+            extensions: [],
+            referenceTaskIds: []
+          },
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        metadata: {}
+      };
+      try {
+        await resultManager.processEvent(AgentEvent.statusUpdate(statusUpdateFailed));
+      } catch (error2) {
+        console.error(
+          `Event processing loop failed for task ${taskId}: ${error2 instanceof Error && error2.message || "Unknown error"}`
+        );
+      }
+    } else {
+      console.error(`Event processing loop failed for task ${taskId}: ${errorMessage}`);
+    }
+  }
+  /**
+   * Advances the stream pattern state based on the incoming event.
+   * Returns the (possibly transitioned) pattern; throws on invalid
+   * transitions.
+   */
+  _advanceStreamPattern(event, currentPattern) {
+    switch (currentPattern) {
+      case "undetermined" /* UNDETERMINED */:
+        if (event.kind === "message") return "message-only" /* MESSAGE_ONLY */;
+        if (event.kind === "task") return "task-lifecycle" /* TASK_LIFECYCLE */;
+        throw new UnsupportedOperationError(
+          `Received ${event.kind} before initial 'Message'/'Task' event.`
+        );
+      case "message-only" /* MESSAGE_ONLY */:
+        throw new UnsupportedOperationError(`Received ${event.kind} after message-only response.`);
+      case "task-lifecycle" /* TASK_LIFECYCLE */:
+        if (event.kind !== "statusUpdate" && event.kind !== "artifactUpdate")
+          throw new UnsupportedOperationError(
+            `Stream ordering violation: received ${event.kind} in task lifecycle stream.`
+          );
+        return currentPattern;
+    }
+  }
+  /**
+   * A missing or whitespace-only task ID is malformed input: reject it
+   * with `RequestMalformedError` (-32602 / HTTP 400) instead of letting
+   * the task store surface `TaskNotFoundError` (-32001 / HTTP 404).
+   */
+  _requireValidTaskId(taskId) {
+    if (!taskId || taskId.trim() === "") {
+      throw new RequestMalformedError("Task ID is required");
+    }
+  }
+  /**
+   * Applies `historyLength` semantics:
+   * - undefined: return all history
+   * - 0: omit history
+   * - N > 0: return at most N most recent messages
+   */
+  _applyHistoryLengthSemantics(task, params) {
+    if (params.historyLength !== void 0) {
+      if (params.historyLength <= 0) {
+        task.history = [];
+      } else {
+        task.history = (task.history ?? []).slice(-params.historyLength);
+      }
+    }
+  }
+};
+function trackLatestTaskState(bus) {
+  let lastState;
+  const listener = (event) => {
+    if (event.kind === "task" && event.data.status?.state !== void 0) {
+      lastState = event.data.status.state;
+    } else if (event.kind === "statusUpdate" && event.data.status?.state !== void 0) {
+      lastState = event.data.status.state;
+    }
+  };
+  bus.on("event", listener);
+  return () => {
+    bus.off("event", listener);
+    return lastState;
+  };
+}
+function trackLatestTaskAndState(bus) {
+  let lastTask;
+  let lastState;
+  const listener = (event) => {
+    if (event.kind === "task") {
+      lastTask = event.data;
+      if (event.data.status?.state !== void 0) {
+        lastState = event.data.status.state;
+      }
+    } else if (event.kind === "statusUpdate" && event.data.status?.state !== void 0) {
+      lastState = event.data.status.state;
+    }
+  };
+  bus.on("event", listener);
+  return () => {
+    bus.off("event", listener);
+    return { task: lastTask, state: lastState };
+  };
+}
+
+// src/server/store.ts
+var InMemoryTaskStore = class {
+  _scopedStore;
+  constructor(ownerResolver = resolveUserScope) {
+    this._scopedStore = new ScopedStore(ownerResolver);
+  }
+  async load(taskId, context) {
+    const entry = this._scopedStore.getBucket(context)?.get(taskId);
+    return entry ? structuredClone(entry) : void 0;
+  }
+  async save(task, context) {
+    this._scopedStore.getOrCreateBucket(context).set(task.id, structuredClone(task));
+  }
+  async list(params, context) {
+    const {
+      contextId,
+      status,
+      pageSize = DEFAULT_PAGE_SIZE,
+      pageToken,
+      statusTimestampAfter,
+      includeArtifacts = false
+    } = params;
+    const bucket = this._scopedStore.getBucket(context);
+    let tasks = bucket ? Array.from(bucket.values()) : [];
+    if (contextId) {
+      tasks = tasks.filter((task) => task.contextId === contextId);
+    }
+    if (status !== void 0 && status !== 0 /* TASK_STATE_UNSPECIFIED */) {
+      tasks = tasks.filter((task) => task.status?.state === status);
+    }
+    if (statusTimestampAfter) {
+      const filterTime = new Date(statusTimestampAfter).getTime();
+      tasks = tasks.filter(
+        (task) => task.status?.timestamp && new Date(task.status.timestamp).getTime() > filterTime
+      );
+    }
+    tasks.sort((taskA, taskB) => {
+      const timeA = taskA.status?.timestamp || "";
+      const timeB = taskB.status?.timestamp || "";
+      if (timeB !== timeA) {
+        return timeB.localeCompare(timeA);
+      }
+      return taskB.id.localeCompare(taskA.id);
+    });
+    const totalSize = tasks.length;
+    if (pageToken) {
+      try {
+        const decoded = Buffer.from(pageToken, "base64").toString("utf-8");
+        const [cursorTimestamp, ...idParts] = decoded.split("|");
+        if (idParts.length === 0) {
+          throw new RequestMalformedError("Invalid page token format.");
+        }
+        const cursorId = idParts.join("|");
+        const cursorIndex = tasks.findIndex(
+          (task) => (task.status?.timestamp || "") === cursorTimestamp && task.id === cursorId
+        );
+        if (cursorIndex !== -1) {
+          tasks = tasks.slice(cursorIndex + 1);
+        } else {
+          tasks = [];
+        }
+      } catch (e) {
+        if (e instanceof RequestMalformedError) throw e;
+        throw new RequestMalformedError("Token is not a valid base64-encoded cursor.");
+      }
+    }
+    const paginatedTasks = tasks.slice(0, pageSize);
+    const resultTasks = paginatedTasks.map((task) => {
+      const taskCopy = structuredClone(task);
+      if (!includeArtifacts) {
+        taskCopy.artifacts = [];
+      }
+      return taskCopy;
+    });
+    let nextPageToken = "";
+    if (paginatedTasks.length > 0 && tasks.length > paginatedTasks.length) {
+      const lastTask = paginatedTasks[paginatedTasks.length - 1];
+      const lastTime = lastTask.status?.timestamp || "";
+      nextPageToken = Buffer.from(`${lastTime}|${lastTask.id}`).toString("base64");
+    }
+    return {
+      tasks: resultTasks,
+      nextPageToken,
+      pageSize,
+      totalSize
+    };
+  }
+};
+
+// src/server/transports/list_tasks_serializer.ts
+function serializeListTasksResponse(response, options) {
+  const serialized = ListTasksResponse.toJSON(response);
+  const { tasks, nextPageToken, pageSize, totalSize, ...rest } = serialized;
+  const serializedTasks = tasks ?? [];
+  return {
+    tasks: options?.includeArtifacts ? serializedTasks.map(withMaterializedArtifacts) : serializedTasks,
+    nextPageToken: nextPageToken ?? "",
+    pageSize: pageSize ?? 0,
+    totalSize: totalSize ?? 0,
+    ...rest
+  };
+}
+function withMaterializedArtifacts(task) {
+  if (typeof task !== "object" || task === null) {
+    return task;
+  }
+  const serializedTask = task;
+  if (serializedTask.artifacts !== void 0) {
+    return serializedTask;
+  }
+  return { ...serializedTask, artifacts: [] };
+}
+
+// src/server/transports/jsonrpc/jsonrpc_transport_handler.ts
+var JsonRpcTransportHandler = class _JsonRpcTransportHandler {
+  requestHandler;
+  constructor(requestHandler) {
+    this.requestHandler = requestHandler;
+  }
+  async handle(requestBody, context) {
+    let rpcRequest = { jsonrpc: "2.0", method: "" };
+    try {
+      if (typeof requestBody === "string") {
+        rpcRequest = JSON.parse(requestBody);
+      } else if (typeof requestBody === "object" && requestBody !== null) {
+        rpcRequest = requestBody;
+      } else {
+        throw new RequestMalformedError("Invalid request body type.");
+      }
+      if (!this.isRequestValid(rpcRequest)) {
+        throw new RequestMalformedError("Invalid JSON-RPC Request.");
+      }
+    } catch (error) {
+      const mappedError = _JsonRpcTransportHandler.mapToJSONRPCError(
+        error instanceof SyntaxError ? new RequestMalformedError(error.message || "Failed to parse JSON request.") : error
+      );
+      return {
+        jsonrpc: "2.0",
+        id: rpcRequest.id ?? null,
+        error: mappedError
+      };
+    }
+    const { method, id: requestId = null } = rpcRequest;
+    try {
+      if (method !== "GetExtendedAgentCard" && !this.paramsAreValid(rpcRequest.params)) {
+        throw new RequestMalformedError(`Invalid method parameters.`);
+      }
+      const paramsTenant = rpcRequest.params?.tenant;
+      if (paramsTenant) {
+        context.setTenant(paramsTenant);
+      }
+      if (method === "SendStreamingMessage" || method === "SubscribeToTask") {
+        const params = rpcRequest.params;
+        const agentEventStream = method === "SendStreamingMessage" ? this.requestHandler.sendMessageStream(SendMessageRequest.fromJSON(params), context) : this.requestHandler.resubscribe(SubscribeToTaskRequest.fromJSON(params), context);
+        return (async function* jsonRpcEventStream() {
+          for await (const event of agentEventStream) {
+            yield {
+              jsonrpc: "2.0",
+              id: requestId,
+              result: StreamResponse.toJSON(event)
+            };
+          }
+        })();
+      } else {
+        let result;
+        switch (method) {
+          case "SendMessage": {
+            const messageOrTask = await this.requestHandler.sendMessage(
+              SendMessageRequest.fromJSON(rpcRequest.params),
+              context
+            );
+            result = "messageId" in messageOrTask ? { message: Message.toJSON(messageOrTask) } : { task: Task.toJSON(messageOrTask) };
+            break;
+          }
+          case "GetTask":
+            result = Task.toJSON(
+              await this.requestHandler.getTask(GetTaskRequest.fromJSON(rpcRequest.params), context)
+            );
+            break;
+          case "ListTasks": {
+            const listTasksRequest = ListTasksRequest.fromJSON(rpcRequest.params);
+            result = serializeListTasksResponse(
+              await this.requestHandler.listTasks(listTasksRequest, context),
+              { includeArtifacts: listTasksRequest.includeArtifacts }
+            );
+            break;
+          }
+          case "CancelTask":
+            result = Task.toJSON(
+              await this.requestHandler.cancelTask(
+                CancelTaskRequest.fromJSON(rpcRequest.params),
+                context
+              )
+            );
+            break;
+          case "CreateTaskPushNotificationConfig": {
+            result = TaskPushNotificationConfig.toJSON(
+              await this.requestHandler.createTaskPushNotificationConfig(
+                TaskPushNotificationConfig.fromJSON(rpcRequest.params),
+                context
+              )
+            );
+            break;
+          }
+          case "GetTaskPushNotificationConfig":
+            result = TaskPushNotificationConfig.toJSON(
+              await this.requestHandler.getTaskPushNotificationConfig(
+                GetTaskPushNotificationConfigRequest.fromJSON(rpcRequest.params),
+                context
+              )
+            );
+            break;
+          case "DeleteTaskPushNotificationConfig":
+            await this.requestHandler.deleteTaskPushNotificationConfig(
+              DeleteTaskPushNotificationConfigRequest.fromJSON(rpcRequest.params),
+              context
+            );
+            result = null;
+            break;
+          case "ListTaskPushNotificationConfigs":
+            result = ListTaskPushNotificationConfigsResponse.toJSON(
+              await this.requestHandler.listTaskPushNotificationConfigs(
+                ListTaskPushNotificationConfigsRequest.fromJSON(rpcRequest.params),
+                context
+              )
+            );
+            break;
+          case "GetExtendedAgentCard":
+            result = AgentCard.toJSON(
+              await this.requestHandler.getAuthenticatedExtendedAgentCard(
+                GetExtendedAgentCardRequest.fromJSON(rpcRequest.params ?? {}),
+                context
+              )
+            );
+            break;
+          default:
+            return {
+              jsonrpc: "2.0",
+              id: requestId,
+              error: { code: A2A_ERROR_CODE.METHOD_NOT_FOUND, message: "Invalid method." }
+            };
+        }
+        return {
+          jsonrpc: "2.0",
+          id: requestId,
+          result
+        };
+      }
+    } catch (error) {
+      return {
+        jsonrpc: "2.0",
+        id: requestId,
+        error: _JsonRpcTransportHandler.mapToJSONRPCError(error)
+      };
+    }
+  }
+  isRequestValid(rpcRequest) {
+    if (rpcRequest.jsonrpc !== "2.0") {
+      return false;
+    }
+    if ("id" in rpcRequest) {
+      const id = rpcRequest.id;
+      const isString = typeof id === "string";
+      const isInteger = typeof id === "number" && Number.isInteger(id);
+      const isNull = id === null;
+      if (!isString && !isInteger && !isNull) {
+        return false;
+      }
+    }
+    if (!rpcRequest.method || typeof rpcRequest.method !== "string") {
+      return false;
+    }
+    return true;
+  }
+  paramsAreValid(params) {
+    if (typeof params !== "object" || params === null || Array.isArray(params)) {
+      return false;
+    }
+    for (const key of Object.keys(params)) {
+      if (key === "") {
+        return false;
+      }
+    }
+    return true;
+  }
+  static mapToJSONRPCError(error) {
+    return toJsonRpcError(error);
+  }
+};
+
+// 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/authentication/user.ts
+var UnauthenticatedUser = class {
+  get isAuthenticated() {
+    return false;
+  }
+  get userName() {
+    return "";
+  }
+};
+export {
+  AgentEvent,
+  DefaultExecutionEventBus,
+  DefaultExecutionEventBusManager,
+  DefaultPushNotificationSender,
+  DefaultRequestHandler,
+  ExecutionEventQueue,
+  InMemoryPushNotificationStore,
+  InMemoryTaskStore,
+  JsonRpcTransportHandler,
+  RequestContext,
+  ResultManager,
+  STATE_HEADERS_KEY,
+  ServerCallContext,
+  UnauthenticatedUser,
+  V1PushNotificationSerializer,
+  assertUnreachableEvent,
+  defaultServerCallContextBuilder,
+  getSupportedVersions,
+  resolveUserScope,
+  validateVersion
+};