@mcp-z/mcp-gmail 1.0.0

package/dist/cjs/mcp/tools/message-respond.js

@@ -0,0 +1,367 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return createTool;
+    }
+});
+var _email = require("@mcp-z/email");
+var _oauthgoogle = require("@mcp-z/oauth-google");
+var _types = require("@modelcontextprotocol/sdk/types.js");
+var _googleapis = require("googleapis");
+var _zod = require("zod");
+var _headersutils = require("../../email/parsing/headers-utils.js");
+var _base64encoding = require("../../lib/base64-encoding.js");
+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 _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+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
+        };
+    }
+}
+var AuthRequiredBranchSchema = _oauthgoogle.schemas.AuthRequiredBranchSchema;
+var inputSchema = _zod.z.object({
+    id: _zod.z.coerce.string().trim().min(1).describe('Gmail message ID to reply to'),
+    body: _zod.z.coerce.string().trim().min(1).describe('Reply body content (plain text or HTML)'),
+    contentType: _email.ComposeContentTypeSchema
+});
+var successBranchSchema = _zod.z.object({
+    type: _zod.z.literal('success'),
+    id: _zod.z.string().describe('Original message ID that was replied to')
+});
+var outputSchema = _zod.z.discriminatedUnion('type', [
+    successBranchSchema,
+    AuthRequiredBranchSchema
+]);
+var config = {
+    description: 'Send a reply to a Gmail message',
+    inputSchema: inputSchema,
+    outputSchema: _zod.z.object({
+        result: outputSchema
+    })
+};
+function handler(_0, _1) {
+    return _async_to_generator(function(param, extra) {
+        var id, body, contentType, logger, _ref, _ref1, _ref2, _fullData_payload, gmail, full, response, error, message, fullData, headersArray, headers, fromHdr, replyToHdr, toAddr, subject, messageIdHeader, references, replySubject, inReplyTo, refs, mimeType, lines, raw, threadId, result, error1, message1;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    id = param.id, body = param.body, contentType = param.contentType;
+                    logger = extra.logger;
+                    if (!id || !body) {
+                        throw new _types.McpError(_types.ErrorCode.InvalidParams, 'Missing id or body');
+                    }
+                    logger.info('gmail.message.respond called', {
+                        id: id,
+                        contentType: contentType
+                    });
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        7,
+                        ,
+                        8
+                    ]);
+                    gmail = _googleapis.google.gmail({
+                        version: 'v1',
+                        auth: extra.authContext.auth
+                    });
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        4,
+                        ,
+                        5
+                    ]);
+                    return [
+                        4,
+                        gmail.users.messages.get({
+                            userId: 'me',
+                            id: id,
+                            format: 'metadata',
+                            metadataHeaders: [
+                                'From',
+                                'To',
+                                'Reply-To',
+                                'Subject',
+                                'Message-ID',
+                                'References',
+                                'In-Reply-To',
+                                'Date'
+                            ]
+                        })
+                    ];
+                case 3:
+                    response = _state.sent();
+                    full = response.data;
+                    return [
+                        3,
+                        5
+                    ];
+                case 4:
+                    error = _state.sent();
+                    message = _instanceof(error, Error) ? error.message : String(error);
+                    logger.error('gmail.message.respond fetch error', {
+                        error: message
+                    });
+                    throw new _types.McpError(_types.ErrorCode.InternalError, "Error fetching message metadata: ".concat(message), {
+                        stack: _instanceof(error, Error) ? error.stack : undefined
+                    });
+                case 5:
+                    // Type-safe header extraction
+                    fullData = full;
+                    headersArray = Array.isArray(fullData === null || fullData === void 0 ? void 0 : (_fullData_payload = fullData.payload) === null || _fullData_payload === void 0 ? void 0 : _fullData_payload.headers) ? fullData.payload.headers : [];
+                    headers = Object.fromEntries(headersArray.map(function(h) {
+                        var _header_name, _header_value;
+                        var header = h;
+                        return [
+                            String((_header_name = header.name) !== null && _header_name !== void 0 ? _header_name : ''),
+                            String((_header_value = header.value) !== null && _header_value !== void 0 ? _header_value : '')
+                        ];
+                    }));
+                    fromHdr = headers.From || headers.from;
+                    replyToHdr = headers['Reply-To'] || headers['reply-to'];
+                    toAddr = (_ref = replyToHdr ? (0, _headersutils.extractEmails)(replyToHdr)[0] : (0, _headersutils.extractEmails)(fromHdr)[0]) !== null && _ref !== void 0 ? _ref : '';
+                    subject = (_ref1 = headers.Subject || headers.subject) !== null && _ref1 !== void 0 ? _ref1 : '';
+                    messageIdHeader = headers['Message-ID'] || headers['Message-Id'] || headers['message-id'];
+                    references = (_ref2 = headers.References || headers.references) !== null && _ref2 !== void 0 ? _ref2 : '';
+                    replySubject = /^re:/i.test(subject) ? subject : "Re: ".concat(subject);
+                    inReplyTo = (messageIdHeader === null || messageIdHeader === void 0 ? void 0 : messageIdHeader.startsWith('<')) ? messageIdHeader : messageIdHeader ? "<".concat(messageIdHeader, ">") : undefined;
+                    refs = [
+                        references,
+                        inReplyTo
+                    ].filter(Boolean).join(' ').trim();
+                    mimeType = contentType === 'html' ? 'text/html' : 'text/plain';
+                    lines = [
+                        "To: ".concat(toAddr),
+                        "Subject: ".concat(replySubject),
+                        "In-Reply-To: ".concat(inReplyTo !== null && inReplyTo !== void 0 ? inReplyTo : ''),
+                        "References: ".concat(refs),
+                        'MIME-Version: 1.0',
+                        "Content-Type: ".concat(mimeType, "; charset=UTF-8"),
+                        '',
+                        body
+                    ].join('\r\n');
+                    raw = (0, _base64encoding.b64url)(lines);
+                    // Prepare request body with conditional threadId for exactOptionalPropertyTypes
+                    threadId = (fullData === null || fullData === void 0 ? void 0 : fullData.threadId) ? String(fullData.threadId) : undefined;
+                    return [
+                        4,
+                        gmail.users.messages.send({
+                            userId: 'me',
+                            requestBody: _object_spread({
+                                raw: raw
+                            }, threadId && {
+                                threadId: threadId
+                            })
+                        })
+                    ];
+                case 6:
+                    _state.sent();
+                    logger.info('gmail.message.respond sent reply', {
+                        id: id
+                    });
+                    result = {
+                        type: 'success',
+                        id: id
+                    };
+                    return [
+                        2,
+                        {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify(result)
+                                }
+                            ],
+                            structuredContent: {
+                                result: result
+                            }
+                        }
+                    ];
+                case 7:
+                    error1 = _state.sent();
+                    message1 = _instanceof(error1, Error) ? error1.message : String(error1);
+                    logger.error('gmail.message.respond error', {
+                        error: message1
+                    });
+                    throw new _types.McpError(_types.ErrorCode.InternalError, "Error responding to message: ".concat(message1), {
+                        stack: _instanceof(error1, Error) ? error1.stack : undefined
+                    });
+                case 8:
+                    return [
+                        2
+                    ];
+            }
+        });
+    }).apply(this, arguments);
+}
+function createTool() {
+    return {
+        name: 'message-respond',
+        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-respond.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/Projects/ai/mcp-z/servers/mcp-gmail/src/mcp/tools/message-respond.ts"],"sourcesContent":["import { ComposeContentTypeSchema } from '@mcp-z/email';\nimport type { EnrichedExtra } from '@mcp-z/oauth-google';\nimport { schemas } from '@mcp-z/oauth-google';\n\nconst { AuthRequiredBranchSchema } = schemas;\n\nimport type { ToolModule } from '@mcp-z/server';\nimport { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';\nimport { google } from 'googleapis';\nimport { z } from 'zod';\nimport { extractEmails } from '../../email/parsing/headers-utils.js';\nimport { b64url } from '../../lib/base64-encoding.js';\n\nconst inputSchema = z.object({\n  id: z.coerce.string().trim().min(1).describe('Gmail message ID to reply to'),\n  body: z.coerce.string().trim().min(1).describe('Reply body content (plain text or HTML)'),\n  contentType: ComposeContentTypeSchema,\n});\n\nconst successBranchSchema = z.object({\n  type: z.literal('success'),\n  id: z.string().describe('Original message ID that was replied to'),\n});\n\nconst outputSchema = z.discriminatedUnion('type', [successBranchSchema, AuthRequiredBranchSchema]);\n\nconst config = {\n  description: 'Send a reply to a Gmail message',\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({ id, body, contentType }: Input, extra: EnrichedExtra) {\n  const logger = extra.logger;\n\n  if (!id || !body) {\n    throw new McpError(ErrorCode.InvalidParams, 'Missing id or body');\n  }\n\n  logger.info('gmail.message.respond called', { id, contentType });\n\n  try {\n    const gmail = google.gmail({ version: 'v1', auth: extra.authContext.auth });\n\n    let full: unknown;\n    try {\n      const response = await gmail.users.messages.get({\n        userId: 'me',\n        id: id,\n        format: 'metadata',\n        metadataHeaders: ['From', 'To', 'Reply-To', 'Subject', 'Message-ID', 'References', 'In-Reply-To', 'Date'],\n      });\n      full = response.data;\n    } catch (error) {\n      const message = error instanceof Error ? error.message : String(error);\n      logger.error('gmail.message.respond fetch error', { error: message });\n\n      throw new McpError(ErrorCode.InternalError, `Error fetching message metadata: ${message}`, {\n        stack: error instanceof Error ? error.stack : undefined,\n      });\n    }\n\n    // Type-safe header extraction\n    const fullData = full as { payload?: { headers?: unknown[] }; threadId?: unknown };\n    const headersArray = Array.isArray(fullData?.payload?.headers) ? fullData.payload.headers : [];\n    const headers = Object.fromEntries(\n      headersArray.map((h: unknown) => {\n        const header = h as { name?: unknown; value?: unknown };\n        return [String(header.name ?? ''), String(header.value ?? '')];\n      })\n    );\n    const fromHdr = headers.From || headers.from;\n    const replyToHdr = headers['Reply-To'] || headers['reply-to'];\n    const toAddr = (replyToHdr ? extractEmails(replyToHdr)[0] : extractEmails(fromHdr)[0]) ?? '';\n    const subject = (headers.Subject || headers.subject) ?? '';\n    const messageIdHeader = headers['Message-ID'] || headers['Message-Id'] || headers['message-id'];\n    const references = (headers.References || headers.references) ?? '';\n    const replySubject = /^re:/i.test(subject) ? subject : `Re: ${subject}`;\n    const inReplyTo = messageIdHeader?.startsWith('<') ? messageIdHeader : messageIdHeader ? `<${messageIdHeader}>` : undefined;\n    const refs = [references, inReplyTo].filter(Boolean).join(' ').trim();\n    const mimeType = contentType === 'html' ? 'text/html' : 'text/plain';\n    const lines = [`To: ${toAddr}`, `Subject: ${replySubject}`, `In-Reply-To: ${inReplyTo ?? ''}`, `References: ${refs}`, 'MIME-Version: 1.0', `Content-Type: ${mimeType}; charset=UTF-8`, '', body].join('\\r\\n');\n    const raw = b64url(lines);\n\n    // Prepare request body with conditional threadId for exactOptionalPropertyTypes\n    const threadId = fullData?.threadId ? String(fullData.threadId) : undefined;\n    await gmail.users.messages.send({\n      userId: 'me',\n      requestBody: {\n        raw: raw,\n        ...(threadId && { threadId }),\n      },\n    });\n\n    logger.info('gmail.message.respond sent reply', { id });\n\n    const result: Output = {\n      type: 'success' as const,\n      id,\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('gmail.message.respond error', { error: message });\n\n    throw new McpError(ErrorCode.InternalError, `Error responding to message: ${message}`, {\n      stack: error instanceof Error ? error.stack : undefined,\n    });\n  }\n}\n\nexport default function createTool() {\n  return {\n    name: 'message-respond',\n    config,\n    handler,\n  } satisfies ToolModule;\n}\n"],"names":["createTool","AuthRequiredBranchSchema","schemas","inputSchema","z","object","id","coerce","string","trim","min","describe","body","contentType","ComposeContentTypeSchema","successBranchSchema","type","literal","outputSchema","discriminatedUnion","config","description","result","handler","extra","logger","replyToHdr","headers","fullData","gmail","full","response","error","message","headersArray","fromHdr","toAddr","subject","messageIdHeader","references","replySubject","inReplyTo","refs","mimeType","lines","raw","threadId","McpError","ErrorCode","InvalidParams","info","google","version","auth","authContext","users","messages","get","userId","format","metadataHeaders","data","Error","String","InternalError","stack","undefined","Array","isArray","payload","Object","fromEntries","map","h","header","name","value","From","from","extractEmails","Subject","References","test","startsWith","filter","Boolean","join","b64url","send","requestBody","content","text","JSON","stringify","structuredContent"],"mappings":";;;;+BA6HA;;;eAAwBA;;;qBA7HiB;2BAEjB;qBAKY;0BACb;mBACL;4BACY;8BACP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAPvB,IAAM,AAAEC,2BAA6BC,oBAAO,CAApCD;AASR,IAAME,cAAcC,MAAC,CAACC,MAAM,CAAC;IAC3BC,IAAIF,MAAC,CAACG,MAAM,CAACC,MAAM,GAAGC,IAAI,GAAGC,GAAG,CAAC,GAAGC,QAAQ,CAAC;IAC7CC,MAAMR,MAAC,CAACG,MAAM,CAACC,MAAM,GAAGC,IAAI,GAAGC,GAAG,CAAC,GAAGC,QAAQ,CAAC;IAC/CE,aAAaC,+BAAwB;AACvC;AAEA,IAAMC,sBAAsBX,MAAC,CAACC,MAAM,CAAC;IACnCW,MAAMZ,MAAC,CAACa,OAAO,CAAC;IAChBX,IAAIF,MAAC,CAACI,MAAM,GAAGG,QAAQ,CAAC;AAC1B;AAEA,IAAMO,eAAed,MAAC,CAACe,kBAAkB,CAAC,QAAQ;IAACJ;IAAqBd;CAAyB;AAEjG,IAAMmB,SAAS;IACbC,aAAa;IACblB,aAAaA;IACbe,cAAcd,MAAC,CAACC,MAAM,CAAC;QACrBiB,QAAQJ;IACV;AACF;AAKA,SAAeK;wCAAQ,KAAgC,EAAEC,KAAoB;YAApDlB,IAAIM,MAAMC,aAC3BY,QAwCYC,MACCC,OAEGA,OAZeC,mBAtB7BC,OAEFC,MAEIC,UAOCC,OACDC,SASFL,UACAM,cACAP,SAMAQ,SACAT,YACAU,QACAC,SACAC,iBACAC,YACAC,cACAC,WACAC,MACAC,UACAC,OACAC,KAGAC,UAWAxB,QAcCU,QACDC;;;;oBA/Ee3B,KAAF,MAAEA,IAAIM,OAAN,MAAMA,MAAMC,cAAZ,MAAYA;oBAC3BY,SAASD,MAAMC,MAAM;oBAE3B,IAAI,CAACnB,MAAM,CAACM,MAAM;wBAChB,MAAM,IAAImC,eAAQ,CAACC,gBAAS,CAACC,aAAa,EAAE;oBAC9C;oBAEAxB,OAAOyB,IAAI,CAAC,gCAAgC;wBAAE5C,IAAAA;wBAAIO,aAAAA;oBAAY;;;;;;;;;oBAGtDgB,QAAQsB,kBAAM,CAACtB,KAAK,CAAC;wBAAEuB,SAAS;wBAAMC,MAAM7B,MAAM8B,WAAW,CAACD,IAAI;oBAAC;;;;;;;;;oBAItD;;wBAAMxB,MAAM0B,KAAK,CAACC,QAAQ,CAACC,GAAG,CAAC;4BAC9CC,QAAQ;4BACRpD,IAAIA;4BACJqD,QAAQ;4BACRC,eAAe;gCAAG;gCAAQ;gCAAM;gCAAY;gCAAW;gCAAc;gCAAc;gCAAe;;wBACpG;;;oBALM7B,WAAW;oBAMjBD,OAAOC,SAAS8B,IAAI;;;;;;oBACb7B;oBACDC,UAAUD,AAAK,YAALA,OAAiB8B,SAAQ9B,MAAMC,OAAO,GAAG8B,OAAO/B;oBAChEP,OAAOO,KAAK,CAAC,qCAAqC;wBAAEA,OAAOC;oBAAQ;oBAEnE,MAAM,IAAIc,eAAQ,CAACC,gBAAS,CAACgB,aAAa,EAAE,AAAC,oCAA2C,OAAR/B,UAAW;wBACzFgC,OAAOjC,AAAK,YAALA,OAAiB8B,SAAQ9B,MAAMiC,KAAK,GAAGC;oBAChD;;oBAGF,8BAA8B;oBACxBtC,WAAWE;oBACXI,eAAeiC,MAAMC,OAAO,CAACxC,qBAAAA,gCAAAA,oBAAAA,SAAUyC,OAAO,cAAjBzC,wCAAAA,kBAAmBD,OAAO,IAAIC,SAASyC,OAAO,CAAC1C,OAAO;oBACnFA,UAAU2C,OAAOC,WAAW,CAChCrC,aAAasC,GAAG,CAAC,SAACC;4BAEDC,cAA2BA;wBAD1C,IAAMA,SAASD;wBACf,OAAO;4BAACV,QAAOW,eAAAA,OAAOC,IAAI,cAAXD,0BAAAA,eAAe;4BAAKX,QAAOW,gBAAAA,OAAOE,KAAK,cAAZF,2BAAAA,gBAAgB;yBAAI;oBAChE;oBAEIvC,UAAUR,QAAQkD,IAAI,IAAIlD,QAAQmD,IAAI;oBACtCpD,aAAaC,OAAO,CAAC,WAAW,IAAIA,OAAO,CAAC,WAAW;oBACvDS,UAAUV,OAAAA,aAAaqD,IAAAA,2BAAa,EAACrD,WAAW,CAAC,EAAE,GAAGqD,IAAAA,2BAAa,EAAC5C,QAAQ,CAAC,EAAE,cAArET,kBAAAA,OAA0E;oBACpFW,WAAWV,QAAAA,QAAQqD,OAAO,IAAIrD,QAAQU,OAAO,cAAlCV,mBAAAA,QAAuC;oBAClDW,kBAAkBX,OAAO,CAAC,aAAa,IAAIA,OAAO,CAAC,aAAa,IAAIA,OAAO,CAAC,aAAa;oBACzFY,cAAcZ,QAAAA,QAAQsD,UAAU,IAAItD,QAAQY,UAAU,cAAxCZ,mBAAAA,QAA6C;oBAC3Da,eAAe,QAAQ0C,IAAI,CAAC7C,WAAWA,UAAU,AAAC,OAAc,OAARA;oBACxDI,YAAYH,CAAAA,4BAAAA,sCAAAA,gBAAiB6C,UAAU,CAAC,QAAO7C,kBAAkBA,kBAAkB,AAAC,IAAmB,OAAhBA,iBAAgB,OAAK4B;oBAC5GxB,OAAO;wBAACH;wBAAYE;sBAAW2C,MAAM,CAACC,SAASC,IAAI,CAAC,KAAK7E,IAAI;oBAC7DkC,WAAW9B,gBAAgB,SAAS,cAAc;oBAClD+B,QAAQ;wBAAE,OAAa,OAAPR;wBAAW,YAAwB,OAAbI;wBAAiB,gBAA+B,OAAhBC,sBAAAA,uBAAAA,YAAa;wBAAO,eAAmB,OAALC;wBAAQ;wBAAsB,iBAAyB,OAATC,UAAS;wBAAkB;wBAAI/B;sBAAM0E,IAAI,CAAC;oBAChMzC,MAAM0C,IAAAA,sBAAM,EAAC3C;oBAEnB,gFAAgF;oBAC1EE,WAAWlB,CAAAA,qBAAAA,+BAAAA,SAAUkB,QAAQ,IAAGiB,OAAOnC,SAASkB,QAAQ,IAAIoB;oBAClE;;wBAAMrC,MAAM0B,KAAK,CAACC,QAAQ,CAACgC,IAAI,CAAC;4BAC9B9B,QAAQ;4BACR+B,aAAa;gCACX5C,KAAKA;+BACDC,YAAY;gCAAEA,UAAAA;4BAAS;wBAE/B;;;oBANA;oBAQArB,OAAOyB,IAAI,CAAC,oCAAoC;wBAAE5C,IAAAA;oBAAG;oBAE/CgB,SAAiB;wBACrBN,MAAM;wBACNV,IAAAA;oBACF;oBAEA;;wBAAO;4BACLoF,OAAO;gCACL;oCACE1E,MAAM;oCACN2E,MAAMC,KAAKC,SAAS,CAACvE;gCACvB;;4BAEFwE,mBAAmB;gCAAExE,QAAAA;4BAAO;wBAC9B;;;oBACOU;oBACDC,WAAUD,AAAK,YAALA,QAAiB8B,SAAQ9B,OAAMC,OAAO,GAAG8B,OAAO/B;oBAChEP,OAAOO,KAAK,CAAC,+BAA+B;wBAAEA,OAAOC;oBAAQ;oBAE7D,MAAM,IAAIc,eAAQ,CAACC,gBAAS,CAACgB,aAAa,EAAE,AAAC,gCAAuC,OAAR/B,WAAW;wBACrFgC,OAAOjC,AAAK,YAALA,QAAiB8B,SAAQ9B,OAAMiC,KAAK,GAAGC;oBAChD;;;;;;;IAEJ;;AAEe,SAASlE;IACtB,OAAO;QACL2E,MAAM;QACNvD,QAAAA;QACAG,SAAAA;IACF;AACF"}

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

@@ -0,0 +1,182 @@
+import type { EnrichedExtra } from '@mcp-z/oauth-google';
+import { z } from 'zod';
+declare const inputSchema: z.ZodObject<{
+    shape: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        objects: "objects";
+        arrays: "arrays";
+    }>>>;
+    contentType: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        text: "text";
+        html: "html";
+    }>>>;
+    excludeThreadHistory: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    pageSize: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+    pageToken: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodType<import("../../schemas/gmail-query-schema.js").GmailQuery, unknown, z.core.$ZodTypeInternals<import("../../schemas/gmail-query-schema.js").GmailQuery, unknown>>>;
+    fields: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const outputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    type: z.ZodLiteral<"success">;
+    shape: z.ZodLiteral<"objects">;
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        threadId: z.ZodOptional<z.ZodString>;
+        subject: z.ZodOptional<z.ZodString>;
+        from: z.ZodOptional<z.ZodString>;
+        fromName: z.ZodOptional<z.ZodString>;
+        to: z.ZodOptional<z.ZodString>;
+        cc: z.ZodOptional<z.ZodString>;
+        bcc: z.ZodOptional<z.ZodString>;
+        date: z.ZodOptional<z.ZodString>;
+        receivedDateTime: z.ZodOptional<z.ZodString>;
+        snippet: z.ZodOptional<z.ZodString>;
+        isRead: z.ZodOptional<z.ZodBoolean>;
+        isImportant: z.ZodOptional<z.ZodBoolean>;
+        hasAttachments: z.ZodOptional<z.ZodBoolean>;
+        attachmentCount: z.ZodOptional<z.ZodNumber>;
+        labelIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        folderName: z.ZodOptional<z.ZodString>;
+        body: z.ZodOptional<z.ZodString>;
+        bodyContentType: z.ZodOptional<z.ZodEnum<{
+            text: "text";
+            html: "html";
+        }>>;
+        attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            filename: z.ZodString;
+            mimeType: z.ZodString;
+            size: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+    nextPageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"success">;
+    shape: z.ZodLiteral<"arrays">;
+    columns: z.ZodArray<z.ZodString>;
+    rows: z.ZodArray<z.ZodArray<z.ZodUnknown>>;
+    nextPageToken: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"auth_required">;
+    provider: z.ZodString;
+    message: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+export type Input = z.infer<typeof inputSchema>;
+export type Output = z.infer<typeof outputSchema>;
+declare function handler({ query, pageSize, pageToken, fields, shape, contentType, excludeThreadHistory }: Input, extra: EnrichedExtra): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: {
+        result: {
+            type: "success";
+            shape: "objects";
+            items: {
+                id?: string;
+                threadId?: string;
+                subject?: string;
+                from?: string;
+                fromName?: string;
+                to?: string;
+                cc?: string;
+                bcc?: string;
+                date?: string;
+                receivedDateTime?: string;
+                snippet?: string;
+                isRead?: boolean;
+                isImportant?: boolean;
+                hasAttachments?: boolean;
+                attachmentCount?: number;
+                labelIds?: string[];
+                folderName?: string;
+                body?: string;
+                bodyContentType?: "text" | "html";
+                attachments?: {
+                    id: string;
+                    filename: string;
+                    mimeType: string;
+                    size?: number;
+                }[];
+            }[];
+            nextPageToken?: string;
+        } | {
+            type: "success";
+            shape: "arrays";
+            columns: string[];
+            rows: unknown[][];
+            nextPageToken?: string;
+        };
+    };
+}>;
+export default function createTool(): {
+    name: string;
+    config: {
+        readonly description: "Search Gmail messages using structured query objects with flexible field selection.";
+        readonly inputSchema: z.ZodObject<{
+            shape: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                objects: "objects";
+                arrays: "arrays";
+            }>>>;
+            contentType: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+                text: "text";
+                html: "html";
+            }>>>;
+            excludeThreadHistory: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            pageSize: z.ZodDefault<z.ZodOptional<z.ZodCoercedNumber<unknown>>>;
+            pageToken: z.ZodOptional<z.ZodString>;
+            query: z.ZodOptional<z.ZodType<import("../../schemas/gmail-query-schema.js").GmailQuery, unknown, z.core.$ZodTypeInternals<import("../../schemas/gmail-query-schema.js").GmailQuery, unknown>>>;
+            fields: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        readonly outputSchema: z.ZodObject<{
+            result: z.ZodUnion<readonly [z.ZodObject<{
+                type: z.ZodLiteral<"success">;
+                shape: z.ZodLiteral<"objects">;
+                items: z.ZodArray<z.ZodObject<{
+                    id: z.ZodOptional<z.ZodString>;
+                    threadId: z.ZodOptional<z.ZodString>;
+                    subject: z.ZodOptional<z.ZodString>;
+                    from: z.ZodOptional<z.ZodString>;
+                    fromName: z.ZodOptional<z.ZodString>;
+                    to: z.ZodOptional<z.ZodString>;
+                    cc: z.ZodOptional<z.ZodString>;
+                    bcc: z.ZodOptional<z.ZodString>;
+                    date: z.ZodOptional<z.ZodString>;
+                    receivedDateTime: z.ZodOptional<z.ZodString>;
+                    snippet: z.ZodOptional<z.ZodString>;
+                    isRead: z.ZodOptional<z.ZodBoolean>;
+                    isImportant: z.ZodOptional<z.ZodBoolean>;
+                    hasAttachments: z.ZodOptional<z.ZodBoolean>;
+                    attachmentCount: z.ZodOptional<z.ZodNumber>;
+                    labelIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    folderName: z.ZodOptional<z.ZodString>;
+                    body: z.ZodOptional<z.ZodString>;
+                    bodyContentType: z.ZodOptional<z.ZodEnum<{
+                        text: "text";
+                        html: "html";
+                    }>>;
+                    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        id: z.ZodString;
+                        filename: z.ZodString;
+                        mimeType: z.ZodString;
+                        size: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>>;
+                nextPageToken: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"success">;
+                shape: z.ZodLiteral<"arrays">;
+                columns: z.ZodArray<z.ZodString>;
+                rows: z.ZodArray<z.ZodArray<z.ZodUnknown>>;
+                nextPageToken: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"auth_required">;
+                provider: z.ZodString;
+                message: z.ZodString;
+                url: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>]>;
+        }, z.core.$strip>;
+    };
+    handler: typeof handler;
+};
+export {};