@linkedapi/mcp 1.0.1 → 2.0.0

package/src/linked-api-tools.ts

@@ -1,4 +1,4 @@
-import LinkedApi, { TMappedResponse } from '@linkedapi/node';
+import LinkedApi from '@linkedapi/node';
 import { Tool } from '@modelcontextprotocol/sdk/types.js';
 
 import { AdminConnectAccountTool } from './tools/admin-connect-account.js';
@@ -38,26 +38,18 @@ import { SearchPeopleTool } from './tools/search-people.js';
 import { SendConnectionRequestTool } from './tools/send-connection-request.js';
 import { SendMessageTool } from './tools/send-message.js';
 import { WithdrawConnectionRequestTool } from './tools/withdraw-connection-request.js';
+import type { TLinkedApiToolResult } from './types/linked-api-tool-result.type.js';
 import { AdminTool } from './utils/admin-tool.js';
-import { LinkedApiProgressNotification } from './utils/types.js';
 
 interface TRegisteredLinkedApiTool {
   readonly name: string;
   getTool(): Tool;
   validate(args: unknown): unknown;
-  execute({
-    linkedapi,
-    args,
-    workflowTimeout,
-    progressToken,
-    progressCallback,
-  }: {
+  execute(options: {
     linkedapi: LinkedApi;
     args: never;
-    workflowTimeout: number;
-    progressToken?: string | number;
-    progressCallback: (progress: LinkedApiProgressNotification) => void;
-  }): Promise<TMappedResponse<unknown>>;
+    mcpClient: string;
+  }): Promise<TLinkedApiToolResult<unknown>>;
 }
 
 export class LinkedApiTools {

package/src/prompts/index.ts

@@ -33,7 +33,7 @@ LINKEDIN WORKFLOWS RUN IN THE BACKGROUND:
 - Simply continue listening for updates using get_workflow_result
 
 WHEN A WORKFLOW IS RUNNING IN BACKGROUND:
-1. You'll receive a status message with: workflowId and operationName
+1. You'll receive a status message with: workflowId, status, message, and operationName
 2. Use get_workflow_result(workflowId, operationName) to continue listening for updates
 3. Keep listening until you get the final results
 4. This is normal workflow operation - the task is actively running
@@ -41,6 +41,7 @@ WHEN A WORKFLOW IS RUNNING IN BACKGROUND:
 EXAMPLE BACKGROUND WORKFLOW MESSAGE:
 {
   "message": "Workflow is running in the background. Continue listening for updates.",
+  "status": "running",
   "workflowId": "account-12345-abcde",
   "operationName": "searchCompanies"
 }
@@ -113,6 +114,7 @@ WHAT TO DO WHEN WORKFLOW RUNS IN BACKGROUND:
 EXAMPLE BACKGROUND WORKFLOW MESSAGE:
 {
   "message": "Workflow is running in the background. Continue listening for updates.",
+  "status": "running",
   "workflowId": "account-12345-abcde", 
   "operationName": "searchCompanies"
 }

package/src/tools/get-api-usage-stats.ts

@@ -17,8 +17,6 @@ export class GetApiUsageTool extends LinkedApiTool<TApiUsageParams, TApiUsageAct
   }: {
     linkedapi: LinkedApi;
     args: TApiUsageParams;
-    workflowTimeout: number;
-    progressToken?: string | number;
   }): Promise<TMappedResponse<TApiUsageAction[]>> {
     return await linkedapi.getApiUsage(args);
   }

package/src/tools/get-conversation.ts

@@ -1,14 +1,13 @@
 import LinkedApi, {
-  LinkedApiWorkflowTimeoutError,
+  OPERATION_NAME,
   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 type { TWorkflowAck } from '../types/linked-api-tool-result.type.js';
 import { LinkedApiTool } from '../utils/linked-api-tool.js';
-import { LinkedApiProgressNotification } from '../utils/types.js';
 
 export class GetConversationTool extends LinkedApiTool<
   { personUrl: string; since?: string },
@@ -23,40 +22,20 @@ 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);
+  }): Promise<TMappedResponse<TConversationPollResult> | TWorkflowAck> {
+    const conversations = await this.pollConversation(linkedapi, personUrl, since);
     if (conversations.errors.length === 0) {
       return conversations;
     }
-    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);
+    const ack = await linkedapi.syncConversation.execute({ personUrl });
+    return { ...ack,
+operationName: OPERATION_NAME.syncConversation };
   }
 
-  private async getConversation(
+  private async pollConversation(
     linkedapi: LinkedApi,
     personUrl: string,
     since?: string,
@@ -78,7 +57,7 @@ After get_workflow_result completes this sync workflow, call get_conversation ag
     return {
       name: this.name,
       description:
-        'Allows you to get a conversation with a LinkedIn person using standard LinkedIn messaging.',
+        'Retrieve a conversation with a LinkedIn person via standard LinkedIn messaging. Returns the conversation immediately if it has already been synced. If the conversation has not been synced yet, this tool starts a syncConversation workflow and returns its ack ({status, workflowId, operationName: "syncConversation", message}); the client should call get_workflow_result with that workflowId until completion, then call get_conversation again to read the synced messages.',
       inputSchema: {
         type: 'object',
         properties: {

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

@@ -1,14 +1,24 @@
-import LinkedApi, { OPERATION_NAME, TMappedResponse } from '@linkedapi/node';
+import LinkedApi, {
+  Operation,
+  OPERATION_NAME,
+  TMappedResponse,
+  TOperationName,
+  TWorkflowInProgressResponse,
+} from '@linkedapi/node';
 import { Tool } from '@modelcontextprotocol/sdk/types.js';
 import z from 'zod';
 
-import { executeWithProgress } from '../utils/execute-with-progress.js';
+import type { TWorkflowAck } from '../types/linked-api-tool-result.type.js';
+import { defineRequestTimeoutInSeconds } from '../utils/define-request-timeout.js';
 import { LinkedApiTool } from '../utils/linked-api-tool.js';
-import { LinkedApiProgressNotification } from '../utils/types.js';
+
+const POLL_INTERVAL_MS = 5000 as const;
+const REQUEST_BUDGET_BUFFER_SECONDS = 5 as const;
 
 interface IGetWorkflowResultParams {
   workflowId: string;
   operationName: string;
+  waitSeconds?: number;
 }
 
 export class GetWorkflowResultTool extends LinkedApiTool<IGetWorkflowResultParams, unknown> {
@@ -16,50 +26,66 @@ export class GetWorkflowResultTool extends LinkedApiTool<IGetWorkflowResultParam
   protected readonly schema = z.object({
     workflowId: z.string(),
     operationName: z.enum(Object.values(OPERATION_NAME)),
+    waitSeconds: z.number().int().min(0).optional(),
   });
 
   public override async execute({
     linkedapi,
-    args: { workflowId, operationName },
-    workflowTimeout,
-    progressToken,
-    progressCallback,
+    args: { workflowId, operationName, waitSeconds },
+    mcpClient,
   }: {
     linkedapi: LinkedApi;
     args: IGetWorkflowResultParams;
-    workflowTimeout: number;
-    progressToken?: string | number;
-    progressCallback: (progress: LinkedApiProgressNotification) => void;
-  }): Promise<TMappedResponse<unknown>> {
+    mcpClient: string;
+  }): Promise<TMappedResponse<unknown> | TWorkflowAck> {
+    const typedOperationName = operationName as TOperationName;
     const operation = linkedapi.operations.find(
-      (operation) => operation.operationName === operationName,
-    )!;
-    return await executeWithProgress({
-      progressCallback,
-      operation,
-      workflowTimeout,
-      workflowId,
-      progressToken,
-    });
+      (operation) => operation.operationName === typedOperationName,
+    )! as Operation<unknown, unknown>;
+
+    const cap = Math.max(
+      defineRequestTimeoutInSeconds(mcpClient) - REQUEST_BUDGET_BUFFER_SECONDS,
+      0,
+    );
+    const budgetSeconds = Math.min(waitSeconds ?? cap, cap);
+    const deadline = Date.now() + budgetSeconds * 1000;
+
+    while (true) {
+      const status = await operation.status(workflowId);
+      if (!isWorkflowInProgress(status)) {
+        return status;
+      }
+      const remainingMs = deadline - Date.now();
+      if (remainingMs <= 0) {
+        return { ...status,
+workflowId,
+operationName: typedOperationName };
+      }
+      await sleep(Math.min(POLL_INTERVAL_MS, remainingMs));
+    }
   }
 
   public override getTool(): Tool {
     return {
       name: this.name,
       description:
-        'CONTINUE LISTENING TO BACKGROUND WORKFLOW - THIS IS NORMAL OPERATION! Background workflows are OPTIMAL BEHAVIOR for Linked API operations and keep the MCP client responsive. When a workflow runs in the background, this tool should be used with the provided workflowId and operationName parameters to continue listening for updates. The workflow continues processing in the background while you wait. This is the STANDARD way Linked API works - background processing provides optimal user experience!',
+        'Check the current state of a previously started Linked API workflow. Returns the final result when the workflow has completed, otherwise returns the current in-progress snapshot ({status, workflowId, operationName, message}). The server long-polls up to waitSeconds while the workflow is still running; if the budget elapses without completion, the in-progress snapshot is returned and the client should call this tool again with the same workflowId and operationName.',
       inputSchema: {
         type: 'object',
         properties: {
           workflowId: {
             type: 'string',
-            description:
-              'Required. The workflow ID provided in the background workflow status message.',
+            description: 'Required. The workflow ID returned by the original Linked API tool call.',
           },
           operationName: {
             type: 'string',
             description:
-              'Required. The operationName provided in the background workflow status message. Use the exact value so the result can be restored correctly.',
+              'Required. The operationName returned by the original Linked API tool call. Used to map the response to the right operation.',
+          },
+          waitSeconds: {
+            type: 'number',
+            description:
+              'Optional. Maximum seconds the server should wait for the workflow to complete before returning the current in-progress snapshot. Defaults to the maximum the current MCP client allows; pass 0 to get an immediate one-shot snapshot.',
           },
         },
         required: ['workflowId', 'operationName'],
@@ -67,3 +93,16 @@ export class GetWorkflowResultTool extends LinkedApiTool<IGetWorkflowResultParam
     };
   }
 }
+
+function isWorkflowInProgress(
+  result: TMappedResponse<unknown> | TWorkflowInProgressResponse,
+): result is TWorkflowInProgressResponse {
+  return (
+    'workflowStatus' in result &&
+    (result.workflowStatus === 'running' || result.workflowStatus === 'pending')
+  );
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

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

@@ -1,14 +1,13 @@
 import LinkedApi, {
-  LinkedApiWorkflowTimeoutError,
+  OPERATION_NAME,
   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 type { TWorkflowAck } from '../types/linked-api-tool-result.type.js';
 import { LinkedApiTool } from '../utils/linked-api-tool.js';
-import { LinkedApiProgressNotification } from '../utils/types.js';
 
 export class NvGetConversationTool extends LinkedApiTool<
   { personUrl: string; since?: string },
@@ -23,40 +22,20 @@ 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);
+  }): Promise<TMappedResponse<TConversationPollResult> | TWorkflowAck> {
+    const conversations = await this.pollConversation(linkedapi, personUrl, since);
     if (conversations.errors.length === 0) {
       return conversations;
     }
-    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);
+    const ack = await linkedapi.nvSyncConversation.execute({ personUrl });
+    return { ...ack,
+operationName: OPERATION_NAME.nvSyncConversation };
   }
 
-  private async getConversation(
+  private async pollConversation(
     linkedapi: LinkedApi,
     personUrl: string,
     since?: string,
@@ -78,7 +57,7 @@ After get_workflow_result completes this sync workflow, call nv_get_conversation
     return {
       name: this.name,
       description:
-        'Allows you to get a conversation with a LinkedIn person using Sales Navigator messaging.',
+        'Retrieve a conversation with a LinkedIn person via Sales Navigator messaging. Returns the conversation immediately if it has already been synced. If the conversation has not been synced yet, this tool starts an nvSyncConversation workflow and returns its ack ({status, workflowId, operationName: "nvSyncConversation", message}); the client should call get_workflow_result with that workflowId until completion, then call nv_get_conversation again to read the synced messages.',
       inputSchema: {
         type: 'object',
         properties: {

package/src/types/linked-api-tool-result.type.ts

@@ -0,0 +1,12 @@
+import type {
+  TMappedResponse,
+  TOperationName,
+  TWorkflowInProgressResponse,
+  TWorkflowStartedResponse,
+} from '@linkedapi/node';
+
+export type TWorkflowAck = (TWorkflowStartedResponse | TWorkflowInProgressResponse) & {
+  operationName: TOperationName;
+};
+
+export type TLinkedApiToolResult<TResult> = TWorkflowAck | TMappedResponse<TResult>;

package/src/utils/handle-linked-api-error.ts

@@ -1,27 +1,8 @@
-import { LinkedApiError, LinkedApiWorkflowTimeoutError } from '@linkedapi/node';
+import { LinkedApiError } from '@linkedapi/node';
 
 import { authenticationPrompt } from '../prompts';
 
 export function handleLinkedApiError(error: LinkedApiError): Record<string, unknown> {
-  if (error instanceof LinkedApiWorkflowTimeoutError) {
-    const { message, workflowId, operationName } = error;
-    return {
-      status: 'workflow_running',
-      message,
-      workflowId,
-      operationName,
-      nextAction: {
-        tool: 'get_workflow_result',
-        arguments: {
-          workflowId,
-          operationName,
-        },
-        repeatUntil: 'final data is returned or the tool returns Completed',
-      },
-      userMessage:
-        'Linked API is still working through the cloud-browser workflow. I will keep checking the existing workflow instead of starting a duplicate request.',
-    };
-  }
   switch (error.type) {
     case 'identificationTokenRequired':
     case 'linkedApiTokenRequired':

package/src/utils/linked-api-tool.ts

@@ -1,16 +1,13 @@
-import LinkedApi, { Operation, TMappedResponse, TOperationName } from '@linkedapi/node';
+import LinkedApi, { Operation, TOperationName } from '@linkedapi/node';
 import { Tool } from '@modelcontextprotocol/sdk/types.js';
-import { LinkedApiProgressNotification } from 'src/utils/types';
 import z from 'zod';
 
-import { executeWithProgress } from './execute-with-progress';
+import type { TLinkedApiToolResult, TWorkflowAck } from '../types/linked-api-tool-result.type.js';
 
 interface TLinkedApiToolExecuteOptions<TParams> {
   linkedapi: LinkedApi;
   args: TParams;
-  workflowTimeout: number;
-  progressToken?: string | number;
-  progressCallback: (progress: LinkedApiProgressNotification) => void;
+  mcpClient: string;
 }
 
 export abstract class LinkedApiTool<TParams, TResult> {
@@ -23,34 +20,23 @@ export abstract class LinkedApiTool<TParams, TResult> {
     return this.schema.parse(args) as TParams;
   }
 
-  public abstract execute({
-    linkedapi,
-    args,
-    workflowTimeout,
-    progressToken,
-    progressCallback,
-  }: TLinkedApiToolExecuteOptions<TParams>): Promise<TMappedResponse<TResult>>;
+  public abstract execute(
+    options: TLinkedApiToolExecuteOptions<TParams>,
+  ): Promise<TLinkedApiToolResult<TResult>>;
 }
 
 export abstract class OperationTool<TParams, TResult> extends LinkedApiTool<TParams, TResult> {
   public abstract readonly operationName: TOperationName;
 
-  public override execute({
+  public override async execute({
     linkedapi,
     args,
-    workflowTimeout,
-    progressToken,
-    progressCallback,
-  }: TLinkedApiToolExecuteOptions<TParams>): Promise<TMappedResponse<TResult>> {
+  }: TLinkedApiToolExecuteOptions<TParams>): Promise<TWorkflowAck> {
     const operation = linkedapi.operations.find(
       (operation) => operation.operationName === this.operationName,
     )! as Operation<TParams, TResult>;
-    return executeWithProgress({
-      progressCallback,
-      operation,
-      workflowTimeout,
-      params: args,
-      progressToken,
-    });
+    const response = await operation.execute(args);
+    return { ...response,
+operationName: this.operationName };
   }
 }

package/src/utils/types.ts

@@ -9,9 +9,3 @@ export interface ExtendedCallToolRequest extends CallToolRequest {
     };
   };
 }
-export interface LinkedApiProgressNotification {
-  progressToken?: string | number;
-  progress: number;
-  total?: number;
-  message?: string;
-}

package/dist/utils/execute-with-progress.d.ts

@@ -1,13 +0,0 @@
-import { Operation, TMappedResponse } from '@linkedapi/node';
-import { LinkedApiProgressNotification } from './types';
-interface TExecuteWithProgressOptions<TParams, TResult> {
-    progressCallback: (progress: LinkedApiProgressNotification) => void;
-    operation: Operation<TParams, TResult>;
-    workflowTimeout: number;
-    params?: TParams;
-    workflowId?: string;
-    progressToken?: string | number;
-}
-export declare function executeWithProgress<TParams, TResult>({ progressCallback, operation, workflowTimeout, params, workflowId, progressToken, }: TExecuteWithProgressOptions<TParams, TResult>): Promise<TMappedResponse<TResult>>;
-export {};
-//# sourceMappingURL=execute-with-progress.d.ts.map

package/dist/utils/execute-with-progress.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"execute-with-progress.d.ts","sourceRoot":"","sources":["../../src/utils/execute-with-progress.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiC,SAAS,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAE5F,OAAO,EAAE,6BAA6B,EAAE,MAAM,SAAS,CAAC;AAKxD,UAAU,2BAA2B,CAAC,OAAO,EAAE,OAAO;IACpD,gBAAgB,EAAE,CAAC,QAAQ,EAAE,6BAA6B,KAAK,IAAI,CAAC;IACpE,SAAS,EAAE,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IACvC,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CACjC;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,EAC1D,gBAAgB,EAChB,SAAS,EACT,eAAe,EACf,MAAM,EACN,UAAU,EACV,aAAa,GACd,EAAE,2BAA2B,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CA2DnF"}

package/dist/utils/execute-with-progress.js

@@ -1,85 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeWithProgress = executeWithProgress;
-const node_1 = require("@linkedapi/node");
-const WORKFLOW_PROGRESS_TOTAL = 100;
-const MIN_PROGRESS_INTERVAL = 10000;
-async function executeWithProgress({ progressCallback, operation, workflowTimeout, params, workflowId, progressToken, }) {
-    let progress = 0;
-    progressCallback({
-        progressToken,
-        progress,
-        total: WORKFLOW_PROGRESS_TOTAL,
-        message: `Starting Linked API workflow ${operation.operationName}. The action may enter the cloud-browser queue and take several minutes.`,
-    });
-    const interval = setInterval(() => {
-        if (progress < 50) {
-            progress += 5;
-        }
-        else if (progress < 98) {
-            progress += 1;
-        }
-        progressCallback({
-            progressToken,
-            progress,
-            total: WORKFLOW_PROGRESS_TOTAL,
-            message: `Waiting for workflow ${operation.operationName}. Linked API is still processing it in the background.`,
-        });
-    }, Math.max(workflowTimeout / 20, MIN_PROGRESS_INTERVAL));
-    try {
-        if (!workflowId) {
-            workflowId = await operation.execute(params);
-            progressCallback({
-                progressToken,
-                progress,
-                total: WORKFLOW_PROGRESS_TOTAL,
-                message: `Workflow ${operation.operationName} is queued or running in the background. workflowId: ${workflowId}.`,
-            });
-        }
-        const result = await operation.result(workflowId, {
-            timeout: workflowTimeout,
-        });
-        clearInterval(interval);
-        progressCallback({
-            progressToken,
-            progress: WORKFLOW_PROGRESS_TOTAL,
-            total: WORKFLOW_PROGRESS_TOTAL,
-            message: `Workflow ${operation.operationName} completed successfully`,
-        });
-        return result;
-    }
-    catch (error) {
-        clearInterval(interval);
-        if (error instanceof node_1.LinkedApiWorkflowTimeoutError) {
-            throw generateTimeoutError(error);
-        }
-        throw error;
-    }
-}
-function generateTimeoutError(error) {
-    const restoreMessage = `Workflow is still running in Linked API's cloud-browser queue or background worker.
-
-This is not a failure. The original tool already started the workflow, so retrying it can create duplicate queued work.
-
-ACTION REQUIRED (MCP CLIENT):
-- Do not retry the original tool; the workflow is already running
-- Call the get_workflow_result tool with the parameters below and keep listening until completion
-
-PARAMETERS TO USE:
-- workflowId: ${error.workflowId}
-- operationName: ${error.operationName}
-
-GENERIC MCP CALL EXAMPLE:
-{
-  "name": "get_workflow_result",
-  "arguments": {
-    "workflowId": "${error.workflowId}",
-    "operationName": "${error.operationName}"
-  }
-}
-
-Background processing keeps the MCP client responsive while the workflow completes.`;
-    error.message = restoreMessage;
-    return error;
-}
-//# sourceMappingURL=execute-with-progress.js.map

package/dist/utils/execute-with-progress.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"execute-with-progress.js","sourceRoot":"","sources":["../../src/utils/execute-with-progress.ts"],"names":[],"mappings":";;AAgBA,kDAkEC;AAlFD,0CAA4F;AAI5F,MAAM,uBAAuB,GAAG,GAAY,CAAC;AAC7C,MAAM,qBAAqB,GAAG,KAAc,CAAC;AAWtC,KAAK,UAAU,mBAAmB,CAAmB,EAC1D,gBAAgB,EAChB,SAAS,EACT,eAAe,EACf,MAAM,EACN,UAAU,EACV,aAAa,GACiC;IAC9C,IAAI,QAAQ,GAAG,CAAC,CAAC;IAEjB,gBAAgB,CAAC;QACf,aAAa;QACb,QAAQ;QACR,KAAK,EAAE,uBAAuB;QAC9B,OAAO,EAAE,gCAAgC,SAAS,CAAC,aAAa,0EAA0E;KAC3I,CAAC,CAAC;IAEH,MAAM,QAAQ,GAAG,WAAW,CAC1B,GAAG,EAAE;QACH,IAAI,QAAQ,GAAG,EAAE,EAAE,CAAC;YAClB,QAAQ,IAAI,CAAC,CAAC;QAChB,CAAC;aAAM,IAAI,QAAQ,GAAG,EAAE,EAAE,CAAC;YACzB,QAAQ,IAAI,CAAC,CAAC;QAChB,CAAC;QAED,gBAAgB,CAAC;YACf,aAAa;YACb,QAAQ;YACR,KAAK,EAAE,uBAAuB;YAC9B,OAAO,EAAE,wBAAwB,SAAS,CAAC,aAAa,wDAAwD;SACjH,CAAC,CAAC;IACL,CAAC,EACD,IAAI,CAAC,GAAG,CAAC,eAAe,GAAG,EAAE,EAAE,qBAAqB,CAAC,CACtD,CAAC;IAEF,IAAI,CAAC;QACH,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,UAAU,GAAG,MAAM,SAAS,CAAC,OAAO,CAAC,MAAiB,CAAC,CAAC;YACxD,gBAAgB,CAAC;gBACf,aAAa;gBACb,QAAQ;gBACR,KAAK,EAAE,uBAAuB;gBAC9B,OAAO,EAAE,YAAY,SAAS,CAAC,aAAa,wDAAwD,UAAU,GAAG;aAClH,CAAC,CAAC;QACL,CAAC;QACD,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,MAAM,CAAC,UAAU,EAAE;YAChD,OAAO,EAAE,eAAe;SACzB,CAAC,CAAC;QACH,aAAa,CAAC,QAAQ,CAAC,CAAC;QAExB,gBAAgB,CAAC;YACf,aAAa;YACb,QAAQ,EAAE,uBAAuB;YACjC,KAAK,EAAE,uBAAuB;YAC9B,OAAO,EAAE,YAAY,SAAS,CAAC,aAAa,yBAAyB;SACtE,CAAC,CAAC;QAEH,OAAO,MAAM,CAAC;IAChB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,aAAa,CAAC,QAAQ,CAAC,CAAC;QACxB,IAAI,KAAK,YAAY,oCAA6B,EAAE,CAAC;YACnD,MAAM,oBAAoB,CAAC,KAAK,CAAC,CAAC;QACpC,CAAC;QAED,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC;AAED,SAAS,oBAAoB,CAAC,KAAoC;IAChE,MAAM,cAAc,GAAG;;;;;;;;;gBAST,KAAK,CAAC,UAAU;mBACb,KAAK,CAAC,aAAa;;;;;;qBAMjB,KAAK,CAAC,UAAU;wBACb,KAAK,CAAC,aAAa;;;;oFAIyC,CAAC;IAEnF,KAAK,CAAC,OAAO,GAAG,cAAc,CAAC;IAC/B,OAAO,KAAK,CAAC;AACf,CAAC"}