@mcp-z/mcp-outlook 1.0.0

package/dist/cjs/mcp/tools/message-move-to-trash.d.cts

@@ -0,0 +1,54 @@
+import type { EnrichedExtra } from '@mcp-z/oauth-microsoft';
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const inputSchema: z.ZodObject<{
+    ids: z.ZodArray<z.ZodCoercedString<unknown>>;
+}, z.core.$strip>;
+declare const outputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    totalRequested: z.ZodNumber;
+    successCount: z.ZodNumber;
+    failureCount: z.ZodNumber;
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        success: z.ZodBoolean;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"success">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"auth_required">;
+    provider: z.ZodString;
+    message: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+export type Input = z.infer<typeof inputSchema>;
+export type Output = z.infer<typeof outputSchema>;
+declare function handler({ ids }: Input, extra: EnrichedExtra): Promise<CallToolResult>;
+export default function createTool(): {
+    name: string;
+    config: {
+        readonly description: "Move Outlook messages to trash (recoverable).";
+        readonly inputSchema: z.ZodObject<{
+            ids: z.ZodArray<z.ZodCoercedString<unknown>>;
+        }, z.core.$strip>;
+        readonly outputSchema: z.ZodObject<{
+            result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                totalRequested: z.ZodNumber;
+                successCount: z.ZodNumber;
+                failureCount: z.ZodNumber;
+                results: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    success: z.ZodBoolean;
+                    error: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                type: z.ZodLiteral<"success">;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"auth_required">;
+                provider: z.ZodString;
+                message: z.ZodString;
+                url: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>], "type">;
+        }, z.core.$strip>;
+    };
+    handler: typeof handler;
+};
+export {};

package/dist/cjs/mcp/tools/message-move-to-trash.d.ts

@@ -0,0 +1,54 @@
+import type { EnrichedExtra } from '@mcp-z/oauth-microsoft';
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const inputSchema: z.ZodObject<{
+    ids: z.ZodArray<z.ZodCoercedString<unknown>>;
+}, z.core.$strip>;
+declare const outputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    totalRequested: z.ZodNumber;
+    successCount: z.ZodNumber;
+    failureCount: z.ZodNumber;
+    results: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        success: z.ZodBoolean;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    type: z.ZodLiteral<"success">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"auth_required">;
+    provider: z.ZodString;
+    message: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+export type Input = z.infer<typeof inputSchema>;
+export type Output = z.infer<typeof outputSchema>;
+declare function handler({ ids }: Input, extra: EnrichedExtra): Promise<CallToolResult>;
+export default function createTool(): {
+    name: string;
+    config: {
+        readonly description: "Move Outlook messages to trash (recoverable).";
+        readonly inputSchema: z.ZodObject<{
+            ids: z.ZodArray<z.ZodCoercedString<unknown>>;
+        }, z.core.$strip>;
+        readonly outputSchema: z.ZodObject<{
+            result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                totalRequested: z.ZodNumber;
+                successCount: z.ZodNumber;
+                failureCount: z.ZodNumber;
+                results: z.ZodArray<z.ZodObject<{
+                    id: z.ZodString;
+                    success: z.ZodBoolean;
+                    error: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                type: z.ZodLiteral<"success">;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"auth_required">;
+                provider: z.ZodString;
+                message: z.ZodString;
+                url: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>], "type">;
+        }, z.core.$strip>;
+    };
+    handler: typeof handler;
+};
+export {};

package/dist/cjs/mcp/tools/message-move-to-trash.js

@@ -0,0 +1,460 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return createTool;
+    }
+});
+var _oauthmicrosoft = require("@mcp-z/oauth-microsoft");
+var _microsoftgraphclient = require("@microsoft/microsoft-graph-client");
+var _types = require("@modelcontextprotocol/sdk/types.js");
+var _zod = require("zod");
+var _constantsts = require("../../constants.js");
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+function _ts_values(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function() {
+            if (o && i >= o.length) o = void 0;
+            return {
+                value: o && o[i++],
+                done: !o
+            };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+var AuthRequiredBranchSchema = _oauthmicrosoft.schemas.AuthRequiredBranchSchema;
+var BatchResultSchema = _zod.z.object({
+    totalRequested: _zod.z.number().describe('Total number of messages requested to trash'),
+    successCount: _zod.z.number().describe('Number of messages successfully moved to trash'),
+    failureCount: _zod.z.number().describe('Number of messages that failed to move'),
+    results: _zod.z.array(_zod.z.object({
+        id: _zod.z.string().describe('Message ID'),
+        success: _zod.z.boolean().describe('Whether the operation succeeded'),
+        error: _zod.z.string().optional().describe('Error message if operation failed')
+    })).describe('Individual results for each message')
+});
+var inputSchema = _zod.z.object({
+    ids: _zod.z.array(_zod.z.coerce.string().trim().min(1)).min(1).describe('Outlook message IDs to move to trash')
+});
+// Success branch schema
+var successBranchSchema = BatchResultSchema.extend({
+    type: _zod.z.literal('success')
+});
+// Output schema with auth_required support
+var outputSchema = _zod.z.discriminatedUnion('type', [
+    successBranchSchema,
+    AuthRequiredBranchSchema
+]);
+var config = {
+    description: 'Move Outlook messages to trash (recoverable).',
+    inputSchema: inputSchema,
+    outputSchema: _zod.z.object({
+        result: outputSchema
+    })
+};
+function handler(_0, _1) {
+    return _async_to_generator(function(param, extra) {
+        var ids, logger, validatedIds, invalidIds, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, id, trimmedId, _loop, graph, allResults, i, successCount, failureCount, result, error, message;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    ids = param.ids;
+                    logger = extra.logger;
+                    logger.info('outlook-message-move-to-trash called', {
+                        count: ids.length
+                    });
+                    if (!ids || ids.length === 0) {
+                        logger.info('outlook-message-move-to-trash missing ids');
+                        throw new _types.McpError(_types.ErrorCode.InvalidParams, 'Missing ids');
+                    }
+                    // Validate batch size to prevent memory exhaustion
+                    if (ids.length > _constantsts.MAX_BATCH_SIZE) {
+                        logger.info('outlook-message-move-to-trash batch size exceeded', {
+                            requested: ids.length,
+                            max: _constantsts.MAX_BATCH_SIZE
+                        });
+                        throw new _types.McpError(_types.ErrorCode.InvalidParams, "Batch size ".concat(ids.length, " exceeds maximum allowed size of ").concat(_constantsts.MAX_BATCH_SIZE));
+                    }
+                    // Validate and sanitize IDs
+                    validatedIds = [];
+                    invalidIds = [];
+                    _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                    try {
+                        for(_iterator = ids[Symbol.iterator](); !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                            id = _step.value;
+                            trimmedId = id.trim();
+                            if (!trimmedId) {
+                                invalidIds.push(id);
+                                continue;
+                            }
+                            // Basic Outlook message ID validation - should not contain certain characters
+                            if (trimmedId.includes('/') || trimmedId.includes('\\') || trimmedId.includes('<') || trimmedId.includes('>')) {
+                                invalidIds.push(id);
+                                continue;
+                            }
+                            validatedIds.push(trimmedId);
+                        }
+                    } catch (err) {
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                    }
+                    if (invalidIds.length > 0) {
+                        logger.info('outlook-message-move-to-trash found invalid ids', {
+                            invalidIds: invalidIds,
+                            count: invalidIds.length
+                        });
+                        throw new _types.McpError(_types.ErrorCode.InvalidParams, "Found ".concat(invalidIds.length, " invalid IDs: ").concat(invalidIds.join(', ')));
+                    }
+                    if (validatedIds.length === 0) {
+                        logger.info('outlook-message-move-to-trash no valid ids after validation');
+                        throw new _types.McpError(_types.ErrorCode.InvalidParams, 'No valid IDs found after validation');
+                    }
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        6,
+                        ,
+                        7
+                    ]);
+                    _loop = function(i) {
+                        var _allResults, chunk, chunkResults, processedChunkResults;
+                        return _ts_generator(this, function(_state) {
+                            switch(_state.label){
+                                case 0:
+                                    chunk = validatedIds.slice(i, i + _constantsts.CHUNK_SIZE);
+                                    logger.info('Processing chunk', {
+                                        chunkIndex: i / _constantsts.CHUNK_SIZE + 1,
+                                        chunkSize: chunk.length,
+                                        totalChunks: Math.ceil(validatedIds.length / _constantsts.CHUNK_SIZE)
+                                    });
+                                    return [
+                                        4,
+                                        Promise.allSettled(chunk.map(function(id) {
+                                            return _async_to_generator(function() {
+                                                return _ts_generator(this, function(_state) {
+                                                    switch(_state.label){
+                                                        case 0:
+                                                            return [
+                                                                4,
+                                                                graph.api("/me/messages/".concat(encodeURIComponent(id))).delete()
+                                                            ];
+                                                        case 1:
+                                                            _state.sent();
+                                                            return [
+                                                                2,
+                                                                {
+                                                                    id: id,
+                                                                    success: true
+                                                                }
+                                                            ];
+                                                    }
+                                                });
+                                            })();
+                                        }))
+                                    ];
+                                case 1:
+                                    chunkResults = _state.sent();
+                                    // Process chunk results
+                                    processedChunkResults = chunkResults.map(function(result, chunkIndex) {
+                                        var id = chunk[chunkIndex];
+                                        if (!id) {
+                                            throw new Error("Chunk index ".concat(chunkIndex, " is out of bounds for chunk of size ").concat(chunk.length));
+                                        }
+                                        if (result.status === 'fulfilled') {
+                                            return {
+                                                id: id,
+                                                success: true
+                                            };
+                                        }
+                                        // Extract error message more robustly
+                                        var errorMessage = 'Unknown error';
+                                        if (result.reason) {
+                                            if (typeof result.reason === 'string') {
+                                                errorMessage = result.reason;
+                                            } else if (_instanceof(result.reason, Error)) {
+                                                errorMessage = result.reason.message;
+                                            } else if (result.reason && _type_of(result.reason) === 'object' && 'message' in result.reason) {
+                                                errorMessage = String(result.reason.message);
+                                            } else if (result.reason && _type_of(result.reason) === 'object' && 'error' in result.reason) {
+                                                errorMessage = String(result.reason.error);
+                                            } else {
+                                                errorMessage = String(result.reason);
+                                            }
+                                        }
+                                        return {
+                                            id: id,
+                                            success: false,
+                                            error: errorMessage
+                                        };
+                                    });
+                                    (_allResults = allResults).push.apply(_allResults, _to_consumable_array(processedChunkResults));
+                                    return [
+                                        2
+                                    ];
+                            }
+                        });
+                    };
+                    graph = _microsoftgraphclient.Client.initWithMiddleware({
+                        authProvider: extra.authContext.auth
+                    });
+                    // Process operations in chunks to prevent memory exhaustion
+                    allResults = [];
+                    i = 0;
+                    _state.label = 2;
+                case 2:
+                    if (!(i < validatedIds.length)) return [
+                        3,
+                        5
+                    ];
+                    return [
+                        5,
+                        _ts_values(_loop(i))
+                    ];
+                case 3:
+                    _state.sent();
+                    _state.label = 4;
+                case 4:
+                    i += _constantsts.CHUNK_SIZE;
+                    return [
+                        3,
+                        2
+                    ];
+                case 5:
+                    successCount = allResults.filter(function(r) {
+                        return r.success;
+                    }).length;
+                    failureCount = allResults.filter(function(r) {
+                        return !r.success;
+                    }).length;
+                    result = {
+                        type: 'success',
+                        totalRequested: validatedIds.length,
+                        successCount: successCount,
+                        failureCount: failureCount,
+                        results: allResults
+                    };
+                    logger.info('outlook-message-move-to-trash completed', {
+                        totalRequested: validatedIds.length,
+                        successCount: successCount,
+                        failureCount: failureCount,
+                        chunksProcessed: Math.ceil(validatedIds.length / _constantsts.CHUNK_SIZE)
+                    });
+                    return [
+                        2,
+                        {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify(result)
+                                }
+                            ],
+                            structuredContent: {
+                                result: result
+                            }
+                        }
+                    ];
+                case 6:
+                    error = _state.sent();
+                    message = _instanceof(error, Error) ? error.message : String(error);
+                    logger.error('outlook-message-move-to-trash error', {
+                        error: message
+                    });
+                    throw new _types.McpError(_types.ErrorCode.InternalError, "Error moving messages to trash: ".concat(message), {
+                        stack: _instanceof(error, Error) ? error.stack : undefined
+                    });
+                case 7:
+                    return [
+                        2
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+function createTool() {
+    return {
+        name: 'message-move-to-trash',
+        config: config,
+        handler: handler
+    };
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/mcp/tools/message-move-to-trash.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/Projects/ai/mcp-z/servers/mcp-outlook/src/mcp/tools/message-move-to-trash.ts"],"sourcesContent":["import type { EnrichedExtra } from '@mcp-z/oauth-microsoft';\nimport { schemas } from '@mcp-z/oauth-microsoft';\n\nconst { AuthRequiredBranchSchema } = schemas;\n\nimport type { ToolModule } from '@mcp-z/server';\nimport { Client } from '@microsoft/microsoft-graph-client';\nimport { type CallToolResult, ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';\nimport { z } from 'zod';\nimport { CHUNK_SIZE, MAX_BATCH_SIZE } from '../../constants.ts';\n\nconst BatchResultSchema = z.object({\n  totalRequested: z.number().describe('Total number of messages requested to trash'),\n  successCount: z.number().describe('Number of messages successfully moved to trash'),\n  failureCount: z.number().describe('Number of messages that failed to move'),\n  results: z\n    .array(\n      z.object({\n        id: z.string().describe('Message ID'),\n        success: z.boolean().describe('Whether the operation succeeded'),\n        error: z.string().optional().describe('Error message if operation failed'),\n      })\n    )\n    .describe('Individual results for each message'),\n});\n\nconst inputSchema = z.object({\n  ids: z.array(z.coerce.string().trim().min(1)).min(1).describe('Outlook message IDs to move to trash'),\n});\n\n// Success branch schema\nconst successBranchSchema = BatchResultSchema.extend({\n  type: z.literal('success'),\n});\n\n// Output schema with auth_required support\nconst outputSchema = z.discriminatedUnion('type', [successBranchSchema, AuthRequiredBranchSchema]);\n\nconst config = {\n  description: 'Move Outlook messages to trash (recoverable).',\n  inputSchema: inputSchema,\n  outputSchema: z.object({\n    result: outputSchema,\n  }),\n} as const;\n\nexport type Input = z.infer<typeof inputSchema>;\nexport type Output = z.infer<typeof outputSchema>;\n\nasync function handler({ ids }: Input, extra: EnrichedExtra): Promise<CallToolResult> {\n  const logger = extra.logger;\n  logger.info('outlook-message-move-to-trash called', { count: ids.length });\n\n  if (!ids || ids.length === 0) {\n    logger.info('outlook-message-move-to-trash missing ids');\n    throw new McpError(ErrorCode.InvalidParams, 'Missing ids');\n  }\n\n  // Validate batch size to prevent memory exhaustion\n  if (ids.length > MAX_BATCH_SIZE) {\n    logger.info('outlook-message-move-to-trash batch size exceeded', { requested: ids.length, max: MAX_BATCH_SIZE });\n    throw new McpError(ErrorCode.InvalidParams, `Batch size ${ids.length} exceeds maximum allowed size of ${MAX_BATCH_SIZE}`);\n  }\n\n  // Validate and sanitize IDs\n  const validatedIds: string[] = [];\n  const invalidIds: string[] = [];\n\n  for (const id of ids) {\n    const trimmedId = id.trim();\n    if (!trimmedId) {\n      invalidIds.push(id);\n      continue;\n    }\n    // Basic Outlook message ID validation - should not contain certain characters\n    if (trimmedId.includes('/') || trimmedId.includes('\\\\') || trimmedId.includes('<') || trimmedId.includes('>')) {\n      invalidIds.push(id);\n      continue;\n    }\n    validatedIds.push(trimmedId);\n  }\n\n  if (invalidIds.length > 0) {\n    logger.info('outlook-message-move-to-trash found invalid ids', { invalidIds, count: invalidIds.length });\n    throw new McpError(ErrorCode.InvalidParams, `Found ${invalidIds.length} invalid IDs: ${invalidIds.join(', ')}`);\n  }\n\n  if (validatedIds.length === 0) {\n    logger.info('outlook-message-move-to-trash no valid ids after validation');\n    throw new McpError(ErrorCode.InvalidParams, 'No valid IDs found after validation');\n  }\n\n  try {\n    const graph = Client.initWithMiddleware({ authProvider: extra.authContext.auth });\n    // Process operations in chunks to prevent memory exhaustion\n    const allResults: Array<{ id: string; success: boolean; error?: string }> = [];\n\n    for (let i = 0; i < validatedIds.length; i += CHUNK_SIZE) {\n      const chunk = validatedIds.slice(i, i + CHUNK_SIZE);\n      logger.info('Processing chunk', { chunkIndex: i / CHUNK_SIZE + 1, chunkSize: chunk.length, totalChunks: Math.ceil(validatedIds.length / CHUNK_SIZE) });\n\n      const chunkResults = await Promise.allSettled(\n        chunk.map(async (id) => {\n          await graph.api(`/me/messages/${encodeURIComponent(id)}`).delete();\n          return { id, success: true };\n        })\n      );\n\n      // Process chunk results\n      const processedChunkResults = chunkResults.map((result, chunkIndex) => {\n        const id = chunk[chunkIndex];\n        if (!id) {\n          throw new Error(`Chunk index ${chunkIndex} is out of bounds for chunk of size ${chunk.length}`);\n        }\n        if (result.status === 'fulfilled') {\n          return { id, success: true };\n        }\n\n        // Extract error message more robustly\n        let errorMessage = 'Unknown error';\n        if (result.reason) {\n          if (typeof result.reason === 'string') {\n            errorMessage = result.reason;\n          } else if (result.reason instanceof Error) {\n            errorMessage = result.reason.message;\n          } else if (result.reason && typeof result.reason === 'object' && 'message' in result.reason) {\n            errorMessage = String(result.reason.message);\n          } else if (result.reason && typeof result.reason === 'object' && 'error' in result.reason) {\n            errorMessage = String(result.reason.error);\n          } else {\n            errorMessage = String(result.reason);\n          }\n        }\n\n        return { id, success: false, error: errorMessage };\n      });\n\n      allResults.push(...processedChunkResults);\n    }\n\n    const successCount = allResults.filter((r) => r.success).length;\n    const failureCount = allResults.filter((r) => !r.success).length;\n\n    const result: Output = {\n      type: 'success' as const,\n      totalRequested: validatedIds.length,\n      successCount,\n      failureCount,\n      results: allResults,\n    };\n\n    logger.info('outlook-message-move-to-trash completed', {\n      totalRequested: validatedIds.length,\n      successCount,\n      failureCount,\n      chunksProcessed: Math.ceil(validatedIds.length / CHUNK_SIZE),\n    });\n\n    return {\n      content: [\n        {\n          type: 'text' as const,\n          text: JSON.stringify(result),\n        },\n      ],\n      structuredContent: { result },\n    };\n  } catch (error) {\n    const message = error instanceof Error ? error.message : String(error);\n    logger.error('outlook-message-move-to-trash error', { error: message });\n\n    throw new McpError(ErrorCode.InternalError, `Error moving messages to trash: ${message}`, {\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n  }\n}\n\nexport default function createTool() {\n  return {\n    name: 'message-move-to-trash',\n    config,\n    handler,\n  } satisfies ToolModule;\n}\n"],"names":["createTool","AuthRequiredBranchSchema","schemas","BatchResultSchema","z","object","totalRequested","number","describe","successCount","failureCount","results","array","id","string","success","boolean","error","optional","inputSchema","ids","coerce","trim","min","successBranchSchema","extend","type","literal","outputSchema","discriminatedUnion","config","description","result","handler","extra","logger","validatedIds","invalidIds","trimmedId","graph","allResults","i","message","info","count","length","McpError","ErrorCode","InvalidParams","MAX_BATCH_SIZE","requested","max","push","includes","join","chunk","chunkResults","processedChunkResults","slice","CHUNK_SIZE","chunkIndex","chunkSize","totalChunks","Math","ceil","Promise","allSettled","map","api","encodeURIComponent","delete","Error","status","errorMessage","reason","String","Client","initWithMiddleware","authProvider","authContext","auth","filter","r","chunksProcessed","content","text","JSON","stringify","structuredContent","InternalError","stack","undefined","name"],"mappings":"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"}

package/dist/cjs/mcp/tools/message-respond.d.cts

@@ -0,0 +1,52 @@
+import type { EnrichedExtra } from '@mcp-z/oauth-microsoft';
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+declare const inputSchema: z.ZodObject<{
+    id: z.ZodCoercedString<unknown>;
+    body: z.ZodCoercedString<unknown>;
+    contentType: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        text: "text";
+        html: "html";
+    }>>>;
+}, z.core.$strip>;
+declare const outputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    success: z.ZodBoolean;
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodLiteral<"success">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"auth_required">;
+    provider: z.ZodString;
+    message: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+export type Input = z.infer<typeof inputSchema>;
+export type Output = z.infer<typeof outputSchema>;
+declare function handler({ id, body, contentType }: Input, extra: EnrichedExtra): Promise<CallToolResult>;
+export default function createTool(): {
+    name: string;
+    config: {
+        readonly description: "Reply to an Outlook message";
+        readonly inputSchema: z.ZodObject<{
+            id: z.ZodCoercedString<unknown>;
+            body: z.ZodCoercedString<unknown>;
+            contentType: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                text: "text";
+                html: "html";
+            }>>>;
+        }, z.core.$strip>;
+        readonly outputSchema: z.ZodObject<{
+            result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                success: z.ZodBoolean;
+                id: z.ZodOptional<z.ZodString>;
+                type: z.ZodLiteral<"success">;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"auth_required">;
+                provider: z.ZodString;
+                message: z.ZodString;
+                url: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>], "type">;
+        }, z.core.$strip>;
+    };
+    handler: typeof handler;
+};
+export {};