@dotsetlabs/bellwether 1.0.2 → 1.0.3

package/dist/llm/anthropic.js

@@ -13,6 +13,22 @@ import { getLogger } from '../logging/logger.js';
  */
 const PLACEHOLDER_CONTINUE = 'Continue.';
 const PLACEHOLDER_GREETING = 'Hello.';
+function getErrorStatus(error) {
+    const err = error;
+    return err.status ?? err.statusCode;
+}
+function getErrorCode(error) {
+    const err = error;
+    return err.code ?? err.error?.code;
+}
+function getErrorType(error) {
+    const err = error;
+    return err.type ?? err.error?.type;
+}
+function getErrorMessage(error) {
+    const err = error;
+    return err.error?.message ?? err.message ?? '';
+}
 /**
  * Anthropic Claude LLM client implementation.
  */
@@ -48,7 +64,7 @@ export class AnthropicClient {
             // Separate system message from conversation messages
             const systemPrompt = options?.systemPrompt;
             // Convert messages to Anthropic format
-            const anthropicMessages = messages.map(m => ({
+            const anthropicMessages = messages.map((m) => ({
                 role: m.role === 'assistant' ? 'assistant' : 'user',
                 content: m.content,
             }));
@@ -72,7 +88,7 @@ export class AnthropicClient {
                     max_tokens: options?.maxTokens ?? LLM_DEFAULTS.MAX_TOKENS,
                     system: system,
                     messages: normalizedMessages,
-                });
+                }, { signal: options?.signal });
                 // Track actual token usage from API response
                 if (this.onUsage && response.usage) {
                     this.onUsage(response.usage.input_tokens, response.usage.output_tokens);
@@ -80,26 +96,34 @@ export class AnthropicClient {
                 // Check for content filtering refusal
                 this.checkForRefusal(response, model);
                 // Extract text content from response
-                const textBlocks = response.content.filter(block => block.type === 'text');
+                const textBlocks = response.content.filter((block) => block.type === 'text');
                 if (textBlocks.length === 0) {
                     throw new Error('No text content in Claude response');
                 }
-                return textBlocks.map(block => block.text).join('');
+                return textBlocks.map((block) => block.text).join('');
             }
             catch (error) {
                 // Don't re-process errors that are already typed LLM errors
-                if (error instanceof LLMRefusalError || error instanceof LLMAuthError ||
-                    error instanceof LLMRateLimitError || error instanceof LLMQuotaError ||
+                if (error instanceof LLMRefusalError ||
+                    error instanceof LLMAuthError ||
+                    error instanceof LLMRateLimitError ||
+                    error instanceof LLMQuotaError ||
                     error instanceof LLMConnectionError) {
                     throw error;
                 }
                 // Convert to typed errors for retry logic
                 if (error instanceof Error) {
-                    const message = error.message.toLowerCase();
-                    if (message.includes('401') || message.includes('authentication')) {
+                    const status = getErrorStatus(error);
+                    const code = (getErrorCode(error) ?? '').toLowerCase();
+                    const type = (getErrorType(error) ?? '').toLowerCase();
+                    const message = getErrorMessage(error).toLowerCase();
+                    if (status === 401 || status === 403 || message.includes('authentication')) {
                         throw new LLMAuthError('anthropic', model);
                     }
-                    if (message.includes('429') || message.includes('rate limit')) {
+                    if (status === 429 ||
+                        code.includes('rate_limit') ||
+                        type.includes('rate_limit') ||
+                        message.includes('rate limit')) {
                         // Extract retry-after-ms header if available from Anthropic API error
                         let retryAfterMs;
                         const apiError = error;
@@ -127,7 +151,11 @@ export class AnthropicClient {
                         }
                         throw new LLMRateLimitError('anthropic', retryAfterMs, model);
                     }
-                    if (message.includes('insufficient') || message.includes('credit')) {
+                    if (status === 402 ||
+                        code.includes('insufficient') ||
+                        type.includes('insufficient') ||
+                        message.includes('insufficient') ||
+                        message.includes('credit')) {
                         throw new LLMQuotaError('anthropic', model);
                     }
                     if (message.includes('econnrefused') || message.includes('fetch failed')) {
@@ -164,9 +192,12 @@ export class AnthropicClient {
             throw new LLMRefusalError('anthropic', 'Response blocked due to safety concerns', model);
         }
         // Check content for refusal indicators
-        const textBlocks = response.content.filter(block => block.type === 'text');
+        const textBlocks = response.content.filter((block) => block.type === 'text');
         if (textBlocks.length > 0) {
-            const fullText = textBlocks.map(block => block.text ?? '').join('').toLowerCase();
+            const fullText = textBlocks
+                .map((block) => block.text ?? '')
+                .join('')
+                .toLowerCase();
             // Check for common refusal patterns in Claude's responses
             const refusalPatterns = [
                 'i cannot help with',
@@ -244,7 +275,7 @@ export class AnthropicClient {
             // Separate system message from conversation messages
             const systemPrompt = options?.systemPrompt;
             // Convert messages to Anthropic format
-            const anthropicMessages = messages.map(m => ({
+            const anthropicMessages = messages.map((m) => ({
                 role: m.role === 'assistant' ? 'assistant' : 'user',
                 content: m.content,
             }));
@@ -266,7 +297,7 @@ export class AnthropicClient {
                     max_tokens: options?.maxTokens ?? LLM_DEFAULTS.MAX_TOKENS,
                     system: system,
                     messages: normalizedMessages,
-                });
+                }, { signal: options?.signal });
                 let fullText = '';
                 for await (const event of stream) {
                     if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
@@ -294,8 +325,10 @@ export class AnthropicClient {
             catch (error) {
                 options?.onError?.(error instanceof Error ? error : new Error(String(error)));
                 // Don't re-process errors that are already typed LLM errors
-                if (error instanceof LLMRefusalError || error instanceof LLMAuthError ||
-                    error instanceof LLMRateLimitError || error instanceof LLMQuotaError ||
+                if (error instanceof LLMRefusalError ||
+                    error instanceof LLMAuthError ||
+                    error instanceof LLMRateLimitError ||
+                    error instanceof LLMQuotaError ||
                     error instanceof LLMConnectionError) {
                     throw error;
                 }

package/dist/llm/client.d.ts

@@ -16,6 +16,8 @@ export interface CompletionOptions {
     responseFormat?: 'text' | 'json';
     /** System prompt to set context */
     systemPrompt?: string;
+    /** Optional abort signal to cancel the request */
+    signal?: AbortSignal;
 }
 /**
  * Options for streaming completions.

package/dist/llm/client.js

@@ -36,7 +36,68 @@ export function parseJSONResponse(response) {
         return JSON.parse(cleaned);
     }
     catch (error) {
+        // Try to extract a JSON object/array from mixed content
+        const extracted = extractFirstJsonBlock(cleaned);
+        if (extracted) {
+            try {
+                return JSON.parse(extracted);
+            }
+            catch (extractedError) {
+                throw new Error(`Failed to parse extracted JSON from LLM response: ${extractedError}`);
+            }
+        }
         throw new Error(`Failed to parse JSON from LLM response: ${error}`);
     }
 }
+/**
+ * Extract the first valid JSON object or array from a string.
+ * Handles mixed content like "Here is the JSON: {...}".
+ */
+function extractFirstJsonBlock(text) {
+    const startIndexes = [];
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (char === '{' || char === '[') {
+            startIndexes.push(i);
+        }
+    }
+    for (const start of startIndexes) {
+        const opening = text[start];
+        const closing = opening === '{' ? '}' : ']';
+        let depth = 0;
+        let inString = false;
+        let escape = false;
+        for (let i = start; i < text.length; i++) {
+            const char = text[i];
+            if (inString) {
+                if (escape) {
+                    escape = false;
+                    continue;
+                }
+                if (char === '\\') {
+                    escape = true;
+                    continue;
+                }
+                if (char === '"') {
+                    inString = false;
+                }
+                continue;
+            }
+            if (char === '"') {
+                inString = true;
+                continue;
+            }
+            if (char === opening) {
+                depth += 1;
+            }
+            else if (char === closing) {
+                depth -= 1;
+                if (depth === 0) {
+                    return text.slice(start, i + 1);
+                }
+            }
+        }
+    }
+    return null;
+}
 //# sourceMappingURL=client.js.map

package/dist/llm/ollama.js

@@ -65,12 +65,13 @@ export class OllamaClient {
                         'Content-Type': 'application/json',
                     },
                     body: JSON.stringify(request),
+                    signal: options?.signal,
                 });
                 if (!response.ok) {
                     const errorText = await response.text();
                     throw new Error(`Ollama API error (${response.status}): ${errorText}`);
                 }
-                const result = await response.json();
+                const result = (await response.json());
                 if (!result.message?.content) {
                     throw new Error('No content in Ollama response');
                 }
@@ -170,6 +171,7 @@ export class OllamaClient {
                         'Content-Type': 'application/json',
                     },
                     body: JSON.stringify(request),
+                    signal: options?.signal,
                 });
                 if (!response.ok) {
                     const errorText = await response.text();
@@ -234,7 +236,10 @@ export class OllamaClient {
                         }
                         catch (parseError) {
                             // Log parse error for debugging
-                            this.logger.debug({ buffer, error: parseError instanceof Error ? parseError.message : String(parseError) }, 'Failed to parse final buffer chunk');
+                            this.logger.debug({
+                                buffer,
+                                error: parseError instanceof Error ? parseError.message : String(parseError),
+                            }, 'Failed to parse final buffer chunk');
                         }
                     }
                 }
@@ -318,8 +323,8 @@ export class OllamaClient {
             if (!response.ok) {
                 return [];
             }
-            const result = await response.json();
-            return result.models?.map(m => m.name) ?? [];
+            const result = (await response.json());
+            return result.models?.map((m) => m.name) ?? [];
         }
         catch (error) {
             this.logger.debug({ error: error instanceof Error ? error.message : String(error) }, 'Failed to list Ollama models');

package/dist/llm/openai.js

@@ -15,26 +15,35 @@ import { LLM_DEFAULTS } from '../constants.js';
  * - Don't support custom temperature (only default of 1)
  * - Use reasoning tokens that come out of the completion token budget
  */
-const MODELS_WITH_RESTRICTED_PARAMS = [
-    'o1',
-    'o1-mini',
-    'o1-preview',
-    'o3',
-    'o3-mini',
-    'gpt-5',
-];
+const MODELS_WITH_RESTRICTED_PARAMS = ['o1', 'o1-mini', 'o1-preview', 'o3', 'o3-mini', 'gpt-5'];
 /**
  * Minimum max_completion_tokens for reasoning models.
  * Reasoning models use tokens for internal "thinking" before producing output.
  * We need a high minimum to ensure there are enough tokens left for actual output.
  */
 const REASONING_MODEL_MIN_TOKENS = 8192;
+function getErrorStatus(error) {
+    const err = error;
+    return err.status ?? err.statusCode;
+}
+function getErrorCode(error) {
+    const err = error;
+    return err.code ?? err.error?.code;
+}
+function getErrorType(error) {
+    const err = error;
+    return err.type ?? err.error?.type;
+}
+function getErrorMessage(error) {
+    const err = error;
+    return err.error?.message ?? err.message ?? '';
+}
 /**
  * Check if a model has restricted parameters (newer reasoning/GPT-5 models).
  */
 function hasRestrictedParams(model) {
     const modelLower = model.toLowerCase();
-    return MODELS_WITH_RESTRICTED_PARAMS.some(prefix => modelLower.startsWith(prefix));
+    return MODELS_WITH_RESTRICTED_PARAMS.some((prefix) => modelLower.startsWith(prefix));
 }
 /**
  * Get the effective max tokens for a model, accounting for reasoning overhead.
@@ -88,7 +97,7 @@ export class OpenAIClient {
                 const maxTokensValue = getEffectiveMaxTokens(model, requestedMaxTokens);
                 const response = await this.client.chat.completions.create({
                     model,
-                    messages: allMessages.map(m => ({
+                    messages: allMessages.map((m) => ({
                         role: m.role,
                         content: m.content,
                     })),
@@ -102,10 +111,8 @@ export class OpenAIClient {
                     ...(restrictedParams
                         ? {}
                         : { temperature: options?.temperature ?? LLM_DEFAULTS.TEMPERATURE }),
-                    response_format: options?.responseFormat === 'json'
-                        ? { type: 'json_object' }
-                        : undefined,
-                });
+                    response_format: options?.responseFormat === 'json' ? { type: 'json_object' } : undefined,
+                }, { signal: options?.signal });
                 // Track actual token usage from API response
                 if (this.onUsage && response.usage) {
                     this.onUsage(response.usage.prompt_tokens, response.usage.completion_tokens);
@@ -138,11 +145,14 @@ export class OpenAIClient {
             catch (error) {
                 // Convert to typed errors for retry logic
                 if (error instanceof Error) {
-                    const message = error.message.toLowerCase();
-                    if (message.includes('401')) {
+                    const status = getErrorStatus(error);
+                    const code = (getErrorCode(error) ?? '').toLowerCase();
+                    const type = (getErrorType(error) ?? '').toLowerCase();
+                    const message = getErrorMessage(error).toLowerCase();
+                    if (status === 401 || status === 403) {
                         throw new LLMAuthError('openai', model);
                     }
-                    if (message.includes('429')) {
+                    if (status === 429 || code.includes('rate_limit') || type.includes('rate_limit')) {
                         // Extract Retry-After header if available from OpenAI API error
                         let retryAfterMs;
                         const apiError = error;
@@ -172,7 +182,10 @@ export class OpenAIClient {
                         }
                         throw new LLMRateLimitError('openai', retryAfterMs, model);
                     }
-                    if (message.includes('insufficient_quota')) {
+                    if (status === 402 ||
+                        code.includes('insufficient_quota') ||
+                        type.includes('insufficient_quota') ||
+                        message.includes('insufficient_quota')) {
                         throw new LLMQuotaError('openai', model);
                     }
                     if (message.includes('econnrefused') || message.includes('fetch failed')) {
@@ -219,7 +232,7 @@ export class OpenAIClient {
                 const maxTokensValue = getEffectiveMaxTokens(model, requestedMaxTokens);
                 const stream = await this.client.chat.completions.create({
                     model,
-                    messages: allMessages.map(m => ({
+                    messages: allMessages.map((m) => ({
                         role: m.role,
                         content: m.content,
                     })),
@@ -233,11 +246,9 @@ export class OpenAIClient {
                     ...(restrictedParams
                         ? {}
                         : { temperature: options?.temperature ?? LLM_DEFAULTS.TEMPERATURE }),
-                    response_format: options?.responseFormat === 'json'
-                        ? { type: 'json_object' }
-                        : undefined,
+                    response_format: options?.responseFormat === 'json' ? { type: 'json_object' } : undefined,
                     stream: true,
-                });
+                }, { signal: options?.signal });
                 let fullText = '';
                 let inputTokens = 0;
                 let outputTokens = 0;

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

@@ -36,7 +36,7 @@ export declare abstract class BaseTransport extends EventEmitter {
     /**
      * Send a JSON-RPC message to the server.
      */
-    abstract send(message: JSONRPCMessage): void;
+    abstract send(message: JSONRPCMessage, signal?: AbortSignal): void;
     /**
      * Close the transport connection.
      */

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

@@ -49,11 +49,11 @@ export declare class HTTPTransport extends BaseTransport {
      * Unlike SSE transport, this method handles the response synchronously
      * and emits a 'message' event with the response.
      */
-    send(message: JSONRPCMessage): void;
+    send(message: JSONRPCMessage, signal?: AbortSignal): void;
     /**
      * Send a JSON-RPC message and wait for the response.
      */
-    sendAsync(message: JSONRPCMessage): Promise<JSONRPCResponse | null>;
+    sendAsync(message: JSONRPCMessage, signal?: AbortSignal): Promise<JSONRPCResponse | null>;
     /**
      * Handle a streaming HTTP response (text/event-stream).
      * Includes timeout handling to prevent indefinite hangs.

package/dist/transport/http-transport.js

@@ -59,21 +59,32 @@ export class HTTPTransport extends BaseTransport {
      * Unlike SSE transport, this method handles the response synchronously
      * and emits a 'message' event with the response.
      */
-    send(message) {
+    send(message, signal) {
         if (!this.connected) {
             this.emit('error', new Error('Transport not connected'));
             return;
         }
-        this.sendAsync(message).catch((error) => {
+        this.sendAsync(message, signal).catch((error) => {
             this.emit('error', error);
         });
     }
     /**
      * Send a JSON-RPC message and wait for the response.
      */
-    async sendAsync(message) {
+    async sendAsync(message, signal) {
         this.log('Sending message', { message });
         this.abortController = new AbortController();
+        const controller = this.abortController;
+        let abortListener;
+        if (signal) {
+            if (signal.aborted) {
+                controller.abort();
+            }
+            else {
+                abortListener = () => controller.abort();
+                signal.addEventListener('abort', abortListener, { once: true });
+            }
+        }
         const timeoutId = setTimeout(() => {
             this.abortController?.abort();
         }, this.timeout);
@@ -82,7 +93,7 @@ export class HTTPTransport extends BaseTransport {
                 method: 'POST',
                 headers: this.buildHeaders(),
                 body: JSON.stringify(message),
-                signal: this.abortController.signal,
+                signal: controller.signal,
             });
             clearTimeout(timeoutId);
             if (!response.ok) {
@@ -117,6 +128,11 @@ export class HTTPTransport extends BaseTransport {
             }
             throw error;
         }
+        finally {
+            if (signal && abortListener) {
+                signal.removeEventListener('abort', abortListener);
+            }
+        }
     }
     /**
      * Handle a streaming HTTP response (text/event-stream).
@@ -177,7 +193,9 @@ export class HTTPTransport extends BaseTransport {
                         }
                         catch (error) {
                             // Log streaming parse errors for visibility
-                            const preview = data.length > DISPLAY_LIMITS.TRANSPORT_DATA_PREVIEW ? `${data.substring(0, DISPLAY_LIMITS.TRANSPORT_DATA_PREVIEW)}...` : data;
+                            const preview = data.length > DISPLAY_LIMITS.TRANSPORT_DATA_PREVIEW
+                                ? `${data.substring(0, DISPLAY_LIMITS.TRANSPORT_DATA_PREVIEW)}...`
+                                : data;
                             this.logger.warn({ preview, error: error instanceof Error ? error.message : String(error) }, 'Failed to parse SSE message');
                         }
                     }
@@ -189,7 +207,9 @@ export class HTTPTransport extends BaseTransport {
                         }
                         catch {
                             // Not JSON - this is common for non-JSON lines in streams, log only in debug
-                            this.log('Skipping non-JSON line', { preview: trimmedLine.substring(0, DISPLAY_LIMITS.RESPONSE_DATA_PREVIEW) });
+                            this.log('Skipping non-JSON line', {
+                                preview: trimmedLine.substring(0, DISPLAY_LIMITS.RESPONSE_DATA_PREVIEW),
+                            });
                         }
                     }
                 }

package/dist/transport/mcp-client.d.ts

@@ -130,27 +130,39 @@ export declare class MCPClient {
     /**
      * List all tools available on the server.
      */
-    listTools(): Promise<MCPTool[]>;
+    listTools(options?: {
+        signal?: AbortSignal;
+    }): Promise<MCPTool[]>;
     /**
      * List all prompts available on the server.
      */
-    listPrompts(): Promise<MCPPrompt[]>;
+    listPrompts(options?: {
+        signal?: AbortSignal;
+    }): Promise<MCPPrompt[]>;
     /**
      * List all resources available on the server.
      */
-    listResources(): Promise<MCPResource[]>;
+    listResources(options?: {
+        signal?: AbortSignal;
+    }): Promise<MCPResource[]>;
     /**
      * Read a resource from the server by URI.
      */
-    readResource(uri: string): Promise<MCPResourceReadResult>;
+    readResource(uri: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<MCPResourceReadResult>;
     /**
      * Get a prompt from the server with the given arguments.
      */
-    getPrompt(name: string, args?: Record<string, string>): Promise<MCPPromptGetResult>;
+    getPrompt(name: string, args?: Record<string, string>, options?: {
+        signal?: AbortSignal;
+    }): Promise<MCPPromptGetResult>;
     /**
      * Call a tool on the server.
      */
-    callTool(name: string, args?: Record<string, unknown>): Promise<MCPToolCallResult>;
+    callTool(name: string, args?: Record<string, unknown>, options?: {
+        signal?: AbortSignal;
+    }): Promise<MCPToolCallResult>;
     /**
      * Get server capabilities.
      */