@mcp-z/mcp-outlook 1.0.0

package/dist/esm/email/parsing/message-mapping.d.ts

@@ -0,0 +1,21 @@
+import type { OutlookMessage } from '../../lib/outlook/types.js';
+export interface NormalizedAddress {
+    address?: string | undefined;
+    name?: string | undefined;
+}
+export interface NormalizedMessage {
+    id: string;
+    threadId?: string;
+    date?: string;
+    subject?: string;
+    from?: NormalizedAddress;
+    to?: string[];
+    cc?: string[];
+    bcc?: string[];
+    snippet?: string;
+    labels?: string[];
+    body?: string;
+}
+export declare function mapOutlookMessage(msg: OutlookMessage, opts?: {
+    preferHtml?: boolean;
+}): NormalizedMessage;

package/dist/esm/email/parsing/message-mapping.js

@@ -0,0 +1,35 @@
+import { stripHtml, normalizeDateToISO as toIsoUtc } from '@mcp-z/email';
+import { extractEmailsFromRecipients } from './header-parsing.js';
+export function mapOutlookMessage(msg, opts = {}) {
+    var _ref, _ref1, _msg_id, _toIsoUtc, _msg_toRecipients, _msg_ccRecipients, _msg_bccRecipients;
+    var _msg_from, _msg_body, _msg_body1;
+    const fromAddr = (_msg_from = msg.from) === null || _msg_from === void 0 ? void 0 : _msg_from.emailAddress;
+    const bodyContent = (_ref = (_msg_body = msg.body) === null || _msg_body === void 0 ? void 0 : _msg_body.content) !== null && _ref !== void 0 ? _ref : '';
+    const bodyType = String((_ref1 = (_msg_body1 = msg.body) === null || _msg_body1 === void 0 ? void 0 : _msg_body1.contentType) !== null && _ref1 !== void 0 ? _ref1 : '').toLowerCase();
+    let body;
+    if (bodyContent) {
+        if (opts.preferHtml && bodyType === 'html') body = stripHtml(bodyContent);
+        else body = bodyType === 'html' ? stripHtml(bodyContent) : String(bodyContent);
+    }
+    const out = {
+        id: (_msg_id = msg.id) !== null && _msg_id !== void 0 ? _msg_id : ''
+    };
+    if (msg.conversationId) out.threadId = String(msg.conversationId);
+    if (msg.receivedDateTime) out.date = (_toIsoUtc = toIsoUtc(msg.receivedDateTime)) !== null && _toIsoUtc !== void 0 ? _toIsoUtc : String(msg.receivedDateTime);
+    if (msg.subject) out.subject = String(msg.subject);
+    const fromObj = fromAddr ? {
+        address: fromAddr.address || undefined,
+        name: fromAddr.name || undefined
+    } : undefined;
+    if (fromObj && (fromObj.address || fromObj.name)) out.from = fromObj;
+    const toList = extractEmailsFromRecipients((_msg_toRecipients = msg.toRecipients) !== null && _msg_toRecipients !== void 0 ? _msg_toRecipients : []);
+    if (Array.isArray(toList) && toList.length) out.to = toList;
+    const ccList = extractEmailsFromRecipients((_msg_ccRecipients = msg.ccRecipients) !== null && _msg_ccRecipients !== void 0 ? _msg_ccRecipients : []);
+    if (Array.isArray(ccList) && ccList.length) out.cc = ccList;
+    const bccList = extractEmailsFromRecipients((_msg_bccRecipients = msg.bccRecipients) !== null && _msg_bccRecipients !== void 0 ? _msg_bccRecipients : []);
+    if (Array.isArray(bccList) && bccList.length) out.bcc = bccList;
+    if (msg.bodyPreview) out.snippet = String(msg.bodyPreview);
+    if (Array.isArray(msg.categories) && msg.categories.length) out.labels = msg.categories.map(String);
+    if (body) out.body = body;
+    return out;
+}

package/dist/esm/email/parsing/message-mapping.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/Projects/ai/mcp-z/servers/mcp-outlook/src/email/parsing/message-mapping.ts"],"sourcesContent":["import { stripHtml, normalizeDateToISO as toIsoUtc } from '@mcp-z/email';\nimport type { OutlookMessage } from '../../lib/outlook/types.js';\nimport { extractEmailsFromRecipients } from './header-parsing.js';\n\nexport interface NormalizedAddress {\n  address?: string | undefined;\n  name?: string | undefined;\n}\nexport interface NormalizedMessage {\n  id: string;\n  threadId?: string;\n  date?: string;\n  subject?: string;\n  from?: NormalizedAddress;\n  to?: string[];\n  cc?: string[];\n  bcc?: string[];\n  snippet?: string;\n  labels?: string[];\n  body?: string;\n}\n\nexport function mapOutlookMessage(msg: OutlookMessage, opts: { preferHtml?: boolean } = {}): NormalizedMessage {\n  const fromAddr = msg.from?.emailAddress;\n  const bodyContent = msg.body?.content ?? '';\n  const bodyType = String(msg.body?.contentType ?? '').toLowerCase();\n\n  let body: string | undefined;\n  if (bodyContent) {\n    if (opts.preferHtml && bodyType === 'html') body = stripHtml(bodyContent);\n    else body = bodyType === 'html' ? stripHtml(bodyContent) : String(bodyContent);\n  }\n\n  const out: NormalizedMessage = { id: msg.id ?? '' };\n\n  if (msg.conversationId) out.threadId = String(msg.conversationId);\n  if (msg.receivedDateTime) out.date = toIsoUtc(msg.receivedDateTime) ?? String(msg.receivedDateTime);\n  if (msg.subject) out.subject = String(msg.subject);\n\n  const fromObj = fromAddr ? { address: fromAddr.address || undefined, name: fromAddr.name || undefined } : undefined;\n  if (fromObj && (fromObj.address || fromObj.name)) out.from = fromObj;\n\n  const toList = extractEmailsFromRecipients(msg.toRecipients ?? []);\n  if (Array.isArray(toList) && toList.length) out.to = toList;\n\n  const ccList = extractEmailsFromRecipients(msg.ccRecipients ?? []);\n  if (Array.isArray(ccList) && ccList.length) out.cc = ccList;\n\n  const bccList = extractEmailsFromRecipients(msg.bccRecipients ?? []);\n  if (Array.isArray(bccList) && bccList.length) out.bcc = bccList;\n\n  if (msg.bodyPreview) out.snippet = String(msg.bodyPreview);\n  if (Array.isArray(msg.categories) && msg.categories.length) out.labels = msg.categories.map(String);\n  if (body) out.body = body;\n\n  return out;\n}\n"],"names":["stripHtml","normalizeDateToISO","toIsoUtc","extractEmailsFromRecipients","mapOutlookMessage","msg","opts","fromAddr","from","emailAddress","bodyContent","body","content","bodyType","String","contentType","toLowerCase","preferHtml","out","id","conversationId","threadId","receivedDateTime","date","subject","fromObj","address","undefined","name","toList","toRecipients","Array","isArray","length","to","ccList","ccRecipients","cc","bccList","bccRecipients","bcc","bodyPreview","snippet","categories","labels","map"],"mappings":"AAAA,SAASA,SAAS,EAAEC,sBAAsBC,QAAQ,QAAQ,eAAe;AAEzE,SAASC,2BAA2B,QAAQ,sBAAsB;AAoBlE,OAAO,SAASC,kBAAkBC,GAAmB,EAAEC,OAAiC,CAAC,CAAC;qBAWnDD,SAGAH,WAMMG,mBAGAA,mBAGCA;QAzB3BA,WACGA,WACIA;IAFxB,MAAME,YAAWF,YAAAA,IAAIG,IAAI,cAARH,gCAAAA,UAAUI,YAAY;IACvC,MAAMC,uBAAcL,YAAAA,IAAIM,IAAI,cAARN,gCAAAA,UAAUO,OAAO,uCAAI;IACzC,MAAMC,WAAWC,iBAAOT,aAAAA,IAAIM,IAAI,cAARN,iCAAAA,WAAUU,WAAW,yCAAI,IAAIC,WAAW;IAEhE,IAAIL;IACJ,IAAID,aAAa;QACf,IAAIJ,KAAKW,UAAU,IAAIJ,aAAa,QAAQF,OAAOX,UAAUU;aACxDC,OAAOE,aAAa,SAASb,UAAUU,eAAeI,OAAOJ;IACpE;IAEA,MAAMQ,MAAyB;QAAEC,EAAE,GAAEd,UAAAA,IAAIc,EAAE,cAANd,qBAAAA,UAAU;IAAG;IAElD,IAAIA,IAAIe,cAAc,EAAEF,IAAIG,QAAQ,GAAGP,OAAOT,IAAIe,cAAc;IAChE,IAAIf,IAAIiB,gBAAgB,EAAEJ,IAAIK,IAAI,IAAGrB,YAAAA,SAASG,IAAIiB,gBAAgB,eAA7BpB,uBAAAA,YAAkCY,OAAOT,IAAIiB,gBAAgB;IAClG,IAAIjB,IAAImB,OAAO,EAAEN,IAAIM,OAAO,GAAGV,OAAOT,IAAImB,OAAO;IAEjD,MAAMC,UAAUlB,WAAW;QAAEmB,SAASnB,SAASmB,OAAO,IAAIC;QAAWC,MAAMrB,SAASqB,IAAI,IAAID;IAAU,IAAIA;IAC1G,IAAIF,WAAYA,CAAAA,QAAQC,OAAO,IAAID,QAAQG,IAAI,AAAD,GAAIV,IAAIV,IAAI,GAAGiB;IAE7D,MAAMI,SAAS1B,6BAA4BE,oBAAAA,IAAIyB,YAAY,cAAhBzB,+BAAAA,oBAAoB,EAAE;IACjE,IAAI0B,MAAMC,OAAO,CAACH,WAAWA,OAAOI,MAAM,EAAEf,IAAIgB,EAAE,GAAGL;IAErD,MAAMM,SAAShC,6BAA4BE,oBAAAA,IAAI+B,YAAY,cAAhB/B,+BAAAA,oBAAoB,EAAE;IACjE,IAAI0B,MAAMC,OAAO,CAACG,WAAWA,OAAOF,MAAM,EAAEf,IAAImB,EAAE,GAAGF;IAErD,MAAMG,UAAUnC,6BAA4BE,qBAAAA,IAAIkC,aAAa,cAAjBlC,gCAAAA,qBAAqB,EAAE;IACnE,IAAI0B,MAAMC,OAAO,CAACM,YAAYA,QAAQL,MAAM,EAAEf,IAAIsB,GAAG,GAAGF;IAExD,IAAIjC,IAAIoC,WAAW,EAAEvB,IAAIwB,OAAO,GAAG5B,OAAOT,IAAIoC,WAAW;IACzD,IAAIV,MAAMC,OAAO,CAAC3B,IAAIsC,UAAU,KAAKtC,IAAIsC,UAAU,CAACV,MAAM,EAAEf,IAAI0B,MAAM,GAAGvC,IAAIsC,UAAU,CAACE,GAAG,CAAC/B;IAC5F,IAAIH,MAAMO,IAAIP,IAAI,GAAGA;IAErB,OAAOO;AACT"}

package/dist/esm/email/querying/execute-query.d.ts

@@ -0,0 +1,20 @@
+import type { ExecutionResult } from '@mcp-z/email';
+import type { Client } from '@microsoft/microsoft-graph-client';
+import type { OutlookQuery as QueryNode } from '../../schemas/outlook-query-schema.js';
+import type { Logger } from '../../types.js';
+export interface ExecuteQueryOptions {
+    readonly logger: Logger;
+    readonly limit?: number;
+    readonly includeBody?: boolean;
+    readonly maxPages?: number | null;
+    readonly pageSize?: number;
+    readonly pageToken?: string;
+    readonly timezone?: string;
+    readonly abortSignal?: AbortSignal;
+}
+/**
+ * Execute an Outlook query with direct, single-attempt execution.
+ * No planning, no fallbacks, no retries.
+ * Microsoft Graph errors are returned directly to the caller for actionable feedback.
+ */
+export declare function executeQuery<T>(graph: Client, query: QueryNode | undefined, options: ExecuteQueryOptions, transform: (item: unknown) => T): Promise<ExecutionResult<T>>;

package/dist/esm/email/querying/execute-query.js

@@ -0,0 +1,48 @@
+import { searchMessages } from './search-execution.js';
+/**
+ * Execute an Outlook query with direct, single-attempt execution.
+ * No planning, no fallbacks, no retries.
+ * Microsoft Graph errors are returned directly to the caller for actionable feedback.
+ */ export async function executeQuery(graph, query, options, transform) {
+    const { logger, limit, includeBody, maxPages, pageSize, pageToken } = options;
+    // Single execution - direct query to Microsoft Graph API
+    logger.info('executeQuery: executing direct Outlook query');
+    try {
+        const result = await searchMessages(graph, {
+            ...query !== undefined && {
+                query
+            },
+            limit: limit !== null && limit !== void 0 ? limit : 50,
+            includeBody: includeBody !== null && includeBody !== void 0 ? includeBody : false,
+            maxPages: maxPages !== null && maxPages !== void 0 ? maxPages : null,
+            pageSize: pageSize !== null && pageSize !== void 0 ? pageSize : 50,
+            pageToken: pageToken !== null && pageToken !== void 0 ? pageToken : undefined,
+            logger
+        });
+        // Transform directly - if Microsoft Graph returns invalid data, fail loud
+        const transformedResults = result.messages.map((item, index)=>{
+            try {
+                return transform(item);
+            } catch (transformError) {
+                logger.error(`Transform function failed for item ${index}`, {
+                    itemIndex: index,
+                    error: transformError instanceof Error ? transformError.message : String(transformError)
+                });
+                throw new Error(`Transform failed at item ${index}: ${transformError}`);
+            }
+        });
+        logger.info(`executeQuery: succeeded with ${transformedResults.length} results`);
+        return {
+            success: true,
+            items: transformedResults,
+            metadata: {
+                nextPageToken: result.nextPageToken,
+                totalFetched: result.messages.length
+            }
+        };
+    } catch (error) {
+        // Re-throw errors directly - no fallback logic
+        logger.error('executeQuery: failed', error);
+        throw error;
+    }
+}

package/dist/esm/email/querying/execute-query.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/Projects/ai/mcp-z/servers/mcp-outlook/src/email/querying/execute-query.ts"],"sourcesContent":["import type { ExecutionResult } from '@mcp-z/email';\nimport type { Client } from '@microsoft/microsoft-graph-client';\nimport type { OutlookQuery as QueryNode } from '../../schemas/outlook-query-schema.js';\nimport type { Logger } from '../../types.js';\nimport { searchMessages } from './search-execution.js';\n\nexport interface ExecuteQueryOptions {\n  readonly logger: Logger;\n  readonly limit?: number;\n  readonly includeBody?: boolean;\n  readonly maxPages?: number | null;\n  readonly pageSize?: number;\n  readonly pageToken?: string;\n  readonly timezone?: string;\n  readonly abortSignal?: AbortSignal;\n}\n\n/**\n * Execute an Outlook query with direct, single-attempt execution.\n * No planning, no fallbacks, no retries.\n * Microsoft Graph errors are returned directly to the caller for actionable feedback.\n */\nexport async function executeQuery<T>(graph: Client, query: QueryNode | undefined, options: ExecuteQueryOptions, transform: (item: unknown) => T): Promise<ExecutionResult<T>> {\n  const { logger, limit, includeBody, maxPages, pageSize, pageToken } = options;\n\n  // Single execution - direct query to Microsoft Graph API\n  logger.info('executeQuery: executing direct Outlook query');\n\n  try {\n    const result = await searchMessages(graph, {\n      ...(query !== undefined && { query }),\n      limit: limit ?? 50,\n      includeBody: includeBody ?? false,\n      maxPages: maxPages ?? null,\n      pageSize: pageSize ?? 50,\n      pageToken: pageToken ?? undefined,\n      logger,\n    });\n\n    // Transform directly - if Microsoft Graph returns invalid data, fail loud\n    const transformedResults = result.messages.map((item, index) => {\n      try {\n        return transform(item);\n      } catch (transformError) {\n        logger.error(`Transform function failed for item ${index}`, {\n          itemIndex: index,\n          error: transformError instanceof Error ? transformError.message : String(transformError),\n        });\n        throw new Error(`Transform failed at item ${index}: ${transformError}`);\n      }\n    });\n\n    logger.info(`executeQuery: succeeded with ${transformedResults.length} results`);\n\n    return {\n      success: true,\n      items: transformedResults,\n      metadata: {\n        nextPageToken: result.nextPageToken,\n        totalFetched: result.messages.length,\n      },\n    };\n  } catch (error) {\n    // Re-throw errors directly - no fallback logic\n    logger.error('executeQuery: failed', error as Record<string, unknown>);\n    throw error;\n  }\n}\n"],"names":["searchMessages","executeQuery","graph","query","options","transform","logger","limit","includeBody","maxPages","pageSize","pageToken","info","result","undefined","transformedResults","messages","map","item","index","transformError","error","itemIndex","Error","message","String","length","success","items","metadata","nextPageToken","totalFetched"],"mappings":"AAIA,SAASA,cAAc,QAAQ,wBAAwB;AAavD;;;;CAIC,GACD,OAAO,eAAeC,aAAgBC,KAAa,EAAEC,KAA4B,EAAEC,OAA4B,EAAEC,SAA+B;IAC9I,MAAM,EAAEC,MAAM,EAAEC,KAAK,EAAEC,WAAW,EAAEC,QAAQ,EAAEC,QAAQ,EAAEC,SAAS,EAAE,GAAGP;IAEtE,yDAAyD;IACzDE,OAAOM,IAAI,CAAC;IAEZ,IAAI;QACF,MAAMC,SAAS,MAAMb,eAAeE,OAAO;YACzC,GAAIC,UAAUW,aAAa;gBAAEX;YAAM,CAAC;YACpCI,KAAK,EAAEA,kBAAAA,mBAAAA,QAAS;YAChBC,WAAW,EAAEA,wBAAAA,yBAAAA,cAAe;YAC5BC,QAAQ,EAAEA,qBAAAA,sBAAAA,WAAY;YACtBC,QAAQ,EAAEA,qBAAAA,sBAAAA,WAAY;YACtBC,SAAS,EAAEA,sBAAAA,uBAAAA,YAAaG;YACxBR;QACF;QAEA,0EAA0E;QAC1E,MAAMS,qBAAqBF,OAAOG,QAAQ,CAACC,GAAG,CAAC,CAACC,MAAMC;YACpD,IAAI;gBACF,OAAOd,UAAUa;YACnB,EAAE,OAAOE,gBAAgB;gBACvBd,OAAOe,KAAK,CAAC,CAAC,mCAAmC,EAAEF,OAAO,EAAE;oBAC1DG,WAAWH;oBACXE,OAAOD,0BAA0BG,QAAQH,eAAeI,OAAO,GAAGC,OAAOL;gBAC3E;gBACA,MAAM,IAAIG,MAAM,CAAC,yBAAyB,EAAEJ,MAAM,EAAE,EAAEC,gBAAgB;YACxE;QACF;QAEAd,OAAOM,IAAI,CAAC,CAAC,6BAA6B,EAAEG,mBAAmBW,MAAM,CAAC,QAAQ,CAAC;QAE/E,OAAO;YACLC,SAAS;YACTC,OAAOb;YACPc,UAAU;gBACRC,eAAejB,OAAOiB,aAAa;gBACnCC,cAAclB,OAAOG,QAAQ,CAACU,MAAM;YACtC;QACF;IACF,EAAE,OAAOL,OAAO;QACd,+CAA+C;QAC/Cf,OAAOe,KAAK,CAAC,wBAAwBA;QACrC,MAAMA;IACR;AACF"}

package/dist/esm/email/querying/query-builder.d.ts

@@ -0,0 +1,32 @@
+import type { OutlookQuery as QueryNode } from '../../schemas/outlook-query-schema.js';
+export interface ODataFilterResult {
+    search: string | null;
+    filter: string | null;
+    requireBodyClientFilter: boolean;
+}
+export declare function toGraphFilter(query: QueryNode): ODataFilterResult;
+export declare function toOutlookFilter(parsed: QueryNode, _options?: {
+    includeBodyContent?: boolean;
+    useCaseInsensitiveWrap?: boolean;
+}): {
+    filter: string;
+    search: string;
+    requireBodyClientFilter: boolean;
+    filters: ExtractedFilters;
+};
+interface ExtractedFilters {
+    subjectIncludes: string[];
+    bodyIncludes: string[];
+    textIncludes: string[];
+    fromIncludes: string[];
+    toIncludes: string[];
+    ccIncludes: string[];
+    bccIncludes: string[];
+    categoriesIncludes: string[];
+    labelIncludes: string[];
+    hasAttachment?: boolean;
+    since?: string;
+    before?: string;
+}
+export declare function extractOutlookFilters(parsed: QueryNode): ExtractedFilters;
+export {};

package/dist/esm/email/querying/query-builder.js

@@ -0,0 +1,424 @@
+/**
+ * Outlook category mappings - case insensitive input to exact system categories
+ * Note: These are user-defined categories in Outlook, not system categories like Gmail
+ */ const OUTLOOK_CATEGORIES = {
+    personal: 'Personal',
+    work: 'Work',
+    family: 'Family',
+    travel: 'Travel',
+    important: 'Important',
+    urgent: 'Urgent'
+};
+/**
+ * Validate and map category name to Outlook system category
+ * Throws error for invalid categories (fail fast principle)
+ */ function mapOutlookCategory(category) {
+    // Input validation - fail fast on invalid input
+    if (!category || typeof category !== 'string') {
+        throw new Error(`Invalid category: expected non-empty string, got ${typeof category}`);
+    }
+    const trimmed = category.trim();
+    if (trimmed === '') {
+        throw new Error('Invalid category: empty string after trimming');
+    }
+    // Fail fast on unknown categories
+    const normalizedCategory = trimmed.toLowerCase();
+    const systemCategory = OUTLOOK_CATEGORIES[normalizedCategory];
+    if (!systemCategory) {
+        throw new Error(`Invalid Outlook category: "${category}". Valid categories: ${Object.keys(OUTLOOK_CATEGORIES).join(', ')}`);
+    }
+    return systemCategory;
+}
+export function toGraphFilter(query) {
+    let requireBodyClientFilter = false;
+    function L(s) {
+        // Microsoft Graph does NOT support toLower() function in OData filters
+        // Case-insensitive matching must be done client-side or via $search
+        return s;
+    }
+    function p(s) {
+        return `(${s})`;
+    }
+    function recip(coll, V) {
+        // Graph may reject functions on nested properties; use equality on nested address/name fields.
+        const left = `r/emailAddress/address eq ${V}`;
+        const right = `r/emailAddress/name eq ${V}`;
+        return `${coll}/any(r: ${left} or ${right})`;
+    }
+    function fv(field, raw) {
+        if (raw == null) return '';
+        const rawStr = String(raw);
+        // For text and body fields, skip OData filtering entirely (uses KQL search instead)
+        // Do this BEFORE validation so we don't throw on valid text/body queries
+        if (field === 'text' || field === 'body') {
+            if (rawStr.trim() === '') {
+                throw new Error(`Invalid ${field} value: empty string`);
+            }
+            requireBodyClientFilter = true;
+            return '';
+        }
+        // For all other fields, validate non-empty AFTER checking for null
+        if (rawStr.trim() === '') {
+            throw new Error(`Invalid ${field} value: empty string`);
+        }
+        const V = `'${rawStr.toLowerCase().replace(/'/g, "''")}'`;
+        switch(field){
+            case 'from':
+                {
+                    // For email addresses emit equality checks on nested address/name;
+                    // for name-only tokens, skip server-side filter (handled client-side or via $search).
+                    if (rawStr.includes('@')) {
+                        const addrEq = `${L('from/emailAddress/address')} eq ${V}`;
+                        const nameEq = `${L('from/emailAddress/name')} eq ${V}`;
+                        return p(`${addrEq} or ${nameEq}`);
+                    }
+                    // Don't emit a server-side filter for name-only 'from' tokens.
+                    return '';
+                }
+            case 'to':
+                return recip('toRecipients', V);
+            case 'cc':
+                return recip('ccRecipients', V);
+            case 'bcc':
+                return recip('bccRecipients', V);
+            case 'subject':
+                // Microsoft Graph does NOT support contains() function in OData filters
+                // Use startswith as a partial alternative or rely on $search
+                if (rawStr.includes('-') || rawStr.length < 3) return '';
+                return `startswith(subject, ${V})`;
+            case 'categories':
+                {
+                    // mapOutlookCategory will throw on invalid input (fail fast)
+                    const systemCategory = mapOutlookCategory(rawStr);
+                    // Use the categories OData property with exact case-sensitive match
+                    return `categories/any(c: c eq '${systemCategory}')`;
+                }
+            case 'label':
+                {
+                    // Direct passthrough to categories for Outlook (case-sensitive)
+                    return `categories/any(c: c eq '${rawStr.replace(/'/g, "''")}')`;
+                }
+            default:
+                // Microsoft Graph does NOT support contains() function
+                // For unknown fields, skip server-side filtering
+                return '';
+        }
+    }
+    function chain(op, arr) {
+        if (!arr || arr.length === 0) {
+            throw new Error(`chain: empty array for ${op} operation`);
+        }
+        if (arr.length === 1) {
+            var _arr_;
+            const first = (_arr_ = arr[0]) !== null && _arr_ !== void 0 ? _arr_ : '';
+            return String(first);
+        }
+        const joined = arr.join(` ${op} `);
+        return p(joined);
+    }
+    function fieldExpr(field, op) {
+        if (typeof op === 'string') {
+            return fv(field, op);
+        }
+        if (Array.isArray(op.$any)) {
+            const results = op.$any.map((v)=>fv(field, String(v !== null && v !== void 0 ? v : '')));
+            // Filter out empty strings (from fields like text/body that don't generate OData filters)
+            const validResults = results.filter((s)=>s && s.trim());
+            if (validResults.length === 0) return '';
+            return chain('or', validResults);
+        }
+        if (Array.isArray(op.$all)) {
+            const results = op.$all.map((v)=>fv(field, String(v !== null && v !== void 0 ? v : '')));
+            // Filter out empty strings (from fields like text/body that don't generate OData filters)
+            const validResults = results.filter((s)=>s && s.trim());
+            if (validResults.length === 0) return '';
+            return chain('and', validResults);
+        }
+        if (Array.isArray(op.$none)) {
+            const results = op.$none.map((v)=>fv(field, String(v !== null && v !== void 0 ? v : '')));
+            // Filter out empty strings (from fields like text/body that don't generate OData filters)
+            const validResults = results.filter((s)=>s && s.trim());
+            if (validResults.length === 0) return '';
+            return `not ${p(chain('or', validResults))}`;
+        }
+        throw new Error(`Unknown field operator ${JSON.stringify(op)}`);
+    }
+    function dateExpr(d) {
+        var _parts_;
+        const parts = [];
+        if (d.$gte) parts.push(`receivedDateTime ge ${d.$gte}T00:00:00Z`);
+        if (d.$lt) parts.push(`receivedDateTime lt ${d.$lt}T00:00:00Z`);
+        return parts.length > 1 ? p(parts.join(' and ')) : (_parts_ = parts[0]) !== null && _parts_ !== void 0 ? _parts_ : '';
+    }
+    function emit(n) {
+        if (!n || typeof n !== 'object') return '';
+        if ('$and' in n && n.$and) {
+            const andParts = n.$and.map(emit).filter((part)=>Boolean(part));
+            if (andParts.length === 0) return '';
+            if (andParts.length === 1) {
+                const firstPart = andParts[0];
+                return firstPart !== null && firstPart !== void 0 ? firstPart : '';
+            }
+            return p(andParts.join(' and '));
+        }
+        if ('$or' in n && n.$or) {
+            const orParts = n.$or.map(emit).filter((part)=>Boolean(part));
+            if (orParts.length === 0) return '';
+            if (orParts.length === 1) {
+                const firstPart = orParts[0];
+                return firstPart !== null && firstPart !== void 0 ? firstPart : '';
+            }
+            return p(orParts.join(' or '));
+        }
+        if ('$not' in n && n.$not) {
+            const notExpr = emit(n.$not);
+            return notExpr ? `not (${notExpr})` : '';
+        }
+        if ('hasAttachment' in n && n.hasAttachment) return 'hasAttachments eq true';
+        if ('date' in n && n.date) return dateExpr(n.date);
+        const keys = Object.keys(n);
+        if (keys.length === 1) {
+            var _keys_;
+            const k0 = String((_keys_ = keys[0]) !== null && _keys_ !== void 0 ? _keys_ : '');
+            if (k0 && [
+                'from',
+                'to',
+                'cc',
+                'bcc',
+                'subject',
+                'text',
+                'body',
+                'categories',
+                'label'
+            ].includes(k0)) {
+                const fieldValue = n[k0];
+                if (fieldValue) return fieldExpr(k0, fieldValue);
+            }
+        }
+        return '';
+    }
+    const filterStr = emit(query);
+    const terms = [];
+    function pushTerms(arr) {
+        if (Array.isArray(arr)) {
+            for (const t of arr)if ((t !== null && t !== void 0 ? t : '').toString().trim()) terms.push(String(t).trim());
+        }
+    }
+    function walk(node) {
+        if (!node || typeof node !== 'object') return;
+        if ('$and' in node && node.$and) {
+            node.$and.forEach(walk);
+            return;
+        }
+        if ('$or' in node && node.$or) {
+            node.$or.forEach(walk);
+            return;
+        }
+        if ('$not' in node && node.$not) {
+            walk(node.$not);
+            return;
+        }
+        if ('exactPhrase' in node && node.exactPhrase) {
+            // KQL uses double quotes for exact phrase matching
+            pushTerms([
+                `"${String(node.exactPhrase).replace(/"/g, '\\"')}"`
+            ]);
+            return;
+        }
+        if ('subject' in node && node.subject) {
+            if (typeof node.subject === 'string') {
+                pushTerms([
+                    node.subject
+                ]);
+            } else {
+                pushTerms(node.subject.$any);
+                pushTerms(node.subject.$all);
+                pushTerms(node.subject.$none);
+            }
+        }
+        if ('body' in node && node.body) {
+            if (typeof node.body === 'string') {
+                pushTerms([
+                    node.body
+                ]);
+            } else {
+                pushTerms(node.body.$any);
+                pushTerms(node.body.$all);
+                pushTerms(node.body.$none);
+            }
+        }
+        if ('text' in node && node.text) {
+            if (typeof node.text === 'string') {
+                pushTerms([
+                    node.text
+                ]);
+            } else {
+                pushTerms(node.text.$any);
+                pushTerms(node.text.$all);
+                pushTerms(node.text.$none);
+            }
+        }
+    }
+    walk(query);
+    /**
+   * Escape KQL (Keyword Query Language) special characters in search terms.
+   * KQL special characters that need escaping: \ : ( ) { } [ ] " * ? < > - _
+   * According to Microsoft Graph KQL syntax, these must be escaped with backslash.
+   */ function escapeKQL(term) {
+        if (!term) return term;
+        // Escape backslash first, then other special characters
+        return term.replace(/\\/g, '\\\\').replace(/:/g, '\\:').replace(/\(/g, '\\(').replace(/\)/g, '\\)').replace(/\{/g, '\\{').replace(/\}/g, '\\}').replace(/\[/g, '\\[').replace(/\]/g, '\\]').replace(/"/g, '\\"').replace(/\*/g, '\\*').replace(/\?/g, '\\?').replace(/</g, '\\<').replace(/>/g, '\\>').replace(/-/g, '\\-').replace(/_/g, '\\_');
+    }
+    const mapped = terms.map((t)=>{
+        const escaped = escapeKQL(String(t));
+        return escaped;
+    });
+    const search = mapped.length ? mapped.join(' OR ') : null;
+    return {
+        search,
+        filter: filterStr && typeof filterStr === 'string' && filterStr.length ? filterStr : null,
+        requireBodyClientFilter
+    };
+}
+export function toOutlookFilter(parsed, _options) {
+    const graphResult = toGraphFilter(parsed);
+    const filters = extractOutlookFilters(parsed);
+    return {
+        filter: graphResult.filter,
+        search: graphResult.search,
+        requireBodyClientFilter: graphResult.requireBodyClientFilter,
+        filters
+    };
+}
+export function extractOutlookFilters(parsed) {
+    const filters = {
+        subjectIncludes: [],
+        bodyIncludes: [],
+        textIncludes: [],
+        fromIncludes: [],
+        toIncludes: [],
+        ccIncludes: [],
+        bccIncludes: [],
+        categoriesIncludes: [],
+        labelIncludes: []
+    };
+    function walk(node) {
+        if (!node || typeof node !== 'object') return;
+        if ('$and' in node && node.$and) {
+            node.$and.forEach(walk);
+            return;
+        }
+        if ('$or' in node && node.$or) {
+            node.$or.forEach(walk);
+            return;
+        }
+        if ('$not' in node && node.$not) {
+            walk(node.$not);
+            return;
+        }
+        if ('hasAttachment' in node && node.hasAttachment !== undefined) {
+            filters.hasAttachment = node.hasAttachment === true;
+            return;
+        }
+        if ('date' in node && node.date) {
+            if (node.date.$gte) filters.since = node.date.$gte;
+            if (node.date.$lt) filters.before = node.date.$lt;
+            return;
+        }
+        if ('subject' in node && node.subject) {
+            if (typeof node.subject === 'string') {
+                filters.subjectIncludes.push(node.subject);
+            } else {
+                if (node.subject.$any) filters.subjectIncludes.push(...node.subject.$any);
+                if (node.subject.$all) filters.subjectIncludes.push(...node.subject.$all);
+            }
+        }
+        if ('body' in node && node.body) {
+            if (typeof node.body === 'string') {
+                filters.bodyIncludes.push(node.body);
+            } else {
+                if (node.body.$any) filters.bodyIncludes.push(...node.body.$any);
+                if (node.body.$all) filters.bodyIncludes.push(...node.body.$all);
+            }
+        }
+        if ('text' in node && node.text) {
+            if (typeof node.text === 'string') {
+                filters.textIncludes.push(node.text);
+                filters.bodyIncludes.push(node.text);
+            } else {
+                if (node.text.$any) {
+                    filters.textIncludes.push(...node.text.$any);
+                    filters.bodyIncludes.push(...node.text.$any);
+                }
+                if (node.text.$all) {
+                    filters.textIncludes.push(...node.text.$all);
+                    filters.bodyIncludes.push(...node.text.$all);
+                }
+            }
+        }
+        if ('from' in node && node.from) {
+            if (typeof node.from === 'string') {
+                filters.fromIncludes.push(node.from);
+            } else {
+                if (node.from.$any) filters.fromIncludes.push(...node.from.$any);
+                if (node.from.$all) filters.fromIncludes.push(...node.from.$all);
+            }
+        }
+        if ('to' in node && node.to) {
+            if (typeof node.to === 'string') {
+                filters.toIncludes.push(node.to);
+            } else {
+                if (node.to.$any) filters.toIncludes.push(...node.to.$any);
+                if (node.to.$all) filters.toIncludes.push(...node.to.$all);
+            }
+        }
+        if ('cc' in node && node.cc) {
+            if (typeof node.cc === 'string') {
+                filters.ccIncludes.push(node.cc);
+            } else {
+                if (node.cc.$any) filters.ccIncludes.push(...node.cc.$any);
+                if (node.cc.$all) filters.ccIncludes.push(...node.cc.$all);
+            }
+        }
+        if ('bcc' in node && node.bcc) {
+            if (typeof node.bcc === 'string') {
+                filters.bccIncludes.push(node.bcc);
+            } else {
+                if (node.bcc.$any) filters.bccIncludes.push(...node.bcc.$any);
+                if (node.bcc.$all) filters.bccIncludes.push(...node.bcc.$all);
+            }
+        }
+        if ('categories' in node && node.categories) {
+            if (typeof node.categories === 'string') {
+                if (mapOutlookCategory(node.categories) !== null) {
+                    filters.categoriesIncludes.push(node.categories);
+                }
+            } else {
+                // Filter out invalid categories to prevent memory leaks and maintain clean state
+                if (node.categories.$any) {
+                    const validCategories = node.categories.$any.filter((cat)=>mapOutlookCategory(cat) !== null);
+                    if (validCategories.length > 0) filters.categoriesIncludes.push(...validCategories);
+                }
+                if (node.categories.$all) {
+                    const validCategories = node.categories.$all.filter((cat)=>mapOutlookCategory(cat) !== null);
+                    if (validCategories.length > 0) filters.categoriesIncludes.push(...validCategories);
+                }
+                if (node.categories.$none) {
+                    const validCategories = node.categories.$none.filter((cat)=>mapOutlookCategory(cat) !== null);
+                    if (validCategories.length > 0) filters.categoriesIncludes.push(...validCategories);
+                }
+            }
+        }
+        if ('label' in node && node.label) {
+            if (typeof node.label === 'string') {
+                filters.labelIncludes.push(node.label);
+            } else {
+                if (node.label.$any) filters.labelIncludes.push(...node.label.$any);
+                if (node.label.$all) filters.labelIncludes.push(...node.label.$all);
+                if (node.label.$none) filters.labelIncludes.push(...node.label.$none);
+            }
+        }
+    }
+    walk(parsed);
+    return filters;
+}