@dotsetlabs/bellwether 1.0.2 → 1.0.3

package/dist/transport/mcp-client.js

@@ -252,7 +252,7 @@ export class MCPClient {
             return true;
         }
         // Check patterns
-        return FILTERED_ENV_PATTERNS.some(pattern => pattern.test(name));
+        return FILTERED_ENV_PATTERNS.some((pattern) => pattern.test(name));
     }
     /**
      * Filter sensitive environment variables before passing to subprocess.
@@ -295,7 +295,9 @@ export class MCPClient {
         if (!this.process.stdout || !this.process.stdin) {
             throw new Error('Failed to create stdio streams for server process');
         }
-        this.transport = new StdioTransport(this.process.stdout, this.process.stdin, { debug: this.debug });
+        this.transport = new StdioTransport(this.process.stdout, this.process.stdin, {
+            debug: this.debug,
+        });
         this.transport.on('message', (msg) => {
             this.log('Received:', JSON.stringify(msg));
             this.handleMessage(msg);
@@ -330,7 +332,7 @@ export class MCPClient {
                 // Capture stderr for diagnostic messages (limit to 500 chars)
                 const currentStderr = this.connectionState.stderrOutput ?? '';
                 if (currentStderr.length < 500) {
-                    this.connectionState.stderrOutput = (`${currentStderr}\n${msg}`).trim().slice(0, 500);
+                    this.connectionState.stderrOutput = `${currentStderr}\n${msg}`.trim().slice(0, 500);
                 }
                 // Check if stderr contains error indicators that suggest transport issues
                 if (this.looksLikeTransportError(msg)) {
@@ -348,7 +350,8 @@ export class MCPClient {
      * @param options - Optional configuration overrides
      */
     async connectRemote(url, options) {
-        const transport = options?.transport ?? (this.transportType === 'stdio' ? 'sse' : this.transportType);
+        const transport = options?.transport ??
+            (this.transportType === 'stdio' ? 'sse' : this.transportType);
         this.transportType = transport;
         // Reset flags for new connection
         this.cleaningUp = false;
@@ -414,7 +417,7 @@ export class MCPClient {
         // npx-based servers often need significant time to download and start
         const delay = Math.max(this.startupDelay, TIMEOUTS.MIN_SERVER_STARTUP_WAIT);
         this.logger.debug({ delay }, 'Waiting for server startup');
-        await new Promise(resolve => setTimeout(resolve, delay));
+        await new Promise((resolve) => setTimeout(resolve, delay));
         // Mark server as ready (startup delay complete)
         // Note: This only means we can *try* to initialize - actual readiness
         // is confirmed by successful initialization response
@@ -465,6 +468,9 @@ export class MCPClient {
         }
         for (const [id, pending] of this.pendingRequests) {
             clearTimeout(pending.timer);
+            if (pending.signal && pending.abortListener) {
+                pending.signal.removeEventListener('abort', pending.abortListener);
+            }
             pending.reject(new Error(`Request ${id} cancelled: ${reason}`));
         }
         this.pendingRequests.clear();
@@ -472,33 +478,33 @@ export class MCPClient {
     /**
      * List all tools available on the server.
      */
-    async listTools() {
-        const result = await this.sendRequest('tools/list', {});
+    async listTools(options) {
+        const result = await this.sendRequest('tools/list', {}, options);
         return result.tools;
     }
     /**
      * List all prompts available on the server.
      */
-    async listPrompts() {
-        const result = await this.sendRequest('prompts/list', {});
+    async listPrompts(options) {
+        const result = await this.sendRequest('prompts/list', {}, options);
         return result.prompts;
     }
     /**
      * List all resources available on the server.
      */
-    async listResources() {
-        const result = await this.sendRequest('resources/list', {});
+    async listResources(options) {
+        const result = await this.sendRequest('resources/list', {}, options);
         return result.resources;
     }
     /**
      * Read a resource from the server by URI.
      */
-    async readResource(uri) {
+    async readResource(uri, options) {
         const done = startTiming(this.logger, `readResource:${uri}`);
         try {
             const result = await this.sendRequest('resources/read', {
                 uri,
-            });
+            }, options);
             done();
             return result;
         }
@@ -510,13 +516,13 @@ export class MCPClient {
     /**
      * Get a prompt from the server with the given arguments.
      */
-    async getPrompt(name, args = {}) {
+    async getPrompt(name, args = {}, options) {
         const done = startTiming(this.logger, `getPrompt:${name}`);
         try {
             const result = await this.sendRequest('prompts/get', {
                 name,
                 arguments: args,
-            });
+            }, options);
             done();
             return result;
         }
@@ -528,13 +534,13 @@ export class MCPClient {
     /**
      * Call a tool on the server.
      */
-    async callTool(name, args = {}) {
+    async callTool(name, args = {}, options) {
         const done = startTiming(this.logger, `callTool:${name}`);
         try {
             const result = await this.sendRequest('tools/call', {
                 name,
                 arguments: args,
-            });
+            }, options);
             done();
             return result;
         }
@@ -580,7 +586,7 @@ export class MCPClient {
         }
         this.cleanup();
     }
-    sendRequest(method, params) {
+    sendRequest(method, params, options) {
         return new Promise((resolve, reject) => {
             if (!this.transport) {
                 reject(new Error(this.buildConnectionErrorMessage()));
@@ -594,16 +600,37 @@ export class MCPClient {
                 params,
             };
             const timer = setTimeout(() => {
+                const pending = this.pendingRequests.get(id);
+                if (pending?.signal && pending.abortListener) {
+                    pending.signal.removeEventListener('abort', pending.abortListener);
+                }
                 this.pendingRequests.delete(id);
                 reject(new Error(`Request timeout: ${method}`));
             }, this.timeout);
+            let abortListener;
+            const signal = options?.signal;
+            if (signal) {
+                if (signal.aborted) {
+                    clearTimeout(timer);
+                    reject(new Error(`Request aborted: ${method}`));
+                    return;
+                }
+                abortListener = () => {
+                    clearTimeout(timer);
+                    this.pendingRequests.delete(id);
+                    reject(new Error(`Request aborted: ${method}`));
+                };
+                signal.addEventListener('abort', abortListener, { once: true });
+            }
             this.pendingRequests.set(id, {
                 resolve: resolve,
                 reject,
                 timer,
+                signal,
+                abortListener,
             });
             this.log('Sending:', JSON.stringify(request));
-            this.transport.send(request);
+            this.transport.send(request, signal);
         });
     }
     sendNotification(method, params) {
@@ -628,6 +655,9 @@ export class MCPClient {
             if (pending) {
                 clearTimeout(pending.timer);
                 this.pendingRequests.delete(msg.id);
+                if (pending.signal && pending.abortListener) {
+                    pending.signal.removeEventListener('abort', pending.abortListener);
+                }
                 const response = msg;
                 if (response.error) {
                     pending.reject(new Error(`${response.error.message} (code: ${response.error.code})`));

package/dist/transport/sse-transport.d.ts

@@ -69,7 +69,7 @@ export declare class SSETransport extends BaseTransport {
     /**
      * Send a JSON-RPC message to the server via HTTP POST.
      */
-    send(message: JSONRPCMessage): void;
+    send(message: JSONRPCMessage, _signal?: AbortSignal): void;
     /**
      * Close the SSE connection.
      *

package/dist/transport/sse-transport.js

@@ -147,7 +147,9 @@ export class SSETransport extends BaseTransport {
             this.emit('message', message);
         }
         catch (error) {
-            this.log('Failed to parse SSE message', { error: error instanceof Error ? error.message : String(error) });
+            this.log('Failed to parse SSE message', {
+                error: error instanceof Error ? error.message : String(error),
+            });
             // Don't emit error for parse failures - just log
         }
     }
@@ -216,7 +218,7 @@ export class SSETransport extends BaseTransport {
     /**
      * Send a JSON-RPC message to the server via HTTP POST.
      */
-    send(message) {
+    send(message, _signal) {
         if (!this.connected) {
             this.emit('error', new Error('Transport not connected'));
             return;

package/dist/transport/stdio-transport.d.ts

@@ -37,7 +37,7 @@ export declare class StdioTransport extends BaseTransport {
     isConnected(): boolean;
     private setupInputHandler;
     private processBuffer;
-    send(message: JSONRPCMessage): void;
+    send(message: JSONRPCMessage, _signal?: AbortSignal): void;
     close(): void;
 }
 //# sourceMappingURL=stdio-transport.d.ts.map

package/dist/transport/stdio-transport.js

@@ -153,7 +153,7 @@ export class StdioTransport extends BaseTransport {
             }
         }
     }
-    send(message) {
+    send(message, _signal) {
         const content = JSON.stringify(message);
         const writeData = (data) => {
             try {

package/dist/utils/timeout.d.ts

@@ -45,6 +45,13 @@ export interface TimeoutConfig {
     /** Custom error message */
     errorMessage?: string;
 }
+/**
+ * Optional timeout behavior overrides.
+ */
+export interface TimeoutOptions {
+    /** Abort controller to signal when timeout occurs */
+    abortController?: AbortController;
+}
 /**
  * Error class for timeout errors.
  */
@@ -76,7 +83,7 @@ export declare function checkAborted(signal: AbortSignal | undefined, operationN
  * @param operationName - Name of the operation for error messages
  * @returns The promise result or throws TimeoutError
  */
-export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, operationName: string): Promise<T>;
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, operationName: string, options?: TimeoutOptions): Promise<T>;
 /**
  * Wrap a promise with a timeout and return a result object instead of throwing.
  *
@@ -85,7 +92,7 @@ export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, o
  * @param operationName - Name of the operation
  * @returns Object with either result or error
  */
-export declare function withTimeoutResult<T>(promise: Promise<T>, timeoutMs: number, operationName: string): Promise<{
+export declare function withTimeoutResult<T>(promise: Promise<T>, timeoutMs: number, operationName: string, options?: TimeoutOptions): Promise<{
     success: true;
     result: T;
 } | {
@@ -114,6 +121,7 @@ export declare function withTimeoutAll<T>(operations: Array<{
     promise: Promise<T>;
     timeoutMs: number;
     operationName: string;
+    options?: TimeoutOptions;
 }>): Promise<Array<{
     success: true;
     result: T;

package/dist/utils/timeout.js

@@ -79,11 +79,15 @@ export function checkAborted(signal, operationName) {
  * @param operationName - Name of the operation for error messages
  * @returns The promise result or throws TimeoutError
  */
-export async function withTimeout(promise, timeoutMs, operationName) {
+export async function withTimeout(promise, timeoutMs, operationName, options) {
     let timeoutId;
+    const abortController = options?.abortController;
     const timeoutPromise = new Promise((_, reject) => {
         timeoutId = setTimeout(() => {
             logger.warn({ operationName, timeoutMs }, 'Operation timed out');
+            if (abortController) {
+                abortController.abort(new TimeoutError(operationName, timeoutMs));
+            }
             reject(new TimeoutError(operationName, timeoutMs));
         }, timeoutMs);
     });
@@ -102,9 +106,9 @@ export async function withTimeout(promise, timeoutMs, operationName) {
  * @param operationName - Name of the operation
  * @returns Object with either result or error
  */
-export async function withTimeoutResult(promise, timeoutMs, operationName) {
+export async function withTimeoutResult(promise, timeoutMs, operationName, options) {
     try {
-        const result = await withTimeout(promise, timeoutMs, operationName);
+        const result = await withTimeout(promise, timeoutMs, operationName, options);
         return { success: true, result };
     }
     catch (error) {
@@ -140,9 +144,9 @@ export function createTimeoutAbortController(timeoutMs, operationName) {
  * @returns Array of results (either success with value or failure with error)
  */
 export async function withTimeoutAll(operations) {
-    return Promise.all(operations.map(async ({ promise, timeoutMs, operationName }) => {
+    return Promise.all(operations.map(async ({ promise, timeoutMs, operationName, options }) => {
         try {
-            const result = await withTimeout(promise, timeoutMs, operationName);
+            const result = await withTimeout(promise, timeoutMs, operationName, options);
             return { success: true, result };
         }
         catch (error) {

package/dist/version.js

@@ -30,7 +30,7 @@ function getPackageVersion() {
     }
     catch {
         // Fallback version - should match package.json
-        return '1.0.2';
+        return '1.0.3';
     }
 }
 /**

package/dist/workflow/executor.js

@@ -63,7 +63,7 @@ export class WorkflowExecutor {
     emitProgress(workflow, phase, currentStep, startTime, currentStepInfo) {
         if (!this.onProgress)
             return;
-        const stepsFailed = this.stepResults.filter(r => !r.success).length;
+        const stepsFailed = this.stepResults.filter((r) => !r.success).length;
         this.onProgress({
             phase,
             workflow,
@@ -118,7 +118,9 @@ export class WorkflowExecutor {
             if (requireSuccessfulDeps) {
                 const failedDependencies = this.getFailedDependencies(step, i);
                 if (failedDependencies.length > 0) {
-                    const failedStepNames = failedDependencies.map((idx) => `step ${idx + 1} (${workflow.steps[idx]?.tool ?? 'unknown'})`).join(', ');
+                    const failedStepNames = failedDependencies
+                        .map((idx) => `step ${idx + 1} (${workflow.steps[idx]?.tool ?? 'unknown'})`)
+                        .join(', ');
                     this.logger.debug({
                         stepIndex: i,
                         tool: step.tool,
@@ -229,7 +231,7 @@ export class WorkflowExecutor {
             workflowId: workflow.id,
             success,
             stepsCompleted: this.stepResults.length,
-            stepsFailed: this.stepResults.filter(r => !r.success).length,
+            stepsFailed: this.stepResults.filter((r) => !r.success).length,
             durationMs,
         }, 'Workflow execution complete');
         done();
@@ -251,7 +253,7 @@ export class WorkflowExecutor {
     async executeStep(step, stepIndex, workflow) {
         const startTime = Date.now();
         // Verify tool exists
-        const tool = this.tools.find(t => t.name === step.tool);
+        const tool = this.tools.find((t) => t.name === step.tool);
         if (!tool) {
             return {
                 step,
@@ -284,7 +286,8 @@ export class WorkflowExecutor {
         let error;
         const stepTimeout = this.options.stepTimeout ?? DEFAULT_OPTIONS.stepTimeout;
         try {
-            response = await withTimeout(this.client.callTool(step.tool, resolvedArgs), stepTimeout, `Tool call '${step.tool}'`);
+            const abortController = new AbortController();
+            response = await withTimeout(this.client.callTool(step.tool, resolvedArgs, { signal: abortController.signal }), stepTimeout, `Tool call '${step.tool}'`, { abortController });
             if (response.isError) {
                 error = this.extractErrorMessage(response);
             }
@@ -296,7 +299,7 @@ export class WorkflowExecutor {
         const assertionResults = step.assertions
             ? this.runAssertions(step.assertions, response)
             : undefined;
-        const assertionsFailed = assertionResults?.some(r => !r.passed) ?? false;
+        const assertionsFailed = assertionResults?.some((r) => !r.passed) ?? false;
         const success = !error && !assertionsFailed;
         // Generate analysis if requested
         let analysis;
@@ -359,7 +362,7 @@ export class WorkflowExecutor {
         if (propertyPath.startsWith('result.') || propertyPath === 'result') {
             // Extract text content from the response
             const content = stepResult.response.content;
-            const textContent = content.find(c => c.type === 'text' && c.text !== undefined);
+            const textContent = content.find((c) => c.type === 'text' && c.text !== undefined);
             if (!textContent || textContent.text === undefined) {
                 throw new Error(`Step ${stepIndex} response has no text content`);
             }
@@ -418,7 +421,7 @@ export class WorkflowExecutor {
      * Run assertions against a step response.
      */
     runAssertions(assertions, response) {
-        return assertions.map(assertion => this.runAssertion(assertion, response));
+        return assertions.map((assertion) => this.runAssertion(assertion, response));
     }
     /**
      * Run a single assertion.
@@ -435,7 +438,7 @@ export class WorkflowExecutor {
         let actualValue;
         try {
             // Parse the response content as JSON
-            const textContent = response.content.find(c => c.type === 'text' && c.text !== undefined);
+            const textContent = response.content.find((c) => c.type === 'text' && c.text !== undefined);
             if (!textContent || textContent.text === undefined) {
                 throw new Error('No text content in response');
             }
@@ -484,14 +487,16 @@ export class WorkflowExecutor {
             assertion,
             passed,
             actualValue,
-            message: passed ? undefined : (assertion.message ?? `Assertion failed: ${assertion.condition}`),
+            message: passed
+                ? undefined
+                : (assertion.message ?? `Assertion failed: ${assertion.condition}`),
         };
     }
     /**
      * Extract error message from a tool response.
      */
     extractErrorMessage(response) {
-        const textContent = response.content.find(c => c.type === 'text');
+        const textContent = response.content.find((c) => c.type === 'text');
         if (textContent && 'text' in textContent) {
             return String(textContent.text);
         }
@@ -595,7 +600,7 @@ export class WorkflowExecutor {
         if (!this.llm) {
             return success
                 ? `Workflow "${workflow.name}" completed successfully with ${stepResults.length} steps.`
-                : `Workflow "${workflow.name}" failed at step ${stepResults.findIndex(r => !r.success) + 1}.`;
+                : `Workflow "${workflow.name}" failed at step ${stepResults.findIndex((r) => !r.success) + 1}.`;
         }
         const prompt = buildWorkflowSummaryPrompt({ workflow, stepResults, success });
         try {
@@ -604,7 +609,7 @@ export class WorkflowExecutor {
         catch {
             return success
                 ? `Workflow "${workflow.name}" completed successfully with ${stepResults.length} steps.`
-                : `Workflow "${workflow.name}" failed at step ${stepResults.findIndex(r => !r.success) + 1}.`;
+                : `Workflow "${workflow.name}" failed at step ${stepResults.findIndex((r) => !r.success) + 1}.`;
         }
     }
 }

package/dist/workflow/loader.js

@@ -6,8 +6,10 @@ import { join } from 'path';
 import { parseAllDocuments } from 'yaml';
 import { parseYamlSecure, YAML_SECURITY_LIMITS } from '../utils/yaml-parser.js';
 import { PATHS } from '../constants.js';
+import { getLogger } from '../logging/logger.js';
 /** Default file name for workflow definitions */
 export const DEFAULT_WORKFLOWS_FILE = PATHS.DEFAULT_WORKFLOWS_FILE;
+const logger = getLogger('workflow');
 /**
  * Load workflows from a YAML file.
  * Supports both single-document and multi-document YAML (separated by ---).
@@ -56,9 +58,10 @@ export function tryLoadDefaultWorkflows(directory) {
     try {
         return loadWorkflowsFromFile(path);
     }
-    catch {
+    catch (error) {
         // If the file exists but is invalid, return null rather than throwing
         // This allows the interview to proceed without workflows
+        logger.warn({ path, error: error instanceof Error ? error.message : String(error) }, 'Failed to load default workflow file');
         return null;
     }
 }

package/dist/workflow/state-tracker.js

@@ -74,7 +74,7 @@ export class StateTracker {
         }
         // Use specified probe tools if provided
         if (this.options.probeTools?.length) {
-            this.probeTools = this.options.probeTools.filter(name => this.tools.some(t => t.name === name));
+            this.probeTools = this.options.probeTools.filter((name) => this.tools.some((t) => t.name === name));
         }
         this.logger.debug({
             toolCount: this.tools.length,
@@ -89,9 +89,9 @@ export class StateTracker {
         const name = tool.name;
         const description = tool.description ?? '';
         const combined = `${name} ${description}`;
-        const isReader = READER_PATTERNS.some(p => p.test(combined));
-        const isWriter = WRITER_PATTERNS.some(p => p.test(combined));
-        const isProbe = PROBE_PATTERNS.some(p => p.test(combined));
+        const isReader = READER_PATTERNS.some((p) => p.test(combined));
+        const isWriter = WRITER_PATTERNS.some((p) => p.test(combined));
+        const isProbe = PROBE_PATTERNS.some((p) => p.test(combined));
         let role;
         let confidence;
         if (isReader && isWriter) {
@@ -194,8 +194,9 @@ export class StateTracker {
                 break;
             }
             try {
+                const abortController = new AbortController();
                 // Apply timeout to individual probe tool call
-                const result = await withTimeout(this.client.callTool(probeName, {}), this.probeTimeout, `Probe tool '${probeName}'`);
+                const result = await withTimeout(this.client.callTool(probeName, {}, { signal: abortController.signal }), this.probeTimeout, `Probe tool '${probeName}'`, { abortController });
                 const content = this.extractContent(result);
                 stateData[probeName] = content;
                 successCount++;
@@ -240,7 +241,7 @@ export class StateTracker {
      * Extract content from a tool call result.
      */
     extractContent(result) {
-        const textContent = result.content.find(c => c.type === 'text' && c.text !== undefined);
+        const textContent = result.content.find((c) => c.type === 'text' && c.text !== undefined);
         if (!textContent || textContent.text === undefined) {
             return null;
         }
@@ -256,7 +257,10 @@ export class StateTracker {
      */
     hashState(data) {
         const json = JSON.stringify(data, null, 0);
-        return createHash('sha256').update(json).digest('hex').slice(0, DISPLAY_LIMITS.HASH_DISPLAY_LENGTH);
+        return createHash('sha256')
+            .update(json)
+            .digest('hex')
+            .slice(0, DISPLAY_LIMITS.HASH_DISPLAY_LENGTH);
     }
     /**
      * Compare two snapshots and identify changes.
@@ -351,7 +355,7 @@ export class StateTracker {
                 for (const stateType of stateTypes) {
                     const writers = writerSteps.get(stateType) ?? [];
                     // Find most recent writer for this state type
-                    const recentWriters = writers.filter(w => w < i);
+                    const recentWriters = writers.filter((w) => w < i);
                     if (recentWriters.length > 0) {
                         const producerStep = recentWriters[recentWriters.length - 1];
                         const producerTool = stepResults[producerStep].step.tool;
@@ -372,9 +376,9 @@ export class StateTracker {
      * Verify dependencies using state snapshots.
      */
     verifyDependencies(dependencies, _snapshots, changes) {
-        return dependencies.map(dep => {
+        return dependencies.map((dep) => {
             // Check if the producer step caused any changes
-            const producerChanges = changes.filter(c => c.causedByStep === dep.producerStep);
+            const producerChanges = changes.filter((c) => c.causedByStep === dep.producerStep);
             const verified = producerChanges.length > 0;
             return {
                 ...dep,
@@ -388,19 +392,19 @@ export class StateTracker {
     async generateSummary(tracking) {
         const parts = [];
         // Summarize tool roles
-        const writers = tracking.toolRoles.filter(t => t.role === 'writer' || t.role === 'both');
-        const readers = tracking.toolRoles.filter(t => t.role === 'reader' || t.role === 'both');
+        const writers = tracking.toolRoles.filter((t) => t.role === 'writer' || t.role === 'both');
+        const readers = tracking.toolRoles.filter((t) => t.role === 'reader' || t.role === 'both');
         if (writers.length > 0) {
-            parts.push(`State writers: ${writers.map(t => t.tool).join(', ')}`);
+            parts.push(`State writers: ${writers.map((t) => t.tool).join(', ')}`);
         }
         if (readers.length > 0) {
-            parts.push(`State readers: ${readers.map(t => t.tool).join(', ')}`);
+            parts.push(`State readers: ${readers.map((t) => t.tool).join(', ')}`);
         }
         // Summarize changes
         if (tracking.changes.length > 0) {
-            const created = tracking.changes.filter(c => c.type === 'created').length;
-            const modified = tracking.changes.filter(c => c.type === 'modified').length;
-            const deleted = tracking.changes.filter(c => c.type === 'deleted').length;
+            const created = tracking.changes.filter((c) => c.type === 'created').length;
+            const modified = tracking.changes.filter((c) => c.type === 'modified').length;
+            const deleted = tracking.changes.filter((c) => c.type === 'deleted').length;
             const changeParts = [];
             if (created > 0)
                 changeParts.push(`${created} created`);
@@ -415,7 +419,7 @@ export class StateTracker {
         }
         // Summarize dependencies
         if (tracking.dependencies.length > 0) {
-            const verified = tracking.dependencies.filter(d => d.verified).length;
+            const verified = tracking.dependencies.filter((d) => d.verified).length;
             parts.push(`Dependencies: ${tracking.dependencies.length} inferred (${verified} verified)`);
         }
         return `${parts.join('. ')}.`;