@settlemint/sdk-mcp 2.6.4-pr836c05ff → 2.6.4-pr855d66d3

package/dist/mcp.js

@@ -60238,7 +60238,7 @@ function object(shape, params) {
   };
   return new ZodMiniObject(def);
 }
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.23.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.24.3/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
 function isZ4Schema(s) {
   const schema = s;
   return !!schema._zod;
@@ -60313,7 +60313,7 @@ function normalizeObjectSchema(schema) {
   if (isZ4Schema(schema)) {
     const v4Schema = schema;
     const def = (_a = v4Schema._zod) === null || _a === undefined ? undefined : _a.def;
-    if (def && (def.typeName === "object" || def.shape !== undefined)) {
+    if (def && (def.type === "object" || def.shape !== undefined)) {
       return schema;
     }
   } else {
@@ -60356,7 +60356,7 @@ function isSchemaOptional(schema) {
   var _a, _b, _c;
   if (isZ4Schema(schema)) {
     const v4Schema = schema;
-    return ((_b = (_a = v4Schema._zod) === null || _a === undefined ? undefined : _a.def) === null || _b === undefined ? undefined : _b.typeName) === "ZodOptional";
+    return ((_b = (_a = v4Schema._zod) === null || _a === undefined ? undefined : _a.def) === null || _b === undefined ? undefined : _b.type) === "optional";
   }
   const v3Schema = schema;
   if (typeof schema.isOptional === "function") {
@@ -61730,17 +61730,27 @@ function date4(params) {
 // ../../node_modules/.bun/zod@4.1.12/node_modules/zod/v4/classic/external.js
 config(en_default2());
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.23.0/node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
-var LATEST_PROTOCOL_VERSION = "2025-06-18";
-var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-03-26", "2024-11-05", "2024-10-07"];
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.24.3/node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
+var LATEST_PROTOCOL_VERSION = "2025-11-25";
+var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"];
+var RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task";
 var JSONRPC_VERSION = "2.0";
 var AssertObjectSchema = custom((v) => v !== null && (typeof v === "object" || typeof v === "function"));
 var ProgressTokenSchema = union([string2(), number2().int()]);
 var CursorSchema = string2();
+var TaskCreationParamsSchema = looseObject({
+  ttl: union([number2(), _null3()]).optional(),
+  pollInterval: number2().optional()
+});
+var RelatedTaskMetadataSchema = looseObject({
+  taskId: string2()
+});
 var RequestMetaSchema = looseObject({
-  progressToken: ProgressTokenSchema.optional()
+  progressToken: ProgressTokenSchema.optional(),
+  [RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional()
 });
 var BaseRequestParamsSchema = looseObject({
+  task: TaskCreationParamsSchema.optional(),
   _meta: RequestMetaSchema.optional()
 });
 var RequestSchema = object2({
@@ -61748,14 +61758,18 @@ var RequestSchema = object2({
   params: BaseRequestParamsSchema.optional()
 });
 var NotificationsParamsSchema = looseObject({
-  _meta: record(string2(), unknown()).optional()
+  _meta: object2({
+    [RELATED_TASK_META_KEY]: optional(RelatedTaskMetadataSchema)
+  }).passthrough().optional()
 });
 var NotificationSchema = object2({
   method: string2(),
   params: NotificationsParamsSchema.optional()
 });
 var ResultSchema = looseObject({
-  _meta: record(string2(), unknown()).optional()
+  _meta: looseObject({
+    [RELATED_TASK_META_KEY]: RelatedTaskMetadataSchema.optional()
+  }).optional()
 });
 var RequestIdSchema = union([string2(), number2().int()]);
 var JSONRPCRequestSchema = object2({
@@ -61838,6 +61852,27 @@ var ElicitationCapabilitySchema = preprocess((value) => {
   form: FormElicitationCapabilitySchema.optional(),
   url: AssertObjectSchema.optional()
 }), record(string2(), unknown()).optional()));
+var ClientTasksCapabilitySchema = object2({
+  list: optional(object2({}).passthrough()),
+  cancel: optional(object2({}).passthrough()),
+  requests: optional(object2({
+    sampling: optional(object2({
+      createMessage: optional(object2({}).passthrough())
+    }).passthrough()),
+    elicitation: optional(object2({
+      create: optional(object2({}).passthrough())
+    }).passthrough())
+  }).passthrough())
+}).passthrough();
+var ServerTasksCapabilitySchema = object2({
+  list: optional(object2({}).passthrough()),
+  cancel: optional(object2({}).passthrough()),
+  requests: optional(object2({
+    tools: optional(object2({
+      call: optional(object2({}).passthrough())
+    }).passthrough())
+  }).passthrough())
+}).passthrough();
 var ClientCapabilitiesSchema = object2({
   experimental: record(string2(), AssertObjectSchema).optional(),
   sampling: object2({
@@ -61847,7 +61882,8 @@ var ClientCapabilitiesSchema = object2({
   elicitation: ElicitationCapabilitySchema.optional(),
   roots: object2({
     listChanged: boolean2().optional()
-  }).optional()
+  }).optional(),
+  tasks: optional(ClientTasksCapabilitySchema)
 });
 var InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
   protocolVersion: string2(),
@@ -61871,8 +61907,9 @@ var ServerCapabilitiesSchema = object2({
   }).optional(),
   tools: object2({
     listChanged: boolean2().optional()
-  }).optional()
-});
+  }).optional(),
+  tasks: optional(ServerTasksCapabilitySchema)
+}).passthrough();
 var InitializeResultSchema = ResultSchema.extend({
   protocolVersion: string2(),
   capabilities: ServerCapabilitiesSchema,
@@ -61908,6 +61945,49 @@ var PaginatedRequestSchema = RequestSchema.extend({
 var PaginatedResultSchema = ResultSchema.extend({
   nextCursor: optional(CursorSchema)
 });
+var TaskSchema = object2({
+  taskId: string2(),
+  status: _enum2(["working", "input_required", "completed", "failed", "cancelled"]),
+  ttl: union([number2(), _null3()]),
+  createdAt: string2(),
+  lastUpdatedAt: string2(),
+  pollInterval: optional(number2()),
+  statusMessage: optional(string2())
+});
+var CreateTaskResultSchema = ResultSchema.extend({
+  task: TaskSchema
+});
+var TaskStatusNotificationParamsSchema = NotificationsParamsSchema.merge(TaskSchema);
+var TaskStatusNotificationSchema = NotificationSchema.extend({
+  method: literal("notifications/tasks/status"),
+  params: TaskStatusNotificationParamsSchema
+});
+var GetTaskRequestSchema = RequestSchema.extend({
+  method: literal("tasks/get"),
+  params: BaseRequestParamsSchema.extend({
+    taskId: string2()
+  })
+});
+var GetTaskResultSchema = ResultSchema.merge(TaskSchema);
+var GetTaskPayloadRequestSchema = RequestSchema.extend({
+  method: literal("tasks/result"),
+  params: BaseRequestParamsSchema.extend({
+    taskId: string2()
+  })
+});
+var ListTasksRequestSchema = PaginatedRequestSchema.extend({
+  method: literal("tasks/list")
+});
+var ListTasksResultSchema = PaginatedResultSchema.extend({
+  tasks: array(TaskSchema)
+});
+var CancelTaskRequestSchema = RequestSchema.extend({
+  method: literal("tasks/cancel"),
+  params: BaseRequestParamsSchema.extend({
+    taskId: string2()
+  })
+});
+var CancelTaskResultSchema = ResultSchema.merge(TaskSchema);
 var ResourceContentsSchema = object2({
   uri: string2(),
   mimeType: optional(string2()),
@@ -61927,12 +62007,18 @@ var Base64Schema = string2().refine((val) => {
 var BlobResourceContentsSchema = ResourceContentsSchema.extend({
   blob: Base64Schema
 });
+var AnnotationsSchema = object2({
+  audience: array(_enum2(["user", "assistant"])).optional(),
+  priority: number2().min(0).max(1).optional(),
+  lastModified: exports_iso2.datetime({ offset: true }).optional()
+});
 var ResourceSchema = object2({
   ...BaseMetadataSchema.shape,
   ...IconsSchema.shape,
   uri: string2(),
   description: optional(string2()),
   mimeType: optional(string2()),
+  annotations: AnnotationsSchema.optional(),
   _meta: optional(looseObject({}))
 });
 var ResourceTemplateSchema = object2({
@@ -61941,6 +62027,7 @@ var ResourceTemplateSchema = object2({
   uriTemplate: string2(),
   description: optional(string2()),
   mimeType: optional(string2()),
+  annotations: AnnotationsSchema.optional(),
   _meta: optional(looseObject({}))
 });
 var ListResourcesRequestSchema = PaginatedRequestSchema.extend({
@@ -62015,18 +62102,21 @@ var GetPromptRequestSchema = RequestSchema.extend({
 var TextContentSchema = object2({
   type: literal("text"),
   text: string2(),
+  annotations: AnnotationsSchema.optional(),
   _meta: record(string2(), unknown()).optional()
 });
 var ImageContentSchema = object2({
   type: literal("image"),
   data: Base64Schema,
   mimeType: string2(),
+  annotations: AnnotationsSchema.optional(),
   _meta: record(string2(), unknown()).optional()
 });
 var AudioContentSchema = object2({
   type: literal("audio"),
   data: Base64Schema,
   mimeType: string2(),
+  annotations: AnnotationsSchema.optional(),
   _meta: record(string2(), unknown()).optional()
 });
 var ToolUseContentSchema = object2({
@@ -62039,6 +62129,7 @@ var ToolUseContentSchema = object2({
 var EmbeddedResourceSchema = object2({
   type: literal("resource"),
   resource: union([TextResourceContentsSchema, BlobResourceContentsSchema]),
+  annotations: AnnotationsSchema.optional(),
   _meta: record(string2(), unknown()).optional()
 });
 var ResourceLinkSchema = ResourceSchema.extend({
@@ -62069,6 +62160,9 @@ var ToolAnnotationsSchema = object2({
   idempotentHint: boolean2().optional(),
   openWorldHint: boolean2().optional()
 });
+var ToolExecutionSchema = object2({
+  taskSupport: _enum2(["required", "optional", "forbidden"]).optional()
+});
 var ToolSchema = object2({
   ...BaseMetadataSchema.shape,
   ...IconsSchema.shape,
@@ -62084,6 +62178,7 @@ var ToolSchema = object2({
     required: array(string2()).optional()
   }).catchall(unknown()).optional(),
   annotations: optional(ToolAnnotationsSchema),
+  execution: optional(ToolExecutionSchema),
   _meta: record(string2(), unknown()).optional()
 });
 var ListToolsRequestSchema = PaginatedRequestSchema.extend({
@@ -62148,6 +62243,7 @@ var ToolResultContentSchema = object2({
   isError: optional(boolean2()),
   _meta: optional(object2({}).passthrough())
 }).passthrough();
+var SamplingContentSchema = discriminatedUnion("type", [TextContentSchema, ImageContentSchema, AudioContentSchema]);
 var SamplingMessageContentBlockSchema = discriminatedUnion("type", [
   TextContentSchema,
   ImageContentSchema,
@@ -62177,6 +62273,12 @@ var CreateMessageRequestSchema = RequestSchema.extend({
   params: CreateMessageRequestParamsSchema
 });
 var CreateMessageResultSchema = ResultSchema.extend({
+  model: string2(),
+  stopReason: optional(_enum2(["endTurn", "stopSequence", "maxTokens"]).or(string2())),
+  role: _enum2(["user", "assistant"]),
+  content: SamplingContentSchema
+});
+var CreateMessageResultWithToolsSchema = ResultSchema.extend({
   model: string2(),
   stopReason: optional(_enum2(["endTurn", "stopSequence", "maxTokens", "toolUse"]).or(string2())),
   role: _enum2(["user", "assistant"]),
@@ -62289,7 +62391,7 @@ var ElicitationCompleteNotificationSchema = NotificationSchema.extend({
 });
 var ElicitResultSchema = ResultSchema.extend({
   action: _enum2(["accept", "decline", "cancel"]),
-  content: record(string2(), union([string2(), number2(), boolean2(), array(string2())])).optional()
+  content: preprocess((val) => val === null ? undefined : val, record(string2(), union([string2(), number2(), boolean2(), array(string2())])).optional())
 });
 var ResourceTemplateReferenceSchema = object2({
   type: literal("ref/resource"),
@@ -62357,16 +62459,37 @@ var ClientRequestSchema = union([
   SubscribeRequestSchema,
   UnsubscribeRequestSchema,
   CallToolRequestSchema,
-  ListToolsRequestSchema
+  ListToolsRequestSchema,
+  GetTaskRequestSchema,
+  GetTaskPayloadRequestSchema,
+  ListTasksRequestSchema
 ]);
 var ClientNotificationSchema = union([
   CancelledNotificationSchema,
   ProgressNotificationSchema,
   InitializedNotificationSchema,
-  RootsListChangedNotificationSchema
+  RootsListChangedNotificationSchema,
+  TaskStatusNotificationSchema
+]);
+var ClientResultSchema = union([
+  EmptyResultSchema,
+  CreateMessageResultSchema,
+  CreateMessageResultWithToolsSchema,
+  ElicitResultSchema,
+  ListRootsResultSchema,
+  GetTaskResultSchema,
+  ListTasksResultSchema,
+  CreateTaskResultSchema
+]);
+var ServerRequestSchema = union([
+  PingRequestSchema,
+  CreateMessageRequestSchema,
+  ElicitRequestSchema,
+  ListRootsRequestSchema,
+  GetTaskRequestSchema,
+  GetTaskPayloadRequestSchema,
+  ListTasksRequestSchema
 ]);
-var ClientResultSchema = union([EmptyResultSchema, CreateMessageResultSchema, ElicitResultSchema, ListRootsResultSchema]);
-var ServerRequestSchema = union([PingRequestSchema, CreateMessageRequestSchema, ElicitRequestSchema, ListRootsRequestSchema]);
 var ServerNotificationSchema = union([
   CancelledNotificationSchema,
   ProgressNotificationSchema,
@@ -62375,6 +62498,7 @@ var ServerNotificationSchema = union([
   ResourceListChangedNotificationSchema,
   ToolListChangedNotificationSchema,
   PromptListChangedNotificationSchema,
+  TaskStatusNotificationSchema,
   ElicitationCompleteNotificationSchema
 ]);
 var ServerResultSchema = union([
@@ -62387,7 +62511,10 @@ var ServerResultSchema = union([
   ListResourceTemplatesResultSchema,
   ReadResourceResultSchema,
   CallToolResultSchema,
-  ListToolsResultSchema
+  ListToolsResultSchema,
+  GetTaskResultSchema,
+  ListTasksResultSchema,
+  CreateTaskResultSchema
 ]);
 
 class McpError extends Error {
@@ -62420,6 +62547,11 @@ class UrlElicitationRequiredError extends McpError {
   }
 }
 
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.24.3/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/interfaces.js
+function isTerminal(status) {
+  return status === "completed" || status === "failed" || status === "cancelled";
+}
+
 // ../../node_modules/.bun/zod-to-json-schema@3.25.0+5954958163efbb2a/node_modules/zod-to-json-schema/dist/esm/Options.js
 var ignoreOverride = Symbol("Let zodToJsonSchema decide on which parser to use");
 var defaultOptions = {
@@ -63656,7 +63788,7 @@ var zodToJsonSchema = (schema, options) => {
   }
   return combined;
 };
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.23.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.24.3/node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-json-schema-compat.js
 function mapMiniTarget(t) {
   if (!t)
     return "draft-7";
@@ -63699,7 +63831,7 @@ function parseWithCompat(schema, data) {
   return result.data;
 }
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.23.0/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.24.3/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/protocol.js
 var DEFAULT_REQUEST_TIMEOUT_MSEC = 60000;
 
 class Protocol {
@@ -63713,14 +63845,125 @@ class Protocol {
     this._progressHandlers = new Map;
     this._timeoutInfo = new Map;
     this._pendingDebouncedNotifications = new Set;
+    this._taskProgressTokens = new Map;
+    this._requestResolvers = new Map;
     this.setNotificationHandler(CancelledNotificationSchema, (notification) => {
-      const controller = this._requestHandlerAbortControllers.get(notification.params.requestId);
-      controller === null || controller === undefined || controller.abort(notification.params.reason);
+      this._oncancel(notification);
     });
     this.setNotificationHandler(ProgressNotificationSchema, (notification) => {
       this._onprogress(notification);
     });
     this.setRequestHandler(PingRequestSchema, (_request) => ({}));
+    this._taskStore = _options === null || _options === undefined ? undefined : _options.taskStore;
+    this._taskMessageQueue = _options === null || _options === undefined ? undefined : _options.taskMessageQueue;
+    if (this._taskStore) {
+      this.setRequestHandler(GetTaskRequestSchema, async (request, extra) => {
+        const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+        if (!task) {
+          throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
+        }
+        return {
+          ...task
+        };
+      });
+      this.setRequestHandler(GetTaskPayloadRequestSchema, async (request, extra) => {
+        const handleTaskResult = async () => {
+          var _a;
+          const taskId = request.params.taskId;
+          if (this._taskMessageQueue) {
+            let queuedMessage;
+            while (queuedMessage = await this._taskMessageQueue.dequeue(taskId, extra.sessionId)) {
+              if (queuedMessage.type === "response" || queuedMessage.type === "error") {
+                const message = queuedMessage.message;
+                const requestId = message.id;
+                const resolver = this._requestResolvers.get(requestId);
+                if (resolver) {
+                  this._requestResolvers.delete(requestId);
+                  if (queuedMessage.type === "response") {
+                    resolver(message);
+                  } else {
+                    const errorMessage = message;
+                    const error46 = new McpError(errorMessage.error.code, errorMessage.error.message, errorMessage.error.data);
+                    resolver(error46);
+                  }
+                } else {
+                  const messageType = queuedMessage.type === "response" ? "Response" : "Error";
+                  this._onerror(new Error(`${messageType} handler missing for request ${requestId}`));
+                }
+                continue;
+              }
+              await ((_a = this._transport) === null || _a === undefined ? undefined : _a.send(queuedMessage.message, { relatedRequestId: extra.requestId }));
+            }
+          }
+          const task = await this._taskStore.getTask(taskId, extra.sessionId);
+          if (!task) {
+            throw new McpError(ErrorCode.InvalidParams, `Task not found: ${taskId}`);
+          }
+          if (!isTerminal(task.status)) {
+            await this._waitForTaskUpdate(taskId, extra.signal);
+            return await handleTaskResult();
+          }
+          if (isTerminal(task.status)) {
+            const result = await this._taskStore.getTaskResult(taskId, extra.sessionId);
+            this._clearTaskQueue(taskId);
+            return {
+              ...result,
+              _meta: {
+                ...result._meta,
+                [RELATED_TASK_META_KEY]: {
+                  taskId
+                }
+              }
+            };
+          }
+          return await handleTaskResult();
+        };
+        return await handleTaskResult();
+      });
+      this.setRequestHandler(ListTasksRequestSchema, async (request, extra) => {
+        var _a;
+        try {
+          const { tasks, nextCursor } = await this._taskStore.listTasks((_a = request.params) === null || _a === undefined ? undefined : _a.cursor, extra.sessionId);
+          return {
+            tasks,
+            nextCursor,
+            _meta: {}
+          };
+        } catch (error46) {
+          throw new McpError(ErrorCode.InvalidParams, `Failed to list tasks: ${error46 instanceof Error ? error46.message : String(error46)}`);
+        }
+      });
+      this.setRequestHandler(CancelTaskRequestSchema, async (request, extra) => {
+        try {
+          const task = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+          if (!task) {
+            throw new McpError(ErrorCode.InvalidParams, `Task not found: ${request.params.taskId}`);
+          }
+          if (isTerminal(task.status)) {
+            throw new McpError(ErrorCode.InvalidParams, `Cannot cancel task in terminal status: ${task.status}`);
+          }
+          await this._taskStore.updateTaskStatus(request.params.taskId, "cancelled", "Client cancelled task execution.", extra.sessionId);
+          this._clearTaskQueue(request.params.taskId);
+          const cancelledTask = await this._taskStore.getTask(request.params.taskId, extra.sessionId);
+          if (!cancelledTask) {
+            throw new McpError(ErrorCode.InvalidParams, `Task not found after cancellation: ${request.params.taskId}`);
+          }
+          return {
+            _meta: {},
+            ...cancelledTask
+          };
+        } catch (error46) {
+          if (error46 instanceof McpError) {
+            throw error46;
+          }
+          throw new McpError(ErrorCode.InvalidRequest, `Failed to cancel task: ${error46 instanceof Error ? error46.message : String(error46)}`);
+        }
+      });
+    }
+  }
+  async _oncancel(notification) {
+    const controller = this._requestHandlerAbortControllers.get(notification.params.requestId);
+    controller === null || controller === undefined || controller.abort(notification.params.reason);
   }
   _setupTimeout(messageId, timeout, maxTotalTimeout, onTimeout, resetTimeoutOnProgress = false) {
     this._timeoutInfo.set(messageId, {
@@ -63788,10 +64031,11 @@ class Protocol {
     const responseHandlers = this._responseHandlers;
     this._responseHandlers = new Map;
     this._progressHandlers.clear();
+    this._taskProgressTokens.clear();
     this._pendingDebouncedNotifications.clear();
+    const error46 = McpError.fromError(ErrorCode.ConnectionClosed, "Connection closed");
     this._transport = undefined;
     (_a = this.onclose) === null || _a === undefined || _a.call(this);
-    const error46 = McpError.fromError(ErrorCode.ConnectionClosed, "Connection closed");
     for (const handler of responseHandlers.values()) {
       handler(error46);
     }
@@ -63809,47 +64053,94 @@ class Protocol {
     Promise.resolve().then(() => handler(notification)).catch((error46) => this._onerror(new Error(`Uncaught error in notification handler: ${error46}`)));
   }
   _onrequest(request, extra) {
-    var _a, _b;
+    var _a, _b, _c, _d, _e, _f;
     const handler = (_a = this._requestHandlers.get(request.method)) !== null && _a !== undefined ? _a : this.fallbackRequestHandler;
     const capturedTransport = this._transport;
+    const relatedTaskId = (_d = (_c = (_b = request.params) === null || _b === undefined ? undefined : _b._meta) === null || _c === undefined ? undefined : _c[RELATED_TASK_META_KEY]) === null || _d === undefined ? undefined : _d.taskId;
     if (handler === undefined) {
-      capturedTransport === null || capturedTransport === undefined || capturedTransport.send({
+      const errorResponse = {
         jsonrpc: "2.0",
         id: request.id,
         error: {
           code: ErrorCode.MethodNotFound,
           message: "Method not found"
         }
-      }).catch((error46) => this._onerror(new Error(`Failed to send an error response: ${error46}`)));
+      };
+      if (relatedTaskId && this._taskMessageQueue) {
+        this._enqueueTaskMessage(relatedTaskId, {
+          type: "error",
+          message: errorResponse,
+          timestamp: Date.now()
+        }, capturedTransport === null || capturedTransport === undefined ? undefined : capturedTransport.sessionId).catch((error46) => this._onerror(new Error(`Failed to enqueue error response: ${error46}`)));
+      } else {
+        capturedTransport === null || capturedTransport === undefined || capturedTransport.send(errorResponse).catch((error46) => this._onerror(new Error(`Failed to send an error response: ${error46}`)));
+      }
       return;
     }
     const abortController = new AbortController;
     this._requestHandlerAbortControllers.set(request.id, abortController);
+    const taskCreationParams = (_e = request.params) === null || _e === undefined ? undefined : _e.task;
+    const taskStore = this._taskStore ? this.requestTaskStore(request, capturedTransport === null || capturedTransport === undefined ? undefined : capturedTransport.sessionId) : undefined;
     const fullExtra = {
       signal: abortController.signal,
       sessionId: capturedTransport === null || capturedTransport === undefined ? undefined : capturedTransport.sessionId,
-      _meta: (_b = request.params) === null || _b === undefined ? undefined : _b._meta,
-      sendNotification: (notification) => this.notification(notification, { relatedRequestId: request.id }),
-      sendRequest: (r, resultSchema, options) => this.request(r, resultSchema, { ...options, relatedRequestId: request.id }),
+      _meta: (_f = request.params) === null || _f === undefined ? undefined : _f._meta,
+      sendNotification: async (notification) => {
+        const notificationOptions = { relatedRequestId: request.id };
+        if (relatedTaskId) {
+          notificationOptions.relatedTask = { taskId: relatedTaskId };
+        }
+        await this.notification(notification, notificationOptions);
+      },
+      sendRequest: async (r, resultSchema, options) => {
+        var _a2, _b2;
+        const requestOptions = { ...options, relatedRequestId: request.id };
+        if (relatedTaskId && !requestOptions.relatedTask) {
+          requestOptions.relatedTask = { taskId: relatedTaskId };
+        }
+        const effectiveTaskId = (_b2 = (_a2 = requestOptions.relatedTask) === null || _a2 === undefined ? undefined : _a2.taskId) !== null && _b2 !== undefined ? _b2 : relatedTaskId;
+        if (effectiveTaskId && taskStore) {
+          await taskStore.updateTaskStatus(effectiveTaskId, "input_required");
+        }
+        return await this.request(r, resultSchema, requestOptions);
+      },
       authInfo: extra === null || extra === undefined ? undefined : extra.authInfo,
       requestId: request.id,
-      requestInfo: extra === null || extra === undefined ? undefined : extra.requestInfo
+      requestInfo: extra === null || extra === undefined ? undefined : extra.requestInfo,
+      taskId: relatedTaskId,
+      taskStore,
+      taskRequestedTtl: taskCreationParams === null || taskCreationParams === undefined ? undefined : taskCreationParams.ttl,
+      closeSSEStream: extra === null || extra === undefined ? undefined : extra.closeSSEStream,
+      closeStandaloneSSEStream: extra === null || extra === undefined ? undefined : extra.closeStandaloneSSEStream
     };
-    Promise.resolve().then(() => handler(request, fullExtra)).then((result) => {
+    Promise.resolve().then(() => {
+      if (taskCreationParams) {
+        this.assertTaskHandlerCapability(request.method);
+      }
+    }).then(() => handler(request, fullExtra)).then(async (result) => {
       if (abortController.signal.aborted) {
         return;
       }
-      return capturedTransport === null || capturedTransport === undefined ? undefined : capturedTransport.send({
+      const response = {
         result,
         jsonrpc: "2.0",
         id: request.id
-      });
-    }, (error46) => {
+      };
+      if (relatedTaskId && this._taskMessageQueue) {
+        await this._enqueueTaskMessage(relatedTaskId, {
+          type: "response",
+          message: response,
+          timestamp: Date.now()
+        }, capturedTransport === null || capturedTransport === undefined ? undefined : capturedTransport.sessionId);
+      } else {
+        await (capturedTransport === null || capturedTransport === undefined ? undefined : capturedTransport.send(response));
+      }
+    }, async (error46) => {
       var _a2;
       if (abortController.signal.aborted) {
         return;
       }
-      return capturedTransport === null || capturedTransport === undefined ? undefined : capturedTransport.send({
+      const errorResponse = {
         jsonrpc: "2.0",
         id: request.id,
         error: {
@@ -63857,7 +64148,16 @@ class Protocol {
           message: (_a2 = error46.message) !== null && _a2 !== undefined ? _a2 : "Internal error",
           ...error46["data"] !== undefined && { data: error46["data"] }
         }
-      });
+      };
+      if (relatedTaskId && this._taskMessageQueue) {
+        await this._enqueueTaskMessage(relatedTaskId, {
+          type: "error",
+          message: errorResponse,
+          timestamp: Date.now()
+        }, capturedTransport === null || capturedTransport === undefined ? undefined : capturedTransport.sessionId);
+      } else {
+        await (capturedTransport === null || capturedTransport === undefined ? undefined : capturedTransport.send(errorResponse));
+      }
     }).catch((error46) => this._onerror(new Error(`Failed to send response: ${error46}`))).finally(() => {
       this._requestHandlerAbortControllers.delete(request.id);
     });
@@ -63876,6 +64176,9 @@ class Protocol {
       try {
         this._resetTimeout(messageId);
       } catch (error46) {
+        this._responseHandlers.delete(messageId);
+        this._progressHandlers.delete(messageId);
+        this._cleanupTimeout(messageId);
         responseHandler(error46);
         return;
       }
@@ -63884,14 +64187,38 @@ class Protocol {
   }
   _onresponse(response) {
     const messageId = Number(response.id);
+    const resolver = this._requestResolvers.get(messageId);
+    if (resolver) {
+      this._requestResolvers.delete(messageId);
+      if (isJSONRPCResponse(response)) {
+        resolver(response);
+      } else {
+        const error46 = new McpError(response.error.code, response.error.message, response.error.data);
+        resolver(error46);
+      }
+      return;
+    }
     const handler = this._responseHandlers.get(messageId);
     if (handler === undefined) {
       this._onerror(new Error(`Received a response for an unknown message ID: ${JSON.stringify(response)}`));
       return;
     }
     this._responseHandlers.delete(messageId);
-    this._progressHandlers.delete(messageId);
     this._cleanupTimeout(messageId);
+    let isTaskResponse = false;
+    if (isJSONRPCResponse(response) && response.result && typeof response.result === "object") {
+      const result = response.result;
+      if (result.task && typeof result.task === "object") {
+        const task = result.task;
+        if (typeof task.taskId === "string") {
+          isTaskResponse = true;
+          this._taskProgressTokens.set(task.taskId, messageId);
+        }
+      }
+    }
+    if (!isTaskResponse) {
+      this._progressHandlers.delete(messageId);
+    }
     if (isJSONRPCResponse(response)) {
       handler(response);
     } else {
@@ -63906,16 +64233,87 @@ class Protocol {
     var _a;
     await ((_a = this._transport) === null || _a === undefined ? undefined : _a.close());
   }
+  async* requestStream(request, resultSchema, options) {
+    var _a, _b, _c, _d;
+    const { task } = options !== null && options !== undefined ? options : {};
+    if (!task) {
+      try {
+        const result = await this.request(request, resultSchema, options);
+        yield { type: "result", result };
+      } catch (error46) {
+        yield {
+          type: "error",
+          error: error46 instanceof McpError ? error46 : new McpError(ErrorCode.InternalError, String(error46))
+        };
+      }
+      return;
+    }
+    let taskId;
+    try {
+      const createResult = await this.request(request, CreateTaskResultSchema, options);
+      if (createResult.task) {
+        taskId = createResult.task.taskId;
+        yield { type: "taskCreated", task: createResult.task };
+      } else {
+        throw new McpError(ErrorCode.InternalError, "Task creation did not return a task");
+      }
+      while (true) {
+        const task2 = await this.getTask({ taskId }, options);
+        yield { type: "taskStatus", task: task2 };
+        if (isTerminal(task2.status)) {
+          if (task2.status === "completed") {
+            const result = await this.getTaskResult({ taskId }, resultSchema, options);
+            yield { type: "result", result };
+          } else if (task2.status === "failed") {
+            yield {
+              type: "error",
+              error: new McpError(ErrorCode.InternalError, `Task ${taskId} failed`)
+            };
+          } else if (task2.status === "cancelled") {
+            yield {
+              type: "error",
+              error: new McpError(ErrorCode.InternalError, `Task ${taskId} was cancelled`)
+            };
+          }
+          return;
+        }
+        if (task2.status === "input_required") {
+          const result = await this.getTaskResult({ taskId }, resultSchema, options);
+          yield { type: "result", result };
+          return;
+        }
+        const pollInterval = (_c = (_a = task2.pollInterval) !== null && _a !== undefined ? _a : (_b = this._options) === null || _b === undefined ? undefined : _b.defaultTaskPollInterval) !== null && _c !== undefined ? _c : 1000;
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        (_d = options === null || options === undefined ? undefined : options.signal) === null || _d === undefined || _d.throwIfAborted();
+      }
+    } catch (error46) {
+      yield {
+        type: "error",
+        error: error46 instanceof McpError ? error46 : new McpError(ErrorCode.InternalError, String(error46))
+      };
+    }
+  }
   request(request, resultSchema, options) {
-    const { relatedRequestId, resumptionToken, onresumptiontoken } = options !== null && options !== undefined ? options : {};
+    const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options !== null && options !== undefined ? options : {};
     return new Promise((resolve, reject) => {
-      var _a, _b, _c, _d, _e, _f;
+      var _a, _b, _c, _d, _e, _f, _g;
+      const earlyReject = (error46) => {
+        reject(error46);
+      };
       if (!this._transport) {
-        reject(new Error("Not connected"));
+        earlyReject(new Error("Not connected"));
         return;
       }
       if (((_a = this._options) === null || _a === undefined ? undefined : _a.enforceStrictCapabilities) === true) {
-        this.assertCapabilityForMethod(request.method);
+        try {
+          this.assertCapabilityForMethod(request.method);
+          if (task) {
+            this.assertTaskCapability(request.method);
+          }
+        } catch (e) {
+          earlyReject(e);
+          return;
+        }
       }
       (_b = options === null || options === undefined ? undefined : options.signal) === null || _b === undefined || _b.throwIfAborted();
       const messageId = this._requestMessageId++;
@@ -63934,6 +64332,21 @@ class Protocol {
           }
         };
       }
+      if (task) {
+        jsonrpcRequest.params = {
+          ...jsonrpcRequest.params,
+          task
+        };
+      }
+      if (relatedTask) {
+        jsonrpcRequest.params = {
+          ...jsonrpcRequest.params,
+          _meta: {
+            ...((_d = jsonrpcRequest.params) === null || _d === undefined ? undefined : _d._meta) || {},
+            [RELATED_TASK_META_KEY]: relatedTask
+          }
+        };
+      }
       const cancel = (reason) => {
         var _a2;
         this._responseHandlers.delete(messageId);
@@ -63946,8 +64359,9 @@ class Protocol {
             requestId: messageId,
             reason: String(reason)
           }
-        }, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error46) => this._onerror(new Error(`Failed to send cancellation: ${error46}`)));
-        reject(reason);
+        }, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error47) => this._onerror(new Error(`Failed to send cancellation: ${error47}`)));
+        const error46 = reason instanceof McpError ? reason : new McpError(ErrorCode.RequestTimeout, String(reason));
+        reject(error46);
       };
       this._responseHandlers.set(messageId, (response) => {
         var _a2;
@@ -63968,50 +64382,127 @@ class Protocol {
           reject(error46);
         }
       });
-      (_d = options === null || options === undefined ? undefined : options.signal) === null || _d === undefined || _d.addEventListener("abort", () => {
+      (_e = options === null || options === undefined ? undefined : options.signal) === null || _e === undefined || _e.addEventListener("abort", () => {
         var _a2;
         cancel((_a2 = options === null || options === undefined ? undefined : options.signal) === null || _a2 === undefined ? undefined : _a2.reason);
       });
-      const timeout = (_e = options === null || options === undefined ? undefined : options.timeout) !== null && _e !== undefined ? _e : DEFAULT_REQUEST_TIMEOUT_MSEC;
+      const timeout = (_f = options === null || options === undefined ? undefined : options.timeout) !== null && _f !== undefined ? _f : DEFAULT_REQUEST_TIMEOUT_MSEC;
       const timeoutHandler = () => cancel(McpError.fromError(ErrorCode.RequestTimeout, "Request timed out", { timeout }));
-      this._setupTimeout(messageId, timeout, options === null || options === undefined ? undefined : options.maxTotalTimeout, timeoutHandler, (_f = options === null || options === undefined ? undefined : options.resetTimeoutOnProgress) !== null && _f !== undefined ? _f : false);
-      this._transport.send(jsonrpcRequest, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error46) => {
-        this._cleanupTimeout(messageId);
-        reject(error46);
-      });
+      this._setupTimeout(messageId, timeout, options === null || options === undefined ? undefined : options.maxTotalTimeout, timeoutHandler, (_g = options === null || options === undefined ? undefined : options.resetTimeoutOnProgress) !== null && _g !== undefined ? _g : false);
+      const relatedTaskId = relatedTask === null || relatedTask === undefined ? undefined : relatedTask.taskId;
+      if (relatedTaskId) {
+        const responseResolver = (response) => {
+          const handler = this._responseHandlers.get(messageId);
+          if (handler) {
+            handler(response);
+          } else {
+            this._onerror(new Error(`Response handler missing for side-channeled request ${messageId}`));
+          }
+        };
+        this._requestResolvers.set(messageId, responseResolver);
+        this._enqueueTaskMessage(relatedTaskId, {
+          type: "request",
+          message: jsonrpcRequest,
+          timestamp: Date.now()
+        }).catch((error46) => {
+          this._cleanupTimeout(messageId);
+          reject(error46);
+        });
+      } else {
+        this._transport.send(jsonrpcRequest, { relatedRequestId, resumptionToken, onresumptiontoken }).catch((error46) => {
+          this._cleanupTimeout(messageId);
+          reject(error46);
+        });
+      }
     });
   }
+  async getTask(params, options) {
+    return this.request({ method: "tasks/get", params }, GetTaskResultSchema, options);
+  }
+  async getTaskResult(params, resultSchema, options) {
+    return this.request({ method: "tasks/result", params }, resultSchema, options);
+  }
+  async listTasks(params, options) {
+    return this.request({ method: "tasks/list", params }, ListTasksResultSchema, options);
+  }
+  async cancelTask(params, options) {
+    return this.request({ method: "tasks/cancel", params }, CancelTaskResultSchema, options);
+  }
   async notification(notification, options) {
-    var _a, _b;
+    var _a, _b, _c, _d, _e;
     if (!this._transport) {
       throw new Error("Not connected");
     }
     this.assertNotificationCapability(notification.method);
-    const debouncedMethods = (_b = (_a = this._options) === null || _a === undefined ? undefined : _a.debouncedNotificationMethods) !== null && _b !== undefined ? _b : [];
-    const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !(options === null || options === undefined ? undefined : options.relatedRequestId);
+    const relatedTaskId = (_a = options === null || options === undefined ? undefined : options.relatedTask) === null || _a === undefined ? undefined : _a.taskId;
+    if (relatedTaskId) {
+      const jsonrpcNotification2 = {
+        ...notification,
+        jsonrpc: "2.0",
+        params: {
+          ...notification.params,
+          _meta: {
+            ...((_b = notification.params) === null || _b === undefined ? undefined : _b._meta) || {},
+            [RELATED_TASK_META_KEY]: options.relatedTask
+          }
+        }
+      };
+      await this._enqueueTaskMessage(relatedTaskId, {
+        type: "notification",
+        message: jsonrpcNotification2,
+        timestamp: Date.now()
+      });
+      return;
+    }
+    const debouncedMethods = (_d = (_c = this._options) === null || _c === undefined ? undefined : _c.debouncedNotificationMethods) !== null && _d !== undefined ? _d : [];
+    const canDebounce = debouncedMethods.includes(notification.method) && !notification.params && !(options === null || options === undefined ? undefined : options.relatedRequestId) && !(options === null || options === undefined ? undefined : options.relatedTask);
     if (canDebounce) {
       if (this._pendingDebouncedNotifications.has(notification.method)) {
         return;
       }
       this._pendingDebouncedNotifications.add(notification.method);
       Promise.resolve().then(() => {
-        var _a2;
+        var _a2, _b2;
         this._pendingDebouncedNotifications.delete(notification.method);
         if (!this._transport) {
           return;
         }
-        const jsonrpcNotification2 = {
+        let jsonrpcNotification2 = {
           ...notification,
           jsonrpc: "2.0"
         };
-        (_a2 = this._transport) === null || _a2 === undefined || _a2.send(jsonrpcNotification2, options).catch((error46) => this._onerror(error46));
+        if (options === null || options === undefined ? undefined : options.relatedTask) {
+          jsonrpcNotification2 = {
+            ...jsonrpcNotification2,
+            params: {
+              ...jsonrpcNotification2.params,
+              _meta: {
+                ...((_a2 = jsonrpcNotification2.params) === null || _a2 === undefined ? undefined : _a2._meta) || {},
+                [RELATED_TASK_META_KEY]: options.relatedTask
+              }
+            }
+          };
+        }
+        (_b2 = this._transport) === null || _b2 === undefined || _b2.send(jsonrpcNotification2, options).catch((error46) => this._onerror(error46));
       });
       return;
     }
-    const jsonrpcNotification = {
+    let jsonrpcNotification = {
       ...notification,
       jsonrpc: "2.0"
     };
+    if (options === null || options === undefined ? undefined : options.relatedTask) {
+      jsonrpcNotification = {
+        ...jsonrpcNotification,
+        params: {
+          ...jsonrpcNotification.params,
+          _meta: {
+            ...((_e = jsonrpcNotification.params) === null || _e === undefined ? undefined : _e._meta) || {},
+            [RELATED_TASK_META_KEY]: options.relatedTask
+          }
+        }
+      };
+    }
     await this._transport.send(jsonrpcNotification, options);
   }
   setRequestHandler(requestSchema, handler) {
@@ -64040,6 +64531,124 @@ class Protocol {
   removeNotificationHandler(method) {
     this._notificationHandlers.delete(method);
   }
+  _cleanupTaskProgressHandler(taskId) {
+    const progressToken = this._taskProgressTokens.get(taskId);
+    if (progressToken !== undefined) {
+      this._progressHandlers.delete(progressToken);
+      this._taskProgressTokens.delete(taskId);
+    }
+  }
+  async _enqueueTaskMessage(taskId, message, sessionId) {
+    var _a;
+    if (!this._taskStore || !this._taskMessageQueue) {
+      throw new Error("Cannot enqueue task message: taskStore and taskMessageQueue are not configured");
+    }
+    const maxQueueSize = (_a = this._options) === null || _a === undefined ? undefined : _a.maxTaskQueueSize;
+    await this._taskMessageQueue.enqueue(taskId, message, sessionId, maxQueueSize);
+  }
+  async _clearTaskQueue(taskId, sessionId) {
+    if (this._taskMessageQueue) {
+      const messages = await this._taskMessageQueue.dequeueAll(taskId, sessionId);
+      for (const message of messages) {
+        if (message.type === "request" && isJSONRPCRequest(message.message)) {
+          const requestId = message.message.id;
+          const resolver = this._requestResolvers.get(requestId);
+          if (resolver) {
+            resolver(new McpError(ErrorCode.InternalError, "Task cancelled or completed"));
+            this._requestResolvers.delete(requestId);
+          } else {
+            this._onerror(new Error(`Resolver missing for request ${requestId} during task ${taskId} cleanup`));
+          }
+        }
+      }
+    }
+  }
+  async _waitForTaskUpdate(taskId, signal) {
+    var _a, _b, _c;
+    let interval = (_b = (_a = this._options) === null || _a === undefined ? undefined : _a.defaultTaskPollInterval) !== null && _b !== undefined ? _b : 1000;
+    try {
+      const task = await ((_c = this._taskStore) === null || _c === undefined ? undefined : _c.getTask(taskId));
+      if (task === null || task === undefined ? undefined : task.pollInterval) {
+        interval = task.pollInterval;
+      }
+    } catch (_d) {}
+    return new Promise((resolve, reject) => {
+      if (signal.aborted) {
+        reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
+        return;
+      }
+      const timeoutId = setTimeout(resolve, interval);
+      signal.addEventListener("abort", () => {
+        clearTimeout(timeoutId);
+        reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
+      }, { once: true });
+    });
+  }
+  requestTaskStore(request, sessionId) {
+    const taskStore = this._taskStore;
+    if (!taskStore) {
+      throw new Error("No task store configured");
+    }
+    return {
+      createTask: async (taskParams) => {
+        if (!request) {
+          throw new Error("No request provided");
+        }
+        return await taskStore.createTask(taskParams, request.id, {
+          method: request.method,
+          params: request.params
+        }, sessionId);
+      },
+      getTask: async (taskId) => {
+        const task = await taskStore.getTask(taskId, sessionId);
+        if (!task) {
+          throw new McpError(ErrorCode.InvalidParams, "Failed to retrieve task: Task not found");
+        }
+        return task;
+      },
+      storeTaskResult: async (taskId, status, result) => {
+        await taskStore.storeTaskResult(taskId, status, result, sessionId);
+        const task = await taskStore.getTask(taskId, sessionId);
+        if (task) {
+          const notification = TaskStatusNotificationSchema.parse({
+            method: "notifications/tasks/status",
+            params: task
+          });
+          await this.notification(notification);
+          if (isTerminal(task.status)) {
+            this._cleanupTaskProgressHandler(taskId);
+          }
+        }
+      },
+      getTaskResult: (taskId) => {
+        return taskStore.getTaskResult(taskId, sessionId);
+      },
+      updateTaskStatus: async (taskId, status, statusMessage) => {
+        const task = await taskStore.getTask(taskId, sessionId);
+        if (!task) {
+          throw new McpError(ErrorCode.InvalidParams, `Task "${taskId}" not found - it may have been cleaned up`);
+        }
+        if (isTerminal(task.status)) {
+          throw new McpError(ErrorCode.InvalidParams, `Cannot update task "${taskId}" from terminal status "${task.status}" to "${status}". Terminal states (completed, failed, cancelled) cannot transition to other states.`);
+        }
+        await taskStore.updateTaskStatus(taskId, status, statusMessage, sessionId);
+        const updatedTask = await taskStore.getTask(taskId, sessionId);
+        if (updatedTask) {
+          const notification = TaskStatusNotificationSchema.parse({
+            method: "notifications/tasks/status",
+            params: updatedTask
+          });
+          await this.notification(notification);
+          if (isTerminal(updatedTask.status)) {
+            this._cleanupTaskProgressHandler(taskId);
+          }
+        }
+      },
+      listTasks: (cursor) => {
+        return taskStore.listTasks(cursor, sessionId);
+      }
+    };
+  }
 }
 function isPlainObject2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
@@ -64061,7 +64670,7 @@ function mergeCapabilities(base, additional) {
   return result;
 }
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.23.0/node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.24.3/node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js
 var import_ajv = __toESM(require_ajv(), 1);
 var import_ajv_formats = __toESM(require_dist(), 1);
 function createDefaultAjvInstance() {
@@ -64102,7 +64711,66 @@ class AjvJsonSchemaValidator {
   }
 }
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.23.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.24.3/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
+class ExperimentalServerTasks {
+  constructor(_server) {
+    this._server = _server;
+  }
+  requestStream(request, resultSchema, options) {
+    return this._server.requestStream(request, resultSchema, options);
+  }
+  async getTask(taskId, options) {
+    return this._server.getTask({ taskId }, options);
+  }
+  async getTaskResult(taskId, resultSchema, options) {
+    return this._server.getTaskResult({ taskId }, resultSchema, options);
+  }
+  async listTasks(cursor, options) {
+    return this._server.listTasks(cursor ? { cursor } : undefined, options);
+  }
+  async cancelTask(taskId, options) {
+    return this._server.cancelTask({ taskId }, options);
+  }
+}
+
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.24.3/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/helpers.js
+function assertToolsCallTaskCapability(requests, method, entityName) {
+  var _a;
+  if (!requests) {
+    throw new Error(`${entityName} does not support task creation (required for ${method})`);
+  }
+  switch (method) {
+    case "tools/call":
+      if (!((_a = requests.tools) === null || _a === undefined ? undefined : _a.call)) {
+        throw new Error(`${entityName} does not support task creation for tools/call (required for ${method})`);
+      }
+      break;
+    default:
+      break;
+  }
+}
+function assertClientRequestTaskCapability(requests, method, entityName) {
+  var _a, _b;
+  if (!requests) {
+    throw new Error(`${entityName} does not support task creation (required for ${method})`);
+  }
+  switch (method) {
+    case "sampling/createMessage":
+      if (!((_a = requests.sampling) === null || _a === undefined ? undefined : _a.createMessage)) {
+        throw new Error(`${entityName} does not support task creation for sampling/createMessage (required for ${method})`);
+      }
+      break;
+    case "elicitation/create":
+      if (!((_b = requests.elicitation) === null || _b === undefined ? undefined : _b.create)) {
+        throw new Error(`${entityName} does not support task creation for elicitation/create (required for ${method})`);
+      }
+      break;
+    default:
+      break;
+  }
+}
+
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.24.3/node_modules/@modelcontextprotocol/sdk/dist/esm/server/index.js
 class Server extends Protocol {
   constructor(_serverInfo, options) {
     var _a, _b;
@@ -64135,12 +64803,69 @@ class Server extends Protocol {
       });
     }
   }
+  get experimental() {
+    if (!this._experimental) {
+      this._experimental = {
+        tasks: new ExperimentalServerTasks(this)
+      };
+    }
+    return this._experimental;
+  }
   registerCapabilities(capabilities) {
     if (this.transport) {
       throw new Error("Cannot register capabilities after connecting to transport");
     }
     this._capabilities = mergeCapabilities(this._capabilities, capabilities);
   }
+  setRequestHandler(requestSchema, handler) {
+    var _a, _b, _c;
+    const shape = getObjectShape(requestSchema);
+    const methodSchema = shape === null || shape === undefined ? undefined : shape.method;
+    if (!methodSchema) {
+      throw new Error("Schema is missing a method literal");
+    }
+    let methodValue;
+    if (isZ4Schema(methodSchema)) {
+      const v4Schema = methodSchema;
+      const v4Def = (_a = v4Schema._zod) === null || _a === undefined ? undefined : _a.def;
+      methodValue = (_b = v4Def === null || v4Def === undefined ? undefined : v4Def.value) !== null && _b !== undefined ? _b : v4Schema.value;
+    } else {
+      const v3Schema = methodSchema;
+      const legacyDef = v3Schema._def;
+      methodValue = (_c = legacyDef === null || legacyDef === undefined ? undefined : legacyDef.value) !== null && _c !== undefined ? _c : v3Schema.value;
+    }
+    if (typeof methodValue !== "string") {
+      throw new Error("Schema method literal must be a string");
+    }
+    const method = methodValue;
+    if (method === "tools/call") {
+      const wrappedHandler = async (request, extra) => {
+        const validatedRequest = safeParse2(CallToolRequestSchema, request);
+        if (!validatedRequest.success) {
+          const errorMessage = validatedRequest.error instanceof Error ? validatedRequest.error.message : String(validatedRequest.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call request: ${errorMessage}`);
+        }
+        const { params } = validatedRequest.data;
+        const result = await Promise.resolve(handler(request, extra));
+        if (params.task) {
+          const taskValidationResult = safeParse2(CreateTaskResultSchema, result);
+          if (!taskValidationResult.success) {
+            const errorMessage = taskValidationResult.error instanceof Error ? taskValidationResult.error.message : String(taskValidationResult.error);
+            throw new McpError(ErrorCode.InvalidParams, `Invalid task creation result: ${errorMessage}`);
+          }
+          return taskValidationResult.data;
+        }
+        const validationResult = safeParse2(CallToolResultSchema, result);
+        if (!validationResult.success) {
+          const errorMessage = validationResult.error instanceof Error ? validationResult.error.message : String(validationResult.error);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid tools/call result: ${errorMessage}`);
+        }
+        return validationResult.data;
+      };
+      return super.setRequestHandler(requestSchema, wrappedHandler);
+    }
+    return super.setRequestHandler(requestSchema, handler);
+  }
   assertCapabilityForMethod(method) {
     var _a, _b, _c;
     switch (method) {
@@ -64199,6 +64924,9 @@ class Server extends Protocol {
     }
   }
   assertRequestHandlerCapability(method) {
+    if (!this._capabilities) {
+      return;
+    }
     switch (method) {
       case "completion/complete":
         if (!this._capabilities.completions) {
@@ -64229,11 +64957,30 @@ class Server extends Protocol {
           throw new Error(`Server does not support tools (required for ${method})`);
         }
         break;
+      case "tasks/get":
+      case "tasks/list":
+      case "tasks/result":
+      case "tasks/cancel":
+        if (!this._capabilities.tasks) {
+          throw new Error(`Server does not support tasks capability (required for ${method})`);
+        }
+        break;
       case "ping":
       case "initialize":
         break;
     }
   }
+  assertTaskCapability(method) {
+    var _a, _b;
+    assertClientRequestTaskCapability((_b = (_a = this._clientCapabilities) === null || _a === undefined ? undefined : _a.tasks) === null || _b === undefined ? undefined : _b.requests, method, "Client");
+  }
+  assertTaskHandlerCapability(method) {
+    var _a;
+    if (!this._capabilities) {
+      return;
+    }
+    assertToolsCallTaskCapability((_a = this._capabilities.tasks) === null || _a === undefined ? undefined : _a.requests, method, "Server");
+  }
   async _oninitialize(request) {
     const requestedVersion = request.params.protocolVersion;
     this._clientCapabilities = request.params.capabilities;
@@ -64288,6 +65035,9 @@ class Server extends Protocol {
         }
       }
     }
+    if (params.tools) {
+      return this.request({ method: "sampling/createMessage", params }, CreateMessageResultWithToolsSchema, options);
+    }
     return this.request({ method: "sampling/createMessage", params }, CreateMessageResultSchema, options);
   }
   async elicitInput(params, options) {
@@ -64366,7 +65116,7 @@ class Server extends Protocol {
   }
 }
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.23.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/completable.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.24.3/node_modules/@modelcontextprotocol/sdk/dist/esm/server/completable.js
 var COMPLETABLE_SYMBOL = Symbol.for("mcp.completable");
 function isCompletable(schema) {
   return !!schema && typeof schema === "object" && COMPLETABLE_SYMBOL in schema;
@@ -64380,7 +65130,7 @@ var McpZodTypeKind;
   McpZodTypeKind2["Completable"] = "McpCompletable";
 })(McpZodTypeKind || (McpZodTypeKind = {}));
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.23.0/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/toolNameValidation.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.24.3/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/toolNameValidation.js
 var TOOL_NAME_REGEX = /^[A-Za-z0-9._-]{1,128}$/;
 function validateToolName(name) {
   const warnings = [];
@@ -64438,7 +65188,22 @@ function validateAndWarnToolName(name) {
   return result.isValid;
 }
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.23.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.24.3/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/mcp-server.js
+class ExperimentalMcpServerTasks {
+  constructor(_mcpServer) {
+    this._mcpServer = _mcpServer;
+  }
+  registerToolTask(name, config2, handler) {
+    const execution = { taskSupport: "required", ...config2.execution };
+    if (execution.taskSupport === "forbidden") {
+      throw new Error(`Cannot register task-based tool '${name}' with taskSupport 'forbidden'. Use registerTool() instead.`);
+    }
+    const mcpServerInternal = this._mcpServer;
+    return mcpServerInternal._createRegisteredTool(name, config2.title, config2.description, config2.inputSchema, config2.outputSchema, config2.annotations, execution, config2._meta, handler);
+  }
+}
+
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.24.3/node_modules/@modelcontextprotocol/sdk/dist/esm/server/mcp.js
 class McpServer {
   constructor(serverInfo, options) {
     this._registeredResources = {};
@@ -64451,6 +65216,14 @@ class McpServer {
     this._promptHandlersInitialized = false;
     this.server = new Server(serverInfo, options);
   }
+  get experimental() {
+    if (!this._experimental) {
+      this._experimental = {
+        tasks: new ExperimentalMcpServerTasks(this)
+      };
+    }
+    return this._experimental;
+  }
   async connect(transport) {
     return await this.server.connect(transport);
   }
@@ -64482,6 +65255,7 @@ class McpServer {
             }) : EMPTY_OBJECT_JSON_SCHEMA;
           })(),
           annotations: tool.annotations,
+          execution: tool.execution,
           _meta: tool._meta
         };
         if (tool.outputSchema) {
@@ -64497,39 +65271,34 @@ class McpServer {
       })
     }));
     this.server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
-      const tool = this._registeredTools[request.params.name];
-      let result;
+      var _a;
       try {
+        const tool = this._registeredTools[request.params.name];
         if (!tool) {
           throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} not found`);
         }
         if (!tool.enabled) {
           throw new McpError(ErrorCode.InvalidParams, `Tool ${request.params.name} disabled`);
         }
-        if (tool.inputSchema) {
-          const cb = tool.callback;
-          const inputObj = normalizeObjectSchema(tool.inputSchema);
-          const schemaToParse = inputObj !== null && inputObj !== undefined ? inputObj : tool.inputSchema;
-          const parseResult = await safeParseAsync2(schemaToParse, request.params.arguments);
-          if (!parseResult.success) {
-            throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${request.params.name}: ${getParseErrorMessage(parseResult.error)}`);
-          }
-          const args = parseResult.data;
-          result = await Promise.resolve(cb(args, extra));
-        } else {
-          const cb = tool.callback;
-          result = await Promise.resolve(cb(extra));
+        const isTaskRequest = !!request.params.task;
+        const taskSupport = (_a = tool.execution) === null || _a === undefined ? undefined : _a.taskSupport;
+        const isTaskHandler = "createTask" in tool.handler;
+        if ((taskSupport === "required" || taskSupport === "optional") && !isTaskHandler) {
+          throw new McpError(ErrorCode.InternalError, `Tool ${request.params.name} has taskSupport '${taskSupport}' but was not registered with registerToolTask`);
         }
-        if (tool.outputSchema && !result.isError) {
-          if (!result.structuredContent) {
-            throw new McpError(ErrorCode.InvalidParams, `Output validation error: Tool ${request.params.name} has an output schema but no structured content was provided`);
-          }
-          const outputObj = normalizeObjectSchema(tool.outputSchema);
-          const parseResult = await safeParseAsync2(outputObj, result.structuredContent);
-          if (!parseResult.success) {
-            throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${request.params.name}: ${getParseErrorMessage(parseResult.error)}`);
-          }
+        if (taskSupport === "required" && !isTaskRequest) {
+          throw new McpError(ErrorCode.MethodNotFound, `Tool ${request.params.name} requires task augmentation (taskSupport: 'required')`);
+        }
+        if (taskSupport === "optional" && !isTaskRequest && isTaskHandler) {
+          return await this.handleAutomaticTaskPolling(tool, request, extra);
         }
+        const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
+        const result = await this.executeToolHandler(tool, args, extra);
+        if (isTaskRequest) {
+          return result;
+        }
+        await this.validateToolOutput(tool, result, request.params.name);
+        return result;
       } catch (error46) {
         if (error46 instanceof McpError) {
           if (error46.code === ErrorCode.UrlElicitationRequired) {
@@ -64538,7 +65307,6 @@ class McpServer {
         }
         return this.createToolError(error46 instanceof Error ? error46.message : String(error46));
       }
-      return result;
     });
     this._toolHandlersInitialized = true;
   }
@@ -64553,6 +65321,87 @@ class McpServer {
       isError: true
     };
   }
+  async validateToolInput(tool, args, toolName) {
+    if (!tool.inputSchema) {
+      return;
+    }
+    const inputObj = normalizeObjectSchema(tool.inputSchema);
+    const schemaToParse = inputObj !== null && inputObj !== undefined ? inputObj : tool.inputSchema;
+    const parseResult = await safeParseAsync2(schemaToParse, args);
+    if (!parseResult.success) {
+      const error46 = "error" in parseResult ? parseResult.error : "Unknown error";
+      const errorMessage = getParseErrorMessage(error46);
+      throw new McpError(ErrorCode.InvalidParams, `Input validation error: Invalid arguments for tool ${toolName}: ${errorMessage}`);
+    }
+    return parseResult.data;
+  }
+  async validateToolOutput(tool, result, toolName) {
+    if (!tool.outputSchema) {
+      return;
+    }
+    if (!("content" in result)) {
+      return;
+    }
+    if (result.isError) {
+      return;
+    }
+    if (!result.structuredContent) {
+      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Tool ${toolName} has an output schema but no structured content was provided`);
+    }
+    const outputObj = normalizeObjectSchema(tool.outputSchema);
+    const parseResult = await safeParseAsync2(outputObj, result.structuredContent);
+    if (!parseResult.success) {
+      const error46 = "error" in parseResult ? parseResult.error : "Unknown error";
+      const errorMessage = getParseErrorMessage(error46);
+      throw new McpError(ErrorCode.InvalidParams, `Output validation error: Invalid structured content for tool ${toolName}: ${errorMessage}`);
+    }
+  }
+  async executeToolHandler(tool, args, extra) {
+    const handler = tool.handler;
+    const isTaskHandler = "createTask" in handler;
+    if (isTaskHandler) {
+      if (!extra.taskStore) {
+        throw new Error("No task store provided.");
+      }
+      const taskExtra = { ...extra, taskStore: extra.taskStore };
+      if (tool.inputSchema) {
+        const typedHandler = handler;
+        return await Promise.resolve(typedHandler.createTask(args, taskExtra));
+      } else {
+        const typedHandler = handler;
+        return await Promise.resolve(typedHandler.createTask(taskExtra));
+      }
+    }
+    if (tool.inputSchema) {
+      const typedHandler = handler;
+      return await Promise.resolve(typedHandler(args, extra));
+    } else {
+      const typedHandler = handler;
+      return await Promise.resolve(typedHandler(extra));
+    }
+  }
+  async handleAutomaticTaskPolling(tool, request, extra) {
+    var _a;
+    if (!extra.taskStore) {
+      throw new Error("No task store provided for task-capable tool.");
+    }
+    const args = await this.validateToolInput(tool, request.params.arguments, request.params.name);
+    const handler = tool.handler;
+    const taskExtra = { ...extra, taskStore: extra.taskStore };
+    const createTaskResult = args ? await Promise.resolve(handler.createTask(args, taskExtra)) : await Promise.resolve(handler.createTask(taskExtra));
+    const taskId = createTaskResult.task.taskId;
+    let task = createTaskResult.task;
+    const pollInterval = (_a = task.pollInterval) !== null && _a !== undefined ? _a : 5000;
+    while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      const updatedTask = await extra.taskStore.getTask(taskId);
+      if (!updatedTask) {
+        throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
+      }
+      task = updatedTask;
+    }
+    return await extra.taskStore.getTaskResult(taskId);
+  }
   setCompletionRequestHandler() {
     if (this._completionHandlerInitialized) {
       return;
@@ -64707,7 +65556,9 @@ class McpServer {
         const argsObj = normalizeObjectSchema(prompt.argsSchema);
         const parseResult = await safeParseAsync2(argsObj, request.params.arguments);
         if (!parseResult.success) {
-          throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for prompt ${request.params.name}: ${getParseErrorMessage(parseResult.error)}`);
+          const error46 = "error" in parseResult ? parseResult.error : "Unknown error";
+          const errorMessage = getParseErrorMessage(error46);
+          throw new McpError(ErrorCode.InvalidParams, `Invalid arguments for prompt ${request.params.name}: ${errorMessage}`);
         }
         const args = parseResult.data;
         const cb = prompt.callback;
@@ -64859,7 +65710,7 @@ class McpServer {
     this._registeredPrompts[name] = registeredPrompt;
     return registeredPrompt;
   }
-  _createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, _meta, callback) {
+  _createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, execution, _meta, handler) {
     validateAndWarnToolName(name);
     const registeredTool = {
       title,
@@ -64867,8 +65718,9 @@ class McpServer {
       inputSchema: getZodSchemaObject(inputSchema),
       outputSchema: getZodSchemaObject(outputSchema),
       annotations,
+      execution,
       _meta,
-      callback,
+      handler,
       enabled: true,
       disable: () => registeredTool.update({ enabled: false }),
       enable: () => registeredTool.update({ enabled: true }),
@@ -64889,7 +65741,7 @@ class McpServer {
         if (typeof updates.paramsSchema !== "undefined")
           registeredTool.inputSchema = objectFromShape(updates.paramsSchema);
         if (typeof updates.callback !== "undefined")
-          registeredTool.callback = updates.callback;
+          registeredTool.handler = updates.callback;
         if (typeof updates.annotations !== "undefined")
           registeredTool.annotations = updates.annotations;
         if (typeof updates._meta !== "undefined")
@@ -64917,9 +65769,9 @@ class McpServer {
     }
     if (rest.length > 1) {
       const firstArg = rest[0];
-      if (isZodRawShape(firstArg)) {
+      if (isZodRawShapeCompat(firstArg)) {
         inputSchema = rest.shift();
-        if (rest.length > 1 && typeof rest[0] === "object" && rest[0] !== null && !isZodRawShape(rest[0])) {
+        if (rest.length > 1 && typeof rest[0] === "object" && rest[0] !== null && !isZodRawShapeCompat(rest[0])) {
           annotations = rest.shift();
         }
       } else if (typeof firstArg === "object" && firstArg !== null) {
@@ -64927,14 +65779,14 @@ class McpServer {
       }
     }
     const callback = rest[0];
-    return this._createRegisteredTool(name, undefined, description, inputSchema, outputSchema, annotations, undefined, callback);
+    return this._createRegisteredTool(name, undefined, description, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, undefined, callback);
   }
   registerTool(name, config2, cb) {
     if (this._registeredTools[name]) {
       throw new Error(`Tool ${name} is already registered`);
     }
     const { title, description, inputSchema, outputSchema, annotations, _meta } = config2;
-    return this._createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, _meta, cb);
+    return this._createRegisteredTool(name, title, description, inputSchema, outputSchema, annotations, { taskSupport: "forbidden" }, _meta, cb);
   }
   prompt(name, ...rest) {
     if (this._registeredPrompts[name]) {
@@ -64990,20 +65842,29 @@ var EMPTY_OBJECT_JSON_SCHEMA = {
   type: "object",
   properties: {}
 };
-function isZodRawShape(obj) {
-  if (typeof obj !== "object" || obj === null)
-    return false;
-  const isEmptyObject = Object.keys(obj).length === 0;
-  return isEmptyObject || Object.values(obj).some(isZodTypeLike);
-}
 function isZodTypeLike(value) {
   return value !== null && typeof value === "object" && "parse" in value && typeof value.parse === "function" && "safeParse" in value && typeof value.safeParse === "function";
 }
+function isZodSchemaInstance(obj) {
+  return "_def" in obj || "_zod" in obj || isZodTypeLike(obj);
+}
+function isZodRawShapeCompat(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return false;
+  }
+  if (isZodSchemaInstance(obj)) {
+    return false;
+  }
+  if (Object.keys(obj).length === 0) {
+    return true;
+  }
+  return Object.values(obj).some(isZodTypeLike);
+}
 function getZodSchemaObject(schema) {
   if (!schema) {
     return;
   }
-  if (isZodRawShape(schema)) {
+  if (isZodRawShapeCompat(schema)) {
     return objectFromShape(schema);
   }
   return schema;
@@ -65050,10 +65911,10 @@ var EMPTY_COMPLETION_RESULT = {
   }
 };
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.23.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.24.3/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 import process2 from "node:process";
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.23.0/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.24.3/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
 class ReadBuffer {
   append(chunk) {
     this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
@@ -65083,7 +65944,7 @@ function serializeMessage(message) {
 `;
 }
 
-// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.23.0/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
+// ../../node_modules/.bun/@modelcontextprotocol+sdk@1.24.3/node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js
 class StdioServerTransport {
   constructor(_stdin = process2.stdin, _stdout = process2.stdout) {
     this._stdin = _stdin;
@@ -83863,7 +84724,7 @@ var portalQueries = (server, env3) => {
 var package_default = {
   name: "@settlemint/sdk-mcp",
   description: "MCP interface for SettleMint SDK, providing development tools and project management capabilities",
-  version: "2.6.4-pr836c05ff",
+  version: "2.6.4-pr855d66d3",
   type: "module",
   private: false,
   license: "FSL-1.1-MIT",
@@ -83905,9 +84766,9 @@ var package_default = {
     "@commander-js/extra-typings": "14.0.0",
     "@graphql-tools/load": "8.1.7",
     "@graphql-tools/url-loader": "9.0.5",
-    "@modelcontextprotocol/sdk": "1.23.0",
-    "@settlemint/sdk-js": "2.6.4-pr836c05ff",
-    "@settlemint/sdk-utils": "2.6.4-pr836c05ff",
+    "@modelcontextprotocol/sdk": "1.24.3",
+    "@settlemint/sdk-js": "2.6.4-pr855d66d3",
+    "@settlemint/sdk-utils": "2.6.4-pr855d66d3",
     commander: "14.0.2",
     graphql: "16.12.0",
     zod: "^4",
@@ -89987,4 +90848,4 @@ await main().catch((error47) => {
   process.exit(1);
 });
 
-//# debugId=CF9C0606A922636564756E2164756E21
+//# debugId=77187357ACEC0E5464756E2164756E21