@kadoa/mcp 0.5.32 → 0.6.0-rc.1

package/dist/index.js

@@ -19875,6 +19875,803 @@ var init_mcp = __esm(() => {
   };
 });
 
+// node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
+var RELATED_TASK_META_KEY2 = "io.modelcontextprotocol/related-task", JSONRPC_VERSION2 = "2.0", AssertObjectSchema2, ProgressTokenSchema2, CursorSchema2, TaskCreationParamsSchema2, TaskMetadataSchema2, RelatedTaskMetadataSchema2, RequestMetaSchema2, BaseRequestParamsSchema2, TaskAugmentedRequestParamsSchema2, RequestSchema2, NotificationsParamsSchema2, NotificationSchema2, ResultSchema2, RequestIdSchema2, JSONRPCRequestSchema2, JSONRPCNotificationSchema2, JSONRPCResultResponseSchema2, ErrorCode2, JSONRPCErrorResponseSchema2, JSONRPCMessageSchema2, JSONRPCResponseSchema2, EmptyResultSchema2, CancelledNotificationParamsSchema2, CancelledNotificationSchema2, IconSchema2, IconsSchema2, BaseMetadataSchema2, ImplementationSchema2, FormElicitationCapabilitySchema2, ElicitationCapabilitySchema2, ClientTasksCapabilitySchema2, ServerTasksCapabilitySchema2, ClientCapabilitiesSchema2, InitializeRequestParamsSchema2, InitializeRequestSchema2, ServerCapabilitiesSchema2, InitializeResultSchema2, InitializedNotificationSchema2, PingRequestSchema2, ProgressSchema2, ProgressNotificationParamsSchema2, ProgressNotificationSchema2, PaginatedRequestParamsSchema2, PaginatedRequestSchema2, PaginatedResultSchema2, TaskStatusSchema2, TaskSchema2, CreateTaskResultSchema2, TaskStatusNotificationParamsSchema2, TaskStatusNotificationSchema2, GetTaskRequestSchema2, GetTaskResultSchema2, GetTaskPayloadRequestSchema2, GetTaskPayloadResultSchema2, ListTasksRequestSchema2, ListTasksResultSchema2, CancelTaskRequestSchema2, CancelTaskResultSchema2, ResourceContentsSchema2, TextResourceContentsSchema2, Base64Schema2, BlobResourceContentsSchema2, RoleSchema2, AnnotationsSchema2, ResourceSchema2, ResourceTemplateSchema2, ListResourcesRequestSchema2, ListResourcesResultSchema2, ListResourceTemplatesRequestSchema2, ListResourceTemplatesResultSchema2, ResourceRequestParamsSchema2, ReadResourceRequestParamsSchema2, ReadResourceRequestSchema2, ReadResourceResultSchema2, ResourceListChangedNotificationSchema2, SubscribeRequestParamsSchema2, SubscribeRequestSchema2, UnsubscribeRequestParamsSchema2, UnsubscribeRequestSchema2, ResourceUpdatedNotificationParamsSchema2, ResourceUpdatedNotificationSchema2, PromptArgumentSchema2, PromptSchema2, ListPromptsRequestSchema2, ListPromptsResultSchema2, GetPromptRequestParamsSchema2, GetPromptRequestSchema2, TextContentSchema2, ImageContentSchema2, AudioContentSchema2, ToolUseContentSchema2, EmbeddedResourceSchema2, ResourceLinkSchema2, ContentBlockSchema2, PromptMessageSchema2, GetPromptResultSchema2, PromptListChangedNotificationSchema2, ToolAnnotationsSchema2, ToolExecutionSchema2, ToolSchema2, ListToolsRequestSchema2, ListToolsResultSchema2, CallToolResultSchema2, CompatibilityCallToolResultSchema2, CallToolRequestParamsSchema2, CallToolRequestSchema2, ToolListChangedNotificationSchema2, ListChangedOptionsBaseSchema2, LoggingLevelSchema2, SetLevelRequestParamsSchema2, SetLevelRequestSchema2, LoggingMessageNotificationParamsSchema2, LoggingMessageNotificationSchema2, ModelHintSchema2, ModelPreferencesSchema2, ToolChoiceSchema2, ToolResultContentSchema2, SamplingContentSchema2, SamplingMessageContentBlockSchema2, SamplingMessageSchema2, CreateMessageRequestParamsSchema2, CreateMessageRequestSchema2, CreateMessageResultSchema2, CreateMessageResultWithToolsSchema2, BooleanSchemaSchema2, StringSchemaSchema2, NumberSchemaSchema2, UntitledSingleSelectEnumSchemaSchema2, TitledSingleSelectEnumSchemaSchema2, LegacyTitledEnumSchemaSchema2, SingleSelectEnumSchemaSchema2, UntitledMultiSelectEnumSchemaSchema2, TitledMultiSelectEnumSchemaSchema2, MultiSelectEnumSchemaSchema2, EnumSchemaSchema2, PrimitiveSchemaDefinitionSchema2, ElicitRequestFormParamsSchema2, ElicitRequestURLParamsSchema2, ElicitRequestParamsSchema2, ElicitRequestSchema2, ElicitationCompleteNotificationParamsSchema2, ElicitationCompleteNotificationSchema2, ElicitResultSchema2, ResourceTemplateReferenceSchema2, PromptReferenceSchema2, CompleteRequestParamsSchema2, CompleteRequestSchema2, CompleteResultSchema2, RootSchema2, ListRootsRequestSchema2, ListRootsResultSchema2, RootsListChangedNotificationSchema2, ClientRequestSchema2, ClientNotificationSchema2, ClientResultSchema2, ServerRequestSchema2, ServerNotificationSchema2, ServerResultSchema2;
+var init_types3 = __esm(() => {
+  init_v4();
+  AssertObjectSchema2 = custom((v) => v !== null && (typeof v === "object" || typeof v === "function"));
+  ProgressTokenSchema2 = union([string2(), number2().int()]);
+  CursorSchema2 = string2();
+  TaskCreationParamsSchema2 = looseObject({
+    ttl: union([number2(), _null3()]).optional(),
+    pollInterval: number2().optional()
+  });
+  TaskMetadataSchema2 = object2({
+    ttl: number2().optional()
+  });
+  RelatedTaskMetadataSchema2 = object2({
+    taskId: string2()
+  });
+  RequestMetaSchema2 = looseObject({
+    progressToken: ProgressTokenSchema2.optional(),
+    [RELATED_TASK_META_KEY2]: RelatedTaskMetadataSchema2.optional()
+  });
+  BaseRequestParamsSchema2 = object2({
+    _meta: RequestMetaSchema2.optional()
+  });
+  TaskAugmentedRequestParamsSchema2 = BaseRequestParamsSchema2.extend({
+    task: TaskMetadataSchema2.optional()
+  });
+  RequestSchema2 = object2({
+    method: string2(),
+    params: BaseRequestParamsSchema2.loose().optional()
+  });
+  NotificationsParamsSchema2 = object2({
+    _meta: RequestMetaSchema2.optional()
+  });
+  NotificationSchema2 = object2({
+    method: string2(),
+    params: NotificationsParamsSchema2.loose().optional()
+  });
+  ResultSchema2 = looseObject({
+    _meta: RequestMetaSchema2.optional()
+  });
+  RequestIdSchema2 = union([string2(), number2().int()]);
+  JSONRPCRequestSchema2 = object2({
+    jsonrpc: literal(JSONRPC_VERSION2),
+    id: RequestIdSchema2,
+    ...RequestSchema2.shape
+  }).strict();
+  JSONRPCNotificationSchema2 = object2({
+    jsonrpc: literal(JSONRPC_VERSION2),
+    ...NotificationSchema2.shape
+  }).strict();
+  JSONRPCResultResponseSchema2 = object2({
+    jsonrpc: literal(JSONRPC_VERSION2),
+    id: RequestIdSchema2,
+    result: ResultSchema2
+  }).strict();
+  (function(ErrorCode) {
+    ErrorCode[ErrorCode["ConnectionClosed"] = -32000] = "ConnectionClosed";
+    ErrorCode[ErrorCode["RequestTimeout"] = -32001] = "RequestTimeout";
+    ErrorCode[ErrorCode["ParseError"] = -32700] = "ParseError";
+    ErrorCode[ErrorCode["InvalidRequest"] = -32600] = "InvalidRequest";
+    ErrorCode[ErrorCode["MethodNotFound"] = -32601] = "MethodNotFound";
+    ErrorCode[ErrorCode["InvalidParams"] = -32602] = "InvalidParams";
+    ErrorCode[ErrorCode["InternalError"] = -32603] = "InternalError";
+    ErrorCode[ErrorCode["UrlElicitationRequired"] = -32042] = "UrlElicitationRequired";
+  })(ErrorCode2 || (ErrorCode2 = {}));
+  JSONRPCErrorResponseSchema2 = object2({
+    jsonrpc: literal(JSONRPC_VERSION2),
+    id: RequestIdSchema2.optional(),
+    error: object2({
+      code: number2().int(),
+      message: string2(),
+      data: unknown().optional()
+    })
+  }).strict();
+  JSONRPCMessageSchema2 = union([
+    JSONRPCRequestSchema2,
+    JSONRPCNotificationSchema2,
+    JSONRPCResultResponseSchema2,
+    JSONRPCErrorResponseSchema2
+  ]);
+  JSONRPCResponseSchema2 = union([JSONRPCResultResponseSchema2, JSONRPCErrorResponseSchema2]);
+  EmptyResultSchema2 = ResultSchema2.strict();
+  CancelledNotificationParamsSchema2 = NotificationsParamsSchema2.extend({
+    requestId: RequestIdSchema2.optional(),
+    reason: string2().optional()
+  });
+  CancelledNotificationSchema2 = NotificationSchema2.extend({
+    method: literal("notifications/cancelled"),
+    params: CancelledNotificationParamsSchema2
+  });
+  IconSchema2 = object2({
+    src: string2(),
+    mimeType: string2().optional(),
+    sizes: array(string2()).optional(),
+    theme: _enum(["light", "dark"]).optional()
+  });
+  IconsSchema2 = object2({
+    icons: array(IconSchema2).optional()
+  });
+  BaseMetadataSchema2 = object2({
+    name: string2(),
+    title: string2().optional()
+  });
+  ImplementationSchema2 = BaseMetadataSchema2.extend({
+    ...BaseMetadataSchema2.shape,
+    ...IconsSchema2.shape,
+    version: string2(),
+    websiteUrl: string2().optional(),
+    description: string2().optional()
+  });
+  FormElicitationCapabilitySchema2 = intersection(object2({
+    applyDefaults: boolean2().optional()
+  }), record(string2(), unknown()));
+  ElicitationCapabilitySchema2 = preprocess((value) => {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      if (Object.keys(value).length === 0) {
+        return { form: {} };
+      }
+    }
+    return value;
+  }, intersection(object2({
+    form: FormElicitationCapabilitySchema2.optional(),
+    url: AssertObjectSchema2.optional()
+  }), record(string2(), unknown()).optional()));
+  ClientTasksCapabilitySchema2 = looseObject({
+    list: AssertObjectSchema2.optional(),
+    cancel: AssertObjectSchema2.optional(),
+    requests: looseObject({
+      sampling: looseObject({
+        createMessage: AssertObjectSchema2.optional()
+      }).optional(),
+      elicitation: looseObject({
+        create: AssertObjectSchema2.optional()
+      }).optional()
+    }).optional()
+  });
+  ServerTasksCapabilitySchema2 = looseObject({
+    list: AssertObjectSchema2.optional(),
+    cancel: AssertObjectSchema2.optional(),
+    requests: looseObject({
+      tools: looseObject({
+        call: AssertObjectSchema2.optional()
+      }).optional()
+    }).optional()
+  });
+  ClientCapabilitiesSchema2 = object2({
+    experimental: record(string2(), AssertObjectSchema2).optional(),
+    sampling: object2({
+      context: AssertObjectSchema2.optional(),
+      tools: AssertObjectSchema2.optional()
+    }).optional(),
+    elicitation: ElicitationCapabilitySchema2.optional(),
+    roots: object2({
+      listChanged: boolean2().optional()
+    }).optional(),
+    tasks: ClientTasksCapabilitySchema2.optional()
+  });
+  InitializeRequestParamsSchema2 = BaseRequestParamsSchema2.extend({
+    protocolVersion: string2(),
+    capabilities: ClientCapabilitiesSchema2,
+    clientInfo: ImplementationSchema2
+  });
+  InitializeRequestSchema2 = RequestSchema2.extend({
+    method: literal("initialize"),
+    params: InitializeRequestParamsSchema2
+  });
+  ServerCapabilitiesSchema2 = object2({
+    experimental: record(string2(), AssertObjectSchema2).optional(),
+    logging: AssertObjectSchema2.optional(),
+    completions: AssertObjectSchema2.optional(),
+    prompts: object2({
+      listChanged: boolean2().optional()
+    }).optional(),
+    resources: object2({
+      subscribe: boolean2().optional(),
+      listChanged: boolean2().optional()
+    }).optional(),
+    tools: object2({
+      listChanged: boolean2().optional()
+    }).optional(),
+    tasks: ServerTasksCapabilitySchema2.optional()
+  });
+  InitializeResultSchema2 = ResultSchema2.extend({
+    protocolVersion: string2(),
+    capabilities: ServerCapabilitiesSchema2,
+    serverInfo: ImplementationSchema2,
+    instructions: string2().optional()
+  });
+  InitializedNotificationSchema2 = NotificationSchema2.extend({
+    method: literal("notifications/initialized"),
+    params: NotificationsParamsSchema2.optional()
+  });
+  PingRequestSchema2 = RequestSchema2.extend({
+    method: literal("ping"),
+    params: BaseRequestParamsSchema2.optional()
+  });
+  ProgressSchema2 = object2({
+    progress: number2(),
+    total: optional(number2()),
+    message: optional(string2())
+  });
+  ProgressNotificationParamsSchema2 = object2({
+    ...NotificationsParamsSchema2.shape,
+    ...ProgressSchema2.shape,
+    progressToken: ProgressTokenSchema2
+  });
+  ProgressNotificationSchema2 = NotificationSchema2.extend({
+    method: literal("notifications/progress"),
+    params: ProgressNotificationParamsSchema2
+  });
+  PaginatedRequestParamsSchema2 = BaseRequestParamsSchema2.extend({
+    cursor: CursorSchema2.optional()
+  });
+  PaginatedRequestSchema2 = RequestSchema2.extend({
+    params: PaginatedRequestParamsSchema2.optional()
+  });
+  PaginatedResultSchema2 = ResultSchema2.extend({
+    nextCursor: CursorSchema2.optional()
+  });
+  TaskStatusSchema2 = _enum(["working", "input_required", "completed", "failed", "cancelled"]);
+  TaskSchema2 = object2({
+    taskId: string2(),
+    status: TaskStatusSchema2,
+    ttl: union([number2(), _null3()]),
+    createdAt: string2(),
+    lastUpdatedAt: string2(),
+    pollInterval: optional(number2()),
+    statusMessage: optional(string2())
+  });
+  CreateTaskResultSchema2 = ResultSchema2.extend({
+    task: TaskSchema2
+  });
+  TaskStatusNotificationParamsSchema2 = NotificationsParamsSchema2.merge(TaskSchema2);
+  TaskStatusNotificationSchema2 = NotificationSchema2.extend({
+    method: literal("notifications/tasks/status"),
+    params: TaskStatusNotificationParamsSchema2
+  });
+  GetTaskRequestSchema2 = RequestSchema2.extend({
+    method: literal("tasks/get"),
+    params: BaseRequestParamsSchema2.extend({
+      taskId: string2()
+    })
+  });
+  GetTaskResultSchema2 = ResultSchema2.merge(TaskSchema2);
+  GetTaskPayloadRequestSchema2 = RequestSchema2.extend({
+    method: literal("tasks/result"),
+    params: BaseRequestParamsSchema2.extend({
+      taskId: string2()
+    })
+  });
+  GetTaskPayloadResultSchema2 = ResultSchema2.loose();
+  ListTasksRequestSchema2 = PaginatedRequestSchema2.extend({
+    method: literal("tasks/list")
+  });
+  ListTasksResultSchema2 = PaginatedResultSchema2.extend({
+    tasks: array(TaskSchema2)
+  });
+  CancelTaskRequestSchema2 = RequestSchema2.extend({
+    method: literal("tasks/cancel"),
+    params: BaseRequestParamsSchema2.extend({
+      taskId: string2()
+    })
+  });
+  CancelTaskResultSchema2 = ResultSchema2.merge(TaskSchema2);
+  ResourceContentsSchema2 = object2({
+    uri: string2(),
+    mimeType: optional(string2()),
+    _meta: record(string2(), unknown()).optional()
+  });
+  TextResourceContentsSchema2 = ResourceContentsSchema2.extend({
+    text: string2()
+  });
+  Base64Schema2 = string2().refine((val) => {
+    try {
+      atob(val);
+      return true;
+    } catch {
+      return false;
+    }
+  }, { message: "Invalid Base64 string" });
+  BlobResourceContentsSchema2 = ResourceContentsSchema2.extend({
+    blob: Base64Schema2
+  });
+  RoleSchema2 = _enum(["user", "assistant"]);
+  AnnotationsSchema2 = object2({
+    audience: array(RoleSchema2).optional(),
+    priority: number2().min(0).max(1).optional(),
+    lastModified: datetime2({ offset: true }).optional()
+  });
+  ResourceSchema2 = object2({
+    ...BaseMetadataSchema2.shape,
+    ...IconsSchema2.shape,
+    uri: string2(),
+    description: optional(string2()),
+    mimeType: optional(string2()),
+    annotations: AnnotationsSchema2.optional(),
+    _meta: optional(looseObject({}))
+  });
+  ResourceTemplateSchema2 = object2({
+    ...BaseMetadataSchema2.shape,
+    ...IconsSchema2.shape,
+    uriTemplate: string2(),
+    description: optional(string2()),
+    mimeType: optional(string2()),
+    annotations: AnnotationsSchema2.optional(),
+    _meta: optional(looseObject({}))
+  });
+  ListResourcesRequestSchema2 = PaginatedRequestSchema2.extend({
+    method: literal("resources/list")
+  });
+  ListResourcesResultSchema2 = PaginatedResultSchema2.extend({
+    resources: array(ResourceSchema2)
+  });
+  ListResourceTemplatesRequestSchema2 = PaginatedRequestSchema2.extend({
+    method: literal("resources/templates/list")
+  });
+  ListResourceTemplatesResultSchema2 = PaginatedResultSchema2.extend({
+    resourceTemplates: array(ResourceTemplateSchema2)
+  });
+  ResourceRequestParamsSchema2 = BaseRequestParamsSchema2.extend({
+    uri: string2()
+  });
+  ReadResourceRequestParamsSchema2 = ResourceRequestParamsSchema2;
+  ReadResourceRequestSchema2 = RequestSchema2.extend({
+    method: literal("resources/read"),
+    params: ReadResourceRequestParamsSchema2
+  });
+  ReadResourceResultSchema2 = ResultSchema2.extend({
+    contents: array(union([TextResourceContentsSchema2, BlobResourceContentsSchema2]))
+  });
+  ResourceListChangedNotificationSchema2 = NotificationSchema2.extend({
+    method: literal("notifications/resources/list_changed"),
+    params: NotificationsParamsSchema2.optional()
+  });
+  SubscribeRequestParamsSchema2 = ResourceRequestParamsSchema2;
+  SubscribeRequestSchema2 = RequestSchema2.extend({
+    method: literal("resources/subscribe"),
+    params: SubscribeRequestParamsSchema2
+  });
+  UnsubscribeRequestParamsSchema2 = ResourceRequestParamsSchema2;
+  UnsubscribeRequestSchema2 = RequestSchema2.extend({
+    method: literal("resources/unsubscribe"),
+    params: UnsubscribeRequestParamsSchema2
+  });
+  ResourceUpdatedNotificationParamsSchema2 = NotificationsParamsSchema2.extend({
+    uri: string2()
+  });
+  ResourceUpdatedNotificationSchema2 = NotificationSchema2.extend({
+    method: literal("notifications/resources/updated"),
+    params: ResourceUpdatedNotificationParamsSchema2
+  });
+  PromptArgumentSchema2 = object2({
+    name: string2(),
+    description: optional(string2()),
+    required: optional(boolean2())
+  });
+  PromptSchema2 = object2({
+    ...BaseMetadataSchema2.shape,
+    ...IconsSchema2.shape,
+    description: optional(string2()),
+    arguments: optional(array(PromptArgumentSchema2)),
+    _meta: optional(looseObject({}))
+  });
+  ListPromptsRequestSchema2 = PaginatedRequestSchema2.extend({
+    method: literal("prompts/list")
+  });
+  ListPromptsResultSchema2 = PaginatedResultSchema2.extend({
+    prompts: array(PromptSchema2)
+  });
+  GetPromptRequestParamsSchema2 = BaseRequestParamsSchema2.extend({
+    name: string2(),
+    arguments: record(string2(), string2()).optional()
+  });
+  GetPromptRequestSchema2 = RequestSchema2.extend({
+    method: literal("prompts/get"),
+    params: GetPromptRequestParamsSchema2
+  });
+  TextContentSchema2 = object2({
+    type: literal("text"),
+    text: string2(),
+    annotations: AnnotationsSchema2.optional(),
+    _meta: record(string2(), unknown()).optional()
+  });
+  ImageContentSchema2 = object2({
+    type: literal("image"),
+    data: Base64Schema2,
+    mimeType: string2(),
+    annotations: AnnotationsSchema2.optional(),
+    _meta: record(string2(), unknown()).optional()
+  });
+  AudioContentSchema2 = object2({
+    type: literal("audio"),
+    data: Base64Schema2,
+    mimeType: string2(),
+    annotations: AnnotationsSchema2.optional(),
+    _meta: record(string2(), unknown()).optional()
+  });
+  ToolUseContentSchema2 = object2({
+    type: literal("tool_use"),
+    name: string2(),
+    id: string2(),
+    input: record(string2(), unknown()),
+    _meta: record(string2(), unknown()).optional()
+  });
+  EmbeddedResourceSchema2 = object2({
+    type: literal("resource"),
+    resource: union([TextResourceContentsSchema2, BlobResourceContentsSchema2]),
+    annotations: AnnotationsSchema2.optional(),
+    _meta: record(string2(), unknown()).optional()
+  });
+  ResourceLinkSchema2 = ResourceSchema2.extend({
+    type: literal("resource_link")
+  });
+  ContentBlockSchema2 = union([
+    TextContentSchema2,
+    ImageContentSchema2,
+    AudioContentSchema2,
+    ResourceLinkSchema2,
+    EmbeddedResourceSchema2
+  ]);
+  PromptMessageSchema2 = object2({
+    role: RoleSchema2,
+    content: ContentBlockSchema2
+  });
+  GetPromptResultSchema2 = ResultSchema2.extend({
+    description: string2().optional(),
+    messages: array(PromptMessageSchema2)
+  });
+  PromptListChangedNotificationSchema2 = NotificationSchema2.extend({
+    method: literal("notifications/prompts/list_changed"),
+    params: NotificationsParamsSchema2.optional()
+  });
+  ToolAnnotationsSchema2 = object2({
+    title: string2().optional(),
+    readOnlyHint: boolean2().optional(),
+    destructiveHint: boolean2().optional(),
+    idempotentHint: boolean2().optional(),
+    openWorldHint: boolean2().optional()
+  });
+  ToolExecutionSchema2 = object2({
+    taskSupport: _enum(["required", "optional", "forbidden"]).optional()
+  });
+  ToolSchema2 = object2({
+    ...BaseMetadataSchema2.shape,
+    ...IconsSchema2.shape,
+    description: string2().optional(),
+    inputSchema: object2({
+      type: literal("object"),
+      properties: record(string2(), AssertObjectSchema2).optional(),
+      required: array(string2()).optional()
+    }).catchall(unknown()),
+    outputSchema: object2({
+      type: literal("object"),
+      properties: record(string2(), AssertObjectSchema2).optional(),
+      required: array(string2()).optional()
+    }).catchall(unknown()).optional(),
+    annotations: ToolAnnotationsSchema2.optional(),
+    execution: ToolExecutionSchema2.optional(),
+    _meta: record(string2(), unknown()).optional()
+  });
+  ListToolsRequestSchema2 = PaginatedRequestSchema2.extend({
+    method: literal("tools/list")
+  });
+  ListToolsResultSchema2 = PaginatedResultSchema2.extend({
+    tools: array(ToolSchema2)
+  });
+  CallToolResultSchema2 = ResultSchema2.extend({
+    content: array(ContentBlockSchema2).default([]),
+    structuredContent: record(string2(), unknown()).optional(),
+    isError: boolean2().optional()
+  });
+  CompatibilityCallToolResultSchema2 = CallToolResultSchema2.or(ResultSchema2.extend({
+    toolResult: unknown()
+  }));
+  CallToolRequestParamsSchema2 = TaskAugmentedRequestParamsSchema2.extend({
+    name: string2(),
+    arguments: record(string2(), unknown()).optional()
+  });
+  CallToolRequestSchema2 = RequestSchema2.extend({
+    method: literal("tools/call"),
+    params: CallToolRequestParamsSchema2
+  });
+  ToolListChangedNotificationSchema2 = NotificationSchema2.extend({
+    method: literal("notifications/tools/list_changed"),
+    params: NotificationsParamsSchema2.optional()
+  });
+  ListChangedOptionsBaseSchema2 = object2({
+    autoRefresh: boolean2().default(true),
+    debounceMs: number2().int().nonnegative().default(300)
+  });
+  LoggingLevelSchema2 = _enum(["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]);
+  SetLevelRequestParamsSchema2 = BaseRequestParamsSchema2.extend({
+    level: LoggingLevelSchema2
+  });
+  SetLevelRequestSchema2 = RequestSchema2.extend({
+    method: literal("logging/setLevel"),
+    params: SetLevelRequestParamsSchema2
+  });
+  LoggingMessageNotificationParamsSchema2 = NotificationsParamsSchema2.extend({
+    level: LoggingLevelSchema2,
+    logger: string2().optional(),
+    data: unknown()
+  });
+  LoggingMessageNotificationSchema2 = NotificationSchema2.extend({
+    method: literal("notifications/message"),
+    params: LoggingMessageNotificationParamsSchema2
+  });
+  ModelHintSchema2 = object2({
+    name: string2().optional()
+  });
+  ModelPreferencesSchema2 = object2({
+    hints: array(ModelHintSchema2).optional(),
+    costPriority: number2().min(0).max(1).optional(),
+    speedPriority: number2().min(0).max(1).optional(),
+    intelligencePriority: number2().min(0).max(1).optional()
+  });
+  ToolChoiceSchema2 = object2({
+    mode: _enum(["auto", "required", "none"]).optional()
+  });
+  ToolResultContentSchema2 = object2({
+    type: literal("tool_result"),
+    toolUseId: string2().describe("The unique identifier for the corresponding tool call."),
+    content: array(ContentBlockSchema2).default([]),
+    structuredContent: object2({}).loose().optional(),
+    isError: boolean2().optional(),
+    _meta: record(string2(), unknown()).optional()
+  });
+  SamplingContentSchema2 = discriminatedUnion("type", [TextContentSchema2, ImageContentSchema2, AudioContentSchema2]);
+  SamplingMessageContentBlockSchema2 = discriminatedUnion("type", [
+    TextContentSchema2,
+    ImageContentSchema2,
+    AudioContentSchema2,
+    ToolUseContentSchema2,
+    ToolResultContentSchema2
+  ]);
+  SamplingMessageSchema2 = object2({
+    role: RoleSchema2,
+    content: union([SamplingMessageContentBlockSchema2, array(SamplingMessageContentBlockSchema2)]),
+    _meta: record(string2(), unknown()).optional()
+  });
+  CreateMessageRequestParamsSchema2 = TaskAugmentedRequestParamsSchema2.extend({
+    messages: array(SamplingMessageSchema2),
+    modelPreferences: ModelPreferencesSchema2.optional(),
+    systemPrompt: string2().optional(),
+    includeContext: _enum(["none", "thisServer", "allServers"]).optional(),
+    temperature: number2().optional(),
+    maxTokens: number2().int(),
+    stopSequences: array(string2()).optional(),
+    metadata: AssertObjectSchema2.optional(),
+    tools: array(ToolSchema2).optional(),
+    toolChoice: ToolChoiceSchema2.optional()
+  });
+  CreateMessageRequestSchema2 = RequestSchema2.extend({
+    method: literal("sampling/createMessage"),
+    params: CreateMessageRequestParamsSchema2
+  });
+  CreateMessageResultSchema2 = ResultSchema2.extend({
+    model: string2(),
+    stopReason: optional(_enum(["endTurn", "stopSequence", "maxTokens"]).or(string2())),
+    role: RoleSchema2,
+    content: SamplingContentSchema2
+  });
+  CreateMessageResultWithToolsSchema2 = ResultSchema2.extend({
+    model: string2(),
+    stopReason: optional(_enum(["endTurn", "stopSequence", "maxTokens", "toolUse"]).or(string2())),
+    role: RoleSchema2,
+    content: union([SamplingMessageContentBlockSchema2, array(SamplingMessageContentBlockSchema2)])
+  });
+  BooleanSchemaSchema2 = object2({
+    type: literal("boolean"),
+    title: string2().optional(),
+    description: string2().optional(),
+    default: boolean2().optional()
+  });
+  StringSchemaSchema2 = object2({
+    type: literal("string"),
+    title: string2().optional(),
+    description: string2().optional(),
+    minLength: number2().optional(),
+    maxLength: number2().optional(),
+    format: _enum(["email", "uri", "date", "date-time"]).optional(),
+    default: string2().optional()
+  });
+  NumberSchemaSchema2 = object2({
+    type: _enum(["number", "integer"]),
+    title: string2().optional(),
+    description: string2().optional(),
+    minimum: number2().optional(),
+    maximum: number2().optional(),
+    default: number2().optional()
+  });
+  UntitledSingleSelectEnumSchemaSchema2 = object2({
+    type: literal("string"),
+    title: string2().optional(),
+    description: string2().optional(),
+    enum: array(string2()),
+    default: string2().optional()
+  });
+  TitledSingleSelectEnumSchemaSchema2 = object2({
+    type: literal("string"),
+    title: string2().optional(),
+    description: string2().optional(),
+    oneOf: array(object2({
+      const: string2(),
+      title: string2()
+    })),
+    default: string2().optional()
+  });
+  LegacyTitledEnumSchemaSchema2 = object2({
+    type: literal("string"),
+    title: string2().optional(),
+    description: string2().optional(),
+    enum: array(string2()),
+    enumNames: array(string2()).optional(),
+    default: string2().optional()
+  });
+  SingleSelectEnumSchemaSchema2 = union([UntitledSingleSelectEnumSchemaSchema2, TitledSingleSelectEnumSchemaSchema2]);
+  UntitledMultiSelectEnumSchemaSchema2 = object2({
+    type: literal("array"),
+    title: string2().optional(),
+    description: string2().optional(),
+    minItems: number2().optional(),
+    maxItems: number2().optional(),
+    items: object2({
+      type: literal("string"),
+      enum: array(string2())
+    }),
+    default: array(string2()).optional()
+  });
+  TitledMultiSelectEnumSchemaSchema2 = object2({
+    type: literal("array"),
+    title: string2().optional(),
+    description: string2().optional(),
+    minItems: number2().optional(),
+    maxItems: number2().optional(),
+    items: object2({
+      anyOf: array(object2({
+        const: string2(),
+        title: string2()
+      }))
+    }),
+    default: array(string2()).optional()
+  });
+  MultiSelectEnumSchemaSchema2 = union([UntitledMultiSelectEnumSchemaSchema2, TitledMultiSelectEnumSchemaSchema2]);
+  EnumSchemaSchema2 = union([LegacyTitledEnumSchemaSchema2, SingleSelectEnumSchemaSchema2, MultiSelectEnumSchemaSchema2]);
+  PrimitiveSchemaDefinitionSchema2 = union([EnumSchemaSchema2, BooleanSchemaSchema2, StringSchemaSchema2, NumberSchemaSchema2]);
+  ElicitRequestFormParamsSchema2 = TaskAugmentedRequestParamsSchema2.extend({
+    mode: literal("form").optional(),
+    message: string2(),
+    requestedSchema: object2({
+      type: literal("object"),
+      properties: record(string2(), PrimitiveSchemaDefinitionSchema2),
+      required: array(string2()).optional()
+    })
+  });
+  ElicitRequestURLParamsSchema2 = TaskAugmentedRequestParamsSchema2.extend({
+    mode: literal("url"),
+    message: string2(),
+    elicitationId: string2(),
+    url: string2().url()
+  });
+  ElicitRequestParamsSchema2 = union([ElicitRequestFormParamsSchema2, ElicitRequestURLParamsSchema2]);
+  ElicitRequestSchema2 = RequestSchema2.extend({
+    method: literal("elicitation/create"),
+    params: ElicitRequestParamsSchema2
+  });
+  ElicitationCompleteNotificationParamsSchema2 = NotificationsParamsSchema2.extend({
+    elicitationId: string2()
+  });
+  ElicitationCompleteNotificationSchema2 = NotificationSchema2.extend({
+    method: literal("notifications/elicitation/complete"),
+    params: ElicitationCompleteNotificationParamsSchema2
+  });
+  ElicitResultSchema2 = ResultSchema2.extend({
+    action: _enum(["accept", "decline", "cancel"]),
+    content: preprocess((val) => val === null ? undefined : val, record(string2(), union([string2(), number2(), boolean2(), array(string2())])).optional())
+  });
+  ResourceTemplateReferenceSchema2 = object2({
+    type: literal("ref/resource"),
+    uri: string2()
+  });
+  PromptReferenceSchema2 = object2({
+    type: literal("ref/prompt"),
+    name: string2()
+  });
+  CompleteRequestParamsSchema2 = BaseRequestParamsSchema2.extend({
+    ref: union([PromptReferenceSchema2, ResourceTemplateReferenceSchema2]),
+    argument: object2({
+      name: string2(),
+      value: string2()
+    }),
+    context: object2({
+      arguments: record(string2(), string2()).optional()
+    }).optional()
+  });
+  CompleteRequestSchema2 = RequestSchema2.extend({
+    method: literal("completion/complete"),
+    params: CompleteRequestParamsSchema2
+  });
+  CompleteResultSchema2 = ResultSchema2.extend({
+    completion: looseObject({
+      values: array(string2()).max(100),
+      total: optional(number2().int()),
+      hasMore: optional(boolean2())
+    })
+  });
+  RootSchema2 = object2({
+    uri: string2().startsWith("file://"),
+    name: string2().optional(),
+    _meta: record(string2(), unknown()).optional()
+  });
+  ListRootsRequestSchema2 = RequestSchema2.extend({
+    method: literal("roots/list"),
+    params: BaseRequestParamsSchema2.optional()
+  });
+  ListRootsResultSchema2 = ResultSchema2.extend({
+    roots: array(RootSchema2)
+  });
+  RootsListChangedNotificationSchema2 = NotificationSchema2.extend({
+    method: literal("notifications/roots/list_changed"),
+    params: NotificationsParamsSchema2.optional()
+  });
+  ClientRequestSchema2 = union([
+    PingRequestSchema2,
+    InitializeRequestSchema2,
+    CompleteRequestSchema2,
+    SetLevelRequestSchema2,
+    GetPromptRequestSchema2,
+    ListPromptsRequestSchema2,
+    ListResourcesRequestSchema2,
+    ListResourceTemplatesRequestSchema2,
+    ReadResourceRequestSchema2,
+    SubscribeRequestSchema2,
+    UnsubscribeRequestSchema2,
+    CallToolRequestSchema2,
+    ListToolsRequestSchema2,
+    GetTaskRequestSchema2,
+    GetTaskPayloadRequestSchema2,
+    ListTasksRequestSchema2,
+    CancelTaskRequestSchema2
+  ]);
+  ClientNotificationSchema2 = union([
+    CancelledNotificationSchema2,
+    ProgressNotificationSchema2,
+    InitializedNotificationSchema2,
+    RootsListChangedNotificationSchema2,
+    TaskStatusNotificationSchema2
+  ]);
+  ClientResultSchema2 = union([
+    EmptyResultSchema2,
+    CreateMessageResultSchema2,
+    CreateMessageResultWithToolsSchema2,
+    ElicitResultSchema2,
+    ListRootsResultSchema2,
+    GetTaskResultSchema2,
+    ListTasksResultSchema2,
+    CreateTaskResultSchema2
+  ]);
+  ServerRequestSchema2 = union([
+    PingRequestSchema2,
+    CreateMessageRequestSchema2,
+    ElicitRequestSchema2,
+    ListRootsRequestSchema2,
+    GetTaskRequestSchema2,
+    GetTaskPayloadRequestSchema2,
+    ListTasksRequestSchema2,
+    CancelTaskRequestSchema2
+  ]);
+  ServerNotificationSchema2 = union([
+    CancelledNotificationSchema2,
+    ProgressNotificationSchema2,
+    LoggingMessageNotificationSchema2,
+    ResourceUpdatedNotificationSchema2,
+    ResourceListChangedNotificationSchema2,
+    ToolListChangedNotificationSchema2,
+    PromptListChangedNotificationSchema2,
+    TaskStatusNotificationSchema2,
+    ElicitationCompleteNotificationSchema2
+  ]);
+  ServerResultSchema2 = union([
+    EmptyResultSchema2,
+    InitializeResultSchema2,
+    CompleteResultSchema2,
+    GetPromptResultSchema2,
+    ListPromptsResultSchema2,
+    ListResourcesResultSchema2,
+    ListResourceTemplatesResultSchema2,
+    ReadResourceResultSchema2,
+    CallToolResultSchema2,
+    ListToolsResultSchema2,
+    GetTaskResultSchema2,
+    ListTasksResultSchema2,
+    CreateTaskResultSchema2
+  ]);
+});
+
 // node_modules/axios/lib/helpers/bind.js
 function bind(fn, thisArg) {
   return function wrap() {
@@ -36563,29 +37360,6 @@ function buildAgenticPrompt2(params) {
   }
   return `extract all records from this page and return these fields: ${fieldList}`;
 }
-function mapInboxItem(item) {
-  return {
-    id: item.id,
-    type: knownInboxItemTypes[item.type] ?? item.type,
-    subjectId: item.subjectId,
-    workflowId: item.workflowId,
-    title: item.title,
-    payload: item.payload,
-    isRead: item.isRead,
-    readAt: item.readAt,
-    createdAt: item.createdAt,
-    updatedAt: item.updatedAt
-  };
-}
-function mapInboxListResponse(response) {
-  return {
-    unreadCount: response.data.unreadCount,
-    items: response.data.items.map(mapInboxItem)
-  };
-}
-function mapInboxMarkReadResponse(response) {
-  return { readCount: response.data.readCount };
-}
 function validateEmailChannelConfig(config) {
   const issues = [];
   if (!config.recipients?.length) {
@@ -36748,7 +37522,6 @@ function createClientDomains(params) {
   const { client } = params;
   const assistantService = new AssistantService(client.apis.agent);
   const changesService = new ChangesService(client);
-  const inboxService = new InboxService(client.apis.inbox);
   const userService = new UserService(client);
   const dataFetcherService = new DataFetcherService(client.apis.workflows);
   const channelsService = new NotificationChannelsService(client.apis.notifications, userService);
@@ -36778,7 +37551,6 @@ function createClientDomains(params) {
     extraction: extractionService,
     workflow: workflowsCoreService,
     notification,
-    inbox: inboxService,
     schema: schemasService,
     scrape: scrapeService,
     user: userService,
@@ -36967,8 +37739,8 @@ var import_debug, __require2, FREEFORM_ASSISTANT_ANSWER_KEY = "_freeform", Kadoa
   return needsSerialization ? JSON.stringify(value !== undefined ? value : {}, replaceWithSerializableTypeIfNeeded) : value || "";
 }, toPathString = function(url) {
   return url.pathname + url.search + url.hash;
-}, createRequestFunction = function(axiosArgs, globalAxios13, BASE_PATH2, configuration) {
-  return (axios2 = globalAxios13, basePath = BASE_PATH2) => {
+}, createRequestFunction = function(axiosArgs, globalAxios12, BASE_PATH2, configuration) {
+  return (axios2 = globalAxios12, basePath = BASE_PATH2) => {
     const axiosRequestArgs = { ...axiosArgs.options, url: (axios2.defaults.baseURL ? "" : configuration?.basePath ?? basePath) + axiosArgs.url };
     return axios2.request(axiosRequestArgs);
   };
@@ -38290,67 +39062,7 @@ var import_debug, __require2, FREEFORM_ASSISTANT_ANSWER_KEY = "_freeform", Kadoa
       return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
     }
   };
-}, DataValidationApi, InboxApiAxiosParamCreator = function(configuration) {
-  return {
-    v5InboxList: async (options = {}) => {
-      const localVarPath = `/v5/inbox`;
-      const localVarUrlObj = new URL$1(localVarPath, DUMMY_BASE_URL);
-      let baseOptions;
-      if (configuration) {
-        baseOptions = configuration.baseOptions;
-      }
-      const localVarRequestOptions = { method: "GET", ...baseOptions, ...options };
-      const localVarHeaderParameter = {};
-      const localVarQueryParameter = {};
-      await setApiKeyToObject(localVarHeaderParameter, "x-api-key", configuration);
-      localVarHeaderParameter["Accept"] = "application/json";
-      setSearchParams(localVarUrlObj, localVarQueryParameter);
-      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      return {
-        url: toPathString(localVarUrlObj),
-        options: localVarRequestOptions
-      };
-    },
-    v5InboxMarkRead: async (itemId, options = {}) => {
-      assertParamExists("v5InboxMarkRead", "itemId", itemId);
-      const localVarPath = `/v5/inbox/{itemId}/mark-read`.replace(`{${"itemId"}}`, encodeURIComponent(String(itemId)));
-      const localVarUrlObj = new URL$1(localVarPath, DUMMY_BASE_URL);
-      let baseOptions;
-      if (configuration) {
-        baseOptions = configuration.baseOptions;
-      }
-      const localVarRequestOptions = { method: "POST", ...baseOptions, ...options };
-      const localVarHeaderParameter = {};
-      const localVarQueryParameter = {};
-      await setApiKeyToObject(localVarHeaderParameter, "x-api-key", configuration);
-      localVarHeaderParameter["Accept"] = "application/json";
-      setSearchParams(localVarUrlObj, localVarQueryParameter);
-      let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
-      localVarRequestOptions.headers = { ...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers };
-      return {
-        url: toPathString(localVarUrlObj),
-        options: localVarRequestOptions
-      };
-    }
-  };
-}, InboxApiFp = function(configuration) {
-  const localVarAxiosParamCreator = InboxApiAxiosParamCreator(configuration);
-  return {
-    async v5InboxList(options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.v5InboxList(options);
-      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-      const localVarOperationServerBasePath = operationServerMap["InboxApi.v5InboxList"]?.[localVarOperationServerIndex]?.url;
-      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
-    },
-    async v5InboxMarkRead(itemId, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.v5InboxMarkRead(itemId, options);
-      const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
-      const localVarOperationServerBasePath = operationServerMap["InboxApi.v5InboxMarkRead"]?.[localVarOperationServerIndex]?.url;
-      return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
-    }
-  };
-}, InboxApi, MeApiAxiosParamCreator = function(configuration) {
+}, DataValidationApi, MeApiAxiosParamCreator = function(configuration) {
   return {
     v4MeFeaturesGet: async (options = {}) => {
       const localVarPath = `/v4/me/features`;
@@ -39891,7 +40603,7 @@ var import_debug, __require2, FREEFORM_ASSISTANT_ANSWER_KEY = "_freeform", Kadoa
         options: localVarRequestOptions
       };
     },
-    v4WorkflowsGet: async (search, skip, limit, state, runState, displayState, inSupport, tags, statusFilters, userId, channelId, monitoring, updateInterval, scheduleType, templateId, includeDeleted, format, options = {}) => {
+    v4WorkflowsGet: async (search, skip, limit, state, runState, displayState, inSupport, tags, statusFilters, groupWindows, userId, channelId, monitoring, updateInterval, scheduleType, templateId, includeDeleted, format, options = {}) => {
       const localVarPath = `/v4/workflows`;
       const localVarUrlObj = new URL$1(localVarPath, DUMMY_BASE_URL);
       let baseOptions;
@@ -39929,6 +40641,9 @@ var import_debug, __require2, FREEFORM_ASSISTANT_ANSWER_KEY = "_freeform", Kadoa
       if (statusFilters) {
         localVarQueryParameter["statusFilters"] = statusFilters;
       }
+      if (groupWindows !== undefined) {
+        localVarQueryParameter["groupWindows"] = groupWindows;
+      }
       if (userId) {
         localVarQueryParameter["userId"] = userId;
       }
@@ -40633,8 +41348,8 @@ var import_debug, __require2, FREEFORM_ASSISTANT_ANSWER_KEY = "_freeform", Kadoa
       const localVarOperationServerBasePath = operationServerMap["WorkflowsApi.v4WorkflowsBulkPost"]?.[localVarOperationServerIndex]?.url;
       return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
     },
-    async v4WorkflowsGet(search, skip, limit, state, runState, displayState, inSupport, tags, statusFilters, userId, channelId, monitoring, updateInterval, scheduleType, templateId, includeDeleted, format, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.v4WorkflowsGet(search, skip, limit, state, runState, displayState, inSupport, tags, statusFilters, userId, channelId, monitoring, updateInterval, scheduleType, templateId, includeDeleted, format, options);
+    async v4WorkflowsGet(search, skip, limit, state, runState, displayState, inSupport, tags, statusFilters, groupWindows, userId, channelId, monitoring, updateInterval, scheduleType, templateId, includeDeleted, format, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.v4WorkflowsGet(search, skip, limit, state, runState, displayState, inSupport, tags, statusFilters, groupWindows, userId, channelId, monitoring, updateInterval, scheduleType, templateId, includeDeleted, format, options);
       const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
       const localVarOperationServerBasePath = operationServerMap["WorkflowsApi.v4WorkflowsGet"]?.[localVarOperationServerIndex]?.url;
       return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
@@ -40799,7 +41514,7 @@ var import_debug, __require2, FREEFORM_ASSISTANT_ANSWER_KEY = "_freeform", Kadoa
     const jsonMime = new RegExp("^(application/json|[^;/ \t]+/[^;/ \t]+[+]json)[ \t]*(;.*)?$", "i");
     return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === "application/json-patch+json");
   }
-}, DataFieldDataTypeEnum, InboxItemTypeEnum, CrawlerConfigService = class {
+}, DataFieldDataTypeEnum, CrawlerConfigService = class {
   constructor(client) {
     this.client = client;
   }
@@ -41562,18 +42277,6 @@ var import_debug, __require2, FREEFORM_ASSISTANT_ANSWER_KEY = "_freeform", Kadoa
     }
     return typeof error.message === "string" ? error.message.includes(BUILD_NOT_READY_ERROR) : false;
   }
-}, InboxItemType, knownInboxItemTypes, InboxService = class {
-  constructor(inboxApi) {
-    this.inboxApi = inboxApi;
-  }
-  async list() {
-    const response = await this.inboxApi.v5InboxList();
-    return mapInboxListResponse(response.data);
-  }
-  async markRead(itemId) {
-    const response = await this.inboxApi.v5InboxMarkRead({ itemId });
-    return mapInboxMarkReadResponse(response.data);
-  }
 }, NotificationChannelType, EMAIL_REGEX, _NotificationChannelsService = class _NotificationChannelsService {
   constructor(notificationsApi, userService) {
     this.api = notificationsApi;
@@ -41900,7 +42603,7 @@ var import_debug, __require2, FREEFORM_ASSISTANT_ANSWER_KEY = "_freeform", Kadoa
     }));
     return channels;
   }
-}, PUBLIC_API_URI, WSS_API_URI, REALTIME_API_URI, SDK_VERSION = "0.41.0", SDK_NAME = "kadoa-node-sdk", SDK_LANGUAGE = "node", debug6, isDrainControlMessage = (message) => message.type === "control.draining", isRealtimeEvent = (message) => message.type !== "heartbeat" && message.type !== "control.draining", _Realtime = class _Realtime {
+}, PUBLIC_API_URI, WSS_API_URI, REALTIME_API_URI, SDK_VERSION = "0.42.0", SDK_NAME = "kadoa-node-sdk", SDK_LANGUAGE = "node", debug6, isDrainControlMessage = (message) => message.type === "control.draining", isRealtimeEvent = (message) => message.type !== "heartbeat" && message.type !== "control.draining", _Realtime = class _Realtime {
   constructor(config) {
     this.drainingSockets = /* @__PURE__ */ new Set;
     this.lastHeartbeat = Date.now();
@@ -42693,7 +43396,7 @@ var import_debug, __require2, FREEFORM_ASSISTANT_ANSWER_KEY = "_freeform", Kadoa
       variableId
     });
   }
-}, JobStateEnum, TERMINAL_JOB_STATES, TERMINAL_RUN_STATES2, debug9, WorkflowsCoreService = class {
+}, JobStateEnum, WorkflowStatusFilter, TERMINAL_JOB_STATES, TERMINAL_RUN_STATES2, debug9, WorkflowsCoreService = class {
   constructor(workflowsApi) {
     this.workflowsApi = workflowsApi;
   }
@@ -42948,9 +43651,6 @@ var import_debug, __require2, FREEFORM_ASSISTANT_ANSWER_KEY = "_freeform", Kadoa
   get notifications() {
     return this.get(NotificationsApi);
   }
-  get inbox() {
-    return this.get(InboxApi);
-  }
   get templates() {
     return this.get(TemplatesApi);
   }
@@ -42990,7 +43690,6 @@ var import_debug, __require2, FREEFORM_ASSISTANT_ANSWER_KEY = "_freeform", Kadoa
     this.schema = domains.schema;
     this.scrape = domains.scrape;
     this.notification = domains.notification;
-    this.inbox = domains.inbox;
     this.template = domains.template;
     this.validation = domains.validation;
     this.variable = domains.variable;
@@ -43440,14 +44139,6 @@ var init_dist2 = __esm(() => {
       return DataValidationApiFp(this.configuration).v4DataValidationWorkflowsWorkflowIdValidationsLatestGet(requestParameters.workflowId, requestParameters.includeDryRun, options).then((request) => request(this.axios, this.basePath));
     }
   };
-  InboxApi = class extends BaseAPI {
-    v5InboxList(options) {
-      return InboxApiFp(this.configuration).v5InboxList(options).then((request) => request(this.axios, this.basePath));
-    }
-    v5InboxMarkRead(requestParameters, options) {
-      return InboxApiFp(this.configuration).v5InboxMarkRead(requestParameters.itemId, options).then((request) => request(this.axios, this.basePath));
-    }
-  };
   MeApi = class extends BaseAPI {
     v4MeFeaturesGet(options) {
       return MeApiFp(this.configuration).v4MeFeaturesGet(options).then((request) => request(this.axios, this.basePath));
@@ -43629,7 +44320,7 @@ var init_dist2 = __esm(() => {
       return WorkflowsApiFp(this.configuration).v4WorkflowsBulkPost(requestParameters.v4WorkflowsBulkPostRequest, options).then((request) => request(this.axios, this.basePath));
     }
     v4WorkflowsGet(requestParameters = {}, options) {
-      return WorkflowsApiFp(this.configuration).v4WorkflowsGet(requestParameters.search, requestParameters.skip, requestParameters.limit, requestParameters.state, requestParameters.runState, requestParameters.displayState, requestParameters.inSupport, requestParameters.tags, requestParameters.statusFilters, requestParameters.userId, requestParameters.channelId, requestParameters.monitoring, requestParameters.updateInterval, requestParameters.scheduleType, requestParameters.templateId, requestParameters.includeDeleted, requestParameters.format, options).then((request) => request(this.axios, this.basePath));
+      return WorkflowsApiFp(this.configuration).v4WorkflowsGet(requestParameters.search, requestParameters.skip, requestParameters.limit, requestParameters.state, requestParameters.runState, requestParameters.displayState, requestParameters.inSupport, requestParameters.tags, requestParameters.statusFilters, requestParameters.groupWindows, requestParameters.userId, requestParameters.channelId, requestParameters.monitoring, requestParameters.updateInterval, requestParameters.scheduleType, requestParameters.templateId, requestParameters.includeDeleted, requestParameters.format, options).then((request) => request(this.axios, this.basePath));
     }
     v4WorkflowsPost(requestParameters = {}, options) {
       return WorkflowsApiFp(this.configuration).v4WorkflowsPost(requestParameters.createWorkflowBody, options).then((request) => request(this.axios, this.basePath));
@@ -43713,11 +44404,6 @@ var init_dist2 = __esm(() => {
     Object: "OBJECT",
     Array: "ARRAY"
   };
-  InboxItemTypeEnum = {
-    ShellyQuestion: "shelly_question",
-    DataQualityIssues: "data_quality_issues",
-    SampleDataReady: "sample_data_ready"
-  };
   CanonicalSchemaFieldDataType = {
     String: DataFieldDataTypeEnum.String,
     Number: DataFieldDataTypeEnum.Number,
@@ -43776,16 +44462,6 @@ This is the main page content.`
   };
   debug4 = logger.extraction;
   TERMINAL_RUN_STATES = /* @__PURE__ */ new Set(["FINISHED", "SUCCESS", "FAILED", "ERROR", "STOPPED", "CANCELLED"]);
-  InboxItemType = {
-    AssistantQuestion: InboxItemTypeEnum.ShellyQuestion,
-    DataQualityIssues: InboxItemTypeEnum.DataQualityIssues,
-    PreviewDataReady: InboxItemTypeEnum.SampleDataReady
-  };
-  knownInboxItemTypes = {
-    [InboxItemTypeEnum.ShellyQuestion]: InboxItemType.AssistantQuestion,
-    [InboxItemTypeEnum.DataQualityIssues]: InboxItemType.DataQualityIssues,
-    [InboxItemTypeEnum.SampleDataReady]: InboxItemType.PreviewDataReady
-  };
   NotificationChannelType = {
     EMAIL: "EMAIL",
     SLACK: "SLACK",
@@ -43823,6 +44499,15 @@ This is the main page content.`
     NotSupported: "NOT_SUPPORTED",
     FailedInsufficientFunds: "FAILED_INSUFFICIENT_FUNDS"
   };
+  WorkflowStatusFilter = {
+    Attention: "group:attention",
+    Working: "group:working",
+    Support: "group:support",
+    Failed: "group:failed",
+    Active: "group:active",
+    Complete: "group:complete",
+    Paused: "group:paused"
+  };
   TERMINAL_JOB_STATES = /* @__PURE__ */ new Set([
     JobStateEnum.Finished,
     JobStateEnum.Failed,
@@ -43853,7 +44538,7 @@ function isScrapeRequest(url) {
 function createKadoaClient(auth) {
   const { principal } = auth;
   const client = new KadoaClient({
-    bearerToken: principal.type === "user" ? principal.supabaseJwt : principal.kadoaAccessToken
+    bearerToken: principal.type === "user" ? principal.supabaseJwt : principal.type === "kadoa" ? principal.accessToken : principal.kadoaAccessToken
   });
   client.axiosInstance.interceptors.request.use((config) => {
     config.headers["x-kadoa-source"] = "mcp";
@@ -44386,6 +45071,16 @@ function registerTools(server, ctx, capabilities) {
         teamId: ctx.principal.teamId
       });
     }
+    if (ctx.principal.type === "kadoa") {
+      const user = await ctx.client.user.getCurrentUser();
+      return jsonResult({
+        email: user.email,
+        authMethod: ctx.principal.actor ? `Kadoa Assistant (delegated via ${ctx.principal.actor.sub})` : "Kadoa access token",
+        teamId: ctx.principal.teamId,
+        ...ctx.principal.teamRole ? { memberRole: ctx.principal.teamRole } : {},
+        scopes: ctx.principal.scopes
+      });
+    }
     const jwt = await getValidJwt(ctx);
     const user = await ctx.client.user.getCurrentUser();
     const teams = await ctx.client.listTeams(jwt ? { bearerToken: jwt } : undefined);
@@ -44720,7 +45415,7 @@ function registerTools(server, ctx, capabilities) {
       monitoring: preprocess(coerceBoolean(), boolean2()).optional().describe("Filter by monitoring/real-time status"),
       updateInterval: _enum(["HOURLY", "DAILY", "WEEKLY", "MONTHLY", "REAL_TIME"]).optional().describe("Filter by scheduled update frequency or realtime workflows"),
       templateId: string2().optional().describe("Filter to workflows instantiated from this template ID"),
-      statusFilters: array(_enum(WORKFLOW_STATUS_FILTERS)).optional().describe("Dashboard category filters. group:attention = workflows waiting on the requesting user (Assistant question, unfinished setup, or preview approval). Other groups: working, support, failed, active, complete, paused.")
+      statusFilters: array(_enum(Object.values(WorkflowStatusFilter))).optional().describe("Dashboard category filters. group:attention = workflows waiting on the requesting user (Assistant question, unfinished setup, or preview approval). Other groups: working, support, failed, active, complete, paused.")
     },
     annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true }
   }, withErrorHandling("list_workflows", async (args) => {
@@ -45689,6 +46384,13 @@ function registerTools(server, ctx, capabilities) {
         activeTeamId: ctx.principal.teamId
       });
     }
+    if (ctx.principal.type === "kadoa") {
+      return jsonResult({
+        teams: [{ id: ctx.principal.teamId, active: true }],
+        activeTeamId: ctx.principal.teamId,
+        note: "Team is fixed for this credential; reconnect to switch."
+      });
+    }
     const jwt = await getValidJwt(ctx);
     const teams = await ctx.client.listTeams(jwt ? { bearerToken: jwt } : undefined);
     const activeTeamId = ctx.teamId ?? teams[0]?.id;
@@ -45713,6 +46415,9 @@ function registerTools(server, ctx, capabilities) {
     if (ctx.principal.type === "serviceAccount") {
       return errorResult("This shared organization connector is fixed to one team and cannot switch teams.");
     }
+    if (ctx.principal.type === "kadoa") {
+      return errorResult("team_switch is not available for this credential. Reconnect and choose the team at sign-in.");
+    }
     const jwt = await getValidJwt(ctx);
     const teams = await ctx.client.listTeams({ bearerToken: jwt });
     const identifier = args.teamIdentifier;
@@ -46109,7 +46814,7 @@ function registerTools(server, ctx, capabilities) {
     });
   }));
 }
-var SchemaFieldShape, SchemaValidationAttributionShape, SchemaValidationPresenceRule, SchemaValidationUniquenessRule, SchemaValidationStringLengthRule, SchemaValidationStringFormatRule, SchemaValidationFieldRulesSchema, SchemaValidationRulesSchema, LocationSchema, MonitoringValueOperators, MonitoringValuelessOperators, MonitoringConditionOperatorSchema, MonitoringConditionSchema, MonitoringSchema, WORKFLOW_STATUS_FILTERS, RESUMABLE_ASSISTANT_STATUSES, ACTIVE_ASSISTANT_STATUSES, IDLE_ASSISTANT_STATUSES, CLOSED_ASSISTANT_STATUSES, DASHBOARD_BASE_URL = "https://www.kadoa.com", WORKFLOW_AUDIT_WATCHED_KEYS;
+var SchemaFieldShape, SchemaValidationAttributionShape, SchemaValidationPresenceRule, SchemaValidationUniquenessRule, SchemaValidationStringLengthRule, SchemaValidationStringFormatRule, SchemaValidationFieldRulesSchema, SchemaValidationRulesSchema, LocationSchema, MonitoringValueOperators, MonitoringValuelessOperators, MonitoringConditionOperatorSchema, MonitoringConditionSchema, MonitoringSchema, RESUMABLE_ASSISTANT_STATUSES, ACTIVE_ASSISTANT_STATUSES, IDLE_ASSISTANT_STATUSES, CLOSED_ASSISTANT_STATUSES, DASHBOARD_BASE_URL = "https://www.kadoa.com", WORKFLOW_AUDIT_WATCHED_KEYS;
 var init_tools = __esm(() => {
   init_dist2();
   init_zod();
@@ -46284,15 +46989,6 @@ var init_tools = __esm(() => {
       conditions: preprocess(coerceArray(), array(MonitoringConditionSchema).min(1))
     }).strict().optional()
   }).strict();
-  WORKFLOW_STATUS_FILTERS = [
-    "group:attention",
-    "group:working",
-    "group:support",
-    "group:failed",
-    "group:active",
-    "group:complete",
-    "group:paused"
-  ];
   RESUMABLE_ASSISTANT_STATUSES = new Set(["pending", "created", "active", "idle", "inactive", "interrupted"]);
   ACTIVE_ASSISTANT_STATUSES = new Set(["pending", "created", "active"]);
   IDLE_ASSISTANT_STATUSES = new Set(["idle", "inactive", "interrupted"]);
@@ -46315,7 +47011,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@kadoa/mcp",
-    version: "0.5.32",
+    version: "0.6.0-rc.1",
     description: "Kadoa MCP Server — manage workflows from Claude Desktop, Cursor, and other MCP clients",
     type: "module",
     main: "dist/index.js",
@@ -46339,7 +47035,7 @@ var init_package = __esm(() => {
       prepublishOnly: "bun run check-types && bun run test:unit && bun run build"
     },
     dependencies: {
-      "@kadoa/node-sdk": "^0.41.0",
+      "@kadoa/node-sdk": "^0.42.0",
       "@modelcontextprotocol/sdk": "^1.26.0",
       express: "^5.2.1",
       "express-rate-limit": "^8.2.1",
@@ -50429,8 +51125,12 @@ function randomToken(bytes = 32) {
   return randomBytes(bytes).toString("hex");
 }
 function readPrincipal(entry) {
-  if (entry.principal)
+  if (entry.principal) {
+    if (entry.principal.type === "kadoa") {
+      throw new InvalidTokenError("Stored token has no valid principal");
+    }
     return entry.principal;
+  }
   if (entry.supabaseJwt && entry.supabaseRefreshToken) {
     return {
       type: "user",
@@ -50442,6 +51142,9 @@ function readPrincipal(entry) {
   throw new InvalidTokenError("Stored token has no valid principal");
 }
 function persistPrincipal(principal) {
+  if (principal.type === "kadoa") {
+    throw new InvalidTokenError("Stored token has no valid principal");
+  }
   if (principal.type === "serviceAccount") {
     return { principal, teamId: principal.teamId };
   }
@@ -50867,6 +51570,9 @@ class KadoaOAuthProvider {
     const persistedEntry = entry;
     await this.store.del("refresh_tokens", refreshToken);
     const storedPrincipal = readPrincipal(persistedEntry);
+    if (storedPrincipal.type === "kadoa") {
+      throw new InvalidTokenError("Stored token has no valid principal");
+    }
     if (storedPrincipal.type === "serviceAccount") {
       const newAccessToken = randomToken();
       const newRefreshToken = randomToken();
@@ -51668,6 +52374,179 @@ var init_managed_token_handler = __esm(() => {
   init_managed_connector_registry();
 });
 
+// src/kadoa-access-token.ts
+import { createPublicKey, verify } from "node:crypto";
+function loadKadoaAccessTokenVerifierConfig(env = process.env) {
+  const issuer = env.MCP_AUTH_ISSUER?.trim();
+  const jwksUrl = env.MCP_AUTH_JWKS_URL?.trim();
+  const audience = env.MCP_AUTH_AUDIENCE?.trim();
+  if (!issuer || !jwksUrl || !audience)
+    return;
+  return { issuer, jwksUrl, audience };
+}
+function decodeSegment(segment, label) {
+  try {
+    const value = JSON.parse(Buffer.from(segment, "base64url").toString("utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value))
+      throw new Error("not an object");
+    return value;
+  } catch {
+    throw new KadoaAccessTokenError(`Kadoa access token ${label} is malformed`);
+  }
+}
+function isJwtShaped(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3 || parts.some((part) => !part))
+    return false;
+  try {
+    const header = decodeSegment(parts[0], "header");
+    return header.alg === "RS256";
+  } catch {
+    return false;
+  }
+}
+
+class KadoaAccessTokenVerifier {
+  config;
+  keys = new Map;
+  fetchedAt = 0;
+  lastUnknownKidRefetchAt = 0;
+  inFlightRefresh;
+  fetchImpl;
+  cacheTtlMs;
+  now;
+  constructor(config, options = {}) {
+    this.config = config;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.cacheTtlMs = options.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
+    this.now = options.now ?? (() => Date.now());
+  }
+  refreshKeys() {
+    if (this.inFlightRefresh)
+      return this.inFlightRefresh;
+    const run = this.doRefreshKeys().finally(() => {
+      this.inFlightRefresh = undefined;
+    });
+    this.inFlightRefresh = run;
+    return run;
+  }
+  async doRefreshKeys() {
+    let response;
+    try {
+      response = await this.fetchImpl(this.config.jwksUrl, { signal: AbortSignal.timeout(JWKS_FETCH_TIMEOUT_MS) });
+    } catch (error) {
+      if (error instanceof Error && error.name === "TimeoutError") {
+        throw new KadoaAccessTokenError("JWKS fetch timed out");
+      }
+      throw new KadoaAccessTokenError(`JWKS fetch failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!response.ok)
+      throw new KadoaAccessTokenError(`JWKS fetch returned HTTP ${response.status}`);
+    const body = await response.json();
+    if (!Array.isArray(body.keys))
+      throw new KadoaAccessTokenError("JWKS response has no keys");
+    const next = new Map;
+    for (const key of body.keys) {
+      if (typeof key.kid !== "string" || key.kty !== "RSA")
+        continue;
+      if (key.use !== undefined && key.use !== "sig")
+        continue;
+      if (key.alg !== undefined && key.alg !== "RS256")
+        continue;
+      try {
+        next.set(key.kid, createPublicKey({ key, format: "jwk" }));
+      } catch {}
+    }
+    this.keys = next;
+    this.fetchedAt = this.now();
+  }
+  async keyFor(kid) {
+    const stale = this.now() - this.fetchedAt > this.cacheTtlMs;
+    if (stale || this.keys.size === 0)
+      await this.refreshKeys();
+    let key = this.keys.get(kid);
+    if (!key && !stale) {
+      const nowMs = this.now();
+      if (nowMs - this.lastUnknownKidRefetchAt >= UNKNOWN_KID_REFETCH_INTERVAL_MS) {
+        this.lastUnknownKidRefetchAt = nowMs;
+        await this.refreshKeys();
+        key = this.keys.get(kid);
+      }
+    }
+    if (!key)
+      throw new KadoaAccessTokenError("Kadoa access token signing key is not recognized");
+    return key;
+  }
+  async verify(token) {
+    const parts = token.split(".");
+    if (parts.length !== 3 || parts.some((part) => !part))
+      throw new KadoaAccessTokenError("Kadoa access token is malformed");
+    const header = decodeSegment(parts[0], "header");
+    if (header.alg !== "RS256")
+      throw new KadoaAccessTokenError("Kadoa access token alg must be RS256");
+    if (typeof header.kid !== "string" || !header.kid)
+      throw new KadoaAccessTokenError("Kadoa access token signing key is missing");
+    const key = await this.keyFor(header.kid);
+    const signed = Buffer.from(`${parts[0]}.${parts[1]}`);
+    const signature = Buffer.from(parts[2], "base64url");
+    if (!signature.length || !verify("RSA-SHA256", signed, key, signature)) {
+      throw new KadoaAccessTokenError("Kadoa access token signature is invalid");
+    }
+    const claims = decodeSegment(parts[1], "claims");
+    const nowSeconds = Math.floor(this.now() / 1000);
+    if (claims.iss !== this.config.issuer)
+      throw new KadoaAccessTokenError("Kadoa access token issuer is invalid");
+    const audiences = Array.isArray(claims.aud) ? claims.aud : [claims.aud];
+    if (!audiences.includes(this.config.audience))
+      throw new KadoaAccessTokenError("Kadoa access token audience is invalid");
+    if (typeof claims.exp !== "number" || claims.exp <= nowSeconds)
+      throw new KadoaAccessTokenError("Kadoa access token has expired");
+    if (typeof claims.iat !== "number" || claims.iat > nowSeconds + CLOCK_SKEW_SECONDS) {
+      throw new KadoaAccessTokenError("Kadoa access token issued-at is invalid");
+    }
+    if (typeof claims.nbf === "number" && claims.nbf > nowSeconds + CLOCK_SKEW_SECONDS) {
+      throw new KadoaAccessTokenError("Kadoa access token is not yet valid");
+    }
+    if (claims.purpose !== KADOA_ACCESS_TOKEN_PURPOSE)
+      throw new KadoaAccessTokenError("Kadoa access token purpose is invalid");
+    if (typeof claims.sub !== "string" || !UUID_PATTERN.test(claims.sub))
+      throw new KadoaAccessTokenError("Kadoa access token subject is invalid");
+    if (typeof claims.active_team_id !== "string" || !UUID_PATTERN.test(claims.active_team_id)) {
+      throw new KadoaAccessTokenError("Kadoa access token active_team_id is invalid");
+    }
+    let actor;
+    if (claims.act !== undefined) {
+      const act = claims.act;
+      if (typeof act?.sub !== "string" || typeof act?.session_id !== "string" || !UUID_PATTERN.test(act.session_id)) {
+        throw new KadoaAccessTokenError("Kadoa access token actor claim is malformed");
+      }
+      actor = { sub: act.sub, sessionId: act.session_id };
+    }
+    return {
+      type: "kadoa",
+      userId: claims.sub,
+      teamId: claims.active_team_id,
+      ...typeof claims.team_role === "string" ? { teamRole: claims.team_role } : {},
+      scopes: typeof claims.scope === "string" ? claims.scope.split(" ").filter(Boolean) : [],
+      ...actor ? { actor } : {},
+      accessToken: token,
+      expiresAt: claims.exp
+    };
+  }
+}
+var UUID_PATTERN, CLOCK_SKEW_SECONDS = 30, DEFAULT_CACHE_TTL_MS, UNKNOWN_KID_REFETCH_INTERVAL_MS, JWKS_FETCH_TIMEOUT_MS = 5000, KADOA_ACCESS_TOKEN_PURPOSE = "kadoa-mcp", KadoaAccessTokenError;
+var init_kadoa_access_token = __esm(() => {
+  UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  DEFAULT_CACHE_TTL_MS = 10 * 60 * 1000;
+  UNKNOWN_KID_REFETCH_INTERVAL_MS = 60 * 1000;
+  KadoaAccessTokenError = class KadoaAccessTokenError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "KadoaAccessTokenError";
+    }
+  };
+});
+
 // src/http.ts
 import express8 from "express";
 function jwtClaims2(jwt) {
@@ -51691,6 +52570,9 @@ function resolveAuth(req) {
     }
     return { principal, mcpToken: req.auth.token };
   }
+  if (principal.type === "kadoa") {
+    return { principal, mcpToken: req.auth.token };
+  }
   if (principal.type === "user") {
     const claims = jwtClaims2(principal.supabaseJwt);
     if (!claims.sub) {
@@ -51719,6 +52601,11 @@ async function startHttpServer(options) {
   const managedRegistry = options?.managedRegistry ?? (process.env.MCP_REGISTRY_SERVICE_TOKEN ? new ManagedConnectorRegistry : undefined);
   const provider = new KadoaOAuthProvider(store, managedRegistry);
   const serverUrl = process.env.MCP_SERVER_URL || `http://localhost:${port}`;
+  const verifierConfig = loadKadoaAccessTokenVerifierConfig();
+  const kadoaTokenVerifier = options?.kadoaTokenVerifier ?? (verifierConfig ? new KadoaAccessTokenVerifier(verifierConfig) : undefined);
+  if (!kadoaTokenVerifier) {
+    console.warn("[AUTH] Kadoa access-token verifier disabled (MCP_AUTH_ISSUER, MCP_AUTH_JWKS_URL, MCP_AUTH_AUDIENCE unset); RS256 bearers will be rejected");
+  }
   app.post("/token", express8.urlencoded({ extended: false }), rate_limit_default({
     windowMs: 15 * 60 * 1000,
     limit: 50,
@@ -51757,7 +52644,41 @@ async function startHttpServer(options) {
       redis: store.isConnected() ? "connected" : "fallback"
     });
   });
-  const bearerAuth = requireBearerAuth({ verifier: provider });
+  const oauthBearerAuth = requireBearerAuth({ verifier: provider });
+  const bearerAuth = async (req, res, next) => {
+    const match = req.header("authorization")?.match(/^Bearer ([^\s]+)$/i);
+    const token = match?.[1];
+    if (!token || !isJwtShaped(token))
+      return oauthBearerAuth(req, res, next);
+    if (!kadoaTokenVerifier) {
+      res.status(401).json({
+        jsonrpc: "2.0",
+        error: { code: -32001, message: "Unauthorized: Kadoa access tokens are not accepted by this server" },
+        id: req.body?.id ?? null
+      });
+      return;
+    }
+    try {
+      const principal = await kadoaTokenVerifier.verify(token);
+      req.auth = {
+        token,
+        clientId: principal.actor ? `kadoa-delegated:${principal.actor.sub}` : "kadoa-access-token",
+        scopes: principal.scopes,
+        expiresAt: principal.expiresAt,
+        extra: { principal, teamId: principal.teamId }
+      };
+      next();
+    } catch (error) {
+      const message = error instanceof KadoaAccessTokenError ? error.message : "Kadoa access token rejected";
+      console.error(`[AUTH] KADOA_TOKEN_FAIL: ${message}`);
+      const publicMessage = message.startsWith("JWKS") ? "Kadoa access token could not be verified" : message;
+      res.status(401).json({
+        jsonrpc: "2.0",
+        error: { code: -32001, message: `Unauthorized: ${publicMessage}` },
+        id: req.body?.id ?? null
+      });
+    }
+  };
   app.post("/mcp", bearerAuth, async (req, res) => {
     const auth = resolveAuth(req);
     const method = req.body?.method ?? "unknown";
@@ -51771,7 +52692,8 @@ async function startHttpServer(options) {
       return;
     }
     let principal = auth.principal;
-    const identity = `mode=${principal.type}:team=${principal.teamId.slice(0, 8)}...`;
+    const delegatedSession = principal.type === "kadoa" && principal.actor ? `:session=${principal.actor.sessionId}` : "";
+    const identity = `mode=${principal.type}:team=${principal.teamId.slice(0, 8)}...${delegatedSession}`;
     if (principal.type === "user" && isJwtExpired(principal.supabaseJwt)) {
       try {
         const refreshed = await refreshSupabaseJwtRaw(principal.supabaseRefreshToken);
@@ -51892,6 +52814,7 @@ var init_http2 = __esm(async () => {
   init_managed_connector_client();
   init_managed_connector_registry();
   init_managed_token_handler();
+  init_kadoa_access_token();
   await init_src();
 });
 
@@ -51946,11 +52869,24 @@ async function createServer(auth, options) {
     }
   }
   registerTools(server, ctx, capabilities);
+  if (principal.type === "kadoa") {
+    const hidden = new Set(["team_switch"]);
+    const rawServer = server.server;
+    const baseHandler = rawServer._requestHandlers.get("tools/list");
+    if (!baseHandler) {
+      throw new Error("SDK tools/list handler not found; cannot hide team_switch");
+    }
+    server.server.setRequestHandler(ListToolsRequestSchema2, async (request, extra) => {
+      const result = await baseHandler(request, extra);
+      return { ...result, tools: result.tools.filter((tool) => !hidden.has(tool.name)) };
+    });
+  }
   server.server.onerror = (error) => console.error("[MCP Error]", safeErrorSummary(error));
   return server;
 }
 var init_src = __esm(async () => {
   init_mcp();
+  init_types3();
   init_client();
   init_tools();
   init_package();