@credal/actions 0.2.77 → 0.2.81

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

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

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

@@ -0,0 +1,135 @@
+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";
+function hasReadOnlyQuery(query) {
+    const normalizedQuery = query
+        .replace(/\/\*[\s\S]*?\*\//g, "")
+        .replace(/--.*$/gm, "")
+        .trim()
+        .toUpperCase();
+    const writeOperations = [
+        "INSERT",
+        "UPDATE",
+        "DELETE",
+        "CREATE",
+        "DROP",
+        "ALTER",
+        "TRUNCATE",
+        "MERGE",
+        "REPLACE",
+        "GRANT",
+        "REVOKE",
+        "CALL",
+        "EXECUTE",
+    ];
+    for (const operation of writeOperations) {
+        const regex = new RegExp(`\\b${operation}\\b`, "i");
+        if (regex.test(normalizedQuery)) {
+            return false; // Not read-only
+        }
+    }
+    return true; // Read-only
+}
+const queryGoogleBigQuery = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    var _b, _c, _d, _e, _f, _g, _h;
+    if (!authParams.authToken) {
+        return { success: false, error: MISSING_AUTH_TOKEN };
+    }
+    const { query, projectId, maxResults = 1000, timeoutMs = 30000, maximumBytesProcessed = "500000000" } = params;
+    const hasReadOnly = hasReadOnlyQuery(query);
+    if (!hasReadOnly) {
+        return { success: false, error: `Read-only queries only. Your query contains write operations.` };
+    }
+    try {
+        const allRows = [];
+        let schema = [];
+        let totalRows = "0";
+        let pageToken;
+        const deadline = Date.now() + timeoutMs;
+        /**
+         * We loop while a pageToken is returned **and** we haven't exceeded the
+         * caller‑supplied timeout.
+         */
+        do {
+            const { data } = yield axiosClient.post(`https://bigquery.googleapis.com/bigquery/v2/projects/${projectId}/queries`, {
+                query,
+                useLegacySql: false,
+                maximumBytesProcessed,
+                maxResults,
+                pageToken,
+            }, {
+                headers: {
+                    Authorization: `Bearer ${authParams.authToken}`,
+                    "Content-Type": "application/json",
+                },
+            });
+            // capture schema once
+            if (!schema.length && ((_b = data.schema) === null || _b === void 0 ? void 0 : _b.fields)) {
+                schema = data.schema.fields.map(f => ({
+                    name: f.name,
+                    type: f.type,
+                    mode: f.mode,
+                }));
+            }
+            // accumulate rows
+            if ((_c = data.rows) === null || _c === void 0 ? void 0 : _c.length) {
+                data.rows.forEach(row => {
+                    const rowObj = {};
+                    row.f.forEach((cell, idx) => {
+                        var _a, _b;
+                        const fieldName = (_b = (_a = schema[idx]) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : `column_${idx}`;
+                        rowObj[fieldName] = cell.v;
+                    });
+                    allRows.push(rowObj);
+                });
+            }
+            totalRows = (_d = data.totalRows) !== null && _d !== void 0 ? _d : totalRows;
+            pageToken = data.pageToken;
+            if (pageToken && Date.now() > deadline) {
+                return {
+                    success: false,
+                    error: "Query timeout exceeded while paging through results",
+                };
+            }
+        } while (pageToken);
+        // check for any job‑level errors that API surfaced
+        if (allRows.length === 0 && schema.length === 0) {
+            return {
+                success: false,
+                error: "Query returned no data and no schema (unexpected)",
+            };
+        }
+        return {
+            success: true,
+            data: allRows,
+            totalRows,
+            schema,
+        };
+    }
+    catch (err) {
+        console.error("Error querying BigQuery:", err);
+        let errorMessage = "Unknown error";
+        if (err instanceof Error) {
+            errorMessage = err.message;
+        }
+        else if (typeof err === "object" && err !== null && "response" in err) {
+            const axiosErr = err;
+            if ((_g = (_f = (_e = axiosErr.response) === null || _e === void 0 ? void 0 : _e.data) === null || _f === void 0 ? void 0 : _f.error) === null || _g === void 0 ? void 0 : _g.message) {
+                errorMessage = axiosErr.response.data.error.message;
+            }
+            else if ((_h = axiosErr.response) === null || _h === void 0 ? void 0 : _h.statusText) {
+                errorMessage = axiosErr.response.statusText;
+            }
+        }
+        return { success: false, error: errorMessage };
+    }
+});
+export default queryGoogleBigQuery;

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;

package/dist/actions/providers/google-oauth/utils/extractContentFromDriveFileId.js

@@ -0,0 +1,129 @@
+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 mammoth from "mammoth";
+import { MISSING_AUTH_TOKEN } from "../../../util/missingAuthConstants.js";
+const extractContentFromDriveFileId = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    if (!authParams.authToken) {
+        return { success: false, error: MISSING_AUTH_TOKEN };
+    }
+    const { fileId, mimeType } = params;
+    let content = "";
+    try {
+        // Handle different file types - read content directly
+        if (mimeType === "application/vnd.google-apps.document") {
+            // Google Docs - download as plain text
+            const exportUrl = `https://www.googleapis.com/drive/v3/files/${encodeURIComponent(fileId)}/export?mimeType=text/plain`;
+            const exportRes = yield axiosClient.get(exportUrl, {
+                headers: {
+                    Authorization: `Bearer ${authParams.authToken}`,
+                },
+                responseType: "text",
+            });
+            content = exportRes.data;
+        }
+        else if (mimeType === "application/vnd.google-apps.spreadsheet") {
+            // Google Sheets - download as CSV
+            const exportUrl = `https://www.googleapis.com/drive/v3/files/${encodeURIComponent(fileId)}/export?mimeType=text/csv`;
+            const exportRes = yield axiosClient.get(exportUrl, {
+                headers: {
+                    Authorization: `Bearer ${authParams.authToken}`,
+                },
+                responseType: "text",
+            });
+            // Clean up excessive commas from empty columns
+            content = exportRes.data
+                .split("\n")
+                .map((line) => line.replace(/,+$/, "")) // Remove trailing commas
+                .map((line) => line.replace(/,{2,}/g, ",")) // Replace multiple commas with single comma
+                .join("\n");
+        }
+        else if (mimeType === "application/vnd.google-apps.presentation") {
+            // Google Slides - download as plain text
+            const exportUrl = `https://www.googleapis.com/drive/v3/files/${encodeURIComponent(fileId)}/export?mimeType=text/plain`;
+            const exportRes = yield axiosClient.get(exportUrl, {
+                headers: {
+                    Authorization: `Bearer ${authParams.authToken}`,
+                },
+                responseType: "text",
+            });
+            content = exportRes.data;
+        }
+        else if (mimeType === "application/pdf") {
+            return {
+                success: false,
+                error: "PDF files are not supported for text extraction",
+            };
+        }
+        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();
+        return {
+            success: true,
+            content,
+        };
+    }
+    catch (error) {
+        console.error("Error getting Google Drive file content", error);
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error",
+        };
+    }
+});
+export default extractContentFromDriveFileId;

package/dist/actions/providers/googlemail/sendGmail.js

@@ -10,11 +10,61 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { axiosClient } from "../../util/axiosClient.js";
 import { MISSING_AUTH_TOKEN } from "../../util/missingAuthConstants.js";
 const sendGmail = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
+    var _b, _c, _d;
     if (!authParams.authToken) {
         return { success: false, error: MISSING_AUTH_TOKEN };
     }
-    const { to, cc, bcc, subject, content } = params;
+    const { to, cc, bcc, subject, content, threadId } = params;
     try {
+        // If replying to a thread, get the original message details
+        let inReplyTo = "";
+        let references = "";
+        let formattedSubject = subject;
+        if (threadId) {
+            try {
+                // Get the thread to find the last message ID and subject
+                const threadResponse = yield axiosClient.get(`https://gmail.googleapis.com/gmail/v1/users/me/threads/${threadId}`, {
+                    headers: {
+                        Authorization: `Bearer ${authParams.authToken}`,
+                    },
+                });
+                const messages = threadResponse.data.messages;
+                if (messages && messages.length > 0) {
+                    const lastMessage = messages[messages.length - 1];
+                    // Get the Message-ID header from the last message
+                    const messageIdHeader = (_b = lastMessage.payload.headers) === null || _b === void 0 ? void 0 : _b.find((h) => h.name.toLowerCase() === "message-id");
+                    if (messageIdHeader) {
+                        inReplyTo = messageIdHeader.value;
+                    }
+                    // Get existing References header or create new one
+                    const referencesHeader = (_c = lastMessage.payload.headers) === null || _c === void 0 ? void 0 : _c.find((h) => h.name.toLowerCase() === "references");
+                    if (referencesHeader) {
+                        references = `${referencesHeader.value} ${inReplyTo}`.trim();
+                    }
+                    else {
+                        references = inReplyTo;
+                    }
+                    // Get original subject and format as reply
+                    const subjectHeader = (_d = lastMessage.payload.headers) === null || _d === void 0 ? void 0 : _d.find((h) => h.name.toLowerCase() === "subject");
+                    // When threadId is provided, ALWAYS use the original thread's subject
+                    // Ignore the subject parameter completely to ensure proper threading
+                    if (subjectHeader) {
+                        const originalSubject = subjectHeader.value;
+                        formattedSubject = originalSubject.toLowerCase().startsWith("re:")
+                            ? originalSubject
+                            : `Re: ${originalSubject}`;
+                    }
+                    else {
+                        formattedSubject = "Re: (no subject)";
+                    }
+                }
+            }
+            catch (threadError) {
+                console.warn("Could not fetch thread details for proper reply formatting:", threadError);
+                // When threadId is provided but thread fetch fails, still ignore the subject param
+                formattedSubject = "Re: (no subject)";
+            }
+        }
         // Create the email message in RFC 2822 format
         let message = "";
         // Add recipients
@@ -27,9 +77,17 @@ const sendGmail = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, a
         if (bcc && bcc.length > 0) {
             message += `Bcc: ${bcc.join(", ")}\r\n`;
         }
-        // Add subject
-        message += `Subject: ${subject}\r\n`;
+        // Add subject (formatted for reply if needed)
+        message += `Subject: ${formattedSubject}\r\n`;
+        // Add threading headers if replying - CRITICAL for proper threading
+        if (threadId && inReplyTo) {
+            message += `In-Reply-To: ${inReplyTo}\r\n`;
+            if (references) {
+                message += `References: ${references}\r\n`;
+            }
+        }
         message += `Content-Type: text/html; charset=utf-8\r\n`;
+        message += `MIME-Version: 1.0\r\n`;
         message += `\r\n`;
         message += content;
         // Encode the message in base64url format
@@ -38,9 +96,14 @@ const sendGmail = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, a
             .replace(/\+/g, "-")
             .replace(/\//g, "_")
             .replace(/=+$/, "");
-        const response = yield axiosClient.post("https://gmail.googleapis.com/gmail/v1/users/me/messages/send", {
+        const requestBody = {
             raw: encodedMessage,
-        }, {
+        };
+        // IMPORTANT: Include threadId in the request body for proper threading
+        if (threadId) {
+            requestBody.threadId = threadId;
+        }
+        const response = yield axiosClient.post("https://gmail.googleapis.com/gmail/v1/users/me/messages/send", requestBody, {
             headers: {
                 Authorization: `Bearer ${authParams.authToken}`,
                 "Content-Type": "application/json",
@@ -52,6 +115,7 @@ const sendGmail = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, a
         };
     }
     catch (error) {
+        console.error("Gmail send error:", error);
         return {
             success: false,
             error: error instanceof Error ? error.message : "Unknown error sending email",

package/dist/actions/providers/googlemaps/nearbysearch.d.ts

@@ -0,0 +1,3 @@
+import { googlemapsNearbysearchFunction } from "../../autogen/types";
+declare const nearbysearch: googlemapsNearbysearchFunction;
+export default nearbysearch;