@linkedapi/mcp 0.3.11

package/src/tools/react-to-post.ts

@@ -0,0 +1,44 @@
+import { OPERATION_NAME, TReactToPostParams } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class ReactToPostTool extends OperationTool<TReactToPostParams, unknown> {
+  public override readonly name = 'react_to_post';
+  public override readonly operationName = OPERATION_NAME.reactToPost;
+  protected override readonly schema = z.object({
+    postUrl: z.string(),
+    type: z.enum(['like', 'love', 'celebrate', 'support', 'funny', 'insightful']).or(z.string()),
+    companyUrl: z.string().optional(),
+  });
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Allows you to react to a post using any available reaction type (st.reactToPost action).',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          postUrl: {
+            type: 'string',
+            description:
+              "LinkedIn URL of the post to react. (e.g., 'https://www.linkedin.com/posts/username_activity-id')",
+          },
+          type: {
+            type: 'string',
+            description: 'Enum describing the reaction type.',
+            enum: ['like', 'love', 'support', 'celebrate', 'insightful', 'funny'],
+          },
+          companyUrl: {
+            type: 'string',
+            description:
+              "LinkedIn company page URL. If specified, the reaction will be added on behalf of the company. (e.g., 'https://www.linkedin.com/company/acme-corp')",
+          },
+        },
+        required: ['postUrl', 'type'],
+      },
+    };
+  }
+}

package/src/tools/remove-connection.ts

@@ -0,0 +1,32 @@
+import { OPERATION_NAME, TRemoveConnectionParams } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class RemoveConnectionTool extends OperationTool<TRemoveConnectionParams, unknown> {
+  public override readonly name = 'remove_connection';
+  public override readonly operationName = OPERATION_NAME.removeConnection;
+  protected override readonly schema = z.object({
+    personUrl: z.string(),
+  });
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Allows you to remove a person from your connections (st.removeConnection action).',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          personUrl: {
+            type: 'string',
+            description:
+              "Public or hashed LinkedIn URL of the person you want to remove from your connections. (e.g., 'https://www.linkedin.com/in/john-doe')",
+          },
+        },
+        required: ['personUrl'],
+      },
+    };
+  }
+}

package/src/tools/retrieve-connections.ts

@@ -0,0 +1,105 @@
+import {
+  OPERATION_NAME,
+  TRetrieveConnectionsParams,
+  TRetrieveConnectionsResult,
+} from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class RetrieveConnectionsTool extends OperationTool<
+  TRetrieveConnectionsParams,
+  TRetrieveConnectionsResult[]
+> {
+  public override readonly name = 'retrieve_connections';
+  public override readonly operationName = OPERATION_NAME.retrieveConnections;
+  protected override readonly schema = z.object({
+    limit: z.number().min(1).max(1000).optional(),
+    since: z.string().optional(),
+    filter: z
+      .object({
+        firstName: z.string().optional(),
+        lastName: z.string().optional(),
+        position: z.string().optional(),
+        locations: z.array(z.string()).optional(),
+        industries: z.array(z.string()).optional(),
+        currentCompanies: z.array(z.string()).optional(),
+        previousCompanies: z.array(z.string()).optional(),
+        schools: z.array(z.string()).optional(),
+      })
+      .optional(),
+  });
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'allows you to retrieve your connections and perform additional person-related actions if needed (st.retrieveConnections action).',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          limit: {
+            type: 'number',
+            description:
+              'Optional. Number of connections to return. Defaults to 10, with a maximum value of 1000.',
+          },
+          since: {
+            type: 'string',
+            description:
+              'Optional. ISO date string that filters connections to only include those made on or after the specified date. Only works when filter is not provided.',
+          },
+          filter: {
+            type: 'object',
+            description:
+              'Optional. Object that specifies filtering criteria for people. When multiple filter fields are specified, they are combined using AND logic.',
+            properties: {
+              firstName: {
+                type: 'string',
+                description: 'Optional. First name of person.',
+              },
+              lastName: {
+                type: 'string',
+                description: 'Optional. Last name of person.',
+              },
+              position: {
+                type: 'string',
+                description: 'Optional. Job position of person.',
+              },
+              locations: {
+                type: 'array',
+                description:
+                  'Optional. Array of free-form strings representing locations. Matches if person is located in any of the listed locations.',
+                items: { type: 'string' },
+              },
+              industries: {
+                type: 'array',
+                description:
+                  'Optional. Array of enums representing industries. Matches if person works in any of the listed industries. Takes specific values available in the LinkedIn interface.',
+                items: { type: 'string' },
+              },
+              currentCompanies: {
+                type: 'array',
+                description:
+                  'Optional. Array of company names. Matches if person currently works at any of the listed companies.',
+                items: { type: 'string' },
+              },
+              previousCompanies: {
+                type: 'array',
+                description:
+                  'Optional. Array of company names. Matches if person previously worked at any of the listed companies.',
+                items: { type: 'string' },
+              },
+              schools: {
+                type: 'array',
+                description:
+                  'Optional. Array of institution names. Matches if person currently attends or previously attended any of the listed institutions.',
+                items: { type: 'string' },
+              },
+            },
+          },
+        },
+      },
+    };
+  }
+}

package/src/tools/retrieve-pending-requests.ts

@@ -0,0 +1,23 @@
+import { OPERATION_NAME } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class RetrievePendingRequestsTool extends OperationTool<unknown, unknown> {
+  public override readonly name = 'retrieve_pending_requests';
+  public override readonly operationName = OPERATION_NAME.retrievePendingRequests;
+  protected override readonly schema = z.object({});
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Allows you to retrieve pending connection requests sent from your account. (st.retrievePendingRequests action).',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+      },
+    };
+  }
+}

package/src/tools/retrieve-performance.ts

@@ -0,0 +1,23 @@
+import { OPERATION_NAME } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class RetrievePerformanceTool extends OperationTool<unknown, unknown> {
+  public override readonly name = 'retrieve_performance';
+  public override readonly operationName = OPERATION_NAME.retrievePerformance;
+  protected override readonly schema = z.object({});
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Allows you to retrieve performance analytics from your LinkedIn dashboard (st.retrievePerformance action).',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+      },
+    };
+  }
+}

package/src/tools/retrieve-ssi.ts

@@ -0,0 +1,23 @@
+import { OPERATION_NAME } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class RetrieveSSITool extends OperationTool<unknown, unknown> {
+  public override readonly operationName = OPERATION_NAME.retrieveSSI;
+  public override readonly name = 'retrieve_ssi';
+  protected override readonly schema = z.object({});
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Allows you to retrieve your current SSI (Social Selling Index) (st.retrieveSSI action).',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+      },
+    };
+  }
+}

package/src/tools/search-companies.ts

@@ -0,0 +1,93 @@
+import { OPERATION_NAME, TSearchCompaniesParams } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class SearchCompaniesTool extends OperationTool<TSearchCompaniesParams, unknown> {
+  public override readonly name = 'search_companies';
+  public override readonly operationName = OPERATION_NAME.searchCompanies;
+  protected override readonly schema = z.object({
+    term: z.string().optional(),
+    limit: z.number().min(1).max(1000).optional(),
+    filter: z
+      .object({
+        locations: z.array(z.string()).optional(),
+        industries: z.array(z.string()).optional(),
+        sizes: z
+          .array(
+            z.enum([
+              '1-10',
+              '11-50',
+              '51-200',
+              '201-500',
+              '501-1000',
+              '1001-5000',
+              '5001-10000',
+              '10001+',
+            ]),
+          )
+          .optional(),
+      })
+      .optional(),
+  });
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Allows you to search for companies applying various filtering criteria (st.searchCompanies action).',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          term: {
+            type: 'string',
+            description: 'Optional. Keyword or phrase to search.',
+          },
+          limit: {
+            type: 'number',
+            description:
+              'Optional. Number of search results to return. Defaults to 10, with a maximum value of 1000.',
+          },
+          filter: {
+            type: 'object',
+            description:
+              'Optional. Object that specifies filtering criteria for companies. When multiple filter fields are specified, they are combined using AND logic.',
+            properties: {
+              sizes: {
+                type: 'array',
+                description:
+                  'Optional. Array of enums representing employee count ranges. Matches if company size falls within any of the listed ranges.',
+                items: {
+                  type: 'string',
+                  enum: [
+                    '1-10',
+                    '11-50',
+                    '51-200',
+                    '201-500',
+                    '501-1000',
+                    '1001-5000',
+                    '5001-10000',
+                    '10001+',
+                  ],
+                },
+              },
+              locations: {
+                type: 'array',
+                description:
+                  'Optional. Array of free-form strings representing locations. Matches if company is headquartered in any of the listed locations.',
+                items: { type: 'string' },
+              },
+              industries: {
+                type: 'array',
+                description:
+                  'Optional. Array of enums representing industries. Matches if company works in any of the listed industries. Takes specific values available in the LinkedIn interface.',
+                items: { type: 'string' },
+              },
+            },
+          },
+        },
+      },
+    };
+  }
+}

package/src/tools/search-people.ts

@@ -0,0 +1,97 @@
+import { OPERATION_NAME, TSearchPeopleParams } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class SearchPeopleTool extends OperationTool<TSearchPeopleParams, unknown> {
+  public override readonly name = 'search_people';
+  public override readonly operationName = OPERATION_NAME.searchPeople;
+  protected override readonly schema = z.object({
+    term: z.string().optional(),
+    limit: z.number().min(1).max(1000).optional(),
+    filter: z
+      .object({
+        firstName: z.string().optional(),
+        lastName: z.string().optional(),
+        position: z.string().optional(),
+        locations: z.array(z.string()).optional(),
+        industries: z.array(z.string()).optional(),
+        currentCompanies: z.array(z.string()).optional(),
+        previousCompanies: z.array(z.string()).optional(),
+        schools: z.array(z.string()).optional(),
+      })
+      .optional(),
+  });
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Allows you to search people applying various filtering criteria (st.searchPeople action).',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          term: {
+            type: 'string',
+            description: 'Optional. Keyword or phrase to search.',
+          },
+          limit: {
+            type: 'number',
+            description:
+              'Optional. Number of search results to return. Defaults to 10, with a maximum value of 1000.',
+          },
+          filter: {
+            type: 'object',
+            description:
+              'Optional. Object that specifies filtering criteria for people. When multiple filter fields are specified, they are combined using AND logic.',
+            properties: {
+              firstName: {
+                type: 'string',
+                description: 'Optional. First name of person.',
+              },
+              lastName: {
+                type: 'string',
+                description: 'Optional. Last name of person.',
+              },
+              position: {
+                type: 'string',
+                description: 'Optional. Job position of person.',
+              },
+              locations: {
+                type: 'array',
+                description:
+                  'Optional. Array of free-form strings representing locations. Matches if person is located in any of the listed locations.',
+                items: { type: 'string' },
+              },
+              industries: {
+                type: 'array',
+                description:
+                  'Optional. Array of enums representing industries. Matches if person works in any of the listed industries. Takes specific values available in the LinkedIn interface.',
+                items: { type: 'string' },
+              },
+              currentCompanies: {
+                type: 'array',
+                description:
+                  'Optional. Array of company names. Matches if person currently works at any of the listed companies.',
+                items: { type: 'string' },
+              },
+              previousCompanies: {
+                type: 'array',
+                description:
+                  'Optional. Array of company names. Matches if person previously worked at any of the listed companies.',
+                items: { type: 'string' },
+              },
+              schools: {
+                type: 'array',
+                description:
+                  'Optional. Array of institution names. Matches if person currently attends or previously attended any of the listed institutions.',
+                items: { type: 'string' },
+              },
+            },
+          },
+        },
+      },
+    };
+  }
+}

package/src/tools/send-connection-request.ts

@@ -0,0 +1,46 @@
+import { OPERATION_NAME, TSendConnectionRequestParams } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class SendConnectionRequestTool extends OperationTool<
+  TSendConnectionRequestParams,
+  unknown
+> {
+  public override readonly name = 'send_connection_request';
+  public override readonly operationName = OPERATION_NAME.sendConnectionRequest;
+  protected override readonly schema = z.object({
+    personUrl: z.string(),
+    note: z.string().optional(),
+    email: z.string().optional(),
+  });
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Allows you to send a connection request to a person (st.sendConnectionRequest action).',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          personUrl: {
+            type: 'string',
+            description:
+              "Public or hashed LinkedIn URL of the person you want to send a connection request to. (e.g., 'https://www.linkedin.com/in/john-doe')",
+          },
+          note: {
+            type: 'string',
+            description: 'Optional. Note to include with the connection request.',
+          },
+          email: {
+            type: 'string',
+            description:
+              'Optional. Email address required by some people for sending connection requests to them. If it is required and not provided, the connection request will fail.',
+          },
+        },
+        required: ['personUrl'],
+      },
+    };
+  }
+}

package/src/tools/send-message.ts

@@ -0,0 +1,36 @@
+import { OPERATION_NAME, TSendMessageParams } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class SendMessageTool extends OperationTool<TSendMessageParams, unknown> {
+  public override readonly name = 'send_message';
+  public override readonly operationName = OPERATION_NAME.sendMessage;
+  protected override readonly schema = z.object({
+    personUrl: z.string(),
+    text: z.string().min(1),
+  });
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description: 'Allows you to send a message to a person (st.sendMessage action).',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          personUrl: {
+            type: 'string',
+            description:
+              "LinkedIn URL of the person you want to send a message to (e.g., 'https://www.linkedin.com/in/john-doe')",
+          },
+          text: {
+            type: 'string',
+            description: 'The message text, must be up to 1900 characters.',
+          },
+        },
+        required: ['personUrl', 'text'],
+      },
+    };
+  }
+}

package/src/tools/sync-conversation.ts

@@ -0,0 +1,32 @@
+import { OPERATION_NAME, TSyncConversationParams } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class SyncConversationTool extends OperationTool<TSyncConversationParams, unknown> {
+  public override readonly name = 'sync_conversation';
+  public override readonly operationName = OPERATION_NAME.syncConversation;
+  protected override readonly schema = z.object({
+    personUrl: z.string(),
+  });
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Allows you to sync a conversation so you can start polling it (st.syncConversation action).',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          personUrl: {
+            type: 'string',
+            description:
+              "The LinkedIn URL of the person whose conversation you want to synchronize (e.g., 'https://www.linkedin.com/in/john-doe')",
+          },
+        },
+        required: ['personUrl'],
+      },
+    };
+  }
+}

package/src/tools/withdraw-connection-request.ts

@@ -0,0 +1,41 @@
+import { OPERATION_NAME, TWithdrawConnectionRequestParams } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class WithdrawConnectionRequestTool extends OperationTool<
+  TWithdrawConnectionRequestParams,
+  unknown
+> {
+  public override readonly name = 'withdraw_connection_request';
+  public override readonly operationName = OPERATION_NAME.withdrawConnectionRequest;
+  protected override readonly schema = z.object({
+    personUrl: z.string(),
+    unfollow: z.boolean().optional(),
+  });
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Allows you to withdraw the connection request sent to a person (st.withdrawConnectionRequest action).',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          personUrl: {
+            type: 'string',
+            description:
+              "Public or hashed LinkedIn URL of the person you want to withdraw the connection request from. (e.g., 'https://www.linkedin.com/in/john-doe')",
+          },
+          unfollow: {
+            type: 'boolean',
+            description:
+              'Optional. Boolean indicating whether you want to unfollow the person when withdrawing the request. The default value is true.',
+          },
+        },
+        required: ['personUrl'],
+      },
+    };
+  }
+}

package/src/utils/define-request-timeout.ts

@@ -0,0 +1,17 @@
+export function defineRequestTimeoutInSeconds(mcpClient: string): number {
+  const bigTimeout = 600;
+
+  console.error('mcpClient', mcpClient);
+  switch (mcpClient) {
+    case 'claude':
+      return 180;
+    case 'chatgpt':
+      return 50;
+    case 'cursor':
+    case 'vscode':
+    case 'windsurf':
+      return bigTimeout;
+    default:
+      return 60;
+  }
+}