@linkedapi/mcp 2.0.1 → 2.1.1

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

@@ -0,0 +1,65 @@
+import { LinkedApiAdmin, TDeleteLimitsParams } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import z from 'zod';
+
+import { AdminTool } from '../utils/admin-tool.js';
+
+export class AdminDeleteLimitsTool extends AdminTool<TDeleteLimitsParams, void> {
+  public readonly name = 'admin_delete_limits';
+  protected readonly schema = z.object({
+    accountId: z.string(),
+    limits: z.array(
+      z.object({
+        category: z.string(),
+        period: z.enum(['daily', 'weekly', 'monthly']),
+      }),
+    ),
+  });
+
+  public override async execute({
+    admin,
+    args,
+  }: {
+    admin: LinkedApiAdmin;
+    args: TDeleteLimitsParams;
+  }): Promise<void> {
+    await admin.limits.delete(args);
+  }
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Delete specific rate limits for an account. Deleted limits fall back to system defaults.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          accountId: {
+            type: 'string',
+            description: 'Account UUID',
+          },
+          limits: {
+            type: 'array',
+            description: 'Array of limit keys to delete',
+            items: {
+              type: 'object',
+              properties: {
+                category: {
+                  type: 'string',
+                  description: 'Limit category',
+                },
+                period: {
+                  type: 'string',
+                  enum: ['daily', 'weekly', 'monthly'],
+                  description: 'Limit period',
+                },
+              },
+              required: ['category', 'period'],
+            },
+          },
+        },
+        required: ['accountId', 'limits'],
+      },
+    };
+  }
+}

package/src/tools/admin-get-billing-link.ts

@@ -0,0 +1,30 @@
+import { LinkedApiAdmin, TBillingLinkResult } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import z from 'zod';
+
+import { AdminTool } from '../utils/admin-tool.js';
+
+export class AdminGetBillingLinkTool extends AdminTool<Record<string, never>, TBillingLinkResult> {
+  public readonly name = 'admin_get_billing_link';
+  protected readonly schema = z.object({});
+
+  public override async execute({
+    admin,
+  }: {
+    admin: LinkedApiAdmin;
+    args: Record<string, never>;
+  }): Promise<TBillingLinkResult> {
+    return await admin.subscription.getBillingLink();
+  }
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description: 'Get a Stripe billing portal link for the current workspace.',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+      },
+    };
+  }
+}

package/src/tools/admin-get-connection-session.ts

@@ -0,0 +1,46 @@
+import {
+  LinkedApiAdmin,
+  TConnectionSessionResult,
+  TGetConnectionSessionParams,
+} from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import z from 'zod';
+
+import { AdminTool } from '../utils/admin-tool.js';
+
+export class AdminGetConnectionSessionTool extends AdminTool<
+  TGetConnectionSessionParams,
+  TConnectionSessionResult
+> {
+  public readonly name = 'admin_get_connection_session';
+  protected readonly schema = z.object({
+    sessionId: z.string(),
+  });
+
+  public override async execute({
+    admin,
+    args,
+  }: {
+    admin: LinkedApiAdmin;
+    args: TGetConnectionSessionParams;
+  }): Promise<TConnectionSessionResult> {
+    return await admin.accounts.getConnectionSession(args);
+  }
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description: 'Get connection or reconnection session status by session ID.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          sessionId: {
+            type: 'string',
+            description: 'Connection session UUID',
+          },
+        },
+        required: ['sessionId'],
+      },
+    };
+  }
+}

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

@@ -0,0 +1,33 @@
+import { LinkedApiAdmin, TLimit } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import z from 'zod';
+
+import { AdminTool } from '../utils/admin-tool.js';
+
+export class AdminGetLimitsDefaultsTool extends AdminTool<
+  Record<string, never>,
+  { limits: Array<TLimit> }
+> {
+  public readonly name = 'admin_get_limits_defaults';
+  protected readonly schema = z.object({});
+
+  public override async execute({
+    admin,
+  }: {
+    admin: LinkedApiAdmin;
+    args: Record<string, never>;
+  }): Promise<{ limits: Array<TLimit> }> {
+    return await admin.limits.getDefaults();
+  }
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description: 'Get system default rate limits.',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+      },
+    };
+  }
+}

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

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

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

@@ -0,0 +1,33 @@
+import { LinkedApiAdmin, TSubscriptionProduct } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import z from 'zod';
+
+import { AdminTool } from '../utils/admin-tool.js';
+
+export class AdminGetSubscriptionPricingTool extends AdminTool<
+  Record<string, never>,
+  { products: Array<TSubscriptionProduct> }
+> {
+  public readonly name = 'admin_get_subscription_pricing';
+  protected readonly schema = z.object({});
+
+  public override async execute({
+    admin,
+  }: {
+    admin: LinkedApiAdmin;
+    args: Record<string, never>;
+  }): Promise<{ products: Array<TSubscriptionProduct> }> {
+    return await admin.subscription.getPricing();
+  }
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description: 'Get available subscription products and prices.',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+      },
+    };
+  }
+}

package/src/tools/admin-reparse-account-info.ts

@@ -0,0 +1,47 @@
+import {
+  LinkedApiAdmin,
+  TReparseAccountInfoParams,
+  TReparseAccountInfoResult,
+} from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import z from 'zod';
+
+import { AdminTool } from '../utils/admin-tool.js';
+
+export class AdminReparseAccountInfoTool extends AdminTool<
+  TReparseAccountInfoParams,
+  TReparseAccountInfoResult
+> {
+  public readonly name = 'admin_reparse_account_info';
+  protected readonly schema = z.object({
+    accountId: z.string(),
+  });
+
+  public override async execute({
+    admin,
+    args,
+  }: {
+    admin: LinkedApiAdmin;
+    args: TReparseAccountInfoParams;
+  }): Promise<TReparseAccountInfoResult> {
+    return await admin.accounts.reparseAccountInfo(args);
+  }
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Refresh stored profile information for a connected account. Starts a background reparse workflow and returns workflowId.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          accountId: {
+            type: 'string',
+            description: 'UUID of the account to refresh',
+          },
+        },
+        required: ['accountId'],
+      },
+    };
+  }
+}

package/src/tools/fetch-job.ts

@@ -0,0 +1,32 @@
+import { OPERATION_NAME, TBaseFetchJobParams } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class FetchJobTool extends OperationTool<TBaseFetchJobParams, unknown> {
+  public override readonly name = 'fetch_job';
+  public override readonly operationName = OPERATION_NAME.fetchJob;
+  protected override readonly schema = z.object({
+    jobUrl: z.string(),
+  });
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Open a LinkedIn job and retrieve its details such as company, location, salary, and description (st.openJob action).',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          jobUrl: {
+            type: 'string',
+            description:
+              "LinkedIn URL of the job. (e.g., 'https://www.linkedin.com/jobs/view/4416248954/')",
+          },
+        },
+        required: ['jobUrl'],
+      },
+    };
+  }
+}

package/src/tools/search-jobs.ts

@@ -0,0 +1,172 @@
+import { OPERATION_NAME, TSearchJobsParams } from '@linkedapi/node';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+
+import { OperationTool } from '../utils/linked-api-tool.js';
+
+export class SearchJobsTool extends OperationTool<TSearchJobsParams, unknown> {
+  public override readonly name = 'search_jobs';
+  public override readonly operationName = OPERATION_NAME.searchJobs;
+  protected override readonly schema = z.object({
+    term: z.string().optional(),
+    limit: z.number().min(1).max(1000).optional(),
+    filter: z
+      .object({
+        location: z.string().optional(),
+        datePosted: z.enum(['anyTime', 'past24Hours', 'pastWeek', 'pastMonth']).optional(),
+        experienceLevels: z
+          .array(
+            z.enum([
+              'internship',
+              'entryLevel',
+              'associate',
+              'midSeniorLevel',
+              'director',
+              'executive',
+            ]),
+          )
+          .optional(),
+        employmentTypes: z
+          .array(
+            z.enum([
+              'fullTime',
+              'partTime',
+              'contract',
+              'temporary',
+              'volunteer',
+              'internship',
+              'other',
+            ]),
+          )
+          .optional(),
+        workplaceTypes: z.array(z.enum(['onSite', 'remote', 'hybrid'])).optional(),
+        companies: z.array(z.string()).optional(),
+        industries: z.array(z.string()).optional(),
+        jobFunctions: z.array(z.string()).optional(),
+        easyApply: z.boolean().optional(),
+        hasVerifications: z.boolean().optional(),
+        under10Applicants: z.boolean().optional(),
+        inYourNetwork: z.boolean().optional(),
+        fairChanceEmployer: z.boolean().optional(),
+      })
+      .optional(),
+    customSearchUrl: z.string().optional(),
+  });
+
+  public override getTool(): Tool {
+    return {
+      name: this.name,
+      description:
+        'Allows you to search jobs applying various filtering criteria (st.searchJobs 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 jobs. When multiple filter fields are specified, they are combined using AND logic.',
+            properties: {
+              location: {
+                type: 'string',
+                description: 'Optional. Free-form location string.',
+              },
+              datePosted: {
+                type: 'string',
+                enum: ['anyTime', 'past24Hours', 'pastWeek', 'pastMonth'],
+                description: 'Optional. How recently the job was posted.',
+              },
+              experienceLevels: {
+                type: 'array',
+                description: 'Optional. Array of experience levels.',
+                items: {
+                  type: 'string',
+                  enum: [
+                    'internship',
+                    'entryLevel',
+                    'associate',
+                    'midSeniorLevel',
+                    'director',
+                    'executive',
+                  ],
+                },
+              },
+              employmentTypes: {
+                type: 'array',
+                description: 'Optional. Array of employment types.',
+                items: {
+                  type: 'string',
+                  enum: [
+                    'fullTime',
+                    'partTime',
+                    'contract',
+                    'temporary',
+                    'volunteer',
+                    'internship',
+                    'other',
+                  ],
+                },
+              },
+              workplaceTypes: {
+                type: 'array',
+                description: 'Optional. Array of workplace types.',
+                items: {
+                  type: 'string',
+                  enum: ['onSite', 'remote', 'hybrid'],
+                },
+              },
+              companies: {
+                type: 'array',
+                description: 'Optional. Array of company names.',
+                items: { type: 'string' },
+              },
+              industries: {
+                type: 'array',
+                description: 'Optional. Array of industry names.',
+                items: { type: 'string' },
+              },
+              jobFunctions: {
+                type: 'array',
+                description: 'Optional. Array of job function names.',
+                items: { type: 'string' },
+              },
+              easyApply: {
+                type: 'boolean',
+                description: 'Optional. When true, only jobs with Easy Apply.',
+              },
+              hasVerifications: {
+                type: 'boolean',
+                description: 'Optional. When true, only jobs with verification signals.',
+              },
+              under10Applicants: {
+                type: 'boolean',
+                description: 'Optional. When true, only jobs with fewer than 10 applicants.',
+              },
+              inYourNetwork: {
+                type: 'boolean',
+                description: 'Optional. When true, only jobs from your network.',
+              },
+              fairChanceEmployer: {
+                type: 'boolean',
+                description: 'Optional. When true, only fair chance employer jobs.',
+              },
+            },
+          },
+          customSearchUrl: {
+            type: 'string',
+            description:
+              'Optional. URL copied from a LinkedIn jobs search page. When specified, overrides term and filter.',
+          },
+        },
+      },
+    };
+  }
+}