@oneshot-agent/mcp-server 0.22.0 → 0.23.0

package/README.md

@@ -96,7 +96,7 @@ Read tools (inbox, SMS inbox, notifications, balance, browser profiles) return p
 ## Remote (hosted)
 
 Clients that run in someone else's cloud — Grok Bot, hosted runners — cannot spawn this
-server and must not hold a wallet key. For them OneShot hosts the same 53 tools over
+server and must not hold a wallet key. For them OneShot hosts the same 61 tools over
 Streamable HTTP at **`https://win.oneshotagent.com/mcp`**, authenticated with an
 **agent access token** and billed to the agent's credit balance:
 

package/dist/index.js

@@ -52,7 +52,7 @@ async function main() {
     // Create MCP server
     const server = new Server({
         name: "oneshot-mcp",
-        version: "0.22.0", // keep in sync with package.json; guarded by version.test.ts
+        version: "0.23.0", // keep in sync with package.json; guarded by version.test.ts
     }, {
         capabilities: {
             tools: {},

package/dist/tools/index.js

@@ -17,6 +17,7 @@ import { deepResearchPersonTool, socialProfilesTool, articleSearchTool, personNe
 import { companySearchTool, enrichCompanyTool, handleCompanySearch, handleEnrichCompany } from "./company.js";
 import { localSearchTool, localResolveTool, handleLocalSearch, handleLocalResolve } from "./local.js";
 import { govSolicitationsTool, handleGovSolicitations } from "./gov.js";
+import { linkedinConnectTool, linkedinAccountsTool, linkedinSyncTool, linkedinConversationsTool, linkedinMessagesTool, linkedinReplyTool, linkedinViewProfileTool, linkedinReactTool, handleLinkedinConnect, handleLinkedinAccounts, handleLinkedinSync, handleLinkedinConversations, handleLinkedinMessages, handleLinkedinReply, handleLinkedinViewProfile, handleLinkedinReact, } from "./linkedin.js";
 import { computeTool, computeStatusTool, computeTasksTool, computeCancelTool, computeRespondTool, computePauseTool, computeResumeTool, computeFundTool, handleCompute, handleComputeStatus, handleComputeTasks, handleComputeCancel, handleComputeRespond, handleComputePause, handleComputeResume, handleComputeFund } from "./compute.js";
 import { listDomainsTool, pauseDomainTool, resumeDomainTool, handleListDomains, handlePauseDomain, handleResumeDomain } from "./domains.js";
 import { spendBreakdownTool, rocsTool, rocsByGoalTool, receiptsListTool, tagReceiptValueTool, handleSpendBreakdown, handleRocs, handleRocsByGoal, handleReceiptsList, handleTagReceiptValue } from "./analytics.js";
@@ -71,6 +72,15 @@ export const tools = [
     browserDeleteProfileTool,
     // Web Read
     webReadTool,
+    // LinkedIn (human-connected account)
+    linkedinConnectTool,
+    linkedinAccountsTool,
+    linkedinSyncTool,
+    linkedinConversationsTool,
+    linkedinMessagesTool,
+    linkedinReplyTool,
+    linkedinViewProfileTool,
+    linkedinReactTool,
     // Domains
     listDomainsTool,
     pauseDomainTool,
@@ -138,6 +148,15 @@ const handlers = {
     "oneshot_browser_delete_profile": handleBrowserDeleteProfile,
     // Web Read
     "oneshot_web_read": handleWebRead,
+    // LinkedIn (human-connected account)
+    "oneshot_linkedin_connect": handleLinkedinConnect,
+    "oneshot_linkedin_accounts": handleLinkedinAccounts,
+    "oneshot_linkedin_sync": handleLinkedinSync,
+    "oneshot_linkedin_conversations": handleLinkedinConversations,
+    "oneshot_linkedin_messages": handleLinkedinMessages,
+    "oneshot_linkedin_reply": handleLinkedinReply,
+    "oneshot_linkedin_view_profile": handleLinkedinViewProfile,
+    "oneshot_linkedin_react": handleLinkedinReact,
     // Domains
     "oneshot_list_domains": handleListDomains,
     "oneshot_pause_domain": handlePauseDomain,

package/dist/tools/linkedin.d.ts

@@ -0,0 +1,20 @@
+import type { Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { OneShot } from "@oneshot-agent/sdk";
+export declare const linkedinConnectTool: Tool;
+export declare const linkedinAccountsTool: Tool;
+export declare const linkedinSyncTool: Tool;
+export declare const linkedinConversationsTool: Tool;
+export declare const linkedinMessagesTool: Tool;
+export declare const linkedinReplyTool: Tool;
+export declare const linkedinViewProfileTool: Tool;
+export declare const linkedinReactTool: Tool;
+export declare function handleLinkedinConnect(agent: OneShot, args: Record<string, unknown>): Promise<import("@oneshot-agent/sdk").LinkedInConnectIntentIssued>;
+export declare function handleLinkedinAccounts(agent: OneShot, args: Record<string, unknown>): Promise<import("@oneshot-agent/sdk").LinkedInConnectIntent | import("@oneshot-agent/sdk").LinkedInSyncStatus | {
+    accounts: import("@oneshot-agent/sdk").LinkedInAccount[];
+}>;
+export declare function handleLinkedinSync(agent: OneShot, args: Record<string, unknown>): Promise<import("@oneshot-agent/sdk").LinkedInSyncRunResult>;
+export declare function handleLinkedinConversations(agent: OneShot, args: Record<string, unknown>): Promise<import("@oneshot-agent/sdk").LinkedInConversationsPage>;
+export declare function handleLinkedinMessages(agent: OneShot, args: Record<string, unknown>): Promise<import("@oneshot-agent/sdk").LinkedInMessagesPage>;
+export declare function handleLinkedinReply(agent: OneShot, args: Record<string, unknown>): Promise<import("@oneshot-agent/sdk").LinkedInWriteResult>;
+export declare function handleLinkedinViewProfile(agent: OneShot, args: Record<string, unknown>): Promise<import("@oneshot-agent/sdk").LinkedInProfileViewResult>;
+export declare function handleLinkedinReact(agent: OneShot, args: Record<string, unknown>): Promise<import("@oneshot-agent/sdk").LinkedInWriteResult>;

package/dist/tools/linkedin.js

@@ -0,0 +1,198 @@
+/**
+ * LinkedIn messaging through a human-connected account (issue #756).
+ *
+ * The human connects their own LinkedIn account via a hosted login link and
+ * grants specific actions (read, reply, view_profile, react). Reconnect and
+ * revoke are deliberately NOT exposed as MCP tools — a human decides those
+ * from the application that owns the account.
+ */
+const GRANT_ACTIONS = ["read", "reply", "view_profile", "react", "invite", "comment"];
+export const linkedinConnectTool = {
+    name: "oneshot_linkedin_connect",
+    description: "Create a hosted LinkedIn login link for a human to connect THEIR OWN LinkedIn account to this agent, granting specific actions (read, reply, view_profile, react). Returns intent_id + url (show the url to the human; it expires in 30 minutes; never embed it in an iframe). Poll oneshot_linkedin_accounts with the intent_id afterwards. Free tool.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            requested_actions: { type: "array", items: { type: "string", enum: GRANT_ACTIONS }, description: "Actions to ask the human to grant. 'read' is needed for sync + reads; 'reply' to send; 'view_profile' / 'react' for engagement." },
+            success_redirect_url: { type: "string", description: "https:// URL the human is sent to after connecting (optional)" },
+            failure_redirect_url: { type: "string", description: "https:// URL on failure (optional)" },
+        },
+        required: ["requested_actions"],
+    },
+};
+export const linkedinAccountsTool = {
+    name: "oneshot_linkedin_accounts",
+    description: "List the LinkedIn accounts connected to this agent (status, granted actions, sync coverage), or, with intent_id, check a pending connection from oneshot_linkedin_connect (pending → completed with the account, or failed with a reason). Free tool.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            intent_id: { type: "string", description: "Connection intent to check instead of listing accounts" },
+            account_id: { type: "string", description: "Return one account (with coverage + recent sync runs) instead of the list" },
+            include_revoked: { type: "boolean", description: "Include revoked accounts in the list (default false)" },
+        },
+    },
+};
+export const linkedinSyncTool = {
+    name: "oneshot_linkedin_sync",
+    description: "Sync message history from a connected LinkedIn account. One paid call = one bounded run (up to max_pages × 250 messages, newest first); a run that hits the bound is paused with a cursor and the next call with mode 'continue' resumes it. Check coverage.complete / pending_cursor in the result before buying another run. Requires the 'read' grant. Paid tool (flat price per run).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            account_id: { type: "string", description: "Connected LinkedIn account id (required)" },
+            mode: { type: "string", enum: ["continue", "restart", "history"], description: "continue = resume the paused cursor (default); restart = discard paused cursors; history = also re-request the provider's history back-fill" },
+            max_pages: { type: "number", description: "Pages of 250 messages this run may fetch (1-10, default 10)" },
+            memo: { type: "string", description: "Why this sync is running (audit trail)" },
+        },
+        required: ["account_id"],
+    },
+};
+export const linkedinConversationsTool = {
+    name: "oneshot_linkedin_conversations",
+    description: "List synced LinkedIn conversations for a connected account, newest activity first, with attendees and unread counts. Every response carries coverage + sync_state — an empty list with sync_state != 'complete' means not synced yet, not an empty inbox. Free tool.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            account_id: { type: "string", description: "Connected LinkedIn account id (required)" },
+            cursor: { type: "string", description: "next_cursor from the previous page" },
+            limit: { type: "number", description: "1-100, default 50" },
+            since: { type: "string", description: "ISO time: only conversations changed after this" },
+            unread: { type: "boolean", description: "Only conversations with unread messages" },
+            archived: { type: "boolean", description: "List archived conversations instead of active ones (default false)" },
+        },
+        required: ["account_id"],
+    },
+};
+export const linkedinMessagesTool = {
+    name: "oneshot_linkedin_messages",
+    description: "List synced LinkedIn messages for a connected account, newest first. Filter by conversation_id, direction ('inbound' = the human received it; use since as a reply watermark), since (sent after), changed_since (edited/read/deleted after). Attachment metadata only. Free tool.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            account_id: { type: "string", description: "Connected LinkedIn account id (required)" },
+            conversation_id: { type: "string", description: "Restrict to one conversation" },
+            direction: { type: "string", enum: ["inbound", "outbound"] },
+            since: { type: "string", description: "ISO time: only messages sent after this" },
+            changed_since: { type: "string", description: "ISO time: only messages updated after this" },
+            cursor: { type: "string", description: "next_cursor from the previous page" },
+            limit: { type: "number", description: "1-100, default 50" },
+            include_deleted: { type: "boolean", description: "Include messages deleted upstream (default false)" },
+        },
+        required: ["account_id"],
+    },
+};
+export const linkedinReplyTool = {
+    name: "oneshot_linkedin_reply",
+    description: "Send a reply in an existing LinkedIn conversation through a connected account that granted 'reply'. The human's account sends it; a message LinkedIn accepted cannot be recalled. Per-account daily cap (default 50) shared by every caller; sends are paced. An Idempotency-Key is generated automatically so a retry never double-sends. Outcome (sent / failed / ambiguous-under-reconciliation) is in the returned job result. Paid tool (flat price per message).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            account_id: { type: "string", description: "Connected LinkedIn account id (required)" },
+            conversation_id: { type: "string", description: "Conversation id from oneshot_linkedin_conversations (required)" },
+            text: { type: "string", description: "Message text, 1-4000 characters (required)" },
+            memo: { type: "string", description: "Why this reply is being sent (audit trail)" },
+            idempotency_key: { type: "string", description: "Optional caller-supplied key; reuse it to safely retry the same send" },
+        },
+        required: ["account_id", "conversation_id", "text"],
+    },
+};
+export const linkedinViewProfileTool = {
+    name: "oneshot_linkedin_view_profile",
+    description: "View a LinkedIn profile through a connected account that granted 'view_profile' and return a public-safe summary (name, headline, location, network distance). notify=false (default) is a data read; notify=true makes the human appear in the target's 'who viewed your profile' and cannot be undone. Per-account daily cap (default 100). Paid tool (flat price per view).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            account_id: { type: "string", description: "Connected LinkedIn account id (required)" },
+            identifier: { type: "string", description: "Public identifier, provider id, or a linkedin.com/in/<slug> URL (required)" },
+            notify: { type: "boolean", description: "Default false. true = the profile owner sees the view." },
+            memo: { type: "string", description: "Why (audit trail)" },
+            idempotency_key: { type: "string", description: "Optional caller-supplied key; reuse it to safely retry the same view without paying or notifying twice" },
+        },
+        required: ["account_id", "identifier"],
+    },
+};
+export const linkedinReactTool = {
+    name: "oneshot_linkedin_react",
+    description: "React to a LinkedIn post through a connected account that granted 'react' (like, celebrate, support, love, insightful, funny). Per-account daily cap (default 50). Reactions can be removed by the human on LinkedIn but not through this tool. Paid tool (flat price per reaction).",
+    inputSchema: {
+        type: "object",
+        properties: {
+            account_id: { type: "string", description: "Connected LinkedIn account id (required)" },
+            post_id: { type: "string", description: "LinkedIn post social id, e.g. urn:li:activity:… (required)" },
+            reaction_type: { type: "string", enum: ["like", "celebrate", "support", "love", "insightful", "funny"], description: "Default like" },
+            memo: { type: "string", description: "Why (audit trail)" },
+            idempotency_key: { type: "string", description: "Optional caller-supplied key; reuse it to safely retry the same reaction" },
+        },
+        required: ["account_id", "post_id"],
+    },
+};
+export async function handleLinkedinConnect(agent, args) {
+    return agent.linkedinConnect({
+        requestedActions: args.requested_actions,
+        successRedirectUrl: args.success_redirect_url,
+        failureRedirectUrl: args.failure_redirect_url,
+    });
+}
+export async function handleLinkedinAccounts(agent, args) {
+    if (typeof args.intent_id === "string" && args.intent_id)
+        return agent.getLinkedInConnection(args.intent_id);
+    if (typeof args.account_id === "string" && args.account_id)
+        return agent.getLinkedInSync(args.account_id);
+    return agent.listLinkedInAccounts({ includeRevoked: args.include_revoked });
+}
+export async function handleLinkedinSync(agent, args) {
+    return agent.linkedinSync({
+        accountId: args.account_id,
+        mode: args.mode,
+        maxPages: args.max_pages,
+        memo: args.memo,
+    });
+}
+export async function handleLinkedinConversations(agent, args) {
+    return agent.linkedinConversations({
+        accountId: args.account_id,
+        cursor: args.cursor,
+        limit: args.limit,
+        since: args.since,
+        unread: args.unread,
+        archived: args.archived,
+    });
+}
+export async function handleLinkedinMessages(agent, args) {
+    return agent.linkedinMessages({
+        accountId: args.account_id,
+        conversationId: args.conversation_id,
+        direction: args.direction,
+        since: args.since,
+        changedSince: args.changed_since,
+        cursor: args.cursor,
+        limit: args.limit,
+        includeDeleted: args.include_deleted,
+    });
+}
+export async function handleLinkedinReply(agent, args) {
+    return agent.linkedinReply({
+        accountId: args.account_id,
+        conversationId: args.conversation_id,
+        text: args.text,
+        memo: args.memo,
+        idempotencyKey: args.idempotency_key,
+    });
+}
+export async function handleLinkedinViewProfile(agent, args) {
+    return agent.linkedinViewProfile({
+        accountId: args.account_id,
+        identifier: args.identifier,
+        notify: args.notify,
+        memo: args.memo,
+        idempotencyKey: args.idempotency_key,
+    });
+}
+export async function handleLinkedinReact(agent, args) {
+    return agent.linkedinReact({
+        accountId: args.account_id,
+        postId: args.post_id,
+        reactionType: args.reaction_type,
+        memo: args.memo,
+        idempotencyKey: args.idempotency_key,
+    });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oneshot-agent/mcp-server",
-  "version": "0.22.0",
-  "description": "MCP server for OneShot - 53 tools for AI agents",
+  "version": "0.23.0",
+  "description": "MCP server for OneShot - 61 tools for AI agents",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -25,7 +25,7 @@
   "dependencies": {
     "@coinbase/cdp-sdk": "1.45.0",
     "@modelcontextprotocol/sdk": "1.27.1",
-    "@oneshot-agent/sdk": "^0.34.0",
+    "@oneshot-agent/sdk": "^0.35.0",
     "zod": "3.25.76"
   },
   "devDependencies": {