@useactor/core 0.1.0 → 0.2.3

package/dist/plugins/google-workspace-integration.js

@@ -0,0 +1,1353 @@
+import { getGoogleOAuthMetadata, loadGoogleOAuthCredential, } from "./google-workspace-oauth.js";
+import { appendGoogleDocText, createGoogleDoc, replaceGoogleDocText, } from "./google-docs.js";
+import { createGoogleDriveFolder, createGoogleDriveTextFile, exportGoogleDriveText, getGoogleDriveMetadata, googleWorkspaceOAuthSecretId, moveGoogleDriveFile, renameGoogleDriveFile, searchGoogleDrive, trashGoogleDriveFile, } from "./google-drive.js";
+import { addGoogleSheet, appendGoogleSheetsRows, batchUpdateGoogleSheets, clearGoogleSheetsRange, createGoogleSpreadsheet, deleteGoogleSheet, formatGoogleSheetsRange, getGoogleSheetsMetadata, readGoogleSheetsRange, renameGoogleSheet, searchGoogleSheetsValues, updateGoogleSheetsRange, } from "./google-sheets.js";
+import { batchUpdateGoogleSlides, createGoogleSlide, createGoogleSlidesImage, createGoogleSlidesPresentation, createGoogleSlidesShape, createGoogleSlidesTable, createGoogleSlidesTextBox, deleteGoogleSlidesObject, getGoogleSlidesMetadata, readGoogleSlidesText, replaceGoogleSlidesText, updateGoogleSlidesShapeStyle, updateGoogleSlidesTextStyle, } from "./google-slides.js";
+import { createSystemKeychainSecretStore } from "../providers/secrets.js";
+export const googleWorkspaceIntegrationId = "google_workspace";
+export { googleWorkspaceOAuthSecretId };
+export const googleWorkspaceIntegrationConfig = {
+    id: googleWorkspaceIntegrationId,
+    kind: "google_workspace",
+    name: "Google Workspace",
+    description: "OAuth API-backed app connector for Google Drive, Docs, and Sheets.",
+    defaultEnabled: false,
+};
+export const googleWorkspaceScopes = [
+    "https://www.googleapis.com/auth/drive",
+    "https://www.googleapis.com/auth/drive.metadata.readonly",
+    "https://www.googleapis.com/auth/drive.readonly",
+    "https://www.googleapis.com/auth/documents",
+    "https://www.googleapis.com/auth/presentations",
+    "https://www.googleapis.com/auth/spreadsheets",
+];
+export function createGoogleWorkspaceIntegration() {
+    const statusTool = {
+        id: "google_workspace_status",
+        name: "Google Workspace status",
+        description: "Return Google Workspace connector authentication status.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {},
+        },
+        permissionPolicy: "never",
+        async executor() {
+            return {
+                content: JSON.stringify({
+                    ok: true,
+                    integration: googleWorkspaceIntegrationId,
+                    status: "oauth_api",
+                    transport: "oauth_api",
+                    capabilities: ["drive", "docs", "sheets", "slides"],
+                }),
+            };
+        },
+    };
+    const driveSearchTool = {
+        id: "google_drive_search",
+        name: "Google Drive search",
+        description: "Search authenticated Google Drive files by name or full text and return file metadata.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                query: {
+                    type: "string",
+                    description: "Search text to match against file names or full text.",
+                },
+                pageSize: {
+                    type: "number",
+                    description: "Maximum number of files to return, from 1 to 25.",
+                },
+                mimeType: {
+                    type: "string",
+                    description: "Optional exact Google Drive MIME type filter. Use folder for Drive folders.",
+                },
+                driveScope: {
+                    type: "string",
+                    enum: ["all_drives", "my_drive", "shared_with_me"],
+                    description: "Drive search scope. Defaults to all_drives, including Shared Drives.",
+                },
+            },
+        },
+        permissionPolicy: "never",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await searchGoogleDrive(parseDriveSearchInput(input))),
+            };
+        },
+    };
+    const driveExportTextTool = {
+        id: "google_drive_export_text",
+        name: "Google Drive export text",
+        description: "Export a Google Docs, Google Sheets, or plain text Google Drive file as text by file id.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["fileId"],
+            properties: {
+                fileId: {
+                    type: "string",
+                    description: "Google Drive file id to export as text.",
+                },
+            },
+        },
+        permissionPolicy: "never",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await exportGoogleDriveText(parseDriveExportTextInput(input))),
+            };
+        },
+    };
+    const driveMetadataTool = {
+        id: "google_drive_get_metadata",
+        name: "Google Drive metadata",
+        description: "Read generic Google Drive file metadata by file id for any supported file type.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["fileId"],
+            properties: {
+                fileId: {
+                    type: "string",
+                    description: "Google Drive file id to inspect.",
+                },
+            },
+        },
+        permissionPolicy: "never",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await getGoogleDriveMetadata(parseDriveFileIdInput(input, "google_drive_get_metadata"))),
+            };
+        },
+    };
+    const sheetsMetadataTool = {
+        id: "google_sheets_get_metadata",
+        name: "Google Sheets metadata",
+        description: "Read spreadsheet title and sheet tab metadata from Google Sheets.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["spreadsheetId"],
+            properties: {
+                spreadsheetId: {
+                    type: "string",
+                    description: "Google Sheets spreadsheet id.",
+                },
+            },
+        },
+        permissionPolicy: "never",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await getGoogleSheetsMetadata(parseSpreadsheetIdInput(input, "google_sheets_get_metadata"))),
+            };
+        },
+    };
+    const sheetsReadRangeTool = {
+        id: "google_sheets_read_range",
+        name: "Google Sheets read range",
+        description: "Read formatted values from a Google Sheets A1 notation range.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["spreadsheetId", "range"],
+            properties: {
+                spreadsheetId: {
+                    type: "string",
+                    description: "Google Sheets spreadsheet id.",
+                },
+                range: {
+                    type: "string",
+                    description: "A1 notation range, for example Sheet1!A1:D20.",
+                },
+            },
+        },
+        permissionPolicy: "never",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await readGoogleSheetsRange(parseSheetsReadRangeInput(input))),
+            };
+        },
+    };
+    const sheetsSearchValuesTool = {
+        id: "google_sheets_search_values",
+        name: "Google Sheets search values",
+        description: "Search formatted values in one or more Google Sheets ranges.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["spreadsheetId", "query"],
+            properties: {
+                spreadsheetId: {
+                    type: "string",
+                    description: "Google Sheets spreadsheet id.",
+                },
+                query: {
+                    type: "string",
+                    description: "Text to search for in formatted cell values.",
+                },
+                ranges: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Optional A1 notation ranges. Defaults to A1:Z1000 for every sheet tab.",
+                },
+                maxMatches: {
+                    type: "number",
+                    description: "Maximum number of matches to return, from 1 to 100.",
+                },
+            },
+        },
+        permissionPolicy: "never",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await searchGoogleSheetsValues(parseSheetsSearchValuesInput(input))),
+            };
+        },
+    };
+    const sheetsCreateTool = {
+        id: "google_sheets_create",
+        name: "Google Sheets create",
+        description: "Create a native Google Sheets spreadsheet.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["title"],
+            properties: {
+                title: {
+                    type: "string",
+                    description: "Spreadsheet title.",
+                },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await createGoogleSpreadsheet(parseSheetsCreateInput(input))),
+            };
+        },
+    };
+    const sheetsUpdateRangeTool = {
+        id: "google_sheets_update_range",
+        name: "Google Sheets update range",
+        description: "Write rows of values to a Google Sheets A1 notation range.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["spreadsheetId", "range", "values"],
+            properties: {
+                spreadsheetId: { type: "string" },
+                range: {
+                    type: "string",
+                    description: "A1 notation range, for example Sheet1!A1:D20.",
+                },
+                values: {
+                    type: "array",
+                    items: { type: "array", items: {} },
+                    description: "Rows of values to write.",
+                },
+                valueInputOption: {
+                    type: "string",
+                    enum: ["RAW", "USER_ENTERED"],
+                    description: "Defaults to USER_ENTERED.",
+                },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await updateGoogleSheetsRange(parseSheetsWriteRangeInput(input, "google_sheets_update_range"))),
+            };
+        },
+    };
+    const sheetsAppendRowsTool = {
+        id: "google_sheets_append_rows",
+        name: "Google Sheets append rows",
+        description: "Append rows to a Google Sheets A1 notation range.",
+        inputSchema: sheetsUpdateRangeTool.inputSchema,
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await appendGoogleSheetsRows(parseSheetsWriteRangeInput(input, "google_sheets_append_rows"))),
+            };
+        },
+    };
+    const sheetsClearRangeTool = {
+        id: "google_sheets_clear_range",
+        name: "Google Sheets clear range",
+        description: "Clear values from a Google Sheets A1 notation range.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["spreadsheetId", "range"],
+            properties: {
+                spreadsheetId: { type: "string" },
+                range: { type: "string" },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await clearGoogleSheetsRange(parseSheetsClearRangeInput(input))),
+            };
+        },
+    };
+    const sheetsAddSheetTool = {
+        id: "google_sheets_add_sheet",
+        name: "Google Sheets add sheet",
+        description: "Add a new tab to a Google Sheets spreadsheet.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["spreadsheetId", "title"],
+            properties: {
+                spreadsheetId: { type: "string" },
+                title: { type: "string" },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await addGoogleSheet(parseSheetsSheetInput(input, "google_sheets_add_sheet"))),
+            };
+        },
+    };
+    const sheetsRenameSheetTool = {
+        id: "google_sheets_rename_sheet",
+        name: "Google Sheets rename sheet",
+        description: "Rename a Google Sheets tab by numeric sheet id.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["spreadsheetId", "sheetId", "title"],
+            properties: {
+                spreadsheetId: { type: "string" },
+                sheetId: { type: "number" },
+                title: { type: "string" },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await renameGoogleSheet(parseSheetsRenameSheetInput(input))),
+            };
+        },
+    };
+    const sheetsDeleteSheetTool = {
+        id: "google_sheets_delete_sheet",
+        name: "Google Sheets delete sheet",
+        description: "Delete a Google Sheets tab by numeric sheet id.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["spreadsheetId", "sheetId"],
+            properties: {
+                spreadsheetId: { type: "string" },
+                sheetId: { type: "number" },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await deleteGoogleSheet(parseSheetsDeleteSheetInput(input))),
+            };
+        },
+    };
+    const sheetsFormatRangeTool = {
+        id: "google_sheets_format_range",
+        name: "Google Sheets format range",
+        description: "Apply Google Sheets userEnteredFormat fields to a grid range.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["spreadsheetId", "sheetId", "userEnteredFormat", "fields"],
+            properties: {
+                spreadsheetId: { type: "string" },
+                sheetId: { type: "number" },
+                startRowIndex: { type: "number" },
+                endRowIndex: { type: "number" },
+                startColumnIndex: { type: "number" },
+                endColumnIndex: { type: "number" },
+                userEnteredFormat: {
+                    type: "object",
+                    description: "Google Sheets CellFormat object, for example {textFormat:{bold:true}}.",
+                },
+                fields: {
+                    type: "string",
+                    description: "CellFormat fields to apply, for example textFormat,backgroundColor,horizontalAlignment.",
+                },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await formatGoogleSheetsRange(parseSheetsFormatRangeInput(input))),
+            };
+        },
+    };
+    const sheetsBatchUpdateTool = {
+        id: "google_sheets_batch_update",
+        name: "Google Sheets batch update",
+        description: "Apply advanced Google Sheets batchUpdate requests to a spreadsheet.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["spreadsheetId", "requests"],
+            properties: {
+                spreadsheetId: { type: "string" },
+                requests: {
+                    type: "array",
+                    items: { type: "object" },
+                    description: "Google Sheets API batchUpdate requests. Use high-level tools when possible.",
+                },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await batchUpdateGoogleSheets(parseSheetsBatchUpdateInput(input))),
+            };
+        },
+    };
+    const slidesMetadataTool = {
+        id: "google_slides_get_metadata",
+        name: "Google Slides metadata",
+        description: "Read presentation title and slide object metadata from Google Slides.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["presentationId"],
+            properties: {
+                presentationId: { type: "string" },
+            },
+        },
+        permissionPolicy: "never",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await getGoogleSlidesMetadata(parseSlidesPresentationInput(input, "google_slides_get_metadata"))),
+            };
+        },
+    };
+    const slidesReadTextTool = {
+        id: "google_slides_read_text",
+        name: "Google Slides read text",
+        description: "Read text content from Google Slides shapes, tables, and speaker notes.",
+        inputSchema: slidesMetadataTool.inputSchema,
+        permissionPolicy: "never",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await readGoogleSlidesText(parseSlidesPresentationInput(input, "google_slides_read_text"))),
+            };
+        },
+    };
+    const slidesCreateTool = {
+        id: "google_slides_create",
+        name: "Google Slides create",
+        description: "Create a native Google Slides presentation.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["title"],
+            properties: {
+                title: { type: "string" },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await createGoogleSlidesPresentation(parseSlidesCreateInput(input))),
+            };
+        },
+    };
+    const slidesCreateSlideTool = {
+        id: "google_slides_create_slide",
+        name: "Google Slides create slide",
+        description: "Create a slide in a Google Slides presentation.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["presentationId"],
+            properties: {
+                presentationId: { type: "string" },
+                objectId: { type: "string" },
+                insertionIndex: { type: "number" },
+                predefinedLayout: {
+                    type: "string",
+                    description: "Google Slides predefined layout. Defaults to BLANK.",
+                },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await createGoogleSlide(parseSlidesCreateSlideInput(input))),
+            };
+        },
+    };
+    const slidesDeleteObjectTool = {
+        id: "google_slides_delete_object",
+        name: "Google Slides delete object",
+        description: "Delete a slide or page element from a Google Slides presentation.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["presentationId", "objectId"],
+            properties: {
+                presentationId: { type: "string" },
+                objectId: { type: "string" },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await deleteGoogleSlidesObject(parseSlidesObjectInput(input, "google_slides_delete_object"))),
+            };
+        },
+    };
+    const slidesCreateTextBoxTool = {
+        id: "google_slides_create_text_box",
+        name: "Google Slides create text box",
+        description: "Create a text box on a slide and insert text.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["presentationId", "pageObjectId", "text"],
+            properties: slidesElementProperties({
+                text: { type: "string" },
+            }),
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await createGoogleSlidesTextBox(parseSlidesCreateTextBoxInput(input))),
+            };
+        },
+    };
+    const slidesReplaceTextTool = {
+        id: "google_slides_replace_text",
+        name: "Google Slides replace text",
+        description: "Replace matching text in a Google Slides presentation.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["presentationId", "containsText", "replaceText"],
+            properties: {
+                presentationId: { type: "string" },
+                containsText: { type: "string" },
+                replaceText: { type: "string" },
+                pageObjectIds: { type: "array", items: { type: "string" } },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await replaceGoogleSlidesText(parseSlidesReplaceTextInput(input))),
+            };
+        },
+    };
+    const slidesCreateImageTool = {
+        id: "google_slides_create_image",
+        name: "Google Slides create image",
+        description: "Create an image element from a URL on a Google Slides slide.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["presentationId", "pageObjectId", "url"],
+            properties: slidesElementProperties({
+                url: { type: "string" },
+            }),
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await createGoogleSlidesImage(parseSlidesCreateImageInput(input))),
+            };
+        },
+    };
+    const slidesCreateShapeTool = {
+        id: "google_slides_create_shape",
+        name: "Google Slides create shape",
+        description: "Create a shape on a Google Slides slide.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["presentationId", "pageObjectId"],
+            properties: slidesElementProperties({
+                shapeType: { type: "string" },
+            }),
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await createGoogleSlidesShape(parseSlidesCreateShapeInput(input))),
+            };
+        },
+    };
+    const slidesCreateTableTool = {
+        id: "google_slides_create_table",
+        name: "Google Slides create table",
+        description: "Create a table on a Google Slides slide.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["presentationId", "pageObjectId", "rows", "columns"],
+            properties: slidesElementProperties({
+                rows: { type: "number" },
+                columns: { type: "number" },
+            }),
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await createGoogleSlidesTable(parseSlidesCreateTableInput(input))),
+            };
+        },
+    };
+    const slidesUpdateTextStyleTool = {
+        id: "google_slides_update_text_style",
+        name: "Google Slides update text style",
+        description: "Update text style fields for a Google Slides text object.",
+        inputSchema: slidesStyleInputSchema("style"),
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await updateGoogleSlidesTextStyle(parseSlidesStyleObjectInput(input, "google_slides_update_text_style"))),
+            };
+        },
+    };
+    const slidesUpdateShapeStyleTool = {
+        id: "google_slides_update_shape_style",
+        name: "Google Slides update shape style",
+        description: "Update shape property fields for a Google Slides shape object.",
+        inputSchema: slidesStyleInputSchema("style"),
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await updateGoogleSlidesShapeStyle(parseSlidesStyleObjectInput(input, "google_slides_update_shape_style"))),
+            };
+        },
+    };
+    const slidesBatchUpdateTool = {
+        id: "google_slides_batch_update",
+        name: "Google Slides batch update",
+        description: "Apply advanced Google Slides batchUpdate requests to a presentation.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["presentationId", "requests"],
+            properties: {
+                presentationId: { type: "string" },
+                requests: {
+                    type: "array",
+                    items: { type: "object" },
+                    description: "Google Slides API batchUpdate requests. Use high-level tools when possible.",
+                },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await batchUpdateGoogleSlides(parseSlidesBatchUpdateInput(input))),
+            };
+        },
+    };
+    const driveCreateFolderTool = {
+        id: "google_drive_create_folder",
+        name: "Google Drive create folder",
+        description: "Create a Google Drive folder, optionally inside a parent folder id.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["name"],
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Folder name to create.",
+                },
+                parentId: {
+                    type: "string",
+                    description: "Optional parent folder id.",
+                },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await createGoogleDriveFolder(parseDriveCreateFolderInput(input))),
+            };
+        },
+    };
+    const driveCreateTextFileTool = {
+        id: "google_drive_create_text_file",
+        name: "Google Drive create text file",
+        description: "Create a plain text Google Drive file, optionally inside a parent folder id.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["name", "text"],
+            properties: {
+                name: {
+                    type: "string",
+                    description: "File name to create.",
+                },
+                text: {
+                    type: "string",
+                    description: "Text content to upload.",
+                },
+                parentId: {
+                    type: "string",
+                    description: "Optional parent folder id.",
+                },
+                mimeType: {
+                    type: "string",
+                    description: "Optional text MIME type. Defaults to text/plain.",
+                },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await createGoogleDriveTextFile(parseDriveCreateTextFileInput(input))),
+            };
+        },
+    };
+    const driveRenameFileTool = {
+        id: "google_drive_rename_file",
+        name: "Google Drive rename file",
+        description: "Rename a Google Drive file or folder by file id.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["fileId", "name"],
+            properties: {
+                fileId: {
+                    type: "string",
+                    description: "Google Drive file id to rename.",
+                },
+                name: {
+                    type: "string",
+                    description: "New file or folder name.",
+                },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await renameGoogleDriveFile(parseDriveRenameFileInput(input))),
+            };
+        },
+    };
+    const driveMoveFileTool = {
+        id: "google_drive_move_file",
+        name: "Google Drive move file",
+        description: "Move a Google Drive file or folder into a target folder by id.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["fileId", "targetFolderId"],
+            properties: {
+                fileId: {
+                    type: "string",
+                    description: "Google Drive file id to move.",
+                },
+                targetFolderId: {
+                    type: "string",
+                    description: "Destination Google Drive folder id.",
+                },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await moveGoogleDriveFile(parseDriveMoveFileInput(input))),
+            };
+        },
+    };
+    const driveTrashFileTool = {
+        id: "google_drive_trash_file",
+        name: "Google Drive trash file",
+        description: "Move a Google Drive file or folder to trash by file id. This does not permanently delete it.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["fileId"],
+            properties: {
+                fileId: {
+                    type: "string",
+                    description: "Google Drive file id to move to trash.",
+                },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await trashGoogleDriveFile(parseDriveFileIdInput(input, "google_drive_trash_file"))),
+            };
+        },
+    };
+    const docsCreateTool = {
+        id: "google_docs_create",
+        name: "Google Docs create",
+        description: "Create a native Google Doc with an optional initial Markdown-formatted body.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["title"],
+            properties: {
+                title: {
+                    type: "string",
+                    description: "Google Doc title.",
+                },
+                text: {
+                    type: "string",
+                    description: "Optional initial document text.",
+                },
+                format: {
+                    type: "string",
+                    enum: ["markdown", "plain_text"],
+                    description: "How to interpret text. Defaults to markdown for headings, bold, links, lists, separators, and simple tables.",
+                },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await createGoogleDoc(parseDocsCreateInput(input))),
+            };
+        },
+    };
+    const docsAppendTextTool = {
+        id: "google_docs_append_text",
+        name: "Google Docs append text",
+        description: "Append Markdown-formatted text to the end of a Google Doc by document id.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["documentId", "text"],
+            properties: {
+                documentId: {
+                    type: "string",
+                    description: "Google Docs document id.",
+                },
+                text: {
+                    type: "string",
+                    description: "Text to append.",
+                },
+                format: {
+                    type: "string",
+                    enum: ["markdown", "plain_text"],
+                    description: "How to interpret text. Defaults to markdown for headings, bold, links, lists, separators, and simple tables.",
+                },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await appendGoogleDocText(parseDocsTextInput(input, "google_docs_append_text"))),
+            };
+        },
+    };
+    const docsReplaceTextTool = {
+        id: "google_docs_replace_text",
+        name: "Google Docs replace text",
+        description: "Replace the full body of a Google Doc with Markdown-formatted text by document id.",
+        inputSchema: {
+            type: "object",
+            additionalProperties: false,
+            required: ["documentId", "text"],
+            properties: {
+                documentId: {
+                    type: "string",
+                    description: "Google Docs document id.",
+                },
+                text: {
+                    type: "string",
+                    description: "Replacement text for the document body.",
+                },
+                format: {
+                    type: "string",
+                    enum: ["markdown", "plain_text"],
+                    description: "How to interpret text. Defaults to markdown for headings, bold, links, lists, separators, and simple tables.",
+                },
+            },
+        },
+        permissionPolicy: "on-request",
+        async executor(input) {
+            return {
+                content: JSON.stringify(await replaceGoogleDocText(parseDocsTextInput(input, "google_docs_replace_text"))),
+            };
+        },
+    };
+    const tools = [
+        statusTool,
+        driveSearchTool,
+        driveExportTextTool,
+        driveMetadataTool,
+        driveCreateFolderTool,
+        driveCreateTextFileTool,
+        driveRenameFileTool,
+        driveMoveFileTool,
+        driveTrashFileTool,
+        docsCreateTool,
+        docsAppendTextTool,
+        docsReplaceTextTool,
+        sheetsMetadataTool,
+        sheetsReadRangeTool,
+        sheetsSearchValuesTool,
+        sheetsCreateTool,
+        sheetsUpdateRangeTool,
+        sheetsAppendRowsTool,
+        sheetsClearRangeTool,
+        sheetsAddSheetTool,
+        sheetsRenameSheetTool,
+        sheetsDeleteSheetTool,
+        sheetsFormatRangeTool,
+        sheetsBatchUpdateTool,
+        slidesMetadataTool,
+        slidesReadTextTool,
+        slidesCreateTool,
+        slidesCreateSlideTool,
+        slidesDeleteObjectTool,
+        slidesCreateTextBoxTool,
+        slidesReplaceTextTool,
+        slidesCreateImageTool,
+        slidesCreateShapeTool,
+        slidesCreateTableTool,
+        slidesUpdateTextStyleTool,
+        slidesUpdateShapeStyleTool,
+        slidesBatchUpdateTool,
+    ];
+    return {
+        definition: {
+            id: googleWorkspaceIntegrationId,
+            kind: googleWorkspaceIntegrationConfig.kind,
+            name: googleWorkspaceIntegrationConfig.name,
+            description: googleWorkspaceIntegrationConfig.description,
+            defaultEnabled: googleWorkspaceIntegrationConfig.defaultEnabled,
+            transport: {
+                kind: "oauth_api",
+                provider: "google",
+            },
+            auth: {
+                kind: "oauth",
+                provider: "google",
+                scopes: googleWorkspaceScopes,
+                secretRefPrefix: "secret_google_workspace",
+            },
+            skills: [
+                {
+                    name: "Google Workspace app connector",
+                    invocationName: "google-workspace",
+                    description: "Use enabled Google Workspace capabilities through typed connector tools. Do not use raw Google REST calls, shell commands, MCP-only paths, or prompt hints for built-in Google support.",
+                    triggerHints: ["google drive", "google docs", "google sheets"],
+                },
+            ],
+            tools: tools.map((tool) => ({
+                id: tool.id,
+                name: tool.name,
+                description: tool.description,
+                inputSchema: tool.inputSchema,
+                permissionPolicy: tool.permissionPolicy,
+                readOnly: tool.permissionPolicy !== "on-request",
+                approvalRequired: tool.permissionPolicy === "on-request",
+            })),
+        },
+        tools,
+    };
+}
+export async function checkGoogleWorkspaceIntegrationStatus(options) {
+    const secretStore = options?.secretStore ?? createSystemKeychainSecretStore();
+    let credential;
+    try {
+        credential = await loadGoogleOAuthCredential({
+            secretStore,
+            secretId: googleWorkspaceOAuthSecretId,
+        });
+    }
+    catch (error) {
+        if (isUnsupportedSystemKeychainError(error)) {
+            credential = undefined;
+        }
+        else {
+            throw error;
+        }
+    }
+    const metadata = getGoogleOAuthMetadata(credential);
+    if (metadata.authenticated) {
+        return {
+            id: googleWorkspaceIntegrationId,
+            status: "active",
+            message: metadata.email
+                ? `Google Workspace OAuth ${metadata.email}`
+                : "Google Workspace OAuth is active.",
+        };
+    }
+    return {
+        id: googleWorkspaceIntegrationId,
+        status: "setup_required",
+        message: "Google Workspace login required.",
+    };
+}
+function isUnsupportedSystemKeychainError(error) {
+    return (error instanceof Error &&
+        error.message.startsWith("System keychain SecretStore is not supported on "));
+}
+function parseDriveSearchInput(input) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        return {};
+    }
+    const record = input;
+    return {
+        ...(typeof record.query === "string" ? { query: record.query } : {}),
+        ...(typeof record.pageSize === "number" ? { pageSize: record.pageSize } : {}),
+        ...(typeof record.mimeType === "string" ? { mimeType: record.mimeType } : {}),
+        ...(isDriveScope(record.driveScope) ? { driveScope: record.driveScope } : {}),
+    };
+}
+function isDriveScope(value) {
+    return (value === "all_drives" ||
+        value === "my_drive" ||
+        value === "shared_with_me");
+}
+function parseDriveExportTextInput(input) {
+    return parseDriveFileIdInput(input, "google_drive_export_text");
+}
+function parseDriveFileIdInput(input, toolName) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        throw new Error(`${toolName} requires a fileId.`);
+    }
+    const fileId = input.fileId;
+    if (typeof fileId !== "string" || !fileId.trim()) {
+        throw new Error(`${toolName} requires a fileId.`);
+    }
+    return { fileId: fileId.trim() };
+}
+function parseDriveCreateFolderInput(input) {
+    const record = requireRecordInput(input, "google_drive_create_folder");
+    return {
+        name: requireString(record, "name", "google_drive_create_folder"),
+        ...optionalStringProperty(record, "parentId"),
+    };
+}
+function parseDriveCreateTextFileInput(input) {
+    const record = requireRecordInput(input, "google_drive_create_text_file");
+    return {
+        name: requireString(record, "name", "google_drive_create_text_file"),
+        text: requireString(record, "text", "google_drive_create_text_file"),
+        ...optionalStringProperty(record, "parentId"),
+        ...optionalStringProperty(record, "mimeType"),
+    };
+}
+function parseDriveRenameFileInput(input) {
+    const record = requireRecordInput(input, "google_drive_rename_file");
+    return {
+        fileId: requireString(record, "fileId", "google_drive_rename_file"),
+        name: requireString(record, "name", "google_drive_rename_file"),
+    };
+}
+function parseDriveMoveFileInput(input) {
+    const record = requireRecordInput(input, "google_drive_move_file");
+    return {
+        fileId: requireString(record, "fileId", "google_drive_move_file"),
+        targetFolderId: requireString(record, "targetFolderId", "google_drive_move_file"),
+    };
+}
+function parseDocsCreateInput(input) {
+    const record = requireRecordInput(input, "google_docs_create");
+    return {
+        title: requireString(record, "title", "google_docs_create"),
+        ...optionalStringProperty(record, "text"),
+        ...optionalDocsFormatProperty(record),
+    };
+}
+function parseDocsTextInput(input, toolName) {
+    const record = requireRecordInput(input, toolName);
+    return {
+        documentId: requireString(record, "documentId", toolName),
+        text: requireString(record, "text", toolName),
+        ...optionalDocsFormatProperty(record),
+    };
+}
+function requireRecordInput(input, toolName) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        throw new Error(`${toolName} requires an object input.`);
+    }
+    return input;
+}
+function requireString(record, key, toolName) {
+    const value = record[key];
+    if (typeof value !== "string" || !value.trim()) {
+        throw new Error(`${toolName} requires ${key}.`);
+    }
+    return value.trim();
+}
+function optionalStringProperty(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value.trim()
+        ? { [key]: value.trim() }
+        : {};
+}
+function optionalDocsFormatProperty(record) {
+    return record.format === "markdown" || record.format === "plain_text"
+        ? { format: record.format }
+        : {};
+}
+function slidesElementProperties(extra) {
+    return {
+        presentationId: { type: "string" },
+        objectId: { type: "string" },
+        pageObjectId: { type: "string" },
+        x: { type: "number" },
+        y: { type: "number" },
+        width: { type: "number" },
+        height: { type: "number" },
+        ...extra,
+    };
+}
+function slidesStyleInputSchema(styleKey) {
+    return {
+        type: "object",
+        additionalProperties: false,
+        required: ["presentationId", "objectId", styleKey, "fields"],
+        properties: {
+            presentationId: { type: "string" },
+            objectId: { type: "string" },
+            [styleKey]: { type: "object" },
+            fields: { type: "string" },
+        },
+    };
+}
+function parseSpreadsheetIdInput(input, toolName) {
+    if (!input || typeof input !== "object" || Array.isArray(input)) {
+        throw new Error(`${toolName} requires a spreadsheetId.`);
+    }
+    const spreadsheetId = input.spreadsheetId;
+    if (typeof spreadsheetId !== "string" || !spreadsheetId.trim()) {
+        throw new Error(`${toolName} requires a spreadsheetId.`);
+    }
+    return { spreadsheetId: spreadsheetId.trim() };
+}
+function parseSheetsReadRangeInput(input) {
+    const base = parseSpreadsheetIdInput(input, "google_sheets_read_range");
+    const range = input.range;
+    if (typeof range !== "string" || !range.trim()) {
+        throw new Error("google_sheets_read_range requires a range.");
+    }
+    return { ...base, range: range.trim() };
+}
+function parseSheetsCreateInput(input) {
+    const record = requireRecordInput(input, "google_sheets_create");
+    return { title: requireString(record, "title", "google_sheets_create") };
+}
+function parseSheetsWriteRangeInput(input, toolName) {
+    const base = parseSheetsReadRangeInput(input);
+    const record = input;
+    if (!Array.isArray(record.values) || !record.values.every(Array.isArray)) {
+        throw new Error(`${toolName} requires values as an array of rows.`);
+    }
+    return {
+        ...base,
+        values: record.values,
+        ...(record.valueInputOption === "RAW" ||
+            record.valueInputOption === "USER_ENTERED"
+            ? { valueInputOption: record.valueInputOption }
+            : {}),
+    };
+}
+function parseSheetsClearRangeInput(input) {
+    const base = parseSpreadsheetIdInput(input, "google_sheets_clear_range");
+    const range = input.range;
+    if (typeof range !== "string" || !range.trim()) {
+        throw new Error("google_sheets_clear_range requires a range.");
+    }
+    return { ...base, range: range.trim() };
+}
+function parseSheetsSheetInput(input, toolName) {
+    const record = requireRecordInput(input, toolName);
+    return {
+        spreadsheetId: requireString(record, "spreadsheetId", toolName),
+        title: requireString(record, "title", toolName),
+    };
+}
+function parseSheetsRenameSheetInput(input) {
+    const record = requireRecordInput(input, "google_sheets_rename_sheet");
+    return {
+        spreadsheetId: requireString(record, "spreadsheetId", "google_sheets_rename_sheet"),
+        sheetId: requireNumber(record, "sheetId", "google_sheets_rename_sheet"),
+        title: requireString(record, "title", "google_sheets_rename_sheet"),
+    };
+}
+function parseSheetsDeleteSheetInput(input) {
+    const record = requireRecordInput(input, "google_sheets_delete_sheet");
+    return {
+        spreadsheetId: requireString(record, "spreadsheetId", "google_sheets_delete_sheet"),
+        sheetId: requireNumber(record, "sheetId", "google_sheets_delete_sheet"),
+    };
+}
+function parseSheetsFormatRangeInput(input) {
+    const record = requireRecordInput(input, "google_sheets_format_range");
+    const userEnteredFormat = record.userEnteredFormat;
+    if (!userEnteredFormat || typeof userEnteredFormat !== "object" || Array.isArray(userEnteredFormat)) {
+        throw new Error("google_sheets_format_range requires userEnteredFormat.");
+    }
+    return {
+        spreadsheetId: requireString(record, "spreadsheetId", "google_sheets_format_range"),
+        sheetId: requireNumber(record, "sheetId", "google_sheets_format_range"),
+        ...optionalNumberProperty(record, "startRowIndex"),
+        ...optionalNumberProperty(record, "endRowIndex"),
+        ...optionalNumberProperty(record, "startColumnIndex"),
+        ...optionalNumberProperty(record, "endColumnIndex"),
+        userEnteredFormat: userEnteredFormat,
+        fields: requireString(record, "fields", "google_sheets_format_range"),
+    };
+}
+function parseSheetsBatchUpdateInput(input) {
+    const record = requireRecordInput(input, "google_sheets_batch_update");
+    if (!Array.isArray(record.requests) || !record.requests.every(isPlainObject)) {
+        throw new Error("google_sheets_batch_update requires requests.");
+    }
+    return {
+        spreadsheetId: requireString(record, "spreadsheetId", "google_sheets_batch_update"),
+        requests: record.requests,
+    };
+}
+function parseSlidesPresentationInput(input, toolName) {
+    const record = requireRecordInput(input, toolName);
+    return {
+        presentationId: requireString(record, "presentationId", toolName),
+    };
+}
+function parseSlidesCreateInput(input) {
+    const record = requireRecordInput(input, "google_slides_create");
+    return { title: requireString(record, "title", "google_slides_create") };
+}
+function parseSlidesCreateSlideInput(input) {
+    const record = requireRecordInput(input, "google_slides_create_slide");
+    return {
+        presentationId: requireString(record, "presentationId", "google_slides_create_slide"),
+        ...optionalStringProperty(record, "objectId"),
+        ...optionalNumberProperty(record, "insertionIndex"),
+        ...optionalStringProperty(record, "predefinedLayout"),
+    };
+}
+function parseSlidesObjectInput(input, toolName) {
+    const record = requireRecordInput(input, toolName);
+    return {
+        presentationId: requireString(record, "presentationId", toolName),
+        objectId: requireString(record, "objectId", toolName),
+    };
+}
+function parseSlidesCreateTextBoxInput(input) {
+    const record = requireRecordInput(input, "google_slides_create_text_box");
+    return {
+        ...parseSlidesElementInput(record, "google_slides_create_text_box"),
+        text: requireString(record, "text", "google_slides_create_text_box"),
+    };
+}
+function parseSlidesReplaceTextInput(input) {
+    const record = requireRecordInput(input, "google_slides_replace_text");
+    return {
+        presentationId: requireString(record, "presentationId", "google_slides_replace_text"),
+        containsText: requireString(record, "containsText", "google_slides_replace_text"),
+        replaceText: requireString(record, "replaceText", "google_slides_replace_text"),
+        ...(Array.isArray(record.pageObjectIds)
+            ? { pageObjectIds: record.pageObjectIds.filter((value) => typeof value === "string") }
+            : {}),
+    };
+}
+function parseSlidesCreateImageInput(input) {
+    const record = requireRecordInput(input, "google_slides_create_image");
+    return {
+        ...parseSlidesElementInput(record, "google_slides_create_image"),
+        url: requireString(record, "url", "google_slides_create_image"),
+    };
+}
+function parseSlidesCreateShapeInput(input) {
+    const record = requireRecordInput(input, "google_slides_create_shape");
+    return {
+        ...parseSlidesElementInput(record, "google_slides_create_shape"),
+        ...optionalStringProperty(record, "shapeType"),
+    };
+}
+function parseSlidesCreateTableInput(input) {
+    const record = requireRecordInput(input, "google_slides_create_table");
+    return {
+        ...parseSlidesElementInput(record, "google_slides_create_table"),
+        rows: requirePositiveInteger(record, "rows", "google_slides_create_table"),
+        columns: requirePositiveInteger(record, "columns", "google_slides_create_table"),
+    };
+}
+function parseSlidesStyleObjectInput(input, toolName) {
+    const record = requireRecordInput(input, toolName);
+    const style = record.style;
+    if (!isPlainObject(style)) {
+        throw new Error(`${toolName} requires style.`);
+    }
+    return {
+        presentationId: requireString(record, "presentationId", toolName),
+        objectId: requireString(record, "objectId", toolName),
+        style,
+        fields: requireString(record, "fields", toolName),
+    };
+}
+function parseSlidesBatchUpdateInput(input) {
+    const record = requireRecordInput(input, "google_slides_batch_update");
+    if (!Array.isArray(record.requests) || !record.requests.every(isPlainObject)) {
+        throw new Error("google_slides_batch_update requires requests.");
+    }
+    return {
+        presentationId: requireString(record, "presentationId", "google_slides_batch_update"),
+        requests: record.requests,
+    };
+}
+function parseSlidesElementInput(record, toolName) {
+    return {
+        presentationId: requireString(record, "presentationId", toolName),
+        ...optionalStringProperty(record, "objectId"),
+        pageObjectId: requireString(record, "pageObjectId", toolName),
+        ...optionalNumberProperty(record, "x"),
+        ...optionalNumberProperty(record, "y"),
+        ...optionalNumberProperty(record, "width"),
+        ...optionalNumberProperty(record, "height"),
+    };
+}
+function parseSheetsSearchValuesInput(input) {
+    const base = parseSpreadsheetIdInput(input, "google_sheets_search_values");
+    const record = input;
+    const query = record.query;
+    if (typeof query !== "string" || !query.trim()) {
+        throw new Error("google_sheets_search_values requires a query.");
+    }
+    return {
+        ...base,
+        query: query.trim(),
+        ...(Array.isArray(record.ranges)
+            ? { ranges: record.ranges.filter((value) => typeof value === "string") }
+            : {}),
+        ...(typeof record.maxMatches === "number" ? { maxMatches: record.maxMatches } : {}),
+    };
+}
+function requireNumber(record, key, toolName) {
+    const value = record[key];
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error(`${toolName} requires ${key}.`);
+    }
+    return value;
+}
+function requirePositiveInteger(record, key, toolName) {
+    const value = requireNumber(record, key, toolName);
+    if (!Number.isInteger(value) || value < 1) {
+        throw new Error(`${toolName} requires ${key} to be a positive integer.`);
+    }
+    return value;
+}
+function optionalNumberProperty(record, key) {
+    const value = record[key];
+    return typeof value === "number" && Number.isFinite(value)
+        ? { [key]: value }
+        : {};
+}
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+//# sourceMappingURL=google-workspace-integration.js.map