@credal/actions 0.2.106 → 0.2.108

package/dist/actions/providers/github/listCommits.js

@@ -0,0 +1,73 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import axios from "axios";
+import { githubListCommitsOutputSchema, } from "../../autogen/types.js";
+import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
+const listCommits = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    var _b, _c;
+    const { authToken } = authParams;
+    if (!authToken) {
+        throw new Error(MISSING_AUTH_TOKEN);
+    }
+    const { repositoryName, repositoryOwner, branch, since, until, author, perPage = 30, page = 1 } = params;
+    try {
+        const url = `https://api.github.com/repos/${repositoryOwner}/${repositoryName}/commits`;
+        const requestParams = {
+            per_page: Math.min(perPage, 100), // GitHub API max is 100
+            page,
+        };
+        if (branch) {
+            requestParams.sha = branch;
+        }
+        if (since) {
+            requestParams.since = since;
+        }
+        if (until) {
+            requestParams.until = until;
+        }
+        if (author) {
+            requestParams.author = author;
+        }
+        const response = yield axios.get(url, {
+            headers: {
+                Authorization: `Bearer ${authToken}`,
+                Accept: "application/vnd.github+json",
+                "X-GitHub-Api-Version": "2022-11-28",
+            },
+            params: requestParams,
+        });
+        const commits = response.data;
+        // Transform only the field names that differ between GitHub API and our schema
+        const transformedCommits = commits.map(commit => (Object.assign(Object.assign({}, commit), { htmlUrl: commit.html_url, commit: Object.assign(Object.assign({}, commit.commit), { commentCount: commit.commit.comment_count || 0 }), author: commit.author, parents: commit.parents.map(parent => (Object.assign(Object.assign({}, parent), { htmlUrl: parent.html_url }))) })));
+        // Check if there are more pages by looking at the Link header
+        const linkHeader = response.headers.link;
+        const hasMore = linkHeader ? linkHeader.includes('rel="next"') : false;
+        return githubListCommitsOutputSchema.parse({
+            success: true,
+            commits: transformedCommits,
+            totalCount: commits.length, // Note: GitHub doesn't provide total count in this endpoint
+            hasMore,
+        });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        const responseError = error && typeof error === "object" && "response" in error
+            ? (_c = (_b = error.response) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.message
+            : undefined;
+        return githubListCommitsOutputSchema.parse({
+            success: false,
+            error: responseError || errorMessage || "Failed to list commits",
+            commits: [],
+            totalCount: 0,
+            hasMore: false,
+        });
+    }
+});
+export default listCommits;

package/dist/actions/providers/google-oauth/editAGoogleCalendarEvent.js

@@ -9,9 +9,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { axiosClient } from "../../util/axiosClient.js";
 import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
+import { getDayOfWeek } from "../../../utils/datetime.js";
 const editAGoogleCalendarEvent = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    var _b, _c;
     if (!authParams.authToken) {
-        return { success: false, error: MISSING_AUTH_TOKEN, eventId: "", eventUrl: "" };
+        return { success: false, error: MISSING_AUTH_TOKEN, eventId: "", eventUrl: "", eventDayOfWeek: "" };
     }
     const { calendarId, eventId, title, description, start, end, location, attendees, status, organizer, timeZone } = params;
     const url = `https://www.googleapis.com/calendar/v3/calendars/${encodeURIComponent(calendarId)}/events/${encodeURIComponent(eventId)}`;
@@ -47,10 +49,15 @@ const editAGoogleCalendarEvent = (_a) => __awaiter(void 0, [_a], void 0, functio
             },
         });
         const { id, htmlLink } = res.data;
+        // Get the event day of week from the start time (use provided start or fetch from response)
+        const eventDayOfWeek = start
+            ? getDayOfWeek(start)
+            : getDayOfWeek(((_b = res.data.start) === null || _b === void 0 ? void 0 : _b.dateTime) || ((_c = res.data.start) === null || _c === void 0 ? void 0 : _c.date) || "");
         return {
             success: true,
             eventId: id,
             eventUrl: htmlLink,
+            eventDayOfWeek,
         };
     }
     catch (error) {
@@ -59,6 +66,7 @@ const editAGoogleCalendarEvent = (_a) => __awaiter(void 0, [_a], void 0, functio
             error: error instanceof Error ? error.message : "Unknown error editing event",
             eventId: "",
             eventUrl: "",
+            eventDayOfWeek: "",
         };
     }
 });

package/dist/actions/providers/google-oauth/getDriveContentById.d.ts

@@ -0,0 +1,3 @@
+import type { googleOauthGetDriveFileContentByIDFunction } from "../../autogen/types.js";
+declare const getDriveFileContentByID: googleOauthGetDriveFileContentByIDFunction;
+export default getDriveFileContentByID;

package/dist/actions/providers/google-oauth/getDriveContentById.js

@@ -0,0 +1,161 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import pdf from "pdf-parse/lib/pdf-parse.js";
+import { axiosClient } from "../../util/axiosClient.js";
+import mammoth from "mammoth";
+import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
+const getDriveFileContentByID = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    if (!authParams.authToken) {
+        return { success: false, error: MISSING_AUTH_TOKEN };
+    }
+    const { fileId, limit } = params;
+    try {
+        // First, get file metadata to determine the file type
+        const metadataUrl = `https://www.googleapis.com/drive/v3/files/${encodeURIComponent(fileId)}?fields=name,mimeType,size`;
+        const metadataRes = yield axiosClient.get(metadataUrl, {
+            headers: {
+                Authorization: `Bearer ${authParams.authToken}`,
+            },
+        });
+        const { name: fileName, mimeType, size } = metadataRes.data;
+        // Check if file is too large (50MB limit for safety)
+        if (size && parseInt(size) > 50 * 1024 * 1024) {
+            return {
+                success: false,
+                error: "File too large (>50MB)",
+            };
+        }
+        let content = "";
+        // Handle different file types - read content directly
+        if (mimeType === "application/vnd.google-apps.document") {
+            // Google Docs - download as plain text
+            const downloadUrl = `https://www.googleapis.com/drive/v3/files/${encodeURIComponent(fileId)}?alt=media&format=txt`;
+            const downloadRes = yield axiosClient.get(downloadUrl, {
+                headers: {
+                    Authorization: `Bearer ${authParams.authToken}`,
+                },
+                responseType: 'text',
+            });
+            content = downloadRes.data;
+        }
+        else if (mimeType === "application/vnd.google-apps.spreadsheet") {
+            // Google Sheets - download as CSV
+            const downloadUrl = `https://www.googleapis.com/drive/v3/files/${encodeURIComponent(fileId)}?alt=media&format=csv`;
+            const downloadRes = yield axiosClient.get(downloadUrl, {
+                headers: {
+                    Authorization: `Bearer ${authParams.authToken}`,
+                },
+                responseType: 'text',
+            });
+            content = downloadRes.data;
+        }
+        else if (mimeType === "application/vnd.google-apps.presentation") {
+            // Google Slides - download as plain text
+            const downloadUrl = `https://www.googleapis.com/drive/v3/files/${encodeURIComponent(fileId)}?alt=media&format=txt`;
+            const downloadRes = yield axiosClient.get(downloadUrl, {
+                headers: {
+                    Authorization: `Bearer ${authParams.authToken}`,
+                },
+                responseType: 'text',
+            });
+            content = downloadRes.data;
+        }
+        else if (mimeType === "application/pdf") {
+            // PDF files - use pdf-parse
+            const downloadUrl = `https://www.googleapis.com/drive/v3/files/${encodeURIComponent(fileId)}?alt=media`;
+            const downloadRes = yield axiosClient.get(downloadUrl, {
+                headers: {
+                    Authorization: `Bearer ${authParams.authToken}`,
+                },
+                responseType: 'arraybuffer',
+            });
+            try {
+                const pdfData = yield pdf(downloadRes.data);
+                content = pdfData.text;
+            }
+            catch (pdfError) {
+                return {
+                    success: false,
+                    error: `Failed to parse PDF: ${pdfError instanceof Error ? pdfError.message : 'Unknown PDF error'}`,
+                };
+            }
+        }
+        else if (mimeType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document" ||
+            mimeType === "application/msword") {
+            // Word documents (.docx or .doc) - download and extract text using mammoth
+            const downloadUrl = `https://www.googleapis.com/drive/v3/files/${encodeURIComponent(fileId)}?alt=media`;
+            const downloadRes = yield axiosClient.get(downloadUrl, {
+                headers: {
+                    Authorization: `Bearer ${authParams.authToken}`,
+                },
+                responseType: 'arraybuffer',
+            });
+            try {
+                // mammoth works with .docx files. It will ignore formatting and return raw text
+                const result = yield mammoth.extractRawText({ buffer: Buffer.from(downloadRes.data) });
+                content = result.value; // raw text
+            }
+            catch (wordError) {
+                return {
+                    success: false,
+                    error: `Failed to parse Word document: ${wordError instanceof Error ? wordError.message : 'Unknown Word error'}`,
+                };
+            }
+        }
+        else if (mimeType === "text/plain" ||
+            mimeType === "text/html" ||
+            mimeType === "application/rtf" ||
+            (mimeType === null || mimeType === void 0 ? void 0 : mimeType.startsWith("text/"))) {
+            // Text-based files
+            const downloadUrl = `https://www.googleapis.com/drive/v3/files/${encodeURIComponent(fileId)}?alt=media`;
+            const downloadRes = yield axiosClient.get(downloadUrl, {
+                headers: {
+                    Authorization: `Bearer ${authParams.authToken}`,
+                },
+                responseType: 'text',
+            });
+            content = downloadRes.data;
+        }
+        else if (mimeType === null || mimeType === void 0 ? void 0 : mimeType.startsWith("image/")) {
+            // Skip images
+            return {
+                success: false,
+                error: "Image files are not supported for text extraction",
+            };
+        }
+        else {
+            // Unsupported file type
+            return {
+                success: false,
+                error: `Unsupported file type: ${mimeType}`,
+            };
+        }
+        content = content.trim();
+        const originalLength = content.length;
+        // Naive way to truncate content
+        if (limit && content.length > limit) {
+            content = content.substring(0, limit);
+        }
+        return {
+            success: true,
+            content,
+            fileName,
+            fileLength: originalLength,
+        };
+    }
+    catch (error) {
+        console.error("Error getting Google Drive file content", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+});
+export default getDriveFileContentByID;

package/dist/actions/providers/google-oauth/listCalendarEvents.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { axiosClient } from "../../util/axiosClient.js";
 import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
+import { getDayOfWeek } from "../../../utils/datetime.js";
 const listCalendarEvents = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
     if (!authParams.authToken) {
         return { success: false, error: MISSING_AUTH_TOKEN, events: [] };
@@ -57,7 +58,9 @@ const listCalendarEvents = (_a) => __awaiter(void 0, [_a], void 0, function* ({
                 description,
                 location,
                 start: (start === null || start === void 0 ? void 0 : start.dateTime) || (start === null || start === void 0 ? void 0 : start.date) || "",
+                startDayOfWeek: getDayOfWeek((start === null || start === void 0 ? void 0 : start.dateTime) || (start === null || start === void 0 ? void 0 : start.date) || ""),
                 end: (end === null || end === void 0 ? void 0 : end.dateTime) || (end === null || end === void 0 ? void 0 : end.date) || "",
+                endDayOfWeek: getDayOfWeek((end === null || end === void 0 ? void 0 : end.dateTime) || (end === null || end === void 0 ? void 0 : end.date) || ""),
                 attendees: Array.isArray(attendees)
                     ? attendees.map(({ email, displayName, responseStatus }) => ({
                         email,

package/dist/actions/providers/google-oauth/scheduleCalendarMeeting.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { v4 } from "uuid";
 import { axiosClient } from "../../util/axiosClient.js";
 import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
+import { getDayOfWeek } from "../../../utils/datetime.js";
 /**
  * Creates a new Google calendar event using OAuth authentication
  */
@@ -56,6 +57,7 @@ const scheduleCalendarMeeting = (_a) => __awaiter(void 0, [_a], void 0, function
             success: true,
             eventId: response.data.id,
             eventUrl: response.data.htmlLink,
+            eventDayOfWeek: getDayOfWeek(start),
         };
     }
     catch (error) {

package/dist/actions/providers/google-oauth/searchAndGetDriveContentByKeywords.d.ts

@@ -0,0 +1,3 @@
+import type { googleOauthSearchDriveByKeywordsFunction } from "../../autogen/types.js";
+declare const searchDriveByKeywords: googleOauthSearchDriveByKeywordsFunction;
+export default searchDriveByKeywords;

package/dist/actions/providers/google-oauth/searchAndGetDriveContentByKeywords.js

@@ -0,0 +1,47 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { axiosClient } from "../../util/axiosClient.js";
+import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
+const searchDriveByKeywords = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    var _b;
+    if (!authParams.authToken) {
+        return { success: false, error: MISSING_AUTH_TOKEN, files: [] };
+    }
+    const { keywords, limit } = params;
+    // Build the query: fullText contains 'keyword1' or fullText contains 'keyword2' ...
+    const query = keywords.map(kw => `fullText contains '${kw.replace(/'/g, "\\'")}'`).join(" or ");
+    const url = `https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&fields=files(id,name,mimeType,webViewLink)&supportsAllDrives=true&includeItemsFromAllDrives=true`;
+    // 1. Get the file metadata from google drive search
+    let files = [];
+    try {
+        const res = yield axiosClient.get(url, {
+            headers: {
+                Authorization: `Bearer ${authParams.authToken}`,
+            },
+        });
+        files =
+            ((_b = res.data.files) === null || _b === void 0 ? void 0 : _b.map((file) => ({
+                id: file.id || "",
+                name: file.name || "",
+                mimeType: file.mimeType || "",
+                url: file.webViewLink || "",
+            }))) || [];
+    }
+    catch (error) {
+        console.error("Error searching Google Drive", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+            files: [],
+        };
+    }
+    files = limit ? files.splice(0, limit) : files;
+});
+export default searchDriveByKeywords;

package/dist/actions/providers/google-oauth/searchDriveAndGetContentByKeywords.d.ts

@@ -0,0 +1,3 @@
+import type { googleOauthSearchDriveAndGetContentByKeywordsFunction } from "../../autogen/types.js";
+declare const searchDriveAndGetContentByKeywords: googleOauthSearchDriveAndGetContentByKeywordsFunction;
+export default searchDriveAndGetContentByKeywords;

package/dist/actions/providers/google-oauth/searchDriveAndGetContentByKeywords.js

@@ -0,0 +1,110 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { axiosClient } from "../../util/axiosClient.js";
+import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
+import extractContentFromDriveFileId from "./utils/extractContentFromDriveFileId.js";
+import { normalizeText } from "../../../utils/string.js";
+/** Intelligently selects a section of text around the median occurrence of keywords */
+const intelligentSelectByMedianSection = (text, keywords, limit) => {
+    if (!text || text.length <= limit)
+        return text;
+    if (!(keywords === null || keywords === void 0 ? void 0 : keywords.length))
+        return text.substring(0, limit);
+    // Find all keyword positions (case-insensitive, limited to first 1000 matches)
+    const positions = [];
+    const normalizedText = normalizeText(text);
+    for (const keyword of keywords) {
+        if (keyword.length < 3)
+            continue; // Skip very short keywords
+        let pos = -1;
+        const normalizedKeyword = normalizeText(keyword);
+        while ((pos = normalizedText.indexOf(normalizedKeyword, pos + 1)) !== -1 && positions.length < 1000) {
+            positions.push(pos);
+        }
+    }
+    if (!positions.length)
+        return text.substring(0, limit);
+    // Find median position (using sort for simplicity, still fast for 1000 elements)
+    positions.sort((a, b) => a - b);
+    const medianPos = positions[Math.floor(positions.length / 2)];
+    // Return window around median
+    const half = Math.floor(limit / 2);
+    const start = Math.max(0, medianPos - half);
+    const end = Math.min(text.length, start + limit);
+    return text.substring(start, end);
+};
+const searchDriveAndGetContentByKeywords = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    var _b;
+    if (!authParams.authToken) {
+        return { success: false, error: MISSING_AUTH_TOKEN, files: [] };
+    }
+    const { keywords, fileLimit, fileSizeLimit } = params;
+    let files = [];
+    // 1. Search for files and get their metadata
+    // Build the query: fullText contains 'keyword1' or fullText contains 'keyword2' ...
+    const query = keywords.map(kw => `fullText contains '${kw.replace(/'/g, "\\'")}'`).join(" or ");
+    const url = `https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&fields=files(id,name,mimeType,webViewLink)&supportsAllDrives=true&includeItemsFromAllDrives=true`;
+    try {
+        const res = yield axiosClient.get(url, {
+            headers: {
+                Authorization: `Bearer ${authParams.authToken}`,
+            },
+        });
+        files =
+            ((_b = res.data.files) === null || _b === void 0 ? void 0 : _b.map((file) => ({
+                id: file.id,
+                name: file.name,
+                mimeType: file.mimeType,
+                url: file.webViewLink,
+            }))) || [];
+    }
+    catch (error) {
+        console.error("Error searching Google Drive", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+            files: [],
+        };
+    }
+    files = fileLimit ? files.splice(0, fileLimit) : files;
+    // 2. Extract content from files and do some smart range selection
+    const processedFiles = yield Promise.all(files
+        .filter((file) => file.id && file.mimeType)
+        .map((file) => __awaiter(void 0, void 0, void 0, function* () {
+        const content = yield extractContentFromDriveFileId({
+            params: { fileId: file.id, mimeType: file.mimeType },
+            authParams,
+        });
+        if (content.success) {
+            let selectedContent = content.content;
+            if (fileSizeLimit && selectedContent && selectedContent.length > fileSizeLimit) {
+                selectedContent = intelligentSelectByMedianSection(selectedContent, keywords, fileSizeLimit);
+            }
+            return {
+                id: file.id || "",
+                name: file.name || "",
+                mimeType: file.mimeType || "",
+                url: file.url || "",
+                content: selectedContent,
+            };
+        }
+        else {
+            return {
+                id: file.id || "",
+                name: file.name || "",
+                mimeType: file.mimeType || "",
+                url: file.url || "",
+                error: content.error,
+            };
+        }
+    })));
+    return { success: true, files: processedFiles };
+});
+export default searchDriveAndGetContentByKeywords;

package/dist/actions/providers/google-oauth/searchDriveAndGetContentByQuery.d.ts

@@ -0,0 +1,3 @@
+import type { googleOauthSearchDriveAndGetContentByQueryFunction } from "../../autogen/types.js";
+declare const searchDriveAndGetContentByQuery: googleOauthSearchDriveAndGetContentByQueryFunction;
+export default searchDriveAndGetContentByQuery;

package/dist/actions/providers/google-oauth/searchDriveAndGetContentByQuery.js

@@ -0,0 +1,78 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { axiosClient } from "../../util/axiosClient.js";
+import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
+import extractContentFromDriveFileId from "./utils/extractContentFromDriveFileId.js";
+const searchDriveAndGetContentByQuery = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    var _b;
+    if (!authParams.authToken) {
+        return { success: false, error: MISSING_AUTH_TOKEN, files: [] };
+    }
+    const { query, fileLimit, fileSizeLimit } = params;
+    let files = [];
+    // 1. Search for files and get their metadata
+    const url = `https://www.googleapis.com/drive/v3/files?q=${encodeURIComponent(query)}&fields=files(id,name,mimeType,webViewLink)&supportsAllDrives=true&includeItemsFromAllDrives=true&corpora=allDrives`;
+    try {
+        const res = yield axiosClient.get(url, {
+            headers: {
+                Authorization: `Bearer ${authParams.authToken}`,
+            },
+        });
+        files =
+            ((_b = res.data.files) === null || _b === void 0 ? void 0 : _b.map((file) => ({
+                id: file.id,
+                name: file.name,
+                mimeType: file.mimeType,
+                url: file.webViewLink,
+            }))) || [];
+    }
+    catch (error) {
+        console.error("Error searching Google Drive", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+            files: [],
+        };
+    }
+    files = fileLimit ? files.splice(0, fileLimit) : files;
+    // 2. Extract content from files and do some smart range selection
+    const processedFiles = yield Promise.all(files
+        .filter((file) => file.id && file.mimeType)
+        .map((file) => __awaiter(void 0, void 0, void 0, function* () {
+        const content = yield extractContentFromDriveFileId({
+            params: { fileId: file.id, mimeType: file.mimeType },
+            authParams,
+        });
+        if (content.success) {
+            let selectedContent = content.content;
+            if (fileSizeLimit && selectedContent && selectedContent.length > fileSizeLimit) {
+                selectedContent = selectedContent.substring(0, fileSizeLimit);
+            }
+            return {
+                id: file.id || "",
+                name: file.name || "",
+                mimeType: file.mimeType || "",
+                url: file.url || "",
+                content: selectedContent,
+            };
+        }
+        else {
+            return {
+                id: file.id || "",
+                name: file.name || "",
+                mimeType: file.mimeType || "",
+                url: file.url || "",
+                error: content.error,
+            };
+        }
+    })));
+    return { success: true, files: processedFiles };
+});
+export default searchDriveAndGetContentByQuery;

package/dist/actions/providers/google-oauth/utils/extractContentFromDriveFileId.d.ts

@@ -0,0 +1,15 @@
+import type { AuthParamsType } from "../../../autogen/types.js";
+export type getDriveFileContentParams = {
+    fileId: string;
+    mimeType: string;
+};
+export type getDriveFileContentOutput = {
+    success: boolean;
+    content?: string;
+    error?: string;
+};
+declare const extractContentFromDriveFileId: ({ params, authParams, }: {
+    params: getDriveFileContentParams;
+    authParams: AuthParamsType;
+}) => Promise<getDriveFileContentOutput>;
+export default extractContentFromDriveFileId;