@anuma/sdk 1.0.0

package/dist/tools/index.cjs

@@ -0,0 +1,775 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/tools/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createChatTools: () => createChatTools,
+  createDriveTools: () => createDriveTools,
+  createGoogleCalendarCreateEventTool: () => createGoogleCalendarCreateEventTool,
+  createGoogleCalendarTool: () => createGoogleCalendarTool,
+  createGoogleCalendarUpdateEventTool: () => createGoogleCalendarUpdateEventTool,
+  createGoogleDriveGetContentTool: () => createGoogleDriveGetContentTool,
+  createGoogleDriveListRecentTool: () => createGoogleDriveListRecentTool,
+  createGoogleDriveSearchTool: () => createGoogleDriveSearchTool
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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/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)
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createChatTools,
+  createDriveTools,
+  createGoogleCalendarCreateEventTool,
+  createGoogleCalendarTool,
+  createGoogleCalendarUpdateEventTool,
+  createGoogleDriveGetContentTool,
+  createGoogleDriveListRecentTool,
+  createGoogleDriveSearchTool
+});