@credal/actions 0.2.208 → 0.2.210

package/dist/actions/providers/slack/sendMessage.js

@@ -6,7 +6,7 @@ const sendMessage = async ({ params, authParams, }) => {
     if (!authParams.authToken) {
         throw new Error(MISSING_AUTH_TOKEN);
     }
-    const { channelId: inputChannelId, channelName, message } = params;
+    const { channelId: inputChannelId, channelName, message, unfurlLinks, threadTs, replyBroadcast } = params;
     if (!inputChannelId && !channelName) {
         throw Error("Either channelId or channelName must be provided");
     }
@@ -19,33 +19,74 @@ const sendMessage = async ({ params, authParams, }) => {
     if (!channelId) {
         throw Error(`Channel with name ${channelName} not found`);
     }
-    try {
-        // First try sending as Markdown blocks (mrkdwn)
-        await client.chat.postMessage({
-            channel: channelId,
-            text: message, // Fallback text for notifications/clients that don't render blocks
-            blocks: [
-                {
-                    type: "section",
-                    text: {
-                        type: "mrkdwn",
-                        text: message,
-                    },
-                },
-            ],
+    const baseArgs = {
+        channel: channelId,
+        text: message,
+        unfurl_links: unfurlLinks,
+    };
+    const messageBlocks = [
+        {
+            type: "section",
+            text: {
+                type: "mrkdwn",
+                text: message,
+            },
+        },
+    ];
+    const postAsBlocks = () => client.chat.postMessage(threadTs
+        ? replyBroadcast
+            ? {
+                ...baseArgs,
+                thread_ts: threadTs,
+                reply_broadcast: true,
+                blocks: messageBlocks,
+            }
+            : {
+                ...baseArgs,
+                thread_ts: threadTs,
+                blocks: messageBlocks,
+            }
+        : {
+            ...baseArgs,
+            blocks: messageBlocks,
         });
+    const postAsPlainText = () => client.chat.postMessage(threadTs
+        ? replyBroadcast
+            ? { ...baseArgs, thread_ts: threadTs, reply_broadcast: true }
+            : { ...baseArgs, thread_ts: threadTs }
+        : baseArgs);
+    const buildSuccess = async (result) => {
+        const ts = result.ts;
+        const resolvedChannelId = result.channel ?? channelId;
+        let permalink;
+        if (ts) {
+            try {
+                const permalinkResult = await client.chat.getPermalink({
+                    channel: resolvedChannelId,
+                    message_ts: ts,
+                });
+                permalink = permalinkResult.permalink;
+            }
+            catch {
+                // Permalink fetch failed, but the message was sent successfully
+            }
+        }
         return slackSendMessageOutputSchema.parse({
             success: true,
+            channelId: resolvedChannelId,
+            timestamp: ts,
+            threadTs: threadTs,
+            permalink,
         });
+    };
+    try {
+        const result = await postAsBlocks();
+        return await buildSuccess(result);
     }
     catch {
-        // On any error, retry once with plain text only (no blocks)
         try {
-            await client.chat.postMessage({
-                channel: channelId,
-                text: message,
-            });
-            return slackSendMessageOutputSchema.parse({ success: true });
+            const result = await postAsPlainText();
+            return await buildSuccess(result);
         }
         catch (retryError) {
             return slackSendMessageOutputSchema.parse({

package/dist/utils/google.d.ts

@@ -128,6 +128,7 @@ interface GoogleSlidesPresentation {
     };
 }
 export declare function parseGoogleDocFromRawContentToPlainText(snapshotRawContent: GoogleDocsDocument): string;
+export declare function parseWorkbookBufferToPlainText(data: ArrayBuffer | Buffer, charLimit?: number): string;
 export declare function parseGoogleSheetsFromRawContentToPlainText(snapshotRawContent: GoogleSheetsSpreadsheet): string;
 export declare function parseGoogleSlidesFromRawContentToPlainText(snapshotRawContent: GoogleSlidesPresentation): string;
 export declare function getGoogleDocContent(fileId: string, authToken: string, axiosClient: AxiosInstance, sharedDriveParams: string): Promise<string>;

package/dist/utils/google.js

@@ -1,4 +1,5 @@
 import Papa from "papaparse";
+import { read, utils } from "xlsx";
 import { isAxiosTimeoutError } from "../actions/util/axiosClient.js";
 // Helper function to parse Google Docs content to plain text
 export function parseGoogleDocFromRawContentToPlainText(snapshotRawContent) {
@@ -138,6 +139,23 @@ function parseCSVToSheetJson(csvData, sheetName = "Sheet1") {
     });
     return JSON.stringify([{ sheetName, headers, rows }]);
 }
+export function parseWorkbookBufferToPlainText(data, charLimit) {
+    const workbook = read(data, { type: "buffer", sheetStubs: false });
+    const sheetTexts = [];
+    let totalLength = 0;
+    // charLimit here is a soft parsing budget; downstream callers may still apply a hard final slice.
+    const effectiveLimit = charLimit ? charLimit * 1.5 : 100_000;
+    for (const sheetName of workbook.SheetNames) {
+        if (totalLength >= effectiveLimit) {
+            break;
+        }
+        const sheet = workbook.Sheets[sheetName];
+        const csv = utils.sheet_to_csv(sheet);
+        sheetTexts.push(`--- Sheet: ${sheetName} ---\n${csv}`);
+        totalLength += csv.length;
+    }
+    return sheetTexts.join("\n").trim();
+}
 export function parseGoogleSheetsFromRawContentToPlainText(snapshotRawContent) {
     if (!snapshotRawContent.sheets)
         return "[]";
@@ -317,21 +335,14 @@ export async function getGoogleDocContent(fileId, authToken, axiosClient, shared
     }
 }
 export async function getGoogleSheetContent(fileId, authToken, axiosClient, sharedDriveParams) {
-    // Use CSV export as primary method - it's much faster and more reliable for large sheets
-    // The Sheets API with includeGridData can timeout on large spreadsheets
+    // Prefer XLSX export so native Google Sheets follow the same workbook parsing path as uploaded Excel files.
     try {
-        const exportUrl = `${GDRIVE_BASE_URL}${encodeURIComponent(fileId)}/export?mimeType=text/csv${sharedDriveParams}`;
+        const exportUrl = `${GDRIVE_BASE_URL}${encodeURIComponent(fileId)}/export?mimeType=application/vnd.openxmlformats-officedocument.spreadsheetml.sheet${sharedDriveParams}`;
         const exportRes = await axiosClient.get(exportUrl, {
             headers: { Authorization: `Bearer ${authToken}` },
-            responseType: "text",
+            responseType: "arraybuffer",
         });
-        // Clean up trailing commas and convert to JSON format
-        const cleanedCsv = exportRes.data
-            .split("\n")
-            .map((line) => line.replace(/,+$/, ""))
-            .map((line) => line.replace(/,{2,}/g, ","))
-            .join("\n");
-        return parseCSVToSheetJson(cleanedCsv);
+        return parseWorkbookBufferToPlainText(exportRes.data);
     }
     catch (exportError) {
         // Check if it's a 404 or permission error
@@ -342,21 +353,36 @@ export async function getGoogleSheetContent(fileId, authToken, axiosClient, shar
                 throw new Error(`Spreadsheet not accessible (${status}): ${fileId}`, { cause: exportError });
             }
         }
-        // If CSV export fails, try the Sheets API as fallback (but this is slower)
+        // If XLSX export fails, fall back to the prior CSV-first behavior.
         try {
-            const sheetsUrl = `https://sheets.googleapis.com/v4/spreadsheets/${fileId}?includeGridData=true`;
-            const sheetsRes = await axiosClient.get(sheetsUrl, {
-                headers: {
-                    Authorization: `Bearer ${authToken}`,
-                },
+            const csvExportUrl = `${GDRIVE_BASE_URL}${encodeURIComponent(fileId)}/export?mimeType=text/csv${sharedDriveParams}`;
+            const csvExportRes = await axiosClient.get(csvExportUrl, {
+                headers: { Authorization: `Bearer ${authToken}` },
+                responseType: "text",
             });
-            return parseGoogleSheetsFromRawContentToPlainText(sheetsRes.data);
+            const cleanedCsv = csvExportRes.data
+                .split("\n")
+                .map((line) => line.replace(/,+$/, ""))
+                .map((line) => line.replace(/,{2,}/g, ","))
+                .join("\n");
+            return parseCSVToSheetJson(cleanedCsv);
         }
-        catch (sheetsError) {
-            if (isAxiosTimeoutError(sheetsError)) {
-                throw new Error("Request timed out using Google Sheets API", { cause: sheetsError });
+        catch {
+            try {
+                const sheetsUrl = `https://sheets.googleapis.com/v4/spreadsheets/${fileId}?includeGridData=true`;
+                const sheetsRes = await axiosClient.get(sheetsUrl, {
+                    headers: {
+                        Authorization: `Bearer ${authToken}`,
+                    },
+                });
+                return parseGoogleSheetsFromRawContentToPlainText(sheetsRes.data);
+            }
+            catch (sheetsError) {
+                if (isAxiosTimeoutError(sheetsError)) {
+                    throw new Error("Request timed out using Google Sheets API", { cause: sheetsError });
+                }
+                throw new Error(`Unable to access spreadsheet content: ${fileId}`, { cause: sheetsError });
             }
-            throw new Error(`Unable to access spreadsheet content: ${fileId}`, { cause: sheetsError });
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@credal/actions",
-  "version": "0.2.208",
+  "version": "0.2.210",
   "type": "module",
   "description": "AI Actions by Credal AI",
   "sideEffects": false,

package/dist/actions/providers/jira/updateServiceDeskRequest.d.ts

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

package/dist/actions/providers/jira/updateServiceDeskRequest.js

@@ -1,72 +0,0 @@
-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";
-const updateServiceDeskRequest = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
-    const { issueId, requestTypeId, summary, description, priority, customFields } = params;
-    const { authToken, cloudId, baseUrl } = authParams;
-    if (!cloudId || !authToken) {
-        throw new Error("Valid Cloud ID and auth token are required to update service desk request");
-    }
-    // Use the regular Jira API for updating service desk requests as they are still Jira issues
-    const apiUrl = `https://api.atlassian.com/ex/jira/${cloudId}/rest/api/3/issue/${issueId}`;
-    const formattedDescription = description
-        ? {
-            type: "doc",
-            version: 1,
-            content: [
-                {
-                    type: "paragraph",
-                    content: [
-                        {
-                            type: "text",
-                            text: description,
-                        },
-                    ],
-                },
-            ],
-        }
-        : undefined;
-    const payload = {
-        fields: Object.assign(Object.assign(Object.assign(Object.assign({}, (summary && { summary })), (formattedDescription && { description: formattedDescription })), (priority && { priority: { name: priority } })), (customFields && Object.assign({}, customFields))),
-    };
-    try {
-        yield axiosClient.put(apiUrl, payload, {
-            headers: {
-                Authorization: `Bearer ${authToken}`,
-                Accept: "application/json",
-                "Content-Type": "application/json",
-            },
-        });
-        // Get the updated issue details to return current status and web link
-        const getResponse = yield axiosClient.get(apiUrl, {
-            headers: {
-                Authorization: `Bearer ${authToken}`,
-                Accept: "application/json",
-            },
-        });
-        const issueKey = getResponse.data.key;
-        const currentStatus = getResponse.data.fields.status.name;
-        const webLink = `${baseUrl}/browse/${issueKey}`;
-        return {
-            success: true,
-            issueKey,
-            webLink,
-            currentStatus,
-        };
-    }
-    catch (error) {
-        console.error("Error updating service desk request:", error);
-        return {
-            success: false,
-            error: error instanceof Error ? error.message : "Unknown error",
-        };
-    }
-});
-export default updateServiceDeskRequest;

package/dist/actions/providers/microsoft/sendOutlookEmail.d.ts

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

package/dist/actions/providers/microsoft/sendOutlookEmail.js

@@ -1,48 +0,0 @@
-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 { getGraphClient } from "./utils.js";
-const sendEmail = (_a) => __awaiter(void 0, [_a], void 0, function* ({ params, authParams, }) {
-    const { toRecipients, subject, body, ccRecipients, bccRecipients } = params;
-    let client = undefined;
-    try {
-        client = yield getGraphClient(authParams);
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: "Error while authorizing: " + (error instanceof Error ? error.message : "Unknown error"),
-        };
-    }
-    try {
-        const message = {
-            message: Object.assign(Object.assign({ subject, body: {
-                    contentType: "HTML",
-                    content: body,
-                }, toRecipients: toRecipients.map(email => ({ emailAddress: { address: email } })) }, (ccRecipients && ccRecipients.length > 0
-                ? { ccRecipients: ccRecipients.map(email => ({ emailAddress: { address: email } })) }
-                : {})), (bccRecipients && bccRecipients.length > 0
-                ? { bccRecipients: bccRecipients.map(email => ({ emailAddress: { address: email } })) }
-                : {})),
-            saveToSentItems: true,
-        };
-        yield client.api("/me/sendMail").post(message);
-        return {
-            success: true,
-        };
-    }
-    catch (error) {
-        console.error(error);
-        return {
-            success: false,
-            error: "Error sending email: " + (error instanceof Error ? error.message : "Unknown error"),
-        };
-    }
-});
-export default sendEmail;