@dotsetlabs/bellwether 2.1.2 → 2.1.3

package/dist/constants/core.d.ts

@@ -63,8 +63,6 @@ export declare const TRANSPORT_ERRORS: {
     readonly MAX_ERRORS_TO_COLLECT: 50;
     /** Error messages that indicate a likely server bug (vs environment issue) */
     readonly SERVER_BUG_INDICATORS: readonly RegExp[];
-    /** Error messages that indicate environment/config issues */
-    readonly ENVIRONMENT_ISSUE_INDICATORS: readonly RegExp[];
 };
 /**
  * Interview process configuration defaults.
@@ -508,46 +506,6 @@ export declare const CLI_SECURITY: {
 /**
  * External service URLs.
  */
-export declare const TOKEN_ESTIMATION: {
-    /** Average input tokens per question */
-    readonly AVG_INPUT_PER_QUESTION: 500;
-    /** Average output tokens per question */
-    readonly AVG_OUTPUT_PER_QUESTION: 300;
-    /** Schema overhead tokens per tool */
-    readonly SCHEMA_OVERHEAD_PER_TOOL: 200;
-    /** Character to token ratio (approximate) */
-    readonly CHARS_PER_TOKEN: 4;
-    /** Word adjustment factor */
-    readonly WORD_ADJUSTMENT: 0.3;
-    /** Role/message overhead tokens */
-    readonly MESSAGE_OVERHEAD_TOKENS: 4;
-    /** Default context window when model unknown */
-    readonly DEFAULT_CONTEXT_WINDOW: 16000;
-};
-/**
- * Default token budget limits.
- */
-export declare const TOKEN_BUDGET: {
-    /** Maximum total tokens for an interview */
-    readonly MAX_TOTAL_TOKENS: 1000000;
-    /** Maximum input tokens per request */
-    readonly MAX_INPUT_PER_REQUEST: 100000;
-    /** Maximum output tokens per request */
-    readonly MAX_OUTPUT_PER_REQUEST: 8000;
-    /** Reserved tokens for output in context */
-    readonly OUTPUT_RESERVE: 4000;
-};
-/**
- * Metrics collection configuration.
- */
-export declare const METRICS_CONFIG: {
-    /** Maximum entries in metrics store */
-    readonly MAX_ENTRIES: 10000;
-    /** Latency histogram buckets (ms) */
-    readonly LATENCY_BUCKETS: readonly [10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000];
-    /** Metric name prefix */
-    readonly PREFIX: "bellwether_";
-};
 /**
  * Default model configurations per provider.
  * Uses budget-friendly, non-reasoning models by default for cost efficiency.

package/dist/constants/core.js

@@ -112,14 +112,6 @@ export const TRANSPORT_ERRORS = {
         /protocol.*error/i,
         /invalid.*response/i,
     ],
-    /** Error messages that indicate environment/config issues */
-    ENVIRONMENT_ISSUE_INDICATORS: [
-        /ENOENT/i,
-        /not found/i,
-        /permission denied/i,
-        /EACCES/i,
-        /cannot find module/i,
-    ],
 };
 // ==================== Interview Configuration ====================
 /**
@@ -589,48 +581,6 @@ export const CLI_SECURITY = {
 /**
  * External service URLs.
  */
-export const TOKEN_ESTIMATION = {
-    /** Average input tokens per question */
-    AVG_INPUT_PER_QUESTION: 500,
-    /** Average output tokens per question */
-    AVG_OUTPUT_PER_QUESTION: 300,
-    /** Schema overhead tokens per tool */
-    SCHEMA_OVERHEAD_PER_TOOL: 200,
-    /** Character to token ratio (approximate) */
-    CHARS_PER_TOKEN: 4,
-    /** Word adjustment factor */
-    WORD_ADJUSTMENT: 0.3,
-    /** Role/message overhead tokens */
-    MESSAGE_OVERHEAD_TOKENS: 4,
-    /** Default context window when model unknown */
-    DEFAULT_CONTEXT_WINDOW: 16000,
-};
-// ==================== Token Budget ====================
-/**
- * Default token budget limits.
- */
-export const TOKEN_BUDGET = {
-    /** Maximum total tokens for an interview */
-    MAX_TOTAL_TOKENS: 1000000,
-    /** Maximum input tokens per request */
-    MAX_INPUT_PER_REQUEST: 100000,
-    /** Maximum output tokens per request */
-    MAX_OUTPUT_PER_REQUEST: 8000,
-    /** Reserved tokens for output in context */
-    OUTPUT_RESERVE: 4000,
-};
-// ==================== Metrics ====================
-/**
- * Metrics collection configuration.
- */
-export const METRICS_CONFIG = {
-    /** Maximum entries in metrics store */
-    MAX_ENTRIES: 10000,
-    /** Latency histogram buckets (ms) */
-    LATENCY_BUCKETS: [10, 25, 50, 100, 250, 500, 1000, 2500, 5000, 10000],
-    /** Metric name prefix */
-    PREFIX: 'bellwether_',
-};
 // ==================== LLM Models ====================
 /**
  * Default model configurations per provider.

package/dist/contract/validator.js

@@ -8,6 +8,8 @@
 import { readFileSync, existsSync } from 'fs';
 import * as yaml from 'yaml';
 import { CONTRACT_TESTING } from '../constants.js';
+import { getValueAtPath } from '../utils/jsonpath.js';
+import { detectContentType } from '../utils/content-type.js';
 /**
  * Load a contract from a file.
  */
@@ -398,33 +400,6 @@ function validateOutput(toolName, result, outputContract) {
     }
     return violations;
 }
-/**
- * Get value at a JSONPath-like path.
- * Supports simple paths like $.field.nested[0].value
- */
-function getValueAtPath(obj, path) {
-    // Remove leading $. if present
-    const cleanPath = path.replace(/^\$\.?/, '');
-    if (!cleanPath)
-        return obj;
-    const segments = cleanPath.split(/\.|\[|\]/).filter(Boolean);
-    let current = obj;
-    for (const segment of segments) {
-        if (current === null || current === undefined)
-            return undefined;
-        if (typeof current !== 'object')
-            return undefined;
-        // Handle array index
-        const index = parseInt(segment, 10);
-        if (!isNaN(index) && Array.isArray(current)) {
-            current = current[index];
-        }
-        else {
-            current = current[segment];
-        }
-    }
-    return current;
-}
 /**
  * Get the type name of a value.
  */
@@ -435,26 +410,6 @@ function getValueType(value) {
         return 'array';
     return typeof value;
 }
-/**
- * Detect content type from raw output.
- */
-function detectContentType(raw) {
-    const trimmed = raw.trim();
-    if ((trimmed.startsWith('{') && trimmed.endsWith('}')) ||
-        (trimmed.startsWith('[') && trimmed.endsWith(']'))) {
-        try {
-            JSON.parse(trimmed);
-            return 'json';
-        }
-        catch {
-            // Not valid JSON
-        }
-    }
-    if (/^#|^\*{1,3}[^*]|\[.*\]\(.*\)|^```/.test(trimmed)) {
-        return 'markdown';
-    }
-    return 'text';
-}
 /**
  * Truncate a string for display.
  */

package/dist/interview/question-category.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Canonical question categories used across personas, interview generation, and scenarios.
+ */
+export type QuestionCategory = 'happy_path' | 'edge_case' | 'error_handling' | 'boundary' | 'security';
+//# sourceMappingURL=question-category.d.ts.map

package/dist/interview/question-category.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=question-category.js.map

package/dist/interview/question-types.d.ts

@@ -0,0 +1,80 @@
+import type { QuestionCategory } from './question-category.js';
+/**
+ * Expected outcome for a test question.
+ * - 'success': Test expects the tool to execute successfully
+ * - 'error': Test expects the tool to reject/fail (validation test)
+ * - 'either': Test outcome is acceptable either way
+ */
+export type ExpectedOutcome = 'success' | 'error' | 'either';
+/**
+ * A question to ask about a tool's behavior.
+ */
+export interface InterviewQuestion {
+    /** Description of what this question tests */
+    description: string;
+    /** Category of question */
+    category: QuestionCategory;
+    /** Arguments to pass to the tool */
+    args: Record<string, unknown>;
+    /**
+     * Expected outcome of this test.
+     * Used to determine if the tool behaved correctly.
+     * - 'success': Expects successful execution (happy path)
+     * - 'error': Expects rejection/error (validation test)
+     * - 'either': Either outcome is acceptable
+     */
+    expectedOutcome?: ExpectedOutcome;
+    /** Semantic validation metadata (for tests generated from semantic type inference) */
+    metadata?: {
+        /** The inferred semantic type being tested */
+        semanticType?: string;
+        /** Expected behavior: 'reject' for invalid values, 'accept' for valid */
+        expectedBehavior?: 'reject' | 'accept';
+        /** Confidence level of the semantic type inference (0-1) */
+        confidence?: number;
+        /** Stateful testing metadata */
+        stateful?: {
+            /** Keys injected from prior tool outputs */
+            usedKeys?: string[];
+            /** Keys captured from this response */
+            providedKeys?: string[];
+        };
+        /**
+         * Whether this tool uses operation-based dispatch pattern.
+         * Tools with this pattern have different required args per operation.
+         */
+        operationBased?: boolean;
+        /** The parameter name that selects the operation (e.g., "operation", "action") */
+        operationParam?: string;
+        /** The parameter name that holds operation-specific args (e.g., "args", "params") */
+        argsParam?: string;
+        /**
+         * Whether this tool requires prior state (session, chain, etc.).
+         * These tools need an active session before they can work.
+         */
+        selfStateful?: boolean;
+        /** Reason for self-stateful detection */
+        selfStatefulReason?: string;
+        /**
+         * Whether this tool has complex array schemas requiring structured data.
+         * Simple test data generation often fails for these tools.
+         */
+        hasComplexArrays?: boolean;
+        /** Array parameters with complex item schemas */
+        complexArrayParams?: string[];
+    };
+}
+/**
+ * Assessment of whether a tool interaction outcome matched expectations.
+ */
+export interface OutcomeAssessment {
+    /** What outcome was expected */
+    expected: ExpectedOutcome;
+    /** What actually happened */
+    actual: 'success' | 'error';
+    /** Whether the tool behaved correctly (matches expectation) */
+    correct: boolean;
+    /** True if this was a validation test that correctly rejected invalid input */
+    isValidationSuccess?: boolean;
+}
+//# sourceMappingURL=question-types.d.ts.map

package/dist/interview/question-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=question-types.js.map

package/dist/interview/schema-test-generator.d.ts

@@ -6,27 +6,10 @@
  * 8-12 tests per tool covering boundaries, types, enums, and error handling.
  */
 import type { MCPTool } from '../transport/types.js';
-import type { InterviewQuestion, ExpectedOutcome } from './types.js';
-import type { QuestionCategory } from '../persona/types.js';
+import type { InterviewQuestion } from './types.js';
 import type { SemanticInference } from '../validation/semantic-types.js';
-/**
- * Test fixture pattern for matching parameter names.
- */
-export interface TestFixturePattern {
-    /** Regex pattern to match parameter names */
-    match: string;
-    /** Value to use for matching parameters */
-    value: unknown;
-}
-/**
- * Test fixtures configuration for customizing test values.
- */
-export interface TestFixturesConfig {
-    /** Custom values for specific parameter names (exact match) */
-    parameterValues?: Record<string, unknown>;
-    /** Custom values for parameters matching regex patterns */
-    patterns?: TestFixturePattern[];
-}
+import type { TestFixturesConfig } from './test-fixtures.js';
+export type { TestFixturePattern, TestFixturesConfig } from './test-fixtures.js';
 /**
  * Options for test generation.
  */
@@ -49,15 +32,6 @@ export interface SchemaTestGeneratorResult {
     /** Semantic type inferences for parameters */
     semanticInferences: SemanticInference[];
 }
-/**
- * Determine expected outcome for a test based on its category and description.
- * Uses OUTCOME_ASSESSMENT constants to classify tests.
- *
- * @param category - Test category
- * @param description - Test description
- * @returns Expected outcome: 'success', 'error', or 'either'
- */
-export declare function determineExpectedOutcome(category: QuestionCategory, description: string): ExpectedOutcome;
 /**
  * Generate comprehensive schema-based test cases for a tool.
  *

package/dist/interview/schema-test-generator.js

@@ -5,9 +5,10 @@
  * This module is the core of the enhanced testing capability, producing
  * 8-12 tests per tool covering boundaries, types, enums, and error handling.
  */
-import { SCHEMA_TESTING, SEMANTIC_VALIDATION, OUTCOME_ASSESSMENT } from '../constants.js';
-import { SMART_VALUE_GENERATION, OPERATION_BASED_DETECTION, SELF_STATEFUL_DETECTION, COMPLEX_SCHEMA_DETECTION, } from '../constants/testing.js';
+import { SCHEMA_TESTING, SEMANTIC_VALIDATION } from '../constants.js';
+import { OPERATION_BASED_DETECTION, SELF_STATEFUL_DETECTION, COMPLEX_SCHEMA_DETECTION, } from '../constants/testing.js';
 import { generateSemanticTests } from '../validation/semantic-test-generator.js';
+import { generateSmartStringValue as generateSmartStringValueResult, generateSmartNumberValue as generateSmartNumberValueResult, } from './smart-value-generator.js';
 // ==================== Helper Functions ====================
 /**
  * Get the primary type from a schema property.
@@ -107,39 +108,12 @@ function mergeAllOfSchemas(schemas) {
  * Used for nested array items where we don't have a property name.
  */
 function generateSmartStringValueForSchema(schema) {
-    const description = (schema.description ?? '').toLowerCase();
-    // Check description for explicit format hints
-    for (const { pattern, value } of DATE_FORMAT_PATTERNS) {
-        if (pattern.test(schema.description ?? '') || pattern.test(description)) {
-            return value;
-        }
-    }
-    for (const { pattern, value } of SEMANTIC_FORMAT_PATTERNS) {
-        if (pattern.test(schema.description ?? '') || pattern.test(description)) {
-            return value;
-        }
+    const generated = generateSmartStringValueResult('', schema).value;
+    if (typeof generated === 'string' && generated.length > 0) {
+        return generated;
     }
-    // Check schema format field
-    if (schema.format === 'date')
-        return '2024-01-15';
-    if (schema.format === 'date-time')
-        return '2024-01-15T14:30:00Z';
-    if (schema.format === 'email')
-        return 'test@example.com';
-    if (schema.format === 'uri' || schema.format === 'url')
-        return 'https://example.com';
-    if (schema.format === 'uuid')
-        return '550e8400-e29b-41d4-a716-446655440000';
-    if (schema.format === 'ipv4')
-        return '192.168.1.100';
-    if (schema.format === 'time')
-        return '14:30:00';
-    // Respect minLength constraint
     const minLength = schema.minLength ?? 0;
-    if (minLength > 4) {
-        return 'test'.padEnd(minLength, 'x');
-    }
-    return 'test';
+    return minLength > 4 ? 'test'.padEnd(minLength, 'x') : 'test';
 }
 /**
  * Generate a minimal array that satisfies minItems constraint.
@@ -373,266 +347,17 @@ function generateDefaultValue(propName, prop, fixtures) {
             return 'test';
     }
 }
-/**
- * Pattern matchers for detecting date/time formats in descriptions.
- * Each pattern maps to a format string and example value.
- */
-const DATE_FORMAT_PATTERNS = [
-    // ISO 8601 date patterns
-    {
-        pattern: /YYYY-MM-DD|ISO\s*8601\s*date|date.*format.*YYYY/i,
-        value: '2024-01-15',
-        formatName: 'ISO 8601 date',
-    },
-    { pattern: /YYYY-MM|year-month|month.*format/i, value: '2024-01', formatName: 'year-month' },
-    {
-        pattern: /ISO\s*8601\s*(datetime|timestamp)|datetime.*format|timestamp.*ISO/i,
-        value: '2024-01-15T14:30:00Z',
-        formatName: 'ISO 8601 datetime',
-    },
-    // Unix timestamp patterns
-    {
-        pattern: /unix\s*timestamp|epoch\s*time|seconds\s*since/i,
-        value: '1705330200',
-        formatName: 'Unix timestamp',
-    },
-    {
-        pattern: /milliseconds?\s*(since|timestamp)|ms\s*timestamp/i,
-        value: '1705330200000',
-        formatName: 'Unix timestamp (ms)',
-    },
-    // Time patterns
-    {
-        pattern: /HH:MM:SS|time.*format.*HH|24.hour.*time/i,
-        value: '14:30:00',
-        formatName: '24-hour time',
-    },
-    { pattern: /HH:MM|hour.*minute/i, value: '14:30', formatName: 'hour:minute' },
-    // Other date formats
-    { pattern: /MM\/DD\/YYYY|US\s*date/i, value: '01/15/2024', formatName: 'US date' },
-    { pattern: /DD\/MM\/YYYY|European\s*date/i, value: '15/01/2024', formatName: 'European date' },
-];
-/**
- * Pattern matchers for detecting other semantic types in descriptions.
- */
-const SEMANTIC_FORMAT_PATTERNS = [
-    // Currency/money patterns
-    { pattern: /currency.*amount|dollar.*amount|price/i, value: '99.99', formatName: 'currency' },
-    { pattern: /percentage|percent/i, value: '50', formatName: 'percentage' },
-    // Phone patterns
-    { pattern: /phone.*number|telephone/i, value: '+1-555-123-4567', formatName: 'phone' },
-    // UUID patterns
-    {
-        pattern: /UUID|unique.*identifier/i,
-        value: '550e8400-e29b-41d4-a716-446655440000',
-        formatName: 'UUID',
-    },
-    // IP address patterns
-    { pattern: /IP.*address|IPv4/i, value: '192.168.1.100', formatName: 'IP address' },
-    // JSON patterns
-    { pattern: /JSON\s*string|stringify|serialized/i, value: '{"key": "value"}', formatName: 'JSON' },
-    // Base64 patterns
-    { pattern: /base64|encoded/i, value: 'dGVzdA==', formatName: 'base64' },
-];
-/**
- * Generate a contextually appropriate string value based on property name,
- * constraints, and description.
- *
- * This function implements smart test value generation by:
- * 1. Parsing schema descriptions for format hints (e.g., "YYYY-MM-DD")
- * 2. Checking schema format field
- * 3. Inferring from property name patterns
- */
 function generateSmartStringValue(propName, prop) {
-    const lowerName = propName.toLowerCase();
-    const description = (prop.description ?? '').toLowerCase();
-    // Priority 1: Check description for explicit date/time format hints
-    // This is the most reliable indicator since the schema author specified it
-    for (const { pattern, value } of DATE_FORMAT_PATTERNS) {
-        if (pattern.test(prop.description ?? '') || pattern.test(description)) {
-            return value;
-        }
-    }
-    // Priority 2: Check description for other semantic format hints
-    for (const { pattern, value } of SEMANTIC_FORMAT_PATTERNS) {
-        if (pattern.test(prop.description ?? '') || pattern.test(description)) {
-            return value;
-        }
-    }
-    // Priority 3: Check schema format field (JSON Schema standard)
-    if (prop.format === 'date') {
-        return '2024-01-15';
-    }
-    if (prop.format === 'date-time') {
-        return '2024-01-15T14:30:00Z';
-    }
-    if (prop.format === 'email') {
-        return 'test@example.com';
-    }
-    if (prop.format === 'uri' || prop.format === 'url') {
-        return 'https://example.com';
-    }
-    if (prop.format === 'uuid') {
-        return '550e8400-e29b-41d4-a716-446655440000';
-    }
-    if (prop.format === 'ipv4') {
-        return '192.168.1.100';
-    }
-    if (prop.format === 'time') {
-        return '14:30:00';
-    }
-    // Priority 4: Infer from property name patterns
-    if (lowerName.includes('date') || description.includes('date')) {
-        return '2024-01-15';
-    }
-    if (lowerName.includes('time') || description.includes('time')) {
-        return '14:30:00';
-    }
-    if (lowerName.includes('email') || description.includes('email')) {
-        return 'test@example.com';
-    }
-    if (lowerName.includes('url') ||
-        lowerName.includes('uri') ||
-        description.includes('url') ||
-        description.includes('uri')) {
-        return 'https://example.com';
-    }
-    if (lowerName.includes('path') ||
-        lowerName.includes('directory') ||
-        lowerName.includes('dir') ||
-        description.includes('path')) {
-        return '/tmp/test';
-    }
-    if (lowerName.includes('id') || description.includes('identifier')) {
-        return 'test-id-123';
-    }
-    if (lowerName.includes('name')) {
-        return 'test-name';
-    }
-    if (lowerName.includes('query') || lowerName.includes('search')) {
-        return 'test query';
-    }
-    if (lowerName.includes('token')) {
-        return 'test-token-abc123';
-    }
-    if (lowerName.includes('account') || description.includes('account')) {
-        return 'test-account-123';
-    }
-    if (lowerName.includes('amount') || description.includes('amount')) {
-        return '100.00';
-    }
-    if (lowerName.includes('category') || description.includes('category')) {
-        return 'test-category';
-    }
-    // Default fallback
-    return 'test';
+    const generated = generateSmartStringValueResult(propName, prop).value;
+    return typeof generated === 'string' ? generated : 'test';
 }
 /**
  * Generate a contextually appropriate number value based on constraints and property name.
  * Detects coordinates (latitude/longitude) and pagination parameters.
  */
 function generateSmartNumberValue(prop, propName) {
-    const { COORDINATES, PAGINATION } = SMART_VALUE_GENERATION;
-    const lowerName = (propName ?? '').toLowerCase();
-    const description = (prop.description ?? '').toLowerCase();
-    // Check for latitude patterns
-    for (const pattern of COORDINATES.LATITUDE_PATTERNS) {
-        if (pattern.test(propName ?? '') || pattern.test(description)) {
-            // Ensure value is within valid latitude range
-            const value = COORDINATES.DEFAULTS.latitude;
-            if (prop.minimum !== undefined && value < prop.minimum) {
-                return prop.minimum;
-            }
-            if (prop.maximum !== undefined && value > prop.maximum) {
-                return prop.maximum;
-            }
-            return value;
-        }
-    }
-    // Check for longitude patterns
-    for (const pattern of COORDINATES.LONGITUDE_PATTERNS) {
-        if (pattern.test(propName ?? '') || pattern.test(description)) {
-            // Ensure value is within valid longitude range
-            const value = COORDINATES.DEFAULTS.longitude;
-            if (prop.minimum !== undefined && value < prop.minimum) {
-                return prop.minimum;
-            }
-            if (prop.maximum !== undefined && value > prop.maximum) {
-                return prop.maximum;
-            }
-            return value;
-        }
-    }
-    // Check for pagination patterns
-    for (const pattern of PAGINATION.LIMIT_PATTERNS) {
-        if (pattern.test(propName ?? '')) {
-            const value = PAGINATION.DEFAULTS.limit;
-            if (prop.minimum !== undefined && value < prop.minimum) {
-                return prop.minimum;
-            }
-            if (prop.maximum !== undefined && value > prop.maximum) {
-                return prop.maximum;
-            }
-            return value;
-        }
-    }
-    for (const pattern of PAGINATION.OFFSET_PATTERNS) {
-        if (pattern.test(propName ?? '')) {
-            // Distinguish between offset/skip (start at 0) and page (start at 1)
-            const lowerPropName = (propName ?? '').toLowerCase();
-            if (lowerPropName === 'page' || lowerPropName.includes('page')) {
-                return PAGINATION.DEFAULTS.page;
-            }
-            return PAGINATION.DEFAULTS.offset;
-        }
-    }
-    // Check for year detection in name/description
-    if (lowerName.includes('year') || description.includes('year')) {
-        return 2024;
-    }
-    // Check for percentage
-    if (lowerName.includes('percent') || description.includes('percent')) {
-        return 50;
-    }
-    // Standard value generation based on constraints
-    const min = prop.minimum ?? 0;
-    const max = prop.maximum ?? 100;
-    // Use midpoint between min and max if both are specified
-    if (prop.minimum !== undefined && prop.maximum !== undefined) {
-        return Math.floor((min + max) / 2);
-    }
-    // Use minimum + 1 if only minimum is specified
-    if (prop.minimum !== undefined) {
-        return min + 1;
-    }
-    // Use reasonable defaults
-    return 1;
-}
-/**
- * Determine expected outcome for a test based on its category and description.
- * Uses OUTCOME_ASSESSMENT constants to classify tests.
- *
- * @param category - Test category
- * @param description - Test description
- * @returns Expected outcome: 'success', 'error', or 'either'
- */
-export function determineExpectedOutcome(category, description) {
-    // Check if category expects error
-    if (OUTCOME_ASSESSMENT.EXPECTS_ERROR_CATEGORIES.includes(category)) {
-        return 'error';
-    }
-    // Check if category expects success
-    if (OUTCOME_ASSESSMENT.EXPECTS_SUCCESS_CATEGORIES.includes(category)) {
-        return 'success';
-    }
-    // Check description patterns for error expectation
-    for (const pattern of OUTCOME_ASSESSMENT.EXPECTS_ERROR_PATTERNS) {
-        if (pattern.test(description)) {
-            return 'error';
-        }
-    }
-    // Default to 'either' for edge cases
-    return 'either';
+    const generated = generateSmartNumberValueResult(prop, propName).value;
+    return typeof generated === 'number' ? generated : 1;
 }
 /**
  * Add a question to the list, avoiding duplicates.

package/dist/interview/test-fixtures.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Test fixture pattern for matching parameter names.
+ */
+export interface TestFixturePattern {
+    /** Regex pattern to match parameter names */
+    match: string;
+    /** Value to use for matching parameters */
+    value: unknown;
+}
+/**
+ * Test fixtures configuration for customizing generated test values.
+ */
+export interface TestFixturesConfig {
+    /** Custom values for specific parameter names (exact match) */
+    parameterValues?: Record<string, unknown>;
+    /** Custom values for parameters matching regex patterns */
+    patterns?: TestFixturePattern[];
+}
+//# sourceMappingURL=test-fixtures.d.ts.map

package/dist/interview/test-fixtures.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=test-fixtures.js.map