@a2a-js/sdk 0.3.10 → 0.3.11

package/dist/client/index.cjs

@@ -264,8 +264,8 @@ var JsonRpcTransport = class _JsonRpcTransport {
     }
     const rpcResponse = await httpResponse.json();
     if (rpcResponse.id !== requestId) {
-      console.error(
-        `CRITICAL: RPC response ID mismatch for method ${method}. Expected ${requestId}, got ${rpcResponse.id}.`
+      throw new Error(
+        `JSON-RPC response ID mismatch for method ${method}. Expected ${requestId}, got ${rpcResponse.id}.`
       );
     }
     if ("error" in rpcResponse) {
@@ -329,38 +329,31 @@ var JsonRpcTransport = class _JsonRpcTransport {
     if (!jsonData.trim()) {
       throw new Error("Attempted to process empty SSE event data.");
     }
+    let a2aStreamResponse;
     try {
-      const sseJsonRpcResponse = JSON.parse(jsonData);
-      const a2aStreamResponse = sseJsonRpcResponse;
-      if (a2aStreamResponse.id !== originalRequestId) {
-        console.warn(
-          `SSE Event's JSON-RPC response ID mismatch. Client request ID: ${originalRequestId}, event response ID: ${a2aStreamResponse.id}.`
-        );
-      }
-      if ("error" in a2aStreamResponse) {
-        const err = a2aStreamResponse.error;
-        throw new Error(
-          `SSE event contained an error: ${err.message} (Code: ${err.code}) Data: ${JSON.stringify(err.data || {})}`,
-          { cause: _JsonRpcTransport.mapToError(a2aStreamResponse) }
-        );
-      }
-      if (!("result" in a2aStreamResponse) || typeof a2aStreamResponse.result === "undefined") {
-        throw new Error(`SSE event JSON-RPC response is missing 'result' field. Data: ${jsonData}`);
-      }
-      return a2aStreamResponse.result;
+      a2aStreamResponse = JSON.parse(jsonData);
     } catch (e) {
-      if (e instanceof Error && (e.message.startsWith("SSE event contained an error") || e.message.startsWith("SSE event JSON-RPC response is missing 'result' field"))) {
-        throw e;
-      }
-      console.error(
-        "Failed to parse SSE event data string or unexpected JSON-RPC structure:",
-        jsonData,
-        e
+      throw new Error(
+        `Failed to parse SSE event data: "${jsonData.substring(0, 100)}...". Original error: ${e instanceof Error && e.message || "Unknown error"}`,
+        { cause: e }
       );
+    }
+    if (a2aStreamResponse.id !== originalRequestId) {
       throw new Error(
-        `Failed to parse SSE event data: "${jsonData.substring(0, 100)}...". Original error: ${e instanceof Error && e.message || "Unknown error"}`
+        `JSON-RPC response ID mismatch in SSE event. Expected ${originalRequestId}, got ${a2aStreamResponse.id}.`
       );
     }
+    if ("error" in a2aStreamResponse) {
+      const err = a2aStreamResponse.error;
+      throw new Error(
+        `SSE event contained an error: ${err.message} (Code: ${err.code}) Data: ${JSON.stringify(err.data || {})}`,
+        { cause: _JsonRpcTransport.mapToError(a2aStreamResponse) }
+      );
+    }
+    if (!("result" in a2aStreamResponse) || typeof a2aStreamResponse.result === "undefined") {
+      throw new Error(`SSE event JSON-RPC response is missing 'result' field. Data: ${jsonData}`);
+    }
+    return a2aStreamResponse.result;
   }
   static mapToError(response) {
     switch (response.error.code) {
@@ -833,586 +826,229 @@ function createAuthenticatingFetchWithRetry(fetchImpl, authHandler) {
   return authFetch;
 }
 
-// src/client/card-resolver.ts
-var DefaultAgentCardResolver = class {
-  constructor(options) {
-    this.options = options;
-  }
-  /**
-   * Fetches the agent card based on provided base URL and path.
-   * Path is selected in the following order:
-   * 1) path parameter
-   * 2) path from options
-   * 3) .well-known/agent-card.json
-   */
-  async resolve(baseUrl, path) {
-    const agentCardUrl = new URL(path ?? this.options?.path ?? AGENT_CARD_PATH, baseUrl);
-    const response = await this.fetchImpl(agentCardUrl);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch Agent Card from ${agentCardUrl}: ${response.status}`);
-    }
-    return await response.json();
-  }
-  fetchImpl(...args) {
-    if (this.options?.fetchImpl) {
-      return this.options.fetchImpl(...args);
-    }
-    return fetch(...args);
+// src/types/pb/a2a_types.ts
+function taskStateFromJSON(object) {
+  switch (object) {
+    case 0:
+    case "TASK_STATE_UNSPECIFIED":
+      return 0 /* TASK_STATE_UNSPECIFIED */;
+    case 1:
+    case "TASK_STATE_SUBMITTED":
+      return 1 /* TASK_STATE_SUBMITTED */;
+    case 2:
+    case "TASK_STATE_WORKING":
+      return 2 /* TASK_STATE_WORKING */;
+    case 3:
+    case "TASK_STATE_COMPLETED":
+      return 3 /* TASK_STATE_COMPLETED */;
+    case 4:
+    case "TASK_STATE_FAILED":
+      return 4 /* TASK_STATE_FAILED */;
+    case 5:
+    case "TASK_STATE_CANCELLED":
+      return 5 /* TASK_STATE_CANCELLED */;
+    case 6:
+    case "TASK_STATE_INPUT_REQUIRED":
+      return 6 /* TASK_STATE_INPUT_REQUIRED */;
+    case 7:
+    case "TASK_STATE_REJECTED":
+      return 7 /* TASK_STATE_REJECTED */;
+    case 8:
+    case "TASK_STATE_AUTH_REQUIRED":
+      return 8 /* TASK_STATE_AUTH_REQUIRED */;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return -1 /* UNRECOGNIZED */;
   }
-};
-var AgentCardResolver = {
-  default: new DefaultAgentCardResolver()
-};
-
-// src/client/multitransport-client.ts
-var Client = class {
-  constructor(transport, agentCard, config) {
-    this.transport = transport;
-    this.agentCard = agentCard;
-    this.config = config;
+}
+function taskStateToJSON(object) {
+  switch (object) {
+    case 0 /* TASK_STATE_UNSPECIFIED */:
+      return "TASK_STATE_UNSPECIFIED";
+    case 1 /* TASK_STATE_SUBMITTED */:
+      return "TASK_STATE_SUBMITTED";
+    case 2 /* TASK_STATE_WORKING */:
+      return "TASK_STATE_WORKING";
+    case 3 /* TASK_STATE_COMPLETED */:
+      return "TASK_STATE_COMPLETED";
+    case 4 /* TASK_STATE_FAILED */:
+      return "TASK_STATE_FAILED";
+    case 5 /* TASK_STATE_CANCELLED */:
+      return "TASK_STATE_CANCELLED";
+    case 6 /* TASK_STATE_INPUT_REQUIRED */:
+      return "TASK_STATE_INPUT_REQUIRED";
+    case 7 /* TASK_STATE_REJECTED */:
+      return "TASK_STATE_REJECTED";
+    case 8 /* TASK_STATE_AUTH_REQUIRED */:
+      return "TASK_STATE_AUTH_REQUIRED";
+    case -1 /* UNRECOGNIZED */:
+    default:
+      return "UNRECOGNIZED";
   }
-  /**
-   * If the current agent card supports the extended feature, it will try to fetch the extended agent card from the server,
-   * Otherwise it will return the current agent card value.
-   */
-  async getAgentCard(options) {
-    if (this.agentCard.supportsAuthenticatedExtendedCard) {
-      this.agentCard = await this.executeWithInterceptors(
-        { method: "getAgentCard" },
-        options,
-        (_, options2) => this.transport.getExtendedAgentCard(options2)
-      );
-    }
-    return this.agentCard;
+}
+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 */;
   }
-  /**
-   * Sends a message to an agent to initiate a new interaction or to continue an existing one.
-   * Uses blocking mode by default.
-   */
-  sendMessage(params, options) {
-    params = this.applyClientConfig({
-      params,
-      blocking: !(this.config?.polling ?? false)
-    });
-    return this.executeWithInterceptors(
-      { method: "sendMessage", value: params },
-      options,
-      this.transport.sendMessage.bind(this.transport)
-    );
+}
+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";
   }
-  /**
-   * Sends a message to an agent to initiate/continue a task AND subscribes the client to real-time updates for that task.
-   * Performs fallback to non-streaming if not supported by the agent.
-   */
-  async *sendMessageStream(params, options) {
-    const method = "sendMessageStream";
-    params = this.applyClientConfig({ params, blocking: true });
-    const beforeArgs = {
-      input: { method, value: params },
-      agentCard: this.agentCard,
-      options
+}
+var SendMessageConfiguration = {
+  fromJSON(object) {
+    return {
+      acceptedOutputModes: globalThis.Array.isArray(object?.acceptedOutputModes) ? object.acceptedOutputModes.map((e) => globalThis.String(e)) : globalThis.Array.isArray(object?.accepted_output_modes) ? object.accepted_output_modes.map(
+        (e) => globalThis.String(e)
+      ) : [],
+      pushNotification: isSet(object.pushNotification) ? PushNotificationConfig.fromJSON(object.pushNotification) : isSet(object.push_notification) ? PushNotificationConfig.fromJSON(object.push_notification) : void 0,
+      historyLength: isSet(object.historyLength) ? globalThis.Number(object.historyLength) : isSet(object.history_length) ? globalThis.Number(object.history_length) : 0,
+      blocking: isSet(object.blocking) ? globalThis.Boolean(object.blocking) : false
     };
-    const beforeResult = await this.interceptBefore(beforeArgs);
-    if (beforeResult) {
-      const earlyReturn = beforeResult.earlyReturn.value;
-      const afterArgs = {
-        result: { method, value: earlyReturn },
-        agentCard: this.agentCard,
-        options: beforeArgs.options
-      };
-      await this.interceptAfter(afterArgs, beforeResult.executed);
-      yield afterArgs.result.value;
-      return;
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.acceptedOutputModes?.length) {
+      obj.acceptedOutputModes = message.acceptedOutputModes;
     }
-    if (!this.agentCard.capabilities.streaming) {
-      const result = await this.transport.sendMessage(beforeArgs.input.value, beforeArgs.options);
-      const afterArgs = {
-        result: { method, value: result },
-        agentCard: this.agentCard,
-        options: beforeArgs.options
-      };
-      await this.interceptAfter(afterArgs);
-      yield afterArgs.result.value;
-      return;
+    if (message.pushNotification !== void 0) {
+      obj.pushNotification = PushNotificationConfig.toJSON(message.pushNotification);
     }
-    for await (const event of this.transport.sendMessageStream(
-      beforeArgs.input.value,
-      beforeArgs.options
-    )) {
-      const afterArgs = {
-        result: { method, value: event },
-        agentCard: this.agentCard,
-        options: beforeArgs.options
-      };
-      await this.interceptAfter(afterArgs);
-      yield afterArgs.result.value;
-      if (afterArgs.earlyReturn) {
-        return;
-      }
+    if (message.historyLength !== 0) {
+      obj.historyLength = Math.round(message.historyLength);
     }
-  }
-  /**
-   * Sets or updates the push notification configuration for a specified task.
-   * Requires the server to have AgentCard.capabilities.pushNotifications: true.
-   */
-  setTaskPushNotificationConfig(params, options) {
-    if (!this.agentCard.capabilities.pushNotifications) {
-      throw new PushNotificationNotSupportedError();
+    if (message.blocking !== false) {
+      obj.blocking = message.blocking;
     }
-    return this.executeWithInterceptors(
-      { method: "setTaskPushNotificationConfig", value: params },
-      options,
-      this.transport.setTaskPushNotificationConfig.bind(this.transport)
-    );
+    return obj;
   }
-  /**
-   * Retrieves the current push notification configuration for a specified task.
-   * Requires the server to have AgentCard.capabilities.pushNotifications: true.
-   */
-  getTaskPushNotificationConfig(params, options) {
-    if (!this.agentCard.capabilities.pushNotifications) {
-      throw new PushNotificationNotSupportedError();
-    }
-    return this.executeWithInterceptors(
-      { method: "getTaskPushNotificationConfig", value: params },
-      options,
-      this.transport.getTaskPushNotificationConfig.bind(this.transport)
-    );
-  }
-  /**
-   * Retrieves the associated push notification configurations for a specified task.
-   * Requires the server to have AgentCard.capabilities.pushNotifications: true.
-   */
-  listTaskPushNotificationConfig(params, options) {
-    if (!this.agentCard.capabilities.pushNotifications) {
-      throw new PushNotificationNotSupportedError();
-    }
-    return this.executeWithInterceptors(
-      { method: "listTaskPushNotificationConfig", value: params },
-      options,
-      this.transport.listTaskPushNotificationConfig.bind(this.transport)
-    );
-  }
-  /**
-   * Deletes an associated push notification configuration for a task.
-   */
-  deleteTaskPushNotificationConfig(params, options) {
-    return this.executeWithInterceptors(
-      { method: "deleteTaskPushNotificationConfig", value: params },
-      options,
-      this.transport.deleteTaskPushNotificationConfig.bind(this.transport)
-    );
-  }
-  /**
-   * Retrieves the current state (including status, artifacts, and optionally history) of a previously initiated task.
-   */
-  getTask(params, options) {
-    return this.executeWithInterceptors(
-      { method: "getTask", value: params },
-      options,
-      this.transport.getTask.bind(this.transport)
-    );
-  }
-  /**
-   * Requests the cancellation of an ongoing task. The server will attempt to cancel the task,
-   * but success is not guaranteed (e.g., the task might have already completed or failed, or cancellation might not be supported at its current stage).
-   */
-  cancelTask(params, options) {
-    return this.executeWithInterceptors(
-      { method: "cancelTask", value: params },
-      options,
-      this.transport.cancelTask.bind(this.transport)
-    );
-  }
-  /**
-   * Allows a client to reconnect to an updates stream for an ongoing task after a previous connection was interrupted.
-   */
-  async *resubscribeTask(params, options) {
-    const method = "resubscribeTask";
-    const beforeArgs = {
-      input: { method, value: params },
-      agentCard: this.agentCard,
-      options
+};
+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
     };
-    const beforeResult = await this.interceptBefore(beforeArgs);
-    if (beforeResult) {
-      const earlyReturn = beforeResult.earlyReturn.value;
-      const afterArgs = {
-        result: { method, value: earlyReturn },
-        agentCard: this.agentCard,
-        options: beforeArgs.options
-      };
-      await this.interceptAfter(afterArgs, beforeResult.executed);
-      yield afterArgs.result.value;
-      return;
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.id !== "") {
+      obj.id = message.id;
     }
-    for await (const event of this.transport.resubscribeTask(
-      beforeArgs.input.value,
-      beforeArgs.options
-    )) {
-      const afterArgs = {
-        result: { method, value: event },
-        agentCard: this.agentCard,
-        options: beforeArgs.options
-      };
-      await this.interceptAfter(afterArgs);
-      yield afterArgs.result.value;
-      if (afterArgs.earlyReturn) {
-        return;
-      }
+    if (message.contextId !== "") {
+      obj.contextId = message.contextId;
     }
-  }
-  applyClientConfig({
-    params,
-    blocking
-  }) {
-    const result = { ...params, configuration: params.configuration ?? {} };
-    if (!result.configuration.acceptedOutputModes && this.config?.acceptedOutputModes) {
-      result.configuration.acceptedOutputModes = this.config.acceptedOutputModes;
+    if (message.status !== void 0) {
+      obj.status = TaskStatus.toJSON(message.status);
     }
-    if (!result.configuration.pushNotificationConfig && this.config?.pushNotificationConfig) {
-      result.configuration.pushNotificationConfig = this.config.pushNotificationConfig;
+    if (message.artifacts?.length) {
+      obj.artifacts = message.artifacts.map((e) => Artifact.toJSON(e));
     }
-    result.configuration.blocking ??= blocking;
-    return result;
+    if (message.history?.length) {
+      obj.history = message.history.map((e) => Message.toJSON(e));
+    }
+    if (message.metadata !== void 0) {
+      obj.metadata = message.metadata;
+    }
+    return obj;
   }
-  async executeWithInterceptors(input, options, transportCall) {
-    const beforeArgs = {
-      input,
-      agentCard: this.agentCard,
-      options
+};
+var TaskStatus = {
+  fromJSON(object) {
+    return {
+      state: isSet(object.state) ? taskStateFromJSON(object.state) : 0,
+      update: isSet(object.message) ? Message.fromJSON(object.message) : isSet(object.update) ? Message.fromJSON(object.update) : void 0,
+      timestamp: isSet(object.timestamp) ? globalThis.String(object.timestamp) : void 0
     };
-    const beforeResult = await this.interceptBefore(beforeArgs);
-    if (beforeResult) {
-      const afterArgs2 = {
-        result: {
-          method: input.method,
-          value: beforeResult.earlyReturn.value
-        },
-        agentCard: this.agentCard,
-        options: beforeArgs.options
-      };
-      await this.interceptAfter(afterArgs2, beforeResult.executed);
-      return afterArgs2.result.value;
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.state !== 0) {
+      obj.state = taskStateToJSON(message.state);
     }
-    const result = await transportCall(beforeArgs.input.value, beforeArgs.options);
-    const afterArgs = {
-      result: { method: input.method, value: result },
-      agentCard: this.agentCard,
-      options: beforeArgs.options
-    };
-    await this.interceptAfter(afterArgs);
-    return afterArgs.result.value;
-  }
-  async interceptBefore(args) {
-    if (!this.config?.interceptors || this.config.interceptors.length === 0) {
-      return;
+    if (message.update !== void 0) {
+      obj.message = Message.toJSON(message.update);
     }
-    const executed = [];
-    for (const interceptor of this.config.interceptors) {
-      await interceptor.before(args);
-      executed.push(interceptor);
-      if (args.earlyReturn) {
-        return {
-          earlyReturn: args.earlyReturn,
-          executed
-        };
-      }
+    if (message.timestamp !== void 0) {
+      obj.timestamp = message.timestamp;
     }
+    return obj;
   }
-  async interceptAfter(args, interceptors) {
-    const reversedInterceptors = [...interceptors ?? this.config?.interceptors ?? []].reverse();
-    for (const interceptor of reversedInterceptors) {
-      await interceptor.after(args);
-      if (args.earlyReturn) {
-        return;
-      }
+};
+var Part = {
+  fromJSON(object) {
+    return {
+      part: isSet(object.text) ? { $case: "text", value: globalThis.String(object.text) } : isSet(object.file) ? { $case: "file", value: FilePart.fromJSON(object.file) } : isSet(object.data) ? { $case: "data", value: DataPart.fromJSON(object.data) } : void 0
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.part?.$case === "text") {
+      obj.text = message.part.value;
+    } else if (message.part?.$case === "file") {
+      obj.file = FilePart.toJSON(message.part.value);
+    } else if (message.part?.$case === "data") {
+      obj.data = DataPart.toJSON(message.part.value);
     }
+    return obj;
   }
 };
-
-// src/server/error.ts
-var A2AError = class _A2AError extends Error {
-  code;
-  data;
-  taskId;
-  // Optional task ID context
-  constructor(code, message, data, taskId) {
-    super(message);
-    this.name = "A2AError";
-    this.code = code;
-    this.data = data;
-    this.taskId = taskId;
-  }
-  /**
-   * Formats the error into a standard JSON-RPC error object structure.
-   */
-  toJSONRPCError() {
-    const errorObject = {
-      code: this.code,
-      message: this.message
+var FilePart = {
+  fromJSON(object) {
+    return {
+      file: isSet(object.fileWithUri) ? { $case: "fileWithUri", value: globalThis.String(object.fileWithUri) } : isSet(object.file_with_uri) ? { $case: "fileWithUri", value: globalThis.String(object.file_with_uri) } : isSet(object.fileWithBytes) ? { $case: "fileWithBytes", value: Buffer.from(bytesFromBase64(object.fileWithBytes)) } : isSet(object.file_with_bytes) ? { $case: "fileWithBytes", value: Buffer.from(bytesFromBase64(object.file_with_bytes)) } : void 0,
+      mimeType: isSet(object.mimeType) ? globalThis.String(object.mimeType) : isSet(object.mime_type) ? globalThis.String(object.mime_type) : ""
     };
-    if (this.data !== void 0) {
-      errorObject.data = this.data;
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.file?.$case === "fileWithUri") {
+      obj.fileWithUri = message.file.value;
+    } else if (message.file?.$case === "fileWithBytes") {
+      obj.fileWithBytes = base64FromBytes(message.file.value);
     }
-    return errorObject;
+    if (message.mimeType !== "") {
+      obj.mimeType = message.mimeType;
+    }
+    return obj;
   }
-  // Static factory methods for common errors
-  static parseError(message, data) {
-    return new _A2AError(-32700, message, data);
-  }
-  static invalidRequest(message, data) {
-    return new _A2AError(-32600, message, data);
-  }
-  static methodNotFound(method) {
-    return new _A2AError(-32601, `Method not found: ${method}`);
-  }
-  static invalidParams(message, data) {
-    return new _A2AError(-32602, message, data);
-  }
-  static internalError(message, data) {
-    return new _A2AError(-32603, message, data);
-  }
-  static taskNotFound(taskId) {
-    return new _A2AError(-32001, `Task not found: ${taskId}`, void 0, taskId);
-  }
-  static taskNotCancelable(taskId) {
-    return new _A2AError(-32002, `Task not cancelable: ${taskId}`, void 0, taskId);
-  }
-  static pushNotificationNotSupported() {
-    return new _A2AError(-32003, "Push Notification is not supported");
-  }
-  static unsupportedOperation(operation) {
-    return new _A2AError(-32004, `Unsupported operation: ${operation}`);
-  }
-  static authenticatedExtendedCardNotConfigured() {
-    return new _A2AError(-32007, `Extended card not configured.`);
-  }
-};
-
-// src/types/pb/a2a_types.ts
-function taskStateFromJSON(object) {
-  switch (object) {
-    case 0:
-    case "TASK_STATE_UNSPECIFIED":
-      return 0 /* TASK_STATE_UNSPECIFIED */;
-    case 1:
-    case "TASK_STATE_SUBMITTED":
-      return 1 /* TASK_STATE_SUBMITTED */;
-    case 2:
-    case "TASK_STATE_WORKING":
-      return 2 /* TASK_STATE_WORKING */;
-    case 3:
-    case "TASK_STATE_COMPLETED":
-      return 3 /* TASK_STATE_COMPLETED */;
-    case 4:
-    case "TASK_STATE_FAILED":
-      return 4 /* TASK_STATE_FAILED */;
-    case 5:
-    case "TASK_STATE_CANCELLED":
-      return 5 /* TASK_STATE_CANCELLED */;
-    case 6:
-    case "TASK_STATE_INPUT_REQUIRED":
-      return 6 /* TASK_STATE_INPUT_REQUIRED */;
-    case 7:
-    case "TASK_STATE_REJECTED":
-      return 7 /* TASK_STATE_REJECTED */;
-    case 8:
-    case "TASK_STATE_AUTH_REQUIRED":
-      return 8 /* TASK_STATE_AUTH_REQUIRED */;
-    case -1:
-    case "UNRECOGNIZED":
-    default:
-      return -1 /* UNRECOGNIZED */;
-  }
-}
-function taskStateToJSON(object) {
-  switch (object) {
-    case 0 /* TASK_STATE_UNSPECIFIED */:
-      return "TASK_STATE_UNSPECIFIED";
-    case 1 /* TASK_STATE_SUBMITTED */:
-      return "TASK_STATE_SUBMITTED";
-    case 2 /* TASK_STATE_WORKING */:
-      return "TASK_STATE_WORKING";
-    case 3 /* TASK_STATE_COMPLETED */:
-      return "TASK_STATE_COMPLETED";
-    case 4 /* TASK_STATE_FAILED */:
-      return "TASK_STATE_FAILED";
-    case 5 /* TASK_STATE_CANCELLED */:
-      return "TASK_STATE_CANCELLED";
-    case 6 /* TASK_STATE_INPUT_REQUIRED */:
-      return "TASK_STATE_INPUT_REQUIRED";
-    case 7 /* TASK_STATE_REJECTED */:
-      return "TASK_STATE_REJECTED";
-    case 8 /* TASK_STATE_AUTH_REQUIRED */:
-      return "TASK_STATE_AUTH_REQUIRED";
-    case -1 /* UNRECOGNIZED */:
-    default:
-      return "UNRECOGNIZED";
-  }
-}
-function roleFromJSON(object) {
-  switch (object) {
-    case 0:
-    case "ROLE_UNSPECIFIED":
-      return 0 /* ROLE_UNSPECIFIED */;
-    case 1:
-    case "ROLE_USER":
-      return 1 /* ROLE_USER */;
-    case 2:
-    case "ROLE_AGENT":
-      return 2 /* ROLE_AGENT */;
-    case -1:
-    case "UNRECOGNIZED":
-    default:
-      return -1 /* UNRECOGNIZED */;
-  }
-}
-function roleToJSON(object) {
-  switch (object) {
-    case 0 /* ROLE_UNSPECIFIED */:
-      return "ROLE_UNSPECIFIED";
-    case 1 /* ROLE_USER */:
-      return "ROLE_USER";
-    case 2 /* ROLE_AGENT */:
-      return "ROLE_AGENT";
-    case -1 /* UNRECOGNIZED */:
-    default:
-      return "UNRECOGNIZED";
-  }
-}
-var SendMessageConfiguration = {
-  fromJSON(object) {
-    return {
-      acceptedOutputModes: globalThis.Array.isArray(object?.acceptedOutputModes) ? object.acceptedOutputModes.map((e) => globalThis.String(e)) : globalThis.Array.isArray(object?.accepted_output_modes) ? object.accepted_output_modes.map(
-        (e) => globalThis.String(e)
-      ) : [],
-      pushNotification: isSet(object.pushNotification) ? PushNotificationConfig.fromJSON(object.pushNotification) : isSet(object.push_notification) ? PushNotificationConfig.fromJSON(object.push_notification) : void 0,
-      historyLength: isSet(object.historyLength) ? globalThis.Number(object.historyLength) : isSet(object.history_length) ? globalThis.Number(object.history_length) : 0,
-      blocking: isSet(object.blocking) ? globalThis.Boolean(object.blocking) : false
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.acceptedOutputModes?.length) {
-      obj.acceptedOutputModes = message.acceptedOutputModes;
-    }
-    if (message.pushNotification !== void 0) {
-      obj.pushNotification = PushNotificationConfig.toJSON(message.pushNotification);
-    }
-    if (message.historyLength !== 0) {
-      obj.historyLength = Math.round(message.historyLength);
-    }
-    if (message.blocking !== false) {
-      obj.blocking = message.blocking;
-    }
-    return obj;
-  }
-};
-var Task = {
-  fromJSON(object) {
-    return {
-      id: isSet(object.id) ? globalThis.String(object.id) : "",
-      contextId: isSet(object.contextId) ? globalThis.String(object.contextId) : isSet(object.context_id) ? globalThis.String(object.context_id) : "",
-      status: isSet(object.status) ? TaskStatus.fromJSON(object.status) : void 0,
-      artifacts: globalThis.Array.isArray(object?.artifacts) ? object.artifacts.map((e) => Artifact.fromJSON(e)) : [],
-      history: globalThis.Array.isArray(object?.history) ? object.history.map((e) => Message.fromJSON(e)) : [],
-      metadata: isObject(object.metadata) ? object.metadata : void 0
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.id !== "") {
-      obj.id = message.id;
-    }
-    if (message.contextId !== "") {
-      obj.contextId = message.contextId;
-    }
-    if (message.status !== void 0) {
-      obj.status = TaskStatus.toJSON(message.status);
-    }
-    if (message.artifacts?.length) {
-      obj.artifacts = message.artifacts.map((e) => Artifact.toJSON(e));
-    }
-    if (message.history?.length) {
-      obj.history = message.history.map((e) => Message.toJSON(e));
-    }
-    if (message.metadata !== void 0) {
-      obj.metadata = message.metadata;
-    }
-    return obj;
-  }
-};
-var TaskStatus = {
-  fromJSON(object) {
-    return {
-      state: isSet(object.state) ? taskStateFromJSON(object.state) : 0,
-      update: isSet(object.message) ? Message.fromJSON(object.message) : isSet(object.update) ? Message.fromJSON(object.update) : void 0,
-      timestamp: isSet(object.timestamp) ? globalThis.String(object.timestamp) : void 0
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.state !== 0) {
-      obj.state = taskStateToJSON(message.state);
-    }
-    if (message.update !== void 0) {
-      obj.message = Message.toJSON(message.update);
-    }
-    if (message.timestamp !== void 0) {
-      obj.timestamp = message.timestamp;
-    }
-    return obj;
-  }
-};
-var Part = {
-  fromJSON(object) {
-    return {
-      part: isSet(object.text) ? { $case: "text", value: globalThis.String(object.text) } : isSet(object.file) ? { $case: "file", value: FilePart.fromJSON(object.file) } : isSet(object.data) ? { $case: "data", value: DataPart.fromJSON(object.data) } : void 0
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.part?.$case === "text") {
-      obj.text = message.part.value;
-    } else if (message.part?.$case === "file") {
-      obj.file = FilePart.toJSON(message.part.value);
-    } else if (message.part?.$case === "data") {
-      obj.data = DataPart.toJSON(message.part.value);
-    }
-    return obj;
-  }
-};
-var FilePart = {
-  fromJSON(object) {
-    return {
-      file: isSet(object.fileWithUri) ? { $case: "fileWithUri", value: globalThis.String(object.fileWithUri) } : isSet(object.file_with_uri) ? { $case: "fileWithUri", value: globalThis.String(object.file_with_uri) } : isSet(object.fileWithBytes) ? { $case: "fileWithBytes", value: Buffer.from(bytesFromBase64(object.fileWithBytes)) } : isSet(object.file_with_bytes) ? { $case: "fileWithBytes", value: Buffer.from(bytesFromBase64(object.file_with_bytes)) } : void 0,
-      mimeType: isSet(object.mimeType) ? globalThis.String(object.mimeType) : isSet(object.mime_type) ? globalThis.String(object.mime_type) : ""
-    };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.file?.$case === "fileWithUri") {
-      obj.fileWithUri = message.file.value;
-    } else if (message.file?.$case === "fileWithBytes") {
-      obj.fileWithBytes = base64FromBytes(message.file.value);
-    }
-    if (message.mimeType !== "") {
-      obj.mimeType = message.mimeType;
-    }
-    return obj;
-  }
-};
-var DataPart = {
-  fromJSON(object) {
-    return { data: isObject(object.data) ? object.data : void 0 };
-  },
-  toJSON(message) {
-    const obj = {};
-    if (message.data !== void 0) {
-      obj.data = message.data;
-    }
-    return obj;
+};
+var DataPart = {
+  fromJSON(object) {
+    return { data: isObject(object.data) ? object.data : void 0 };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.data !== void 0) {
+      obj.data = message.data;
+    }
+    return obj;
   }
 };
 var Message = {
@@ -2268,10 +1904,69 @@ function isSet(value) {
   return value !== null && value !== void 0;
 }
 
-// src/types/converters/id_decoding.ts
-var CONFIG_REGEX = /^tasks\/([^/]+)\/pushNotificationConfigs\/([^/]+)$/;
-var TASK_ONLY_REGEX = /^tasks\/([^/]+)(?:\/|$)/;
-var extractTaskId = (name) => {
+// src/server/error.ts
+var A2AError = class _A2AError extends Error {
+  code;
+  data;
+  taskId;
+  // Optional task ID context
+  constructor(code, message, data, taskId) {
+    super(message);
+    this.name = "A2AError";
+    this.code = code;
+    this.data = data;
+    this.taskId = taskId;
+  }
+  /**
+   * Formats the error into a standard JSON-RPC error object structure.
+   */
+  toJSONRPCError() {
+    const errorObject = {
+      code: this.code,
+      message: this.message
+    };
+    if (this.data !== void 0) {
+      errorObject.data = this.data;
+    }
+    return errorObject;
+  }
+  // Static factory methods for common errors
+  static parseError(message, data) {
+    return new _A2AError(-32700, message, data);
+  }
+  static invalidRequest(message, data) {
+    return new _A2AError(-32600, message, data);
+  }
+  static methodNotFound(method) {
+    return new _A2AError(-32601, `Method not found: ${method}`);
+  }
+  static invalidParams(message, data) {
+    return new _A2AError(-32602, message, data);
+  }
+  static internalError(message, data) {
+    return new _A2AError(-32603, message, data);
+  }
+  static taskNotFound(taskId) {
+    return new _A2AError(-32001, `Task not found: ${taskId}`, void 0, taskId);
+  }
+  static taskNotCancelable(taskId) {
+    return new _A2AError(-32002, `Task not cancelable: ${taskId}`, void 0, taskId);
+  }
+  static pushNotificationNotSupported() {
+    return new _A2AError(-32003, "Push Notification is not supported");
+  }
+  static unsupportedOperation(operation) {
+    return new _A2AError(-32004, `Unsupported operation: ${operation}`);
+  }
+  static authenticatedExtendedCardNotConfigured() {
+    return new _A2AError(-32007, `Extended card not configured.`);
+  }
+};
+
+// src/types/converters/id_decoding.ts
+var CONFIG_REGEX = /^tasks\/([^/]+)\/pushNotificationConfigs\/([^/]+)$/;
+var TASK_ONLY_REGEX = /^tasks\/([^/]+)(?:\/|$)/;
+var extractTaskId = (name) => {
   const match = name.match(TASK_ONLY_REGEX);
   if (!match) {
     throw A2AError.invalidParams(`Invalid or missing task ID in: "${name}"`);
@@ -2292,237 +1987,84 @@ var generatePushNotificationConfigName = (taskId, configId) => {
   return `tasks/${taskId}/pushNotificationConfigs/${configId}`;
 };
 
-// src/types/converters/to_proto.ts
-var ToProto = class _ToProto {
-  static agentCard(agentCard) {
+// src/types/converters/from_proto.ts
+var FromProto = class _FromProto {
+  static taskQueryParams(request) {
     return {
-      protocolVersion: agentCard.protocolVersion,
-      name: agentCard.name,
-      description: agentCard.description,
-      url: agentCard.url,
-      preferredTransport: agentCard.preferredTransport ?? "",
-      additionalInterfaces: agentCard.additionalInterfaces?.map((i) => _ToProto.agentInterface(i)) ?? [],
-      provider: _ToProto.agentProvider(agentCard.provider),
-      version: agentCard.version,
-      documentationUrl: agentCard.documentationUrl ?? "",
-      capabilities: _ToProto.agentCapabilities(agentCard.capabilities),
-      securitySchemes: agentCard.securitySchemes ? Object.fromEntries(
-        Object.entries(agentCard.securitySchemes).map(([key, value]) => [
-          key,
-          _ToProto.securityScheme(value)
-        ])
-      ) : {},
-      security: agentCard.security?.map((s) => _ToProto.security(s)) ?? [],
-      defaultInputModes: agentCard.defaultInputModes,
-      defaultOutputModes: agentCard.defaultOutputModes,
-      skills: agentCard.skills.map((s) => _ToProto.agentSkill(s)),
-      supportsAuthenticatedExtendedCard: agentCard.supportsAuthenticatedExtendedCard,
-      signatures: agentCard.signatures?.map((s) => _ToProto.agentCardSignature(s)) ?? []
+      id: extractTaskId(request.name),
+      historyLength: request.historyLength
     };
   }
-  static agentCardSignature(signatures) {
+  static taskIdParams(request) {
     return {
-      protected: signatures.protected,
-      signature: signatures.signature,
-      header: signatures.header
+      id: extractTaskId(request.name)
     };
   }
-  static agentSkill(skill) {
+  static getTaskPushNotificationConfigParams(request) {
+    const { taskId, configId } = extractTaskAndPushNotificationConfigId(request.name);
     return {
-      id: skill.id,
-      name: skill.name,
-      description: skill.description,
-      tags: skill.tags ?? [],
-      examples: skill.examples ?? [],
-      inputModes: skill.inputModes ?? [],
-      outputModes: skill.outputModes ?? [],
-      security: skill.security ? skill.security.map((s) => _ToProto.security(s)) : []
+      id: taskId,
+      pushNotificationConfigId: configId
     };
   }
-  static security(security) {
+  static listTaskPushNotificationConfigParams(request) {
     return {
-      schemes: Object.fromEntries(
-        Object.entries(security).map(([key, value]) => {
-          return [key, { list: value }];
-        })
-      )
+      id: extractTaskId(request.parent)
     };
   }
-  static securityScheme(scheme) {
-    switch (scheme.type) {
-      case "apiKey":
-        return {
-          scheme: {
-            $case: "apiKeySecurityScheme",
-            value: {
-              name: scheme.name,
-              location: scheme.in,
-              description: scheme.description ?? ""
-            }
-          }
-        };
-      case "http":
-        return {
-          scheme: {
-            $case: "httpAuthSecurityScheme",
-            value: {
-              description: scheme.description ?? "",
-              scheme: scheme.scheme,
-              bearerFormat: scheme.bearerFormat ?? ""
-            }
-          }
-        };
-      case "mutualTLS":
-        return {
-          scheme: {
-            $case: "mtlsSecurityScheme",
-            value: {
-              description: scheme.description ?? ""
-            }
-          }
-        };
-      case "oauth2":
-        return {
-          scheme: {
-            $case: "oauth2SecurityScheme",
-            value: {
-              description: scheme.description ?? "",
-              flows: _ToProto.oauthFlows(scheme.flows),
-              oauth2MetadataUrl: scheme.oauth2MetadataUrl ?? ""
-            }
-          }
-        };
-      case "openIdConnect":
-        return {
-          scheme: {
-            $case: "openIdConnectSecurityScheme",
-            value: {
-              description: scheme.description ?? "",
-              openIdConnectUrl: scheme.openIdConnectUrl
-            }
-          }
-        };
-      default:
-        throw A2AError.internalError(`Unsupported security scheme type`);
-    }
-  }
-  static oauthFlows(flows) {
-    if (flows.implicit) {
-      return {
-        flow: {
-          $case: "implicit",
-          value: {
-            authorizationUrl: flows.implicit.authorizationUrl,
-            scopes: flows.implicit.scopes,
-            refreshUrl: flows.implicit.refreshUrl ?? ""
-          }
-        }
-      };
-    } else if (flows.password) {
-      return {
-        flow: {
-          $case: "password",
-          value: {
-            tokenUrl: flows.password.tokenUrl,
-            scopes: flows.password.scopes,
-            refreshUrl: flows.password.refreshUrl ?? ""
-          }
-        }
-      };
-    } else if (flows.clientCredentials) {
-      return {
-        flow: {
-          $case: "clientCredentials",
-          value: {
-            tokenUrl: flows.clientCredentials.tokenUrl,
-            scopes: flows.clientCredentials.scopes,
-            refreshUrl: flows.clientCredentials.refreshUrl ?? ""
-          }
-        }
-      };
-    } else if (flows.authorizationCode) {
-      return {
-        flow: {
-          $case: "authorizationCode",
-          value: {
-            authorizationUrl: flows.authorizationCode.authorizationUrl,
-            tokenUrl: flows.authorizationCode.tokenUrl,
-            scopes: flows.authorizationCode.scopes,
-            refreshUrl: flows.authorizationCode.refreshUrl ?? ""
-          }
-        }
-      };
-    } else {
-      throw A2AError.internalError(`Unsupported OAuth flows`);
+  static createTaskPushNotificationConfig(request) {
+    if (!request.config?.pushNotificationConfig) {
+      throw A2AError.invalidParams(
+        "Request must include a `config` object with a `pushNotificationConfig`"
+      );
     }
-  }
-  static agentInterface(agentInterface) {
     return {
-      transport: agentInterface.transport,
-      url: agentInterface.url
+      taskId: extractTaskId(request.parent),
+      pushNotificationConfig: _FromProto.pushNotificationConfig(
+        request.config.pushNotificationConfig
+      )
     };
   }
-  static agentProvider(agentProvider) {
-    if (!agentProvider) {
-      return void 0;
-    }
+  static deleteTaskPushNotificationConfigParams(request) {
+    const { taskId, configId } = extractTaskAndPushNotificationConfigId(request.name);
     return {
-      url: agentProvider.url,
-      organization: agentProvider.organization
+      id: taskId,
+      pushNotificationConfigId: configId
     };
   }
-  static agentCapabilities(capabilities) {
+  static message(message) {
+    if (!message) {
+      return void 0;
+    }
     return {
-      streaming: capabilities.streaming,
-      pushNotifications: capabilities.pushNotifications,
-      extensions: capabilities.extensions ? capabilities.extensions.map((e) => _ToProto.agentExtension(e)) : []
-    };
-  }
-  static agentExtension(extension) {
-    return {
-      uri: extension.uri,
-      description: extension.description ?? "",
-      required: extension.required ?? false,
-      params: extension.params
-    };
-  }
-  static listTaskPushNotificationConfig(config) {
-    return {
-      configs: config.map((c) => _ToProto.taskPushNotificationConfig(c)),
-      nextPageToken: ""
-    };
-  }
-  static getTaskPushNotificationConfigParams(config) {
-    return {
-      name: generatePushNotificationConfigName(config.id, config.pushNotificationConfigId)
-    };
-  }
-  static listTaskPushNotificationConfigParams(config) {
-    return {
-      parent: generateTaskName(config.id),
-      pageToken: "",
-      pageSize: 0
-    };
-  }
-  static deleteTaskPushNotificationConfigParams(config) {
-    return {
-      name: generatePushNotificationConfigName(config.id, config.pushNotificationConfigId)
+      kind: "message",
+      messageId: message.messageId,
+      parts: message.content.map((p) => _FromProto.part(p)),
+      contextId: message.contextId || void 0,
+      taskId: message.taskId || void 0,
+      role: _FromProto.role(message.role),
+      metadata: message.metadata,
+      extensions: message.extensions
     };
   }
-  static taskPushNotificationConfig(config) {
-    return {
-      name: generatePushNotificationConfigName(
-        config.taskId,
-        config.pushNotificationConfig.id ?? ""
-      ),
-      pushNotificationConfig: _ToProto.pushNotificationConfig(config.pushNotificationConfig)
-    };
+  static role(role) {
+    switch (role) {
+      case 2 /* ROLE_AGENT */:
+        return "agent";
+      case 1 /* ROLE_USER */:
+        return "user";
+      default:
+        throw A2AError.invalidParams(`Invalid role: ${role}`);
+    }
   }
-  static taskPushNotificationConfigCreate(config) {
+  static messageSendConfiguration(configuration) {
+    if (!configuration) {
+      return void 0;
+    }
     return {
-      parent: generateTaskName(config.taskId),
-      config: _ToProto.taskPushNotificationConfig(config),
-      configId: config.pushNotificationConfig.id
+      blocking: configuration.blocking,
+      acceptedOutputModes: configuration.acceptedOutputModes,
+      pushNotificationConfig: _FromProto.pushNotificationConfig(configuration.pushNotification)
     };
   }
   static pushNotificationConfig(config) {
@@ -2530,10 +2072,10 @@ var ToProto = class _ToProto {
       return void 0;
     }
     return {
-      id: config.id ?? "",
+      id: config.id,
       url: config.url,
-      token: config.token ?? "",
-      authentication: _ToProto.pushNotificationAuthenticationInfo(config.authentication)
+      token: config.token || void 0,
+      authentication: _FromProto.pushNotificationAuthenticationInfo(config.authentication)
     };
   }
   static pushNotificationAuthenticationInfo(authInfo) {
@@ -2542,302 +2084,888 @@ var ToProto = class _ToProto {
     }
     return {
       schemes: authInfo.schemes,
-      credentials: authInfo.credentials ?? ""
+      credentials: authInfo.credentials
     };
   }
-  static messageStreamResult(event) {
-    if (event.kind === "message") {
-      return {
-        payload: {
-          $case: "msg",
-          value: _ToProto.message(event)
-        }
-      };
-    } else if (event.kind === "task") {
-      return {
-        payload: {
-          $case: "task",
-          value: _ToProto.task(event)
-        }
-      };
-    } else if (event.kind === "status-update") {
+  static part(part) {
+    if (part.part?.$case === "text") {
       return {
-        payload: {
-          $case: "statusUpdate",
-          value: _ToProto.taskStatusUpdateEvent(event)
-        }
+        kind: "text",
+        text: part.part.value
       };
-    } else if (event.kind === "artifact-update") {
+    }
+    if (part.part?.$case === "file") {
+      const filePart = part.part.value;
+      if (filePart.file?.$case === "fileWithUri") {
+        return {
+          kind: "file",
+          file: {
+            uri: filePart.file.value,
+            mimeType: filePart.mimeType
+          }
+        };
+      } else if (filePart.file?.$case === "fileWithBytes") {
+        return {
+          kind: "file",
+          file: {
+            bytes: filePart.file.value.toString("base64"),
+            mimeType: filePart.mimeType
+          }
+        };
+      }
+      throw A2AError.invalidParams("Invalid file part type");
+    }
+    if (part.part?.$case === "data") {
       return {
-        payload: {
-          $case: "artifactUpdate",
-          value: _ToProto.taskArtifactUpdateEvent(event)
-        }
+        kind: "data",
+        data: part.part.value.data
       };
-    } else {
-      throw A2AError.internalError("Invalid event type");
     }
+    throw A2AError.invalidParams("Invalid part type");
   }
-  static taskStatusUpdateEvent(event) {
+  static messageSendParams(request) {
     return {
-      taskId: event.taskId,
-      status: _ToProto.taskStatus(event.status),
-      contextId: event.contextId,
-      metadata: event.metadata,
-      final: event.final
+      message: _FromProto.message(request.request),
+      configuration: _FromProto.messageSendConfiguration(request.configuration),
+      metadata: request.metadata
     };
   }
-  static taskArtifactUpdateEvent(event) {
+  static sendMessageResult(response) {
+    if (response.payload?.$case === "task") {
+      return _FromProto.task(response.payload.value);
+    } else if (response.payload?.$case === "msg") {
+      return _FromProto.message(response.payload.value);
+    }
+    throw A2AError.invalidParams("Invalid SendMessageResponse: missing result");
+  }
+  static task(task) {
     return {
-      taskId: event.taskId,
-      artifact: _ToProto.artifact(event.artifact),
-      contextId: event.contextId,
-      metadata: event.metadata,
-      append: event.append,
-      lastChunk: event.lastChunk
+      kind: "task",
+      id: task.id,
+      status: _FromProto.taskStatus(task.status),
+      contextId: task.contextId,
+      artifacts: task.artifacts?.map((a) => _FromProto.artifact(a)),
+      history: task.history?.map((h) => _FromProto.message(h)),
+      metadata: task.metadata
     };
   }
-  static messageSendResult(params) {
-    if (params.kind === "message") {
-      return {
-        payload: {
-          $case: "msg",
-          value: _ToProto.message(params)
-        }
-      };
-    } else if (params.kind === "task") {
-      return {
-        payload: {
-          $case: "task",
-          value: _ToProto.task(params)
-        }
-      };
-    }
+  static taskStatus(status) {
+    return {
+      message: _FromProto.message(status.update),
+      state: _FromProto.taskState(status.state),
+      timestamp: status.timestamp
+    };
   }
-  static message(message) {
-    if (!message) {
-      return void 0;
+  static taskState(state) {
+    switch (state) {
+      case 1 /* TASK_STATE_SUBMITTED */:
+        return "submitted";
+      case 2 /* TASK_STATE_WORKING */:
+        return "working";
+      case 6 /* TASK_STATE_INPUT_REQUIRED */:
+        return "input-required";
+      case 3 /* TASK_STATE_COMPLETED */:
+        return "completed";
+      case 5 /* TASK_STATE_CANCELLED */:
+        return "canceled";
+      case 4 /* TASK_STATE_FAILED */:
+        return "failed";
+      case 7 /* TASK_STATE_REJECTED */:
+        return "rejected";
+      case 8 /* TASK_STATE_AUTH_REQUIRED */:
+        return "auth-required";
+      case 0 /* TASK_STATE_UNSPECIFIED */:
+        return "unknown";
+      default:
+        throw A2AError.invalidParams(`Invalid task state: ${state}`);
     }
+  }
+  static artifact(artifact) {
     return {
-      messageId: message.messageId,
-      content: message.parts.map((p) => _ToProto.part(p)),
-      contextId: message.contextId ?? "",
-      taskId: message.taskId ?? "",
-      role: _ToProto.role(message.role),
-      metadata: message.metadata,
-      extensions: message.extensions ?? []
+      artifactId: artifact.artifactId,
+      name: artifact.name || void 0,
+      description: artifact.description || void 0,
+      parts: artifact.parts.map((p) => _FromProto.part(p)),
+      metadata: artifact.metadata
     };
   }
-  static role(role) {
-    switch (role) {
-      case "agent":
-        return 2 /* ROLE_AGENT */;
-      case "user":
-        return 1 /* ROLE_USER */;
-      default:
-        throw A2AError.internalError(`Invalid role`);
+  static taskPushNotificationConfig(request) {
+    return {
+      taskId: extractTaskId(request.name),
+      pushNotificationConfig: _FromProto.pushNotificationConfig(request.pushNotificationConfig)
+    };
+  }
+  static listTaskPushNotificationConfig(request) {
+    return request.configs.map((c) => _FromProto.taskPushNotificationConfig(c));
+  }
+  static agentCard(agentCard) {
+    return {
+      additionalInterfaces: agentCard.additionalInterfaces?.map((i) => _FromProto.agentInterface(i)),
+      capabilities: agentCard.capabilities ? _FromProto.agentCapabilities(agentCard.capabilities) : {},
+      defaultInputModes: agentCard.defaultInputModes,
+      defaultOutputModes: agentCard.defaultOutputModes,
+      description: agentCard.description,
+      documentationUrl: agentCard.documentationUrl || void 0,
+      name: agentCard.name,
+      preferredTransport: agentCard.preferredTransport,
+      provider: agentCard.provider ? _FromProto.agentProvider(agentCard.provider) : void 0,
+      protocolVersion: agentCard.protocolVersion,
+      security: agentCard.security?.map((s) => _FromProto.security(s)),
+      securitySchemes: agentCard.securitySchemes ? Object.fromEntries(
+        Object.entries(agentCard.securitySchemes).map(([key, value]) => [
+          key,
+          _FromProto.securityScheme(value)
+        ])
+      ) : {},
+      skills: agentCard.skills.map((s) => _FromProto.skills(s)),
+      signatures: agentCard.signatures?.map((s) => _FromProto.agentCardSignature(s)),
+      supportsAuthenticatedExtendedCard: agentCard.supportsAuthenticatedExtendedCard,
+      url: agentCard.url,
+      version: agentCard.version
+    };
+  }
+  static agentCapabilities(capabilities) {
+    return {
+      extensions: capabilities.extensions?.map((e) => _FromProto.agentExtension(e)),
+      pushNotifications: capabilities.pushNotifications,
+      streaming: capabilities.streaming
+    };
+  }
+  static agentExtension(extension) {
+    return {
+      uri: extension.uri,
+      description: extension.description || void 0,
+      required: extension.required,
+      params: extension.params
+    };
+  }
+  static agentInterface(intf) {
+    return {
+      transport: intf.transport,
+      url: intf.url
+    };
+  }
+  static agentProvider(provider) {
+    return {
+      organization: provider.organization,
+      url: provider.url
+    };
+  }
+  static security(security) {
+    return Object.fromEntries(
+      Object.entries(security.schemes)?.map(([key, value]) => [key, value.list])
+    );
+  }
+  static securityScheme(securitySchemes) {
+    switch (securitySchemes.scheme?.$case) {
+      case "apiKeySecurityScheme":
+        return {
+          type: "apiKey",
+          name: securitySchemes.scheme.value.name,
+          in: securitySchemes.scheme.value.location,
+          description: securitySchemes.scheme.value.description || void 0
+        };
+      case "httpAuthSecurityScheme":
+        return {
+          type: "http",
+          scheme: securitySchemes.scheme.value.scheme,
+          bearerFormat: securitySchemes.scheme.value.bearerFormat || void 0,
+          description: securitySchemes.scheme.value.description || void 0
+        };
+      case "mtlsSecurityScheme":
+        return {
+          type: "mutualTLS",
+          description: securitySchemes.scheme.value.description || void 0
+        };
+      case "oauth2SecurityScheme":
+        return {
+          type: "oauth2",
+          description: securitySchemes.scheme.value.description || void 0,
+          flows: _FromProto.oauthFlows(securitySchemes.scheme.value.flows),
+          oauth2MetadataUrl: securitySchemes.scheme.value.oauth2MetadataUrl || void 0
+        };
+      case "openIdConnectSecurityScheme":
+        return {
+          type: "openIdConnect",
+          description: securitySchemes.scheme.value.description || void 0,
+          openIdConnectUrl: securitySchemes.scheme.value.openIdConnectUrl
+        };
+      default:
+        throw A2AError.internalError(`Unsupported security scheme type`);
+    }
+  }
+  static oauthFlows(flows) {
+    switch (flows.flow?.$case) {
+      case "implicit":
+        return {
+          implicit: {
+            authorizationUrl: flows.flow.value.authorizationUrl,
+            scopes: flows.flow.value.scopes,
+            refreshUrl: flows.flow.value.refreshUrl || void 0
+          }
+        };
+      case "password":
+        return {
+          password: {
+            refreshUrl: flows.flow.value.refreshUrl || void 0,
+            scopes: flows.flow.value.scopes,
+            tokenUrl: flows.flow.value.tokenUrl
+          }
+        };
+      case "authorizationCode":
+        return {
+          authorizationCode: {
+            refreshUrl: flows.flow.value.refreshUrl || void 0,
+            authorizationUrl: flows.flow.value.authorizationUrl,
+            scopes: flows.flow.value.scopes,
+            tokenUrl: flows.flow.value.tokenUrl
+          }
+        };
+      case "clientCredentials":
+        return {
+          clientCredentials: {
+            refreshUrl: flows.flow.value.refreshUrl || void 0,
+            scopes: flows.flow.value.scopes,
+            tokenUrl: flows.flow.value.tokenUrl
+          }
+        };
+      default:
+        throw A2AError.internalError(`Unsupported OAuth flows`);
+    }
+  }
+  static skills(skill) {
+    return {
+      id: skill.id,
+      name: skill.name,
+      description: skill.description,
+      tags: skill.tags,
+      examples: skill.examples,
+      inputModes: skill.inputModes,
+      outputModes: skill.outputModes,
+      security: skill.security?.map((s) => _FromProto.security(s))
+    };
+  }
+  static agentCardSignature(signatures) {
+    return {
+      protected: signatures.protected,
+      signature: signatures.signature,
+      header: signatures.header
+    };
+  }
+  static taskStatusUpdateEvent(event) {
+    return {
+      kind: "status-update",
+      taskId: event.taskId,
+      status: _FromProto.taskStatus(event.status),
+      contextId: event.contextId,
+      metadata: event.metadata,
+      final: event.final
+    };
+  }
+  static taskArtifactUpdateEvent(event) {
+    return {
+      kind: "artifact-update",
+      taskId: event.taskId,
+      artifact: _FromProto.artifact(event.artifact),
+      contextId: event.contextId,
+      metadata: event.metadata,
+      lastChunk: event.lastChunk
+    };
+  }
+  static messageStreamResult(event) {
+    switch (event.payload?.$case) {
+      case "msg":
+        return _FromProto.message(event.payload.value);
+      case "task":
+        return _FromProto.task(event.payload.value);
+      case "statusUpdate":
+        return _FromProto.taskStatusUpdateEvent(event.payload.value);
+      case "artifactUpdate":
+        return _FromProto.taskArtifactUpdateEvent(event.payload.value);
+      default:
+        throw A2AError.internalError("Invalid event type in StreamResponse");
+    }
+  }
+};
+
+// src/client/card-resolver.ts
+var DefaultAgentCardResolver = class {
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * Fetches the agent card based on provided base URL and path.
+   * Path is selected in the following order:
+   * 1) path parameter
+   * 2) path from options
+   * 3) .well-known/agent-card.json
+   */
+  async resolve(baseUrl, path) {
+    const agentCardUrl = new URL(path ?? this.options?.path ?? AGENT_CARD_PATH, baseUrl);
+    const response = await this.fetchImpl(agentCardUrl);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch Agent Card from ${agentCardUrl}: ${response.status}`);
+    }
+    const rawCard = await response.json();
+    return this.normalizeAgentCard(rawCard);
+  }
+  fetchImpl(...args) {
+    if (this.options?.fetchImpl) {
+      return this.options.fetchImpl(...args);
+    }
+    return fetch(...args);
+  }
+  /*
+   * In the v0.3.0 specification, there was a structural drift between the JSON Schema data model
+   * and the Protobuf-based data model for AgentCards.
+   * The JSON Schema format uses a `"type"` discriminator (e.g., `{"type": "openIdConnect"}`),
+   * while the Protobuf JSON representation uses the `oneof` field name as the discriminator
+   * (e.g., `{"openIdConnectSecurityScheme": {...}}`).
+   *
+   * The A2A SDK internal logic expects the JSON Schema-based format. This fallback detection
+   * allows us to parse cards served by endpoints returning the Protobuf JSON structure by
+   * identifying the lack of the "type" field in security schemes or the presence of the
+   * "schemes" wrapper in security entries, and normalizing it before use.
+   */
+  normalizeAgentCard(card) {
+    if (this.isProtoAgentCard(card)) {
+      const parsedProto = AgentCard.fromJSON(card);
+      return FromProto.agentCard(parsedProto);
+    }
+    return card;
+  }
+  isProtoAgentCard(card) {
+    if (!card || typeof card !== "object") return false;
+    const c = card;
+    if (this.hasProtoSecurity(c.security)) return true;
+    if (this.hasProtoSecuritySchemes(c.securitySchemes)) return true;
+    if (Array.isArray(c.skills)) {
+      return c.skills.some(
+        (skill) => skill && typeof skill === "object" && this.hasProtoSecurity(skill.security)
+      );
+    }
+    return false;
+  }
+  hasProtoSecurity(securityArray) {
+    if (Array.isArray(securityArray) && securityArray.length > 0) {
+      const first = securityArray[0];
+      return first && typeof first === "object" && "schemes" in first;
+    }
+    return false;
+  }
+  hasProtoSecuritySchemes(securitySchemes) {
+    if (securitySchemes && typeof securitySchemes === "object") {
+      const schemes = Object.values(securitySchemes);
+      if (schemes.length > 0) {
+        const first = schemes[0];
+        return first && typeof first === "object" && !("type" in first);
+      }
+    }
+    return false;
+  }
+};
+var AgentCardResolver = {
+  default: new DefaultAgentCardResolver()
+};
+
+// src/client/multitransport-client.ts
+var Client = class {
+  constructor(transport, agentCard, config) {
+    this.transport = transport;
+    this.agentCard = agentCard;
+    this.config = config;
+  }
+  /**
+   * If the current agent card supports the extended feature, it will try to fetch the extended agent card from the server,
+   * Otherwise it will return the current agent card value.
+   */
+  async getAgentCard(options) {
+    if (this.agentCard.supportsAuthenticatedExtendedCard) {
+      this.agentCard = await this.executeWithInterceptors(
+        { method: "getAgentCard" },
+        options,
+        (_, options2) => this.transport.getExtendedAgentCard(options2)
+      );
+    }
+    return this.agentCard;
+  }
+  /**
+   * Sends a message to an agent to initiate a new interaction or to continue an existing one.
+   * Uses blocking mode by default.
+   */
+  sendMessage(params, options) {
+    params = this.applyClientConfig({
+      params,
+      blocking: !(this.config?.polling ?? false)
+    });
+    return this.executeWithInterceptors(
+      { method: "sendMessage", value: params },
+      options,
+      this.transport.sendMessage.bind(this.transport)
+    );
+  }
+  /**
+   * Sends a message to an agent to initiate/continue a task AND subscribes the client to real-time updates for that task.
+   * Performs fallback to non-streaming if not supported by the agent.
+   */
+  async *sendMessageStream(params, options) {
+    const method = "sendMessageStream";
+    params = this.applyClientConfig({ params, blocking: true });
+    const beforeArgs = {
+      input: { method, value: params },
+      agentCard: this.agentCard,
+      options
+    };
+    const beforeResult = await this.interceptBefore(beforeArgs);
+    if (beforeResult) {
+      const earlyReturn = beforeResult.earlyReturn.value;
+      const afterArgs = {
+        result: { method, value: earlyReturn },
+        agentCard: this.agentCard,
+        options: beforeArgs.options
+      };
+      await this.interceptAfter(afterArgs, beforeResult.executed);
+      yield afterArgs.result.value;
+      return;
+    }
+    if (!this.agentCard.capabilities.streaming) {
+      const result = await this.transport.sendMessage(beforeArgs.input.value, beforeArgs.options);
+      const afterArgs = {
+        result: { method, value: result },
+        agentCard: this.agentCard,
+        options: beforeArgs.options
+      };
+      await this.interceptAfter(afterArgs);
+      yield afterArgs.result.value;
+      return;
+    }
+    for await (const event of this.transport.sendMessageStream(
+      beforeArgs.input.value,
+      beforeArgs.options
+    )) {
+      const afterArgs = {
+        result: { method, value: event },
+        agentCard: this.agentCard,
+        options: beforeArgs.options
+      };
+      await this.interceptAfter(afterArgs);
+      yield afterArgs.result.value;
+      if (afterArgs.earlyReturn) {
+        return;
+      }
+    }
+  }
+  /**
+   * Sets or updates the push notification configuration for a specified task.
+   * Requires the server to have AgentCard.capabilities.pushNotifications: true.
+   */
+  setTaskPushNotificationConfig(params, options) {
+    if (!this.agentCard.capabilities.pushNotifications) {
+      throw new PushNotificationNotSupportedError();
+    }
+    return this.executeWithInterceptors(
+      { method: "setTaskPushNotificationConfig", value: params },
+      options,
+      this.transport.setTaskPushNotificationConfig.bind(this.transport)
+    );
+  }
+  /**
+   * Retrieves the current push notification configuration for a specified task.
+   * Requires the server to have AgentCard.capabilities.pushNotifications: true.
+   */
+  getTaskPushNotificationConfig(params, options) {
+    if (!this.agentCard.capabilities.pushNotifications) {
+      throw new PushNotificationNotSupportedError();
+    }
+    return this.executeWithInterceptors(
+      { method: "getTaskPushNotificationConfig", value: params },
+      options,
+      this.transport.getTaskPushNotificationConfig.bind(this.transport)
+    );
+  }
+  /**
+   * Retrieves the associated push notification configurations for a specified task.
+   * Requires the server to have AgentCard.capabilities.pushNotifications: true.
+   */
+  listTaskPushNotificationConfig(params, options) {
+    if (!this.agentCard.capabilities.pushNotifications) {
+      throw new PushNotificationNotSupportedError();
+    }
+    return this.executeWithInterceptors(
+      { method: "listTaskPushNotificationConfig", value: params },
+      options,
+      this.transport.listTaskPushNotificationConfig.bind(this.transport)
+    );
+  }
+  /**
+   * Deletes an associated push notification configuration for a task.
+   */
+  deleteTaskPushNotificationConfig(params, options) {
+    return this.executeWithInterceptors(
+      { method: "deleteTaskPushNotificationConfig", value: params },
+      options,
+      this.transport.deleteTaskPushNotificationConfig.bind(this.transport)
+    );
+  }
+  /**
+   * Retrieves the current state (including status, artifacts, and optionally history) of a previously initiated task.
+   */
+  getTask(params, options) {
+    return this.executeWithInterceptors(
+      { method: "getTask", value: params },
+      options,
+      this.transport.getTask.bind(this.transport)
+    );
+  }
+  /**
+   * Requests the cancellation of an ongoing task. The server will attempt to cancel the task,
+   * but success is not guaranteed (e.g., the task might have already completed or failed, or cancellation might not be supported at its current stage).
+   */
+  cancelTask(params, options) {
+    return this.executeWithInterceptors(
+      { method: "cancelTask", value: params },
+      options,
+      this.transport.cancelTask.bind(this.transport)
+    );
+  }
+  /**
+   * Allows a client to reconnect to an updates stream for an ongoing task after a previous connection was interrupted.
+   */
+  async *resubscribeTask(params, options) {
+    const method = "resubscribeTask";
+    const beforeArgs = {
+      input: { method, value: params },
+      agentCard: this.agentCard,
+      options
+    };
+    const beforeResult = await this.interceptBefore(beforeArgs);
+    if (beforeResult) {
+      const earlyReturn = beforeResult.earlyReturn.value;
+      const afterArgs = {
+        result: { method, value: earlyReturn },
+        agentCard: this.agentCard,
+        options: beforeArgs.options
+      };
+      await this.interceptAfter(afterArgs, beforeResult.executed);
+      yield afterArgs.result.value;
+      return;
+    }
+    for await (const event of this.transport.resubscribeTask(
+      beforeArgs.input.value,
+      beforeArgs.options
+    )) {
+      const afterArgs = {
+        result: { method, value: event },
+        agentCard: this.agentCard,
+        options: beforeArgs.options
+      };
+      await this.interceptAfter(afterArgs);
+      yield afterArgs.result.value;
+      if (afterArgs.earlyReturn) {
+        return;
+      }
+    }
+  }
+  applyClientConfig({
+    params,
+    blocking
+  }) {
+    const result = { ...params, configuration: params.configuration ?? {} };
+    if (!result.configuration.acceptedOutputModes && this.config?.acceptedOutputModes) {
+      result.configuration.acceptedOutputModes = this.config.acceptedOutputModes;
+    }
+    if (!result.configuration.pushNotificationConfig && this.config?.pushNotificationConfig) {
+      result.configuration.pushNotificationConfig = this.config.pushNotificationConfig;
+    }
+    result.configuration.blocking ??= blocking;
+    return result;
+  }
+  async executeWithInterceptors(input, options, transportCall) {
+    const beforeArgs = {
+      input,
+      agentCard: this.agentCard,
+      options
+    };
+    const beforeResult = await this.interceptBefore(beforeArgs);
+    if (beforeResult) {
+      const afterArgs2 = {
+        result: {
+          method: input.method,
+          value: beforeResult.earlyReturn.value
+        },
+        agentCard: this.agentCard,
+        options: beforeArgs.options
+      };
+      await this.interceptAfter(afterArgs2, beforeResult.executed);
+      return afterArgs2.result.value;
+    }
+    const result = await transportCall(beforeArgs.input.value, beforeArgs.options);
+    const afterArgs = {
+      result: { method: input.method, value: result },
+      agentCard: this.agentCard,
+      options: beforeArgs.options
+    };
+    await this.interceptAfter(afterArgs);
+    return afterArgs.result.value;
+  }
+  async interceptBefore(args) {
+    if (!this.config?.interceptors || this.config.interceptors.length === 0) {
+      return;
+    }
+    const executed = [];
+    for (const interceptor of this.config.interceptors) {
+      await interceptor.before(args);
+      executed.push(interceptor);
+      if (args.earlyReturn) {
+        return {
+          earlyReturn: args.earlyReturn,
+          executed
+        };
+      }
+    }
+  }
+  async interceptAfter(args, interceptors) {
+    const reversedInterceptors = [...interceptors ?? this.config?.interceptors ?? []].reverse();
+    for (const interceptor of reversedInterceptors) {
+      await interceptor.after(args);
+      if (args.earlyReturn) {
+        return;
+      }
     }
   }
-  static task(task) {
+};
+
+// src/types/converters/to_proto.ts
+var ToProto = class _ToProto {
+  static agentCard(agentCard) {
     return {
-      id: task.id,
-      contextId: task.contextId,
-      status: _ToProto.taskStatus(task.status),
-      artifacts: task.artifacts?.map((a) => _ToProto.artifact(a)) ?? [],
-      history: task.history?.map((m) => _ToProto.message(m)) ?? [],
-      metadata: task.metadata
+      protocolVersion: agentCard.protocolVersion,
+      name: agentCard.name,
+      description: agentCard.description,
+      url: agentCard.url,
+      preferredTransport: agentCard.preferredTransport ?? "",
+      additionalInterfaces: agentCard.additionalInterfaces?.map((i) => _ToProto.agentInterface(i)) ?? [],
+      provider: _ToProto.agentProvider(agentCard.provider),
+      version: agentCard.version,
+      documentationUrl: agentCard.documentationUrl ?? "",
+      capabilities: _ToProto.agentCapabilities(agentCard.capabilities),
+      securitySchemes: agentCard.securitySchemes ? Object.fromEntries(
+        Object.entries(agentCard.securitySchemes).map(([key, value]) => [
+          key,
+          _ToProto.securityScheme(value)
+        ])
+      ) : {},
+      security: agentCard.security?.map((s) => _ToProto.security(s)) ?? [],
+      defaultInputModes: agentCard.defaultInputModes,
+      defaultOutputModes: agentCard.defaultOutputModes,
+      skills: agentCard.skills.map((s) => _ToProto.agentSkill(s)),
+      supportsAuthenticatedExtendedCard: agentCard.supportsAuthenticatedExtendedCard,
+      signatures: agentCard.signatures?.map((s) => _ToProto.agentCardSignature(s)) ?? []
     };
   }
-  static taskStatus(status) {
+  static agentCardSignature(signatures) {
     return {
-      state: _ToProto.taskState(status.state),
-      update: _ToProto.message(status.message),
-      timestamp: status.timestamp
+      protected: signatures.protected,
+      signature: signatures.signature,
+      header: signatures.header
     };
   }
-  static artifact(artifact) {
+  static agentSkill(skill) {
     return {
-      artifactId: artifact.artifactId,
-      name: artifact.name ?? "",
-      description: artifact.description ?? "",
-      parts: artifact.parts.map((p) => _ToProto.part(p)),
-      metadata: artifact.metadata,
-      extensions: artifact.extensions ? artifact.extensions : []
+      id: skill.id,
+      name: skill.name,
+      description: skill.description,
+      tags: skill.tags ?? [],
+      examples: skill.examples ?? [],
+      inputModes: skill.inputModes ?? [],
+      outputModes: skill.outputModes ?? [],
+      security: skill.security ? skill.security.map((s) => _ToProto.security(s)) : []
     };
   }
-  static taskState(state) {
-    switch (state) {
-      case "submitted":
-        return 1 /* TASK_STATE_SUBMITTED */;
-      case "working":
-        return 2 /* TASK_STATE_WORKING */;
-      case "input-required":
-        return 6 /* TASK_STATE_INPUT_REQUIRED */;
-      case "rejected":
-        return 7 /* TASK_STATE_REJECTED */;
-      case "auth-required":
-        return 8 /* TASK_STATE_AUTH_REQUIRED */;
-      case "completed":
-        return 3 /* TASK_STATE_COMPLETED */;
-      case "failed":
-        return 4 /* TASK_STATE_FAILED */;
-      case "canceled":
-        return 5 /* TASK_STATE_CANCELLED */;
-      case "unknown":
-        return 0 /* TASK_STATE_UNSPECIFIED */;
+  static security(security) {
+    return {
+      schemes: Object.fromEntries(
+        Object.entries(security).map(([key, value]) => {
+          return [key, { list: value }];
+        })
+      )
+    };
+  }
+  static securityScheme(scheme) {
+    switch (scheme.type) {
+      case "apiKey":
+        return {
+          scheme: {
+            $case: "apiKeySecurityScheme",
+            value: {
+              name: scheme.name,
+              location: scheme.in,
+              description: scheme.description ?? ""
+            }
+          }
+        };
+      case "http":
+        return {
+          scheme: {
+            $case: "httpAuthSecurityScheme",
+            value: {
+              description: scheme.description ?? "",
+              scheme: scheme.scheme,
+              bearerFormat: scheme.bearerFormat ?? ""
+            }
+          }
+        };
+      case "mutualTLS":
+        return {
+          scheme: {
+            $case: "mtlsSecurityScheme",
+            value: {
+              description: scheme.description ?? ""
+            }
+          }
+        };
+      case "oauth2":
+        return {
+          scheme: {
+            $case: "oauth2SecurityScheme",
+            value: {
+              description: scheme.description ?? "",
+              flows: _ToProto.oauthFlows(scheme.flows),
+              oauth2MetadataUrl: scheme.oauth2MetadataUrl ?? ""
+            }
+          }
+        };
+      case "openIdConnect":
+        return {
+          scheme: {
+            $case: "openIdConnectSecurityScheme",
+            value: {
+              description: scheme.description ?? "",
+              openIdConnectUrl: scheme.openIdConnectUrl
+            }
+          }
+        };
       default:
-        return -1 /* UNRECOGNIZED */;
+        throw A2AError.internalError(`Unsupported security scheme type`);
     }
   }
-  static part(part) {
-    if (part.kind === "text") {
+  static oauthFlows(flows) {
+    if (flows.implicit) {
       return {
-        part: { $case: "text", value: part.text }
+        flow: {
+          $case: "implicit",
+          value: {
+            authorizationUrl: flows.implicit.authorizationUrl,
+            scopes: flows.implicit.scopes,
+            refreshUrl: flows.implicit.refreshUrl ?? ""
+          }
+        }
       };
-    }
-    if (part.kind === "file") {
-      let filePart;
-      if ("uri" in part.file) {
-        filePart = {
-          file: { $case: "fileWithUri", value: part.file.uri },
-          mimeType: part.file.mimeType
-        };
-      } else if ("bytes" in part.file) {
-        filePart = {
-          file: { $case: "fileWithBytes", value: Buffer.from(part.file.bytes, "base64") },
-          mimeType: part.file.mimeType
-        };
-      } else {
-        throw A2AError.internalError("Invalid file part");
-      }
+    } else if (flows.password) {
       return {
-        part: { $case: "file", value: filePart }
+        flow: {
+          $case: "password",
+          value: {
+            tokenUrl: flows.password.tokenUrl,
+            scopes: flows.password.scopes,
+            refreshUrl: flows.password.refreshUrl ?? ""
+          }
+        }
       };
-    }
-    if (part.kind === "data") {
+    } else if (flows.clientCredentials) {
       return {
-        part: { $case: "data", value: { data: part.data } }
+        flow: {
+          $case: "clientCredentials",
+          value: {
+            tokenUrl: flows.clientCredentials.tokenUrl,
+            scopes: flows.clientCredentials.scopes,
+            refreshUrl: flows.clientCredentials.refreshUrl ?? ""
+          }
+        }
+      };
+    } else if (flows.authorizationCode) {
+      return {
+        flow: {
+          $case: "authorizationCode",
+          value: {
+            authorizationUrl: flows.authorizationCode.authorizationUrl,
+            tokenUrl: flows.authorizationCode.tokenUrl,
+            scopes: flows.authorizationCode.scopes,
+            refreshUrl: flows.authorizationCode.refreshUrl ?? ""
+          }
+        }
       };
+    } else {
+      throw A2AError.internalError(`Unsupported OAuth flows`);
     }
-    throw A2AError.internalError("Invalid part type");
   }
-  static messageSendParams(params) {
+  static agentInterface(agentInterface) {
     return {
-      request: _ToProto.message(params.message),
-      configuration: _ToProto.configuration(params.configuration),
-      metadata: params.metadata
+      transport: agentInterface.transport,
+      url: agentInterface.url
     };
   }
-  static configuration(configuration) {
-    if (!configuration) {
+  static agentProvider(agentProvider) {
+    if (!agentProvider) {
       return void 0;
     }
     return {
-      blocking: configuration.blocking,
-      acceptedOutputModes: configuration.acceptedOutputModes ?? [],
-      pushNotification: _ToProto.pushNotificationConfig(configuration.pushNotificationConfig),
-      historyLength: configuration.historyLength ?? 0
-    };
-  }
-  static taskQueryParams(params) {
-    return {
-      name: generateTaskName(params.id),
-      historyLength: params.historyLength ?? 0
-    };
-  }
-  static cancelTaskRequest(params) {
-    return {
-      name: generateTaskName(params.id)
-    };
-  }
-  static taskIdParams(params) {
-    return {
-      name: generateTaskName(params.id)
+      url: agentProvider.url,
+      organization: agentProvider.organization
     };
   }
-  static getAgentCardRequest() {
-    return {};
-  }
-};
-
-// src/types/converters/from_proto.ts
-var FromProto = class _FromProto {
-  static taskQueryParams(request) {
+  static agentCapabilities(capabilities) {
     return {
-      id: extractTaskId(request.name),
-      historyLength: request.historyLength
+      streaming: capabilities.streaming,
+      pushNotifications: capabilities.pushNotifications,
+      extensions: capabilities.extensions ? capabilities.extensions.map((e) => _ToProto.agentExtension(e)) : []
     };
   }
-  static taskIdParams(request) {
+  static agentExtension(extension) {
     return {
-      id: extractTaskId(request.name)
+      uri: extension.uri,
+      description: extension.description ?? "",
+      required: extension.required ?? false,
+      params: extension.params
     };
   }
-  static getTaskPushNotificationConfigParams(request) {
-    const { taskId, configId } = extractTaskAndPushNotificationConfigId(request.name);
+  static listTaskPushNotificationConfig(config) {
     return {
-      id: taskId,
-      pushNotificationConfigId: configId
+      configs: config.map((c) => _ToProto.taskPushNotificationConfig(c)),
+      nextPageToken: ""
     };
   }
-  static listTaskPushNotificationConfigParams(request) {
+  static getTaskPushNotificationConfigParams(config) {
     return {
-      id: extractTaskId(request.parent)
+      name: generatePushNotificationConfigName(config.id, config.pushNotificationConfigId)
     };
   }
-  static createTaskPushNotificationConfig(request) {
-    if (!request.config?.pushNotificationConfig) {
-      throw A2AError.invalidParams(
-        "Request must include a `config` object with a `pushNotificationConfig`"
-      );
-    }
+  static listTaskPushNotificationConfigParams(config) {
     return {
-      taskId: extractTaskId(request.parent),
-      pushNotificationConfig: _FromProto.pushNotificationConfig(
-        request.config.pushNotificationConfig
-      )
+      parent: generateTaskName(config.id),
+      pageToken: "",
+      pageSize: 0
     };
   }
-  static deleteTaskPushNotificationConfigParams(request) {
-    const { taskId, configId } = extractTaskAndPushNotificationConfigId(request.name);
+  static deleteTaskPushNotificationConfigParams(config) {
     return {
-      id: taskId,
-      pushNotificationConfigId: configId
+      name: generatePushNotificationConfigName(config.id, config.pushNotificationConfigId)
     };
   }
-  static message(message) {
-    if (!message) {
-      return void 0;
-    }
+  static taskPushNotificationConfig(config) {
     return {
-      kind: "message",
-      messageId: message.messageId,
-      parts: message.content.map((p) => _FromProto.part(p)),
-      contextId: message.contextId || void 0,
-      taskId: message.taskId || void 0,
-      role: _FromProto.role(message.role),
-      metadata: message.metadata,
-      extensions: message.extensions
+      name: generatePushNotificationConfigName(
+        config.taskId,
+        config.pushNotificationConfig.id ?? ""
+      ),
+      pushNotificationConfig: _ToProto.pushNotificationConfig(config.pushNotificationConfig)
     };
   }
-  static role(role) {
-    switch (role) {
-      case 2 /* ROLE_AGENT */:
-        return "agent";
-      case 1 /* ROLE_USER */:
-        return "user";
-      default:
-        throw A2AError.invalidParams(`Invalid role: ${role}`);
-    }
-  }
-  static messageSendConfiguration(configuration) {
-    if (!configuration) {
-      return void 0;
-    }
+  static taskPushNotificationConfigCreate(config) {
     return {
-      blocking: configuration.blocking,
-      acceptedOutputModes: configuration.acceptedOutputModes,
-      pushNotificationConfig: _FromProto.pushNotificationConfig(configuration.pushNotification)
+      parent: generateTaskName(config.taskId),
+      config: _ToProto.taskPushNotificationConfig(config),
+      configId: config.pushNotificationConfig.id
     };
   }
   static pushNotificationConfig(config) {
@@ -2845,10 +2973,10 @@ var FromProto = class _FromProto {
       return void 0;
     }
     return {
-      id: config.id,
+      id: config.id ?? "",
       url: config.url,
-      token: config.token || void 0,
-      authentication: _FromProto.pushNotificationAuthenticationInfo(config.authentication)
+      token: config.token ?? "",
+      authentication: _ToProto.pushNotificationAuthenticationInfo(config.authentication)
     };
   }
   static pushNotificationAuthenticationInfo(authInfo) {
@@ -2857,307 +2985,221 @@ var FromProto = class _FromProto {
     }
     return {
       schemes: authInfo.schemes,
-      credentials: authInfo.credentials
+      credentials: authInfo.credentials ?? ""
     };
   }
-  static part(part) {
-    if (part.part?.$case === "text") {
+  static messageStreamResult(event) {
+    if (event.kind === "message") {
       return {
-        kind: "text",
-        text: part.part.value
+        payload: {
+          $case: "msg",
+          value: _ToProto.message(event)
+        }
       };
-    }
-    if (part.part?.$case === "file") {
-      const filePart = part.part.value;
-      if (filePart.file?.$case === "fileWithUri") {
-        return {
-          kind: "file",
-          file: {
-            uri: filePart.file.value,
-            mimeType: filePart.mimeType
-          }
-        };
-      } else if (filePart.file?.$case === "fileWithBytes") {
-        return {
-          kind: "file",
-          file: {
-            bytes: filePart.file.value.toString("base64"),
-            mimeType: filePart.mimeType
-          }
-        };
-      }
-      throw A2AError.invalidParams("Invalid file part type");
-    }
-    if (part.part?.$case === "data") {
+    } else if (event.kind === "task") {
       return {
-        kind: "data",
-        data: part.part.value.data
+        payload: {
+          $case: "task",
+          value: _ToProto.task(event)
+        }
       };
-    }
-    throw A2AError.invalidParams("Invalid part type");
-  }
-  static messageSendParams(request) {
-    return {
-      message: _FromProto.message(request.request),
-      configuration: _FromProto.messageSendConfiguration(request.configuration),
-      metadata: request.metadata
-    };
-  }
-  static sendMessageResult(response) {
-    if (response.payload?.$case === "task") {
-      return _FromProto.task(response.payload.value);
-    } else if (response.payload?.$case === "msg") {
-      return _FromProto.message(response.payload.value);
-    }
-    throw A2AError.invalidParams("Invalid SendMessageResponse: missing result");
-  }
-  static task(task) {
-    return {
-      kind: "task",
-      id: task.id,
-      status: _FromProto.taskStatus(task.status),
-      contextId: task.contextId,
-      artifacts: task.artifacts?.map((a) => _FromProto.artifact(a)),
-      history: task.history?.map((h) => _FromProto.message(h)),
-      metadata: task.metadata
-    };
-  }
-  static taskStatus(status) {
-    return {
-      message: _FromProto.message(status.update),
-      state: _FromProto.taskState(status.state),
-      timestamp: status.timestamp
-    };
-  }
-  static taskState(state) {
-    switch (state) {
-      case 1 /* TASK_STATE_SUBMITTED */:
-        return "submitted";
-      case 2 /* TASK_STATE_WORKING */:
-        return "working";
-      case 6 /* TASK_STATE_INPUT_REQUIRED */:
-        return "input-required";
-      case 3 /* TASK_STATE_COMPLETED */:
-        return "completed";
-      case 5 /* TASK_STATE_CANCELLED */:
-        return "canceled";
-      case 4 /* TASK_STATE_FAILED */:
-        return "failed";
-      case 7 /* TASK_STATE_REJECTED */:
-        return "rejected";
-      case 8 /* TASK_STATE_AUTH_REQUIRED */:
-        return "auth-required";
-      case 0 /* TASK_STATE_UNSPECIFIED */:
-        return "unknown";
-      default:
-        throw A2AError.invalidParams(`Invalid task state: ${state}`);
+    } else if (event.kind === "status-update") {
+      return {
+        payload: {
+          $case: "statusUpdate",
+          value: _ToProto.taskStatusUpdateEvent(event)
+        }
+      };
+    } else if (event.kind === "artifact-update") {
+      return {
+        payload: {
+          $case: "artifactUpdate",
+          value: _ToProto.taskArtifactUpdateEvent(event)
+        }
+      };
+    } else {
+      throw A2AError.internalError("Invalid event type");
     }
   }
-  static artifact(artifact) {
+  static taskStatusUpdateEvent(event) {
     return {
-      artifactId: artifact.artifactId,
-      name: artifact.name || void 0,
-      description: artifact.description || void 0,
-      parts: artifact.parts.map((p) => _FromProto.part(p)),
-      metadata: artifact.metadata
+      taskId: event.taskId,
+      status: _ToProto.taskStatus(event.status),
+      contextId: event.contextId,
+      metadata: event.metadata,
+      final: event.final
     };
   }
-  static taskPushNotificationConfig(request) {
+  static taskArtifactUpdateEvent(event) {
     return {
-      taskId: extractTaskId(request.name),
-      pushNotificationConfig: _FromProto.pushNotificationConfig(request.pushNotificationConfig)
+      taskId: event.taskId,
+      artifact: _ToProto.artifact(event.artifact),
+      contextId: event.contextId,
+      metadata: event.metadata,
+      append: event.append,
+      lastChunk: event.lastChunk
     };
   }
-  static listTaskPushNotificationConfig(request) {
-    return request.configs.map((c) => _FromProto.taskPushNotificationConfig(c));
-  }
-  static agentCard(agentCard) {
-    return {
-      additionalInterfaces: agentCard.additionalInterfaces?.map((i) => _FromProto.agentInterface(i)),
-      capabilities: agentCard.capabilities ? _FromProto.agentCapabilities(agentCard.capabilities) : {},
-      defaultInputModes: agentCard.defaultInputModes,
-      defaultOutputModes: agentCard.defaultOutputModes,
-      description: agentCard.description,
-      documentationUrl: agentCard.documentationUrl || void 0,
-      name: agentCard.name,
-      preferredTransport: agentCard.preferredTransport,
-      provider: agentCard.provider ? _FromProto.agentProvider(agentCard.provider) : void 0,
-      protocolVersion: agentCard.protocolVersion,
-      security: agentCard.security?.map((s) => _FromProto.security(s)),
-      securitySchemes: agentCard.securitySchemes ? Object.fromEntries(
-        Object.entries(agentCard.securitySchemes).map(([key, value]) => [
-          key,
-          _FromProto.securityScheme(value)
-        ])
-      ) : {},
-      skills: agentCard.skills.map((s) => _FromProto.skills(s)),
-      signatures: agentCard.signatures?.map((s) => _FromProto.agentCardSignature(s)),
-      supportsAuthenticatedExtendedCard: agentCard.supportsAuthenticatedExtendedCard,
-      url: agentCard.url,
-      version: agentCard.version
-    };
+  static messageSendResult(params) {
+    if (params.kind === "message") {
+      return {
+        payload: {
+          $case: "msg",
+          value: _ToProto.message(params)
+        }
+      };
+    } else if (params.kind === "task") {
+      return {
+        payload: {
+          $case: "task",
+          value: _ToProto.task(params)
+        }
+      };
+    }
   }
-  static agentCapabilities(capabilities) {
+  static message(message) {
+    if (!message) {
+      return void 0;
+    }
     return {
-      extensions: capabilities.extensions?.map((e) => _FromProto.agentExtension(e)),
-      pushNotifications: capabilities.pushNotifications,
-      streaming: capabilities.streaming
+      messageId: message.messageId,
+      content: message.parts.map((p) => _ToProto.part(p)),
+      contextId: message.contextId ?? "",
+      taskId: message.taskId ?? "",
+      role: _ToProto.role(message.role),
+      metadata: message.metadata,
+      extensions: message.extensions ?? []
     };
   }
-  static agentExtension(extension) {
+  static role(role) {
+    switch (role) {
+      case "agent":
+        return 2 /* ROLE_AGENT */;
+      case "user":
+        return 1 /* ROLE_USER */;
+      default:
+        throw A2AError.internalError(`Invalid role`);
+    }
+  }
+  static task(task) {
     return {
-      uri: extension.uri,
-      description: extension.description || void 0,
-      required: extension.required,
-      params: extension.params
+      id: task.id,
+      contextId: task.contextId,
+      status: _ToProto.taskStatus(task.status),
+      artifacts: task.artifacts?.map((a) => _ToProto.artifact(a)) ?? [],
+      history: task.history?.map((m) => _ToProto.message(m)) ?? [],
+      metadata: task.metadata
     };
   }
-  static agentInterface(intf) {
+  static taskStatus(status) {
     return {
-      transport: intf.transport,
-      url: intf.url
+      state: _ToProto.taskState(status.state),
+      update: _ToProto.message(status.message),
+      timestamp: status.timestamp
     };
   }
-  static agentProvider(provider) {
+  static artifact(artifact) {
     return {
-      organization: provider.organization,
-      url: provider.url
+      artifactId: artifact.artifactId,
+      name: artifact.name ?? "",
+      description: artifact.description ?? "",
+      parts: artifact.parts.map((p) => _ToProto.part(p)),
+      metadata: artifact.metadata,
+      extensions: artifact.extensions ? artifact.extensions : []
     };
   }
-  static security(security) {
-    return Object.fromEntries(
-      Object.entries(security.schemes)?.map(([key, value]) => [key, value.list])
-    );
-  }
-  static securityScheme(securitySchemes) {
-    switch (securitySchemes.scheme?.$case) {
-      case "apiKeySecurityScheme":
-        return {
-          type: "apiKey",
-          name: securitySchemes.scheme.value.name,
-          in: securitySchemes.scheme.value.location,
-          description: securitySchemes.scheme.value.description || void 0
-        };
-      case "httpAuthSecurityScheme":
-        return {
-          type: "http",
-          scheme: securitySchemes.scheme.value.scheme,
-          bearerFormat: securitySchemes.scheme.value.bearerFormat || void 0,
-          description: securitySchemes.scheme.value.description || void 0
-        };
-      case "mtlsSecurityScheme":
-        return {
-          type: "mutualTLS",
-          description: securitySchemes.scheme.value.description || void 0
-        };
-      case "oauth2SecurityScheme":
-        return {
-          type: "oauth2",
-          description: securitySchemes.scheme.value.description || void 0,
-          flows: _FromProto.oauthFlows(securitySchemes.scheme.value.flows),
-          oauth2MetadataUrl: securitySchemes.scheme.value.oauth2MetadataUrl || void 0
-        };
-      case "openIdConnectSecurityScheme":
-        return {
-          type: "openIdConnect",
-          description: securitySchemes.scheme.value.description || void 0,
-          openIdConnectUrl: securitySchemes.scheme.value.openIdConnectUrl
-        };
+  static taskState(state) {
+    switch (state) {
+      case "submitted":
+        return 1 /* TASK_STATE_SUBMITTED */;
+      case "working":
+        return 2 /* TASK_STATE_WORKING */;
+      case "input-required":
+        return 6 /* TASK_STATE_INPUT_REQUIRED */;
+      case "rejected":
+        return 7 /* TASK_STATE_REJECTED */;
+      case "auth-required":
+        return 8 /* TASK_STATE_AUTH_REQUIRED */;
+      case "completed":
+        return 3 /* TASK_STATE_COMPLETED */;
+      case "failed":
+        return 4 /* TASK_STATE_FAILED */;
+      case "canceled":
+        return 5 /* TASK_STATE_CANCELLED */;
+      case "unknown":
+        return 0 /* TASK_STATE_UNSPECIFIED */;
       default:
-        throw A2AError.internalError(`Unsupported security scheme type`);
+        return -1 /* UNRECOGNIZED */;
     }
   }
-  static oauthFlows(flows) {
-    switch (flows.flow?.$case) {
-      case "implicit":
-        return {
-          implicit: {
-            authorizationUrl: flows.flow.value.authorizationUrl,
-            scopes: flows.flow.value.scopes,
-            refreshUrl: flows.flow.value.refreshUrl || void 0
-          }
-        };
-      case "password":
-        return {
-          password: {
-            refreshUrl: flows.flow.value.refreshUrl || void 0,
-            scopes: flows.flow.value.scopes,
-            tokenUrl: flows.flow.value.tokenUrl
-          }
-        };
-      case "authorizationCode":
-        return {
-          authorizationCode: {
-            refreshUrl: flows.flow.value.refreshUrl || void 0,
-            authorizationUrl: flows.flow.value.authorizationUrl,
-            scopes: flows.flow.value.scopes,
-            tokenUrl: flows.flow.value.tokenUrl
-          }
+  static part(part) {
+    if (part.kind === "text") {
+      return {
+        part: { $case: "text", value: part.text }
+      };
+    }
+    if (part.kind === "file") {
+      let filePart;
+      if ("uri" in part.file) {
+        filePart = {
+          file: { $case: "fileWithUri", value: part.file.uri },
+          mimeType: part.file.mimeType
         };
-      case "clientCredentials":
-        return {
-          clientCredentials: {
-            refreshUrl: flows.flow.value.refreshUrl || void 0,
-            scopes: flows.flow.value.scopes,
-            tokenUrl: flows.flow.value.tokenUrl
-          }
+      } else if ("bytes" in part.file) {
+        filePart = {
+          file: { $case: "fileWithBytes", value: Buffer.from(part.file.bytes, "base64") },
+          mimeType: part.file.mimeType
         };
-      default:
-        throw A2AError.internalError(`Unsupported OAuth flows`);
+      } else {
+        throw A2AError.internalError("Invalid file part");
+      }
+      return {
+        part: { $case: "file", value: filePart }
+      };
+    }
+    if (part.kind === "data") {
+      return {
+        part: { $case: "data", value: { data: part.data } }
+      };
     }
+    throw A2AError.internalError("Invalid part type");
   }
-  static skills(skill) {
+  static messageSendParams(params) {
     return {
-      id: skill.id,
-      name: skill.name,
-      description: skill.description,
-      tags: skill.tags,
-      examples: skill.examples,
-      inputModes: skill.inputModes,
-      outputModes: skill.outputModes,
-      security: skill.security?.map((s) => _FromProto.security(s))
+      request: _ToProto.message(params.message),
+      configuration: _ToProto.configuration(params.configuration),
+      metadata: params.metadata
     };
   }
-  static agentCardSignature(signatures) {
+  static configuration(configuration) {
+    if (!configuration) {
+      return void 0;
+    }
     return {
-      protected: signatures.protected,
-      signature: signatures.signature,
-      header: signatures.header
+      blocking: configuration.blocking,
+      acceptedOutputModes: configuration.acceptedOutputModes ?? [],
+      pushNotification: _ToProto.pushNotificationConfig(configuration.pushNotificationConfig),
+      historyLength: configuration.historyLength ?? 0
     };
   }
-  static taskStatusUpdateEvent(event) {
+  static taskQueryParams(params) {
     return {
-      kind: "status-update",
-      taskId: event.taskId,
-      status: _FromProto.taskStatus(event.status),
-      contextId: event.contextId,
-      metadata: event.metadata,
-      final: event.final
+      name: generateTaskName(params.id),
+      historyLength: params.historyLength ?? 0
     };
   }
-  static taskArtifactUpdateEvent(event) {
+  static cancelTaskRequest(params) {
     return {
-      kind: "artifact-update",
-      taskId: event.taskId,
-      artifact: _FromProto.artifact(event.artifact),
-      contextId: event.contextId,
-      metadata: event.metadata,
-      lastChunk: event.lastChunk
+      name: generateTaskName(params.id)
     };
   }
-  static messageStreamResult(event) {
-    switch (event.payload?.$case) {
-      case "msg":
-        return _FromProto.message(event.payload.value);
-      case "task":
-        return _FromProto.task(event.payload.value);
-      case "statusUpdate":
-        return _FromProto.taskStatusUpdateEvent(event.payload.value);
-      case "artifactUpdate":
-        return _FromProto.taskArtifactUpdateEvent(event.payload.value);
-      default:
-        throw A2AError.internalError("Invalid event type in StreamResponse");
-    }
+  static taskIdParams(params) {
+    return {
+      name: generateTaskName(params.id)
+    };
+  }
+  static getAgentCardRequest() {
+    return {};
   }
 };
 
@@ -3501,18 +3543,15 @@ var ClientFactory = class {
       ...additionalInterfaces.map((i) => i.transport)
     ];
     for (const transport of transportsByPreference) {
-      if (!urlsPerAgentTransports.has(transport)) {
-        continue;
-      }
+      const url = urlsPerAgentTransports.get(transport);
       const factory = this.transportsByName.get(transport);
-      if (!factory) {
-        continue;
+      if (factory && url) {
+        return new Client(
+          await factory.create(url, agentCard),
+          agentCard,
+          this.options.clientConfig
+        );
       }
-      return new Client(
-        await factory.create(urlsPerAgentTransports.get(transport), agentCard),
-        agentCard,
-        this.options.clientConfig
-      );
     }
     throw new Error(
       "No compatible transport found, available transports: " + [...this.transportsByName.keys()].join()