/**
* Run Procedure Tool Handler
* Executes a procedure on Komodo
*/
import type { KomodoClient } from '../../core/KomodoClient';
import { Logger } from '../../utils/logger';
export interface ProcedureOptions {
async?: boolean;
timeout?: number;
}
export interface RunProcedureRequest {
id: string;
variables?: Record<string, string>;
options?: ProcedureOptions;
}
export interface ProcedureStepResult {
step: number;
name: string;
status: 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
output?: string;
error?: string;
duration?: number;
}
export interface RunProcedureResponse {
success: boolean;
procedureId: string;
executionId?: string;
status: 'queued' | 'running' | 'completed' | 'failed' | 'partial';
message: string;
startedAt?: string;
completedAt?: string;
duration?: number;
steps?: ProcedureStepResult[];
variables?: Record<string, string>;
output?: string;
}
/**
* Run a procedure
*/
export async function runProcedure(
client: KomodoClient,
request: RunProcedureRequest
): Promise<RunProcedureResponse> {
const logger = Logger.getInstance();
try {
logger.info('Running procedure', {
procedureId: request.id,
hasVariables: !!request.variables
});
const payload = {
variables: request.variables,
...request.options
};
const response = await client.post<RunProcedureResponse>(
`/execute/procedure/${request.id}`,
payload
);
logger.info('Procedure execution initiated', {
procedureId: request.id,
executionId: response.executionId,
status: response.status,
stepCount: response.steps?.length
});
return response;
} catch (error) {
logger.error('Failed to run procedure', {
procedureId: request.id,
error: error instanceof Error ? error.message : String(error)
});
throw error;
}
}
