@rnsk/toolkits 0.0.11 → 0.0.12

package/dist/toolkits/gmail/tools/messages-extra.js

@@ -0,0 +1,176 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { encodeBase64Url, encodeMultipartMessage, extractMessageDetails } from './utils.js';
+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 fetchEmails = tool({
+    description: 'Search/list emails with optional hydration: ids_only (fastest), metadata, or full payload. Sort by internalDate client-side; loop page tokens for full coverage.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        query: z.string().optional().describe("Search query, e.g. 'from:x is:unread' (use 'is:' for states, 'label:' only for custom labels)"),
+        labelIds: z.array(z.string()).optional().describe('AND filter by label IDs (custom labels need Label_XXX IDs from list-labels)'),
+        maxResults: z.number().int().min(1).max(500).optional().describe('Messages per page (default 10)'),
+        pageToken: z.string().optional().describe('Next page token; loop until absent'),
+        includeSpamTrash: z.boolean().optional().describe('Include SPAM and TRASH'),
+        idsOnly: z.boolean().optional().describe('Return only IDs/thread IDs (fastest)'),
+        includePayload: z.boolean().optional().describe('Hydrate full payload per message (default true unless idsOnly)'),
+    }),
+    execute: async ({ gmailToken, userId, query, labelIds, maxResults, pageToken, includeSpamTrash, idsOnly, includePayload }) => {
+        const params = new URLSearchParams();
+        if (query)
+            params.append('q', query);
+        if (maxResults)
+            params.append('maxResults', String(maxResults));
+        if (pageToken)
+            params.append('pageToken', pageToken);
+        if (includeSpamTrash)
+            params.append('includeSpamTrash', 'true');
+        for (const id of labelIds || [])
+            params.append('labelIds', id);
+        const list = await gmailFetch(gmailToken, `/users/${userId}/messages?${params.toString()}`, undefined, 'list emails');
+        if (list?.error || idsOnly)
+            return list;
+        const hydrate = includePayload !== false;
+        const messages = await Promise.all((list?.messages || []).map(async (m) => {
+            const full = await gmailFetch(gmailToken, `/users/${userId}/messages/${m.id}?format=${hydrate ? 'full' : 'metadata'}`, undefined, 'hydrate email');
+            if (full?.error)
+                return { messageId: m.id, threadId: m.threadId, error: full.error };
+            return hydrate ? extractMessageDetails(full) : full;
+        }));
+        return { ...list, messages };
+    },
+});
+export const getProfile = tool({
+    description: 'Get mailbox profile (primary email, message/thread totals, historyId). historyId seeds incremental sync via list-history.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+    }),
+    execute: async ({ gmailToken, userId }) => gmailFetch(gmailToken, `/users/${userId}/profile`, undefined, 'get profile'),
+});
+export const whoAmI = tool({
+    description: 'Return the connected account identity (sub, name, email, hosted domain) via userinfo + Gmail profile.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+    }),
+    execute: async ({ gmailToken }) => {
+        try {
+            const [userinfo, profile] = await Promise.all([
+                fetch('https://www.googleapis.com/oauth2/v3/userinfo', {
+                    headers: { Authorization: `Bearer ${gmailToken}` },
+                }).then((r) => (r.ok ? r.json() : null)).catch(() => null),
+                gmailFetch(gmailToken, '/users/me/profile', undefined, 'get profile'),
+            ]);
+            if (!userinfo && profile?.error)
+                return profile;
+            return {
+                sub: userinfo?.sub ?? null,
+                name: userinfo?.name ?? null,
+                email: userinfo?.email ?? profile?.emailAddress ?? null,
+                hosted_domain: userinfo?.hd ?? null,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error getting identity',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+function buildMime(input) {
+    const lines = [
+        `To: ${input.to.join(', ')}`,
+        input.cc?.length ? `Cc: ${input.cc.join(', ')}` : null,
+        input.bcc?.length ? `Bcc: ${input.bcc.join(', ')}` : null,
+        `Subject: ${input.subject ?? ''}`,
+        'MIME-Version: 1.0',
+        `Content-Type: ${input.isHtml ? 'text/html' : 'text/plain'}; charset="UTF-8"`,
+        'Content-Transfer-Encoding: 8bit',
+    ].filter(Boolean);
+    let body = input.body ?? '';
+    if (!input.isHtml)
+        body = body.replace(/\n/g, '<br/>');
+    return encodeBase64Url(`${lines.join('\n')}\n\n${body}`);
+}
+async function fetchPublicUrlBytes(url) {
+    try {
+        const response = await fetch(url);
+        if (!response.ok)
+            return null;
+        const buffer = Buffer.from(await response.arrayBuffer());
+        return {
+            data: buffer.toString('base64'),
+            mimeType: response.headers.get('content-type') || 'application/octet-stream',
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export const updateDraft = tool({
+    description: 'Replace a draft entirely by ID (full replace, not patch). Provide complete content; attachments via public URL only.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        draftId: z.string().describe('Draft ID from list-drafts or create-draft'),
+        recipientEmail: z.string().optional().describe('Primary To recipient'),
+        extraRecipients: z.array(z.string()).optional().describe('Additional To recipients'),
+        cc: z.array(z.string()).optional(),
+        bcc: z.array(z.string()).optional(),
+        subject: z.string().optional(),
+        body: z.string().optional().describe('Plain text or HTML (set isHtml for HTML)'),
+        isHtml: z.boolean().optional(),
+        threadId: z.string().optional().describe('Keep the draft in this thread'),
+        attachmentUrl: z.string().optional().describe('Public file URL to attach (Drive links for >25 MB total)'),
+        attachmentName: z.string().optional().describe('Filename for the attached URL'),
+    }),
+    execute: async ({ gmailToken, userId, draftId, recipientEmail, extraRecipients, cc, bcc, subject, body, isHtml, threadId, attachmentUrl, attachmentName }) => {
+        const to = [recipientEmail, ...(extraRecipients || [])].filter(Boolean);
+        let raw = buildMime({ to, cc, bcc, subject, body, isHtml, threadId });
+        if (attachmentUrl) {
+            const fetched = await fetchPublicUrlBytes(attachmentUrl);
+            if (!fetched)
+                return { error: 'Failed to update draft', details: 'Attachment URL could not be fetched (must be public)' };
+            raw = encodeMultipartMessage({
+                to: to.join(', '),
+                subject: subject ?? '',
+                body: body ?? '',
+                cc: cc?.join(', '),
+                bcc: bcc?.join(', '),
+                attachments: [{ filename: attachmentName || 'attachment', mimeType: fetched.mimeType, data: fetched.data }],
+            });
+        }
+        const payload = { message: { raw } };
+        if (threadId)
+            payload.message.threadId = threadId;
+        return gmailFetch(gmailToken, `/users/${userId}/drafts/${draftId}`, { method: 'PUT', body: JSON.stringify(payload) }, 'update draft');
+    },
+});
+//# sourceMappingURL=messages-extra.js.map

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

@@ -0,0 +1,18 @@
+export declare const getPeople: import("ai").Tool<{
+    gmailToken?: string | undefined;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+    resourceName?: string | undefined;
+    personFields?: string | undefined;
+    otherContacts?: boolean | undefined;
+    syncToken?: string | undefined;
+    sources?: ("READ_SOURCE_TYPE_CONTACT" | "READ_SOURCE_TYPE_PROFILE")[] | undefined;
+}, any>;
+export declare const searchPeople: import("ai").Tool<{
+    query: string;
+    gmailToken?: string | undefined;
+    pageToken?: string | undefined;
+    pageSize?: number | undefined;
+    personFields?: string | undefined;
+}, any>;
+//# sourceMappingURL=people-extra.d.ts.map

package/dist/toolkits/gmail/tools/people-extra.js

@@ -0,0 +1,67 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+const tokenField = z.string().optional().describe('Injected by system; do not provide');
+async function peopleFetch(token, path, params, label) {
+    try {
+        const qs = new URLSearchParams();
+        for (const [k, v] of Object.entries(params))
+            if (v)
+                qs.append(k, v);
+        const url = `https://people.googleapis.com/v1/${path}${qs.toString() ? `?${qs.toString()}` : ''}`;
+        const response = await fetch(url, { headers: { Authorization: `Bearer ${token}` } });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({}));
+            return { error: `Failed to ${label}`, details: error };
+        }
+        return await response.json();
+    }
+    catch (error) {
+        return {
+            error: `Error in ${label}`,
+            message: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+const personFieldsField = z.string().optional().describe("Comma-separated mask, e.g. 'names,emailAddresses' (other-contacts mode allows only emailAddresses, names, phoneNumbers, metadata)");
+export const getPeople = tool({
+    description: "Get one person by resource name, or list 'Other Contacts' with pagination/sync tokens. Other-contacts mode restricts person_fields.",
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        resourceName: z.string().optional().describe("Person resource, e.g. 'people/me' or 'people/c123...' (ignored when otherContacts is true)"),
+        personFields: personFieldsField,
+        otherContacts: z.boolean().optional().describe("True: list Other Contacts (enables pageSize/pageToken/syncToken, ignores resourceName)"),
+        pageSize: z.number().int().min(1).max(1000).optional().describe('Other-contacts page size (default 10)'),
+        pageToken: z.string().optional().describe('Other-contacts next page token'),
+        syncToken: z.string().optional().describe('Other-contacts incremental sync token (empty = full sync)'),
+        sources: z.array(z.enum(['READ_SOURCE_TYPE_CONTACT', 'READ_SOURCE_TYPE_PROFILE'])).optional().describe('Other-contacts sources (PROFILE needs CONTACT too)'),
+    }),
+    execute: async ({ gmailToken, resourceName, personFields, otherContacts, pageSize, pageToken, syncToken, sources }) => {
+        if (otherContacts) {
+            return peopleFetch(gmailToken, 'otherContacts', {
+                readMask: personFields,
+                pageSize: pageSize ? String(pageSize) : undefined,
+                pageToken,
+                syncToken,
+                ...(sources ? { sources: sources.join(',') } : {}),
+            }, 'list other contacts');
+        }
+        return peopleFetch(gmailToken, resourceName || 'people/me', { personFields }, 'get person');
+    },
+});
+export const searchPeople = tool({
+    description: "Search saved contacts (+ Other Contacts optionally) by name/email/phone/org. Never auto-pick from ambiguous results; dedupe by email across pages.",
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        query: z.string().describe('Query matching names, nicknames, emails, phones, organizations'),
+        personFields: z.string().optional().describe("Mask, e.g. 'names,emailAddresses'. Results touching 'Other Contacts' only support emailAddresses, metadata, names, phoneNumbers — avoid organizations/birthdays or they may be silently omitted."),
+        pageSize: z.number().int().min(0).max(30).optional().describe('Results per page (default 10, API caps at 30)'),
+        pageToken: z.string().optional().describe('next_page_token from previous page'),
+    }),
+    execute: async ({ gmailToken, query, personFields, pageSize, pageToken }) => peopleFetch(gmailToken, 'people:searchContacts', {
+        query,
+        readMask: personFields,
+        pageSize: pageSize ? String(pageSize) : undefined,
+        pageToken,
+    }, 'search people'),
+});
+//# sourceMappingURL=people-extra.js.map

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

@@ -0,0 +1,100 @@
+export declare const getLanguageSettings: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const updateLanguageSettings: import("ai").Tool<{
+    userId: string;
+    displayLanguage: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const getVacationSettings: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const updateVacationSettings: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+    enableAutoReply?: boolean | undefined;
+    responseSubject?: string | undefined;
+    responseBodyPlainText?: string | undefined;
+    responseBodyHtml?: string | undefined;
+    restrictToContacts?: boolean | undefined;
+    restrictToDomain?: boolean | undefined;
+    startTime?: string | undefined;
+    endTime?: string | undefined;
+}, any>;
+export declare const settingsGetImap: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const updateImapSettings: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+    enabled?: boolean | undefined;
+    autoExpunge?: boolean | undefined;
+    expungeBehavior?: "expungeBehaviorUnspecified" | "archive" | "trash" | "deleteForever" | undefined;
+    maxFolderSize?: number | undefined;
+}, any>;
+export declare const settingsGetPop: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const updatePopSettings: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+    accessWindow?: "accessWindowUnspecified" | "disabled" | "fromNowOn" | "allMail" | undefined;
+    disposition?: "archive" | "trash" | "dispositionUnspecified" | "leaveInInbox" | "markRead" | undefined;
+}, any>;
+export declare const listSendAs: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const settingsSendAsGet: import("ai").Tool<{
+    userId: string;
+    sendAsEmail: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const patchSendAs: import("ai").Tool<{
+    userId: string;
+    sendAsEmail: string;
+    gmailToken?: string | undefined;
+    displayName?: string | undefined;
+    replyToAddress?: string | undefined;
+    signature?: string | undefined;
+    isDefault?: boolean | undefined;
+    treatAsAlias?: boolean | undefined;
+    smtpMsa?: {
+        host: string;
+        port: number;
+        securityMode: "none" | "securityModeUnspecified" | "ssl" | "starttls";
+        username?: string | undefined;
+        password?: string | undefined;
+    } | undefined;
+}, any>;
+export declare const updateSendAs: import("ai").Tool<{
+    userId: string;
+    sendAsEmail: string;
+    gmailToken?: string | undefined;
+    displayName?: string | undefined;
+    replyToAddress?: string | undefined;
+    signature?: string | undefined;
+    isDefault?: boolean | undefined;
+    treatAsAlias?: boolean | undefined;
+    smtpMsa?: {
+        host: string;
+        port: number;
+        securityMode: "none" | "securityModeUnspecified" | "ssl" | "starttls";
+        username?: string | undefined;
+        password?: string | undefined;
+    } | undefined;
+}, any>;
+export declare const listSmimeInfo: import("ai").Tool<{
+    userId: string;
+    sendAsEmail: string;
+    gmailToken?: string | undefined;
+}, any>;
+export declare const listForwardingAddresses: import("ai").Tool<{
+    userId: string;
+    gmailToken?: string | undefined;
+}, any>;
+//# sourceMappingURL=settings.d.ts.map

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

@@ -0,0 +1,210 @@
+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 getLanguageSettings = tool({
+    description: "Get the Gmail display language (RFC 3066 tag like 'en-GB') for a user.",
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+    }),
+    execute: async ({ gmailToken, userId }) => gmailFetch(gmailToken, `/users/${userId}/settings/language`, undefined, 'get language settings'),
+});
+export const updateLanguageSettings = tool({
+    description: 'Set the Gmail display language. Gmail may save a close variant if the exact tag is unsupported.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        displayLanguage: z.string().describe("RFC 3066 tag, e.g. 'en', 'en-GB', 'fr', 'ja'"),
+    }),
+    execute: async ({ gmailToken, userId, displayLanguage }) => gmailFetch(gmailToken, `/users/${userId}/settings/language`, { method: 'PUT', body: JSON.stringify({ displayLanguage }) }, 'update language settings'),
+});
+export const getVacationSettings = tool({
+    description: 'Get vacation responder (out-of-office) settings: enabled flag, subject, bodies, schedule, restrictions.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+    }),
+    execute: async ({ gmailToken, userId }) => gmailFetch(gmailToken, `/users/${userId}/settings/vacation`, undefined, 'get vacation settings'),
+});
+export const updateVacationSettings = tool({
+    description: 'Configure out-of-office auto-replies. Either responseSubject or responseBodyPlainText must be non-empty to activate.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        enableAutoReply: z.boolean().optional().describe('Turn auto-replies on/off'),
+        responseSubject: z.string().optional().describe('Subject prefix for auto-replies'),
+        responseBodyPlainText: z.string().optional().describe('Plain-text auto-reply body'),
+        responseBodyHtml: z.string().optional().describe('HTML auto-reply body (takes priority, sanitized by Gmail)'),
+        restrictToContacts: z.boolean().optional().describe('Reply only to contacts'),
+        restrictToDomain: z.boolean().optional().describe('Reply only within Workspace domain'),
+        startTime: z.string().optional().describe('Start epoch millis; must precede endTime'),
+        endTime: z.string().optional().describe('End epoch millis'),
+    }),
+    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}/settings/vacation`, { method: 'PUT', body: JSON.stringify(payload) }, 'update vacation settings');
+    },
+});
+export const settingsGetImap = tool({
+    description: 'Get IMAP settings: enabled flag, auto-expunge, expunge behavior, folder size limit.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+    }),
+    execute: async ({ gmailToken, userId }) => gmailFetch(gmailToken, `/users/${userId}/settings/imap`, undefined, 'get IMAP settings'),
+});
+export const updateImapSettings = tool({
+    description: 'Update IMAP settings (enabled, autoExpunge, expungeBehavior, maxFolderSize of 0/1000/2000/5000/10000).',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        enabled: z.boolean().optional(),
+        autoExpunge: z.boolean().optional().describe('Immediately expunge IMAP-deleted messages'),
+        expungeBehavior: z.enum(['expungeBehaviorUnspecified', 'archive', 'trash', 'deleteForever']).optional(),
+        maxFolderSize: z.number().int().optional().describe('0 (no limit), 1000, 2000, 5000, or 10000'),
+    }),
+    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}/settings/imap`, { method: 'PUT', body: JSON.stringify(payload) }, 'update IMAP settings');
+    },
+});
+export const settingsGetPop = tool({
+    description: 'Get POP settings: access window and post-fetch disposition.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+    }),
+    execute: async ({ gmailToken, userId }) => gmailFetch(gmailToken, `/users/${userId}/settings/pop`, undefined, 'get POP settings'),
+});
+export const updatePopSettings = tool({
+    description: 'Update POP access window (disabled/fromNowOn/allMail) and disposition (leaveInInbox/archive/trash/markRead).',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        accessWindow: z.enum(['accessWindowUnspecified', 'disabled', 'fromNowOn', 'allMail']).optional(),
+        disposition: z.enum(['dispositionUnspecified', 'leaveInInbox', 'archive', 'trash', 'markRead']).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}/settings/pop`, { method: 'PUT', body: JSON.stringify(payload) }, 'update POP settings');
+    },
+});
+export const listSendAs = tool({
+    description: "List send-as aliases (primary + custom From addresses) with signatures and verification status. Use before composing from an alias.",
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+    }),
+    execute: async ({ gmailToken, userId }) => gmailFetch(gmailToken, `/users/${userId}/settings/sendAs`, undefined, 'list send-as aliases'),
+});
+export const settingsSendAsGet = tool({
+    description: 'Get one send-as alias config (display name, signature, SMTP relay, verification). 404 if the address is not an alias.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        sendAsEmail: z.string().describe("Alias address shown in From, e.g. 'alias@example.com'"),
+    }),
+    execute: async ({ gmailToken, userId, sendAsEmail }) => gmailFetch(gmailToken, `/users/${userId}/settings/sendAs/${encodeURIComponent(sendAsEmail)}`, undefined, 'get send-as alias'),
+});
+const smtpMsaSchema = z.object({
+    host: z.string().describe('SMTP hostname'),
+    port: z.number().int().describe('SMTP port'),
+    securityMode: z.enum(['securityModeUnspecified', 'none', 'ssl', 'starttls']),
+    username: z.string().optional().describe('SMTP username (write-only)'),
+    password: z.string().optional().describe('SMTP password (write-only)'),
+});
+export const patchSendAs = tool({
+    description: 'Partially update a send-as alias (display name, signature, reply-to, default flag, SMTP relay).',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        sendAsEmail: z.string().describe('Alias address to update'),
+        displayName: z.string().optional().describe('From header name'),
+        replyToAddress: z.string().optional().describe('Reply-To header address'),
+        signature: z.string().optional().describe('HTML signature (sanitized by Gmail)'),
+        isDefault: z.boolean().optional().describe('Make default From (only true is writable)'),
+        treatAsAlias: z.boolean().optional().describe('Treat as primary-address alias (custom aliases only)'),
+        smtpMsa: smtpMsaSchema.optional().describe('SMTP relay config'),
+    }),
+    execute: async ({ gmailToken, userId, sendAsEmail, ...body }) => {
+        const payload = {};
+        for (const [k, v] of Object.entries(body))
+            if (v !== undefined)
+                payload[k] = v;
+        return gmailFetch(gmailToken, `/users/${userId}/settings/sendAs/${encodeURIComponent(sendAsEmail)}`, { method: 'PATCH', body: JSON.stringify(payload) }, 'patch send-as alias');
+    },
+});
+export const updateSendAs = tool({
+    description: 'Fully update a send-as alias. Same fields as patch; non-primary aliases updatable only with domain-wide delegation.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        sendAsEmail: z.string().describe('Alias address to update'),
+        displayName: z.string().optional(),
+        replyToAddress: z.string().optional(),
+        signature: z.string().optional(),
+        isDefault: z.boolean().optional(),
+        treatAsAlias: z.boolean().optional(),
+        smtpMsa: smtpMsaSchema.optional(),
+    }),
+    execute: async ({ gmailToken, userId, sendAsEmail, ...body }) => {
+        const payload = {};
+        for (const [k, v] of Object.entries(body))
+            if (v !== undefined)
+                payload[k] = v;
+        return gmailFetch(gmailToken, `/users/${userId}/settings/sendAs/${encodeURIComponent(sendAsEmail)}`, { method: 'PUT', body: JSON.stringify(payload) }, 'update send-as alias');
+    },
+});
+export const listSmimeInfo = tool({
+    description: "List S/MIME certificate configs for a send-as alias. Needs Workspace Enterprise Plus/Education/Frontline with S/MIME enabled.",
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+        sendAsEmail: z.string().describe('Alias address to list certificates for'),
+    }),
+    execute: async ({ gmailToken, userId, sendAsEmail }) => gmailFetch(gmailToken, `/users/${userId}/settings/sendAs/${encodeURIComponent(sendAsEmail)}/smimeInfo`, undefined, 'list S/MIME configs'),
+});
+export const listForwardingAddresses = tool({
+    description: 'List verified forwarding addresses (accepted/pending) usable as auto-forward targets.',
+    inputSchema: z.object({
+        gmailToken: tokenField,
+        userId: userField,
+    }),
+    execute: async ({ gmailToken, userId }) => gmailFetch(gmailToken, `/users/${userId}/settings/forwardingAddresses`, undefined, 'list forwarding addresses'),
+});
+//# sourceMappingURL=settings.js.map

package/dist/toolkits/google-analytics/tools/admin.d.ts

@@ -16,8 +16,8 @@ export declare const listAccountSummaries: import("ai").Tool<{
 export declare const provisionAccountTicket: import("ai").Tool<{
     redirectUri: string;
     account: {
-        regionCode: string;
         displayName: string;
+        regionCode: string;
     };
     googleAnalyticsToken: string;
 }, any>;
@@ -36,17 +36,17 @@ export declare const updateProperty: import("ai").Tool<{
     name: string;
     updateMask: string;
     googleAnalyticsToken: string;
+    displayName?: string | undefined;
     parent?: string | undefined;
     currencyCode?: string | undefined;
-    displayName?: string | undefined;
     timeZone?: string | undefined;
     industryCategory?: string | undefined;
     propertyType?: "PROPERTY_TYPE_UNSPECIFIED" | "PROPERTY_TYPE_ORDINARY" | "PROPERTY_TYPE_SUBPROPERTY" | "PROPERTY_TYPE_ROLLUP" | undefined;
 }, any>;
 export declare const createRollupProperty: import("ai").Tool<{
+    displayName: string;
     account: string;
     googleAnalyticsToken: string;
-    displayName: string;
     timeZone: string;
     sourceProperties?: string[] | undefined;
 }, any>;

package/dist/toolkits/google-analytics/tools/custom-definitions.d.ts

@@ -1,8 +1,8 @@
 export declare const createCustomDimension: import("ai").Tool<{
+    displayName: string;
     scope: "EVENT" | "USER" | "ITEM";
     parent: string;
     googleAnalyticsToken: string;
-    displayName: string;
     parameterName: string;
     description?: string | undefined;
     disallowAdsPersonalization?: boolean | undefined;
@@ -22,10 +22,10 @@ export declare const archiveCustomDimension: import("ai").Tool<{
     googleAnalyticsToken: string;
 }, any>;
 export declare const createCustomMetric: import("ai").Tool<{
+    displayName: string;
     scope: "EVENT";
     parent: string;
     googleAnalyticsToken: string;
-    displayName: string;
     parameterName: string;
     measurementUnit: "STANDARD" | "CURRENCY" | "FEET" | "METERS" | "KILOMETERS" | "MILES" | "MILLISECONDS" | "SECONDS" | "MINUTES" | "HOURS";
     description?: string | undefined;

package/dist/toolkits/google-classroom/tools/announcement-addons.d.ts

@@ -1,26 +1,26 @@
 export declare const getAnnouncementAddOnContext: import("ai").Tool<{
+    itemId: string;
     googleClassroomToken: string;
     courseId: string;
-    itemId: string;
     attachmentId?: string | undefined;
     addOnToken?: string | undefined;
 }, any>;
 export declare const deleteAnnouncementAddOnAttachment: import("ai").Tool<{
     attachmentId: string;
+    itemId: string;
     googleClassroomToken: string;
     courseId: string;
-    itemId: string;
 }, any>;
 export declare const getAnnouncementAddOnAttachment: import("ai").Tool<{
     attachmentId: string;
+    itemId: string;
     googleClassroomToken: string;
     courseId: string;
-    itemId: string;
 }, any>;
 export declare const listAnnouncementAddOnAttachments: import("ai").Tool<{
+    itemId: string;
     googleClassroomToken: string;
     courseId: string;
-    itemId: string;
     pageToken?: string | undefined;
     pageSize?: number | undefined;
 }, any>;