mcp-sunsama 0.16.1 → 0.17.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # mcp-sunsama
 
+## 0.17.0
+
+### Minor Changes
+
+- 26000bd: Add subtask management support
+
+  - Update sunsama-api dependency to 0.13.1
+  - Add 5 new subtask management tools:
+    - `add-subtask` - Create a subtask with a title in one call (recommended)
+    - `create-subtasks` - Create multiple subtasks for a task (bulk operations)
+    - `update-subtask-title` - Update the title of a subtask
+    - `complete-subtask` - Mark a subtask as complete
+    - `uncomplete-subtask` - Mark a subtask as incomplete
+  - Update README and CLAUDE.md documentation
+
+- e3336cf: Add session token authentication support for users with SSO/OAuth login. Users can now authenticate using `SUNSAMA_SESSION_TOKEN` environment variable (stdio) or Bearer token authentication (HTTP) as an alternative to email/password credentials.
+
 ## 0.16.1
 
 ### Patch Changes

package/CLAUDE.md

@@ -182,7 +182,7 @@ src/
 ├── tools/
 │   ├── shared.ts          # Common utilities and tool wrapper patterns
 │   ├── user-tools.ts      # User operations (get-user)
-│   ├── task-tools.ts      # Task operations (15 tools)
+│   ├── task-tools.ts      # Task operations (20 tools)
 │   ├── stream-tools.ts    # Stream operations (get-streams)
 │   └── index.ts           # Export all tools
 ├── resources/
@@ -226,7 +226,7 @@ __tests__/
 
 **Resource-Based Organization**:
 - **User Tools**: Single tool for user operations
-- **Task Tools**: 15 tools organized by function (query, lifecycle, update)
+- **Task Tools**: 20 tools organized by function (query, lifecycle, update, subtasks)
 - **Stream Tools**: Single tool for stream operations
 
 **Type Safety Improvements**:
@@ -278,6 +278,7 @@ Optional:
 Full CRUD support:
 - **Read**: `get-tasks-by-day`, `get-tasks-backlog`, `get-archived-tasks`, `get-task-by-id`, `get-streams`
 - **Write**: `create-task` (with GitHub/Gmail integration support), `update-task-complete`, `update-task-planned-time`, `update-task-notes`, `update-task-snooze-date`, `update-task-backlog`, `update-task-stream`, `update-task-text`, `update-task-due-date`, `delete-task`
+- **Subtasks**: `add-subtask` (recommended), `create-subtasks` (bulk), `update-subtask-title`, `complete-subtask`, `uncomplete-subtask`
 
 Task read operations support response trimming. `get-tasks-by-day` includes completion filtering. `get-archived-tasks` includes enhanced pagination with hasMore flag for LLM decision-making.
 

package/README.md

@@ -12,6 +12,7 @@ A Model Context Protocol (MCP) server that provides comprehensive task managemen
 - **Create Tasks** - Create new tasks with notes, time estimates, due dates, stream assignments, and GitHub/Gmail integrations
 - **Read Tasks** - Get tasks by day with completion filtering, access backlog tasks, retrieve archived task history
 - **Update Tasks** - Mark tasks as complete with custom timestamps, reschedule tasks or move to backlog
+- **Subtasks** - Add, update, complete, and manage subtasks within tasks
 - **Delete Tasks** - Permanently remove tasks from your workspace
 
 ### User & Stream Operations
@@ -111,6 +112,23 @@ Add this configuration to your Claude Desktop MCP settings:
 }
 ```
 
+### Claude Code Configuration
+
+Add the Sunsama MCP server using the Claude Code CLI:
+
+```bash
+claude mcp add sunsama --scope user \
+  -e SUNSAMA_EMAIL=your-email@example.com \
+  -e SUNSAMA_PASSWORD=your-password \
+  -- npx mcp-sunsama
+```
+
+**Scope Options:**
+- `--scope user` - Available across all projects (recommended)
+- `--scope project` - Only available in the current project
+
+After adding the server, restart Claude Code to connect to the Sunsama MCP server.
+
 ## API Tools
 
 ### Task Management
@@ -129,6 +147,13 @@ Add this configuration to your Claude Desktop MCP settings:
 - `update-task-backlog` - Move tasks to the backlog
 - `delete-task` - Delete tasks permanently
 
+#### Subtask Management
+- `add-subtask` - Create a subtask with a title in one call (recommended for single subtask creation)
+- `create-subtasks` - Create multiple subtasks for a task (low-level API for bulk operations)
+- `update-subtask-title` - Update the title of a subtask
+- `complete-subtask` - Mark a subtask as complete with optional completion timestamp
+- `uncomplete-subtask` - Mark a subtask as incomplete
+
 ### User & Stream Operations
 - `get-user` - Get current user information
 - `get-streams` - Get streams/channels for project organization

package/bun.lock

@@ -10,7 +10,7 @@
         "cors": "^2.8.5",
         "express": "^5.1.0",
         "papaparse": "^5.5.3",
-        "sunsama-api": "0.12.1",
+        "sunsama-api": "0.13.1",
         "zod": "3.24.4",
       },
       "devDependencies": {
@@ -397,7 +397,7 @@
 
     "strip-bom": ["strip-bom@3.0.0", "", {}, "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA=="],
 
-    "sunsama-api": ["sunsama-api@0.12.1", "", { "dependencies": { "graphql": "^16.11.0", "graphql-tag": "^2.12.6", "marked": "^14.1.3", "tough-cookie": "^5.1.2", "tslib": "^2.8.1", "turndown": "^7.2.0", "yjs": "^13.6.27", "zod": "^3.25.64" } }, "sha512-F2GLJjanAeboP4vYg3VIKP8xxQ/8LLqHhNFx3lm9oONOSvLzVAXEJlwonESuUI/iIf93b2i/jYCJ/2guoUhRYQ=="],
+    "sunsama-api": ["sunsama-api@0.13.1", "", { "dependencies": { "graphql": "^16.11.0", "graphql-tag": "^2.12.6", "marked": "^14.1.3", "tough-cookie": "^5.1.2", "tslib": "^2.8.1", "turndown": "^7.2.0", "yjs": "^13.6.27", "zod": "^3.25.64" } }, "sha512-d60j9tLvH/HoF1K/CD8B5rphQ6UW+9XOkJHdABFVfmKCRvA+XNhN73ZzSm78dd+nRJXzaZqKG96+saN8jyBjCg=="],
 
     "term-size": ["term-size@2.2.1", "", {}, "sha512-wK0Ri4fOGjv/XPy8SBHZChl8CM7uMc5VML7SqiQ0zG7+J5Vr+RMQDoHa2CNT6KHUnTGIXH34UDMkPzAUyapBZg=="],
 

package/dist/auth/http.d.ts

@@ -17,6 +17,7 @@ export declare function stopClientCacheCleanup(): void;
 export declare function cleanupAllClients(): void;
 /**
  * Authenticate HTTP request and get or create cached client
+ * Supports both Basic Auth (email/password) and Bearer token authentication
  * Uses secure cache key (password hash) and race condition protection
  */
 export declare function authenticateHttpRequest(authHeader?: string): Promise<SessionData>;

package/dist/auth/http.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/auth/http.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAe9C;;GAEG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAiBtF;AA+CD,wBAAgB,uBAAuB,IAAI,IAAI,CAQ9C;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAM7C;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAYxC;AAED;;;GAGG;AACH,wBAAsB,uBAAuB,CAC3C,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,WAAW,CAAC,CAiEtB"}
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/auth/http.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAe9C;;GAEG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAiBtF;AAwDD,wBAAgB,uBAAuB,IAAI,IAAI,CAQ9C;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,IAAI,CAM7C;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAYxC;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAC3C,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,WAAW,CAAC,CAsItB"}

package/dist/auth/http.js

@@ -36,6 +36,14 @@ function getCacheKey(email, password) {
         .update(`${email}:${password}`)
         .digest('hex');
 }
+/**
+ * Generate secure cache key from session token
+ */
+function getTokenCacheKey(token) {
+    return createHash('sha256')
+        .update(`token:${token}`)
+        .digest('hex');
+}
 /**
  * Check if a cached client is still valid based on TTL
  */
@@ -102,18 +110,80 @@ export function cleanupAllClients() {
 }
 /**
  * Authenticate HTTP request and get or create cached client
+ * Supports both Basic Auth (email/password) and Bearer token authentication
  * Uses secure cache key (password hash) and race condition protection
  */
 export async function authenticateHttpRequest(authHeader) {
-    if (!authHeader || !authHeader.startsWith('Basic ')) {
-        throw new Error("Basic Auth required");
+    if (!authHeader) {
+        throw new Error("Authorization header required (Basic or Bearer)");
+    }
+    const isBearer = authHeader.startsWith('Bearer ');
+    const isBasic = authHeader.startsWith('Basic ');
+    if (!isBearer && !isBasic) {
+        throw new Error("Authorization header must be Basic or Bearer");
     }
-    const { email, password } = parseBasicAuth(authHeader);
-    const cacheKey = getCacheKey(email, password);
     const now = Date.now();
+    let cacheKey;
+    let identifier;
+    if (isBearer) {
+        const token = authHeader.replace('Bearer ', '').trim();
+        if (!token) {
+            throw new Error("Invalid Bearer token");
+        }
+        cacheKey = getTokenCacheKey(token);
+        identifier = 'token-user';
+        // Check for pending authentication (race condition protection)
+        if (authPromises.has(cacheKey)) {
+            console.error(`[Client Cache] Waiting for pending authentication for ${identifier}`);
+            return await authPromises.get(cacheKey);
+        }
+        // Check cache first
+        if (clientCache.has(cacheKey)) {
+            const cached = clientCache.get(cacheKey);
+            if (isClientValid(cached)) {
+                console.error(`[Client Cache] Reusing cached client for ${identifier}`);
+                cached.lastAccessedAt = now;
+                return cached;
+            }
+            else {
+                console.error(`[Client Cache] Cached client expired for ${identifier}, re-authenticating`);
+                try {
+                    cached.sunsamaClient.logout();
+                }
+                catch (err) {
+                    console.error(`[Client Cache] Error logging out expired client:`, err);
+                }
+                clientCache.delete(cacheKey);
+            }
+        }
+        // Create authentication promise for Bearer token
+        console.error(`[Client Cache] Creating new client for ${identifier}`);
+        const authPromise = (async () => {
+            try {
+                const sunsamaClient = new SunsamaClient({ sessionToken: token });
+                const sessionData = {
+                    sunsamaClient,
+                    createdAt: now,
+                    lastAccessedAt: now
+                };
+                clientCache.set(cacheKey, sessionData);
+                console.error(`[Client Cache] Cached new client for ${identifier} (total: ${clientCache.size})`);
+                return sessionData;
+            }
+            finally {
+                authPromises.delete(cacheKey);
+            }
+        })();
+        authPromises.set(cacheKey, authPromise);
+        return authPromise;
+    }
+    // Basic Auth flow
+    const { email, password } = parseBasicAuth(authHeader);
+    cacheKey = getCacheKey(email, password);
+    identifier = email;
     // Check for pending authentication (race condition protection)
     if (authPromises.has(cacheKey)) {
-        console.error(`[Client Cache] Waiting for pending authentication for ${email}`);
+        console.error(`[Client Cache] Waiting for pending authentication for ${identifier}`);
         return await authPromises.get(cacheKey);
     }
     // Check cache first
@@ -121,13 +191,13 @@ export async function authenticateHttpRequest(authHeader) {
         const cached = clientCache.get(cacheKey);
         // Check if still valid (lazy expiration)
         if (isClientValid(cached)) {
-            console.error(`[Client Cache] Reusing cached client for ${email}`);
+            console.error(`[Client Cache] Reusing cached client for ${identifier}`);
             // Update last accessed time (sliding window)
             cached.lastAccessedAt = now;
             return cached;
         }
         else {
-            console.error(`[Client Cache] Cached client expired for ${email}, re-authenticating`);
+            console.error(`[Client Cache] Cached client expired for ${identifier}, re-authenticating`);
             // Cleanup expired client
             try {
                 cached.sunsamaClient.logout();
@@ -139,7 +209,7 @@ export async function authenticateHttpRequest(authHeader) {
         }
     }
     // Create authentication promise to prevent concurrent authentications
-    console.error(`[Client Cache] Creating new client for ${email}`);
+    console.error(`[Client Cache] Creating new client for ${identifier}`);
     const authPromise = (async () => {
         try {
             const sunsamaClient = new SunsamaClient();
@@ -151,7 +221,7 @@ export async function authenticateHttpRequest(authHeader) {
                 lastAccessedAt: now
             };
             clientCache.set(cacheKey, sessionData);
-            console.error(`[Client Cache] Cached new client for ${email} (total: ${clientCache.size})`);
+            console.error(`[Client Cache] Cached new client for ${identifier} (total: ${clientCache.size})`);
             return sessionData;
         }
         finally {

package/dist/auth/stdio.d.ts

@@ -1,6 +1,7 @@
 import { SunsamaClient } from "sunsama-api/client";
 /**
  * Initialize stdio authentication using environment variables
+ * Supports session token (SUNSAMA_SESSION_TOKEN) or email/password (SUNSAMA_EMAIL, SUNSAMA_PASSWORD)
  * @throws {Error} If credentials are missing or authentication fails
  */
 export declare function initializeStdioAuth(): Promise<SunsamaClient>;

package/dist/auth/stdio.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../../src/auth/stdio.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAOnD;;;GAGG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,aAAa,CAAC,CAWlE;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,aAAa,CAAC,CAMrE"}
+{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../../src/auth/stdio.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAOnD;;;;GAIG;AACH,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,aAAa,CAAC,CAoBlE;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,aAAa,CAAC,CAMrE"}

package/dist/auth/stdio.js

@@ -5,11 +5,20 @@ import { SunsamaClient } from "sunsama-api/client";
 let authenticationPromise = null;
 /**
  * Initialize stdio authentication using environment variables
+ * Supports session token (SUNSAMA_SESSION_TOKEN) or email/password (SUNSAMA_EMAIL, SUNSAMA_PASSWORD)
  * @throws {Error} If credentials are missing or authentication fails
  */
 export async function initializeStdioAuth() {
+    // Prefer session token if available (useful for Google SSO users)
+    if (process.env.SUNSAMA_SESSION_TOKEN) {
+        const sunsamaClient = new SunsamaClient({
+            sessionToken: process.env.SUNSAMA_SESSION_TOKEN
+        });
+        return sunsamaClient;
+    }
+    // Fall back to email/password authentication
     if (!process.env.SUNSAMA_EMAIL || !process.env.SUNSAMA_PASSWORD) {
-        throw new Error("Sunsama credentials not configured. Please set SUNSAMA_EMAIL and SUNSAMA_PASSWORD environment variables.");
+        throw new Error("Sunsama credentials not configured. Please set SUNSAMA_SESSION_TOKEN or both SUNSAMA_EMAIL and SUNSAMA_PASSWORD environment variables.");
     }
     const sunsamaClient = new SunsamaClient();
     await sunsamaClient.login(process.env.SUNSAMA_EMAIL, process.env.SUNSAMA_PASSWORD);

package/dist/auth/types.d.ts

@@ -4,7 +4,7 @@ import { SunsamaClient } from "sunsama-api/client";
  */
 export interface SessionData extends Record<string, unknown> {
     sunsamaClient: SunsamaClient;
-    email: string;
+    email?: string;
     createdAt: number;
     lastAccessedAt: number;
 }

package/dist/auth/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/auth/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,WAAY,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC1D,aAAa,EAAE,aAAa,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;CACxB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/auth/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,WAAY,SAAQ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAC1D,aAAa,EAAE,aAAa,CAAC;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;CACxB"}

package/dist/constants.d.ts

@@ -4,7 +4,7 @@
  * VERSION is automatically synced from package.json by scripts/sync-version.ts
  * when running `bun run version`
  */
-export declare const VERSION = "0.16.1";
+export declare const VERSION = "0.17.0";
 export declare const SERVER_NAME = "Sunsama API Server";
 export declare const PACKAGE_NAME = "mcp-sunsama";
 //# sourceMappingURL=constants.d.ts.map

package/dist/constants.js

@@ -4,6 +4,6 @@
  * VERSION is automatically synced from package.json by scripts/sync-version.ts
  * when running `bun run version`
  */
-export const VERSION = "0.16.1";
+export const VERSION = "0.17.0";
 export const SERVER_NAME = "Sunsama API Server";
 export const PACKAGE_NAME = "mcp-sunsama";

package/dist/schemas.d.ts

@@ -340,6 +340,74 @@ export declare const updateTaskStreamSchema: z.ZodObject<{
     streamId: string;
     limitResponsePayload?: boolean | undefined;
 }>;
+/**
+ * Subtask Operation Schemas
+ */
+export declare const createSubtasksSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    subtaskIds: z.ZodArray<z.ZodString, "many">;
+    limitResponsePayload: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+    subtaskIds: string[];
+    limitResponsePayload?: boolean | undefined;
+}, {
+    taskId: string;
+    subtaskIds: string[];
+    limitResponsePayload?: boolean | undefined;
+}>;
+export declare const updateSubtaskTitleSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    subtaskId: z.ZodString;
+    title: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+    subtaskId: string;
+    title: string;
+}, {
+    taskId: string;
+    subtaskId: string;
+    title: string;
+}>;
+export declare const completeSubtaskSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    subtaskId: z.ZodString;
+    completedDate: z.ZodOptional<z.ZodString>;
+    limitResponsePayload: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+    subtaskId: string;
+    limitResponsePayload?: boolean | undefined;
+    completedDate?: string | undefined;
+}, {
+    taskId: string;
+    subtaskId: string;
+    limitResponsePayload?: boolean | undefined;
+    completedDate?: string | undefined;
+}>;
+export declare const uncompleteSubtaskSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    subtaskId: z.ZodString;
+    limitResponsePayload: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+    subtaskId: string;
+    limitResponsePayload?: boolean | undefined;
+}, {
+    taskId: string;
+    subtaskId: string;
+    limitResponsePayload?: boolean | undefined;
+}>;
+export declare const addSubtaskSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    title: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    taskId: string;
+    title: string;
+}, {
+    taskId: string;
+    title: string;
+}>;
 /**
  * Response Type Schemas (for validation and documentation)
  */
@@ -464,9 +532,9 @@ export declare const taskSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     status: string;
     createdAt: string;
+    title: string;
     _id: string;
     groupId: string;
-    title: string;
     updatedAt: string;
     userId: string;
     streamId?: string | undefined;
@@ -476,9 +544,9 @@ export declare const taskSchema: z.ZodObject<{
 }, {
     status: string;
     createdAt: string;
+    title: string;
     _id: string;
     groupId: string;
-    title: string;
     updatedAt: string;
     userId: string;
     streamId?: string | undefined;
@@ -639,9 +707,9 @@ export declare const tasksResponseSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         status: string;
         createdAt: string;
+        title: string;
         _id: string;
         groupId: string;
-        title: string;
         updatedAt: string;
         userId: string;
         streamId?: string | undefined;
@@ -651,9 +719,9 @@ export declare const tasksResponseSchema: z.ZodObject<{
     }, {
         status: string;
         createdAt: string;
+        title: string;
         _id: string;
         groupId: string;
-        title: string;
         updatedAt: string;
         userId: string;
         streamId?: string | undefined;
@@ -666,9 +734,9 @@ export declare const tasksResponseSchema: z.ZodObject<{
     tasks: {
         status: string;
         createdAt: string;
+        title: string;
         _id: string;
         groupId: string;
-        title: string;
         updatedAt: string;
         userId: string;
         streamId?: string | undefined;
@@ -681,9 +749,9 @@ export declare const tasksResponseSchema: z.ZodObject<{
     tasks: {
         status: string;
         createdAt: string;
+        title: string;
         _id: string;
         groupId: string;
-        title: string;
         updatedAt: string;
         userId: string;
         streamId?: string | undefined;
@@ -779,6 +847,11 @@ export type UpdateTaskNotesInput = z.infer<typeof updateTaskNotesSchema>;
 export type UpdateTaskDueDateInput = z.infer<typeof updateTaskDueDateSchema>;
 export type UpdateTaskTextInput = z.infer<typeof updateTaskTextSchema>;
 export type UpdateTaskStreamInput = z.infer<typeof updateTaskStreamSchema>;
+export type CreateSubtasksInput = z.infer<typeof createSubtasksSchema>;
+export type UpdateSubtaskTitleInput = z.infer<typeof updateSubtaskTitleSchema>;
+export type CompleteSubtaskInput = z.infer<typeof completeSubtaskSchema>;
+export type UncompleteSubtaskInput = z.infer<typeof uncompleteSubtaskSchema>;
+export type AddSubtaskInput = z.infer<typeof addSubtaskSchema>;
 export type User = z.infer<typeof userSchema>;
 export type Task = z.infer<typeof taskSchema>;
 export type Stream = z.infer<typeof streamSchema>;

package/dist/schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AAGH,eAAO,MAAM,sBAAsB,+CAIjC,CAAC;AAGH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAW9B,CAAC;AAGH,eAAO,MAAM,qBAAqB,gDAAe,CAAC;AAGlD,eAAO,MAAM,sBAAsB;;;;;;;;;EAOjC,CAAC;AAGH,eAAO,MAAM,iBAAiB;;;;;;EAI5B,CAAC;AAEH;;GAEG;AAGH,eAAO,MAAM,aAAa,gDAAe,CAAC;AAE1C;;GAEG;AAGH,eAAO,MAAM,gBAAgB,gDAAe,CAAC;AA8C7C;;GAEG;AAGH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsB3B,CAAC;AAGH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;EAUnC,CAAC;AAGH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;EAU3B,CAAC;AAGH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;EAarC,CAAC;AAGH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;EAUlC,CAAC;AAGH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;EAUtC,CAAC;AAKH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;EAahC,CAAC;AAGH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;EAalC,CAAC;AAGH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;EAa/B,CAAC;AAGH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;EAUjC,CAAC;AAEH;;GAEG;AAGH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;EAO5B,CAAC;AAGH,eAAO,MAAM,WAAW;;;;;;;;;;;;EAItB,CAAC;AAGH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKrB,CAAC;AAGH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAYrB,CAAC;AAGH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;EAQvB,CAAC;AAEH;;GAEG;AAGH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE7B,CAAC;AAGH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAG9B,CAAC;AAGH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGhC,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;EAI9B,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACrE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACzE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAC3E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AACjE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACzD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE/D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC/D,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC/E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC/D,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC7C,OAAO,0BAA0B,CAClC,CAAC;AACF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAC7E,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAC9C,OAAO,2BAA2B,CACnC,CAAC;AACF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACzE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAC7E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACvE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAE3E,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAC9C,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAC9C,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAClD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../src/schemas.ts"],"names":[],"mappings":"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"}

package/dist/schemas.js

@@ -150,6 +150,39 @@ export const updateTaskStreamSchema = z.object({
     streamId: z.string().min(1, "Stream ID is required").describe("Stream ID to assign to the task"),
     limitResponsePayload: z.boolean().optional().describe("Whether to limit the response payload size"),
 });
+/**
+ * Subtask Operation Schemas
+ */
+// Create subtasks parameters
+export const createSubtasksSchema = z.object({
+    taskId: z.string().min(1, "Task ID is required").describe("The ID of the parent task"),
+    subtaskIds: z.array(z.string().min(1)).min(1, "At least one subtask ID is required").describe("Array of subtask IDs to create (use SunsamaClient.generateTaskId() to generate IDs)"),
+    limitResponsePayload: z.boolean().optional().describe("Whether to limit the response payload size"),
+});
+// Update subtask title parameters
+export const updateSubtaskTitleSchema = z.object({
+    taskId: z.string().min(1, "Task ID is required").describe("The ID of the parent task"),
+    subtaskId: z.string().min(1, "Subtask ID is required").describe("The ID of the subtask to update"),
+    title: z.string().min(1, "Subtask title is required").describe("The new title for the subtask"),
+});
+// Complete subtask parameters
+export const completeSubtaskSchema = z.object({
+    taskId: z.string().min(1, "Task ID is required").describe("The ID of the parent task"),
+    subtaskId: z.string().min(1, "Subtask ID is required").describe("The ID of the subtask to mark as complete"),
+    completedDate: z.string().optional().describe("Completion timestamp (ISO format). Defaults to current time"),
+    limitResponsePayload: z.boolean().optional().describe("Whether to limit the response payload size"),
+});
+// Uncomplete subtask parameters
+export const uncompleteSubtaskSchema = z.object({
+    taskId: z.string().min(1, "Task ID is required").describe("The ID of the parent task"),
+    subtaskId: z.string().min(1, "Subtask ID is required").describe("The ID of the subtask to mark as incomplete"),
+    limitResponsePayload: z.boolean().optional().describe("Whether to limit the response payload size"),
+});
+// Add subtask parameters (convenience method)
+export const addSubtaskSchema = z.object({
+    taskId: z.string().min(1, "Task ID is required").describe("The ID of the parent task"),
+    title: z.string().min(1, "Subtask title is required").describe("The title for the new subtask"),
+});
 /**
  * Response Type Schemas (for validation and documentation)
  */

package/dist/schemas.test.js

@@ -283,20 +283,22 @@ describe("Tool Parameter Schemas", () => {
             };
             expect(() => updateTaskNotesSchema.parse(minimalMarkdownInput)).not.toThrow();
         });
-        test("should reject both HTML and Markdown provided", () => {
-            const invalidInput = {
+        test("should accept both HTML and Markdown provided (XOR validation is in tool execute)", () => {
+            const inputWithBoth = {
                 taskId: "task-123",
                 html: "<p>HTML content</p>",
                 markdown: "Markdown content",
             };
-            expect(() => updateTaskNotesSchema.parse(invalidInput)).toThrow();
+            // Schema accepts both - XOR validation happens in the tool's execute function
+            expect(() => updateTaskNotesSchema.parse(inputWithBoth)).not.toThrow();
         });
-        test("should reject neither HTML nor Markdown provided", () => {
-            const invalidInput = {
+        test("should accept neither HTML nor Markdown provided (XOR validation is in tool execute)", () => {
+            const inputWithNeither = {
                 taskId: "task-123",
                 limitResponsePayload: true,
             };
-            expect(() => updateTaskNotesSchema.parse(invalidInput)).toThrow();
+            // Schema accepts neither - XOR validation happens in the tool's execute function
+            expect(() => updateTaskNotesSchema.parse(inputWithNeither)).not.toThrow();
         });
         test("should reject empty task ID", () => {
             expect(() => updateTaskNotesSchema.parse({

package/dist/tools/task-tools.d.ts

@@ -82,6 +82,36 @@ export declare const updateTaskStreamTool: {
     parameters: any;
     execute: (args: any, extra?: any) => Promise<any>;
 };
+export declare const createSubtasksTool: {
+    name: string;
+    description: string;
+    parameters: any;
+    execute: (args: any, extra?: any) => Promise<any>;
+};
+export declare const updateSubtaskTitleTool: {
+    name: string;
+    description: string;
+    parameters: any;
+    execute: (args: any, extra?: any) => Promise<any>;
+};
+export declare const completeSubtaskTool: {
+    name: string;
+    description: string;
+    parameters: any;
+    execute: (args: any, extra?: any) => Promise<any>;
+};
+export declare const uncompleteSubtaskTool: {
+    name: string;
+    description: string;
+    parameters: any;
+    execute: (args: any, extra?: any) => Promise<any>;
+};
+export declare const addSubtaskTool: {
+    name: string;
+    description: string;
+    parameters: any;
+    execute: (args: any, extra?: any) => Promise<any>;
+};
 export declare const taskTools: {
     name: string;
     description: string;

package/dist/tools/task-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task-tools.d.ts","sourceRoot":"","sources":["../../src/tools/task-tools.ts"],"names":[],"mappings":"AA0CA,eAAO,MAAM,mBAAmB;;;;;CAU9B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;CAqB5B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;CA2B/B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;CAS1B,CAAC;AAGH,eAAO,MAAM,cAAc;;;;;CAsCzB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;CAqBzB,CAAC;AAGH,eAAO,MAAM,sBAAsB;;;;;CAqBjC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;CA6BnC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;CA2BhC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;CAsBpC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;CAwC9B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;CAsBhC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;CA8B7B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;CAsB/B,CAAC;AAGH,eAAO,MAAM,SAAS;;;;;GAoBrB,CAAC"}
+{"version":3,"file":"task-tools.d.ts","sourceRoot":"","sources":["../../src/tools/task-tools.ts"],"names":[],"mappings":"AAoDA,eAAO,MAAM,mBAAmB;;;;;CAU9B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;CAqB5B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;CA2B/B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;CAS1B,CAAC;AAGH,eAAO,MAAM,cAAc;;;;;CAsCzB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;CAqBzB,CAAC;AAGH,eAAO,MAAM,sBAAsB;;;;;CAqBjC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;CA6BnC,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;CA2BhC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;CAsBpC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;CAwC9B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;CAsBhC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;CA8B7B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;CAsB/B,CAAC;AAGH,eAAO,MAAM,kBAAkB;;;;;CAuB7B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;CAuBjC,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;CAwB9B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;CAsBhC,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;CAmBzB,CAAC;AAGH,eAAO,MAAM,SAAS;;;;;GA2BrB,CAAC"}

package/dist/tools/task-tools.js

@@ -1,4 +1,4 @@
-import { createTaskSchema, deleteTaskSchema, getArchivedTasksSchema, getTaskByIdSchema, getTasksBacklogSchema, getTasksByDaySchema, updateTaskBacklogSchema, updateTaskCompleteSchema, updateTaskDueDateSchema, updateTaskNotesSchema, updateTaskPlannedTimeSchema, updateTaskSnoozeDateSchema, updateTaskStreamSchema, updateTaskTextSchema, } from "../schemas.js";
+import { addSubtaskSchema, completeSubtaskSchema, createSubtasksSchema, createTaskSchema, deleteTaskSchema, getArchivedTasksSchema, getTaskByIdSchema, getTasksBacklogSchema, getTasksByDaySchema, uncompleteSubtaskSchema, updateSubtaskTitleSchema, updateTaskBacklogSchema, updateTaskCompleteSchema, updateTaskDueDateSchema, updateTaskNotesSchema, updateTaskPlannedTimeSchema, updateTaskSnoozeDateSchema, updateTaskStreamSchema, updateTaskTextSchema, } from "../schemas.js";
 import { filterTasksByCompletion } from "../utils/task-filters.js";
 import { trimTasksForResponse } from "../utils/task-trimmer.js";
 import { formatJsonResponse, formatPaginatedTsvResponse, formatTsvResponse, withTransportClient, } from "./shared.js";
@@ -257,6 +257,86 @@ export const updateTaskStreamTool = withTransportClient({
         });
     },
 });
+// Subtask Management Tools
+export const createSubtasksTool = withTransportClient({
+    name: "create-subtasks",
+    description: "Create multiple subtasks for a task (low-level API for bulk operations)",
+    parameters: createSubtasksSchema,
+    execute: async ({ taskId, subtaskIds, limitResponsePayload }, context) => {
+        const result = await context.client.createSubtasks(taskId, subtaskIds, limitResponsePayload);
+        return formatJsonResponse({
+            success: result.success,
+            taskId,
+            subtaskIds,
+            subtasksCreated: true,
+            count: subtaskIds.length,
+            updatedFields: result.updatedFields,
+        });
+    },
+});
+export const updateSubtaskTitleTool = withTransportClient({
+    name: "update-subtask-title",
+    description: "Update the title of a subtask",
+    parameters: updateSubtaskTitleSchema,
+    execute: async ({ taskId, subtaskId, title }, context) => {
+        const result = await context.client.updateSubtaskTitle(taskId, subtaskId, title);
+        return formatJsonResponse({
+            success: result.success,
+            taskId,
+            subtaskId,
+            title,
+            subtaskTitleUpdated: true,
+            updatedFields: result.updatedFields,
+        });
+    },
+});
+export const completeSubtaskTool = withTransportClient({
+    name: "complete-subtask",
+    description: "Mark a subtask as complete with optional completion timestamp",
+    parameters: completeSubtaskSchema,
+    execute: async ({ taskId, subtaskId, completedDate, limitResponsePayload }, context) => {
+        const result = await context.client.completeSubtask(taskId, subtaskId, completedDate, limitResponsePayload);
+        return formatJsonResponse({
+            success: result.success,
+            taskId,
+            subtaskId,
+            subtaskCompleted: true,
+            completedDate: completedDate || new Date().toISOString(),
+            updatedFields: result.updatedFields,
+        });
+    },
+});
+export const uncompleteSubtaskTool = withTransportClient({
+    name: "uncomplete-subtask",
+    description: "Mark a subtask as incomplete (uncomplete it)",
+    parameters: uncompleteSubtaskSchema,
+    execute: async ({ taskId, subtaskId, limitResponsePayload }, context) => {
+        const result = await context.client.uncompleteSubtask(taskId, subtaskId, limitResponsePayload);
+        return formatJsonResponse({
+            success: result.success,
+            taskId,
+            subtaskId,
+            subtaskUncompleted: true,
+            updatedFields: result.updatedFields,
+        });
+    },
+});
+export const addSubtaskTool = withTransportClient({
+    name: "add-subtask",
+    description: "Convenience method to create a subtask with a title in one call (recommended for single subtask creation)",
+    parameters: addSubtaskSchema,
+    execute: async ({ taskId, title }, context) => {
+        const result = await context.client.addSubtask(taskId, title);
+        return formatJsonResponse({
+            success: result.result.success,
+            taskId,
+            subtaskId: result.subtaskId,
+            title,
+            subtaskAdded: true,
+            updatedFields: result.result.updatedFields,
+        });
+    },
+});
 // Export all task tools
 export const taskTools = [
     // Query tools
@@ -276,4 +356,10 @@ export const taskTools = [
     updateTaskDueDateTool,
     updateTaskTextTool,
     updateTaskStreamTool,
+    // Subtask management tools
+    createSubtasksTool,
+    updateSubtaskTitleTool,
+    completeSubtaskTool,
+    uncompleteSubtaskTool,
+    addSubtaskTool,
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-sunsama",
-  "version": "0.16.1",
+  "version": "0.17.0",
   "description": "MCP server for Sunsama API integration",
   "type": "module",
   "private": false,
@@ -34,7 +34,7 @@
     "cors": "^2.8.5",
     "express": "^5.1.0",
     "papaparse": "^5.5.3",
-    "sunsama-api": "0.12.1",
+    "sunsama-api": "0.13.1",
     "zod": "3.24.4"
   },
   "devDependencies": {
@@ -64,4 +64,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}

package/src/auth/http.ts

@@ -47,6 +47,15 @@ function getCacheKey(email: string, password: string): string {
     .digest('hex');
 }
 
+/**
+ * Generate secure cache key from session token
+ */
+function getTokenCacheKey(token: string): string {
+  return createHash('sha256')
+    .update(`token:${token}`)
+    .digest('hex');
+}
+
 /**
  * Check if a cached client is still valid based on TTL
  */
@@ -122,22 +131,92 @@ export function cleanupAllClients(): void {
 
 /**
  * Authenticate HTTP request and get or create cached client
+ * Supports both Basic Auth (email/password) and Bearer token authentication
  * Uses secure cache key (password hash) and race condition protection
  */
 export async function authenticateHttpRequest(
   authHeader?: string
 ): Promise<SessionData> {
-  if (!authHeader || !authHeader.startsWith('Basic ')) {
-    throw new Error("Basic Auth required");
+  if (!authHeader) {
+    throw new Error("Authorization header required (Basic or Bearer)");
+  }
+
+  const isBearer = authHeader.startsWith('Bearer ');
+  const isBasic = authHeader.startsWith('Basic ');
+
+  if (!isBearer && !isBasic) {
+    throw new Error("Authorization header must be Basic or Bearer");
   }
 
-  const { email, password } = parseBasicAuth(authHeader);
-  const cacheKey = getCacheKey(email, password);
   const now = Date.now();
+  let cacheKey: string;
+  let identifier: string;
+
+  if (isBearer) {
+    const token = authHeader.replace('Bearer ', '').trim();
+    if (!token) {
+      throw new Error("Invalid Bearer token");
+    }
+    cacheKey = getTokenCacheKey(token);
+    identifier = 'token-user';
+
+    // Check for pending authentication (race condition protection)
+    if (authPromises.has(cacheKey)) {
+      console.error(`[Client Cache] Waiting for pending authentication for ${identifier}`);
+      return await authPromises.get(cacheKey)!;
+    }
+
+    // Check cache first
+    if (clientCache.has(cacheKey)) {
+      const cached = clientCache.get(cacheKey)!;
+      if (isClientValid(cached)) {
+        console.error(`[Client Cache] Reusing cached client for ${identifier}`);
+        cached.lastAccessedAt = now;
+        return cached;
+      } else {
+        console.error(`[Client Cache] Cached client expired for ${identifier}, re-authenticating`);
+        try {
+          cached.sunsamaClient.logout();
+        } catch (err) {
+          console.error(`[Client Cache] Error logging out expired client:`, err);
+        }
+        clientCache.delete(cacheKey);
+      }
+    }
+
+    // Create authentication promise for Bearer token
+    console.error(`[Client Cache] Creating new client for ${identifier}`);
+    const authPromise = (async () => {
+      try {
+        const sunsamaClient = new SunsamaClient({ sessionToken: token });
+
+        const sessionData: SessionData = {
+          sunsamaClient,
+          createdAt: now,
+          lastAccessedAt: now
+        };
+
+        clientCache.set(cacheKey, sessionData);
+        console.error(`[Client Cache] Cached new client for ${identifier} (total: ${clientCache.size})`);
+
+        return sessionData;
+      } finally {
+        authPromises.delete(cacheKey);
+      }
+    })();
+
+    authPromises.set(cacheKey, authPromise);
+    return authPromise;
+  }
+
+  // Basic Auth flow
+  const { email, password } = parseBasicAuth(authHeader);
+  cacheKey = getCacheKey(email, password);
+  identifier = email;
 
   // Check for pending authentication (race condition protection)
   if (authPromises.has(cacheKey)) {
-    console.error(`[Client Cache] Waiting for pending authentication for ${email}`);
+    console.error(`[Client Cache] Waiting for pending authentication for ${identifier}`);
     return await authPromises.get(cacheKey)!;
   }
 
@@ -147,12 +226,12 @@ export async function authenticateHttpRequest(
 
     // Check if still valid (lazy expiration)
     if (isClientValid(cached)) {
-      console.error(`[Client Cache] Reusing cached client for ${email}`);
+      console.error(`[Client Cache] Reusing cached client for ${identifier}`);
       // Update last accessed time (sliding window)
       cached.lastAccessedAt = now;
       return cached;
     } else {
-      console.error(`[Client Cache] Cached client expired for ${email}, re-authenticating`);
+      console.error(`[Client Cache] Cached client expired for ${identifier}, re-authenticating`);
       // Cleanup expired client
       try {
         cached.sunsamaClient.logout();
@@ -164,7 +243,7 @@ export async function authenticateHttpRequest(
   }
 
   // Create authentication promise to prevent concurrent authentications
-  console.error(`[Client Cache] Creating new client for ${email}`);
+  console.error(`[Client Cache] Creating new client for ${identifier}`);
   const authPromise = (async () => {
     try {
       const sunsamaClient = new SunsamaClient();
@@ -178,7 +257,7 @@ export async function authenticateHttpRequest(
       };
 
       clientCache.set(cacheKey, sessionData);
-      console.error(`[Client Cache] Cached new client for ${email} (total: ${clientCache.size})`);
+      console.error(`[Client Cache] Cached new client for ${identifier} (total: ${clientCache.size})`);
 
       return sessionData;
     } finally {

package/src/auth/stdio.ts

@@ -7,12 +7,22 @@ let authenticationPromise: Promise<SunsamaClient> | null = null;
 
 /**
  * Initialize stdio authentication using environment variables
+ * Supports session token (SUNSAMA_SESSION_TOKEN) or email/password (SUNSAMA_EMAIL, SUNSAMA_PASSWORD)
  * @throws {Error} If credentials are missing or authentication fails
  */
 export async function initializeStdioAuth(): Promise<SunsamaClient> {
+  // Prefer session token if available (useful for Google SSO users)
+  if (process.env.SUNSAMA_SESSION_TOKEN) {
+    const sunsamaClient = new SunsamaClient({
+      sessionToken: process.env.SUNSAMA_SESSION_TOKEN
+    });
+    return sunsamaClient;
+  }
+
+  // Fall back to email/password authentication
   if (!process.env.SUNSAMA_EMAIL || !process.env.SUNSAMA_PASSWORD) {
     throw new Error(
-      "Sunsama credentials not configured. Please set SUNSAMA_EMAIL and SUNSAMA_PASSWORD environment variables."
+      "Sunsama credentials not configured. Please set SUNSAMA_SESSION_TOKEN or both SUNSAMA_EMAIL and SUNSAMA_PASSWORD environment variables."
     );
   }
 

package/src/auth/types.ts

@@ -5,7 +5,7 @@ import { SunsamaClient } from "sunsama-api/client";
  */
 export interface SessionData extends Record<string, unknown> {
   sunsamaClient: SunsamaClient;
-  email: string;
+  email?: string;
   createdAt: number;
   lastAccessedAt: number;
 }

package/src/constants.ts

@@ -5,6 +5,6 @@
  * when running `bun run version`
  */
 
-export const VERSION = "0.16.1";
+export const VERSION = "0.17.0";
 export const SERVER_NAME = "Sunsama API Server";
 export const PACKAGE_NAME = "mcp-sunsama";

package/src/schemas.test.ts

@@ -391,21 +391,23 @@ describe("Tool Parameter Schemas", () => {
       expect(() => updateTaskNotesSchema.parse(minimalMarkdownInput)).not.toThrow();
     });
 
-    test("should reject both HTML and Markdown provided", () => {
-      const invalidInput = {
+    test("should accept both HTML and Markdown provided (XOR validation is in tool execute)", () => {
+      const inputWithBoth = {
         taskId: "task-123",
         html: "<p>HTML content</p>",
         markdown: "Markdown content",
       };
-      expect(() => updateTaskNotesSchema.parse(invalidInput)).toThrow();
+      // Schema accepts both - XOR validation happens in the tool's execute function
+      expect(() => updateTaskNotesSchema.parse(inputWithBoth)).not.toThrow();
     });
 
-    test("should reject neither HTML nor Markdown provided", () => {
-      const invalidInput = {
+    test("should accept neither HTML nor Markdown provided (XOR validation is in tool execute)", () => {
+      const inputWithNeither = {
         taskId: "task-123",
         limitResponsePayload: true,
       };
-      expect(() => updateTaskNotesSchema.parse(invalidInput)).toThrow();
+      // Schema accepts neither - XOR validation happens in the tool's execute function
+      expect(() => updateTaskNotesSchema.parse(inputWithNeither)).not.toThrow();
     });
 
     test("should reject empty task ID", () => {

package/src/schemas.ts

@@ -263,6 +263,75 @@ export const updateTaskStreamSchema = z.object({
   ),
 });
 
+/**
+ * Subtask Operation Schemas
+ */
+
+// Create subtasks parameters
+export const createSubtasksSchema = z.object({
+  taskId: z.string().min(1, "Task ID is required").describe(
+    "The ID of the parent task",
+  ),
+  subtaskIds: z.array(z.string().min(1)).min(1, "At least one subtask ID is required").describe(
+    "Array of subtask IDs to create (use SunsamaClient.generateTaskId() to generate IDs)",
+  ),
+  limitResponsePayload: z.boolean().optional().describe(
+    "Whether to limit the response payload size",
+  ),
+});
+
+// Update subtask title parameters
+export const updateSubtaskTitleSchema = z.object({
+  taskId: z.string().min(1, "Task ID is required").describe(
+    "The ID of the parent task",
+  ),
+  subtaskId: z.string().min(1, "Subtask ID is required").describe(
+    "The ID of the subtask to update",
+  ),
+  title: z.string().min(1, "Subtask title is required").describe(
+    "The new title for the subtask",
+  ),
+});
+
+// Complete subtask parameters
+export const completeSubtaskSchema = z.object({
+  taskId: z.string().min(1, "Task ID is required").describe(
+    "The ID of the parent task",
+  ),
+  subtaskId: z.string().min(1, "Subtask ID is required").describe(
+    "The ID of the subtask to mark as complete",
+  ),
+  completedDate: z.string().optional().describe(
+    "Completion timestamp (ISO format). Defaults to current time",
+  ),
+  limitResponsePayload: z.boolean().optional().describe(
+    "Whether to limit the response payload size",
+  ),
+});
+
+// Uncomplete subtask parameters
+export const uncompleteSubtaskSchema = z.object({
+  taskId: z.string().min(1, "Task ID is required").describe(
+    "The ID of the parent task",
+  ),
+  subtaskId: z.string().min(1, "Subtask ID is required").describe(
+    "The ID of the subtask to mark as incomplete",
+  ),
+  limitResponsePayload: z.boolean().optional().describe(
+    "Whether to limit the response payload size",
+  ),
+});
+
+// Add subtask parameters (convenience method)
+export const addSubtaskSchema = z.object({
+  taskId: z.string().min(1, "Task ID is required").describe(
+    "The ID of the parent task",
+  ),
+  title: z.string().min(1, "Subtask title is required").describe(
+    "The title for the new subtask",
+  ),
+});
+
 /**
  * Response Type Schemas (for validation and documentation)
  */
@@ -375,6 +444,12 @@ export type UpdateTaskDueDateInput = z.infer<typeof updateTaskDueDateSchema>;
 export type UpdateTaskTextInput = z.infer<typeof updateTaskTextSchema>;
 export type UpdateTaskStreamInput = z.infer<typeof updateTaskStreamSchema>;
 
+export type CreateSubtasksInput = z.infer<typeof createSubtasksSchema>;
+export type UpdateSubtaskTitleInput = z.infer<typeof updateSubtaskTitleSchema>;
+export type CompleteSubtaskInput = z.infer<typeof completeSubtaskSchema>;
+export type UncompleteSubtaskInput = z.infer<typeof uncompleteSubtaskSchema>;
+export type AddSubtaskInput = z.infer<typeof addSubtaskSchema>;
+
 export type User = z.infer<typeof userSchema>;
 export type Task = z.infer<typeof taskSchema>;
 export type Stream = z.infer<typeof streamSchema>;

package/src/tools/task-tools.ts

@@ -1,5 +1,11 @@
 import type { CreateTaskOptions } from "sunsama-api/types";
 import {
+  type AddSubtaskInput,
+  addSubtaskSchema,
+  type CompleteSubtaskInput,
+  completeSubtaskSchema,
+  type CreateSubtasksInput,
+  createSubtasksSchema,
   type CreateTaskInput,
   createTaskSchema,
   type DeleteTaskInput,
@@ -12,6 +18,10 @@ import {
   getTasksBacklogSchema,
   type GetTasksByDayInput,
   getTasksByDaySchema,
+  type UncompleteSubtaskInput,
+  uncompleteSubtaskSchema,
+  type UpdateSubtaskTitleInput,
+  updateSubtaskTitleSchema,
   type UpdateTaskBacklogInput,
   updateTaskBacklogSchema,
   type UpdateTaskCompleteInput,
@@ -409,6 +419,128 @@ export const updateTaskStreamTool = withTransportClient({
   },
 });
 
+// Subtask Management Tools
+export const createSubtasksTool = withTransportClient({
+  name: "create-subtasks",
+  description: "Create multiple subtasks for a task (low-level API for bulk operations)",
+  parameters: createSubtasksSchema,
+  execute: async (
+    { taskId, subtaskIds, limitResponsePayload }: CreateSubtasksInput,
+    context: ToolContext,
+  ) => {
+    const result = await context.client.createSubtasks(
+      taskId,
+      subtaskIds,
+      limitResponsePayload,
+    );
+
+    return formatJsonResponse({
+      success: result.success,
+      taskId,
+      subtaskIds,
+      subtasksCreated: true,
+      count: subtaskIds.length,
+      updatedFields: result.updatedFields,
+    });
+  },
+});
+
+export const updateSubtaskTitleTool = withTransportClient({
+  name: "update-subtask-title",
+  description: "Update the title of a subtask",
+  parameters: updateSubtaskTitleSchema,
+  execute: async (
+    { taskId, subtaskId, title }: UpdateSubtaskTitleInput,
+    context: ToolContext,
+  ) => {
+    const result = await context.client.updateSubtaskTitle(
+      taskId,
+      subtaskId,
+      title,
+    );
+
+    return formatJsonResponse({
+      success: result.success,
+      taskId,
+      subtaskId,
+      title,
+      subtaskTitleUpdated: true,
+      updatedFields: result.updatedFields,
+    });
+  },
+});
+
+export const completeSubtaskTool = withTransportClient({
+  name: "complete-subtask",
+  description: "Mark a subtask as complete with optional completion timestamp",
+  parameters: completeSubtaskSchema,
+  execute: async (
+    { taskId, subtaskId, completedDate, limitResponsePayload }: CompleteSubtaskInput,
+    context: ToolContext,
+  ) => {
+    const result = await context.client.completeSubtask(
+      taskId,
+      subtaskId,
+      completedDate,
+      limitResponsePayload,
+    );
+
+    return formatJsonResponse({
+      success: result.success,
+      taskId,
+      subtaskId,
+      subtaskCompleted: true,
+      completedDate: completedDate || new Date().toISOString(),
+      updatedFields: result.updatedFields,
+    });
+  },
+});
+
+export const uncompleteSubtaskTool = withTransportClient({
+  name: "uncomplete-subtask",
+  description: "Mark a subtask as incomplete (uncomplete it)",
+  parameters: uncompleteSubtaskSchema,
+  execute: async (
+    { taskId, subtaskId, limitResponsePayload }: UncompleteSubtaskInput,
+    context: ToolContext,
+  ) => {
+    const result = await context.client.uncompleteSubtask(
+      taskId,
+      subtaskId,
+      limitResponsePayload,
+    );
+
+    return formatJsonResponse({
+      success: result.success,
+      taskId,
+      subtaskId,
+      subtaskUncompleted: true,
+      updatedFields: result.updatedFields,
+    });
+  },
+});
+
+export const addSubtaskTool = withTransportClient({
+  name: "add-subtask",
+  description: "Convenience method to create a subtask with a title in one call (recommended for single subtask creation)",
+  parameters: addSubtaskSchema,
+  execute: async (
+    { taskId, title }: AddSubtaskInput,
+    context: ToolContext,
+  ) => {
+    const result = await context.client.addSubtask(taskId, title);
+
+    return formatJsonResponse({
+      success: result.result.success,
+      taskId,
+      subtaskId: result.subtaskId,
+      title,
+      subtaskAdded: true,
+      updatedFields: result.result.updatedFields,
+    });
+  },
+});
+
 // Export all task tools
 export const taskTools = [
   // Query tools
@@ -430,4 +562,11 @@ export const taskTools = [
   updateTaskDueDateTool,
   updateTaskTextTool,
   updateTaskStreamTool,
+
+  // Subtask management tools
+  createSubtasksTool,
+  updateSubtaskTitleTool,
+  completeSubtaskTool,
+  uncompleteSubtaskTool,
+  addSubtaskTool,
 ];