@rnsk/toolkits 0.0.2 → 0.0.3

package/README.md

@@ -0,0 +1,104 @@
+# @rnsk/toolkits
+
+Manifest-driven toolkit registry for AI agents — connector definitions you publish as npm and wire into [Runstack](https://runstack.engineer).
+
+[![npm version](https://img.shields.io/npm/v/@rnsk/toolkits.svg)](https://www.npmjs.com/package/@rnsk/toolkits)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](../../LICENSE)
+
+> This is **not** [`@rnsk/tools`](https://www.npmjs.com/package/@rnsk/tools) (the MCP client SDK). `@rnsk/toolkits` ships **connector implementations** — manifests, tools, OAuth specs, and icons.
+
+## What this package contains
+
+| Export | Purpose |
+|--------|---------|
+| `@rnsk/toolkits` | All toolkit manifests, `registerAllTools()`, `getAllTools()` |
+| `@rnsk/toolkits/core` | Types, `defineToolkit`, validation, schema helpers |
+
+## Seed toolkits (v0.0.3)
+
+**223 tools** across **8 toolkits**.
+
+| Toolkit | Tools | Auth |
+|---------|------:|------|
+| mathematics | 9 | none |
+| linear | 3 | OAuth2 |
+| gmail | 15 | OAuth2 |
+| web-search (Firecrawl) | 2 | service env |
+| github | 173 | OAuth2 |
+| notion | 8 | OAuth2 |
+| google-calendar | 6 | OAuth2 |
+| google-sheets | 7 | OAuth2 |
+
+## Install
+
+```bash
+npm install @rnsk/toolkits
+```
+
+Peer dependencies: `ai`, `zod`.
+
+## Usage
+
+Register every toolkit tool into your application's registry:
+
+```ts
+import { toolkits, registerAllTools } from '@rnsk/toolkits';
+
+registerAllTools(myRegistry);
+```
+
+Inspect manifests or build custom registration:
+
+```ts
+import { toolkits } from '@rnsk/toolkits';
+import { defineToolkit, validateManifests } from '@rnsk/toolkits/core';
+
+for (const manifest of toolkits) {
+  console.log(manifest.id, manifest.tools.length);
+}
+```
+
+Runstack loads this package server-side, registers tools, and routes agent requests through its own meta-tool layer. You can publish a **private fork** or scoped package and point Runstack at your version to host connectors outside the public registry.
+
+## Toolkit structure
+
+Each toolkit lives under `src/toolkits/<id>/`:
+
+```
+<id>/
+  manifest.ts    # defineToolkit({ displayName, auth, tools, ... })
+  icon.ts        # SVG/PNG data URI
+  tools/
+    *.ts         # one tool per file (AI SDK tool() + execute)
+    index.ts     # exports array
+```
+
+After adding a toolkit, register it in `src/index.ts`, then run `npm run validate && npm run build`.
+
+## Local testing
+
+The repo includes a **sandbox** (not published to npm) for exercising tools at runtime:
+
+```bash
+cd ../../sandbox
+cp .env.local.example .env.local
+npm run dev
+```
+
+Use `POST /api/tools/execute` to invoke a tool directly with the same credential-injection pattern Runstack uses. See the [repository README](../../README.md) for sandbox endpoints.
+
+## Versioning
+
+Pre-1.0 (`0.0.x`): patch releases add toolkits and tools. Pin an exact version in production (e.g. `"0.0.3"`).
+
+## Contributing
+
+See [CONTRIBUTING.md](../../CONTRIBUTING.md) in the repository root.
+
+## Security
+
+Report vulnerabilities privately — [SECURITY.md](../../SECURITY.md). Toolkit `execute` functions run server-side with user credentials; every PR is reviewed for token handling and outbound hosts.
+
+## License
+
+MIT

package/dist/core/index.d.ts

@@ -2,5 +2,6 @@ export { CONNECTOR_CATEGORIES, type ConnectorCategory } from './categories.js';
 export { defineToolkit, defineTool, toolkitCamelId } from './define.js';
 export { inferToolScope } from './scope.js';
 export { validateManifests, getAuthType, } from './validate.js';
+export { TOOL_OUTPUT_JSON_SCHEMA, getToolInputZodSchema, resolveZodObjectShape, toolInputToJsonSchema, extractParameterInfo, coerceArguments, type ParameterInfo, } from './schema-helpers.js';
 export type { ToolkitManifest, ToolDefinition, ToolkitIcon, ToolkitAuthSpec, ToolkitAuthType, ToolScope, OAuthProviderSpec, EnvVarSpec, ToolkitAvailability, } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.js

@@ -2,4 +2,5 @@ export { CONNECTOR_CATEGORIES } from './categories.js';
 export { defineToolkit, defineTool, toolkitCamelId } from './define.js';
 export { inferToolScope } from './scope.js';
 export { validateManifests, getAuthType, } from './validate.js';
+export { TOOL_OUTPUT_JSON_SCHEMA, getToolInputZodSchema, resolveZodObjectShape, toolInputToJsonSchema, extractParameterInfo, coerceArguments, } from './schema-helpers.js';
 //# sourceMappingURL=index.js.map

package/dist/core/schema-helpers.d.ts

@@ -0,0 +1,20 @@
+export declare const TOOL_OUTPUT_JSON_SCHEMA: Record<string, unknown>;
+export declare function getToolInputZodSchema(tool: any): any | null;
+export declare function resolveZodObjectShape(schema: {
+    shape?: Record<string, unknown>;
+    _def?: {
+        shape?: Record<string, unknown> | (() => Record<string, unknown>);
+    };
+} | null | undefined): Record<string, unknown> | null;
+export declare function toolInputToJsonSchema(tool: any, requiredAuth?: string): Record<string, unknown>;
+export interface ParameterInfo {
+    type: string;
+    required: boolean;
+    description?: string;
+    itemType?: string;
+    options?: string[];
+    values?: string[];
+}
+export declare function extractParameterInfo(zodType: any): ParameterInfo | Record<string, unknown>;
+export declare function coerceArguments(args: Record<string, unknown>, schema: any): Record<string, unknown>;
+//# sourceMappingURL=schema-helpers.d.ts.map

package/dist/core/schema-helpers.js

@@ -0,0 +1,157 @@
+import { zodToJsonSchema } from 'zod-to-json-schema';
+export const TOOL_OUTPUT_JSON_SCHEMA = {
+    type: 'object',
+    description: 'JSON object returned by the tool. May include result data or an error field.',
+    additionalProperties: true,
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function getToolInputZodSchema(tool) {
+    if (!tool || typeof tool !== 'object')
+        return null;
+    return tool.inputSchema ?? tool._def?.parameters ?? null;
+}
+export function resolveZodObjectShape(schema) {
+    if (!schema)
+        return null;
+    if (schema.shape)
+        return schema.shape;
+    const defShape = schema._def?.shape;
+    if (typeof defShape === 'function')
+        return defShape();
+    if (defShape && typeof defShape === 'object')
+        return defShape;
+    return null;
+}
+function flattenJsonSchema(schema) {
+    if (schema.$ref && typeof schema.$ref === 'string' && schema.definitions) {
+        const refName = schema.$ref.replace('#/definitions/', '');
+        const definitions = schema.definitions;
+        const resolved = definitions[refName];
+        if (resolved) {
+            return {
+                ...resolved,
+                ...(schema.$schema ? { $schema: schema.$schema } : {}),
+            };
+        }
+    }
+    return schema;
+}
+function stripAuthFromJsonSchema(schema, requiredAuth) {
+    const properties = schema.properties;
+    if (!properties)
+        return schema;
+    const filtered = { ...properties };
+    for (const key of Object.keys(filtered)) {
+        if (key === requiredAuth || key.endsWith('Token')) {
+            delete filtered[key];
+        }
+    }
+    const required = Array.isArray(schema.required)
+        ? schema.required.filter((key) => key !== requiredAuth && !key.endsWith('Token'))
+        : undefined;
+    return {
+        ...schema,
+        properties: filtered,
+        ...(required && required.length > 0 ? { required } : {}),
+    };
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function toolInputToJsonSchema(tool, requiredAuth) {
+    const zodSchema = getToolInputZodSchema(tool);
+    if (!zodSchema) {
+        return { type: 'object', properties: {} };
+    }
+    const jsonSchema = zodToJsonSchema(zodSchema, {
+        $refStrategy: 'none',
+    });
+    return stripAuthFromJsonSchema(flattenJsonSchema(jsonSchema), requiredAuth);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function extractParameterInfo(zodType) {
+    const typeName = zodType._def?.typeName;
+    const info = {
+        type: typeName?.replace('Zod', '').toLowerCase() || 'unknown',
+        required: !(zodType?.isOptional?.() ?? false),
+        description: zodType.description || undefined,
+    };
+    switch (typeName) {
+        case 'ZodNumber':
+            info.type = 'number';
+            break;
+        case 'ZodString':
+            info.type = 'string';
+            break;
+        case 'ZodBoolean':
+            info.type = 'boolean';
+            break;
+        case 'ZodArray':
+            info.type = 'array';
+            info.itemType = extractParameterInfo(zodType._def.type).type;
+            break;
+        case 'ZodObject':
+            info.type = 'object';
+            break;
+        case 'ZodUnion':
+            info.type = 'union';
+            info.options =
+                zodType._def.options?.map(
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                (opt) => extractParameterInfo(opt).type) || [];
+            break;
+        case 'ZodEnum':
+            info.type = 'enum';
+            info.values = zodType._def.values || [];
+            break;
+        case 'ZodOptional': {
+            const innerInfo = extractParameterInfo(zodType._def.innerType);
+            return { ...innerInfo, required: false };
+        }
+        default:
+            info.type = typeName?.replace('Zod', '').toLowerCase() || 'any';
+    }
+    return info;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function coerceArguments(args, schema) {
+    const shape = resolveZodObjectShape(schema);
+    if (!shape)
+        return args;
+    const coercedArgs = {};
+    for (const [key, value] of Object.entries(args)) {
+        const fieldSchema = shape[key];
+        if (!fieldSchema) {
+            coercedArgs[key] = value;
+            continue;
+        }
+        let typeName = fieldSchema._def?.typeName;
+        let actualSchema = fieldSchema;
+        if (typeName === 'ZodOptional') {
+            actualSchema = fieldSchema._def?.innerType;
+            typeName = actualSchema?._def?.typeName;
+        }
+        try {
+            switch (typeName) {
+                case 'ZodNumber':
+                    coercedArgs[key] = typeof value === 'string' ? parseFloat(value) : Number(value);
+                    break;
+                case 'ZodString':
+                    coercedArgs[key] = String(value);
+                    break;
+                case 'ZodBoolean':
+                    coercedArgs[key] =
+                        typeof value === 'string' ? value.toLowerCase() === 'true' : Boolean(value);
+                    break;
+                case 'ZodArray':
+                    coercedArgs[key] = Array.isArray(value) ? value : [value];
+                    break;
+                default:
+                    coercedArgs[key] = value;
+            }
+        }
+        catch {
+            coercedArgs[key] = value;
+        }
+    }
+    return coercedArgs;
+}
+//# sourceMappingURL=schema-helpers.js.map

package/dist/index.d.ts

@@ -10,7 +10,6 @@ import type { ToolkitManifest } from './core/types.js';
 export declare const toolkits: ToolkitManifest[];
 export { mathematics, linear, gmail, webSearch, github, notion, googleCalendar, googleSheets, };
 export * from './core/index.js';
-export * from './runtime/index.js';
 export declare function getAllTools(): {
     name: string;
     description: string;

package/dist/index.js

@@ -18,7 +18,6 @@ export const toolkits = [
 ];
 export { mathematics, linear, gmail, webSearch, github, notion, googleCalendar, googleSheets, };
 export * from './core/index.js';
-export * from './runtime/index.js';
 export function getAllTools() {
     return toolkits.flatMap((t) => t.tools.map((toolDef) => ({
         name: toolDef.name,

package/dist/toolkits/github/tools/Actions/list-workflow-jobs.d.ts

@@ -2,7 +2,7 @@ export declare const listWorkflowJobs: import("ai").Tool<{
     repo: string;
     owner: string;
     run_id: number;
-    filter?: "latest" | "all" | undefined;
+    filter?: "all" | "latest" | undefined;
     githubToken?: string | undefined;
     per_page?: number | undefined;
     page?: number | undefined;

package/dist/toolkits/github/tools/Activity/list-notifications.d.ts

@@ -1,8 +1,8 @@
 export declare const listNotifications: import("ai").Tool<{
+    all?: boolean | undefined;
     githubToken?: string | undefined;
     per_page?: number | undefined;
     page?: number | undefined;
-    all?: boolean | undefined;
     participating?: boolean | undefined;
 }, {
     error: string;

package/dist/toolkits/github/tools/Issues/add-issue-labels.d.ts

@@ -1,8 +1,8 @@
 export declare const addIssueLabels: import("ai").Tool<{
+    labels: string[];
     repo: string;
     owner: string;
     issueNumber: number;
-    labels: string[];
     githubToken?: string | undefined;
 }, {
     error: string;

package/dist/toolkits/github/tools/Issues/list-authenticated-user-issues.d.ts

@@ -2,12 +2,12 @@ export declare const listAuthenticatedUserIssues: import("ai").Tool<{
     sort?: "created" | "updated" | "comments" | undefined;
     filter?: "all" | "assigned" | "created" | "mentioned" | "subscribed" | undefined;
     since?: string | undefined;
+    labels?: string | undefined;
     githubToken?: string | undefined;
     per_page?: number | undefined;
     page?: number | undefined;
     state?: "all" | "open" | "closed" | undefined;
     direction?: "asc" | "desc" | undefined;
-    labels?: string | undefined;
 }, {
     number: number;
     title: string;

package/dist/toolkits/github/tools/Issues/list-org-issues.d.ts

@@ -3,12 +3,12 @@ export declare const listOrgIssues: import("ai").Tool<{
     sort?: "created" | "updated" | "comments" | undefined;
     filter?: "all" | "assigned" | "created" | "mentioned" | "subscribed" | undefined;
     since?: string | undefined;
+    labels?: string | undefined;
     githubToken?: string | undefined;
     per_page?: number | undefined;
     page?: number | undefined;
     state?: "all" | "open" | "closed" | undefined;
     direction?: "asc" | "desc" | undefined;
-    labels?: string | undefined;
 }, {
     number: number;
     title: string;

package/dist/toolkits/github/tools/Issues/list-user-account-issues.d.ts

@@ -2,12 +2,12 @@ export declare const listUserAccountIssues: import("ai").Tool<{
     sort?: "created" | "updated" | "comments" | undefined;
     filter?: "all" | "assigned" | "created" | "mentioned" | "subscribed" | undefined;
     since?: string | undefined;
+    labels?: string | undefined;
     githubToken?: string | undefined;
     per_page?: number | undefined;
     page?: number | undefined;
     state?: "all" | "open" | "closed" | undefined;
     direction?: "asc" | "desc" | undefined;
-    labels?: string | undefined;
 }, {
     number: number;
     title: string;

package/dist/toolkits/github/tools/Organizations/list-org-repositories.d.ts

@@ -1,6 +1,6 @@
 export declare const listOrgRepositories: import("ai").Tool<{
     org: string;
-    type?: "sources" | "all" | "public" | "member" | "private" | "forks" | undefined;
+    type?: "all" | "sources" | "public" | "member" | "private" | "forks" | undefined;
     githubToken?: string | undefined;
     per_page?: number | undefined;
     page?: number | undefined;

package/dist/toolkits/github/tools/Webhooks/create-repo-webhook.d.ts

@@ -8,8 +8,8 @@ export declare const createRepoWebhook: import("ai").Tool<{
         insecure_ssl?: string | undefined;
     };
     githubToken?: string | undefined;
-    name?: string | undefined;
     events?: string[] | undefined;
+    name?: string | undefined;
     active?: boolean | undefined;
 }, {
     error: string;

package/dist/toolkits/gmail/icon.js

@@ -4,22 +4,22 @@ const SVG = `<svg width="800" height="636.36322" fill="none" viewBox="0 0 800 63
   <path fill="url(#b)" d="M 141.93685,20.255746 C 105.42331,-10.435083 50.946177,-5.7169131 20.255349,30.796627 -10.435479,67.305622 -5.7173098,121.78275 30.79623,152.47813 l 345.80818,290.6765 a 36.36354,36.36354 0 0 0 46.79533,0 L 769.20792,152.47358 C 805.71691,121.78275 810.43508,67.305622 779.74426,30.792081 749.05343,-5.7169131 694.5763,-10.435083 658.0673,20.255746 L 399.9998,237.18245 Z" id="path3" style="fill:url(#b);stroke-width:4.54544"/>
   <defs id="defs16">
     <linearGradient id="a" x1="165" x2="165" y1="44" y2="166" gradientUnits="userSpaceOnUse" gradientTransform="matrix(4.5454426,0,0,4.5454426,-36.362684,-118.18025)">
-      <stop stopColor="#60d673" id="stop3"/>
-      <stop offset=".17" stopColor="#42c868" id="stop4"/>
-      <stop offset=".39" stopColor="#0ebc5f" id="stop5"/>
-      <stop offset=".62" stopColor="#00a9bb" id="stop6"/>
-      <stop offset=".86" stopColor="#3c90ff" id="stop7"/>
-      <stop offset="1" stopColor="#3186ff" id="stop8"/>
+      <stop stop-color="#60d673" id="stop3"/>
+      <stop offset=".17" stop-color="#42c868" id="stop4"/>
+      <stop offset=".39" stop-color="#0ebc5f" id="stop5"/>
+      <stop offset=".62" stop-color="#00a9bb" id="stop6"/>
+      <stop offset=".86" stop-color="#3c90ff" id="stop7"/>
+      <stop offset="1" stop-color="#3186ff" id="stop8"/>
     </linearGradient>
     <linearGradient id="b" x1="8" x2="184" y1="46.130001" y2="46.130001" gradientUnits="userSpaceOnUse" gradientTransform="matrix(4.5454426,0,0,4.5454426,-36.362684,-118.18025)">
-      <stop offset=".08" stopColor="#ff63a0" id="stop9"/>
-      <stop offset=".3" stopColor="#fc413d" id="stop10"/>
-      <stop offset=".5" stopColor="#fc413d" id="stop11"/>
-      <stop offset=".65" stopColor="#fc413d" id="stop12"/>
-      <stop offset=".72" stopColor="#fc5c30" id="stop13"/>
-      <stop offset=".86" stopColor="#feb10c" id="stop14"/>
-      <stop offset=".91" stopColor="#fec700" id="stop15"/>
-      <stop offset=".96" stopColor="#ffdb0f" id="stop16"/>
+      <stop offset=".08" stop-color="#ff63a0" id="stop9"/>
+      <stop offset=".3" stop-color="#fc413d" id="stop10"/>
+      <stop offset=".5" stop-color="#fc413d" id="stop11"/>
+      <stop offset=".65" stop-color="#fc413d" id="stop12"/>
+      <stop offset=".72" stop-color="#fc5c30" id="stop13"/>
+      <stop offset=".86" stop-color="#feb10c" id="stop14"/>
+      <stop offset=".91" stop-color="#fec700" id="stop15"/>
+      <stop offset=".96" stop-color="#ffdb0f" id="stop16"/>
     </linearGradient>
   </defs>
 </svg>`;

package/dist/toolkits/gmail/manifest.js

@@ -1,12 +1,10 @@
 import { defineToolkit, defineTool } from '../../core/define.js';
 import { GMAIL_ICON } from './icon.js';
-import { listMessages } from './tools/list-messages.js';
-import { getMessage } from './tools/get-message.js';
-import { sendMessage } from './tools/send-message.js';
+import { listMessages, getMessage, sendMessage, createDraft, listDrafts, getDraft, sendDraft, deleteDraft, listThreads, getThread, replyToThread, listLabels, modifyMessageLabels, trashMessage, untrashMessage, } from './tools/index.js';
 export default defineToolkit({
     id: 'gmail',
     displayName: 'Gmail',
-    shortDescription: 'List, read, and send emails.',
+    shortDescription: 'Read, search, draft, send, and organize emails and threads.',
     category: 'Collaboration & Communication',
     icon: GMAIL_ICON,
     auth: {
@@ -20,10 +18,13 @@ export default defineToolkit({
             scopes: [
                 'https://www.googleapis.com/auth/gmail.readonly',
                 'https://www.googleapis.com/auth/gmail.send',
+                'https://www.googleapis.com/auth/gmail.compose',
+                'https://www.googleapis.com/auth/gmail.modify',
+                'https://www.googleapis.com/auth/gmail.labels',
             ],
             exchangeStyle: 'form',
             extraAuthParams: { access_type: 'offline', prompt: 'consent' },
-            connectDescription: 'Connect Gmail to read, draft, and send emails with AI-driven summarization.',
+            connectDescription: 'Connect Gmail to read, draft, send, search, and organize emails and conversation threads.',
             callbackPath: '/api/auth/gmail/callback',
             stateCookie: 'google_oauth_state',
         },
@@ -48,6 +49,78 @@ export default defineToolkit({
             requiredAuth: 'gmailToken',
             scope: 'write',
         }),
+        defineTool({
+            name: 'gmailCreateDraft',
+            tool: createDraft,
+            requiredAuth: 'gmailToken',
+            scope: 'write',
+        }),
+        defineTool({
+            name: 'gmailListDrafts',
+            tool: listDrafts,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailGetDraft',
+            tool: getDraft,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailSendDraft',
+            tool: sendDraft,
+            requiredAuth: 'gmailToken',
+            scope: 'write',
+        }),
+        defineTool({
+            name: 'gmailDeleteDraft',
+            tool: deleteDraft,
+            requiredAuth: 'gmailToken',
+            scope: 'delete',
+        }),
+        defineTool({
+            name: 'gmailListThreads',
+            tool: listThreads,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailGetThread',
+            tool: getThread,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailReplyToThread',
+            tool: replyToThread,
+            requiredAuth: 'gmailToken',
+            scope: 'write',
+        }),
+        defineTool({
+            name: 'gmailListLabels',
+            tool: listLabels,
+            requiredAuth: 'gmailToken',
+            scope: 'read',
+        }),
+        defineTool({
+            name: 'gmailModifyMessageLabels',
+            tool: modifyMessageLabels,
+            requiredAuth: 'gmailToken',
+            scope: 'write',
+        }),
+        defineTool({
+            name: 'gmailTrashMessage',
+            tool: trashMessage,
+            requiredAuth: 'gmailToken',
+            scope: 'delete',
+        }),
+        defineTool({
+            name: 'gmailUntrashMessage',
+            tool: untrashMessage,
+            requiredAuth: 'gmailToken',
+            scope: 'write',
+        }),
     ],
     meta: { since: '0.0.1' },
 });

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

@@ -0,0 +1,34 @@
+export declare const createDraft: import("ai").Tool<{
+    subject: string;
+    to: string;
+    body: string;
+    gmailToken?: string | undefined;
+    threadId?: string | undefined;
+    cc?: string | undefined;
+    bcc?: string | undefined;
+}, {
+    error: string;
+    details: any;
+    success?: undefined;
+    draftId?: undefined;
+    messageId?: undefined;
+    threadId?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    draftId: any;
+    messageId: any;
+    threadId: any;
+    error?: undefined;
+    details?: undefined;
+    message?: undefined;
+} | {
+    error: string;
+    message: string;
+    details?: undefined;
+    success?: undefined;
+    draftId?: undefined;
+    messageId?: undefined;
+    threadId?: undefined;
+}>;
+//# sourceMappingURL=create-draft.d.ts.map

package/dist/toolkits/gmail/tools/create-draft.js

@@ -0,0 +1,60 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+import { encodeRFC822Message } from './utils.js';
+export const createDraft = tool({
+    description: 'Create a draft email in Gmail without sending it immediately. Highly recommended for human-in-the-loop review.',
+    inputSchema: z.object({
+        gmailToken: z.string().optional().describe('Injected by system; do not provide'),
+        to: z.string().describe('Recipient email address'),
+        subject: z.string().describe('Email subject'),
+        body: z.string().describe('Email body (plain text)'),
+        cc: z.string().optional().describe('Optional CC recipient email address(es), comma-separated'),
+        bcc: z.string().optional().describe('Optional BCC recipient email address(es), comma-separated'),
+        threadId: z.string().optional().describe('Optional thread ID to associate the draft with an existing conversation thread'),
+    }),
+    execute: async ({ gmailToken, to, subject, body, cc, bcc, threadId }) => {
+        try {
+            const encodedMessage = encodeRFC822Message({
+                to,
+                subject,
+                body,
+                cc,
+                bcc,
+            });
+            const messagePayload = {
+                raw: encodedMessage,
+            };
+            if (threadId) {
+                messagePayload.threadId = threadId;
+            }
+            const response = await fetch('https://gmail.googleapis.com/gmail/v1/users/me/drafts', {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${gmailToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    message: messagePayload,
+                }),
+            });
+            if (!response.ok) {
+                const error = await response.json();
+                return { error: 'Failed to create draft', details: error };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                draftId: data.id,
+                messageId: data.message?.id,
+                threadId: data.message?.threadId,
+            };
+        }
+        catch (error) {
+            return {
+                error: 'Error creating draft',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            };
+        }
+    },
+});
+//# sourceMappingURL=create-draft.js.map