@anuma/sdk 1.0.0-next.20260224164627

package/dist/tools/index.mjs

@@ -0,0 +1,1645 @@
+// src/tools/googleCalendar.ts
+function ensureTimezone(timestamp) {
+  if (/[Zz]$/.test(timestamp) || /[+-]\d{2}:\d{2}$/.test(timestamp)) {
+    return timestamp;
+  }
+  return `${timestamp}Z`;
+}
+async function fetchCalendarEvents(accessToken, args) {
+  const { timeMin, timeMax, maxResults = 10 } = args;
+  const params = new URLSearchParams({
+    maxResults: String(maxResults),
+    singleEvents: "true",
+    orderBy: "startTime"
+  });
+  const now = /* @__PURE__ */ new Date();
+  const defaultTimeMin = now.toISOString();
+  const defaultTimeMax = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1e3).toISOString();
+  params.set("timeMin", ensureTimezone(timeMin || defaultTimeMin));
+  params.set("timeMax", ensureTimezone(timeMax || defaultTimeMax));
+  try {
+    const response = await fetch(
+      `https://www.googleapis.com/calendar/v3/calendars/primary/events?${params.toString()}`,
+      {
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        }
+      }
+    );
+    if (!response.ok) {
+      if (response.status === 401) {
+        return "Error: Calendar access not authorized. Please grant calendar permissions.";
+      }
+      const errorText = await response.text();
+      return `Error: Failed to fetch calendar events (${response.status}): ${errorText}`;
+    }
+    const data = await response.json();
+    const events = (data.items || []).map(
+      (item) => ({
+        id: item.id,
+        summary: item.summary || "No title",
+        start: item.start?.dateTime || item.start?.date || "Unknown",
+        end: item.end?.dateTime || item.end?.date || "Unknown",
+        description: item.description,
+        location: item.location
+      })
+    );
+    return events;
+  } catch (error) {
+    return `Error: ${error instanceof Error ? error.message : "Unknown error occurred"}`;
+  }
+}
+function buildEventBody(args) {
+  const { summary, start, end, description, location, attendees } = args;
+  const isAllDay = !start.includes("T");
+  const eventBody = {
+    summary,
+    description,
+    location,
+    start: isAllDay ? { date: start } : { dateTime: start },
+    end: isAllDay ? { date: end } : { dateTime: end }
+  };
+  if (attendees && attendees.length > 0) {
+    eventBody.attendees = attendees.map((email) => ({ email }));
+  }
+  return eventBody;
+}
+function parseEventResponse(data) {
+  return {
+    id: data.id,
+    summary: data.summary || "No title",
+    start: data.start?.dateTime || data.start?.date || "Unknown",
+    end: data.end?.dateTime || data.end?.date || "Unknown",
+    description: data.description,
+    location: data.location
+  };
+}
+async function createCalendarEvent(accessToken, args) {
+  const eventBody = buildEventBody(args);
+  try {
+    const response = await fetch(
+      "https://www.googleapis.com/calendar/v3/calendars/primary/events",
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(eventBody)
+      }
+    );
+    if (!response.ok) {
+      if (response.status === 401) {
+        return "Error: Calendar access not authorized. Please grant calendar permissions.";
+      }
+      const errorText = await response.text();
+      return `Error: Failed to create calendar event (${response.status}): ${errorText}`;
+    }
+    const data = await response.json();
+    return parseEventResponse(data);
+  } catch (error) {
+    return `Error: ${error instanceof Error ? error.message : "Unknown error occurred"}`;
+  }
+}
+function buildUpdateEventBody(args) {
+  const { summary, start, end, description, location, attendees } = args;
+  const eventBody = {};
+  if (summary !== void 0) eventBody.summary = summary;
+  if (description !== void 0) eventBody.description = description;
+  if (location !== void 0) eventBody.location = location;
+  if (start !== void 0) {
+    const isAllDay = !start.includes("T");
+    eventBody.start = isAllDay ? { date: start } : { dateTime: start };
+  }
+  if (end !== void 0) {
+    const isAllDay = !end.includes("T");
+    eventBody.end = isAllDay ? { date: end } : { dateTime: end };
+  }
+  if (attendees !== void 0) {
+    eventBody.attendees = attendees.map((email) => ({ email }));
+  }
+  return eventBody;
+}
+async function updateCalendarEvent(accessToken, args) {
+  const { eventId } = args;
+  const eventBody = buildUpdateEventBody(args);
+  try {
+    const response = await fetch(
+      `https://www.googleapis.com/calendar/v3/calendars/primary/events/${eventId}`,
+      {
+        method: "PATCH",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(eventBody)
+      }
+    );
+    if (!response.ok) {
+      if (response.status === 401) {
+        return "Error: Calendar access not authorized. Please grant calendar permissions.";
+      }
+      if (response.status === 404) {
+        return `Error: Event not found with ID: ${eventId}`;
+      }
+      const errorText = await response.text();
+      return `Error: Failed to update calendar event (${response.status}): ${errorText}`;
+    }
+    const data = await response.json();
+    return parseEventResponse(data);
+  } catch (error) {
+    return `Error: ${error instanceof Error ? error.message : "Unknown error occurred"}`;
+  }
+}
+function createGoogleCalendarTool(getAccessToken, requestCalendarAccess) {
+  return {
+    type: "function",
+    function: {
+      name: "google_calendar_list_events",
+      description: "Lists upcoming events from the user's Google Calendar. Returns events within a specified time range. If no time range is specified, returns events for the next 7 days.",
+      arguments: {
+        type: "object",
+        properties: {
+          timeMin: {
+            type: "string",
+            description: 'Start of the time range (ISO 8601 format, e.g., "2024-01-15T00:00:00Z"). Defaults to now.'
+          },
+          timeMax: {
+            type: "string",
+            description: 'End of the time range (ISO 8601 format, e.g., "2024-01-22T23:59:59Z"). Defaults to 7 days from now.'
+          },
+          maxResults: {
+            type: "number",
+            description: "Maximum number of events to return. Defaults to 10."
+          }
+        },
+        required: []
+      }
+    },
+    executor: async (args) => {
+      let token = getAccessToken();
+      if (!token) {
+        try {
+          token = await requestCalendarAccess();
+        } catch {
+          return "Error: Failed to get calendar access. Please grant permissions when prompted.";
+        }
+      }
+      if (!token) {
+        return "Error: No Google Calendar access token available. Please connect your Google account.";
+      }
+      const typedArgs = {
+        timeMin: args.timeMin,
+        timeMax: args.timeMax,
+        maxResults: args.maxResults
+      };
+      return fetchCalendarEvents(token, typedArgs);
+    },
+    autoExecute: true
+  };
+}
+function createGoogleCalendarCreateEventTool(getAccessToken, requestCalendarAccess) {
+  return {
+    type: "function",
+    function: {
+      name: "google_calendar_create_event",
+      description: "Creates a new event in the user's Google Calendar. Supports both timed events (with specific times) and all-day events (date only).",
+      arguments: {
+        type: "object",
+        properties: {
+          summary: {
+            type: "string",
+            description: "The title/name of the event."
+          },
+          start: {
+            type: "string",
+            description: 'Start time in ISO 8601 format. For timed events use datetime format (e.g., "2024-01-15T09:00:00-05:00"). For all-day events use date format (e.g., "2024-01-15").'
+          },
+          end: {
+            type: "string",
+            description: 'End time in ISO 8601 format. For timed events use datetime format (e.g., "2024-01-15T10:00:00-05:00"). For all-day events use date format (e.g., "2024-01-16", note: end date is exclusive).'
+          },
+          description: {
+            type: "string",
+            description: "Optional description or notes for the event."
+          },
+          location: {
+            type: "string",
+            description: "Optional location for the event."
+          },
+          attendees: {
+            type: "array",
+            items: { type: "string" },
+            description: "Optional list of email addresses to invite as attendees."
+          }
+        },
+        required: ["summary", "start", "end"]
+      }
+    },
+    executor: async (args) => {
+      let token = getAccessToken();
+      if (!token) {
+        try {
+          token = await requestCalendarAccess();
+        } catch {
+          return "Error: Failed to get calendar access. Please grant permissions when prompted.";
+        }
+      }
+      if (!token) {
+        return "Error: No Google Calendar access token available. Please connect your Google account.";
+      }
+      const typedArgs = {
+        summary: args.summary,
+        start: args.start,
+        end: args.end,
+        description: args.description,
+        location: args.location,
+        attendees: args.attendees
+      };
+      return createCalendarEvent(token, typedArgs);
+    },
+    autoExecute: true
+  };
+}
+function createGoogleCalendarUpdateEventTool(getAccessToken, requestCalendarAccess) {
+  return {
+    type: "function",
+    function: {
+      name: "google_calendar_update_event",
+      description: "Updates an existing event in the user's Google Calendar. Only the fields provided will be updated; other fields remain unchanged. Use google_calendar_list_events first to get the event ID.",
+      arguments: {
+        type: "object",
+        properties: {
+          eventId: {
+            type: "string",
+            description: "The ID of the event to update (obtained from google_calendar_list_events)."
+          },
+          summary: {
+            type: "string",
+            description: "The new title/name of the event."
+          },
+          start: {
+            type: "string",
+            description: 'New start time in ISO 8601 format. For timed events use datetime format (e.g., "2024-01-15T09:00:00-05:00"). For all-day events use date format (e.g., "2024-01-15").'
+          },
+          end: {
+            type: "string",
+            description: 'New end time in ISO 8601 format. For timed events use datetime format (e.g., "2024-01-15T10:00:00-05:00"). For all-day events use date format (e.g., "2024-01-16").'
+          },
+          description: {
+            type: "string",
+            description: "New description or notes for the event."
+          },
+          location: {
+            type: "string",
+            description: "New location for the event."
+          },
+          attendees: {
+            type: "array",
+            items: { type: "string" },
+            description: "New list of email addresses to invite as attendees (replaces existing attendees)."
+          }
+        },
+        required: ["eventId"]
+      }
+    },
+    executor: async (args) => {
+      let token = getAccessToken();
+      if (!token) {
+        try {
+          token = await requestCalendarAccess();
+        } catch {
+          return "Error: Failed to get calendar access. Please grant permissions when prompted.";
+        }
+      }
+      if (!token) {
+        return "Error: No Google Calendar access token available. Please connect your Google account.";
+      }
+      const typedArgs = {
+        eventId: args.eventId,
+        summary: args.summary,
+        start: args.start,
+        end: args.end,
+        description: args.description,
+        location: args.location,
+        attendees: args.attendees
+      };
+      return updateCalendarEvent(token, typedArgs);
+    },
+    autoExecute: true
+  };
+}
+function createChatTools(getAccessToken, requestCalendarAccess) {
+  return [
+    createGoogleCalendarTool(getAccessToken, requestCalendarAccess),
+    createGoogleCalendarCreateEventTool(getAccessToken, requestCalendarAccess),
+    createGoogleCalendarUpdateEventTool(getAccessToken, requestCalendarAccess)
+  ];
+}
+
+// src/tools/uiInteraction.ts
+function migrateDisplayResult(result, fromVersion, toVersion, migrations) {
+  if (fromVersion >= toVersion) return result;
+  let current = result;
+  for (let v = fromVersion; v < toVersion; v++) {
+    const key = `${v}->${v + 1}`;
+    const migrate = migrations[key];
+    if (migrate) {
+      current = migrate(current);
+    }
+  }
+  return current;
+}
+function generateInteractionId(prefix) {
+  return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+}
+function createInteractiveTool(options, config) {
+  return {
+    type: "function",
+    function: {
+      name: config.name,
+      description: config.description,
+      arguments: config.parameters
+    },
+    executor: async (args) => {
+      if (config.validate && !config.validate(args)) {
+        return { cancelled: true };
+      }
+      const context = options.getContext();
+      if (!context) {
+        return { cancelled: true };
+      }
+      const interactionId = generateInteractionId(config.interactionType);
+      const interactionData = config.mapArgs ? config.mapArgs(args) : args;
+      try {
+        const result = await context.createInteraction(interactionId, config.interactionType, {
+          ...interactionData,
+          afterMessageId: options.getLastMessageId?.()
+        });
+        if (config.mapResult) {
+          return config.mapResult(result, args);
+        }
+        return result;
+      } catch {
+        return { cancelled: true };
+      }
+    },
+    // Interactive tools block until the user responds (e.g. fills a form,
+    // picks a choice).  They must NOT be auto-executed by the SDK's internal
+    // tool loop — instead the app's own onToolCall handler should drive them
+    // so the result is persisted as a "[Tool Execution Results]" message.
+    autoExecute: false
+  };
+}
+function createDisplayTool(options, config) {
+  return {
+    type: "function",
+    function: {
+      name: config.name,
+      description: config.description,
+      arguments: config.parameters
+    },
+    executor: async (args) => {
+      const result = await config.execute(args);
+      const context = options.getContext();
+      if (context) {
+        const interactionId = generateInteractionId(config.displayType);
+        context.createDisplayInteraction(
+          interactionId,
+          config.displayType,
+          { afterMessageId: options.getLastMessageId?.() },
+          result,
+          config.version ?? 1
+        );
+      }
+      return result;
+    },
+    autoExecute: true,
+    skipContinuation: true
+  };
+}
+
+// src/tools/chart.ts
+function createChartTool(options) {
+  return createDisplayTool(options, {
+    name: "display_chart",
+    description: "Renders a chart inline in the chat. Supports bar, line, area, and pie charts. RULES: (1) Call this tool ONCE per request \u2014 you cannot update a chart after it renders. (2) When the user provides data in their message, call this tool immediately with that data \u2014 do NOT search or verify it. (3) Only search/fetch if the user asks for data you don't have. (4) Do NOT repeat the chart data as text in your response. Just add a brief conversational comment about the chart. Use simple alphanumeric keys without spaces (e.g. 'revenue', 'users', 'q1Sales').",
+    parameters: {
+      type: "object",
+      properties: {
+        chartType: {
+          type: "string",
+          enum: ["bar", "line", "area", "pie"],
+          description: "Type of chart to render"
+        },
+        title: {
+          type: "string",
+          description: "Optional title displayed above the chart"
+        },
+        data: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: true
+          },
+          description: "Array of data points. Each object should have a label key and one or more numeric value keys."
+        },
+        dataKeys: {
+          type: "array",
+          items: { type: "string" },
+          description: "Which keys in each data object to chart as series/bars/slices (the numeric values)."
+        },
+        xAxisKey: {
+          type: "string",
+          description: "Which key in each data object to use for x-axis labels (for bar, line, area charts). For pie charts, this is the name/label key for each slice."
+        },
+        colors: {
+          type: "object",
+          additionalProperties: { type: "string" },
+          description: "Optional color overrides. Map of dataKey to CSS color value (e.g. { 'revenue': '#2563eb' }). If omitted, uses theme chart colors."
+        }
+      },
+      required: ["chartType", "data", "dataKeys"]
+    },
+    displayType: "chart",
+    execute: async (args) => {
+      const chartType = args.chartType;
+      const data = args.data;
+      const dataKeys = args.dataKeys;
+      if (!chartType || !["bar", "line", "area", "pie"].includes(chartType)) {
+        return { error: `Unsupported chart type: ${chartType}` };
+      }
+      if (!data || !Array.isArray(data) || data.length === 0) {
+        return { error: "Invalid or empty chart data" };
+      }
+      if (!dataKeys || !Array.isArray(dataKeys) || dataKeys.length === 0) {
+        return { error: "No data keys specified for charting" };
+      }
+      return {
+        chartType,
+        title: args.title,
+        data,
+        dataKeys,
+        xAxisKey: args.xAxisKey,
+        colors: args.colors
+      };
+    }
+  });
+}
+
+// src/tools/googleDrive.ts
+async function searchDriveFiles(accessToken, args) {
+  const { query, maxResults = 10, mimeType } = args;
+  let driveQuery = `fullText contains '${query.replace(/'/g, "\\'")}'`;
+  if (mimeType) {
+    driveQuery += ` and mimeType = '${mimeType}'`;
+  }
+  driveQuery += " and trashed = false";
+  const params = new URLSearchParams({
+    q: driveQuery,
+    pageSize: String(maxResults),
+    fields: "files(id,name,mimeType,webViewLink,modifiedTime,size,owners)",
+    orderBy: "modifiedTime desc"
+  });
+  try {
+    const response = await fetch(`https://www.googleapis.com/drive/v3/files?${params.toString()}`, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      if (response.status === 401) {
+        return "Error: Google Drive access not authorized. Please grant Drive permissions.";
+      }
+      if (response.status === 403) {
+        return "Error: Insufficient permissions to access Google Drive. Please grant read access to your Drive.";
+      }
+      const errorText = await response.text();
+      return `Error: Failed to search Google Drive (${response.status}): ${errorText}`;
+    }
+    const data = await response.json();
+    const files = (data.files || []).map((file) => ({
+      id: file.id,
+      name: file.name,
+      mimeType: file.mimeType,
+      webViewLink: file.webViewLink,
+      modifiedTime: file.modifiedTime,
+      size: file.size,
+      owners: file.owners
+    }));
+    if (files.length === 0) {
+      return `No files found matching "${query}"`;
+    }
+    return files;
+  } catch (error) {
+    return `Error: ${error instanceof Error ? error.message : "Unknown error occurred"}`;
+  }
+}
+function createGoogleDriveSearchTool(getAccessToken, requestDriveAccess) {
+  return {
+    type: "function",
+    function: {
+      name: "google_drive_search",
+      description: "Searches for files in the user's Google Drive. Returns matching files with their names, types, and links. Use this to help users find documents, spreadsheets, presentations, PDFs, and other files stored in their Drive.",
+      arguments: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: 'The search query to find files. Searches in file names and content. Examples: "quarterly report", "budget 2024", "meeting notes".'
+          },
+          maxResults: {
+            type: "number",
+            description: "Maximum number of files to return. Defaults to 10. Maximum is 100."
+          },
+          mimeType: {
+            type: "string",
+            description: 'Optional MIME type filter. Common types: "application/vnd.google-apps.document" (Google Docs), "application/vnd.google-apps.spreadsheet" (Sheets), "application/vnd.google-apps.presentation" (Slides), "application/pdf" (PDF files).'
+          }
+        },
+        required: ["query"]
+      }
+    },
+    executor: async (args) => {
+      let token = getAccessToken();
+      if (!token) {
+        try {
+          token = await requestDriveAccess();
+        } catch {
+          return "Error: Failed to get Google Drive access. Please grant permissions when prompted.";
+        }
+      }
+      if (!token) {
+        return "Error: No Google Drive access token available. Please connect your Google account.";
+      }
+      const typedArgs = {
+        query: args.query,
+        maxResults: args.maxResults,
+        mimeType: args.mimeType
+      };
+      return searchDriveFiles(token, typedArgs);
+    },
+    autoExecute: true
+  };
+}
+async function listRecentDriveFiles(accessToken, args) {
+  const { maxResults = 10, mimeType } = args;
+  let driveQuery = "trashed = false";
+  if (mimeType) {
+    driveQuery += ` and mimeType = '${mimeType}'`;
+  }
+  const params = new URLSearchParams({
+    q: driveQuery,
+    pageSize: String(maxResults),
+    fields: "files(id,name,mimeType,webViewLink,modifiedTime,size,owners)",
+    orderBy: "modifiedTime desc"
+  });
+  try {
+    const response = await fetch(`https://www.googleapis.com/drive/v3/files?${params.toString()}`, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      if (response.status === 401) {
+        return "Error: Google Drive access not authorized. Please grant Drive permissions.";
+      }
+      if (response.status === 403) {
+        return "Error: Insufficient permissions to access Google Drive. Please grant read access to your Drive.";
+      }
+      const errorText = await response.text();
+      return `Error: Failed to list Google Drive files (${response.status}): ${errorText}`;
+    }
+    const data = await response.json();
+    const files = (data.files || []).map((file) => ({
+      id: file.id,
+      name: file.name,
+      mimeType: file.mimeType,
+      webViewLink: file.webViewLink,
+      modifiedTime: file.modifiedTime,
+      size: file.size,
+      owners: file.owners
+    }));
+    if (files.length === 0) {
+      return "No recent files found in your Google Drive.";
+    }
+    return files;
+  } catch (error) {
+    return `Error: ${error instanceof Error ? error.message : "Unknown error occurred"}`;
+  }
+}
+function createGoogleDriveListRecentTool(getAccessToken, requestDriveAccess) {
+  return {
+    type: "function",
+    function: {
+      name: "google_drive_list_recent",
+      description: "Lists recent files from the user's Google Drive, ordered by last modified date. Use this when the user wants to see their recent files without a specific search query.",
+      arguments: {
+        type: "object",
+        properties: {
+          maxResults: {
+            type: "number",
+            description: "Maximum number of files to return. Defaults to 10. Maximum is 100."
+          },
+          mimeType: {
+            type: "string",
+            description: 'Optional MIME type filter. Common types: "application/vnd.google-apps.document" (Google Docs), "application/vnd.google-apps.spreadsheet" (Sheets), "application/vnd.google-apps.presentation" (Slides), "application/pdf" (PDF files).'
+          }
+        },
+        required: []
+      }
+    },
+    executor: async (args) => {
+      let token = getAccessToken();
+      if (!token) {
+        try {
+          token = await requestDriveAccess();
+        } catch {
+          return "Error: Failed to get Google Drive access. Please grant permissions when prompted.";
+        }
+      }
+      if (!token) {
+        return "Error: No Google Drive access token available. Please connect your Google account.";
+      }
+      const typedArgs = {
+        maxResults: args.maxResults,
+        mimeType: args.mimeType
+      };
+      return listRecentDriveFiles(token, typedArgs);
+    },
+    autoExecute: true
+  };
+}
+async function findFileByName(accessToken, fileName) {
+  const driveQuery = `name contains '${fileName.replace(/'/g, "\\'")}' and trashed = false`;
+  const params = new URLSearchParams({
+    q: driveQuery,
+    pageSize: "1",
+    fields: "files(id,name)",
+    orderBy: "modifiedTime desc"
+  });
+  const response = await fetch(`https://www.googleapis.com/drive/v3/files?${params.toString()}`, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json"
+    }
+  });
+  if (!response.ok) {
+    return null;
+  }
+  const data = await response.json();
+  return data.files?.[0]?.id || null;
+}
+var GOOGLE_DOCS_EXPORT_TYPES = {
+  "application/vnd.google-apps.document": "text/plain",
+  "application/vnd.google-apps.spreadsheet": "text/csv",
+  "application/vnd.google-apps.presentation": "text/plain"
+};
+var MAX_CONTENT_LENGTH = 5e4;
+async function resolveFileId(accessToken, fileId, fileName) {
+  if (fileId) {
+    return { fileId };
+  }
+  if (fileName) {
+    console.log("[google_drive_get_content] Searching for file by name:", fileName);
+    const foundId = await findFileByName(accessToken, fileName);
+    if (!foundId) {
+      return {
+        error: `Error: Could not find a file matching "${fileName}". Please check the file name and try again.`
+      };
+    }
+    console.log("[google_drive_get_content] Found file ID:", foundId);
+    return { fileId: foundId };
+  }
+  return { error: "Error: Please provide either a fileId or fileName to get file content." };
+}
+async function fetchFileMetadata(accessToken, fileId) {
+  const response = await fetch(
+    `https://www.googleapis.com/drive/v3/files/${fileId}?fields=id,name,mimeType,webViewLink`,
+    { headers: { Authorization: `Bearer ${accessToken}` } }
+  );
+  if (!response.ok) {
+    if (response.status === 404) {
+      return { error: "Error: File not found. Please check the file ID." };
+    }
+    return { error: `Error: Failed to get file metadata (${response.status})` };
+  }
+  const data = await response.json();
+  return {
+    metadata: { name: data.name, mimeType: data.mimeType, webViewLink: data.webViewLink }
+  };
+}
+function getContentUrl(fileId, mimeType) {
+  if (GOOGLE_DOCS_EXPORT_TYPES[mimeType]) {
+    const exportMimeType = GOOGLE_DOCS_EXPORT_TYPES[mimeType];
+    return {
+      url: `https://www.googleapis.com/drive/v3/files/${fileId}/export?mimeType=${encodeURIComponent(exportMimeType)}`,
+      isExport: true
+    };
+  }
+  if (mimeType.startsWith("text/") || mimeType === "application/json" || mimeType === "application/xml") {
+    return {
+      url: `https://www.googleapis.com/drive/v3/files/${fileId}?alt=media`,
+      isExport: false
+    };
+  }
+  return null;
+}
+function formatNonTextFileResponse(fileId, metadata) {
+  const { name, mimeType, webViewLink } = metadata;
+  const linkInfo = webViewLink ? `
+View in Google Drive: ${webViewLink}` : "";
+  if (mimeType === "application/pdf") {
+    return `File: ${name}
+Type: PDF${linkInfo}
+
+Note: PDF content cannot be extracted directly in the browser. The user can click the link above to view the PDF in Google Drive.`;
+  }
+  if (mimeType.startsWith("image/")) {
+    const directUrl = `https://drive.google.com/uc?export=view&id=${fileId}`;
+    return `File: ${name}
+Type: ${mimeType}${linkInfo}
+Direct image URL: ${directUrl}
+
+To view this image, click the Google Drive link above or use the direct URL.`;
+  }
+  return `File: ${name}
+Type: ${mimeType}${linkInfo}
+
+Note: This file type cannot be displayed as text.`;
+}
+async function fetchAndFormatContent(accessToken, contentUrl, metadata, isExport) {
+  const response = await fetch(contentUrl, {
+    headers: { Authorization: `Bearer ${accessToken}` }
+  });
+  if (!response.ok) {
+    if (response.status === 403) {
+      return `Error: Permission denied. You may not have access to view this file's content.`;
+    }
+    return `Error: Failed to get file content (${response.status})`;
+  }
+  const content = await response.text();
+  const truncated = content.length > MAX_CONTENT_LENGTH;
+  const displayContent = truncated ? content.slice(0, MAX_CONTENT_LENGTH) : content;
+  const header = `=== File: ${metadata.name} ===
+Type: ${metadata.mimeType}${isExport ? " (exported as text)" : ""}
+
+`;
+  const footer = truncated ? `
+
+... (content truncated, showing first ${MAX_CONTENT_LENGTH} characters of ${content.length})` : "";
+  return header + displayContent + footer;
+}
+async function getDriveFileContent(accessToken, args) {
+  console.log("[google_drive_get_content] Starting with:", args);
+  const fileIdResult = await resolveFileId(accessToken, args.fileId, args.fileName);
+  if ("error" in fileIdResult) {
+    return fileIdResult.error;
+  }
+  const { fileId } = fileIdResult;
+  try {
+    const metadataResult = await fetchFileMetadata(accessToken, fileId);
+    if ("error" in metadataResult) {
+      return metadataResult.error;
+    }
+    const { metadata } = metadataResult;
+    console.log("[google_drive_get_content] File metadata:", metadata);
+    const contentUrlResult = getContentUrl(fileId, metadata.mimeType);
+    if (!contentUrlResult) {
+      return formatNonTextFileResponse(fileId, metadata);
+    }
+    return fetchAndFormatContent(
+      accessToken,
+      contentUrlResult.url,
+      metadata,
+      contentUrlResult.isExport
+    );
+  } catch (error) {
+    return `Error: ${error instanceof Error ? error.message : "Unknown error occurred"}`;
+  }
+}
+function createGoogleDriveGetContentTool(getAccessToken, requestDriveAccess) {
+  return {
+    type: "function",
+    function: {
+      name: "google_drive_get_content",
+      description: "Gets the text content of a file from the user's Google Drive. Works with Google Docs, Sheets, Slides (exported as text/CSV), and text-based files. You can provide either a fileId (from a previous search) or a fileName to search for.",
+      arguments: {
+        type: "object",
+        properties: {
+          fileId: {
+            type: "string",
+            description: "The unique file ID from Google Drive. Use this if you have the ID from a previous search result."
+          },
+          fileName: {
+            type: "string",
+            description: "The name (or partial name) of the file to find and read. Use this when you know the file name but not the ID."
+          }
+        },
+        required: []
+      }
+    },
+    executor: async (args) => {
+      console.log("[google_drive_get_content] Executor called with args:", args);
+      let token = getAccessToken();
+      if (!token) {
+        console.log("[google_drive_get_content] No token, requesting access...");
+        try {
+          token = await requestDriveAccess();
+        } catch {
+          return "Error: Failed to get Google Drive access. Please grant permissions when prompted.";
+        }
+      }
+      if (!token) {
+        return "Error: No Google Drive access token available. Please connect your Google account.";
+      }
+      const typedArgs = {
+        fileId: args.fileId,
+        fileName: args.fileName
+      };
+      const result = await getDriveFileContent(token, typedArgs);
+      console.log(
+        "[google_drive_get_content] Result length:",
+        result.length,
+        "First 200 chars:",
+        result.slice(0, 200)
+      );
+      return result;
+    },
+    autoExecute: true
+  };
+}
+function createDriveTools(getAccessToken, requestDriveAccess) {
+  return [
+    createGoogleDriveSearchTool(getAccessToken, requestDriveAccess),
+    createGoogleDriveListRecentTool(getAccessToken, requestDriveAccess),
+    createGoogleDriveGetContentTool(getAccessToken, requestDriveAccess)
+  ];
+}
+
+// src/tools/notion.ts
+var MCP_HTTP_ENDPOINT = "https://mcp.notion.com/mcp";
+var MCP_SSE_ENDPOINT = "https://mcp.notion.com/sse";
+var requestIdCounter = Math.floor(Math.random() * 1e6);
+var sessionCache = /* @__PURE__ */ new Map();
+function generateRequestId() {
+  return ++requestIdCounter;
+}
+function parseSSEResponse(text) {
+  const events = text.split(/\n\n+/);
+  let lastEventData = "";
+  for (const event of events) {
+    const dataLines = [];
+    for (const line of event.split("\n")) {
+      if (line.startsWith("data: ")) {
+        dataLines.push(line.slice(6));
+      } else if (line.startsWith("data:")) {
+        dataLines.push(line.slice(5));
+      }
+    }
+    if (dataLines.length > 0) {
+      lastEventData = dataLines.join("\n");
+    }
+  }
+  if (!lastEventData) {
+    throw new Error("No data found in SSE response");
+  }
+  return JSON.parse(lastEventData);
+}
+async function parseResponseBody(response) {
+  const contentType = response.headers.get("Content-Type") || "";
+  const text = await response.text();
+  if (contentType.includes("text/event-stream") || text.startsWith("event:") || text.startsWith("data:")) {
+    return parseSSEResponse(text);
+  }
+  return JSON.parse(text);
+}
+async function initializeMCPSession(accessToken) {
+  const requestId = generateRequestId();
+  const initRequest = {
+    jsonrpc: "2.0",
+    id: requestId,
+    method: "initialize",
+    params: {
+      protocolVersion: "2024-11-05",
+      capabilities: {},
+      clientInfo: {
+        name: "Anuma",
+        version: "1.0.0"
+      }
+    }
+  };
+  const response = await fetch(MCP_HTTP_ENDPOINT, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream",
+      Authorization: `Bearer ${accessToken}`
+    },
+    body: JSON.stringify(initRequest)
+  });
+  if (!response.ok) {
+    const errorBody = await response.text().catch(() => "");
+    throw new Error(
+      `MCP initialization failed: ${response.status} ${response.statusText}${errorBody ? ` - ${errorBody}` : ""}`
+    );
+  }
+  const sessionId = response.headers.get("Mcp-Session-Id");
+  if (!sessionId) {
+    throw new Error("No Mcp-Session-Id returned from initialization");
+  }
+  const jsonRpcResponse = await parseResponseBody(response);
+  if (jsonRpcResponse.error) {
+    const err = jsonRpcResponse.error;
+    throw new Error(`MCP initialization error: ${err.message || JSON.stringify(err)}`);
+  }
+  await fetch(MCP_HTTP_ENDPOINT, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${accessToken}`,
+      "Mcp-Session-Id": sessionId
+    },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      method: "notifications/initialized"
+    })
+  });
+  sessionCache.set(accessToken, sessionId);
+  return sessionId;
+}
+async function ensureMCPSession(accessToken) {
+  const cached = sessionCache.get(accessToken);
+  if (cached) {
+    return cached;
+  }
+  return initializeMCPSession(accessToken);
+}
+async function callMCPTool(accessToken, toolName, args) {
+  const sessionId = await ensureMCPSession(accessToken);
+  const requestId = generateRequestId();
+  const jsonRpcRequest = {
+    jsonrpc: "2.0",
+    id: requestId,
+    method: "tools/call",
+    params: {
+      name: toolName,
+      arguments: args
+    }
+  };
+  const response = await fetch(MCP_HTTP_ENDPOINT, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json, text/event-stream",
+      Authorization: `Bearer ${accessToken}`,
+      "Mcp-Session-Id": sessionId
+    },
+    body: JSON.stringify(jsonRpcRequest)
+  });
+  if (!response.ok) {
+    if (response.status === 400 || response.status === 401) {
+      sessionCache.delete(accessToken);
+      const newSessionId = await initializeMCPSession(accessToken);
+      const retryResponse = await fetch(MCP_HTTP_ENDPOINT, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Accept: "application/json, text/event-stream",
+          Authorization: `Bearer ${accessToken}`,
+          "Mcp-Session-Id": newSessionId
+        },
+        body: JSON.stringify(jsonRpcRequest)
+      });
+      if (!retryResponse.ok) {
+        const errorBody2 = await retryResponse.text().catch(() => "");
+        throw new Error(
+          `MCP request failed: ${retryResponse.status} ${retryResponse.statusText}${errorBody2 ? ` - ${errorBody2}` : ""}`
+        );
+      }
+      const retryJsonRpcResponse = await parseResponseBody(retryResponse);
+      if (retryJsonRpcResponse.error) {
+        const err = retryJsonRpcResponse.error;
+        throw new Error(`MCP tool error: ${err.message || JSON.stringify(err)}`);
+      }
+      return retryJsonRpcResponse.result;
+    }
+    const errorBody = await response.text().catch(() => "");
+    throw new Error(
+      `MCP request failed: ${response.status} ${response.statusText}${errorBody ? ` - ${errorBody}` : ""}`
+    );
+  }
+  const jsonRpcResponse = await parseResponseBody(response);
+  if (jsonRpcResponse.error) {
+    const err = jsonRpcResponse.error;
+    throw new Error(`MCP tool error: ${err.message || JSON.stringify(err)}`);
+  }
+  return jsonRpcResponse.result;
+}
+function createNotionSearchTool(getAccessToken, requestNotionAccess) {
+  return {
+    type: "function",
+    function: {
+      name: "notion-search",
+      description: "Semantic search over Notion workspace and connected sources (Slack, Google Drive, Github, Jira, etc). Can also search for users by name or email.",
+      arguments: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Semantic search query over workspace and connected sources. For user search, a substring to match against name or email."
+          },
+          query_type: {
+            type: "string",
+            enum: ["internal", "user"],
+            description: "Type of search: 'internal' for workspace/content search, 'user' for user search"
+          },
+          content_search_mode: {
+            type: "string",
+            enum: ["workspace_search", "ai_search"],
+            description: "Override auto-selection of AI search vs workspace search"
+          },
+          data_source_url: {
+            type: "string",
+            description: "URL of a data source to search within"
+          },
+          page_url: {
+            type: "string",
+            description: "URL or ID of a page to search within"
+          },
+          teamspace_id: {
+            type: "string",
+            description: "ID of a teamspace to restrict search results to"
+          },
+          filters: {
+            type: "object",
+            description: "Filters for search results (only for query_type 'internal'). Supports created_date_range {start_date, end_date} and created_by_user_ids array."
+          }
+        },
+        required: ["query"]
+      }
+    },
+    executor: async (args) => {
+      let token = getAccessToken();
+      if (!token) {
+        token = await requestNotionAccess();
+      }
+      try {
+        return await callMCPTool(token, "notion-search", args);
+      } catch (error) {
+        return `Error searching Notion: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    autoExecute: true
+  };
+}
+function createNotionFetchTool(getAccessToken, requestNotionAccess) {
+  return {
+    type: "function",
+    function: {
+      name: "notion-fetch",
+      description: "Retrieve a Notion page or database by URL or ID. Pages return enhanced Markdown. Databases return all data sources.",
+      arguments: {
+        type: "object",
+        properties: {
+          id: {
+            type: "string",
+            description: "The ID or URL of the Notion page/database. Supports notion.so URLs, Notion Sites URLs (*.notion.site), and raw UUIDs."
+          },
+          include_transcript: {
+            type: "boolean",
+            description: "Include transcript if available"
+          },
+          include_discussions: {
+            type: "boolean",
+            description: "Include discussion counts and inline discussion markers"
+          }
+        },
+        required: ["id"]
+      }
+    },
+    executor: async (args) => {
+      let token = getAccessToken();
+      if (!token) {
+        token = await requestNotionAccess();
+      }
+      try {
+        return await callMCPTool(token, "notion-fetch", args);
+      } catch (error) {
+        return `Error fetching Notion page: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    autoExecute: true
+  };
+}
+function createNotionCreatePagesTool(getAccessToken, requestNotionAccess) {
+  return {
+    type: "function",
+    function: {
+      name: "notion-create-pages",
+      description: "Create one or more Notion pages. All pages in a single call share the same parent. Properties use simplified format: title is a string, dates use date:{prop}:start format, checkboxes use __YES__/__NO__. Content is Notion-flavored Markdown.",
+      arguments: {
+        type: "object",
+        properties: {
+          pages: {
+            type: "array",
+            description: "Array of page objects to create (max 100)",
+            items: {
+              type: "object",
+              properties: {
+                properties: {
+                  type: "object",
+                  description: "JSON map of property names to values. Title is a string, numbers are JS numbers, checkboxes use __YES__/__NO__, dates use date:{prop}:start/end/is_datetime format."
+                },
+                content: {
+                  type: "string",
+                  description: "Page content in Notion-flavored Markdown format"
+                }
+              },
+              required: ["properties", "content"]
+            }
+          },
+          parent: {
+            type: "object",
+            description: "Parent for all pages. Use {type:'page_id', page_id:'...'}, {type:'database_id', database_id:'...'}, or {type:'data_source_id', data_source_id:'...'}. Do NOT pass this field to create standalone private pages."
+          }
+        },
+        required: ["pages"]
+      }
+    },
+    executor: async (args) => {
+      let token = getAccessToken();
+      if (!token) {
+        token = await requestNotionAccess();
+      }
+      try {
+        return await callMCPTool(token, "notion-create-pages", args);
+      } catch (error) {
+        return `Error creating Notion page: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    autoExecute: true
+  };
+}
+function createNotionUpdatePageTool(getAccessToken, requestNotionAccess) {
+  return {
+    type: "function",
+    function: {
+      name: "notion-update-page",
+      description: "Update a Notion page's properties or content. Uses command-based operations: 'update_properties' to change properties, 'replace_content' to replace all content, 'replace_content_range' to replace specific text, 'insert_content_after' to insert after text.",
+      arguments: {
+        type: "object",
+        properties: {
+          data: {
+            type: "object",
+            description: "Update data containing page_id and a command",
+            properties: {
+              page_id: {
+                type: "string",
+                description: "The ID of the page to update (with or without dashes)"
+              },
+              command: {
+                type: "string",
+                enum: [
+                  "update_properties",
+                  "replace_content",
+                  "replace_content_range",
+                  "insert_content_after"
+                ],
+                description: "The update command to execute"
+              },
+              properties: {
+                type: "object",
+                description: "For update_properties: JSON map of property names to values. Use null to remove a value."
+              },
+              new_str: {
+                type: "string",
+                description: "For replace_content/replace_content_range/insert_content_after: the new content string"
+              },
+              selection_with_ellipsis: {
+                type: "string",
+                description: "For replace_content_range/insert_content_after: unique start and end snippet (~10 chars each with ellipsis)"
+              },
+              allow_deleting_content: {
+                type: "boolean",
+                description: "For replace_content/replace_content_range: allow deletion of child pages/databases"
+              }
+            },
+            required: ["page_id", "command"]
+          }
+        },
+        required: ["data"]
+      }
+    },
+    executor: async (args) => {
+      let token = getAccessToken();
+      if (!token) {
+        token = await requestNotionAccess();
+      }
+      try {
+        return await callMCPTool(token, "notion-update-page", args);
+      } catch (error) {
+        return `Error updating Notion page: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    autoExecute: true
+  };
+}
+function createNotionMovePagesTool(getAccessToken, requestNotionAccess) {
+  return {
+    type: "function",
+    function: {
+      name: "notion-move-pages",
+      description: "Move one or more Notion pages or databases to a new parent.",
+      arguments: {
+        type: "object",
+        properties: {
+          page_or_database_ids: {
+            type: "array",
+            description: "Array of page or database IDs to move (UUIDs, max 100)",
+            items: { type: "string" }
+          },
+          new_parent: {
+            type: "object",
+            description: "New parent: {type:'page_id', page_id:'...'}, {type:'database_id', database_id:'...'}, {type:'data_source_id', data_source_id:'...'}, or {type:'workspace'} for private pages."
+          }
+        },
+        required: ["page_or_database_ids", "new_parent"]
+      }
+    },
+    executor: async (args) => {
+      let token = getAccessToken();
+      if (!token) {
+        token = await requestNotionAccess();
+      }
+      try {
+        return await callMCPTool(token, "notion-move-pages", args);
+      } catch (error) {
+        return `Error moving Notion pages: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    autoExecute: true
+  };
+}
+function createNotionDuplicatePageTool(getAccessToken, requestNotionAccess) {
+  return {
+    type: "function",
+    function: {
+      name: "notion-duplicate-page",
+      description: "Duplicate a Notion page. The duplication completes asynchronously.",
+      arguments: {
+        type: "object",
+        properties: {
+          page_id: {
+            type: "string",
+            description: "The ID of the page to duplicate (UUID with or without dashes)"
+          }
+        },
+        required: ["page_id"]
+      }
+    },
+    executor: async (args) => {
+      let token = getAccessToken();
+      if (!token) {
+        token = await requestNotionAccess();
+      }
+      try {
+        return await callMCPTool(token, "notion-duplicate-page", args);
+      } catch (error) {
+        return `Error duplicating Notion page: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    autoExecute: true
+  };
+}
+function createNotionCreateDatabaseTool(getAccessToken, requestNotionAccess) {
+  return {
+    type: "function",
+    function: {
+      name: "notion-create-database",
+      description: "Create a new Notion database with a properties schema. If no title property is provided, 'Name' is auto-added. Supports property types: title, rich_text, number, select, multi_select, date, people, checkbox, url, email, phone_number, formula, relation, rollup, status, unique_id, etc.",
+      arguments: {
+        type: "object",
+        properties: {
+          properties: {
+            type: "object",
+            description: "Property schema for the database. Each key is a property name, value defines the type."
+          },
+          parent: {
+            type: "object",
+            description: "Parent page: {type:'page_id', page_id:'...'}. Omit for private workspace-level database."
+          },
+          title: {
+            type: "array",
+            description: "Title of the database as rich text array (max 100)",
+            items: { type: "object" }
+          },
+          description: {
+            type: "array",
+            description: "Description of the database as rich text array (max 100)",
+            items: { type: "object" }
+          }
+        },
+        required: ["properties"]
+      }
+    },
+    executor: async (args) => {
+      let token = getAccessToken();
+      if (!token) {
+        token = await requestNotionAccess();
+      }
+      try {
+        return await callMCPTool(token, "notion-create-database", args);
+      } catch (error) {
+        return `Error creating Notion database: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    autoExecute: true
+  };
+}
+function createNotionUpdateDataSourceTool(getAccessToken, requestNotionAccess) {
+  return {
+    type: "function",
+    function: {
+      name: "notion-update-data-source",
+      description: "Update a Notion data source's title, description, property schema, or other attributes. Use null to remove a property. Provide only 'name' to rename a property.",
+      arguments: {
+        type: "object",
+        properties: {
+          data_source_id: {
+            type: "string",
+            description: "The ID of the data source to update (UUID). Can be a data source ID or database ID."
+          },
+          title: {
+            type: "array",
+            description: "New title as rich text array (max 100)",
+            items: { type: "object" }
+          },
+          description: {
+            type: "array",
+            description: "New description as rich text array (max 100)",
+            items: { type: "object" }
+          },
+          properties: {
+            type: "object",
+            description: "Property schema updates. Use null to remove, {name:'...'} to rename, or full definition to add/update."
+          },
+          is_inline: {
+            type: "boolean",
+            description: "Whether the database is inline"
+          },
+          in_trash: {
+            type: "boolean",
+            description: "Trash the data source (requires Notion UI to undo)"
+          }
+        },
+        required: ["data_source_id"]
+      }
+    },
+    executor: async (args) => {
+      let token = getAccessToken();
+      if (!token) {
+        token = await requestNotionAccess();
+      }
+      try {
+        return await callMCPTool(token, "notion-update-data-source", args);
+      } catch (error) {
+        return `Error updating Notion data source: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    autoExecute: true
+  };
+}
+function createNotionCreateCommentTool(getAccessToken, requestNotionAccess) {
+  return {
+    type: "function",
+    function: {
+      name: "notion-create-comment",
+      description: "Add a comment to a Notion page. Supports page-level comments, content-specific comments (using selection_with_ellipsis), or replies to existing discussions (using discussion_id).",
+      arguments: {
+        type: "object",
+        properties: {
+          page_id: {
+            type: "string",
+            description: "The ID of the page to comment on (with or without dashes)"
+          },
+          rich_text: {
+            type: "array",
+            description: "Comment content as rich text array (max 100). Objects can be text, mention, or equation.",
+            items: {
+              type: "object",
+              properties: {
+                text: {
+                  type: "object",
+                  properties: {
+                    content: { type: "string" }
+                  },
+                  required: ["content"]
+                }
+              },
+              required: ["text"]
+            }
+          },
+          discussion_id: {
+            type: "string",
+            description: "ID or URL of an existing discussion to reply to"
+          },
+          selection_with_ellipsis: {
+            type: "string",
+            description: "Unique start and end snippet (~10 chars each with ellipsis) of content to comment on"
+          }
+        },
+        required: ["page_id", "rich_text"]
+      }
+    },
+    executor: async (args) => {
+      let token = getAccessToken();
+      if (!token) {
+        token = await requestNotionAccess();
+      }
+      try {
+        return await callMCPTool(token, "notion-create-comment", args);
+      } catch (error) {
+        return `Error creating Notion comment: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    autoExecute: true
+  };
+}
+function createNotionGetCommentsTool(getAccessToken, requestNotionAccess) {
+  return {
+    type: "function",
+    function: {
+      name: "notion-get-comments",
+      description: "Get comments and discussions from a Notion page. Returns discussions with full comment content.",
+      arguments: {
+        type: "object",
+        properties: {
+          page_id: {
+            type: "string",
+            description: "Identifier for the Notion page"
+          },
+          include_all_blocks: {
+            type: "boolean",
+            description: "Include discussions on child blocks (default: false)"
+          },
+          include_resolved: {
+            type: "boolean",
+            description: "Include resolved discussions (default: false)"
+          },
+          discussion_id: {
+            type: "string",
+            description: "Fetch a specific discussion by ID or URL (e.g., discussion://pageId/blockId/discussionId)"
+          }
+        },
+        required: ["page_id"]
+      }
+    },
+    executor: async (args) => {
+      let token = getAccessToken();
+      if (!token) {
+        token = await requestNotionAccess();
+      }
+      try {
+        return await callMCPTool(token, "notion-get-comments", args);
+      } catch (error) {
+        return `Error retrieving Notion comments: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    autoExecute: true
+  };
+}
+function createNotionGetUsersTool(getAccessToken, requestNotionAccess) {
+  return {
+    type: "function",
+    function: {
+      name: "notion-get-users",
+      description: "List users in the Notion workspace. Supports filtering by name/email, pagination, fetching a specific user by ID, or fetching the current bot user (user_id: 'self').",
+      arguments: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Search query to filter users by name or email (case-insensitive, max 100 chars)"
+          },
+          start_cursor: {
+            type: "string",
+            description: "Cursor for pagination from previous response"
+          },
+          page_size: {
+            type: "integer",
+            description: "Number of users per page (1-100, default 100)"
+          },
+          user_id: {
+            type: "string",
+            description: "Return only the user matching this ID. Pass 'self' to fetch the current bot user."
+          }
+        }
+      }
+    },
+    executor: async (args) => {
+      let token = getAccessToken();
+      if (!token) {
+        token = await requestNotionAccess();
+      }
+      try {
+        return await callMCPTool(token, "notion-get-users", args);
+      } catch (error) {
+        return `Error listing Notion users: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    autoExecute: true
+  };
+}
+function createNotionGetTeamsTool(getAccessToken, requestNotionAccess) {
+  return {
+    type: "function",
+    function: {
+      name: "notion-get-teams",
+      description: "Retrieve teams (teamspaces) in the Notion workspace. Shows team names, IDs, membership status, and roles.",
+      arguments: {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Search query to filter teams by name (case-insensitive, max 100 chars)"
+          }
+        }
+      }
+    },
+    executor: async (args) => {
+      let token = getAccessToken();
+      if (!token) {
+        token = await requestNotionAccess();
+      }
+      try {
+        return await callMCPTool(token, "notion-get-teams", args);
+      } catch (error) {
+        return `Error retrieving Notion teams: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+    autoExecute: true
+  };
+}
+function createNotionTools(getAccessToken, requestNotionAccess) {
+  return [
+    // Search
+    createNotionSearchTool(getAccessToken, requestNotionAccess),
+    // Pages
+    createNotionFetchTool(getAccessToken, requestNotionAccess),
+    createNotionCreatePagesTool(getAccessToken, requestNotionAccess),
+    createNotionUpdatePageTool(getAccessToken, requestNotionAccess),
+    createNotionMovePagesTool(getAccessToken, requestNotionAccess),
+    createNotionDuplicatePageTool(getAccessToken, requestNotionAccess),
+    // Data Sources (Databases)
+    createNotionCreateDatabaseTool(getAccessToken, requestNotionAccess),
+    createNotionUpdateDataSourceTool(getAccessToken, requestNotionAccess),
+    // Comments
+    createNotionCreateCommentTool(getAccessToken, requestNotionAccess),
+    createNotionGetCommentsTool(getAccessToken, requestNotionAccess),
+    // Users & Teams
+    createNotionGetUsersTool(getAccessToken, requestNotionAccess),
+    createNotionGetTeamsTool(getAccessToken, requestNotionAccess)
+  ];
+}
+function getMCPEndpoints() {
+  return {
+    http: MCP_HTTP_ENDPOINT,
+    sse: MCP_SSE_ENDPOINT
+  };
+}
+async function callNotionMCPTool(accessToken, toolName, args) {
+  return callMCPTool(accessToken, toolName, args);
+}
+export {
+  callNotionMCPTool,
+  createChartTool,
+  createChatTools,
+  createDisplayTool,
+  createDriveTools,
+  createGoogleCalendarCreateEventTool,
+  createGoogleCalendarTool,
+  createGoogleCalendarUpdateEventTool,
+  createGoogleDriveGetContentTool,
+  createGoogleDriveListRecentTool,
+  createGoogleDriveSearchTool,
+  createInteractiveTool,
+  createNotionCreateCommentTool,
+  createNotionCreateDatabaseTool,
+  createNotionCreatePagesTool,
+  createNotionDuplicatePageTool,
+  createNotionFetchTool,
+  createNotionGetCommentsTool,
+  createNotionGetTeamsTool,
+  createNotionGetUsersTool,
+  createNotionMovePagesTool,
+  createNotionSearchTool,
+  createNotionTools,
+  createNotionUpdateDataSourceTool,
+  createNotionUpdatePageTool,
+  getMCPEndpoints,
+  migrateDisplayResult
+};