@linkedapi/mcp 0.3.11 → 1.0.1

package/src/tools/admin-get-accounts.ts

@@ -0,0 +1,30 @@
+import { LinkedApiAdmin, TAccountsResult } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import z from 'zod';
+
+import { AdminTool } from '../utils/admin-tool.js';
+
+export class AdminGetAccountsTool extends AdminTool<Record<string, never>, TAccountsResult> {
+  public readonly name = 'admin_get_accounts';
+  protected readonly schema = z.object({});
+
+  public override async execute({
+    admin,
+  }: {
+    admin: LinkedApiAdmin;
+    args: Record<string, never>;
+  }): Promise<TAccountsResult> {
+    return await admin.accounts.getAll();
+  }
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description: 'Get all connected LinkedIn accounts and pending connection sessions.',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+      },
+    };
+  }
+}

package/src/tools/admin-get-limits-usage.ts

@@ -0,0 +1,42 @@
+import { LinkedApiAdmin, TGetLimitsUsageParams, TLimitUsage } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import z from 'zod';
+
+import { AdminTool } from '../utils/admin-tool.js';
+
+export class AdminGetLimitsUsageTool extends AdminTool<
+  TGetLimitsUsageParams,
+  { usage: Array<TLimitUsage> }
+> {
+  public readonly name = 'admin_get_limits_usage';
+  protected readonly schema = z.object({
+    accountId: z.string(),
+  });
+
+  public override async execute({
+    admin,
+    args,
+  }: {
+    admin: LinkedApiAdmin;
+    args: TGetLimitsUsageParams;
+  }): Promise<{ usage: Array<TLimitUsage> }> {
+    return await admin.limits.getUsage(args);
+  }
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description: 'Get current usage against configured rate limits for an account.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          accountId: {
+            type: 'string',
+            description: 'Account UUID',
+          },
+        },
+        required: ['accountId'],
+      },
+    };
+  }
+}

package/src/tools/admin-get-seats.ts

@@ -0,0 +1,34 @@
+import { LinkedApiAdmin, TSubscriptionSeat } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import z from 'zod';
+
+import { AdminTool } from '../utils/admin-tool.js';
+
+export class AdminGetSeatsTool extends AdminTool<
+  Record<string, never>,
+  { seats: Array<TSubscriptionSeat> }
+> {
+  public readonly name = 'admin_get_seats';
+  protected readonly schema = z.object({});
+
+  public override async execute({
+    admin,
+  }: {
+    admin: LinkedApiAdmin;
+    args: Record<string, never>;
+  }): Promise<{ seats: Array<TSubscriptionSeat> }> {
+    return await admin.subscription.getSeats();
+  }
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Get active subscription seats. Each seat allows one connected LinkedIn account. Seat types: core (standard) and plus (includes Sales Navigator).',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+      },
+    };
+  }
+}

package/src/tools/admin-get-subscription-status.ts

@@ -0,0 +1,33 @@
+import { LinkedApiAdmin, TSubscriptionStatus } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import z from 'zod';
+
+import { AdminTool } from '../utils/admin-tool.js';
+
+export class AdminGetSubscriptionStatusTool extends AdminTool<
+  Record<string, never>,
+  TSubscriptionStatus
+> {
+  public readonly name = 'admin_get_subscription_status';
+  protected readonly schema = z.object({});
+
+  public override async execute({
+    admin,
+  }: {
+    admin: LinkedApiAdmin;
+    args: Record<string, never>;
+  }): Promise<TSubscriptionStatus> {
+    return await admin.subscription.getStatus();
+  }
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description: 'Get current subscription status, trial eligibility, and cancellation schedule.',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+      },
+    };
+  }
+}

package/src/tools/admin-regenerate-token.ts

@@ -0,0 +1,43 @@
+import { LinkedApiAdmin, TRegenerateTokenParams, TRegenerateTokenResult } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import z from 'zod';
+
+import { AdminTool } from '../utils/admin-tool.js';
+
+export class AdminRegenerateTokenTool extends AdminTool<
+  TRegenerateTokenParams,
+  TRegenerateTokenResult
+> {
+  public readonly name = 'admin_regenerate_token';
+  protected readonly schema = z.object({
+    accountId: z.string(),
+  });
+
+  public override async execute({
+    admin,
+    args,
+  }: {
+    admin: LinkedApiAdmin;
+    args: TRegenerateTokenParams;
+  }): Promise<TRegenerateTokenResult> {
+    return await admin.accounts.regenerateIdentificationToken(args);
+  }
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Regenerate identification token for an account. The old token becomes invalid immediately.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          accountId: {
+            type: 'string',
+            description: 'UUID of the account',
+          },
+        },
+        required: ['accountId'],
+      },
+    };
+  }
+}

package/src/tools/admin-reset-limits.ts

@@ -0,0 +1,39 @@
+import { LinkedApiAdmin, TResetLimitsParams } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import z from 'zod';
+
+import { AdminTool } from '../utils/admin-tool.js';
+
+export class AdminResetLimitsTool extends AdminTool<TResetLimitsParams, void> {
+  public readonly name = 'admin_reset_limits';
+  protected readonly schema = z.object({
+    accountId: z.string(),
+  });
+
+  public override async execute({
+    admin,
+    args,
+  }: {
+    admin: LinkedApiAdmin;
+    args: TResetLimitsParams;
+  }): Promise<void> {
+    await admin.limits.resetToDefaults(args);
+  }
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description: 'Reset all rate limits for an account to the system defaults.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          accountId: {
+            type: 'string',
+            description: 'Account UUID',
+          },
+        },
+        required: ['accountId'],
+      },
+    };
+  }
+}

package/src/tools/admin-set-limits.ts

@@ -0,0 +1,75 @@
+import { LinkedApiAdmin, TSetLimitsParams } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import z from 'zod';
+
+import { AdminTool } from '../utils/admin-tool.js';
+
+export class AdminSetLimitsTool extends AdminTool<TSetLimitsParams, void> {
+  public readonly name = 'admin_set_limits';
+  protected readonly schema = z.object({
+    accountId: z.string(),
+    limits: z.array(
+      z.object({
+        category: z.string(),
+        period: z.enum(['daily', 'weekly', 'monthly']),
+        maxValue: z.number().int().min(0),
+        isEnabled: z.boolean().optional(),
+      }),
+    ),
+  });
+
+  public override async execute({
+    admin,
+    args,
+  }: {
+    admin: LinkedApiAdmin;
+    args: TSetLimitsParams;
+  }): Promise<void> {
+    await admin.limits.set(args);
+  }
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Set rate limits for an account. Only specified limits are created or updated; other limits remain unchanged. Categories: stPersonProfileViews, stCompanyPageViews, stConnectionRequests, stMessages, stSearchQueries, stReactions, stComments, stPosts, nvPersonProfileViews, nvCompanyPageViews, nvMessages.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          accountId: {
+            type: 'string',
+            description: 'Account UUID',
+          },
+          limits: {
+            type: 'array',
+            description: 'Array of limit configurations',
+            items: {
+              type: 'object',
+              properties: {
+                category: {
+                  type: 'string',
+                  description: 'Limit category',
+                },
+                period: {
+                  type: 'string',
+                  enum: ['daily', 'weekly', 'monthly'],
+                  description: 'Limit period',
+                },
+                maxValue: {
+                  type: 'number',
+                  description: 'Maximum allowed actions (>= 0)',
+                },
+                isEnabled: {
+                  type: 'boolean',
+                  description: 'Whether this limit is enforced (default: true)',
+                },
+              },
+              required: ['category', 'period', 'maxValue'],
+            },
+          },
+        },
+        required: ['accountId', 'limits'],
+      },
+    };
+  }
+}

package/src/tools/admin-set-seats.ts

@@ -0,0 +1,52 @@
+import { LinkedApiAdmin, TSetSeatsParams, TSetSeatsResult } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import z from 'zod';
+
+import { AdminTool } from '../utils/admin-tool.js';
+
+export class AdminSetSeatsTool extends AdminTool<TSetSeatsParams, TSetSeatsResult> {
+  public readonly name = 'admin_set_seats';
+  protected readonly schema = z.object({
+    quantity: z.number().int().min(1).max(1000),
+    seatType: z.enum(['core', 'plus']),
+    billingPeriod: z.enum(['month', 'year']),
+  });
+
+  public override async execute({
+    admin,
+    args,
+  }: {
+    admin: LinkedApiAdmin;
+    args: TSetSeatsParams;
+  }): Promise<TSetSeatsResult> {
+    return await admin.subscription.setSeats(args);
+  }
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Set number of subscription seats. Returns checkout link if no active subscription, otherwise updates immediately.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          quantity: {
+            type: 'number',
+            description: 'Number of seats (1-1000)',
+          },
+          seatType: {
+            type: 'string',
+            enum: ['core', 'plus'],
+            description: 'Seat type. "plus" unlocks Sales Navigator actions.',
+          },
+          billingPeriod: {
+            type: 'string',
+            enum: ['month', 'year'],
+            description: 'Billing period',
+          },
+        },
+        required: ['quantity', 'seatType', 'billingPeriod'],
+      },
+    };
+  }
+}

package/src/tools/comment-on-post.ts

@@ -16,7 +16,8 @@ export class CommentOnPostTool extends OperationTool<TCommentOnPostParams, unkno
   public override getTool(): Tool {
     return {
       name: this.name,
-      description: 'Allows you to leave a comment on a post (st.commentOnPost action).',
+      description:
+        'Allows you to leave a comment on a post (st.commentOnPost action). If this workflow is still running, do not retry this tool; retrying can post duplicate comments.',
       inputSchema: {
         type: 'object',
         properties: {

package/src/tools/create-post.ts

@@ -26,7 +26,7 @@ export class CreatePostTool extends OperationTool<TCreatePostParams, unknown> {
     return {
       name: this.name,
       description:
-        'Creates a new LinkedIn post with optional media attachments (st.createPost action).',
+        'Creates a new LinkedIn post with optional media attachments (st.createPost action). If this workflow is still running, do not retry this tool; retrying can create duplicate posts.',
       inputSchema: {
         type: 'object',
         properties: {

package/src/tools/execute-custom-workflow.ts

@@ -17,7 +17,8 @@ export class ExecuteCustomWorkflowTool extends OperationTool<
   public override getTool(): Tool {
     return {
       name: this.name,
-      description: 'Execute a custom workflow definition',
+      description:
+        'Execute a custom workflow definition. If this workflow is still running, do not retry this tool; retrying can duplicate any write actions inside the custom workflow.',
       inputSchema: {
         type: 'object',
         properties: { definition: { type: 'object' } },

package/src/tools/get-conversation.ts

@@ -1,8 +1,14 @@
-import LinkedApi, { TConversationPollResult, TMappedResponse } from '@linkedapi/node';
+import LinkedApi, {
+  LinkedApiWorkflowTimeoutError,
+  TConversationPollResult,
+  TMappedResponse,
+} from '@linkedapi/node';
 import { Tool } from '@modelcontextprotocol/sdk/types.js';
 import z from 'zod';
 
+import { executeWithProgress } from '../utils/execute-with-progress.js';
 import { LinkedApiTool } from '../utils/linked-api-tool.js';
+import { LinkedApiProgressNotification } from '../utils/types.js';
 
 export class GetConversationTool extends LinkedApiTool<
   { personUrl: string; since?: string },
@@ -17,18 +23,36 @@ export class GetConversationTool extends LinkedApiTool<
   public override async execute({
     linkedapi,
     args: { personUrl, since },
+    workflowTimeout,
+    progressToken,
+    progressCallback,
   }: {
     linkedapi: LinkedApi;
     args: { personUrl: string; since?: string };
     workflowTimeout: number;
     progressToken?: string | number;
+    progressCallback: (progress: LinkedApiProgressNotification) => void;
   }): Promise<TMappedResponse<TConversationPollResult>> {
     const conversations = await this.getConversation(linkedapi, personUrl, since);
     if (conversations.errors.length === 0) {
       return conversations;
     }
-    const workflowId = await linkedapi.syncConversation.execute({ personUrl });
-    await linkedapi.syncConversation.result(workflowId);
+    try {
+      await executeWithProgress({
+        progressCallback,
+        operation: linkedapi.syncConversation,
+        workflowTimeout,
+        params: { personUrl },
+        progressToken,
+      });
+    } catch (error) {
+      if (error instanceof LinkedApiWorkflowTimeoutError) {
+        error.message = `${error.message}
+
+After get_workflow_result completes this sync workflow, call get_conversation again with the same personUrl to read the synchronized messages.`;
+      }
+      throw error;
+    }
     return await this.getConversation(linkedapi, personUrl, since);
   }
 

package/src/tools/get-workflow-result.ts

@@ -4,6 +4,7 @@ import z from 'zod';
 
 import { executeWithProgress } from '../utils/execute-with-progress.js';
 import { LinkedApiTool } from '../utils/linked-api-tool.js';
+import { LinkedApiProgressNotification } from '../utils/types.js';
 
 interface IGetWorkflowResultParams {
   workflowId: string;
@@ -22,16 +23,21 @@ export class GetWorkflowResultTool extends LinkedApiTool<IGetWorkflowResultParam
     args: { workflowId, operationName },
     workflowTimeout,
     progressToken,
+    progressCallback,
   }: {
     linkedapi: LinkedApi;
     args: IGetWorkflowResultParams;
     workflowTimeout: number;
     progressToken?: string | number;
+    progressCallback: (progress: LinkedApiProgressNotification) => void;
   }): Promise<TMappedResponse<unknown>> {
     const operation = linkedapi.operations.find(
       (operation) => operation.operationName === operationName,
     )!;
-    return await executeWithProgress(this.progressCallback, operation, workflowTimeout, {
+    return await executeWithProgress({
+      progressCallback,
+      operation,
+      workflowTimeout,
       workflowId,
       progressToken,
     });
@@ -47,12 +53,13 @@ export class GetWorkflowResultTool extends LinkedApiTool<IGetWorkflowResultParam
         properties: {
           workflowId: {
             type: 'string',
-            description: 'The workflow ID provided in the background workflow status message',
+            description:
+              'Required. The workflow ID provided in the background workflow status message.',
           },
           operationName: {
             type: 'string',
             description:
-              'Optional function name for proper type restoration (provided in background workflow status if available)',
+              'Required. The operationName provided in the background workflow status message. Use the exact value so the result can be restored correctly.',
           },
         },
         required: ['workflowId', 'operationName'],

package/src/tools/nv-get-conversation.ts

@@ -1,8 +1,14 @@
-import LinkedApi, { TConversationPollResult, TMappedResponse } from '@linkedapi/node';
+import LinkedApi, {
+  LinkedApiWorkflowTimeoutError,
+  TConversationPollResult,
+  TMappedResponse,
+} from '@linkedapi/node';
 import { Tool } from '@modelcontextprotocol/sdk/types.js';
 import z from 'zod';
 
+import { executeWithProgress } from '../utils/execute-with-progress.js';
 import { LinkedApiTool } from '../utils/linked-api-tool.js';
+import { LinkedApiProgressNotification } from '../utils/types.js';
 
 export class NvGetConversationTool extends LinkedApiTool<
   { personUrl: string; since?: string },
@@ -17,18 +23,36 @@ export class NvGetConversationTool extends LinkedApiTool<
   public override async execute({
     linkedapi,
     args: { personUrl, since },
+    workflowTimeout,
+    progressToken,
+    progressCallback,
   }: {
     linkedapi: LinkedApi;
     args: { personUrl: string; since?: string };
     workflowTimeout: number;
     progressToken?: string | number;
+    progressCallback: (progress: LinkedApiProgressNotification) => void;
   }): Promise<TMappedResponse<TConversationPollResult>> {
     const conversations = await this.getConversation(linkedapi, personUrl, since);
     if (conversations.errors.length === 0) {
       return conversations;
     }
-    const workflowId = await linkedapi.nvSyncConversation.execute({ personUrl });
-    await linkedapi.nvSyncConversation.result(workflowId);
+    try {
+      await executeWithProgress({
+        progressCallback,
+        operation: linkedapi.nvSyncConversation,
+        workflowTimeout,
+        params: { personUrl },
+        progressToken,
+      });
+    } catch (error) {
+      if (error instanceof LinkedApiWorkflowTimeoutError) {
+        error.message = `${error.message}
+
+After get_workflow_result completes this sync workflow, call nv_get_conversation again with the same personUrl to read the synchronized messages.`;
+      }
+      throw error;
+    }
     return await this.getConversation(linkedapi, personUrl, since);
   }
 

package/src/tools/nv-send-message.ts

@@ -17,7 +17,7 @@ export class NvSendMessageTool extends OperationTool<TNvSendMessageParams, unkno
     return {
       name: this.name,
       description:
-        'Allows you to send a message to a person in Sales Navigator (nv.sendMessage action)',
+        'Allows you to send a message to a person in Sales Navigator (nv.sendMessage action). If this workflow is still running, do not retry this tool; retrying can send duplicate Sales Navigator messages to the same person.',
       inputSchema: {
         type: 'object',
         properties: {

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

@@ -17,7 +17,7 @@ export class ReactToPostTool extends OperationTool<TReactToPostParams, unknown>
     return {
       name: this.name,
       description:
-        'Allows you to react to a post using any available reaction type (st.reactToPost action).',
+        'Allows you to react to a post using any available reaction type (st.reactToPost action). If this workflow is still running, do not retry this tool; retrying can queue duplicate reaction attempts.',
       inputSchema: {
         type: 'object',
         properties: {

package/src/tools/remove-connection.ts

@@ -15,7 +15,7 @@ export class RemoveConnectionTool extends OperationTool<TRemoveConnectionParams,
     return {
       name: this.name,
       description:
-        'Allows you to remove a person from your connections (st.removeConnection action).',
+        'Allows you to remove a person from your connections (st.removeConnection action). If this workflow is still running, do not retry this tool; retrying can queue duplicate removal attempts for the same person.',
       inputSchema: {
         type: 'object',
         properties: {

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

@@ -20,7 +20,7 @@ export class SendConnectionRequestTool extends OperationTool<
     return {
       name: this.name,
       description:
-        'Allows you to send a connection request to a person (st.sendConnectionRequest action).',
+        'Allows you to send a connection request to a person (st.sendConnectionRequest action). If this workflow is still running, do not retry this tool; retrying can queue duplicate connection request attempts for the same person.',
       inputSchema: {
         type: 'object',
         properties: {

package/src/tools/send-message.ts

@@ -15,7 +15,8 @@ export class SendMessageTool extends OperationTool<TSendMessageParams, unknown>
   public override getTool(): Tool {
     return {
       name: this.name,
-      description: 'Allows you to send a message to a person (st.sendMessage action).',
+      description:
+        'Allows you to send a message to a person (st.sendMessage action). If this workflow is still running, do not retry this tool; retrying can send duplicate messages to the same person.',
       inputSchema: {
         type: 'object',
         properties: {

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

@@ -19,7 +19,7 @@ export class WithdrawConnectionRequestTool extends OperationTool<
     return {
       name: this.name,
       description:
-        'Allows you to withdraw the connection request sent to a person (st.withdrawConnectionRequest action).',
+        'Allows you to withdraw the connection request sent to a person (st.withdrawConnectionRequest action). If this workflow is still running, do not retry this tool; retrying can queue duplicate withdrawal attempts for the same person.',
       inputSchema: {
         type: 'object',
         properties: {

package/src/utils/admin-tool.ts

@@ -0,0 +1,22 @@
+import { LinkedApiAdmin } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import z from 'zod';
+
+export abstract class AdminTool<TParams, TResult> {
+  public abstract readonly name: string;
+  protected abstract readonly schema: z.ZodSchema;
+
+  public abstract getTool(): Tool;
+
+  public validate(args: unknown): TParams {
+    return this.schema.parse(args) as TParams;
+  }
+
+  public abstract execute({
+    admin,
+    args,
+  }: {
+    admin: LinkedApiAdmin;
+    args: TParams;
+  }): Promise<TResult>;
+}

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

@@ -1,16 +1,28 @@
 export function defineRequestTimeoutInSeconds(mcpClient: string): number {
-  const bigTimeout = 600;
+  const BIG_TIMEOUT = 600 as const;
+  const normalizedMcpClient = mcpClient.trim().toLowerCase();
 
-  console.error('mcpClient', mcpClient);
-  switch (mcpClient) {
+  switch (normalizedMcpClient) {
+    case 'codex':
+    case 'codex-cli':
+    case 'codex-desktop':
+    case 'openai-codex':
+      return BIG_TIMEOUT;
+    case 'claude-code':
+    case 'claude_code':
+    case 'claude code':
+      return BIG_TIMEOUT;
     case 'claude':
+    case 'claude-desktop':
+    case 'anthropic':
       return 180;
     case 'chatgpt':
+    case 'openai':
       return 50;
     case 'cursor':
     case 'vscode':
     case 'windsurf':
-      return bigTimeout;
+      return BIG_TIMEOUT;
     default:
       return 60;
   }