@critical-path/mcp 0.11.7 → 0.11.8

package/src/index.test.ts

@@ -1,347 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { CriticalPathEngine, InMemoryStore } from '@critical-path/core';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
-import {
-  ALL_TOOLS,
-  TOOL_MAP,
-  createCriticalPathMcpServer,
-  registerWebMcpTools,
-  ensureModelContextShim
-} from './index.js';
-
-describe('@critical-path/mcp', () => {
-  let engine: CriticalPathEngine;
-
-  beforeEach(() => {
-    engine = new CriticalPathEngine({ store: new InMemoryStore() });
-  });
-
-  describe('Tool Definitions', () => {
-    it('registers all core project management tools', () => {
-      const toolNames = ALL_TOOLS.map((t) => t.name);
-      expect(toolNames).toContain('list_projects');
-      expect(toolNames).toContain('get_project');
-      expect(toolNames).toContain('create_project');
-      expect(toolNames).toContain('list_tasks');
-      expect(toolNames).toContain('get_task');
-      expect(toolNames).toContain('create_task');
-      expect(toolNames).toContain('update_task');
-      expect(toolNames).toContain('delete_task');
-      expect(toolNames).toContain('list_deliverables');
-      expect(toolNames).toContain('create_deliverable');
-      expect(toolNames).toContain('list_comments');
-      expect(toolNames).toContain('add_comment');
-      expect(toolNames).toContain('calculate_critical_path');
-      expect(toolNames).toContain('get_timeline_ladder');
-      expect(toolNames).toContain('get_task_ladder');
-      expect(toolNames).toContain('get_workload_distribution');
-    });
-
-    it('executes project and task workflows through tool definitions', async () => {
-      // 1. Create project
-      const createProjTool = TOOL_MAP.get('create_project')!;
-      const project = await createProjTool.execute(
-        { name: 'Core Engine Dev', key: 'CED' },
-        engine
-      );
-      expect(project.id).toBeDefined();
-      expect(project.name).toBe('Core Engine Dev');
-
-      // 2. List projects
-      const listProjTool = TOOL_MAP.get('list_projects')!;
-      const projects = await listProjTool.execute({}, engine);
-      expect(projects).toHaveLength(1);
-      expect(projects[0].id).toBe(project.id);
-
-      // 3. Create task
-      const createTaskTool = TOOL_MAP.get('create_task')!;
-      const task = await createTaskTool.execute(
-        {
-          projectId: project.id,
-          title: 'Implement WebMCP Spec',
-          priority: 'urgent',
-          tags: ['agent', 'mcp']
-        },
-        engine
-      );
-      expect(task.id).toBeDefined();
-      expect(task.title).toBe('Implement WebMCP Spec');
-      expect(task.priority).toBe('urgent');
-
-      // 4. Update task
-      const updateTaskTool = TOOL_MAP.get('update_task')!;
-      const updated = await updateTaskTool.execute(
-        {
-          id: task.id,
-          status: 'in_progress',
-          estimatedHours: 5
-        },
-        engine
-      );
-      expect(updated.status).toBe('in_progress');
-      expect(updated.estimatedHours).toBe(5);
-
-      // 5. Add comment
-      const addCommentTool = TOOL_MAP.get('add_comment')!;
-      const comment = await addCommentTool.execute(
-        {
-          taskId: task.id,
-          content: 'Started drafting the WebMCP handler',
-          authorId: 'agent-1'
-        },
-        engine
-      );
-      expect(comment.content).toBe('Started drafting the WebMCP handler');
-
-      // 6. List tasks with filter
-      const listTasksTool = TOOL_MAP.get('list_tasks')!;
-      const filtered = await listTasksTool.execute(
-        { projectId: project.id, status: 'in_progress' },
-        engine
-      );
-      expect(filtered.tasks).toHaveLength(1);
-      expect(filtered.nextCursor).toBeUndefined();
-
-      // 7. Delete task
-      const deleteTaskTool = TOOL_MAP.get('delete_task')!;
-      const delRes = await deleteTaskTool.execute({ id: task.id }, engine);
-      expect(delRes.success).toBe(true);
-
-      const afterDelete = await listTasksTool.execute({ projectId: project.id }, engine);
-      expect(afterDelete.tasks).toHaveLength(0);
-    });
-
-    it('calculates critical path and returns timeline ladder via MCP tools', async () => {
-      const createProjTool = TOOL_MAP.get('create_project')!;
-      const project = await createProjTool.execute({ name: 'Timeline Ladder MCP', key: 'TLM' }, engine);
-
-      const createTaskTool = TOOL_MAP.get('create_task')!;
-      const t1 = await createTaskTool.execute({
-        projectId: project.id,
-        title: 'Step 1: Prototype',
-        status: 'done',
-        estimatedHours: 4
-      }, engine);
-
-      const t2 = await createTaskTool.execute({
-        projectId: project.id,
-        title: 'Step 2: Polish',
-        status: 'in_progress',
-        estimatedHours: 6
-      }, engine);
-
-      await engine.addDependency({
-        taskId: t2.id,
-        dependsOnTaskId: t1.id,
-        type: 'blocking'
-      });
-
-      // 1. calculate_critical_path tool
-      const cpmTool = TOOL_MAP.get('calculate_critical_path')!;
-      const cpmResult = await cpmTool.execute({ projectId: project.id }, engine);
-      expect(cpmResult.totalDurationHours).toBe(10);
-      expect(cpmResult.criticalTaskIds).toEqual([t1.id, t2.id]);
-
-      // 2. get_timeline_ladder tool
-      const ladderTool = TOOL_MAP.get('get_timeline_ladder')!;
-      const ladderResult = await ladderTool.execute({ projectId: project.id, level: 'all' }, engine);
-      expect(ladderResult.macro).toBeDefined();
-      expect(ladderResult.macro.criticalPathDurationHours).toBe(10);
-      expect(ladderResult.standard.tasks).toHaveLength(2);
-
-      // 3. get_task_ladder tool
-      const taskLadderTool = TOOL_MAP.get('get_task_ladder')!;
-      const taskLadderResult = await taskLadderTool.execute({ taskId: t2.id }, engine);
-      expect(taskLadderResult.taskId).toBe(t2.id);
-      expect(taskLadderResult.standard.title).toBe('Step 2: Polish');
-      expect(taskLadderResult.metrics).toBeDefined();
-
-      // 4. get_task_metrics tool
-      const taskMetricsTool = TOOL_MAP.get('get_task_metrics')!;
-      const taskMetricsResult = await taskMetricsTool.execute({ taskId: t2.id }, engine);
-      expect(taskMetricsResult.taskId).toBe(t2.id);
-      expect(taskMetricsResult.realityDelta.estimatedHours).toBe(6);
-      expect(taskMetricsResult.progress).toBeDefined();
-      expect(taskMetricsResult.evm).toBeDefined();
-
-      // 5. get_task_progress_history tool
-      const taskHistoryTool = TOOL_MAP.get('get_task_progress_history')!;
-      const taskHistoryResult = await taskHistoryTool.execute({ taskId: t2.id }, engine);
-      expect(taskHistoryResult.taskId).toBe(t2.id);
-      expect(taskHistoryResult.points.length).toBeGreaterThanOrEqual(1);
-
-      // 6. get_workload_distribution tool
-      const workloadTool = TOOL_MAP.get('get_workload_distribution')!;
-      const workloadResult = await workloadTool.execute({ projectId: project.id, interval: 'week' }, engine);
-      expect(workloadResult.projectId).toBe(project.id);
-      expect(workloadResult.buckets.length).toBeGreaterThan(0);
-      expect(workloadResult.totalHours).toBeGreaterThan(0);
-    });
-  });
-
-  describe('Standard MCP Server Creation', () => {
-    it('creates an MCP Server instance with capabilities', () => {
-      const server = createCriticalPathMcpServer({
-        engine,
-        name: 'test-mcp-server',
-        version: '1.0.0'
-      });
-      expect(server).toBeDefined();
-    });
-
-    it('throws if neither engine nor client is provided', () => {
-      expect(() => createCriticalPathMcpServer({} as any)).toThrow(
-        'Either engine or client must be provided'
-      );
-    });
-    async function connect(options: Parameters<typeof createCriticalPathMcpServer>[0]) {
-      const server = createCriticalPathMcpServer(options);
-      const client = new Client({ name: 'test-client', version: '1.0.0' });
-      const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
-      await Promise.all([server.connect(serverTransport), client.connect(clientTransport)]);
-      return client;
-    }
-
-    it('refuses to call tools excluded by the tools option', async () => {
-      const project = await engine.createProject({ name: 'Guarded', key: 'GRD' });
-      const task = await engine.createTask({ projectId: project.id, title: 'Keep me' });
-      const client = await connect({ engine, tools: ['list_tasks'] });
-
-      const { tools } = await client.listTools();
-      expect(tools.map((t) => t.name)).toEqual(['list_tasks']);
-
-      await expect(client.callTool({ name: 'delete_task', arguments: { id: task.id } })).rejects.toThrow(
-        /not registered/
-      );
-      expect(await engine.getTask(task.id)).not.toBeNull();
-    });
-
-    it('validates tool arguments and rejects undeclared fields', async () => {
-      const source = await engine.createProject({ name: 'Source', key: 'SRC' });
-      const other = await engine.createProject({ name: 'Other', key: 'OTH' });
-      const task = await engine.createTask({ projectId: source.id, title: 'Stay put' });
-      const client = await connect({ engine });
-
-      const invalid = await client.callTool({ name: 'get_task', arguments: { id: 42 } });
-      expect(invalid.isError).toBe(true);
-      expect((invalid.content as Array<{ text: string }>)[0].text).toContain('Invalid arguments');
-
-      const undeclared = await client.callTool({
-        name: 'update_task',
-        arguments: { id: task.id, title: 'Renamed', projectId: other.id }
-      });
-      expect(undeclared.isError).toBe(true);
-      expect((undeclared.content as Array<{ text: string }>)[0].text).toContain('projectId');
-      const unchanged = await engine.getTask(task.id);
-      expect(unchanged?.title).toBe('Stay put');
-      expect(unchanged?.projectId).toBe(source.id);
-    });
-
-    it('attributes engine writes to the configured actor', async () => {
-      const project = await engine.createProject({ name: 'Actors', key: 'ACT' });
-      const task = await engine.createTask({ projectId: project.id, title: 'T' });
-
-      const defaultClient = await connect({ engine });
-      const first = await defaultClient.callTool({ name: 'add_comment', arguments: { taskId: task.id, content: 'hi' } });
-      expect(JSON.parse((first.content as Array<{ text: string }>)[0].text).authorId).toBe('mcp-agent');
-
-      const namedClient = await connect({ engine, actor: { userId: 'claude', actorType: 'agent' } });
-      const second = await namedClient.callTool({ name: 'add_comment', arguments: { taskId: task.id, content: 'hi' } });
-      expect(JSON.parse((second.content as Array<{ text: string }>)[0].text).authorId).toBe('claude');
-    });
-
-    it('marks destructive tools with MCP annotations', async () => {
-      const client = await connect({ engine });
-      const { tools } = await client.listTools();
-      expect(tools.find((t) => t.name === 'delete_task')?.annotations?.destructiveHint).toBe(true);
-      expect(tools.find((t) => t.name === 'list_tasks')?.annotations?.readOnlyHint).toBe(true);
-    });
-  });
-
-  describe('WebMCP Client Layer', () => {
-    let mockDoc: any;
-    let mockWin: any;
-
-    beforeEach(() => {
-      mockDoc = {};
-      mockWin = {};
-    });
-
-    it('creates a modelContext shim if document.modelContext is not natively present', () => {
-      const shim = ensureModelContextShim(mockDoc);
-      expect(shim).toBeDefined();
-      expect(mockDoc.modelContext).toBe(shim);
-      expect(typeof shim!.registerTool).toBe('function');
-    });
-
-    it('registers tools into modelContext and allows execution', async () => {
-      const project = await engine.createProject({ name: 'WebMCP Test Project' });
-
-      // Mock client that delegates to engine
-      const mockClient: any = {
-        getProjects: () => engine.getProjects(),
-        getProject: (id: string) => engine.getProject(id),
-        createProject: (d: any) => engine.createProject(d),
-        getTasks: (pId?: string) => engine.getTasks(pId),
-        getTask: (id: string) => engine.getTask(id),
-        createTask: (d: any) => engine.createTask(d),
-        updateTask: (id: string, u: any) => engine.updateTask(id, u),
-        deleteTask: (id: string) => engine.deleteTask(id)
-      };
-
-      const handle = registerWebMcpTools({
-        client: mockClient,
-        projectId: project.id,
-        document: mockDoc,
-        window: mockWin
-      });
-
-      expect(handle.getRegisteredTools().length).toBeGreaterThan(0);
-      expect(mockDoc.modelContext).toBeDefined();
-
-      const registered = await mockDoc.modelContext.getTools();
-      expect(registered.length).toBe(handle.getRegisteredTools().length);
-
-      // Execute create_task via WebMCP modelContext, inheriting ambient projectId
-      const createdTask = await mockDoc.modelContext.executeTool('create_task', {
-        title: 'Task Created via WebMCP'
-      });
-      expect(createdTask.id).toBeDefined();
-      expect(createdTask.projectId).toBe(project.id);
-      expect(createdTask.title).toBe('Task Created via WebMCP');
-
-      // Verify window fallback
-      expect(mockWin.__CRITICAL_PATH_WEBMCP__).toBeDefined();
-      expect(mockWin.__CRITICAL_PATH_WEBMCP__.projectId).toBe(project.id);
-
-      // Cleanup
-      handle.unregister();
-      const afterUnregister = await mockDoc.modelContext.getTools();
-      expect(afterUnregister).toHaveLength(0);
-      expect(mockWin.__CRITICAL_PATH_WEBMCP__).toBeUndefined();
-    });
-
-    it('supports AbortSignal unregistration lifecycle', async () => {
-      const controller = new AbortController();
-      const mockClient: any = {
-        getTasks: () => Promise.resolve([])
-      };
-
-      registerWebMcpTools({
-        client: mockClient,
-        signal: controller.signal,
-        document: mockDoc,
-        window: mockWin
-      });
-
-      let tools = await mockDoc.modelContext.getTools();
-      expect(tools.length).toBeGreaterThan(0);
-
-      controller.abort();
-
-      tools = await mockDoc.modelContext.getTools();
-      expect(tools).toHaveLength(0);
-    });
-  });
-});

package/src/index.ts

@@ -1,3 +0,0 @@
-export * from './tools/definitions.js';
-export * from './server/index.js';
-export * from './web/index.js';

package/src/server/index.ts

@@ -1,275 +0,0 @@
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  ListResourcesRequestSchema,
-  ReadResourceRequestSchema,
-  ListPromptsRequestSchema,
-  GetPromptRequestSchema,
-  ErrorCode,
-  McpError
-} from '@modelcontextprotocol/sdk/types.js';
-import type { Actor, CriticalPathEngine } from '@critical-path/core';
-import type { CriticalPathClient } from '@critical-path/client';
-import { ALL_TOOLS, parseToolArgs, type BackendContext } from '../tools/definitions.js';
-
-export interface CriticalPathMcpServerOptions {
-  engine?: CriticalPathEngine;
-  client?: CriticalPathClient;
-  name?: string;
-  version?: string;
-  tools?: string[];
-  /**
-   * Identity that changes made through an `engine` are attributed to (activity log, comment
-   * authors, ...). Defaults to `DEFAULT_MCP_ACTOR`. With a `client`, identity comes from the API's
-   * authentication (e.g. the `Authorization` header passed to the client) instead.
-   */
-  actor?: Actor;
-}
-
-export const DEFAULT_MCP_ACTOR: Actor = Object.freeze({ userId: 'mcp-agent', username: 'MCP Agent', actorType: 'agent' });
-
-export function createCriticalPathMcpServer(options: CriticalPathMcpServerOptions): Server {
-  const target: BackendContext | undefined = options.engine
-    ? options.engine.withActor(options.actor ?? DEFAULT_MCP_ACTOR)
-    : options.client;
-  if (!target) {
-    throw new Error('Either engine or client must be provided to createCriticalPathMcpServer.');
-  }
-
-  const serverName = options.name || 'critical-path-mcp';
-  const serverVersion = options.version || '0.1.0';
-
-  const activeTools = options.tools
-    ? ALL_TOOLS.filter((t) => options.tools!.includes(t.name))
-    : ALL_TOOLS;
-  const activeToolMap = new Map(activeTools.map((tool) => [tool.name, tool]));
-
-  const server = new Server(
-    {
-      name: serverName,
-      version: serverVersion
-    },
-    {
-      capabilities: {
-        tools: {},
-        resources: {},
-        prompts: {}
-      }
-    }
-  );
-
-  // 1. Tool Listing
-  server.setRequestHandler(ListToolsRequestSchema, async () => {
-    return {
-      tools: activeTools.map((tool) => ({
-        name: tool.name,
-        title: tool.title,
-        description: tool.description,
-        inputSchema: tool.inputSchema,
-        annotations: {
-          title: tool.title,
-          readOnlyHint: tool.annotations?.readOnlyHint ?? false,
-          destructiveHint: tool.annotations?.requiresConfirmation ?? false
-        }
-      }))
-    };
-  });
-
-  // 2. Tool Execution
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-    // Look up only the tools this server exposes, so a filtered-out tool cannot be called by name.
-    const tool = activeToolMap.get(name);
-
-    if (!tool) {
-      throw new McpError(ErrorCode.MethodNotFound, `Tool "${name}" is not registered on this MCP server.`);
-    }
-
-    try {
-      // Plugin init and seeding must finish before tools touch the engine.
-      if (options.engine) await options.engine.ready;
-      const result = await tool.execute(parseToolArgs(tool, args), target);
-      return {
-        content: [
-          {
-            type: 'text',
-            text: JSON.stringify(result, null, 2)
-          }
-        ]
-      };
-    } catch (err: any) {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `Error executing tool "${name}": ${err?.message || String(err)}`
-          }
-        ],
-        isError: true
-      };
-    }
-  });
-
-  // 3. Resources Listing
-  server.setRequestHandler(ListResourcesRequestSchema, async () => {
-    return {
-      resources: [
-        {
-          uri: 'criticalpath://projects',
-          name: 'Critical Path Projects',
-          mimeType: 'application/json',
-          description: 'Live list of all projects managed by Critical Path'
-        },
-        {
-          uri: 'criticalpath://tasks',
-          name: 'Critical Path Tasks',
-          mimeType: 'application/json',
-          description: 'Live list of all tasks across projects'
-        }
-      ]
-    };
-  });
-
-  // 4. Resource Reading
-  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-    const uri = request.params.uri;
-
-    if (uri === 'criticalpath://projects') {
-      const projects = await target.getProjects();
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: 'application/json',
-            text: JSON.stringify(projects, null, 2)
-          }
-        ]
-      };
-    }
-
-    if (uri === 'criticalpath://tasks') {
-      const tasks = await target.getTasks();
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: 'application/json',
-            text: JSON.stringify(tasks, null, 2)
-          }
-        ]
-      };
-    }
-
-    const taskMatch = uri.match(/^criticalpath:\/\/tasks\/([^/]+)$/);
-    if (taskMatch) {
-      const taskId = taskMatch[1];
-      const task = await target.getTask(taskId);
-      if (!task) {
-        throw new McpError(ErrorCode.InvalidRequest, `Task with ID "${taskId}" not found.`);
-      }
-      return {
-        contents: [
-          {
-            uri,
-            mimeType: 'application/json',
-            text: JSON.stringify(task, null, 2)
-          }
-        ]
-      };
-    }
-
-    throw new McpError(ErrorCode.InvalidRequest, `Unknown resource URI: ${uri}`);
-  });
-
-  // 5. Prompts Listing
-  server.setRequestHandler(ListPromptsRequestSchema, async () => {
-    return {
-      prompts: [
-        {
-          name: 'summarize_project',
-          description: 'Analyze project health, open tasks, blockers, and recent deliverables.',
-          arguments: [
-            {
-              name: 'projectId',
-              description: 'The ID of the project to summarize',
-              required: true
-            }
-          ]
-        },
-        {
-          name: 'triage_task',
-          description: 'Review a task description, suggest priority, labels, and workflow status.',
-          arguments: [
-            {
-              name: 'taskId',
-              description: 'The task ID to triage',
-              required: true
-            }
-          ]
-        }
-      ]
-    };
-  });
-
-  // 6. Prompts Retrieval
-  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-    const { name, arguments: args } = request.params;
-
-    if (name === 'summarize_project') {
-      const projectId = args?.projectId;
-      if (!projectId) {
-        throw new McpError(ErrorCode.InvalidParams, 'Argument "projectId" is required.');
-      }
-      const project = await target.getProject(projectId);
-      const tasks = await target.getTasks(projectId);
-
-      return {
-        description: `Project summary for ${project?.name || projectId}`,
-        messages: [
-          {
-            role: 'user',
-            content: {
-              type: 'text',
-              text: `Please analyze the current status of project "${project?.name || projectId}".\n\nProject Info:\n${JSON.stringify(project, null, 2)}\n\nTasks (${tasks.length} total):\n${JSON.stringify(tasks, null, 2)}\n\nProvide an executive summary highlighting:\n1. Overall progress and completion rate\n2. Any high/urgent priority tasks needing immediate attention\n3. Recommendations for unblocking or advancing the sprint.`
-            }
-          }
-        ]
-      };
-    }
-
-    if (name === 'triage_task') {
-      const taskId = args?.taskId;
-      if (!taskId) {
-        throw new McpError(ErrorCode.InvalidParams, 'Argument "taskId" is required.');
-      }
-      const task = await target.getTask(taskId);
-      if (!task) {
-        throw new McpError(ErrorCode.InvalidRequest, `Task "${taskId}" not found.`);
-      }
-
-      return {
-        description: `Triage task "${task.title}"`,
-        messages: [
-          {
-            role: 'user',
-            content: {
-              type: 'text',
-              text: `Please review and triage the following task:\n\n${JSON.stringify(task, null, 2)}\n\nSuggest:\n1. Appropriate priority level\n2. Relevant tags\n3. Estimated completion hours\n4. Clear acceptance criteria or missing details.`
-            }
-          }
-        ]
-      };
-    }
-
-    throw new McpError(ErrorCode.MethodNotFound, `Prompt "${name}" is not defined.`);
-  });
-
-  return server;
-}
-
-export async function startStdioServer(server: Server): Promise<void> {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}

package/src/tools/definitions.test.ts

@@ -1,29 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { ALL_TOOLS } from './definitions.js';
-
-describe('MCP tool definitions', () => {
-  // inputSchema is generated from zodSchema by defineTool; this guards the generation itself
-  // (e.g. a zod feature that zod-to-json-schema cannot express would drop fields here).
-  it.each(ALL_TOOLS.map((t) => [t.name, t] as const))('%s: zodSchema and inputSchema agree', (_name, tool) => {
-    const json = tool.inputSchema as { properties?: Record<string, unknown>; required?: string[] };
-    const shape = tool.zodSchema.shape as Record<string, { isOptional(): boolean }>;
-
-    expect(Object.keys(shape).sort()).toEqual(Object.keys(json.properties ?? {}).sort());
-    expect(
-      Object.entries(shape)
-        .filter(([, schema]) => !schema.isOptional())
-        .map(([key]) => key)
-        .sort()
-    ).toEqual([...(json.required ?? [])].sort());
-  });
-
-  it('generates closed object schemas with descriptions for every tool', () => {
-    for (const tool of ALL_TOOLS) {
-      expect(tool.inputSchema).toMatchObject({ type: 'object', additionalProperties: false });
-      expect(tool.inputSchema).not.toHaveProperty('$schema');
-    }
-    const updateTask = ALL_TOOLS.find((t) => t.name === 'update_task')!;
-    expect((updateTask.inputSchema as any).properties.isBlocked.description).toBe('Whether the task is blocked');
-  });
-});
-