@rnsk/toolkits 0.0.11 → 0.0.12

package/dist/toolkits/gmail/manifest.js

@@ -1,6 +1,6 @@
 import { defineToolkit, defineTool } from '../../core/define.js';
 import { GMAIL_ICON } from './icon.js';
-import { listMessages, getMessage, sendMessage, createDraft, listDrafts, getDraft, sendDraft, deleteDraft, listThreads, getThread, replyToThread, listLabels, modifyMessageLabels, trashMessage, untrashMessage, batchDeleteMessages, batchModifyMessages, createFilter, createLabel, deleteFilter, deleteLabel, deleteMessage, deleteThread, forwardMessage, getAttachment, getAutoForwarding, getContacts, getFilter, } from './tools/index.js';
+import { listMessages, getMessage, sendMessage, createDraft, listDrafts, getDraft, sendDraft, deleteDraft, listThreads, getThread, replyToThread, listLabels, modifyMessageLabels, trashMessage, untrashMessage, batchDeleteMessages, batchModifyMessages, createFilter, createLabel, deleteFilter, deleteLabel, deleteMessage, deleteThread, forwardMessage, getAttachment, getAutoForwarding, getContacts, getFilter, fetchEmails, getLabel, getLanguageSettings, getPeople, getProfile, getVacationSettings, importMessage, insertMessage, listCseIdentities, listCseKeypairs, listFilters, listForwardingAddresses, listHistory, listSendAs, listSmimeInfo, modifyThreadLabels, moveThreadToTrash, patchLabel, patchSendAs, searchPeople, settingsGetImap, settingsGetPop, settingsSendAsGet, stopWatch, untrashThread, updateDraft, updateImapSettings, updateLabel, updateLanguageSettings, updatePopSettings, updateSendAs, updateVacationSettings, whoAmI, } from './tools/index.js';
 export default defineToolkit({
     id: 'gmail',
     displayName: 'Gmail',
@@ -22,7 +22,12 @@ export default defineToolkit({
                 'https://www.googleapis.com/auth/gmail.modify',
                 'https://www.googleapis.com/auth/gmail.labels',
                 'https://www.googleapis.com/auth/gmail.settings.basic',
+                'https://www.googleapis.com/auth/gmail.settings.sharing',
+                'https://www.googleapis.com/auth/gmail.insert',
                 'https://www.googleapis.com/auth/contacts.readonly',
+                'https://www.googleapis.com/auth/contacts.other.readonly',
+                'openid',
+                'https://www.googleapis.com/auth/userinfo.email',
             ],
             exchangeStyle: 'form',
             extraAuthParams: { access_type: 'offline', prompt: 'consent' },
@@ -201,6 +206,204 @@ export default defineToolkit({
             requiredAuth: 'gmailToken',
             scope: 'read',
         }),
+        defineTool({
+            name: 'gmailFetchEmails',
+            tool: fetchEmails,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailGetLabel',
+            tool: getLabel,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailGetLanguageSettings',
+            tool: getLanguageSettings,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailGetPeople',
+            tool: getPeople,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailGetProfile',
+            tool: getProfile,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailGetVacationSettings',
+            tool: getVacationSettings,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailImportMessage',
+            tool: importMessage,
+            requiredAuth: 'gmailToken',
+            scope: 'write',
+        }),
+        defineTool({
+            name: 'gmailInsertMessage',
+            tool: insertMessage,
+            requiredAuth: 'gmailToken',
+            scope: 'write',
+        }),
+        defineTool({
+            name: 'gmailListCseIdentities',
+            tool: listCseIdentities,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailListCseKeypairs',
+            tool: listCseKeypairs,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailListFilters',
+            tool: listFilters,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailListForwardingAddresses',
+            tool: listForwardingAddresses,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailListHistory',
+            tool: listHistory,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailListSendAs',
+            tool: listSendAs,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailListSmimeInfo',
+            tool: listSmimeInfo,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailModifyThreadLabels',
+            tool: modifyThreadLabels,
+            requiredAuth: 'gmailToken',
+            scope: 'write',
+        }),
+        defineTool({
+            name: 'gmailMoveThreadToTrash',
+            tool: moveThreadToTrash,
+            requiredAuth: 'gmailToken',
+            scope: 'delete',
+        }),
+        defineTool({
+            name: 'gmailPatchLabel',
+            tool: patchLabel,
+            requiredAuth: 'gmailToken',
+            scope: 'write',
+        }),
+        defineTool({
+            name: 'gmailPatchSendAs',
+            tool: patchSendAs,
+            requiredAuth: 'gmailToken',
+            scope: 'write',
+        }),
+        defineTool({
+            name: 'gmailSearchPeople',
+            tool: searchPeople,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailSettingsGetImap',
+            tool: settingsGetImap,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailSettingsGetPop',
+            tool: settingsGetPop,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailSettingsSendAsGet',
+            tool: settingsSendAsGet,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailStopWatch',
+            tool: stopWatch,
+            requiredAuth: 'gmailToken',
+            scope: 'delete',
+        }),
+        defineTool({
+            name: 'gmailUntrashThread',
+            tool: untrashThread,
+            requiredAuth: 'gmailToken',
+            scope: 'write',
+        }),
+        defineTool({
+            name: 'gmailUpdateDraft',
+            tool: updateDraft,
+            requiredAuth: 'gmailToken',
+            scope: 'write',
+        }),
+        defineTool({
+            name: 'gmailUpdateImapSettings',
+            tool: updateImapSettings,
+            requiredAuth: 'gmailToken',
+            scope: 'write',
+        }),
+        defineTool({
+            name: 'gmailUpdateLabel',
+            tool: updateLabel,
+            requiredAuth: 'gmailToken',
+            scope: 'write',
+        }),
+        defineTool({
+            name: 'gmailUpdateLanguageSettings',
+            tool: updateLanguageSettings,
+            requiredAuth: 'gmailToken',
+            scope: 'write',
+        }),
+        defineTool({
+            name: 'gmailUpdatePopSettings',
+            tool: updatePopSettings,
+            requiredAuth: 'gmailToken',
+            scope: 'write',
+        }),
+        defineTool({
+            name: 'gmailUpdateSendAs',
+            tool: updateSendAs,
+            requiredAuth: 'gmailToken',
+            scope: 'write',
+        }),
+        defineTool({
+            name: 'gmailUpdateVacationSettings',
+            tool: updateVacationSettings,
+            requiredAuth: 'gmailToken',
+            scope: 'write',
+        }),
+        defineTool({
+            name: 'gmailWhoAmI',
+            tool: whoAmI,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
     ],
     meta: { since: '0.0.1' },
 });

package/dist/toolkits/gmail/tools/create-label.d.ts

@@ -1,10 +1,10 @@
 export declare const createLabel: import("ai").Tool<{
     labelName: string;
     gmailToken?: string | undefined;
-    labelListVisibility?: "labelShow" | "labelShowIfUnread" | "labelHide" | undefined;
-    messageListVisibility?: "show" | "hide" | undefined;
     textColor?: string | undefined;
     backgroundColor?: string | undefined;
+    messageListVisibility?: "show" | "hide" | undefined;
+    labelListVisibility?: "labelShow" | "labelShowIfUnread" | "labelHide" | undefined;
 }, {
     error: string;
     details: any;

package/dist/toolkits/gmail/tools/index.d.ts

@@ -1,4 +1,9 @@
 export * from './utils.js';
+export * from './settings.js';
+export * from './labels-threads.js';
+export * from './mailbox.js';
+export * from './messages-extra.js';
+export * from './people-extra.js';
 export * from './list-messages.js';
 export * from './get-message.js';
 export * from './send-message.js';

package/dist/toolkits/gmail/tools/index.js

@@ -1,4 +1,9 @@
 export * from './utils.js';
+export * from './settings.js';
+export * from './labels-threads.js';
+export * from './mailbox.js';
+export * from './messages-extra.js';
+export * from './people-extra.js';
 export * from './list-messages.js';
 export * from './get-message.js';
 export * from './send-message.js';

package/dist/toolkits/gmail/tools/labels-threads.d.ts

@@ -0,0 +1,47 @@
+export declare const getLabel: import("ai").Tool<{
+    id: string;
+    userId: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const patchLabel: import("ai").Tool<{
+    id: string;
+    userId: string;
+    gmailToken?: string | undefined;
+    name?: string | undefined;
+    messageListVisibility?: "show" | "hide" | undefined;
+    labelListVisibility?: "labelShow" | "labelShowIfUnread" | "labelHide" | undefined;
+    color?: {
+        textColor: string;
+        backgroundColor: string;
+    } | undefined;
+}, any>;
+export declare const updateLabel: import("ai").Tool<{
+    id: string;
+    userId: string;
+    gmailToken?: string | undefined;
+    name?: string | undefined;
+    messageListVisibility?: "show" | "hide" | undefined;
+    labelListVisibility?: "labelShow" | "labelShowIfUnread" | "labelHide" | undefined;
+    color?: {
+        textColor: string;
+        backgroundColor: string;
+    } | undefined;
+}, any>;
+export declare const modifyThreadLabels: import("ai").Tool<{
+    userId: string;
+    threadId: string;
+    gmailToken?: string | undefined;
+    addLabelIds?: string[] | undefined;
+    removeLabelIds?: string[] | undefined;
+}, any>;
+export declare const moveThreadToTrash: import("ai").Tool<{
+    userId: string;
+    threadId: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const untrashThread: import("ai").Tool<{
+    userId: string;
+    threadId: string;
+    gmailToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=labels-threads.d.ts.map

package/dist/toolkits/gmail/tools/labels-threads.js

@@ -0,0 +1,110 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+const userField = z.string().optional().default('me').describe("User's email address or 'me' for the authenticated user");
+async function gmailFetch(token, path, init, label = 'Gmail request') {
+    try {
+        const response = await fetch(`https://gmail.googleapis.com/gmail/v1${path}`, {
+            ...init,
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json',
+                ...(init?.headers || {}),
+            },
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({}));
+            return { error: `Failed to ${label}`, details: error };
+        }
+        if (response.status === 204)
+            return { success: true };
+        return await response.json();
+    }
+    catch (error) {
+        return {
+            error: `Error in ${label}`,
+            message: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+export const getLabel = tool({
+    description: 'Get label details (name, type, visibility, message/thread counts, color) by label ID.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        id: z.string().describe("Label ID: system (INBOX, SENT, ...) or custom ('Label_1')"),
+    }),
+    execute: async ({ gmailToken, userId, id }) => gmailFetch(gmailToken, `/users/${userId}/labels/${id}`, undefined, 'get label'),
+});
+const colorSchema = z.object({
+    textColor: z.string().describe('Hex from Gmail palette, e.g. #000000'),
+    backgroundColor: z.string().describe('Hex from Gmail palette, e.g. #ffffff'),
+});
+export const patchLabel = tool({
+    description: 'Partially update a user label (name, visibility, color with both subfields). System labels are rejected.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        id: z.string().describe('User label ID to update'),
+        name: z.string().optional().describe('New display name (non-empty, unique, no commas)'),
+        messageListVisibility: z.enum(['show', 'hide']).optional(),
+        labelListVisibility: z.enum(['labelShow', 'labelShowIfUnread', 'labelHide']).optional(),
+        color: colorSchema.optional().describe('Both subfields required, Gmail palette only'),
+    }),
+    execute: async ({ gmailToken, userId, id, ...body }) => {
+        const payload = {};
+        for (const [k, v] of Object.entries(body))
+            if (v !== undefined)
+                payload[k] = v;
+        return gmailFetch(gmailToken, `/users/${userId}/labels/${id}`, { method: 'PATCH', body: JSON.stringify(payload) }, 'patch label');
+    },
+});
+export const updateLabel = tool({
+    description: 'Fully update a user label (PUT). Same fields as patch; provide the complete desired state.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        id: z.string().describe('User label ID to update'),
+        name: z.string().optional(),
+        messageListVisibility: z.enum(['show', 'hide']).optional(),
+        labelListVisibility: z.enum(['labelShow', 'labelShowIfUnread', 'labelHide']).optional(),
+        color: colorSchema.optional(),
+    }),
+    execute: async ({ gmailToken, userId, id, ...body }) => {
+        const payload = {};
+        for (const [k, v] of Object.entries(body))
+            if (v !== undefined)
+                payload[k] = v;
+        return gmailFetch(gmailToken, `/users/${userId}/labels/${id}`, { method: 'PUT', body: JSON.stringify(payload) }, 'update label');
+    },
+});
+export const modifyThreadLabels = tool({
+    description: 'Add/remove label IDs on a whole thread (all messages). For single messages use modify-message-labels instead.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        threadId: z.string().describe('Thread ID to modify'),
+        addLabelIds: z.array(z.string()).optional().describe("Label IDs to add (add wins on overlap)"),
+        removeLabelIds: z.array(z.string()).optional().describe('Label IDs to remove'),
+    }),
+    execute: async ({ gmailToken, userId, threadId, addLabelIds, removeLabelIds }) => gmailFetch(gmailToken, `/users/${userId}/threads/${threadId}/modify`, { method: 'POST', body: JSON.stringify({ addLabelIds, removeLabelIds }) }, 'modify thread labels'),
+});
+export const moveThreadToTrash = tool({
+    description: 'Move a thread and all its messages to trash (recoverable via untrash-thread).',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        threadId: z.string().describe('Thread ID to trash'),
+    }),
+    execute: async ({ gmailToken, userId, threadId }) => gmailFetch(gmailToken, `/users/${userId}/threads/${threadId}/trash`, { method: 'POST' }, 'trash thread'),
+});
+export const untrashThread = tool({
+    description: 'Restore a trashed thread and its messages.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        threadId: z.string().describe('Thread ID to restore'),
+    }),
+    execute: async ({ gmailToken, userId, threadId }) => gmailFetch(gmailToken, `/users/${userId}/threads/${threadId}/untrash`, { method: 'POST' }, 'untrash thread'),
+});
+//# sourceMappingURL=labels-threads.js.map

package/dist/toolkits/gmail/tools/list-drafts.d.ts

@@ -1,8 +1,8 @@
 export declare const listDrafts: import("ai").Tool<{
     maxResults: number;
     gmailToken?: string | undefined;
-    q?: string | undefined;
     pageToken?: string | undefined;
+    q?: string | undefined;
 }, {
     error: string;
     details: any;

package/dist/toolkits/gmail/tools/list-threads.d.ts

@@ -1,8 +1,8 @@
 export declare const listThreads: import("ai").Tool<{
     maxResults: number;
     gmailToken?: string | undefined;
-    q?: string | undefined;
     pageToken?: string | undefined;
+    q?: string | undefined;
 }, {
     error: string;
     details: any;

package/dist/toolkits/gmail/tools/mailbox.d.ts

@@ -0,0 +1,46 @@
+export declare const listFilters: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const listHistory: import("ai").Tool<{
+    userId: string;
+    startHistoryId: string;
+    gmailToken?: string | undefined;
+    labelId?: string | undefined;
+    historyTypes?: ("messageAdded" | "messageDeleted" | "labelAdded" | "labelRemoved")[] | undefined;
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+}, any>;
+export declare const listCseIdentities: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+export declare const listCseKeypairs: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+}, any>;
+export declare const importMessage: import("ai").Tool<{
+    userId: string;
+    raw: string;
+    gmailToken?: string | undefined;
+    deleted?: boolean | undefined;
+    neverMarkSpam?: boolean | undefined;
+    internalDateSource?: "receivedTime" | "dateHeader" | undefined;
+    processForCalendar?: boolean | undefined;
+}, any>;
+export declare const insertMessage: import("ai").Tool<{
+    userId: string;
+    raw: string;
+    gmailToken?: string | undefined;
+    deleted?: boolean | undefined;
+    internalDateSource?: "receivedTime" | "dateHeader" | undefined;
+}, any>;
+export declare const stopWatch: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=mailbox.d.ts.map

package/dist/toolkits/gmail/tools/mailbox.js

@@ -0,0 +1,142 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+const userField = z.string().optional().default('me').describe("User's email address or 'me' for the authenticated user");
+async function gmailFetch(token, path, init, label = 'Gmail request') {
+    try {
+        const response = await fetch(`https://gmail.googleapis.com/gmail/v1${path}`, {
+            ...init,
+            headers: {
+                Authorization: `Bearer ${token}`,
+                'Content-Type': 'application/json',
+                ...(init?.headers || {}),
+            },
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({}));
+            return { error: `Failed to ${label}`, details: error };
+        }
+        if (response.status === 204)
+            return { success: true };
+        return await response.json();
+    }
+    catch (error) {
+        return {
+            error: `Error in ${label}`,
+            message: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+export const listFilters = tool({
+    description: 'List all Gmail filters. Audit for malicious rules or check for duplicates before creating new ones.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+    }),
+    execute: async ({ gmailToken, userId }) => gmailFetch(gmailToken, `/users/${userId}/settings/filters`, undefined, 'list filters'),
+});
+export const listHistory = tool({
+    description: 'List mailbox changes since a history ID for incremental sync. Persist the newest historyId as checkpoint; empty history is valid (no changes).',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        startHistoryId: z.string().describe('Numeric history ID to sync from (get via get-profile)'),
+        labelId: z.string().optional().describe('Restrict to changes on this label, e.g. INBOX'),
+        historyTypes: z.array(z.enum(['messageAdded', 'messageDeleted', 'labelAdded', 'labelRemoved'])).optional(),
+        maxResults: z.number().int().min(1).max(500).optional().describe('Records per page (default 100, max 500)'),
+        pageToken: z.string().optional().describe('Next page token; loop until absent'),
+    }),
+    execute: async ({ gmailToken, userId, startHistoryId, labelId, historyTypes, maxResults, pageToken }) => {
+        const params = new URLSearchParams({ startHistoryId });
+        if (labelId)
+            params.append('labelId', labelId);
+        if (maxResults)
+            params.append('maxResults', String(maxResults));
+        if (pageToken)
+            params.append('pageToken', pageToken);
+        for (const t of historyTypes || [])
+            params.append('historyTypes', t);
+        return gmailFetch(gmailToken, `/users/${userId}/history?${params.toString()}`, undefined, 'list history');
+    },
+});
+export const listCseIdentities = tool({
+    description: 'List client-side encryption sending identities with key-pair associations (Workspace CSE only).',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        pageSize: z.number().int().min(1).optional().describe('Identities per page (default 20)'),
+        pageToken: z.string().optional(),
+    }),
+    execute: async ({ gmailToken, userId, pageSize, pageToken }) => {
+        const params = new URLSearchParams();
+        if (pageSize)
+            params.append('pageSize', String(pageSize));
+        if (pageToken)
+            params.append('pageToken', pageToken);
+        const qs = params.toString() ? `?${params.toString()}` : '';
+        return gmailFetch(gmailToken, `/users/${userId}/settings/cse/identities${qs}`, undefined, 'list CSE identities');
+    },
+});
+export const listCseKeypairs = tool({
+    description: 'List client-side encryption key pairs (public certs, enablement state). Paginate with page tokens.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        pageSize: z.number().int().min(1).optional().describe('Key pairs per page (default 20)'),
+        pageToken: z.string().optional().describe('Omit for the first page'),
+    }),
+    execute: async ({ gmailToken, userId, pageSize, pageToken }) => {
+        const params = new URLSearchParams();
+        if (pageSize)
+            params.append('pageSize', String(pageSize));
+        if (pageToken)
+            params.append('pageToken', pageToken);
+        const qs = params.toString() ? `?${params.toString()}` : '';
+        return gmailFetch(gmailToken, `/users/${userId}/settings/cse/keypairs${qs}`, undefined, 'list CSE key pairs');
+    },
+});
+export const importMessage = tool({
+    description: 'Import an RFC 2822 base64url message with delivery scanning/classification (no SMTP, no SPF checks).',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        raw: z.string().describe('Full RFC 2822 message, base64url-encoded'),
+        deleted: z.boolean().optional().describe('Vault-only delete (Workspace only)'),
+        neverMarkSpam: z.boolean().optional().describe('Bypass spam classifier'),
+        internalDateSource: z.enum(['receivedTime', 'dateHeader']).optional(),
+        processForCalendar: z.boolean().optional().describe('Extract calendar invites to Google Calendar'),
+    }),
+    execute: async ({ gmailToken, userId, ...body }) => {
+        const payload = {};
+        for (const [k, v] of Object.entries(body))
+            if (v !== undefined)
+                payload[k] = v;
+        return gmailFetch(gmailToken, `/users/${userId}/messages/import`, { method: 'POST', body: JSON.stringify(payload) }, 'import message');
+    },
+});
+export const insertMessage = tool({
+    description: 'Insert an RFC 2822 base64url message directly (IMAP APPEND equivalent), bypassing most scanning. Does not send.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        raw: z.string().describe('Full RFC 2822 message, base64url-encoded'),
+        deleted: z.boolean().optional().describe('Vault-only delete (Workspace only)'),
+        internalDateSource: z.enum(['receivedTime', 'dateHeader']).optional(),
+    }),
+    execute: async ({ gmailToken, userId, ...body }) => {
+        const payload = {};
+        for (const [k, v] of Object.entries(body))
+            if (v !== undefined)
+                payload[k] = v;
+        return gmailFetch(gmailToken, `/users/${userId}/messages`, { method: 'POST', body: JSON.stringify(payload) }, 'insert message');
+    },
+});
+export const stopWatch = tool({
+    description: 'Stop Gmail push notifications for the mailbox previously configured via watch.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+    }),
+    execute: async ({ gmailToken, userId }) => gmailFetch(gmailToken, `/users/${userId}/stop`, { method: 'POST' }, 'stop watch'),
+});
+//# sourceMappingURL=mailbox.js.map

package/dist/toolkits/gmail/tools/messages-extra.d.ts

@@ -0,0 +1,34 @@
+export declare const fetchEmails: import("ai").Tool<{
+    userId: string;
+    query?: string | undefined;
+    gmailToken?: string | undefined;
+    maxResults?: number | undefined;
+    pageToken?: string | undefined;
+    labelIds?: string[] | undefined;
+    includeSpamTrash?: boolean | undefined;
+    idsOnly?: boolean | undefined;
+    includePayload?: boolean | undefined;
+}, any>;
+export declare const getProfile: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const whoAmI: import("ai").Tool<{
+    gmailToken?: string | undefined;
+}, any>;
+export declare const updateDraft: import("ai").Tool<{
+    userId: string;
+    draftId: string;
+    body?: string | undefined;
+    gmailToken?: string | undefined;
+    threadId?: string | undefined;
+    recipientEmail?: string | undefined;
+    extraRecipients?: string[] | undefined;
+    cc?: string[] | undefined;
+    bcc?: string[] | undefined;
+    subject?: string | undefined;
+    isHtml?: boolean | undefined;
+    attachmentUrl?: string | undefined;
+    attachmentName?: string | undefined;
+}, any>;
+//# sourceMappingURL=messages-extra.d.ts.map