@mindstudio-ai/agent 0.0.7 → 0.0.9

package/llms.txt

@@ -0,0 +1,225 @@
+# @mindstudio-ai/agent
+
+TypeScript SDK for executing MindStudio workflow steps. Each method calls a specific AI/automation action and returns typed results.
+
+## Setup
+
+```typescript
+import { MindStudioAgent } from '@mindstudio-ai/agent';
+
+// With API key
+const agent = new MindStudioAgent({ apiKey: 'your-key' });
+
+// Or via environment variables (MINDSTUDIO_API_KEY or CALLBACK_TOKEN)
+const agent = new MindStudioAgent();
+```
+
+## Usage pattern
+
+Every method returns the output fields directly, plus `$appId`, `$threadId`, and `$rateLimitRemaining` metadata:
+
+```typescript
+const { content } = await agent.generateText({ message: 'Hello' });
+
+// Thread persistence — pass $appId/$threadId to maintain state across calls:
+const r1 = await agent.generateText({ message: 'My name is Alice' });
+const r2 = await agent.generateText(
+  { message: 'What is my name?' },
+  { threadId: r1.$threadId, appId: r1.$appId },
+);
+```
+
+## Error handling
+
+```typescript
+import { MindStudioError } from '@mindstudio-ai/agent';
+// Throws MindStudioError with .code, .status, .details
+// 429 errors are retried automatically (3 retries by default)
+```
+
+## Available methods
+
+Each entry: `method(requiredParams) -> outputKeys` — description
+
+### General
+
+- `addSubtitlesToVideo(videoUrl, language, fontName, fontSize, fontWeight, fontColor, highlightColor, strokeWidth, strokeColor, backgroundColor, backgroundOpacity, position, yOffset, wordsPerSubtitle, enableAnimation)` -> { videoUrl } — Add Subtitles To Video
+- `analyzeImage(prompt, imageUrl)` -> { analysis } — Analyze Image
+- `analyzeVideo(prompt, videoUrl)` -> { analysis } — Analyze Video
+- `captureThumbnail(videoUrl, at)` -> { thumbnailUrl } — Get Image from Video Frame
+- `convertPdfToImages(pdfUrl)` -> { imageUrls } — Convert PDF to Images
+- `createDataSource(name)` — Create Data Source
+- `deleteDataSource(dataSourceId)` — Delete Data Source
+- `deleteDataSourceDocument(dataSourceId, documentId)` — Delete Data Source Document
+- `detectPII(input, language, entities)` -> { detected, detections } — Detect PII
+- `downloadVideo(videoUrl, format)` -> { videoUrl } — Download Video
+- `enhanceImageGenerationPrompt(initialPrompt, includeNegativePrompt, systemPrompt)` -> { prompt } — Enhance Image Prompt
+- `enhanceVideoGenerationPrompt(initialPrompt, includeNegativePrompt, systemPrompt)` -> { prompt } — Enhance Video Prompt
+- `extractAudioFromVideo(videoUrl)` -> { audioUrl } — Extract Audio from Video
+- `extractText(url)` -> { text } — Extract Text from URL
+- `fetchDataSourceDocument(dataSourceId, documentId)` — Fetch Data Source Document
+- `fetchSlackChannelHistory(connectionId, channelId)` -> { messages } — Fetch Slack Channel History
+- `generateAsset(source, sourceType, outputFormat, pageSize, testData)` -> { url } — Generate HTML Asset
+- `generateChart(chart)` -> { chartUrl } — Generate Chart
+- `generateImage(prompt)` -> { imageUrl } — Generate Image
+- `generateLipsync()` — Generate Lipsync
+- `generateMusic(text)` — Generate Music
+- `generateStaticVideoFromImage(imageUrl, duration)` -> { videoUrl } — Generate Static Video from Image
+- `generateText(message)` -> { content } — User Message
+- `generateVideo(prompt)` -> { videoUrl } — Generate Video
+- `getMediaMetadata(mediaUrl)` -> { metadata } — Get Media Metadata
+- `httpRequest(url, method, headers, queryParams, body, bodyItems, contentType, customContentType)` -> { ok, status, statusText, response } — HTTP Request
+- `imageFaceSwap(imageUrl, faceImageUrl, engine)` -> { imageUrl } — Image Face Swap
+- `imageRemoveWatermark(imageUrl, engine)` -> { imageUrl } — Remove Image Watermark
+- `insertVideoClips(baseVideoUrl, overlayVideos)` -> { videoUrl } — Insert Video Clips
+- `listDataSources()` — List Data Sources
+- `logic(context, cases)` -> { selectedCase } — Evaluate Logic
+- `makeDotComRunScenario(webhookUrl, input)` -> { data } — Make.com Run Scenario
+- `mergeAudio(mp3Urls)` -> { audioUrl } — Merge Audio
+- `mergeVideos(videoUrls)` -> { videoUrl } — Merge Videos
+- `mixAudioIntoVideo(videoUrl, audioUrl, options)` -> { videoUrl } — Mix Audio into Video
+- `muteVideo(videoUrl)` -> { videoUrl } — Mute Video
+- `n8nRunNode(method, authentication, user, password, webhookUrl, input)` -> { data } — N8N Run Node
+- `postToSlackChannel(channelId, messageType, message, connectionId)` — Post to Slack Channel
+- `postToZapier(webhookUrl, input)` -> { data } — Post to Zapier
+- `queryDataSource(dataSourceId, query, maxResults)` -> { text, chunks, query, citations, latencyMs } — Query Data Source
+- `queryExternalDatabase(connectionId, query, outputFormat)` -> { data } — Query External SQL Database
+- `redactPII(input, language, entities)` -> { text } — Redact PII
+- `removeBackgroundFromImage(imageUrl)` -> { imageUrl } — Remove Background From Image
+- `resizeVideo(videoUrl, mode)` -> { videoUrl } — Resize Video
+- `runPackagedWorkflow(appId, workflowId, inputVariables, outputVariables, name)` -> { data } — Run Packaged Workflow
+- `scrapeLinkedInCompany(url)` -> { company } — Scrape LinkedIn Company
+- `scrapeLinkedInProfile(url)` -> { profile } — Scrape LinkedIn Profile
+- `scrapeUrl(url)` -> { content } — Scrape URL
+- `scrapeXPost(url)` -> { post } — Scrape X Post
+- `scrapeXProfile(url)` -> { profile } — Scrape X Profile
+- `searchGoogle(query, exportType)` -> { results } — Search Google
+- `searchGoogleImages(query, exportType)` -> { images } — Search Google Images
+- `searchGoogleNews(text, exportType)` -> { articles } — Search Google News
+- `searchGoogleTrends(text, hl, geo, data_type, cat, date, ts)` -> { trends } — Search Google Trends
+- `searchPerplexity(query, exportType)` -> { results } — Search Perplexity
+- `sendEmail(subject, body, connectionId)` -> { recipients } — Send Email
+- `sendSMS(body, connectionId)` — Send SMS
+- `setRunTitle(title)` — Set Run Title
+- `setVariable(value, type)` -> { variableName, value } — Set Variable
+- `telegramSendAudio(botToken, chatId, audioUrl, mode)` — Send Telegram Audio
+- `telegramSendFile(botToken, chatId, fileUrl)` — Send Telegram File
+- `telegramSendImage(botToken, chatId, imageUrl)` — Send Telegram Image
+- `telegramSendMessage(botToken, chatId, text)` — Send Telegram Message
+- `telegramSendVideo(botToken, chatId, videoUrl)` — Send Telegram Video
+- `telegramSetTyping(botToken, chatId)` — Telegram Set Typing
+- `textToSpeech(text)` -> { audioUrl } — Text to Speech
+- `transcribeAudio(audioUrl, prompt)` -> { text } — Transcribe Audio
+- `trimMedia(inputUrl)` -> { mediaUrl } — Trim Media
+- `uploadDataSourceDocument(dataSourceId, file, fileName)` — Upload Data Source Document
+- `upscaleImage(imageUrl, targetResolution, engine)` -> { imageUrl } — Upscale Image
+- `upscaleVideo(videoUrl, targetResolution, engine)` -> { videoUrl } — Upscale Video
+- `videoFaceSwap(videoUrl, faceImageUrl, targetIndex, engine)` -> { videoUrl } — Video Face Swap
+- `videoRemoveBackground(videoUrl, newBackground, engine)` -> { videoUrl } — Remove Video Background
+- `videoRemoveWatermark(videoUrl, engine)` -> { videoUrl } — Remove Video Watermark
+- `watermarkImage(imageUrl, watermarkImageUrl, corner, paddingPx, widthPx)` -> { imageUrl } — Watermark Image
+- `watermarkVideo(videoUrl, imageUrl, corner, paddingPx, widthPx)` -> { videoUrl } — Watermark Video
+
+### ActiveCampaign
+
+- `activeCampaignAddNote(contactId, note, connectionId)` — Add Note
+- `activeCampaignCreateContact(email, firstName, lastName, phone, accountId, customFields, connectionId)` -> { contactId } — Create Contact
+
+### Airtable
+
+- `airtableCreateUpdateRecord(connectionId, baseId, tableId, fields, recordData)` -> { recordId } — Create/Update record
+- `airtableDeleteRecord(connectionId, baseId, tableId, recordId)` -> { deleted } — Delete record
+- `airtableGetRecord(connectionId, baseId, tableId, recordId)` -> { record } — Get record
+- `airtableGetTableRecords(connectionId, baseId, tableId)` -> { records } — Get table records
+
+### Apollo
+
+- `enrichPerson(params)` -> { data } — Enrich Person
+- `peopleSearch(smartQuery, enrichPeople, enrichOrganizations, limit, page, params)` -> { results } — People Search
+
+### Coda
+
+- `codaCreateUpdatePage(connectionId, pageData)` -> { pageId } — Create/Update page
+- `codaCreateUpdateRow(connectionId, docId, tableId, rowData)` -> { rowId } — Create/Update row
+- `codaFindRow(connectionId, docId, tableId, rowData)` -> { row } — Find row
+- `codaGetPage(connectionId, docId, pageId)` -> { content } — Get page
+- `codaGetTableRows(connectionId, docId, tableId)` -> { rows } — Get table rows
+
+### Facebook
+
+- `scrapeFacebookPage(pageUrl)` -> { data } — Scrape Page
+- `scrapeFacebookPosts(pageUrl)` -> { data } — Scrape Posts for Page
+
+### Google
+
+- `createGoogleDoc(title, text, connectionId, textType)` -> { documentUrl } — Create Google Doc
+- `createGoogleSheet(title, text, connectionId)` -> { spreadsheetUrl } — Create Google Sheet
+- `fetchGoogleDoc(documentId, connectionId, exportType)` -> { content } — Fetch Google Doc
+- `fetchGoogleSheet(spreadsheetId, range, connectionId, exportType)` -> { content } — Fetch Google Sheet
+- `updateGoogleDoc(documentId, connectionId, text, textType, operationType)` -> { documentUrl } — Update Google Doc
+- `updateGoogleSheet(text, connectionId, spreadsheetId, range, operationType)` -> { spreadsheetUrl } — Update Google Sheet
+
+### Google Calendar
+
+- `createGoogleCalendarEvent(connectionId, summary, startDateTime, endDateTime)` -> { eventId, htmlLink } — Create Event
+- `deleteGoogleCalendarEvent(connectionId, eventId)` — Get Event
+- `getGoogleCalendarEvent(connectionId, eventId, exportType)` -> { event } — Get Event
+- `listGoogleCalendarEvents(connectionId, limit, exportType)` -> { events } — List Events
+- `updateGoogleCalendarEvent(connectionId, eventId)` -> { eventId, htmlLink } — Update Event
+
+### HubSpot
+
+- `hubspotCreateCompany(connectionId, company, enabledProperties)` -> { companyId } — Create/Update Company
+- `hubspotCreateContact(connectionId, contact, enabledProperties, companyDomain)` -> { contactId } — Create/Update Contact
+- `hubspotGetCompany(connectionId, searchBy, companyDomain, companyId, additionalProperties)` -> { company } — Get Company
+- `hubspotGetContact(connectionId, searchBy, contactEmail, contactId, additionalProperties)` -> { contact } — Get Contact
+
+### Hunter.io
+
+- `hunterApiCompanyEnrichment(domain)` -> { data } — Enrich Company
+- `hunterApiDomainSearch(domain)` -> { data } — Domain Search
+- `hunterApiEmailFinder(domain, firstName, lastName)` -> { data } — Find Email
+- `hunterApiEmailVerification(email)` -> { data } — Verify Email
+- `hunterApiPersonEnrichment(email)` -> { data } — Enrich Person
+
+### Instagram
+
+- `scrapeInstagramComments(postUrl, resultsLimit)` -> { data } — Scrape Comments
+- `scrapeInstagramMentions(profileUrl, resultsLimit)` -> { data } — Scrape Mentions
+- `scrapeInstagramPosts(profileUrl, resultsLimit, onlyPostsNewerThan)` -> { data } — Scrape Posts
+- `scrapeInstagramProfile(profileUrl)` -> { data } — Scrape Profile
+- `scrapeInstagramReels(profileUrl, resultsLimit)` -> { data } — Scrape Reels
+
+### LinkedIn
+
+- `postToLinkedIn(message, visibility, connectionId)` — Create post
+
+### Meta Threads
+
+- `scrapeMetaThreadsProfile(profileUrl)` -> { data } — Scrape Profile
+
+### Notion
+
+- `notionCreatePage(pageId, content, title, connectionId)` -> { pageId, pageUrl } — Create Page
+- `notionUpdatePage(pageId, content, mode, connectionId)` -> { pageId, pageUrl } — Update Page
+
+### X
+
+- `postToX(text, connectionId)` — Create post
+- `searchXPosts(query, scope, options)` -> { posts } — Search Posts
+
+### YouTube
+
+- `fetchYoutubeCaptions(videoUrl, exportType, language)` -> { transcripts } — Fetch Captions
+- `fetchYoutubeChannel(channelUrl)` -> { channel } — Fetch Channel
+- `fetchYoutubeComments(videoUrl, exportType, limitPages)` -> { comments } — Fetch Comments
+- `fetchYoutubeVideo(videoUrl)` -> { video } — Fetch Video
+- `searchYoutube(query, limitPages, filter, filterType)` -> { results } — Search Videos
+- `searchYoutubeTrends(bp, hl, gl)` -> { trends } — Search Trends
+
+### Helpers
+
+- `listModels()` -> { models } — List all available AI models
+- `listModelsByType(modelType)` -> { models } — Filter by type: "llm_chat", "image_generation", "video_generation", "video_analysis", "text_to_speech", "vision", "transcription"
+- `listConnectors()` -> { services } — List available connector services
+- `getConnector(serviceId)` -> { service } — Get connector details

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindstudio-ai/agent",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "TypeScript SDK for MindStudio direct step execution",
   "type": "module",
   "main": "./dist/index.js",
@@ -13,7 +13,8 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "llms.txt"
   ],
   "scripts": {
     "build": "npm run codegen && tsup",