@exaudeus/workrail 0.8.5 → 0.9.0

package/dist/config/feature-flags.js

@@ -1,7 +1,17 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StaticFeatureFlagProvider = exports.EnvironmentFeatureFlagProvider = exports.FEATURE_FLAG_DEFINITIONS = void 0;
+exports.StaticFeatureFlagProvider = exports.CustomEnvFeatureFlagProvider = exports.EnvironmentFeatureFlagProvider = exports.FEATURE_FLAG_DEFINITIONS = void 0;
 exports.createFeatureFlagProvider = createFeatureFlagProvider;
+const tsyringe_1 = require("tsyringe");
 exports.FEATURE_FLAG_DEFINITIONS = [
     {
         key: 'sessionTools',
@@ -35,6 +45,22 @@ exports.FEATURE_FLAG_DEFINITIONS = [
         since: '0.8.3',
         stable: false,
     },
+    {
+        key: 'authoritativeDescriptions',
+        envVar: 'WORKRAIL_AUTHORITATIVE_DESCRIPTIONS',
+        defaultValue: false,
+        description: 'Use imperative/mandatory language in tool descriptions to improve agent workflow compliance',
+        since: '0.9.0',
+        stable: false,
+    },
+    {
+        key: 'v2Tools',
+        envVar: 'WORKRAIL_ENABLE_V2_TOOLS',
+        defaultValue: false,
+        description: 'Enable WorkRail v2 MCP tools (Slice 1: list_workflows, inspect_workflow) behind an explicit opt-in flag',
+        since: '0.9.0',
+        stable: false,
+    },
 ];
 function parseBoolean(value, defaultValue) {
     if (value === undefined) {
@@ -54,14 +80,17 @@ function parseBoolean(value, defaultValue) {
         `Using default: ${defaultValue}`);
     return defaultValue;
 }
-class EnvironmentFeatureFlagProvider {
-    constructor(env = process.env) {
-        const flags = {};
-        for (const definition of exports.FEATURE_FLAG_DEFINITIONS) {
-            const envValue = env[definition.envVar];
-            flags[definition.key] = parseBoolean(envValue, definition.defaultValue);
-        }
-        this.flags = flags;
+function buildFlags(envSource) {
+    const flags = {};
+    for (const definition of exports.FEATURE_FLAG_DEFINITIONS) {
+        const envValue = envSource[definition.envVar];
+        flags[definition.key] = parseBoolean(envValue, definition.defaultValue);
+    }
+    return flags;
+}
+let EnvironmentFeatureFlagProvider = class EnvironmentFeatureFlagProvider {
+    constructor() {
+        this.flags = buildFlags(process.env);
         const enabledExperimental = exports.FEATURE_FLAG_DEFINITIONS
             .filter(def => !def.stable && this.flags[def.key])
             .map(def => def.key);
@@ -69,6 +98,9 @@ class EnvironmentFeatureFlagProvider {
             console.error(`[FeatureFlags] Experimental features enabled: ${enabledExperimental.join(', ')}`);
         }
     }
+    static withEnv(env) {
+        return new CustomEnvFeatureFlagProvider(env);
+    }
     isEnabled(key) {
         return this.flags[key] ?? false;
     }
@@ -87,8 +119,36 @@ class EnvironmentFeatureFlagProvider {
         }
         return lines.join('\n');
     }
-}
+};
 exports.EnvironmentFeatureFlagProvider = EnvironmentFeatureFlagProvider;
+exports.EnvironmentFeatureFlagProvider = EnvironmentFeatureFlagProvider = __decorate([
+    (0, tsyringe_1.singleton)(),
+    __metadata("design:paramtypes", [])
+], EnvironmentFeatureFlagProvider);
+class CustomEnvFeatureFlagProvider {
+    constructor(env) {
+        this.flags = buildFlags(env);
+    }
+    isEnabled(key) {
+        return this.flags[key] ?? false;
+    }
+    getAll() {
+        return { ...this.flags };
+    }
+    getSummary() {
+        const lines = ['Feature Flags:'];
+        for (const definition of exports.FEATURE_FLAG_DEFINITIONS) {
+            const enabled = this.flags[definition.key];
+            const status = enabled ? '✓ ENABLED' : '✗ DISABLED';
+            const stability = definition.stable ? '[STABLE]' : '[EXPERIMENTAL]';
+            lines.push(`  ${status} ${stability} ${definition.key}`);
+            lines.push(`    ${definition.description}`);
+            lines.push(`    env: ${definition.envVar}`);
+        }
+        return lines.join('\n');
+    }
+}
+exports.CustomEnvFeatureFlagProvider = CustomEnvFeatureFlagProvider;
 class StaticFeatureFlagProvider {
     constructor(flags = {}) {
         this.flags = flags;
@@ -109,6 +169,8 @@ class StaticFeatureFlagProvider {
     }
 }
 exports.StaticFeatureFlagProvider = StaticFeatureFlagProvider;
-function createFeatureFlagProvider(env) {
-    return new EnvironmentFeatureFlagProvider(env);
+function createFeatureFlagProvider() {
+    throw new Error('createFeatureFlagProvider() is removed. ' +
+        'Use DI: container.resolve(DI.Infra.FeatureFlags). ' +
+        'For tests: EnvironmentFeatureFlagProvider.withEnv(customEnv)');
 }

package/dist/core/error-handler.d.ts

@@ -1,8 +1,22 @@
-import { JSONRPCResponse } from '../types/mcp-types';
+export declare enum MCPErrorCodes {
+    PARSE_ERROR = -32700,
+    INVALID_REQUEST = -32600,
+    METHOD_NOT_FOUND = -32601,
+    INVALID_PARAMS = -32602,
+    INTERNAL_ERROR = -32603,
+    SERVER_ERROR = -32000,
+    WORKFLOW_NOT_FOUND = -32001,
+    INVALID_WORKFLOW = -32002,
+    STEP_NOT_FOUND = -32003,
+    VALIDATION_ERROR = -32004,
+    STATE_ERROR = -32005,
+    STORAGE_ERROR = -32006,
+    SECURITY_ERROR = -32007
+}
 export declare class MCPError extends Error {
     readonly code: number;
-    readonly data?: any;
-    constructor(code: number, message: string, data?: any);
+    readonly data?: unknown;
+    constructor(code: number, message: string, data?: unknown);
 }
 export declare class WorkflowNotFoundError extends MCPError {
     constructor(workflowId: string);
@@ -14,7 +28,7 @@ export declare class StepNotFoundError extends MCPError {
     constructor(stepId: string, workflowId?: string);
 }
 export declare class ValidationError extends MCPError {
-    constructor(message: string, field?: string, details?: any);
+    constructor(message: string, field?: string, details?: unknown);
 }
 export declare class StateError extends MCPError {
     constructor(message: string, executionId?: string);
@@ -25,26 +39,3 @@ export declare class StorageError extends MCPError {
 export declare class SecurityError extends MCPError {
     constructor(message: string, action?: string);
 }
-export declare class ErrorHandler {
-    private static instance;
-    private constructor();
-    static getInstance(): ErrorHandler;
-    handleError(error: Error, requestId: string | number | null): JSONRPCResponse;
-    private convertToMCPError;
-    private logError;
-    createParseError(): JSONRPCResponse;
-    createInvalidRequestError(requestId: string | number | null): JSONRPCResponse;
-    createMethodNotFoundError(method: string, requestId: string | number | null): JSONRPCResponse;
-    createInvalidParamsError(details: string, requestId: string | number | null): JSONRPCResponse;
-    sanitizeErrorData(data: any): any;
-    getErrorRecoverySuggestions(error: MCPError): string[];
-    isRecoverableError(error: MCPError): boolean;
-    getErrorSeverity(error: MCPError): 'low' | 'medium' | 'high' | 'critical';
-}
-export declare const errorHandler: ErrorHandler;
-export declare function createErrorResponse(code: number, message: string, requestId: string | number | null, data?: any): JSONRPCResponse;
-export declare function withErrorHandling<T extends any[], R>(fn: (...args: T) => Promise<R>, requestId: string | number | null): (...args: T) => Promise<R | JSONRPCResponse>;
-export declare function validateRequest(request: any): {
-    valid: boolean;
-    error?: JSONRPCResponse;
-};

package/dist/core/error-handler.js

@@ -1,10 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.errorHandler = exports.ErrorHandler = exports.SecurityError = exports.StorageError = exports.StateError = exports.ValidationError = exports.StepNotFoundError = exports.InvalidWorkflowError = exports.WorkflowNotFoundError = exports.MCPError = void 0;
-exports.createErrorResponse = createErrorResponse;
-exports.withErrorHandling = withErrorHandling;
-exports.validateRequest = validateRequest;
-const mcp_types_1 = require("../types/mcp-types");
+exports.SecurityError = exports.StorageError = exports.StateError = exports.ValidationError = exports.StepNotFoundError = exports.InvalidWorkflowError = exports.WorkflowNotFoundError = exports.MCPError = exports.MCPErrorCodes = void 0;
+var MCPErrorCodes;
+(function (MCPErrorCodes) {
+    MCPErrorCodes[MCPErrorCodes["PARSE_ERROR"] = -32700] = "PARSE_ERROR";
+    MCPErrorCodes[MCPErrorCodes["INVALID_REQUEST"] = -32600] = "INVALID_REQUEST";
+    MCPErrorCodes[MCPErrorCodes["METHOD_NOT_FOUND"] = -32601] = "METHOD_NOT_FOUND";
+    MCPErrorCodes[MCPErrorCodes["INVALID_PARAMS"] = -32602] = "INVALID_PARAMS";
+    MCPErrorCodes[MCPErrorCodes["INTERNAL_ERROR"] = -32603] = "INTERNAL_ERROR";
+    MCPErrorCodes[MCPErrorCodes["SERVER_ERROR"] = -32000] = "SERVER_ERROR";
+    MCPErrorCodes[MCPErrorCodes["WORKFLOW_NOT_FOUND"] = -32001] = "WORKFLOW_NOT_FOUND";
+    MCPErrorCodes[MCPErrorCodes["INVALID_WORKFLOW"] = -32002] = "INVALID_WORKFLOW";
+    MCPErrorCodes[MCPErrorCodes["STEP_NOT_FOUND"] = -32003] = "STEP_NOT_FOUND";
+    MCPErrorCodes[MCPErrorCodes["VALIDATION_ERROR"] = -32004] = "VALIDATION_ERROR";
+    MCPErrorCodes[MCPErrorCodes["STATE_ERROR"] = -32005] = "STATE_ERROR";
+    MCPErrorCodes[MCPErrorCodes["STORAGE_ERROR"] = -32006] = "STORAGE_ERROR";
+    MCPErrorCodes[MCPErrorCodes["SECURITY_ERROR"] = -32007] = "SECURITY_ERROR";
+})(MCPErrorCodes || (exports.MCPErrorCodes = MCPErrorCodes = {}));
 class MCPError extends Error {
     constructor(code, message, data) {
         super(message);
@@ -16,256 +28,50 @@ class MCPError extends Error {
 exports.MCPError = MCPError;
 class WorkflowNotFoundError extends MCPError {
     constructor(workflowId) {
-        super(mcp_types_1.MCPErrorCodes.WORKFLOW_NOT_FOUND, `Workflow with id '${workflowId}' not found`, { workflowId });
+        super(MCPErrorCodes.WORKFLOW_NOT_FOUND, `Workflow with id '${workflowId}' not found`, { workflowId });
         this.name = 'WorkflowNotFoundError';
     }
 }
 exports.WorkflowNotFoundError = WorkflowNotFoundError;
 class InvalidWorkflowError extends MCPError {
     constructor(workflowId, details) {
-        super(mcp_types_1.MCPErrorCodes.INVALID_WORKFLOW, `Invalid workflow: ${workflowId}`, { workflowId, details });
+        super(MCPErrorCodes.INVALID_WORKFLOW, `Invalid workflow: ${workflowId}`, { workflowId, details });
         this.name = 'InvalidWorkflowError';
     }
 }
 exports.InvalidWorkflowError = InvalidWorkflowError;
 class StepNotFoundError extends MCPError {
     constructor(stepId, workflowId) {
-        super(mcp_types_1.MCPErrorCodes.STEP_NOT_FOUND, `Step with id '${stepId}' not found in workflow`, { stepId, workflowId });
+        super(MCPErrorCodes.STEP_NOT_FOUND, `Step with id '${stepId}' not found in workflow`, { stepId, workflowId });
         this.name = 'StepNotFoundError';
     }
 }
 exports.StepNotFoundError = StepNotFoundError;
 class ValidationError extends MCPError {
     constructor(message, field, details) {
-        super(mcp_types_1.MCPErrorCodes.VALIDATION_ERROR, message, { field, details });
+        super(MCPErrorCodes.VALIDATION_ERROR, message, { field, details });
         this.name = 'ValidationError';
     }
 }
 exports.ValidationError = ValidationError;
 class StateError extends MCPError {
     constructor(message, executionId) {
-        super(mcp_types_1.MCPErrorCodes.STATE_ERROR, message, { executionId });
+        super(MCPErrorCodes.STATE_ERROR, message, { executionId });
         this.name = 'StateError';
     }
 }
 exports.StateError = StateError;
 class StorageError extends MCPError {
     constructor(message, operation) {
-        super(mcp_types_1.MCPErrorCodes.STORAGE_ERROR, message, { operation });
+        super(MCPErrorCodes.STORAGE_ERROR, message, { operation });
         this.name = 'StorageError';
     }
 }
 exports.StorageError = StorageError;
 class SecurityError extends MCPError {
     constructor(message, action) {
-        super(mcp_types_1.MCPErrorCodes.SECURITY_ERROR, message, { action });
+        super(MCPErrorCodes.SECURITY_ERROR, message, { action });
         this.name = 'SecurityError';
     }
 }
 exports.SecurityError = SecurityError;
-class ErrorHandler {
-    constructor() {
-    }
-    static getInstance() {
-        if (!ErrorHandler.instance) {
-            ErrorHandler.instance = new ErrorHandler();
-        }
-        return ErrorHandler.instance;
-    }
-    handleError(error, requestId) {
-        let mcpError;
-        if (error instanceof MCPError) {
-            mcpError = error;
-        }
-        else {
-            mcpError = this.convertToMCPError(error);
-        }
-        this.logError(mcpError);
-        const errorResponse = {
-            jsonrpc: "2.0",
-            id: requestId,
-            error: {
-                code: mcpError.code,
-                message: mcpError.message,
-                data: mcpError.data
-            }
-        };
-        return errorResponse;
-    }
-    convertToMCPError(error) {
-        return new MCPError(mcp_types_1.MCPErrorCodes.INTERNAL_ERROR, error.message || 'Internal server error', { originalError: error.name });
-    }
-    logError(error) {
-        const logEntry = {
-            timestamp: new Date(),
-            level: 'error',
-            error: {
-                name: error.name,
-                code: error.code,
-                message: error.message,
-                data: error.data,
-                stack: error.stack
-            }
-        };
-        console.error('MCP Error:', logEntry);
-    }
-    createParseError() {
-        return {
-            jsonrpc: "2.0",
-            id: null,
-            error: {
-                code: mcp_types_1.MCPErrorCodes.PARSE_ERROR,
-                message: "Parse error",
-                data: { details: "Invalid JSON was received" }
-            }
-        };
-    }
-    createInvalidRequestError(requestId) {
-        return {
-            jsonrpc: "2.0",
-            id: requestId,
-            error: {
-                code: mcp_types_1.MCPErrorCodes.INVALID_REQUEST,
-                message: "Invalid Request",
-                data: { details: "The JSON sent is not a valid Request object" }
-            }
-        };
-    }
-    createMethodNotFoundError(method, requestId) {
-        return {
-            jsonrpc: "2.0",
-            id: requestId,
-            error: {
-                code: mcp_types_1.MCPErrorCodes.METHOD_NOT_FOUND,
-                message: "Method not found",
-                data: { method }
-            }
-        };
-    }
-    createInvalidParamsError(details, requestId) {
-        return {
-            jsonrpc: "2.0",
-            id: requestId,
-            error: {
-                code: mcp_types_1.MCPErrorCodes.INVALID_PARAMS,
-                message: "Invalid params",
-                data: { details }
-            }
-        };
-    }
-    sanitizeErrorData(data) {
-        if (!data)
-            return undefined;
-        const sanitized = { ...data };
-        const sensitiveKeys = ['password', 'token', 'secret', 'key', 'authorization'];
-        for (const key of sensitiveKeys) {
-            if (sanitized[key]) {
-                sanitized[key] = '[REDACTED]';
-            }
-        }
-        return sanitized;
-    }
-    getErrorRecoverySuggestions(error) {
-        const suggestions = [];
-        switch (error.code) {
-            case mcp_types_1.MCPErrorCodes.WORKFLOW_NOT_FOUND:
-                suggestions.push("Check if the workflow ID is correct", "Verify the workflow exists in the storage", "Try listing available workflows first");
-                break;
-            case mcp_types_1.MCPErrorCodes.INVALID_WORKFLOW:
-                suggestions.push("Validate the workflow JSON against the schema", "Check for required fields and proper formatting", "Ensure all step IDs are unique");
-                break;
-            case mcp_types_1.MCPErrorCodes.STEP_NOT_FOUND:
-                suggestions.push("Verify the step ID exists in the workflow", "Check the workflow definition for the correct step ID", "Ensure the workflow is properly loaded");
-                break;
-            case mcp_types_1.MCPErrorCodes.VALIDATION_ERROR:
-                suggestions.push("Check the input parameters against the schema", "Verify all required fields are provided", "Ensure data types match the expected format");
-                break;
-            case mcp_types_1.MCPErrorCodes.STATE_ERROR:
-                suggestions.push("Check if the workflow execution exists", "Verify the execution state is valid", "Try restarting the workflow execution");
-                break;
-            case mcp_types_1.MCPErrorCodes.STORAGE_ERROR:
-                suggestions.push("Check file system permissions", "Verify storage path is accessible", "Ensure sufficient disk space");
-                break;
-            case mcp_types_1.MCPErrorCodes.SECURITY_ERROR:
-                suggestions.push("Verify authentication credentials", "Check API key permissions", "Ensure proper authorization");
-                break;
-            default:
-                suggestions.push("Check the server logs for more details", "Verify the request format is correct", "Try the request again");
-        }
-        return suggestions;
-    }
-    isRecoverableError(error) {
-        const recoverableCodes = [
-            mcp_types_1.MCPErrorCodes.WORKFLOW_NOT_FOUND,
-            mcp_types_1.MCPErrorCodes.STEP_NOT_FOUND,
-            mcp_types_1.MCPErrorCodes.VALIDATION_ERROR,
-            mcp_types_1.MCPErrorCodes.INVALID_PARAMS
-        ];
-        return recoverableCodes.includes(error.code);
-    }
-    getErrorSeverity(error) {
-        switch (error.code) {
-            case mcp_types_1.MCPErrorCodes.PARSE_ERROR:
-            case mcp_types_1.MCPErrorCodes.INVALID_REQUEST:
-                return 'low';
-            case mcp_types_1.MCPErrorCodes.METHOD_NOT_FOUND:
-            case mcp_types_1.MCPErrorCodes.INVALID_PARAMS:
-            case mcp_types_1.MCPErrorCodes.WORKFLOW_NOT_FOUND:
-            case mcp_types_1.MCPErrorCodes.STEP_NOT_FOUND:
-            case mcp_types_1.MCPErrorCodes.VALIDATION_ERROR:
-                return 'medium';
-            case mcp_types_1.MCPErrorCodes.STATE_ERROR:
-            case mcp_types_1.MCPErrorCodes.STORAGE_ERROR:
-                return 'high';
-            case mcp_types_1.MCPErrorCodes.INTERNAL_ERROR:
-            case mcp_types_1.MCPErrorCodes.SECURITY_ERROR:
-                return 'critical';
-            default:
-                return 'medium';
-        }
-    }
-}
-exports.ErrorHandler = ErrorHandler;
-exports.errorHandler = ErrorHandler.getInstance();
-function createErrorResponse(code, message, requestId, data) {
-    return {
-        jsonrpc: "2.0",
-        id: requestId,
-        error: {
-            code,
-            message,
-            data: exports.errorHandler.sanitizeErrorData(data)
-        }
-    };
-}
-function withErrorHandling(fn, requestId) {
-    return async (...args) => {
-        try {
-            return await fn(...args);
-        }
-        catch (error) {
-            return exports.errorHandler.handleError(error, requestId);
-        }
-    };
-}
-function validateRequest(request) {
-    if (!request || typeof request !== 'object') {
-        return {
-            valid: false,
-            error: exports.errorHandler.createInvalidRequestError(null)
-        };
-    }
-    if (request.jsonrpc !== "2.0") {
-        return {
-            valid: false,
-            error: exports.errorHandler.createInvalidRequestError(request.id)
-        };
-    }
-    if (!request.method || typeof request.method !== 'string') {
-        return {
-            valid: false,
-            error: exports.errorHandler.createInvalidRequestError(request.id)
-        };
-    }
-    return { valid: true };
-}

package/dist/di/container.d.ts

@@ -0,0 +1,12 @@
+import 'reflect-metadata';
+import { container } from 'tsyringe';
+import type { RuntimeMode } from '../runtime/runtime-mode.js';
+export interface ContainerInitOptions {
+    readonly runtimeMode?: RuntimeMode;
+}
+export declare function initializeContainer(options?: ContainerInitOptions): Promise<void>;
+export declare function startAsyncServices(): Promise<void>;
+export declare function bootstrap(options?: ContainerInitOptions): Promise<void>;
+export declare function resetContainer(): void;
+export declare function isInitialized(): boolean;
+export { container };