@mirra-messenger/sdk 0.3.0 → 0.5.0

package/dist/generated/adapters.js

@@ -0,0 +1,2669 @@
+"use strict";
+/**
+ * Auto-Generated SDK Adapter Methods
+ *
+ * DO NOT EDIT THIS FILE DIRECTLY
+ * Generated from adapter operation schemas
+ * Run: npm run generate:llm-api
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatedAdapters = void 0;
+// ============================================================================
+// Adapter Factory Functions
+// ============================================================================
+/**
+ * Flows Adapter
+ * Category: internal
+ */
+function createFlowsAdapter(sdk) {
+    return {
+        /**
+         * Create a new time-based flow with cron schedule
+         * @param args.title - Flow title
+         * @param args.description - Detailed description of what the flow does
+         * @param args.schedule - Cron expression for scheduling (e.g., "0 9 * * *" for daily at 9am)
+         * @param args.scriptId - ID of the script to execute when triggered
+         * @param args.scriptInput - Optional static input data for the script (optional)
+         */
+        createTimeFlow: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'flows',
+                method: 'createTimeFlow',
+                params: args || {}
+            });
+        },
+        /**
+         * Create an event-based flow with pre-filtering conditions.
+    
+    EFFICIENCY RULE: Always filter in eventFilter, not the script.
+    - eventFilter conditions: FREE (evaluated in-memory before script runs)
+    - Script filtering: EXPENSIVE (invokes Lambda for every event)
+    
+    BAD: Trigger on "telegram.message" with no filter → script checks sender
+    GOOD: Trigger on "telegram.message" with eventFilter for sender
+    
+    TRIGGER STRUCTURE:
+    {
+      type: "event",
+      config: {
+        eventFilter: {
+          operator: "and" | "or",
+          conditions: [
+            { operator: "equals", field: "eventType", value: "call.ended" },
+            { operator: "contains", field: "content.text", value: "urgent" }
+          ]
+        }
+      }
+    }
+    
+    VALID OPERATORS: equals, notEquals, contains, startsWith, endsWith, greaterThan, lessThan, exists, notExists, matchesRegex, and, or, not
+    
+    COMMON EVENT TYPES: call.started, call.ended, call.action, telegram.message, gmail.email_received
+         * @param args.title - Flow title
+         * @param args.description - Detailed description of what the flow does
+         * @param args.trigger - Event filter conditions that determine WHEN the script runs. Add ALL filtering logic here to minimize Lambda invocations. Must have type:"event" and config.eventFilter with operator and conditions array.
+         * @param args.scriptId - ID of the script to execute when triggered
+         * @param args.scriptInput - Optional static input data for the script (optional)
+         */
+        createEventFlow: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'flows',
+                method: 'createEventFlow',
+                params: args || {}
+            });
+        },
+        /**
+         * List all flows for the user
+         * @param args.status - Filter by status: active, paused, completed, failed (optional)
+         */
+        listFlows: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'flows',
+                method: 'listFlows',
+                params: args || {}
+            });
+        },
+        /**
+         * Get a specific flow by ID
+         * @param args.id - Flow ID
+         */
+        getFlow: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'flows',
+                method: 'getFlow',
+                params: args || {}
+            });
+        },
+        /**
+         * Update an existing flow
+         * @param args.id - Flow ID to update
+         * @param args.title - New title (optional)
+         * @param args.description - New description (optional)
+         * @param args.trigger - New trigger configuration (optional)
+         * @param args.scriptId - New script ID (optional)
+         * @param args.scriptInput - New script input data (optional)
+         * @param args.status - New status: active, paused, completed, failed (optional)
+         */
+        updateFlow: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'flows',
+                method: 'updateFlow',
+                params: args || {}
+            });
+        },
+        /**
+         * Delete a flow
+         * @param args.id - Flow ID to delete
+         */
+        deleteFlow: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'flows',
+                method: 'deleteFlow',
+                params: args || {}
+            });
+        },
+        /**
+         * Pause an active flow
+         * @param args.id - Flow ID to pause
+         */
+        pauseFlow: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'flows',
+                method: 'pauseFlow',
+                params: args || {}
+            });
+        },
+        /**
+         * Resume a paused flow
+         * @param args.id - Flow ID to resume
+         */
+        resumeFlow: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'flows',
+                method: 'resumeFlow',
+                params: args || {}
+            });
+        },
+        /**
+         * Search flows with filters
+         * @param args.status - Filter by status (or array of statuses) (optional)
+         * @param args.triggerType - Filter by trigger type: time or event (optional)
+         * @param args.limit - Maximum number of results (default: 100) (optional)
+         * @param args.offset - Pagination offset (default: 0) (optional)
+         */
+        searchFlows: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'flows',
+                method: 'searchFlows',
+                params: args || {}
+            });
+        },
+        /**
+         * Record execution result for a flow
+         * @param args.id - Flow ID
+         * @param args.success - Whether execution succeeded
+         * @param args.result - Execution result data (optional)
+         * @param args.error - Error message if execution failed (optional)
+         */
+        recordExecution: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'flows',
+                method: 'recordExecution',
+                params: args || {}
+            });
+        },
+        /**
+         * List all available event types that can trigger automations
+         * @param args.includeTemplates - Include condition templates for each event type (optional)
+         */
+        listEventTypes: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'flows',
+                method: 'listEventTypes',
+                params: args || {}
+            });
+        },
+        /**
+         * Test a flow by generating an event that matches the trigger conditions.
+    
+    MODES:
+    - dryRun=true (DEFAULT): Validates trigger matching only. Safe, no side effects, no token consumption.
+    - dryRun=false: Executes the real script. WARNING: This causes real side effects (sends messages, makes API calls, consumes tokens).
+    
+    Use dryRun=true first to verify trigger conditions work, then dryRun=false only when ready to test full execution.
+    
+    WORKFLOW:
+    1. Generates a test event from the flow's trigger conditions
+    2. Validates the event matches the trigger (always)
+    3. If dryRun=false, executes the script with the test event
+    
+    RESULT:
+    Returns detailed information about trigger matching, including which conditions passed/failed, and optionally full execution results.
+         * @param args.flowId - ID of the flow to test
+         * @param args.dryRun - If true (default), only validate trigger matching without executing script. If false, execute the script (causes side effects). (optional)
+         * @param args.eventOverrides - Custom field values to merge into the generated test event (e.g., {"content.text": "custom message"}) (optional)
+         */
+        testFlow: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'flows',
+                method: 'testFlow',
+                params: args || {}
+            });
+        },
+        /**
+         * Check if a custom event would match a flow trigger without any execution. Useful for debugging trigger conditions or testing with real event data.
+         * @param args.flowId - ID of the flow
+         * @param args.event - Event object to test against the trigger (must match IntegrationEvent structure)
+         */
+        validateTrigger: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'flows',
+                method: 'validateTrigger',
+                params: args || {}
+            });
+        },
+        /**
+         * Get all active flows that are triggered by a specific event type. Used by frontend to show flow selection for targeted execution (e.g., call.action flows).
+         * @param args.eventType - Event type to filter by (e.g., "call.action", "call.ended", "telegram.message")
+         */
+        getFlowsByEventType: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'flows',
+                method: 'getFlowsByEventType',
+                params: args || {}
+            });
+        }
+    };
+}
+/**
+ * User Adapter
+ * Category: internal
+ */
+function createUserAdapter(sdk) {
+    return {
+        /**
+         * Get user profile information including username, email, timezone, phone, and usage stats
+         */
+        getProfile: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'user',
+                method: 'getProfile',
+                params: args || {}
+            });
+        },
+        /**
+         * Update user profile fields (username, email, timezone, phone)
+         * @param args.username - New username (3-30 characters, alphanumeric with underscores/hyphens) (optional)
+         * @param args.email - New email address (optional)
+         * @param args.timezone - IANA timezone identifier (e.g., America/Los_Angeles) (optional)
+         * @param args.phoneNumber - Phone number (7-15 digits with optional formatting) (optional)
+         */
+        updateProfile: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'user',
+                method: 'updateProfile',
+                params: args || {}
+            });
+        },
+        /**
+         * Update user preferences (notification settings, etc)
+         * @param args.timezone - Preferred timezone for scheduling (optional)
+         * @param args.socials - Social media links (twitter, discord) (optional)
+         */
+        updatePreferences: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'user',
+                method: 'updatePreferences',
+                params: args || {}
+            });
+        },
+        /**
+         * Get token usage statistics, quota, and billing information
+         */
+        getUsageStats: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'user',
+                method: 'getUsageStats',
+                params: args || {}
+            });
+        },
+        /**
+         * Get active sessions/devices (based on push token registrations)
+         */
+        getSessions: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'user',
+                method: 'getSessions',
+                params: args || {}
+            });
+        },
+        /**
+         * Soft delete user account (set inactive flag) - CAUTION: This marks the account for deletion
+         * @param args.confirm - Must be true to confirm account deactivation
+         */
+        deactivateAccount: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'user',
+                method: 'deactivateAccount',
+                params: args || {}
+            });
+        }
+    };
+}
+/**
+ * Contacts Adapter
+ * Category: internal
+ */
+function createContactsAdapter(sdk) {
+    return {
+        /**
+         * Get a list of all accepted contacts for the user with their profile information
+         * @param args.limit - Maximum number of contacts to return (default: 100) (optional)
+         * @param args.offset - Number of contacts to skip for pagination (default: 0) (optional)
+         */
+        listContacts: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'contacts',
+                method: 'listContacts',
+                params: args || {}
+            });
+        },
+        /**
+         * Get detailed information about a specific contact by their ID or username
+         * @param args.contactId - The contact user ID (MongoDB ObjectId) (optional)
+         * @param args.username - The contact username (optional)
+         */
+        getContact: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'contacts',
+                method: 'getContact',
+                params: args || {}
+            });
+        },
+        /**
+         * Send a contact request to another user by their username
+         * @param args.username - Username of the user to add as a contact
+         */
+        addContact: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'contacts',
+                method: 'addContact',
+                params: args || {}
+            });
+        },
+        /**
+         * Remove a user from your contacts list (unfriend)
+         * @param args.contactId - The contact user ID to remove (optional)
+         * @param args.username - The contact username to remove (optional)
+         */
+        removeContact: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'contacts',
+                method: 'removeContact',
+                params: args || {}
+            });
+        },
+        /**
+         * Search your contacts by username, email, phone, or wallet address
+         * @param args.query - Search query - can be username, email, phone, or wallet address
+         * @param args.searchType - Type of search to perform: all, username, email, phone, or wallet (default: all) (optional)
+         * @param args.limit - Maximum number of results (default: 20) (optional)
+         */
+        searchContacts: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'contacts',
+                method: 'searchContacts',
+                params: args || {}
+            });
+        },
+        /**
+         * Block a user (prevents them from contacting you)
+         * @param args.contactId - The user ID to block (optional)
+         * @param args.username - The username to block (optional)
+         */
+        blockContact: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'contacts',
+                method: 'blockContact',
+                params: args || {}
+            });
+        },
+        /**
+         * Unblock a previously blocked user
+         * @param args.contactId - The user ID to unblock (optional)
+         * @param args.username - The username to unblock (optional)
+         */
+        unblockContact: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'contacts',
+                method: 'unblockContact',
+                params: args || {}
+            });
+        },
+        /**
+         * Get a list of all users you have blocked
+         * @param args.limit - Maximum number of results (default: 100) (optional)
+         * @param args.offset - Number of items to skip for pagination (default: 0) (optional)
+         */
+        getBlockedContacts: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'contacts',
+                method: 'getBlockedContacts',
+                params: args || {}
+            });
+        },
+        /**
+         * Get pending contact requests (sent by you or received from others)
+         * @param args.type - Type of requests to retrieve: all, sent, or received (default: all) (optional)
+         * @param args.status - Filter by request status: pending, accepted, or rejected (default: pending) (optional)
+         */
+        getContactRequests: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'contacts',
+                method: 'getContactRequests',
+                params: args || {}
+            });
+        }
+    };
+}
+/**
+ * Memory Adapter
+ * Category: internal
+ */
+function createMemoryAdapter(sdk) {
+    return {
+        /**
+         * Create a new memory entity in the knowledge graph. Use the type field to specify what kind of memory (task, note, idea, shopping_item, etc.)
+         * @param args.type - Memory subtype: "task" (reminders/todos), "note" (general notes), "idea" (concepts/ideas), "shopping_item" (shopping list), "topic" (general knowledge), "document" (documents), "contact" (people), or "event" (calendar items)
+         * @param args.content - Main content/description of the memory
+         * @param args.metadata - Additional metadata (e.g., priority, deadline, tags, etc.) (optional)
+         */
+        create: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'memory',
+                method: 'create',
+                params: args || {}
+            });
+        },
+        /**
+         * Semantic search across memory entities with advanced filtering
+         * @param args.query - Search query text for semantic matching
+         * @param args.types - Filter by entity types (e.g., ["TASK", "NOTE", "IDEA"]) (optional)
+         * @param args.startTime - Filter entities created after this timestamp (Unix milliseconds) (optional)
+         * @param args.endTime - Filter entities created before this timestamp (Unix milliseconds) (optional)
+         * @param args.propertyFilters - Filter by entity properties: { status: ["completed"], tags: ["urgent"], priority: ["high"], roles: ["task"], contexts: ["work"] } (optional)
+         * @param args.limit - Maximum number of results (default: 50, max: 100) (optional)
+         */
+        search: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'memory',
+                method: 'search',
+                params: args || {}
+            });
+        },
+        /**
+         * Query memory entities with filters. Returns lightweight summaries with normalized fields: id, type, name, description, status, priority, createdAt, updatedAt
+         * @param args.type - Semantic type filter (e.g., "task", "note", "idea", "reminder", "contact", "document"). Matches against meta_item_type, subType, or semantic_roles (optional)
+         * @param args.filters - Additional filters (not yet implemented) (optional)
+         * @param args.limit - Maximum results (default: 50, max: 100). Use smaller limits to get complete results without truncation (optional)
+         * @param args.offset - Pagination offset for fetching more results (default: 0) (optional)
+         */
+        query: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'memory',
+                method: 'query',
+                params: args || {}
+            });
+        },
+        /**
+         * Find a single entity matching criteria
+         * @param args.filters - Filter criteria (e.g., { id: "..." })
+         */
+        findOne: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'memory',
+                method: 'findOne',
+                params: args || {}
+            });
+        },
+        /**
+         * Update an existing memory entity
+         * @param args.id - Entity ID to update
+         * @param args.type - Entity type (optional)
+         * @param args.content - Updated content (optional)
+         * @param args.metadata - Updated metadata (optional)
+         */
+        update: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'memory',
+                method: 'update',
+                params: args || {}
+            });
+        },
+        /**
+         * Delete a memory entity
+         * @param args.id - Entity ID to delete
+         */
+        delete: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'memory',
+                method: 'delete',
+                params: args || {}
+            });
+        }
+    };
+}
+/**
+ * AI Services Adapter
+ * Category: internal
+ */
+function createAiAdapter(sdk) {
+    return {
+        /**
+         * Have a conversation with an AI assistant. Supports multi-turn conversations with system prompts, user messages, and assistant responses.
+    
+    PROVIDER: Uses Anthropic (Claude) as the AI provider.
+    
+    BEST PRACTICES:
+    - Use system messages to set AI behavior and constraints
+    - Keep conversations focused - avoid unnecessary context
+    
+    MESSAGE STRUCTURE:
+    Each message has:
+    - role: "system" | "user" | "assistant"
+    - content: string (the message text)
+    
+    TYPICAL PATTERNS:
+    1. Simple query: [{ role: "user", content: "question" }]
+    2. With system prompt: [{ role: "system", content: "instructions" }, { role: "user", content: "question" }]
+    3. Multi-turn: [system, user, assistant, user, assistant, ...]
+         * @param args.messages - Array of message objects with role ("system" | "user" | "assistant") and content (string). System messages set AI behavior, user messages are queries, assistant messages are previous AI responses.
+         * @param args.model - Specific model to use. Default: "claude-3-haiku-20240307". Use Anthropic Claude model names. (optional)
+         * @param args.temperature - Creativity level 0.0-1.0. Lower=factual/consistent, Higher=creative/varied. Default: 0.7 (optional)
+         * @param args.maxTokens - Maximum tokens in response. Default: 1000. Increase for longer responses (costs more tokens). (optional)
+         */
+        chat: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'ai',
+                method: 'chat',
+                params: args || {}
+            });
+        },
+        /**
+         * Use AI to make a decision from a list of options. The AI analyzes your prompt, considers the context, and selects the most appropriate option with reasoning.
+    
+    USE CASES:
+    - Route messages to correct handlers
+    - Classify user intents
+    - Select appropriate tools or actions
+    - Prioritize tasks
+    - Choose templates or responses
+    - Determine sentiment or category
+    
+    HOW IT WORKS:
+    1. Provide a prompt (the decision context)
+    2. List available options (each with id and label)
+    3. Optionally add extra context
+    4. AI returns selected option ID and reasoning
+    
+    BEST PRACTICES:
+    - Make option labels clear and descriptive
+    - Use unique IDs for options
+    - Add context when decision needs background info
+    - Keep prompt focused on the decision criteria
+    - Use metadata field for additional option data
+         * @param args.prompt - The decision prompt - what needs to be decided and why
+         * @param args.options - Array of options to choose from. Each option must have: id (unique identifier), label (descriptive name), and optional metadata (additional data)
+         * @param args.context - Additional context to help the AI make a better decision (optional)
+         * @param args.model - Specific model to use. Defaults to system default. (optional)
+         */
+        decide: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'ai',
+                method: 'decide',
+                params: args || {}
+            });
+        }
+    };
+}
+/**
+ * Documents Adapter
+ * Category: storage
+ */
+function createDocumentAdapter(sdk) {
+    return {
+        /**
+         * Upload and process a document (PDF, DOCX, TXT, MD)
+         * @param args.file - Base64 encoded file content
+         * @param args.filename - Original filename with extension
+         * @param args.mimeType - MIME type (application/pdf, text/plain, etc.)
+         * @param args.graphId - Target graph ID (defaults to user's personal graph) (optional)
+         * @param args.title - Custom document title (optional)
+         * @param args.productTags - Array of product tags for categorization (optional)
+         */
+        upload: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'document',
+                method: 'upload',
+                params: args || {}
+            });
+        },
+        /**
+         * Get document metadata and content
+         * @param args.documentId - Document ID to retrieve
+         */
+        get: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'document',
+                method: 'get',
+                params: args || {}
+            });
+        },
+        /**
+         * Get document processing status
+         * @param args.documentId - Document ID to check
+         */
+        getStatus: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'document',
+                method: 'getStatus',
+                params: args || {}
+            });
+        },
+        /**
+         * Get all chunks for a document
+         * @param args.documentId - Document ID
+         */
+        getChunks: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'document',
+                method: 'getChunks',
+                params: args || {}
+            });
+        },
+        /**
+         * Delete a document and all its chunks
+         * @param args.documentId - Document ID to delete
+         */
+        delete: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'document',
+                method: 'delete',
+                params: args || {}
+            });
+        },
+        /**
+         * Share a document to another graph (group or user-contact)
+         * @param args.documentId - Document ID to share
+         * @param args.targetGraphId - Target graph ID to share to
+         * @param args.shareReason - Optional reason for sharing (optional)
+         */
+        share: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'document',
+                method: 'share',
+                params: args || {}
+            });
+        },
+        /**
+         * Remove document access from a graph
+         * @param args.documentId - Document ID
+         * @param args.graphId - Graph ID to remove access from
+         */
+        unshare: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'document',
+                method: 'unshare',
+                params: args || {}
+            });
+        },
+        /**
+         * List all graphs a document is shared in
+         * @param args.documentId - Document ID
+         */
+        listGraphs: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'document',
+                method: 'listGraphs',
+                params: args || {}
+            });
+        },
+        /**
+         * Semantic search across document chunks
+         * @param args.query - Search query
+         * @param args.graphId - Graph ID to search in (defaults to user's graph) (optional)
+         * @param args.limit - Maximum results (default: 10) (optional)
+         * @param args.threshold - Similarity threshold 0-1 (default: 0.7) (optional)
+         */
+        search: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'document',
+                method: 'search',
+                params: args || {}
+            });
+        },
+        /**
+         * List documents in a graph
+         * @param args.graphId - Graph ID to list documents from (defaults to user's graph) (optional)
+         * @param args.limit - Maximum results (default: 50) (optional)
+         * @param args.offset - Pagination offset (default: 0) (optional)
+         */
+        list: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'document',
+                method: 'list',
+                params: args || {}
+            });
+        }
+    };
+}
+/**
+ * Feed Items Adapter
+ * Category: internal
+ */
+function createFeedItemsAdapter(sdk) {
+    return {
+        /**
+         * Create a feed item with flexible content blocks. Use this to show action results, notifications, or updates to users.
+         * @param args.title - Main title of the feed item (shown prominently)
+         * @param args.subtitle - Optional subtitle (shown below title in muted color) (optional)
+         * @param args.blocks - Array of content blocks to display (text, key_value, list, timestamp, user_mention, divider, image, progress)
+         * @param args.itemType - Type: informative (FYI), actionable (needs response), or error
+         * @param args.actions - Optional action buttons for the feed item (optional)
+         * @param args.avatar - Optional avatar to show (user profile, icon, or custom image) (optional)
+         * @param args.metadata - Additional metadata (searchable, not displayed) (optional)
+         */
+        createFeedItem: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'feed-items',
+                method: 'create_feed_item',
+                params: args || {}
+            });
+        }
+    };
+}
+/**
+ * Telegram Adapter
+ * Category: social
+ */
+function createTelegramAdapter(sdk) {
+    return {
+        /**
+         * Send a text message to a Telegram chat or user. Supports both chat IDs and usernames.
+         * @param args.chatId - Chat ID (numeric) or username (e.g., @username) to send the message to. Chat IDs can be obtained from getChats operation.
+         * @param args.text - The text content of the message to send
+         */
+        sendMessage: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'telegram',
+                method: 'sendMessage',
+                params: args || {}
+            });
+        },
+        /**
+         * Retrieve Telegram chats with pagination support. Use limit and offset to paginate through large chat lists. Results are cached for 10 minutes.
+         * @param args.limit - Maximum number of chats to return (default: 50, max: 100). Use pagination for large chat lists to avoid token limits. (optional)
+         * @param args.offset - Number of chats to skip for pagination (default: 0). Combine with limit to fetch subsequent pages. (optional)
+         * @param args.forceRefresh - If true, bypasses the cache and fetches fresh chat data from Telegram. Default: false (optional)
+         */
+        getChats: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'telegram',
+                method: 'getChats',
+                params: args || {}
+            });
+        },
+        /**
+         * Find a Telegram chat by name or username. Searches through user's chats and returns the first match.
+         * @param args.name - Chat name, username (with or without @), or partial match to search for
+         */
+        findChatByName: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'telegram',
+                method: 'findChatByName',
+                params: args || {}
+            });
+        },
+        /**
+         * Search for messages across Telegram chats by content, date range, sender, or specific chats.
+         * @param args.chatIds - Array of chat IDs to search within. If not provided, searches globally. (optional)
+         * @param args.query - Text query to search for in messages (optional)
+         * @param args.fromDate - ISO date string for start of date range (optional)
+         * @param args.toDate - ISO date string for end of date range (optional)
+         * @param args.limit - Maximum number of messages to return (default: 100, max: 100) (optional)
+         * @param args.senderId - Filter messages by sender ID (optional)
+         */
+        searchMessages: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'telegram',
+                method: 'searchMessages',
+                params: args || {}
+            });
+        },
+        /**
+         * Get recent private chat contacts from Telegram, ordered by most recent activity. Uses the cached chat list filtered for 1:1 conversations.
+         * @param args.limit - Maximum number of contacts to return (default: 100, max: 100) (optional)
+         */
+        getRecentContacts: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'telegram',
+                method: 'getRecentContacts',
+                params: args || {}
+            });
+        },
+        /**
+         * Get message history from a specific Telegram chat with pagination and date filtering.
+         * @param args.chatId - Chat ID to retrieve messages from
+         * @param args.limit - Maximum number of messages to return (default: 50, max: 100) (optional)
+         * @param args.offsetId - Message ID to use as pagination offset (optional)
+         * @param args.minDate - ISO date string for minimum message date (optional)
+         * @param args.maxDate - ISO date string for maximum message date (optional)
+         */
+        getChatMessages: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'telegram',
+                method: 'getChatMessages',
+                params: args || {}
+            });
+        },
+        /**
+         * Get summary of unread messages across Telegram chats, including mentions and last message info.
+         * @param args.chatIds - Array of chat IDs to filter by. If not provided, checks all chats. (optional)
+         * @param args.priorityOnly - If true, only return chats with unread messages (optional)
+         * @param args.groupBy - Group results by "chat" or "sender" (optional)
+         */
+        getUnreadSummary: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'telegram',
+                method: 'getUnreadSummary',
+                params: args || {}
+            });
+        },
+        /**
+         * Mark messages as read in a Telegram chat up to a specific message ID.
+         * @param args.chatId - Chat ID to mark messages as read in
+         * @param args.maxMessageId - Maximum message ID to mark as read. If not provided, marks all messages as read. (optional)
+         */
+        markAsRead: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'telegram',
+                method: 'markAsRead',
+                params: args || {}
+            });
+        },
+        /**
+         * Get messages where the user is mentioned in Telegram chats.
+         * @param args.chatIds - Array of chat IDs to filter mentions by (optional)
+         * @param args.sinceDate - ISO date string - only return mentions since this date (optional)
+         * @param args.onlyUnread - If true, only return unread mentions (optional)
+         */
+        getMentions: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'telegram',
+                method: 'getMentions',
+                params: args || {}
+            });
+        },
+        /**
+         * Perform a global search across all Telegram chats for messages matching a query.
+         * @param args.query - Search query text
+         * @param args.filter - Filter results by chat type: "groups", "private", or "channels" (optional)
+         * @param args.limit - Maximum number of results to return (default: 100, max: 100) (optional)
+         */
+        globalSearch: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'telegram',
+                method: 'globalSearch',
+                params: args || {}
+            });
+        }
+    };
+}
+/**
+ * Gmail Adapter
+ * Category: communication
+ */
+function createGoogleGmailAdapter(sdk) {
+    return {
+        /**
+         * Send an email via Gmail
+         * @param args.to - Valid email address
+         * @param args.subject - Email subject line
+         * @param args.body - Email body content
+         * @param args.cc - CC recipients (comma-separated email addresses) (optional)
+         * @param args.bcc - BCC recipients (comma-separated email addresses) (optional)
+         * @param args.isHtml - Whether body is HTML format (optional)
+         */
+        sendEmail: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-gmail',
+                method: 'sendEmail',
+                params: args || {}
+            });
+        },
+        /**
+         * Search emails with Gmail query syntax
+         * @param args.query - Gmail search query (e.g., "from:user@example.com is:unread")
+         * @param args.maxResults - Maximum number of results to return (default: 50, max: 100) (optional)
+         */
+        searchEmails: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-gmail',
+                method: 'searchEmails',
+                params: args || {}
+            });
+        },
+        /**
+         * List recent emails from inbox
+         * @param args.maxResults - Maximum number of results to return (default: 50, max: 100) (optional)
+         */
+        listEmails: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-gmail',
+                method: 'listEmails',
+                params: args || {}
+            });
+        },
+        /**
+         * Get details of a specific email by ID
+         * @param args.messageId - Gmail message ID
+         */
+        getEmail: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-gmail',
+                method: 'getEmail',
+                params: args || {}
+            });
+        },
+        /**
+         * Create a draft email in Gmail
+         * @param args.to - Valid email address
+         * @param args.subject - Email subject line
+         * @param args.body - Email body content
+         * @param args.cc - CC recipients (comma-separated email addresses) (optional)
+         * @param args.bcc - BCC recipients (comma-separated email addresses) (optional)
+         * @param args.isHtml - Whether body is HTML format (optional)
+         */
+        createDraft: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-gmail',
+                method: 'createDraft',
+                params: args || {}
+            });
+        },
+        /**
+         * Update an existing draft email
+         * @param args.draftId - Gmail draft ID to update
+         * @param args.to - Updated recipient email address(es) (optional)
+         * @param args.subject - Updated email subject line (optional)
+         * @param args.body - Updated email body content (optional)
+         * @param args.cc - Updated CC recipients (optional)
+         * @param args.bcc - Updated BCC recipients (optional)
+         * @param args.isHtml - Whether body is HTML format (optional)
+         */
+        updateDraft: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-gmail',
+                method: 'updateDraft',
+                params: args || {}
+            });
+        },
+        /**
+         * Delete a draft email
+         * @param args.draftId - Gmail draft ID to delete
+         */
+        deleteDraft: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-gmail',
+                method: 'deleteDraft',
+                params: args || {}
+            });
+        },
+        /**
+         * List all draft emails
+         * @param args.maxResults - Maximum number of drafts to return (default: 10) (optional)
+         */
+        listDrafts: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-gmail',
+                method: 'listDrafts',
+                params: args || {}
+            });
+        },
+        /**
+         * Delete an email
+         * @param args.messageId - Gmail message ID to delete
+         */
+        deleteEmail: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-gmail',
+                method: 'deleteEmail',
+                params: args || {}
+            });
+        }
+    };
+}
+/**
+ * Google Calendar Adapter
+ * Category: productivity
+ */
+function createGoogleCalendarAdapter(sdk) {
+    return {
+        /**
+         * Create a new calendar event
+         * @param args.summary - Event title/summary
+         * @param args.start - Start time object with dateTime and optional timeZone
+         * @param args.end - End time object with dateTime and optional timeZone
+         * @param args.description - Event description (optional)
+         * @param args.location - Event location (optional)
+         * @param args.attendees - Array of attendee email addresses (optional)
+         */
+        createEvent: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-calendar',
+                method: 'createEvent',
+                params: args || {}
+            });
+        },
+        /**
+         * List calendar events
+         * @param args.timeMin - Start time for events to list (ISO 8601) (optional)
+         * @param args.timeMax - End time for events to list (ISO 8601) (optional)
+         * @param args.maxResults - Maximum number of events to return (default: 50, max: 100) (optional)
+         * @param args.query - Search query to filter events (optional)
+         */
+        listEvents: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-calendar',
+                method: 'listEvents',
+                params: args || {}
+            });
+        },
+        /**
+         * Get calendar events (alias for listEvents)
+         * @param args.timeMin - Start time for events to list (ISO 8601) (optional)
+         * @param args.timeMax - End time for events to list (ISO 8601) (optional)
+         * @param args.maxResults - Maximum number of events to return (default: 50, max: 100) (optional)
+         * @param args.query - Search query to filter events (optional)
+         */
+        getEvents: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-calendar',
+                method: 'getEvents',
+                params: args || {}
+            });
+        },
+        /**
+         * Get a specific calendar event by ID
+         * @param args.eventId - Calendar event ID
+         */
+        getEvent: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-calendar',
+                method: 'getEvent',
+                params: args || {}
+            });
+        },
+        /**
+         * Update an existing calendar event
+         * @param args.eventId - Calendar event ID to update
+         * @param args.summary - Updated event title/summary (optional)
+         * @param args.description - Updated event description (optional)
+         * @param args.location - Updated event location (optional)
+         * @param args.start - Updated start time object with dateTime and optional timeZone (optional)
+         * @param args.end - Updated end time object with dateTime and optional timeZone (optional)
+         */
+        updateEvent: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-calendar',
+                method: 'updateEvent',
+                params: args || {}
+            });
+        },
+        /**
+         * Delete a calendar event
+         * @param args.eventId - Calendar event ID to delete
+         */
+        deleteEvent: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-calendar',
+                method: 'deleteEvent',
+                params: args || {}
+            });
+        },
+        /**
+         * Search calendar events by text query
+         * @param args.query - Search query to filter events
+         * @param args.timeMin - Start time for events to search (ISO 8601) (optional)
+         * @param args.timeMax - End time for events to search (ISO 8601) (optional)
+         * @param args.maxResults - Maximum number of events to return (default: 50, max: 100) (optional)
+         */
+        searchEvents: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-calendar',
+                method: 'searchEvents',
+                params: args || {}
+            });
+        }
+    };
+}
+/**
+ * Google Drive Adapter
+ * Category: storage
+ */
+function createGoogleDriveAdapter(sdk) {
+    return {
+        /**
+         * List files in Google Drive
+         * @param args.query - Search query (Google Drive query syntax) (optional)
+         * @param args.pageSize - Maximum number of files to return (default: 20) (optional)
+         */
+        listFiles: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-drive',
+                method: 'listFiles',
+                params: args || {}
+            });
+        },
+        /**
+         * Create a new file in Google Drive
+         * @param args.name - Name of the file
+         * @param args.mimeType - MIME type of the file
+         * @param args.folderId - Parent folder ID (optional) (optional)
+         */
+        createFile: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-drive',
+                method: 'createFile',
+                params: args || {}
+            });
+        },
+        /**
+         * Create a new folder in Google Drive
+         * @param args.name - Name of the folder
+         * @param args.parentFolderId - Parent folder ID (optional) (optional)
+         */
+        createFolder: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-drive',
+                method: 'createFolder',
+                params: args || {}
+            });
+        },
+        /**
+         * Get information about a file
+         * @param args.fileId - ID of the file
+         */
+        getFileInfo: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-drive',
+                method: 'getFileInfo',
+                params: args || {}
+            });
+        },
+        /**
+         * Share a file with others
+         * @param args.fileId - ID of the file to share
+         * @param args.email - Email address to share with (optional) (optional)
+         * @param args.role - Permission role: reader, writer, commenter (default: reader) (optional)
+         */
+        shareFile: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-drive',
+                method: 'shareFile',
+                params: args || {}
+            });
+        },
+        /**
+         * Download a file from Google Drive. For Google Docs/Sheets, exports as PDF/XLSX. Returns base64-encoded data.
+         * @param args.fileId - ID of the file to download
+         */
+        downloadFile: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-drive',
+                method: 'downloadFile',
+                params: args || {}
+            });
+        },
+        /**
+         * Move a file to a different folder
+         * @param args.fileId - ID of the file to move
+         * @param args.folderId - ID of the destination folder
+         */
+        moveFile: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-drive',
+                method: 'moveFile',
+                params: args || {}
+            });
+        },
+        /**
+         * Delete a file or folder. By default moves to trash; set permanently=true to delete forever.
+         * @param args.fileId - ID of the file or folder to delete
+         * @param args.permanently - If true, permanently delete instead of moving to trash (default: false) (optional)
+         */
+        deleteFile: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-drive',
+                method: 'deleteFile',
+                params: args || {}
+            });
+        },
+        /**
+         * Search for files using Google Drive query syntax
+         * @param args.query - Search query using Drive syntax (e.g., "name contains 'report'", "mimeType='application/pdf'")
+         * @param args.pageSize - Maximum number of files to return (default: 20) (optional)
+         */
+        searchFiles: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-drive',
+                method: 'searchFiles',
+                params: args || {}
+            });
+        },
+        /**
+         * Update file metadata (name, description)
+         * @param args.fileId - ID of the file to update
+         * @param args.name - New name for the file (optional)
+         * @param args.description - New description for the file (optional)
+         */
+        updateFile: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-drive',
+                method: 'updateFile',
+                params: args || {}
+            });
+        }
+    };
+}
+/**
+ * Google Sheets Adapter
+ * Category: productivity
+ */
+function createGoogleSheetsAdapter(sdk) {
+    return {
+        /**
+         * Create a new Google Sheets spreadsheet
+         * @param args.title - Title of the spreadsheet
+         */
+        createSpreadsheet: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-sheets',
+                method: 'createSpreadsheet',
+                params: args || {}
+            });
+        },
+        /**
+         * Read data from a range in a spreadsheet
+         * @param args.spreadsheetId - ID of the spreadsheet
+         * @param args.range - Cell range (e.g., "Sheet1!A1:B10")
+         */
+        readRange: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-sheets',
+                method: 'readRange',
+                params: args || {}
+            });
+        },
+        /**
+         * Write data to a range in a spreadsheet
+         * @param args.spreadsheetId - ID of the spreadsheet
+         * @param args.range - Cell range (e.g., "Sheet1!A1:B10")
+         * @param args.values - Data to write (2D array)
+         */
+        writeRange: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-sheets',
+                method: 'writeRange',
+                params: args || {}
+            });
+        },
+        /**
+         * Append a row to a spreadsheet
+         * @param args.spreadsheetId - ID of the spreadsheet
+         * @param args.sheetName - Name of the sheet
+         * @param args.values - Row values to append
+         */
+        appendRow: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-sheets',
+                method: 'appendRow',
+                params: args || {}
+            });
+        },
+        /**
+         * Get spreadsheet metadata and properties
+         * @param args.spreadsheetId - ID of the spreadsheet
+         */
+        getSpreadsheet: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-sheets',
+                method: 'getSpreadsheet',
+                params: args || {}
+            });
+        },
+        /**
+         * Insert a value at a specific cell with optional formatting
+         * @param args.spreadsheetId - ID of the spreadsheet
+         * @param args.cell - Cell reference in format SheetName!A1
+         * @param args.value - Value to insert
+         * @param args.bold - Make text bold (optional)
+         * @param args.italic - Make text italic (optional)
+         * @param args.foregroundColor - Text color (hex or named color) (optional)
+         * @param args.backgroundColor - Cell background color (hex or named color) (optional)
+         */
+        insertAtCell: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-sheets',
+                method: 'insertAtCell',
+                params: args || {}
+            });
+        },
+        /**
+         * Insert a formula at a specific cell
+         * @param args.spreadsheetId - ID of the spreadsheet
+         * @param args.cell - Cell reference in format SheetName!A1
+         * @param args.formula - Formula to insert (with or without leading =)
+         * @param args.note - Optional note to add to the cell (optional)
+         */
+        insertFormula: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-sheets',
+                method: 'insertFormula',
+                params: args || {}
+            });
+        },
+        /**
+         * Apply formatting to a range of cells
+         * @param args.spreadsheetId - ID of the spreadsheet
+         * @param args.range - Range in format SheetName!A1:B10
+         * @param args.bold - Make text bold (optional)
+         * @param args.italic - Make text italic (optional)
+         * @param args.foregroundColor - Text color (hex or named color) (optional)
+         * @param args.backgroundColor - Cell background color (hex or named color) (optional)
+         * @param args.borders - Add borders to cells (optional)
+         */
+        formatRange: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-sheets',
+                method: 'formatRange',
+                params: args || {}
+            });
+        },
+        /**
+         * Create a chart from spreadsheet data
+         * @param args.spreadsheetId - ID of the spreadsheet
+         * @param args.sheetId - ID of the sheet containing data
+         * @param args.dataRange - Data range for the chart (e.g., A1:B10)
+         * @param args.chartType - Chart type: BAR, LINE, AREA, PIE, or SCATTER
+         * @param args.title - Chart title
+         * @param args.position - Chart position with row, column, rowCount, columnCount
+         */
+        createChart: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-sheets',
+                method: 'createChart',
+                params: args || {}
+            });
+        },
+        /**
+         * Find and replace text in a spreadsheet
+         * @param args.spreadsheetId - ID of the spreadsheet
+         * @param args.findText - Text to find
+         * @param args.replaceText - Text to replace with
+         * @param args.sheetName - Limit search to specific sheet (optional)
+         * @param args.matchCase - Case-sensitive search (optional)
+         * @param args.matchEntireCell - Match entire cell content only (optional)
+         */
+        findAndReplace: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-sheets',
+                method: 'findAndReplace',
+                params: args || {}
+            });
+        },
+        /**
+         * Insert multiple rows of data at once
+         * @param args.spreadsheetId - ID of the spreadsheet
+         * @param args.sheetName - Name of the sheet
+         * @param args.rowsData - 2D array of row data to insert
+         * @param args.startingRow - Row number to start insertion (1-indexed). If not provided, appends to end (optional)
+         * @param args.formattingOptions - Optional formatting to apply (bold, italic, foregroundColor, backgroundColor, borders) (optional)
+         */
+        insertMultipleRows: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-sheets',
+                method: 'insertMultipleRows',
+                params: args || {}
+            });
+        },
+        /**
+         * Clear content from a range of cells
+         * @param args.spreadsheetId - ID of the spreadsheet
+         * @param args.sheetName - Name of the sheet
+         * @param args.range - Range to clear (e.g., A1:B10)
+         */
+        clearRange: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-sheets',
+                method: 'clearRange',
+                params: args || {}
+            });
+        },
+        /**
+         * Insert empty rows at a specific position in a sheet. IMPORTANT: Requires numeric sheetId (get from getSpreadsheet), not sheet name. Row indices are 0-indexed (row 1 in UI = index 0).
+         * @param args.spreadsheetId - ID of the spreadsheet
+         * @param args.sheetId - Numeric sheet ID (get from getSpreadsheet response: sheets[0].properties.sheetId). This is NOT the sheet name.
+         * @param args.startRowIndex - Row index to start inserting at (0-indexed). To insert before row 5 in the UI, use index 4.
+         * @param args.numRows - Number of rows to insert
+         */
+        insertRows: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-sheets',
+                method: 'insertRows',
+                params: args || {}
+            });
+        },
+        /**
+         * Delete rows from a sheet. IMPORTANT: Requires numeric sheetId (get from getSpreadsheet), not sheet name. Row indices are 0-indexed (row 1 in UI = index 0).
+         * @param args.spreadsheetId - ID of the spreadsheet
+         * @param args.sheetId - Numeric sheet ID (get from getSpreadsheet response: sheets[0].properties.sheetId). This is NOT the sheet name.
+         * @param args.startRowIndex - Row index to start deleting from (0-indexed). To delete row 5 in the UI, use index 4.
+         * @param args.numRows - Number of rows to delete
+         */
+        deleteRows: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-sheets',
+                method: 'deleteRows',
+                params: args || {}
+            });
+        },
+        /**
+         * Insert empty columns at a specific position in a sheet. IMPORTANT: Requires numeric sheetId (get from getSpreadsheet), not sheet name. Column indices are 0-indexed (A=0, B=1, C=2, etc.).
+         * @param args.spreadsheetId - ID of the spreadsheet
+         * @param args.sheetId - Numeric sheet ID (get from getSpreadsheet response: sheets[0].properties.sheetId). This is NOT the sheet name.
+         * @param args.startColumnIndex - Column index to start inserting at (0-indexed: A=0, B=1, C=2, D=3, etc.). To insert before column D, use index 3.
+         * @param args.numColumns - Number of columns to insert
+         */
+        insertColumns: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-sheets',
+                method: 'insertColumns',
+                params: args || {}
+            });
+        },
+        /**
+         * Delete columns from a sheet. IMPORTANT: Requires numeric sheetId (get from getSpreadsheet), not sheet name. Column indices are 0-indexed (A=0, B=1, C=2, etc.).
+         * @param args.spreadsheetId - ID of the spreadsheet
+         * @param args.sheetId - Numeric sheet ID (get from getSpreadsheet response: sheets[0].properties.sheetId). This is NOT the sheet name.
+         * @param args.startColumnIndex - Column index to start deleting from (0-indexed: A=0, B=1, C=2, D=3, etc.). To delete column D, use index 3.
+         * @param args.numColumns - Number of columns to delete
+         */
+        deleteColumns: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-sheets',
+                method: 'deleteColumns',
+                params: args || {}
+            });
+        },
+        /**
+         * Copy data from one range to another location within the same spreadsheet. IMPORTANT: Requires numeric sheetIds (get from getSpreadsheet), not sheet names. Can copy within same sheet or across sheets.
+         * @param args.spreadsheetId - ID of the spreadsheet
+         * @param args.sourceSheetId - Numeric sheet ID of the source sheet (get from getSpreadsheet response: sheets[n].properties.sheetId)
+         * @param args.sourceRange - Source range in A1 notation WITHOUT sheet name (e.g., "A1:C5", not "Sheet1!A1:C5")
+         * @param args.targetSheetId - Numeric sheet ID of the target sheet (can be same as sourceSheetId to copy within same sheet)
+         * @param args.targetStartCell - Target start cell in A1 notation (e.g., "E1"). The copied data will fill cells starting from this position.
+         */
+        copyRange: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-sheets',
+                method: 'copyRange',
+                params: args || {}
+            });
+        }
+    };
+}
+/**
+ * Google Docs Adapter
+ * Category: productivity
+ */
+function createGoogleDocsAdapter(sdk) {
+    return {
+        /**
+         * Create a new Google Doc
+         * @param args.title - Title of the document
+         */
+        createDocument: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-docs',
+                method: 'createDocument',
+                params: args || {}
+            });
+        },
+        /**
+         * Get a Google Doc by ID
+         * @param args.documentId - ID of the document
+         */
+        getDocument: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-docs',
+                method: 'getDocument',
+                params: args || {}
+            });
+        },
+        /**
+         * Append text to the end of a document
+         * @param args.documentId - ID of the document
+         * @param args.text - Text to append
+         */
+        appendText: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-docs',
+                method: 'appendText',
+                params: args || {}
+            });
+        },
+        /**
+         * Replace text in a document
+         * @param args.documentId - ID of the document
+         * @param args.searchText - Text to search for
+         * @param args.replaceText - Text to replace with
+         */
+        replaceText: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-docs',
+                method: 'replaceText',
+                params: args || {}
+            });
+        },
+        /**
+         * Get the text content of a Google Doc
+         * @param args.documentId - ID of the document
+         */
+        getDocumentContent: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-docs',
+                method: 'getDocumentContent',
+                params: args || {}
+            });
+        },
+        /**
+         * Insert text at a specific position in the document
+         * @param args.documentId - ID of the document
+         * @param args.text - Text to insert
+         * @param args.position - Character position to insert at (1-indexed)
+         */
+        insertTextAtPosition: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-docs',
+                method: 'insertTextAtPosition',
+                params: args || {}
+            });
+        },
+        /**
+         * Insert text after a search string in the document
+         * @param args.documentId - ID of the document
+         * @param args.searchText - Text to search for
+         * @param args.textToInsert - Text to insert after the search text
+         * @param args.occurrence - Which occurrence to insert after (default: 1) (optional)
+         */
+        insertTextAfter: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-docs',
+                method: 'insertTextAfter',
+                params: args || {}
+            });
+        },
+        /**
+         * Insert a heading into the document
+         * @param args.documentId - ID of the document
+         * @param args.text - Heading text
+         * @param args.level - Heading level (1-6)
+         * @param args.position - Character position to insert at (optional)
+         * @param args.insertAfterText - Insert after this text instead of at position (optional)
+         */
+        insertHeading: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-docs',
+                method: 'insertHeading',
+                params: args || {}
+            });
+        },
+        /**
+         * Insert a bulleted or numbered list into the document
+         * @param args.documentId - ID of the document
+         * @param args.items - Array of list items
+         * @param args.listType - Type of list: "bulleted" or "numbered"
+         * @param args.position - Character position to insert at (optional)
+         * @param args.insertAfterText - Insert after this text instead of at position (optional)
+         */
+        insertList: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-docs',
+                method: 'insertList',
+                params: args || {}
+            });
+        },
+        /**
+         * Insert a table into the document
+         * @param args.documentId - ID of the document
+         * @param args.data - 2D array of table data (rows x columns)
+         * @param args.hasHeader - Whether the first row is a header (default: true) (optional)
+         * @param args.position - Character position to insert at (optional)
+         * @param args.insertAfterText - Insert after this text instead of at position (optional)
+         */
+        insertTable: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-docs',
+                method: 'insertTable',
+                params: args || {}
+            });
+        },
+        /**
+         * Replace the entire content of a document
+         * @param args.documentId - ID of the document
+         * @param args.newContent - New content to replace existing content
+         */
+        updateDocumentContent: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-docs',
+                method: 'updateDocumentContent',
+                params: args || {}
+            });
+        },
+        /**
+         * Create a new section with a heading and content
+         * @param args.documentId - ID of the document
+         * @param args.heading - Section heading text
+         * @param args.content - Section content text
+         */
+        createSection: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-docs',
+                method: 'createSection',
+                params: args || {}
+            });
+        },
+        /**
+         * Find the character position for insertion based on position or search text
+         * @param args.documentId - ID of the document
+         * @param args.position - Position to find (1 for start, -1 for end)
+         * @param args.searchText - Text to search for (returns position after this text) (optional)
+         */
+        findInsertionPoint: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-docs',
+                method: 'findInsertionPoint',
+                params: args || {}
+            });
+        }
+    };
+}
+/**
+ * Jira Adapter
+ * Category: project
+ */
+function createJiraAdapter(sdk) {
+    return {
+        /**
+         * Create a new Jira issue
+         * @param args.projectKey - Jira project key (e.g., "PROJ")
+         * @param args.summary - Issue summary/title
+         * @param args.description - Issue description (optional)
+         * @param args.issueType - Issue type (Task, Bug, Story, etc.) (optional)
+         */
+        createIssue: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jira',
+                method: 'createIssue',
+                params: args || {}
+            });
+        },
+        /**
+         * Search Jira issues using JQL
+         * @param args.jql - JQL query string
+         * @param args.maxResults - Maximum number of results (default: 50, max: 100) (optional)
+         */
+        searchIssues: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jira',
+                method: 'searchIssues',
+                params: args || {}
+            });
+        },
+        /**
+         * Get a specific Jira issue by key or ID
+         * @param args.issueKey - Issue key (e.g., "PROJ-123") or ID
+         */
+        getIssue: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jira',
+                method: 'getIssue',
+                params: args || {}
+            });
+        },
+        /**
+         * Update an existing Jira issue
+         * @param args.issueKey - Issue key (e.g., "PROJ-123")
+         * @param args.summary - New issue summary/title (optional)
+         * @param args.description - New issue description (optional)
+         */
+        updateIssue: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jira',
+                method: 'updateIssue',
+                params: args || {}
+            });
+        },
+        /**
+         * Delete a Jira issue
+         * @param args.issueKey - Issue key (e.g., "PROJ-123")
+         */
+        deleteIssue: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jira',
+                method: 'deleteIssue',
+                params: args || {}
+            });
+        },
+        /**
+         * Add a comment to a Jira issue
+         * @param args.issueKey - Issue key (e.g., "PROJ-123")
+         * @param args.comment - Comment text
+         */
+        addComment: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jira',
+                method: 'addComment',
+                params: args || {}
+            });
+        },
+        /**
+         * Transition a Jira issue to a different status
+         * @param args.issueKey - Issue key (e.g., "PROJ-123")
+         * @param args.transitionId - ID of the transition to perform
+         */
+        transitionIssue: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jira',
+                method: 'transitionIssue',
+                params: args || {}
+            });
+        },
+        /**
+         * Assign a Jira issue to a user
+         * @param args.issueKey - Issue key (e.g., "PROJ-123")
+         * @param args.accountId - Atlassian account ID of the assignee
+         */
+        assignIssue: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jira',
+                method: 'assignIssue',
+                params: args || {}
+            });
+        },
+        /**
+         * Get all accessible Jira projects
+         */
+        getProjects: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jira',
+                method: 'getProjects',
+                params: args || {}
+            });
+        },
+        /**
+         * List all accessible Jira projects (alias for getProjects)
+         */
+        listProjects: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jira',
+                method: 'listProjects',
+                params: args || {}
+            });
+        },
+        /**
+         * Get metadata for a specific Jira project
+         * @param args.projectKey - Project key (e.g., "PROJ")
+         */
+        getProjectMetadata: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jira',
+                method: 'getProjectMetadata',
+                params: args || {}
+            });
+        },
+        /**
+         * Get available transitions for a Jira issue
+         * @param args.issueKey - Issue key (e.g., "PROJ-123")
+         */
+        getTransitions: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jira',
+                method: 'getTransitions',
+                params: args || {}
+            });
+        },
+        /**
+         * List users that can be assigned to issues in a project
+         * @param args.projectKey - Project key (e.g., "PROJ")
+         */
+        listAssignableUsers: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jira',
+                method: 'listAssignableUsers',
+                params: args || {}
+            });
+        },
+        /**
+         * Get available issue types for a project
+         * @param args.projectKey - Project key (e.g., "PROJ")
+         */
+        getIssueTypes: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jira',
+                method: 'getIssueTypes',
+                params: args || {}
+            });
+        },
+        /**
+         * Search Jira API for available operations beyond core tools
+         * @param args.query - Describe what you want to do (e.g., "add label to card")
+         * @param args.limit - Max results to return (default 5) (optional)
+         */
+        discoverExtended: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jira',
+                method: 'discoverExtended',
+                params: args || {}
+            });
+        },
+        /**
+         * Execute a Jira API operation by operationId
+         * @param args.operationId - The operationId from discoverExtended results
+         * @param args.pathParams - Path parameters, e.g., { id: "abc123" } (optional)
+         * @param args.queryParams - Query string parameters (optional)
+         * @param args.body - Request body for POST/PUT/PATCH operations (optional)
+         */
+        executeExtended: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jira',
+                method: 'executeExtended',
+                params: args || {}
+            });
+        }
+    };
+}
+/**
+ * Twitter Adapter
+ * Category: social
+ */
+function createTwitterAdapter(sdk) {
+    return {
+        /**
+         * Post a tweet
+         * @param args.text - Tweet text (max 280 characters)
+         */
+        postTweet: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'twitter',
+                method: 'postTweet',
+                params: args || {}
+            });
+        },
+        /**
+         * Retrieve tweets from a Twitter user. Must provide either userId OR userName.
+         * @param args.userId - Twitter user ID (recommended for stability and speed) (optional)
+         * @param args.userName - Twitter username/screen name (alternative to userId) (optional)
+         * @param args.cursor - Pagination cursor for next page of results (optional)
+         * @param args.includeReplies - Whether to include replies in results (default: false) (optional)
+         */
+        getUserTweets: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'twitter',
+                method: 'getUserTweets',
+                params: args || {}
+            });
+        }
+    };
+}
+/**
+ * Trello Adapter
+ * Category: productivity
+ */
+function createTrelloAdapter(sdk) {
+    return {
+        /**
+         * Get all boards for the authenticated user
+         */
+        getBoards: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'trello',
+                method: 'getBoards',
+                params: args || {}
+            });
+        },
+        /**
+         * Get a specific board by ID including its lists
+         * @param args.boardId - The ID of the board to retrieve
+         */
+        getBoard: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'trello',
+                method: 'getBoard',
+                params: args || {}
+            });
+        },
+        /**
+         * Create a new card in a Trello list
+         * @param args.name - Card name/title
+         * @param args.idList - ID of the list to add the card to
+         * @param args.desc - Card description (supports markdown) (optional)
+         */
+        createCard: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'trello',
+                method: 'createCard',
+                params: args || {}
+            });
+        },
+        /**
+         * Get a specific card by ID
+         * @param args.cardId - The ID of the card to retrieve
+         */
+        getCard: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'trello',
+                method: 'getCard',
+                params: args || {}
+            });
+        },
+        /**
+         * Update an existing card
+         * @param args.cardId - The ID of the card to update
+         * @param args.name - New card name (optional)
+         * @param args.desc - New card description (optional)
+         * @param args.idList - Move card to a different list (optional)
+         * @param args.closed - Archive the card (optional)
+         */
+        updateCard: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'trello',
+                method: 'updateCard',
+                params: args || {}
+            });
+        },
+        /**
+         * Delete a card permanently
+         * @param args.cardId - The ID of the card to delete
+         */
+        deleteCard: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'trello',
+                method: 'deleteCard',
+                params: args || {}
+            });
+        },
+        /**
+         * Create a new checklist on a card
+         * @param args.cardId - The ID of the card to add the checklist to
+         * @param args.name - Checklist name
+         */
+        createChecklist: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'trello',
+                method: 'createChecklist',
+                params: args || {}
+            });
+        },
+        /**
+         * Get a specific checklist by ID
+         * @param args.checklistId - The ID of the checklist to retrieve
+         */
+        getChecklist: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'trello',
+                method: 'getChecklist',
+                params: args || {}
+            });
+        },
+        /**
+         * Update a checklist name
+         * @param args.checklistId - The ID of the checklist to update
+         * @param args.name - New checklist name
+         */
+        updateChecklist: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'trello',
+                method: 'updateChecklist',
+                params: args || {}
+            });
+        },
+        /**
+         * Delete a checklist from a card
+         * @param args.checklistId - The ID of the checklist to delete
+         */
+        deleteChecklist: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'trello',
+                method: 'deleteChecklist',
+                params: args || {}
+            });
+        },
+        /**
+         * Add a check item to a checklist
+         * @param args.checklistId - The ID of the checklist to add the item to
+         * @param args.name - Check item text
+         */
+        addCheckItem: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'trello',
+                method: 'addCheckItem',
+                params: args || {}
+            });
+        },
+        /**
+         * Update a check item (name or completion state)
+         * @param args.cardId - The ID of the card containing the check item
+         * @param args.checkItemId - The ID of the check item to update
+         * @param args.name - New check item text (optional)
+         * @param args.state - Check state: "complete" or "incomplete" (optional)
+         */
+        updateCheckItem: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'trello',
+                method: 'updateCheckItem',
+                params: args || {}
+            });
+        },
+        /**
+         * Delete a check item from a checklist
+         * @param args.checklistId - The ID of the checklist containing the item
+         * @param args.checkItemId - The ID of the check item to delete
+         */
+        deleteCheckItem: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'trello',
+                method: 'deleteCheckItem',
+                params: args || {}
+            });
+        },
+        /**
+         * Search Trello API for available operations beyond core tools
+         * @param args.query - Describe what you want to do (e.g., "add label to card")
+         * @param args.limit - Max results to return (default 5) (optional)
+         */
+        discoverExtended: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'trello',
+                method: 'discoverExtended',
+                params: args || {}
+            });
+        },
+        /**
+         * Execute a Trello API operation by operationId
+         * @param args.operationId - The operationId from discoverExtended results
+         * @param args.pathParams - Path parameters, e.g., { id: "abc123" } (optional)
+         * @param args.queryParams - Query string parameters (optional)
+         * @param args.body - Request body for POST/PUT/PATCH operations (optional)
+         */
+        executeExtended: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'trello',
+                method: 'executeExtended',
+                params: args || {}
+            });
+        }
+    };
+}
+/**
+ * Jupiter Adapter
+ * Category: crypto
+ */
+function createJupiterAdapter(sdk) {
+    return {
+        /**
+         * Execute a token swap on Jupiter DEX
+         * @param args.inputMint - Input token mint address
+         * @param args.outputMint - Output token mint address
+         * @param args.amount - Amount to swap (in smallest unit)
+         * @param args.inputDecimals - Number of decimals for input token
+         * @param args.slippageBps - Slippage tolerance in basis points (default: 50) (optional)
+         */
+        swap: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jupiter',
+                method: 'swap',
+                params: args || {}
+            });
+        },
+        /**
+         * Get token holdings for a wallet
+         * @param args.walletAddress - Wallet address to check (uses actor wallet if not provided) (optional)
+         */
+        getHoldings: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jupiter',
+                method: 'getHoldings',
+                params: args || {}
+            });
+        },
+        /**
+         * Get token security information using Jupiter Shield
+         * @param args.tokenMint - Token mint address to check security for
+         */
+        getTokenSecurity: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jupiter',
+                method: 'getTokenSecurity',
+                params: args || {}
+            });
+        },
+        /**
+         * Search for tokens by symbol, name, or mint address
+         * @param args.query - Search query (symbol, name, or mint address)
+         */
+        searchTokens: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jupiter',
+                method: 'searchTokens',
+                params: args || {}
+            });
+        },
+        /**
+         * Refresh an expired swap with new quote and transaction
+         * @param args.feedItemId - Feed item ID containing the swap to refresh
+         * @param args.swapId - Original swap ID
+         * @param args.inputMint - Input token mint address
+         * @param args.outputMint - Output token mint address
+         * @param args.amount - Amount to swap (in UI units)
+         * @param args.inputDecimals - Input token decimals
+         * @param args.slippageBps - Slippage tolerance in basis points (optional)
+         */
+        refreshSwap: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'jupiter',
+                method: 'refreshSwap',
+                params: args || {}
+            });
+        }
+    };
+}
+/**
+ * Crypto Adapter
+ * Category: crypto
+ */
+function createCryptoAdapter(sdk) {
+    return {
+        /**
+         * Get the current price of a crypto asset
+         * @param args.tokenAddress - Token contract address (EVM: 0x..., SVM: base58)
+         * @param args.chainName - Specific chain name (auto-detected if not provided) (optional)
+         */
+        getPrice: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'crypto',
+                method: 'getPrice',
+                params: args || {}
+            });
+        },
+        /**
+         * Send cryptocurrency or tokens (creates pending transaction for signing)
+         * @param args.recipient - Contact username, user ID, or Solana wallet address
+         * @param args.token - Token symbol (SOL, USDC), name, or mint address
+         * @param args.amount - Amount to send (in UI units)
+         */
+        sendToken: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'crypto',
+                method: 'sendToken',
+                params: args || {}
+            });
+        },
+        /**
+         * Set up automated price monitoring with progressive alerts
+         * @param args.tokenAddress - Token contract address to monitor
+         * @param args.direction - Alert direction: "above" or "below"
+         * @param args.targetPrice - Target price in USD to trigger alert
+         * @param args.scriptId - ID of the script to execute when price target is reached
+         * @param args.chainName - Chain name (auto-detected if not provided) (optional)
+         * @param args.percentStep - Progressive alert step percentage (default: 0.1 = 10%) (optional)
+         */
+        monitorPrice: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'crypto',
+                method: 'monitorPrice',
+                params: args || {}
+            });
+        },
+        /**
+         * List all active crypto price monitoring assignments
+         */
+        listSubscriptions: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'crypto',
+                method: 'listSubscriptions',
+                params: args || {}
+            });
+        },
+        /**
+         * Stop monitoring a crypto asset
+         * @param args.tokenAddress - Token address to stop monitoring
+         */
+        unsubscribeAsset: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'crypto',
+                method: 'unsubscribeAsset',
+                params: args || {}
+            });
+        },
+        /**
+         * Refresh an expired transaction with new blockhash and updated details
+         * @param args.feedItemId - Feed item ID containing the transaction to refresh
+         * @param args.transferId - Original transfer ID
+         * @param args.recipient - Recipient address
+         * @param args.token - Token symbol or mint address
+         * @param args.amount - Amount to send
+         * @param args.tokenMint - Token mint address (optional, will resolve if not provided) (optional)
+         * @param args.tokenDecimals - Token decimals (optional) (optional)
+         */
+        refreshTransaction: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'crypto',
+                method: 'refreshTransaction',
+                params: args || {}
+            });
+        }
+    };
+}
+/**
+ * Scripts Adapter
+ * Category: productivity
+ */
+function createScriptsAdapter(sdk) {
+    return {
+        /**
+         * Create a new script with initial version and API key. IMPORTANT: The script ID for subsequent operations (deployScript, executeScript, etc.) is returned at data._id in the response.
+         * @param args.name - Name of the script
+         * @param args.description - Description of what the script does (optional)
+         * @param args.runtime - Lambda runtime (default: nodejs18) (optional)
+         * @param args.config - Script configuration (timeout, memory, maxCostPerExecution, etc.) (optional)
+         * @param args.code - Initial JavaScript/TypeScript code for the script
+         */
+        createScript: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'scripts',
+                method: 'createScript',
+                params: args || {}
+            });
+        },
+        /**
+         * Delete a script and all its versions
+         * @param args.scriptId - ID of the script to delete
+         */
+        deleteScript: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'scripts',
+                method: 'deleteScript',
+                params: args || {}
+            });
+        },
+        /**
+         * Create a new version of an existing script.
+         * @param args.scriptId - ID of the script
+         * @param args.code - Updated code for the new version
+         * @param args.commitMessage - Description of changes in this version (optional)
+         */
+        createVersion: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'scripts',
+                method: 'createVersion',
+                params: args || {}
+            });
+        },
+        /**
+         * List all versions of a script
+         * @param args.scriptId - ID of the script
+         */
+        listVersions: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'scripts',
+                method: 'listVersions',
+                params: args || {}
+            });
+        },
+        /**
+         * Deploy a script version to AWS Lambda. Must be called after createScript to make the script executable.
+         * @param args.scriptId - ID of the script to deploy (from createScript response at data._id)
+         * @param args.version - Version number to deploy (default: latest) (optional)
+         */
+        deployScript: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'scripts',
+                method: 'deployScript',
+                params: args || {}
+            });
+        },
+        /**
+         * Execute a deployed script with custom data. Script must be deployed first via deployScript.
+         * @param args.scriptId - ID of the script to execute (from createScript response at data._id)
+         * @param args.data - Input data to pass to the script (optional)
+         * @param args.trigger - Trigger information (type, source, event) (optional)
+         */
+        executeScript: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'scripts',
+                method: 'executeScript',
+                params: args || {}
+            });
+        },
+        /**
+         * Get details of a specific script
+         * @param args.scriptId - ID of the script
+         */
+        getScript: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'scripts',
+                method: 'getScript',
+                params: args || {}
+            });
+        },
+        /**
+         * List all scripts owned by the user
+         */
+        listScripts: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'scripts',
+                method: 'listScripts',
+                params: args || {}
+            });
+        },
+        /**
+         * Get execution history for a script
+         * @param args.scriptId - ID of the script
+         * @param args.status - Filter by status (completed, failed, running) (optional)
+         * @param args.limit - Maximum number of executions to return (default: 100) (optional)
+         */
+        getExecutions: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'scripts',
+                method: 'getExecutions',
+                params: args || {}
+            });
+        },
+        /**
+         * Get details of a specific execution
+         * @param args.executionId - ID of the execution
+         */
+        getExecution: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'scripts',
+                method: 'getExecution',
+                params: args || {}
+            });
+        },
+        /**
+         * Publish a script to the marketplace
+         * @param args.scriptId - ID of the script to publish
+         * @param args.pricing - Pricing configuration for the marketplace (optional)
+         */
+        publishScript: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'scripts',
+                method: 'publishScript',
+                params: args || {}
+            });
+        },
+        /**
+         * Remove a script from the marketplace
+         * @param args.scriptId - ID of the script to unpublish
+         */
+        unpublishScript: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'scripts',
+                method: 'unpublishScript',
+                params: args || {}
+            });
+        },
+        /**
+         * List all published scripts in the marketplace
+         */
+        listMarketplaceScripts: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'scripts',
+                method: 'listMarketplaceScripts',
+                params: args || {}
+            });
+        },
+        /**
+         * Get execution metrics for a script
+         * @param args.scriptId - ID of the script
+         */
+        getMetrics: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'scripts',
+                method: 'getMetrics',
+                params: args || {}
+            });
+        },
+        /**
+         * Create a webhook endpoint for the script
+         * @param args.scriptId - ID of the script
+         * @param args.name - Name of the webhook
+         * @param args.enabled - Whether webhook is enabled (default: true) (optional)
+         */
+        createWebhook: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'scripts',
+                method: 'createWebhook',
+                params: args || {}
+            });
+        },
+        /**
+         * Create a cron schedule for the script
+         * @param args.scriptId - ID of the script
+         * @param args.name - Name of the schedule
+         * @param args.cronExpression - Cron expression (e.g., "0 9 * * *" for daily at 9am)
+         * @param args.enabled - Whether schedule is enabled (default: true) (optional)
+         * @param args.data - Data to pass to the script on scheduled execution (optional)
+         */
+        createSchedule: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'scripts',
+                method: 'createSchedule',
+                params: args || {}
+            });
+        },
+        /**
+         * Get the script code for a specific flow
+         * @param args.flowId - ID of the flow to get script code for
+         */
+        getFlowScript: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'scripts',
+                method: 'getFlowScript',
+                params: args || {}
+            });
+        },
+        /**
+         * Modify the script code for a flow. Automatically creates a copy if user doesn't own the original, deploys to Lambda, and updates the flow.
+         * @param args.flowId - ID of the flow to modify
+         * @param args.newCode - New code to deploy
+         * @param args.commitMessage - Description of changes (optional)
+         */
+        modifyFlowScript: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'scripts',
+                method: 'modifyFlowScript',
+                params: args || {}
+            });
+        },
+        /**
+         * Validate script code BEFORE creating or deploying. Checks for: 1) Missing async handler wrapper (top-level await errors), 2) Invalid adapter operations. Returns validation errors with suggestions for fixes. ALWAYS use this before createScript/modifyFlowScript.
+         * @param args.code - The script code to validate
+         */
+        lintScript: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'scripts',
+                method: 'lintScript',
+                params: args || {}
+            });
+        }
+    };
+}
+/**
+ * Feedback Adapter
+ * Category: internal
+ */
+function createFeedbackAdapter(sdk) {
+    return {
+        /**
+         * Report a bug with detailed context and reproduction steps
+         * @param args.title - Brief bug description
+         * @param args.description - Detailed description of the bug
+         * @param args.severity - Bug severity: critical, high, medium, or low
+         * @param args.stepsToReproduce - Steps to reproduce the bug (optional)
+         * @param args.expectedBehavior - What should happen (optional)
+         * @param args.actualBehavior - What actually happens (optional)
+         * @param args.errorDetails - Error details: { message, stack, code } (optional)
+         * @param args.context - Additional context: { conversationId, recentMessages, platform, appVersion } (optional)
+         * @param args.llmAnalysis - LLM analysis of the issue (optional)
+         */
+        reportBug: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'feedback',
+                method: 'reportBug',
+                params: args || {}
+            });
+        },
+        /**
+         * Auto-report tool or adapter failures for debugging
+         * @param args.adapterType - Adapter type (e.g., jupiter, crypto)
+         * @param args.operation - Operation that failed (e.g., swap, sendToken)
+         * @param args.errorMessage - Error message from the failure
+         * @param args.errorCode - Error code if available (optional)
+         * @param args.errorStack - Error stack trace (optional)
+         * @param args.args - Sanitized arguments that caused the failure (optional)
+         * @param args.llmAnalysis - LLM analysis of why it failed (optional)
+         * @param args.suggestedFix - LLM suggested fix (optional)
+         * @param args.context - Additional context: { conversationId, userId, timestamp } (optional)
+         */
+        reportToolFailure: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'feedback',
+                method: 'reportToolFailure',
+                params: args || {}
+            });
+        },
+        /**
+         * Report when LLM cannot fulfill a user request
+         * @param args.userRequest - What the user asked for
+         * @param args.reason - Why it could not be fulfilled
+         * @param args.suggestedCapability - What capability would enable this (optional)
+         * @param args.relatedAdapters - Adapters that might be relevant (optional)
+         * @param args.context - Additional context: { conversationId } (optional)
+         */
+        reportMissingCapability: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'feedback',
+                method: 'reportMissingCapability',
+                params: args || {}
+            });
+        },
+        /**
+         * Submit general user feedback
+         * @param args.sentiment - Sentiment: positive, negative, or neutral
+         * @param args.feedback - Feedback content
+         * @param args.category - Category: ux, performance, feature, or general (optional)
+         * @param args.context - Additional context: { feature, screen } (optional)
+         */
+        submitFeedback: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'feedback',
+                method: 'submitFeedback',
+                params: args || {}
+            });
+        },
+        /**
+         * Submit a feature request
+         * @param args.title - Feature title
+         * @param args.description - Feature description
+         * @param args.useCase - Why the user needs this feature (optional)
+         * @param args.priority - Priority: high, medium, or low (optional)
+         */
+        submitFeatureRequest: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'feedback',
+                method: 'submitFeatureRequest',
+                params: args || {}
+            });
+        }
+    };
+}
+/**
+ * Mirra Messaging Adapter
+ * Category: communication
+ */
+function createMirraMessagingAdapter(sdk) {
+    return {
+        /**
+         * Send a direct message to a contact. The message is sent as the authenticated user with optional automation metadata.
+         * @param args.recipientId - User ID of the recipient (use findContact to look up by username)
+         * @param args.content - Message text content
+         * @param args.automation - Automation metadata: { source: "sdk" | "flow", flowId?: string, flowTitle?: string } (optional)
+         */
+        sendMessage: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'mirra-messaging',
+                method: 'sendMessage',
+                params: args || {}
+            });
+        },
+        /**
+         * Send a message to a group chat. The message is sent as the authenticated user with optional automation metadata.
+         * @param args.groupId - Group ID to send the message to
+         * @param args.content - Message text content
+         * @param args.automation - Automation metadata: { source: "sdk" | "flow", flowId?: string, flowTitle?: string } (optional)
+         */
+        sendGroupMessage: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'mirra-messaging',
+                method: 'sendGroupMessage',
+                params: args || {}
+            });
+        },
+        /**
+         * Get list of accepted contacts for the user
+         * @param args.limit - Maximum number of contacts to return (default 50) (optional)
+         * @param args.offset - Offset for pagination (default 0) (optional)
+         */
+        getContacts: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'mirra-messaging',
+                method: 'getContacts',
+                params: args || {}
+            });
+        },
+        /**
+         * Find a contact by username or partial name match
+         * @param args.query - Username or name to search for
+         */
+        findContact: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'mirra-messaging',
+                method: 'findContact',
+                params: args || {}
+            });
+        },
+        /**
+         * Get list of chat instances for the user
+         * @param args.scope - Filter by scope: direct, user, group, or all (default all) (optional)
+         * @param args.limit - Maximum number of chats to return (default 50) (optional)
+         */
+        getChats: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'mirra-messaging',
+                method: 'getChats',
+                params: args || {}
+            });
+        },
+        /**
+         * Get list of groups the user is a member of
+         * @param args.limit - Maximum number of groups to return (default 50) (optional)
+         */
+        getGroups: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'mirra-messaging',
+                method: 'getGroups',
+                params: args || {}
+            });
+        }
+    };
+}
+// ============================================================================
+// Exports
+// ============================================================================
+exports.generatedAdapters = {
+    flows: createFlowsAdapter,
+    user: createUserAdapter,
+    contacts: createContactsAdapter,
+    memory: createMemoryAdapter,
+    ai: createAiAdapter,
+    document: createDocumentAdapter,
+    feedItems: createFeedItemsAdapter,
+    telegram: createTelegramAdapter,
+    googleGmail: createGoogleGmailAdapter,
+    googleCalendar: createGoogleCalendarAdapter,
+    googleDrive: createGoogleDriveAdapter,
+    googleSheets: createGoogleSheetsAdapter,
+    googleDocs: createGoogleDocsAdapter,
+    jira: createJiraAdapter,
+    twitter: createTwitterAdapter,
+    trello: createTrelloAdapter,
+    jupiter: createJupiterAdapter,
+    crypto: createCryptoAdapter,
+    scripts: createScriptsAdapter,
+    feedback: createFeedbackAdapter,
+    mirraMessaging: createMirraMessagingAdapter
+};
+//# sourceMappingURL=adapters.js.map