@softeria/ms-365-mcp-server 0.131.1 → 0.131.3

package/dist/__tests__/graph-tools.test.js

@@ -93,6 +93,15 @@ function createMockServer() {
         tools.set(name, { description, schema, handler });
       }
     ),
+    registerTool: vi.fn(
+      (name, config, handler) => {
+        tools.set(name, {
+          description: config.description,
+          schema: config.inputSchema?.shape ?? config.inputSchema,
+          handler
+        });
+      }
+    ),
     tools
   };
 }

package/dist/endpoints.json

@@ -1100,14 +1100,16 @@
     "method": "post",
     "toolName": "create-todo-task",
     "presets": ["personal", "tasks"],
-    "scopes": ["Tasks.ReadWrite"]
+    "scopes": ["Tasks.ReadWrite"],
+    "llmTip": "Creates a new task in a Microsoft To Do list. Body: { title: \"...\" }; optional dueDateTime, reminderDateTime, importance, body (notes), recurrence, categories. Requires todoTaskListId from list-todo-task-lists."
   },
   {
     "pathPattern": "/me/todo/lists/{todoTaskList-id}/tasks/{todoTask-id}",
     "method": "patch",
     "toolName": "update-todo-task",
     "presets": ["personal", "tasks"],
-    "scopes": ["Tasks.ReadWrite"]
+    "scopes": ["Tasks.ReadWrite"],
+    "llmTip": "Updates a Microsoft To Do task. Use this to mark a to-do item complete or done (body: { status: \"completed\" }), reopen it (status: \"notStarted\"), rename it (title), or change its due date (dueDateTime), reminder (reminderDateTime), importance, or notes (body). Requires todoTaskListId from list-todo-task-lists and todoTaskId from list-todo-tasks."
   },
   {
     "pathPattern": "/me/todo/lists/{todoTaskList-id}/tasks/{todoTask-id}",

package/dist/graph-tools.js

@@ -395,6 +395,44 @@ function registerUtilityToolWithMcp(server, utility, ctx) {
     async (params) => utility.execute(params, ctx)
   );
 }
+function bodySchemaShape(schema) {
+  let current = schema;
+  for (let i = 0; i < 10 && current; i++) {
+    if (current instanceof z.ZodObject) {
+      return current.shape;
+    }
+    const def = current._def;
+    current = def?.innerType ?? def?.schema ?? def?.getter?.();
+  }
+  return null;
+}
+function lenientBodySchema(schema) {
+  if (schema instanceof z.ZodObject) {
+    return schema.passthrough();
+  }
+  if (schema instanceof z.ZodOptional) {
+    return lenientBodySchema(schema.unwrap()).optional();
+  }
+  if (schema instanceof z.ZodNullable) {
+    return lenientBodySchema(schema.unwrap()).nullable();
+  }
+  if (schema instanceof z.ZodLazy) {
+    return z.lazy(() => lenientBodySchema(schema.schema));
+  }
+  return schema;
+}
+const READ_ONLY_BODY_FIELDS = /* @__PURE__ */ new Set([
+  "id",
+  "createdDateTime",
+  "lastModifiedDateTime",
+  "changeKey"
+]);
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwn(obj, key) {
+  return Object.prototype.hasOwnProperty.call(obj, key);
+}
 async function executeGraphTool(tool, config, graphClient, params, authManager) {
   logger.info(`Tool ${tool.alias} called with params: ${JSON.stringify(params)}`);
   if (isConfirmGateEnabled() && isDestructiveOperation(tool.method, config) && params.confirm !== true) {
@@ -451,6 +489,10 @@ async function executeGraphTool(tool, config, graphClient, params, authManager)
     const queryParams = {};
     const headers = {};
     let body = null;
+    const bodyShape = bodySchemaShape(
+      parameterDefinitions.find((p) => p.type === "Body")?.schema
+    );
+    const strayBodyFields = {};
     for (const [paramName, paramValue] of Object.entries(params)) {
       if ([
         "account",
@@ -529,6 +571,29 @@ async function executeGraphTool(tool, config, graphClient, params, authManager)
       } else if (isOdataParam) {
         queryParams[fixedParamName] = `${paramValue}`;
         logger.info(`OData param fallback: forwarded ${fixedParamName}=${paramValue}`);
+      } else if (bodyShape && (hasOwn(bodyShape, paramName) || hasOwn(bodyShape, camelCaseParamName)) && !READ_ONLY_BODY_FIELDS.has(hasOwn(bodyShape, paramName) ? paramName : camelCaseParamName)) {
+        const fieldName = hasOwn(bodyShape, paramName) ? paramName : camelCaseParamName;
+        strayBodyFields[fieldName] = paramValue;
+        logger.info(
+          `Body field fallback: merging top-level param '${fieldName}' into request body`
+        );
+      } else {
+        logger.warn(`Dropping unrecognized parameter '${paramName}' for tool ${tool.alias}`);
+      }
+    }
+    if (Object.keys(strayBodyFields).length > 0) {
+      if (isPlainObject(body)) {
+        const keys = Object.keys(body);
+        const bodyIsNestedField = bodyShape != null && hasOwn(bodyShape, "body") && keys.length > 0 && keys.every((k) => !hasOwn(bodyShape, k));
+        body = bodyIsNestedField ? { ...strayBodyFields, body } : { ...strayBodyFields, ...body };
+        logger.info(`Merged flattened body fields: ${Object.keys(strayBodyFields).join(", ")}`);
+      } else if (body == null) {
+        body = strayBodyFields;
+        logger.info(`Merged flattened body fields: ${Object.keys(strayBodyFields).join(", ")}`);
+      } else {
+        logger.warn(
+          `Cannot merge flattened body fields (${Object.keys(strayBodyFields).join(", ")}) into non-object request body; dropping them`
+        );
       }
     }
     if (TOP_UNSUPPORTED_DELTA_TOOLS.has(tool.alias)) {
@@ -792,7 +857,7 @@ function registerGraphTools(server, graphClient, readOnly = false, enabledToolsP
     const paramSchema = {};
     if (tool.parameters && tool.parameters.length > 0) {
       for (const param of tool.parameters) {
-        paramSchema[param.name] = param.schema || z.any();
+        paramSchema[param.name] = param.type === "Body" && param.schema ? lenientBodySchema(param.schema) : param.schema || z.any();
       }
     }
     const pathParamMatches = tool.path.matchAll(/:([a-zA-Z]+)/g);
@@ -880,16 +945,19 @@ function registerGraphTools(server, graphClient, readOnly = false, enabledToolsP
     }
     const isReadOnlyTool = tool.method.toUpperCase() === "GET" || endpointConfig?.readOnly === true;
     try {
-      server.tool(
+      server.registerTool(
         tool.alias,
-        toolDescription,
-        paramSchema,
         {
           title: tool.alias,
-          readOnlyHint: isReadOnlyTool,
-          destructiveHint: destructive,
-          openWorldHint: true
-          // All tools call Microsoft Graph API
+          description: toolDescription,
+          inputSchema: z.object(paramSchema).passthrough(),
+          annotations: {
+            title: tool.alias,
+            readOnlyHint: isReadOnlyTool,
+            destructiveHint: destructive,
+            openWorldHint: true
+            // All tools call Microsoft Graph API
+          }
         },
         async (params) => executeGraphTool(tool, endpointConfig, graphClient, params, authManager)
       );

package/dist/normalize-tool-schema.js

@@ -0,0 +1,112 @@
+import { ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import logger from "./logger.js";
+function unescapePointer(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function isBadRef(value) {
+  return typeof value === "string" && value.startsWith("#/") && !value.startsWith("#/$defs/");
+}
+function collectBadRefTargets(node, targets) {
+  if (!node || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const item of node) collectBadRefTargets(item, targets);
+    return;
+  }
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "$ref" && isBadRef(value)) {
+      targets.add(value.slice(1));
+    } else {
+      collectBadRefTargets(value, targets);
+    }
+  }
+}
+function resolvePointer(root, pointer) {
+  const tokens = pointer.split("/").slice(1).map(unescapePointer);
+  if (tokens.length === 0) return null;
+  let parent = null;
+  let key = "";
+  let cur = root;
+  for (const token of tokens) {
+    if (!cur || typeof cur !== "object") return null;
+    parent = cur;
+    key = Array.isArray(cur) ? Number(token) : token;
+    cur = cur[key];
+    if (cur === void 0) return null;
+  }
+  return parent === null ? null : { parent, key, obj: cur };
+}
+function repointRefs(node, nameFor) {
+  if (!node || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const item of node) repointRefs(item, nameFor);
+    return;
+  }
+  const record = node;
+  for (const [key, value] of Object.entries(record)) {
+    if (key === "$ref" && isBadRef(value)) {
+      const name = nameFor.get(value.slice(1));
+      if (name) record.$ref = `#/$defs/${name}`;
+    } else {
+      repointRefs(value, nameFor);
+    }
+  }
+}
+function normalizeToolSchemaRefs(schema) {
+  const targets = /* @__PURE__ */ new Set();
+  collectBadRefTargets(schema, targets);
+  if (targets.size === 0) return schema;
+  const clone = structuredClone(schema);
+  const slots = /* @__PURE__ */ new Map();
+  for (const pointer of [...targets].sort()) {
+    const slot = resolvePointer(clone, pointer);
+    if (slot) slots.set(pointer, slot);
+  }
+  if (slots.size === 0) return schema;
+  const takenNames = new Set(
+    clone.$defs && typeof clone.$defs === "object" ? Object.keys(clone.$defs) : []
+  );
+  const nameFor = /* @__PURE__ */ new Map();
+  let index = 0;
+  for (const pointer of slots.keys()) {
+    let name = `def${index++}`;
+    while (takenNames.has(name)) name = `def${index++}`;
+    takenNames.add(name);
+    nameFor.set(pointer, name);
+  }
+  const defs = {};
+  for (const [pointer, slot] of slots) {
+    defs[nameFor.get(pointer)] = slot.obj;
+  }
+  for (const [pointer, slot] of slots) {
+    slot.parent[slot.key] = {
+      $ref: `#/$defs/${nameFor.get(pointer)}`
+    };
+  }
+  repointRefs(clone, nameFor);
+  for (const name of Object.keys(defs)) repointRefs(defs[name], nameFor);
+  const existingDefs = clone.$defs ?? {};
+  clone.$defs = { ...existingDefs, ...defs };
+  return clone;
+}
+function installToolSchemaRefNormalization(server) {
+  const lowLevel = server.server;
+  const handlers = lowLevel._requestHandlers;
+  const original = handlers?.get("tools/list");
+  if (!original) {
+    logger.warn("Skipping tool-schema $ref normalization: tools/list handler not found");
+    return;
+  }
+  lowLevel.setRequestHandler(ListToolsRequestSchema, async (request, extra) => {
+    const result = await original(request, extra);
+    for (const tool of result.tools ?? []) {
+      if (tool.inputSchema && typeof tool.inputSchema === "object") {
+        tool.inputSchema = normalizeToolSchemaRefs(tool.inputSchema);
+      }
+    }
+    return result;
+  });
+}
+export {
+  installToolSchemaRefNormalization,
+  normalizeToolSchemaRefs
+};

package/dist/server.js

@@ -9,6 +9,7 @@ import logger, { enableConsoleLogging } from "./logger.js";
 import { registerAuthTools } from "./auth-tools.js";
 import { registerGraphTools, registerDiscoveryTools } from "./graph-tools.js";
 import { buildMcpServerInstructions } from "./mcp-instructions.js";
+import { installToolSchemaRefNormalization } from "./normalize-tool-schema.js";
 import GraphClient from "./graph-client.js";
 import {
   buildScopesFromEndpoints,
@@ -102,6 +103,7 @@ class MicrosoftGraphServer {
         this.options.allowedScopes
       );
     }
+    installToolSchemaRefNormalization(server);
     return server;
   }
   async initialize(version) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softeria/ms-365-mcp-server",
-  "version": "0.131.1",
+  "version": "0.131.3",
   "description": " A Model Context Protocol (MCP) server for interacting with Microsoft 365 and Office services through the Graph API",
   "type": "module",
   "main": "dist/index.js",

package/src/endpoints.json

@@ -1100,14 +1100,16 @@
     "method": "post",
     "toolName": "create-todo-task",
     "presets": ["personal", "tasks"],
-    "scopes": ["Tasks.ReadWrite"]
+    "scopes": ["Tasks.ReadWrite"],
+    "llmTip": "Creates a new task in a Microsoft To Do list. Body: { title: \"...\" }; optional dueDateTime, reminderDateTime, importance, body (notes), recurrence, categories. Requires todoTaskListId from list-todo-task-lists."
   },
   {
     "pathPattern": "/me/todo/lists/{todoTaskList-id}/tasks/{todoTask-id}",
     "method": "patch",
     "toolName": "update-todo-task",
     "presets": ["personal", "tasks"],
-    "scopes": ["Tasks.ReadWrite"]
+    "scopes": ["Tasks.ReadWrite"],
+    "llmTip": "Updates a Microsoft To Do task. Use this to mark a to-do item complete or done (body: { status: \"completed\" }), reopen it (status: \"notStarted\"), rename it (title), or change its due date (dueDateTime), reminder (reminderDateTime), importance, or notes (body). Requires todoTaskListId from list-todo-task-lists and todoTaskId from list-todo-tasks."
   },
   {
     "pathPattern": "/me/todo/lists/{todoTaskList-id}/tasks/{todoTask-id}",