@kadoa/mcp 0.5.33 → 0.6.0-rc.1

package/README.md

@@ -376,6 +376,16 @@ KADOA_PUBLIC_API_URI=http://localhost:12380 bun run dev
 
 The server starts in HTTP mode. You authenticate via OAuth the same way as with the remote server.
 
+### HTTP server environment variables
+
+Opaque OAuth bearer tokens are routed to the existing OAuth verifier. RS256 Kadoa access tokens (Public API tokens, including delegated Kadoa Assistant tokens) additionally require:
+
+| Variable | Description | If unset |
+|---|---|---|
+| `MCP_AUTH_ISSUER` | Issuer of Public API RS256 access tokens, `https://api.kadoa.com/v5/auth` | RS256 bearers rejected |
+| `MCP_AUTH_JWKS_URL` | JWKS of that issuer, `https://api.kadoa.com/v5/auth/.well-known/jwks.json` | RS256 bearers rejected |
+| `MCP_AUTH_AUDIENCE` | This pod's exact resource URL, e.g. `https://beta.mcp.kadoa.com/mcp` — must match the pod actually serving the request; a value copied from another pod's config cross-accepts that pod's tokens | RS256 bearers rejected |
+
 ## Contributing
 
 A typical feature touches three repos — **`kadoa-backend` → `kadoa-sdks` → `kadoa-mcp`**. The same surgery on three layers; same operation, different audience above it.

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() {
@@ -43741,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";
@@ -44274,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);
@@ -45577,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;
@@ -45601,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;
@@ -46194,7 +47011,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@kadoa/mcp",
-    version: "0.5.33",
+    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",
@@ -50308,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",
@@ -50321,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 };
   }
@@ -50746,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();
@@ -51547,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) {
@@ -51570,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) {
@@ -51598,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,
@@ -51636,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";
@@ -51650,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);
@@ -51771,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();
 });
 
@@ -51825,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();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kadoa/mcp",
-  "version": "0.5.33",
+  "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",