@rnsk/toolkits 0.0.4 → 0.0.6

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

@@ -0,0 +1,162 @@
+import { gcpListComputeInstances } from './compute/list-instances.js';
+import { gcpGetComputeInstance } from './compute/get-instance.js';
+import { gcpStartComputeInstance } from './compute/start-instance.js';
+import { gcpStopComputeInstance } from './compute/stop-instance.js';
+import { gcpGetMonitoringMetrics } from './monitoring/get-metrics.js';
+import { gcpListMonitoringMetricDescriptors } from './monitoring/list-metric-descriptors.js';
+export { gcpListComputeInstances, gcpGetComputeInstance, gcpStartComputeInstance, gcpStopComputeInstance, gcpGetMonitoringMetrics, gcpListMonitoringMetricDescriptors, };
+export declare const gcpTools: ({
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        gcpCredentials?: string | undefined;
+        zone?: string | undefined;
+    }, {
+        error: string;
+        count?: undefined;
+        instances?: undefined;
+        message?: undefined;
+    } | {
+        count: number;
+        instances: Record<string, unknown>[];
+        error?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        count?: undefined;
+        instances?: undefined;
+    }>;
+    requiredAuth: "gcpCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        zone: string;
+        instance: string;
+        gcpCredentials?: string | undefined;
+    }, {
+        error: string;
+        name?: undefined;
+        zone?: undefined;
+        status?: undefined;
+        machineType?: undefined;
+        privateIp?: undefined;
+        publicIp?: undefined;
+        creationTimestamp?: undefined;
+        message?: undefined;
+    } | {
+        name: string | null | undefined;
+        zone: string;
+        status: string | null | undefined;
+        machineType: string | undefined;
+        privateIp: string | null | undefined;
+        publicIp: string | null | undefined;
+        creationTimestamp: string | null | undefined;
+        error?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        name?: undefined;
+        zone?: undefined;
+        status?: undefined;
+        machineType?: undefined;
+        privateIp?: undefined;
+        publicIp?: undefined;
+        creationTimestamp?: undefined;
+    }>;
+    requiredAuth: "gcpCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        zone: string;
+        instance: string;
+        gcpCredentials?: string | undefined;
+    }, {
+        error: string;
+        instance?: undefined;
+        zone?: undefined;
+        operation?: undefined;
+        status?: undefined;
+        message?: undefined;
+    } | {
+        instance: string;
+        zone: string;
+        operation: string | undefined;
+        status: string;
+        error?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        instance?: undefined;
+        zone?: undefined;
+        operation?: undefined;
+        status?: undefined;
+    }>;
+    requiredAuth: "gcpCredentials";
+    scope: "write";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        filter: string;
+        startTime?: string | undefined;
+        endTime?: string | undefined;
+        gcpCredentials?: string | undefined;
+    }, {
+        error: string;
+        timeSeries?: undefined;
+        message?: undefined;
+    } | {
+        timeSeries: {
+            metric: import("@google-cloud/monitoring/build/protos/protos.js").google.api.IMetric | null | undefined;
+            resource: import("@google-cloud/monitoring/build/protos/protos.js").google.api.IMonitoredResource | null | undefined;
+            points: {
+                value: import("@google-cloud/monitoring/build/protos/protos.js").google.monitoring.v3.ITypedValue | null | undefined;
+                interval: import("@google-cloud/monitoring/build/protos/protos.js").google.monitoring.v3.ITimeInterval | null | undefined;
+            }[];
+        }[];
+        error?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        timeSeries?: undefined;
+    }>;
+    requiredAuth: "gcpCredentials";
+    scope: "read";
+} | {
+    name: string;
+    description: string;
+    tool: import("ai").Tool<{
+        filter?: string | undefined;
+        gcpCredentials?: string | undefined;
+    }, {
+        error: string;
+        descriptors?: undefined;
+        message?: undefined;
+    } | {
+        descriptors: {
+            type: string | null | undefined;
+            displayName: string | null | undefined;
+            description: string | null | undefined;
+            metricKind: import("@google-cloud/monitoring/build/protos/protos.js").google.api.MetricDescriptor.MetricKind | "METRIC_KIND_UNSPECIFIED" | "GAUGE" | "DELTA" | "CUMULATIVE" | null | undefined;
+            valueType: import("@google-cloud/monitoring/build/protos/protos.js").google.api.MetricDescriptor.ValueType | "VALUE_TYPE_UNSPECIFIED" | "BOOL" | "INT64" | "DOUBLE" | "STRING" | "DISTRIBUTION" | "MONEY" | null | undefined;
+            unit: string | null | undefined;
+        }[];
+        error?: undefined;
+        message?: undefined;
+    } | {
+        error: string;
+        message: string;
+        descriptors?: undefined;
+    }>;
+    requiredAuth: "gcpCredentials";
+    scope: "read";
+})[];
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,52 @@
+import { gcpListComputeInstances } from './compute/list-instances.js';
+import { gcpGetComputeInstance } from './compute/get-instance.js';
+import { gcpStartComputeInstance } from './compute/start-instance.js';
+import { gcpStopComputeInstance } from './compute/stop-instance.js';
+import { gcpGetMonitoringMetrics } from './monitoring/get-metrics.js';
+import { gcpListMonitoringMetricDescriptors } from './monitoring/list-metric-descriptors.js';
+export { gcpListComputeInstances, gcpGetComputeInstance, gcpStartComputeInstance, gcpStopComputeInstance, gcpGetMonitoringMetrics, gcpListMonitoringMetricDescriptors, };
+export const gcpTools = [
+    {
+        name: 'gcpListComputeInstances',
+        description: 'List Compute Engine instances, optionally filtered by zone.',
+        tool: gcpListComputeInstances,
+        requiredAuth: 'gcpCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'gcpGetComputeInstance',
+        description: 'Get details about a specific Compute Engine instance.',
+        tool: gcpGetComputeInstance,
+        requiredAuth: 'gcpCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'gcpStartComputeInstance',
+        description: 'Start a stopped Compute Engine instance.',
+        tool: gcpStartComputeInstance,
+        requiredAuth: 'gcpCredentials',
+        scope: 'write',
+    },
+    {
+        name: 'gcpStopComputeInstance',
+        description: 'Stop a running Compute Engine instance.',
+        tool: gcpStopComputeInstance,
+        requiredAuth: 'gcpCredentials',
+        scope: 'write',
+    },
+    {
+        name: 'gcpGetMonitoringMetrics',
+        description: 'Retrieve Cloud Monitoring time series data for a metric filter.',
+        tool: gcpGetMonitoringMetrics,
+        requiredAuth: 'gcpCredentials',
+        scope: 'read',
+    },
+    {
+        name: 'gcpListMonitoringMetricDescriptors',
+        description: 'List available Cloud Monitoring metric descriptors.',
+        tool: gcpListMonitoringMetricDescriptors,
+        requiredAuth: 'gcpCredentials',
+        scope: 'read',
+    },
+];
+//# sourceMappingURL=index.js.map

package/dist/toolkits/gcp/tools/monitoring/get-metrics.d.ts

@@ -0,0 +1,26 @@
+export declare const gcpGetMonitoringMetrics: import("ai").Tool<{
+    filter: string;
+    startTime?: string | undefined;
+    endTime?: string | undefined;
+    gcpCredentials?: string | undefined;
+}, {
+    error: string;
+    timeSeries?: undefined;
+    message?: undefined;
+} | {
+    timeSeries: {
+        metric: import("@google-cloud/monitoring/build/protos/protos.js").google.api.IMetric | null | undefined;
+        resource: import("@google-cloud/monitoring/build/protos/protos.js").google.api.IMonitoredResource | null | undefined;
+        points: {
+            value: import("@google-cloud/monitoring/build/protos/protos.js").google.monitoring.v3.ITypedValue | null | undefined;
+            interval: import("@google-cloud/monitoring/build/protos/protos.js").google.monitoring.v3.ITimeInterval | null | undefined;
+        }[];
+    }[];
+    error?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    timeSeries?: undefined;
+}>;
+//# sourceMappingURL=get-metrics.d.ts.map

package/dist/toolkits/gcp/tools/monitoring/get-metrics.js

@@ -0,0 +1,53 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { createMonitoringClient, getProjectId } from '../client.js';
+export const gcpGetMonitoringMetrics = tool({
+    description: 'Retrieve Cloud Monitoring time series data for a metric filter (e.g. compute.googleapis.com/instance/cpu/utilization). Use this to check resource health or usage trends.',
+    inputSchema: z.object({
+        gcpCredentials: z.string().optional().describe('Injected by system; do not provide'),
+        filter: z
+            .string()
+            .describe('Monitoring filter, e.g. \'metric.type="compute.googleapis.com/instance/cpu/utilization"\''),
+        startTime: z.string().optional().describe('Start time in ISO 8601 format (default: 1 hour ago)'),
+        endTime: z.string().optional().describe('End time in ISO 8601 format (default: now)'),
+    }),
+    execute: async ({ gcpCredentials, filter, startTime, endTime }) => {
+        if (!gcpCredentials) {
+            return { error: 'GCP credentials are required. Connect GCP first.' };
+        }
+        try {
+            const client = createMonitoringClient(gcpCredentials);
+            const projectId = getProjectId(gcpCredentials);
+            const [timeSeries] = await client.listTimeSeries({
+                name: `projects/${projectId}`,
+                filter,
+                interval: {
+                    startTime: {
+                        seconds: startTime ? Math.floor(new Date(startTime).getTime() / 1000) : Math.floor(Date.now() / 1000) - 3600,
+                    },
+                    endTime: {
+                        seconds: endTime ? Math.floor(new Date(endTime).getTime() / 1000) : Math.floor(Date.now() / 1000),
+                    },
+                },
+                view: 'FULL',
+            });
+            return {
+                timeSeries: (timeSeries ?? []).map((series) => ({
+                    metric: series.metric,
+                    resource: series.resource,
+                    points: (series.points ?? []).map((point) => ({
+                        value: point.value,
+                        interval: point.interval,
+                    })),
+                })),
+            };
+        }
+        catch (err) {
+            return {
+                error: 'Failed to get Cloud Monitoring metrics',
+                message: err instanceof Error ? err.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=get-metrics.js.map

package/dist/toolkits/gcp/tools/monitoring/list-metric-descriptors.d.ts

@@ -0,0 +1,24 @@
+export declare const gcpListMonitoringMetricDescriptors: import("ai").Tool<{
+    filter?: string | undefined;
+    gcpCredentials?: string | undefined;
+}, {
+    error: string;
+    descriptors?: undefined;
+    message?: undefined;
+} | {
+    descriptors: {
+        type: string | null | undefined;
+        displayName: string | null | undefined;
+        description: string | null | undefined;
+        metricKind: import("@google-cloud/monitoring/build/protos/protos.js").google.api.MetricDescriptor.MetricKind | "METRIC_KIND_UNSPECIFIED" | "GAUGE" | "DELTA" | "CUMULATIVE" | null | undefined;
+        valueType: import("@google-cloud/monitoring/build/protos/protos.js").google.api.MetricDescriptor.ValueType | "VALUE_TYPE_UNSPECIFIED" | "BOOL" | "INT64" | "DOUBLE" | "STRING" | "DISTRIBUTION" | "MONEY" | null | undefined;
+        unit: string | null | undefined;
+    }[];
+    error?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    descriptors?: undefined;
+}>;
+//# sourceMappingURL=list-metric-descriptors.d.ts.map

package/dist/toolkits/gcp/tools/monitoring/list-metric-descriptors.js

@@ -0,0 +1,40 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { createMonitoringClient, getProjectId } from '../client.js';
+export const gcpListMonitoringMetricDescriptors = tool({
+    description: 'List available Cloud Monitoring metric descriptors, optionally filtered by metric type.',
+    inputSchema: z.object({
+        gcpCredentials: z.string().optional().describe('Injected by system; do not provide'),
+        filter: z.string().optional().describe('Optional filter for metric type, e.g. \'metric.type = starts_with("compute")\''),
+    }),
+    execute: async ({ gcpCredentials, filter }) => {
+        if (!gcpCredentials) {
+            return { error: 'GCP credentials are required. Connect GCP first.' };
+        }
+        try {
+            const client = createMonitoringClient(gcpCredentials);
+            const projectId = getProjectId(gcpCredentials);
+            const [descriptors] = await client.listMetricDescriptors({
+                name: `projects/${projectId}`,
+                filter,
+            });
+            return {
+                descriptors: (descriptors ?? []).map((descriptor) => ({
+                    type: descriptor.type,
+                    displayName: descriptor.displayName,
+                    description: descriptor.description,
+                    metricKind: descriptor.metricKind,
+                    valueType: descriptor.valueType,
+                    unit: descriptor.unit,
+                })),
+            };
+        }
+        catch (err) {
+            return {
+                error: 'Failed to list Cloud Monitoring metric descriptors',
+                message: err instanceof Error ? err.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=list-metric-descriptors.js.map

package/dist/toolkits/gmail/manifest.js

@@ -12,7 +12,7 @@ export default defineToolkit({
         tokenField: 'gmailToken',
         provider: {
             slug: 'gmail',
-            env: { clientId: 'GMAIL_CLIENT_ID', clientSecret: 'GMAIL_CLIENT_SECRET' },
+            env: { clientId: 'GOOGLE_GMAIL_CLIENT_ID', clientSecret: 'GOOGLE_GMAIL_CLIENT_SECRET' },
             authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
             tokenUrl: 'https://oauth2.googleapis.com/token',
             scopes: [

package/dist/toolkits/google-calendar/manifest.js

@@ -13,12 +13,7 @@ export default defineToolkit({
         tokenField: 'googleCalendarToken',
         provider: {
             slug: 'googlecalendar',
-            env: {
-                clientId: 'GOOGLE_CALENDAR_CLIENT_ID',
-                clientSecret: 'GOOGLE_CALENDAR_CLIENT_SECRET',
-                clientIdFallback: 'GMAIL_CLIENT_ID',
-                clientSecretFallback: 'GMAIL_CLIENT_SECRET',
-            },
+            env: { clientId: 'GOOGLE_CALENDAR_CLIENT_ID', clientSecret: 'GOOGLE_CALENDAR_CLIENT_SECRET' },
             authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
             tokenUrl: 'https://oauth2.googleapis.com/token',
             scopes: [

package/dist/toolkits/google-docs/icon.d.ts

@@ -0,0 +1,5 @@
+export declare const GDOCS_ICON: {
+    kind: "svg";
+    dataUri: string;
+};
+//# sourceMappingURL=icon.d.ts.map

package/dist/toolkits/google-docs/icon.js

@@ -0,0 +1,6 @@
+const SVG = `<svg xmlns="http://www.w3.org/2000/svg" width="192" height="192" viewBox="0 0 192 192" fill="none"><mask id="mask0_37242_8762" style="mask-type:alpha" maskUnits="userSpaceOnUse" x="32" y="8" width="128" height="176"><path d="M130.334 184L61.6 184C52.6565 184 48.1848 184 44.6375 182.596C39.5029 180.563 35.4374 176.497 33.4045 171.362C32 167.815 32 163.343 32 154.4L32 37.6C32 28.6565 32 24.1848 33.4045 20.6375C35.4374 15.5029 39.5029 11.4374 44.6375 9.40447C48.1848 8 52.6565 8 61.6 8L100 8L154.793 62.7933L154.793 62.7934C156.454 64.4543 157.285 65.2848 157.923 66.2239C158.845 67.5811 159.479 69.1131 159.785 70.725C159.997 71.8404 159.997 73.0264 159.995 75.3985C159.96 124.317 159.938 124.799 159.937 154.366C159.937 163.332 159.937 167.816 158.532 171.363C156.499 176.498 152.434 180.562 147.299 182.596C143.752 184 139.279 184 130.334 184Z" fill="#3186FF"/></mask><g mask="url(#mask0_37242_8762)"><path d="M159.94 184L31.9999 184L31.9999 8.00001L99.9999 8L159.999 68L159.94 184Z" fill="#3186FF"/><g filter="url(#filter0_f_37242_8762)"><path d="M43 192H149V70.2271V20H43V192Z" fill="url(#paint0_linear_37242_8762)"/></g></g><path d="M154.995 62.9951C152.489 61.1143 149.375 60 146 60H112.8C105.731 60 100 54.2692 100 47.2002V8L154.995 62.9951Z" fill="#76BBFF"/><rect x="64.001" y="114" width="64" height="12" rx="6" fill="white"/><rect x="64.001" y="143" width="48" height="12" rx="6" fill="white"/><defs><filter id="filter0_f_37242_8762" x="31" y="8" width="130" height="196" filterUnits="userSpaceOnUse" color-interpolation-filters="sRGB"><feFlood flood-opacity="0" result="BackgroundImageFix"/><feBlend mode="normal" in="SourceGraphic" in2="BackgroundImageFix" result="shape"/><feGaussianBlur stdDeviation="6" result="effect1_foregroundBlur_37242_8762"/></filter><linearGradient id="paint0_linear_37242_8762" x1="96" y1="59.2839" x2="54.6124" y2="171.338" gradientUnits="userSpaceOnUse"><stop offset="0.33" stop-color="#3186FF"/><stop offset="1" stop-color="#A9A8FF"/></linearGradient></defs></svg>`;
+export const GDOCS_ICON = {
+    kind: 'svg',
+    dataUri: `data:image/svg+xml;base64,${Buffer.from(SVG).toString('base64')}`,
+};
+//# sourceMappingURL=icon.js.map

package/dist/toolkits/google-docs/manifest.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("../../index.js").ToolkitManifest;
+export default _default;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/toolkits/google-docs/manifest.js

@@ -0,0 +1,40 @@
+import { defineToolkit, defineTool } from '../../core/define.js';
+import { inferToolScope } from '../../core/scope.js';
+import { GDOCS_ICON } from './icon.js';
+import { googleDocsTools } from './tools/index.js';
+export default defineToolkit({
+    id: 'google-docs',
+    displayName: 'Google Docs',
+    shortDescription: 'Create, read, edit, and manage Google Docs documents.',
+    category: 'Document & File Management',
+    icon: GDOCS_ICON,
+    auth: {
+        type: 'oauth2',
+        tokenField: 'googleDocsToken',
+        provider: {
+            slug: 'google-docs',
+            env: { clientId: 'GOOGLE_DOCS_CLIENT_ID', clientSecret: 'GOOGLE_DOCS_CLIENT_SECRET' },
+            authorizeUrl: 'https://accounts.google.com/o/oauth2/v2/auth',
+            tokenUrl: 'https://oauth2.googleapis.com/token',
+            scopes: [
+                'https://www.googleapis.com/auth/documents',
+                'https://www.googleapis.com/auth/drive',
+            ],
+            exchangeStyle: 'form',
+            extraAuthParams: { access_type: 'offline', prompt: 'consent' },
+            connectDescription: 'Connect Google Docs to create, read, and edit documents.',
+            callbackPath: '/api/auth/google-docs/callback',
+            stateCookie: 'google_docs_oauth_state',
+        },
+    },
+    allowedHosts: ['docs.googleapis.com', 'www.googleapis.com'],
+    tools: googleDocsTools.map((entry) => defineTool({
+        name: entry.name,
+        description: entry.description,
+        tool: entry.tool,
+        requiredAuth: entry.requiredAuth,
+        scope: entry.scope ?? inferToolScope(entry.name),
+    })),
+    meta: { since: '0.0.5' },
+});
+//# sourceMappingURL=manifest.js.map

package/dist/toolkits/google-docs/tools/append-text.d.ts

@@ -0,0 +1,30 @@
+export declare const appendText: import("ai").Tool<{
+    text: string;
+    googleDocsToken: string;
+    documentId: string;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    documentId?: undefined;
+    index?: undefined;
+    replies?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    documentId: string;
+    index: number;
+    replies: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    documentId?: undefined;
+    index?: undefined;
+    replies?: undefined;
+}>;
+//# sourceMappingURL=append-text.d.ts.map

package/dist/toolkits/google-docs/tools/append-text.js

@@ -0,0 +1,48 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+import { getDocumentEndIndex } from './utils.js';
+export const appendText = tool({
+    description: 'Append text to the end of a Google Docs document.',
+    inputSchema: z.object({
+        googleDocsToken: z.string().describe('The Google Docs access token'),
+        documentId: z.string().describe('The ID of the document'),
+        text: z.string().describe('Text to append'),
+    }),
+    execute: async ({ googleDocsToken, documentId, text }) => {
+        try {
+            const docResponse = await fetch(`https://docs.googleapis.com/v1/documents/${documentId}`, {
+                headers: { Authorization: `Bearer ${googleDocsToken}` },
+            });
+            if (!docResponse.ok) {
+                const error = await docResponse.json();
+                return { error: 'Failed to get document for append', details: error };
+            }
+            const document = await docResponse.json();
+            const index = getDocumentEndIndex(document);
+            const response = await fetch(`https://docs.googleapis.com/v1/documents/${documentId}:batchUpdate`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${googleDocsToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    requests: [{ insertText: { location: { index }, text } }],
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to append text', details: error };
+            }
+            const data = await response.json();
+            return { success: true, documentId, index, replies: data.replies };
+        }
+        catch (error) {
+            return {
+                error: 'Error appending text',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=append-text.js.map

package/dist/toolkits/google-docs/tools/copy-document.d.ts

@@ -0,0 +1,27 @@
+export declare const copyDocument: import("ai").Tool<{
+    googleDocsToken: string;
+    documentId: string;
+    name?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    documentId?: undefined;
+    name?: undefined;
+    webViewLink?: undefined;
+    message?: undefined;
+} | {
+    documentId: any;
+    name: any;
+    webViewLink: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    documentId?: undefined;
+    name?: undefined;
+    webViewLink?: undefined;
+}>;
+//# sourceMappingURL=copy-document.d.ts.map

package/dist/toolkits/google-docs/tools/copy-document.js

@@ -0,0 +1,43 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const copyDocument = tool({
+    description: 'Copy a Google Docs document.',
+    inputSchema: z.object({
+        googleDocsToken: z.string().describe('The Google Docs access token'),
+        documentId: z.string().describe('The ID of the document to copy'),
+        name: z.string().optional().describe('Name for the copy'),
+    }),
+    execute: async ({ googleDocsToken, documentId, name }) => {
+        try {
+            const metadata = {};
+            if (name)
+                metadata.name = name;
+            const response = await fetch(`https://www.googleapis.com/drive/v3/files/${documentId}/copy`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${googleDocsToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(metadata),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to copy document', details: error };
+            }
+            const data = await response.json();
+            return {
+                documentId: data.id,
+                name: data.name,
+                webViewLink: data.webViewLink,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error copying document',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=copy-document.js.map

package/dist/toolkits/google-docs/tools/create-document.d.ts

@@ -0,0 +1,26 @@
+export declare const createDocument: import("ai").Tool<{
+    title: string;
+    googleDocsToken: string;
+}, {
+    error: string;
+    details: any;
+    documentId?: undefined;
+    title?: undefined;
+    revisionId?: undefined;
+    message?: undefined;
+} | {
+    documentId: any;
+    title: any;
+    revisionId: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    documentId?: undefined;
+    title?: undefined;
+    revisionId?: undefined;
+}>;
+//# sourceMappingURL=create-document.d.ts.map

package/dist/toolkits/google-docs/tools/create-document.js

@@ -0,0 +1,39 @@
+// @ts-nocheck
+import { tool } from 'ai';
+import { z } from 'zod';
+export const createDocument = tool({
+    description: 'Create a new blank Google Docs document with a title.',
+    inputSchema: z.object({
+        googleDocsToken: z.string().describe('The Google Docs access token'),
+        title: z.string().describe('Title of the new document'),
+    }),
+    execute: async ({ googleDocsToken, title }) => {
+        try {
+            const response = await fetch('https://docs.googleapis.com/v1/documents', {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${googleDocsToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ title }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to create document', details: error };
+            }
+            const data = await response.json();
+            return {
+                documentId: data.documentId,
+                title: data.title,
+                revisionId: data.revisionId,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error creating document',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-document.js.map