@mirra-messenger/sdk 0.4.0 → 0.5.0

package/dist/generated/adapters.js

@@ -221,6 +221,17 @@ function createFlowsAdapter(sdk) {
                 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 || {}
+            });
         }
     };
 }
@@ -435,9 +446,13 @@ function createMemoryAdapter(sdk) {
             });
         },
         /**
-         * 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)
+         * 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({
@@ -447,11 +462,11 @@ function createMemoryAdapter(sdk) {
             });
         },
         /**
-         * 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 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({
@@ -786,9 +801,7 @@ function createTelegramAdapter(sdk) {
             });
         },
         /**
-         * 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)
+         * 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) => {
@@ -977,28 +990,6 @@ function createGoogleGmailAdapter(sdk) {
                 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
@@ -1061,6 +1052,58 @@ function createGoogleCalendarAdapter(sdk) {
                 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 || {}
+            });
         }
     };
 }
@@ -1130,6 +1173,66 @@ function createGoogleDriveAdapter(sdk) {
                 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 || {}
+            });
         }
     };
 }
@@ -1187,6 +1290,196 @@ function createGoogleSheetsAdapter(sdk) {
                 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 || {}
+            });
         }
     };
 }
@@ -1242,6 +1535,127 @@ function createGoogleDocsAdapter(sdk) {
                 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 || {}
+            });
         }
     };
 }
@@ -1411,6 +1825,32 @@ function createJiraAdapter(sdk) {
                 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 || {}
+            });
         }
     };
 }
@@ -1432,7 +1872,7 @@ function createTwitterAdapter(sdk) {
             });
         },
         /**
-         * Retrieve tweets from a Twitter user
+         * 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)
@@ -1607,6 +2047,32 @@ function createTrelloAdapter(sdk) {
                 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 || {}
+            });
         }
     };
 }
@@ -1663,6 +2129,23 @@ function createJupiterAdapter(sdk) {
                 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 || {}
+            });
         }
     };
 }
@@ -1733,6 +2216,23 @@ function createCryptoAdapter(sdk) {
                 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 || {}
+            });
         }
     };
 }
@@ -1971,6 +2471,175 @@ function createScriptsAdapter(sdk) {
         }
     };
 }
+/**
+ * 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
 // ============================================================================
@@ -1993,6 +2662,8 @@ exports.generatedAdapters = {
     trello: createTrelloAdapter,
     jupiter: createJupiterAdapter,
     crypto: createCryptoAdapter,
-    scripts: createScriptsAdapter
+    scripts: createScriptsAdapter,
+    feedback: createFeedbackAdapter,
+    mirraMessaging: createMirraMessagingAdapter
 };
 //# sourceMappingURL=adapters.js.map