134 lines
4.9 KiB
TypeScript
134 lines
4.9 KiB
TypeScript
/**
|
|
* List Executions Tool
|
|
*
|
|
* This tool retrieves a list of workflow executions from n8n.
|
|
*/
|
|
|
|
import { BaseExecutionToolHandler } from './base-handler.js';
|
|
import { ToolCallResult, ToolDefinition, Execution } from '../../types/index.js'; // Import Execution type
|
|
import { formatExecutionSummary, summarizeExecutions } from '../../utils/execution-formatter.js';
|
|
|
|
// Define specific type for list arguments based on ToolDefinition
|
|
interface ListExecutionsArgs {
|
|
workflowId?: string;
|
|
status?: 'success' | 'error' | 'waiting' | 'canceled'; // Use specific statuses if known
|
|
limit?: number;
|
|
lastId?: string; // Note: n8n API might not support cursor pagination with lastId easily
|
|
includeSummary?: boolean;
|
|
}
|
|
|
|
/**
|
|
* Handler for the list_executions tool
|
|
*/
|
|
export class ListExecutionsHandler extends BaseExecutionToolHandler {
|
|
/**
|
|
* Execute the tool
|
|
*
|
|
* @param args Tool arguments (workflowId, status, limit, lastId, includeSummary)
|
|
* @returns List of executions
|
|
*/
|
|
async execute(args: ListExecutionsArgs): Promise<ToolCallResult> { // Use specific args type
|
|
return this.handleExecution(async (args) => { // Pass args to handler
|
|
// Fetch all executions first (n8n API might require filtering via query params)
|
|
// TODO: Update apiService.getExecutions to accept filter parameters if possible
|
|
const executions: Execution[] = await this.apiService.getExecutions();
|
|
|
|
// Apply filters locally for now
|
|
let filteredExecutions = executions;
|
|
|
|
// Filter by workflow ID if provided
|
|
if (args.workflowId) {
|
|
filteredExecutions = filteredExecutions.filter(
|
|
(execution: Execution) => execution.workflowId === args.workflowId
|
|
);
|
|
}
|
|
|
|
// Filter by status if provided
|
|
if (args.status) {
|
|
filteredExecutions = filteredExecutions.filter(
|
|
(execution: Execution) => execution.status === args.status
|
|
);
|
|
}
|
|
|
|
// TODO: Implement pagination using lastId if the API supports it.
|
|
// This usually requires sorting and finding the index, or specific API params.
|
|
|
|
// Apply limit if provided (after filtering and potential pagination)
|
|
const limit = args.limit && args.limit > 0 ? args.limit : filteredExecutions.length;
|
|
// Ensure limit is applied correctly after potential pagination logic
|
|
filteredExecutions = filteredExecutions.slice(0, limit);
|
|
|
|
// Format the executions for display
|
|
const formattedExecutions = filteredExecutions.map((execution: Execution) =>
|
|
formatExecutionSummary(execution)
|
|
);
|
|
|
|
// Generate summary if requested (based on the initially fetched, unfiltered list)
|
|
let summary = undefined;
|
|
if (args.includeSummary) {
|
|
// Summarize based on the *original* list before filtering/limiting for accurate stats
|
|
summary = summarizeExecutions(executions);
|
|
}
|
|
|
|
// Prepare response data
|
|
const responseData = {
|
|
// Return the filtered and limited list
|
|
executions: formattedExecutions,
|
|
summary: summary,
|
|
count: formattedExecutions.length, // Count of returned executions
|
|
// Indicate if filters were applied
|
|
filtersApplied: args.workflowId || args.status ? true : false,
|
|
// Note: totalAvailable might be misleading if pagination isn't fully implemented
|
|
totalAvailable: executions.length,
|
|
};
|
|
|
|
return this.formatSuccess(
|
|
responseData,
|
|
`Found ${formattedExecutions.length} execution(s)` + (responseData.filtersApplied ? ' matching filters.' : '.')
|
|
);
|
|
}, args); // Pass args to handleExecution
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get tool definition for the list_executions tool
|
|
*
|
|
* @returns Tool definition
|
|
*/
|
|
export function getListExecutionsToolDefinition(): ToolDefinition {
|
|
return {
|
|
name: 'list_executions',
|
|
description: 'Retrieve a list of workflow executions from n8n, with optional filtering.',
|
|
inputSchema: {
|
|
type: 'object',
|
|
properties: {
|
|
workflowId: {
|
|
type: 'string',
|
|
description: 'Optional ID of workflow to filter executions by',
|
|
},
|
|
status: {
|
|
type: 'string',
|
|
description: 'Optional status to filter by (e.g., success, error, waiting)',
|
|
// Consider using enum if statuses are fixed:
|
|
// enum: ['success', 'error', 'waiting', 'canceled']
|
|
},
|
|
limit: {
|
|
type: 'number',
|
|
description: 'Maximum number of executions to return (default: all matching)',
|
|
},
|
|
// lastId is hard to implement without API support for cursor pagination
|
|
// lastId: {
|
|
// type: 'string',
|
|
// description: 'ID of the last execution for pagination (if supported)',
|
|
// },
|
|
includeSummary: {
|
|
type: 'boolean',
|
|
description: 'Include summary statistics about all executions (before filtering/limiting)',
|
|
default: false,
|
|
},
|
|
},
|
|
required: [],
|
|
},
|
|
};
|
|
}
|