@mirra-messenger/sdk 0.2.0 → 0.4.0

package/dist/generated/adapters.js

@@ -0,0 +1,1998 @@
+"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 || {}
+            });
+        }
+    };
+}
+/**
+ * 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
+         * @param args.query - Search query text
+         * @param args.limit - Maximum number of results to return (default: 50, max: 100) (optional)
+         */
+        search: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'memory',
+                method: 'search',
+                params: args || {}
+            });
+        },
+        /**
+         * Query entities with filters and pagination
+         * @param args.type - Entity type filter (optional)
+         * @param args.filters - Additional filters (optional)
+         * @param args.limit - Maximum results (default: 50, max: 100) (optional)
+         * @param args.offset - Pagination offset (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 contacts from Telegram, optionally filtering for new contacts since a specific date.
+         * @param args.sinceDate - ISO date string - only return contacts with activity since this date (optional)
+         * @param args.onlyNewContacts - If true, only return contacts that are new (first message after sinceDate) (optional)
+         * @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 || {}
+            });
+        },
+        /**
+         * Mark an email as read
+         * @param args.messageId - Gmail message ID to mark as read
+         */
+        markAsRead: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-gmail',
+                method: 'markAsRead',
+                params: args || {}
+            });
+        },
+        /**
+         * Mark an email as unread
+         * @param args.messageId - Gmail message ID to mark as unread
+         */
+        markAsUnread: async (args) => {
+            return sdk.resources.call({
+                resourceId: 'google-gmail',
+                method: 'markAsUnread',
+                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 || {}
+            });
+        }
+    };
+}
+/**
+ * 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 || {}
+            });
+        }
+    };
+}
+/**
+ * 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 || {}
+            });
+        }
+    };
+}
+/**
+ * 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 || {}
+            });
+        }
+    };
+}
+/**
+ * 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 || {}
+            });
+        }
+    };
+}
+/**
+ * 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
+         * @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 || {}
+            });
+        }
+    };
+}
+/**
+ * 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 || {}
+            });
+        }
+    };
+}
+/**
+ * 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 || {}
+            });
+        }
+    };
+}
+/**
+ * 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 || {}
+            });
+        }
+    };
+}
+// ============================================================================
+// 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
+};
+//# sourceMappingURL=adapters.js.map