glirastes 0.3.2 → 0.5.0

package/dist/cjs/server/testing/edge-cases.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runEdgeCaseTest = runEdgeCaseTest;
 const vitest_1 = require("vitest");
+const zod_introspect_js_1 = require("./zod-introspect.js");
 /**
  * Auto-generates edge case tests from tool Zod schemas + custom cases.
  *
@@ -23,7 +24,7 @@ function runEdgeCaseTest(toolRegistry, options) {
     (0, vitest_1.describe)('AI Tool Edge Cases', () => {
         for (const [toolName, toolDef] of toolsWithSchemas) {
             const schema = toolDef.inputSchema;
-            const shape = getObjectShape(schema);
+            const shape = (0, zod_introspect_js_1.getObjectShape)(schema);
             const hasShapeTests = shape && hasTestableFields(shape);
             const custom = customCases[toolName];
             const hasCustom = custom && custom.length > 0;
@@ -89,59 +90,26 @@ function runEdgeCaseTest(toolRegistry, options) {
  */
 function hasTestableFields(shape) {
     for (const [, fieldSchema] of Object.entries(shape)) {
-        const optional = isOptional(fieldSchema);
-        if (!optional)
-            return true; // Required field → generates "rejects missing" test
-        const inner = unwrap(fieldSchema);
-        const typeName = inner._def.typeName;
-        if (typeName === 'ZodEnum' && inner._def.values)
+        if (!(0, zod_introspect_js_1.isOptional)(fieldSchema))
+            return true; // Required field → "rejects missing" test
+        const inner = (0, zod_introspect_js_1.unwrap)(fieldSchema);
+        const type = (0, zod_introspect_js_1.getBaseType)(inner);
+        if (type === 'enum' && (0, zod_introspect_js_1.getEnumValues)(inner).length > 0)
+            return true;
+        if (type === 'array' && (0, zod_introspect_js_1.getArrayMax)(inner) !== null)
+            return true;
+        if (type === 'string' && (0, zod_introspect_js_1.isUuidString)(inner))
             return true;
-        if (typeName === 'ZodArray') {
-            const checks = inner._def.checks ?? [];
-            if (checks.some((c) => c.kind === 'max'))
-                return true;
-        }
-        if (typeName === 'ZodString') {
-            const checks = inner._def.checks ?? [];
-            if (checks.some((c) => c.kind === 'uuid'))
-                return true;
-        }
     }
     return false;
 }
-function getObjectShape(schema) {
-    const def = schema._def;
-    if (def.typeName === 'ZodObject' && typeof def.shape === 'function') {
-        return def.shape();
-    }
-    // Unwrap ZodEffects (e.g. .refine(), .transform())
-    if (def.typeName === 'ZodEffects' && def.innerType) {
-        return getObjectShape(def.innerType);
-    }
-    return null;
-}
-function isOptional(schema) {
-    const name = schema._def.typeName;
-    return name === 'ZodOptional' || name === 'ZodNullable' || name === 'ZodDefault';
-}
-function unwrap(schema) {
-    const name = schema._def.typeName;
-    if ((name === 'ZodOptional' || name === 'ZodNullable' || name === 'ZodDefault') &&
-        schema._def.innerType) {
-        return unwrap(schema._def.innerType);
-    }
-    if (name === 'ZodEffects' && schema._def.innerType) {
-        return unwrap(schema._def.innerType);
-    }
-    return schema;
-}
 function generateShapeTests(shape, parentSchema) {
     // Build a valid base object with placeholder values
     const baseInput = buildMinimalValidInput(shape);
     for (const [fieldName, fieldSchema] of Object.entries(shape)) {
-        const optional = isOptional(fieldSchema);
-        const inner = unwrap(fieldSchema);
-        const typeName = inner._def.typeName;
+        const optional = (0, zod_introspect_js_1.isOptional)(fieldSchema);
+        const inner = (0, zod_introspect_js_1.unwrap)(fieldSchema);
+        const type = (0, zod_introspect_js_1.getBaseType)(inner);
         // Required field: test missing
         if (!optional) {
             (0, vitest_1.it)(`rejects missing ${fieldName} (required)`, () => {
@@ -152,9 +120,9 @@ function generateShapeTests(shape, parentSchema) {
             });
         }
         // Enum: test each valid value + invalid
-        if (typeName === 'ZodEnum' && inner._def.values) {
-            const values = inner._def.values;
-            for (const val of values) {
+        const enumValues = type === 'enum' ? (0, zod_introspect_js_1.getEnumValues)(inner) : [];
+        if (enumValues.length > 0) {
+            for (const val of enumValues) {
                 (0, vitest_1.it)(`accepts valid ${fieldName} enum: ${val}`, () => {
                     const result = parentSchema.safeParse({ ...baseInput, [fieldName]: val });
                     (0, vitest_1.expect)(result.success).toBe(true);
@@ -166,11 +134,9 @@ function generateShapeTests(shape, parentSchema) {
             });
         }
         // Array with max: test at limit and over limit
-        if (typeName === 'ZodArray') {
-            const checks = inner._def.checks ?? [];
-            const maxCheck = checks.find((c) => c.kind === 'max');
-            if (maxCheck && typeof maxCheck.value === 'number') {
-                const max = maxCheck.value;
+        if (type === 'array') {
+            const max = (0, zod_introspect_js_1.getArrayMax)(inner);
+            if (max !== null) {
                 const arrayFillValue = getArrayElementPlaceholder(inner);
                 (0, vitest_1.it)(`accepts ${fieldName} at max(${max})`, () => {
                     const result = parentSchema.safeParse({
@@ -189,31 +155,24 @@ function generateShapeTests(shape, parentSchema) {
             }
         }
         // String with UUID check
-        if (typeName === 'ZodString') {
-            const checks = inner._def.checks ?? [];
-            const hasUuid = checks.some((c) => c.kind === 'uuid');
-            if (hasUuid) {
-                (0, vitest_1.it)(`rejects invalid ${fieldName} UUID: "not-a-uuid"`, () => {
-                    const result = parentSchema.safeParse({ ...baseInput, [fieldName]: 'not-a-uuid' });
-                    (0, vitest_1.expect)(result.success).toBe(false);
-                });
-            }
+        if (type === 'string' && (0, zod_introspect_js_1.isUuidString)(inner)) {
+            (0, vitest_1.it)(`rejects invalid ${fieldName} UUID: "not-a-uuid"`, () => {
+                const result = parentSchema.safeParse({ ...baseInput, [fieldName]: 'not-a-uuid' });
+                (0, vitest_1.expect)(result.success).toBe(false);
+            });
         }
     }
 }
 function getArrayElementPlaceholder(arraySchema) {
-    const elementSchema = arraySchema._def.type;
+    const elementSchema = (0, zod_introspect_js_1.getArrayElement)(arraySchema);
     if (elementSchema) {
-        const elInner = unwrap(elementSchema);
-        const elType = elInner._def.typeName;
-        if (elType === 'ZodString') {
-            const elChecks = elInner._def.checks ?? [];
-            if (elChecks.some((c) => c.kind === 'uuid')) {
-                return '00000000-0000-0000-0000-000000000000';
-            }
-            return 'test-id';
+        const elType = (0, zod_introspect_js_1.getBaseType)(elementSchema);
+        if (elType === 'string') {
+            return (0, zod_introspect_js_1.isUuidString)(elementSchema)
+                ? '00000000-0000-0000-0000-000000000000'
+                : 'test-id';
         }
-        if (elType === 'ZodNumber')
+        if (elType === 'number')
             return 1;
     }
     return 'test-id';
@@ -221,44 +180,36 @@ function getArrayElementPlaceholder(arraySchema) {
 function buildMinimalValidInput(shape) {
     const input = {};
     for (const [name, schema] of Object.entries(shape)) {
-        if (isOptional(schema))
+        if ((0, zod_introspect_js_1.isOptional)(schema))
             continue;
-        const inner = unwrap(schema);
-        const typeName = inner._def.typeName;
-        if (typeName === 'ZodString') {
-            const checks = inner._def.checks ?? [];
-            if (checks.some((c) => c.kind === 'uuid')) {
-                input[name] = '00000000-0000-0000-0000-000000000000';
-            }
-            else {
-                input[name] = 'test-value';
-            }
+        const inner = (0, zod_introspect_js_1.unwrap)(schema);
+        const type = (0, zod_introspect_js_1.getBaseType)(inner);
+        if (type === 'string') {
+            input[name] = (0, zod_introspect_js_1.isUuidString)(inner)
+                ? '00000000-0000-0000-0000-000000000000'
+                : 'test-value';
         }
-        else if (typeName === 'ZodNumber') {
+        else if (type === 'number') {
             input[name] = 1;
         }
-        else if (typeName === 'ZodBoolean') {
+        else if (type === 'boolean') {
             input[name] = false;
         }
-        else if (typeName === 'ZodEnum' && inner._def.values) {
-            input[name] = inner._def.values[0];
+        else if (type === 'enum') {
+            const values = (0, zod_introspect_js_1.getEnumValues)(inner);
+            input[name] = values.length > 0 ? values[0] : 'test';
         }
-        else if (typeName === 'ZodArray') {
+        else if (type === 'array') {
             // Introspect array element type to generate valid placeholders
-            const elementSchema = inner._def.type;
+            const elementSchema = (0, zod_introspect_js_1.getArrayElement)(inner);
             if (elementSchema) {
-                const elInner = unwrap(elementSchema);
-                const elType = elInner._def.typeName;
-                if (elType === 'ZodString') {
-                    const elChecks = elInner._def.checks ?? [];
-                    if (elChecks.some((c) => c.kind === 'uuid')) {
-                        input[name] = ['00000000-0000-0000-0000-000000000000'];
-                    }
-                    else {
-                        input[name] = ['test-id'];
-                    }
+                const elType = (0, zod_introspect_js_1.getBaseType)(elementSchema);
+                if (elType === 'string') {
+                    input[name] = (0, zod_introspect_js_1.isUuidString)(elementSchema)
+                        ? ['00000000-0000-0000-0000-000000000000']
+                        : ['test-id'];
                 }
-                else if (elType === 'ZodNumber') {
+                else if (elType === 'number') {
                     input[name] = [1];
                 }
                 else {

package/dist/cjs/server/testing/guardrails.js

@@ -2,71 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runGuardrailsTest = runGuardrailsTest;
 const vitest_1 = require("vitest");
-// ============================================================================
-// Local guardrails implementation for testing (basic input validation only).
-// Full guardrails with Lancer Warden delegation live in server-pro.
-// ============================================================================
-const DEFAULT_INJECTION_PATTERNS = [
-    /ignore\s+(all\s+)?previous\s+instructions/i,
-    /tell\s+me\s+your\s+(system\s+)?prompt/i,
-    /you\s+are\s+now\s+a\s+different/i,
-    /act\s+as\s+an?\s+(admin|root|system)/i,
-    /bypass\s+(security|auth)/i,
-];
-function createLocalGuardrails(config) {
-    const maxLength = config?.maxInputLength ?? 4000;
-    const injectionEnabled = config?.enableInjectionDetection ?? true;
-    const patterns = [
-        ...DEFAULT_INJECTION_PATTERNS,
-        ...(config?.injectionPatterns ?? []),
-    ];
-    function validate(input) {
-        const trimmed = input.trim();
-        // Block empty / whitespace-only
-        if (trimmed.length === 0) {
-            return { valid: false, blocked: true, reason: 'empty_input', sanitized: '' };
-        }
-        // Block oversized
-        if (trimmed.length > maxLength) {
-            return {
-                valid: false,
-                blocked: true,
-                reason: 'input_too_long',
-                sanitized: trimmed.slice(0, maxLength),
-            };
-        }
-        // Injection detection (signal only, not blocked)
-        if (injectionEnabled) {
-            for (const pattern of patterns) {
-                if (pattern.test(trimmed)) {
-                    return {
-                        valid: true,
-                        blocked: false,
-                        reason: 'prompt_injection_signal',
-                        sanitized: trimmed,
-                    };
-                }
-            }
-        }
-        // Custom validators
-        if (config?.customValidators) {
-            for (const validator of config.customValidators) {
-                const result = validator.validate(trimmed);
-                if (!result.valid)
-                    return result;
-            }
-        }
-        return { valid: true, blocked: false, sanitized: trimmed };
-    }
-    function sanitize(input) {
-        const trimmed = input.trim();
-        if (trimmed.length > maxLength) {
-            return trimmed.slice(0, maxLength);
-        }
-        return trimmed;
-    }
-    return { validate, sanitize };
-}
+const local_guardrails_js_1 = require("../core/local-guardrails.js");
 const DEFAULT_VALID_INPUTS = [
     'show my tasks',
     'create a task called Shopping',
@@ -94,7 +30,7 @@ const DEFAULT_INJECTION_INPUTS = [
  */
 function runGuardrailsTest(guardrailsConfig, options) {
     const maxLength = guardrailsConfig?.maxInputLength ?? 4000;
-    const guardrails = createLocalGuardrails(guardrailsConfig);
+    const guardrails = (0, local_guardrails_js_1.createLocalGuardrails)(guardrailsConfig);
     const validInputs = [
         ...DEFAULT_VALID_INPUTS,
         ...(options?.extraValidInputs ?? []),

package/dist/cjs/server/testing/helpers.js

@@ -5,69 +5,8 @@ exports.simulatePipeline = simulatePipeline;
 exports.collectAllModuleTools = collectAllModuleTools;
 exports.getToolsByModule = getToolsByModule;
 const index_js_1 = require("../core/index.js");
-// ============================================================================
-// Local guardrails for pipeline simulation (basic input validation only).
-// Full guardrails with Lancer Warden delegation live in server-pro.
-// ============================================================================
-const DEFAULT_INJECTION_PATTERNS = [
-    /ignore\s+(all\s+)?previous\s+instructions/i,
-    /tell\s+me\s+your\s+(system\s+)?prompt/i,
-    /you\s+are\s+now\s+a\s+different/i,
-    /act\s+as\s+an?\s+(admin|root|system)/i,
-    /bypass\s+(security|auth)/i,
-];
-function createLocalGuardrails(config) {
-    const maxLength = config?.maxInputLength ?? 4000;
-    const injectionEnabled = config?.enableInjectionDetection ?? true;
-    const patterns = [
-        ...DEFAULT_INJECTION_PATTERNS,
-        ...(config?.injectionPatterns ?? []),
-    ];
-    function validate(input) {
-        const trimmed = input.trim();
-        if (trimmed.length === 0) {
-            return { valid: false, blocked: true, reason: 'empty_input', sanitized: '' };
-        }
-        if (trimmed.length > maxLength) {
-            return {
-                valid: false,
-                blocked: true,
-                reason: 'input_too_long',
-                sanitized: trimmed.slice(0, maxLength),
-            };
-        }
-        if (injectionEnabled) {
-            for (const pattern of patterns) {
-                if (pattern.test(trimmed)) {
-                    return {
-                        valid: true,
-                        blocked: false,
-                        reason: 'prompt_injection_signal',
-                        sanitized: trimmed,
-                    };
-                }
-            }
-        }
-        if (config?.customValidators) {
-            for (const validator of config.customValidators) {
-                const result = validator.validate(trimmed);
-                if (!result.valid)
-                    return result;
-            }
-        }
-        return { valid: true, blocked: false, sanitized: trimmed };
-    }
-    function sanitize(input) {
-        const trimmed = input.trim();
-        if (trimmed.length > maxLength) {
-            return trimmed.slice(0, maxLength);
-        }
-        return trimmed;
-    }
-    return { validate, sanitize };
-}
 function buildPipelineComponents(modules, guardrailsConfig, confidenceThresholds) {
-    const guardrails = createLocalGuardrails(guardrailsConfig);
+    const guardrails = (0, index_js_1.createLocalGuardrails)(guardrailsConfig);
     const router = (0, index_js_1.createAiRouter)({ modules, confidenceThresholds });
     return { guardrails, router, modules };
 }

package/dist/cjs/server/testing/index.d.ts

@@ -1,6 +1,7 @@
 export { createAiTestSuite } from './create-test-suite.js';
 export type { TestSuiteConfig, RoutingTestCase, GuardrailsTestOptions, SimulatedPipelineResult, AiTestSuite, CombinationTestCase, CombinationTestOptions, ExecutionStep, EdgeCaseTestOptions, CustomEdgeCase, SchemaConsistencyChain, SchemaConsistencyOptions, RegressionTestCase, RegressionContext, MockToolExecutor, ToolDefinitionForTest, } from './types.js';
 export { runSmokeTest } from './smoke.js';
+export { assertModuleRegistryParity } from './registry-parity.js';
 export { runRoutingTest } from './routing.js';
 export { runGuardrailsTest } from './guardrails.js';
 export { runApprovalTest } from './approvals.js';

package/dist/cjs/server/testing/index.js

@@ -7,13 +7,15 @@
 // No LLM calls needed.
 // ============================================================================
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getToolsByModule = exports.collectAllModuleTools = exports.simulatePipeline = exports.buildPipelineComponents = exports.createMockToolExecutor = exports.runRegressionTest = exports.runSchemaConsistencyTest = exports.runEdgeCaseTest = exports.runCombinationTest = exports.runApprovalTest = exports.runGuardrailsTest = exports.runRoutingTest = exports.runSmokeTest = exports.createAiTestSuite = void 0;
+exports.getToolsByModule = exports.collectAllModuleTools = exports.simulatePipeline = exports.buildPipelineComponents = exports.createMockToolExecutor = exports.runRegressionTest = exports.runSchemaConsistencyTest = exports.runEdgeCaseTest = exports.runCombinationTest = exports.runApprovalTest = exports.runGuardrailsTest = exports.runRoutingTest = exports.assertModuleRegistryParity = exports.runSmokeTest = exports.createAiTestSuite = void 0;
 // Main API
 var create_test_suite_js_1 = require("./create-test-suite.js");
 Object.defineProperty(exports, "createAiTestSuite", { enumerable: true, get: function () { return create_test_suite_js_1.createAiTestSuite; } });
 // Low-level building blocks (for advanced usage)
 var smoke_js_1 = require("./smoke.js");
 Object.defineProperty(exports, "runSmokeTest", { enumerable: true, get: function () { return smoke_js_1.runSmokeTest; } });
+var registry_parity_js_1 = require("./registry-parity.js");
+Object.defineProperty(exports, "assertModuleRegistryParity", { enumerable: true, get: function () { return registry_parity_js_1.assertModuleRegistryParity; } });
 var routing_js_1 = require("./routing.js");
 Object.defineProperty(exports, "runRoutingTest", { enumerable: true, get: function () { return routing_js_1.runRoutingTest; } });
 var guardrails_js_1 = require("./guardrails.js");

package/dist/cjs/server/testing/registry-parity.d.ts

@@ -0,0 +1,18 @@
+import type { ModuleDefinition } from '../../types.js';
+/**
+ * Assert that every tool a module references is actually served by the
+ * execution registry / manifest. Modules referencing retired names once
+ * shipped an app whose model could not call a single domain tool while every
+ * fixture-based probe stayed green — this check must always run against the
+ * real served names, never against a test fixture.
+ *
+ * `servedToolNames` accepts manifest names in either spelling: the signed
+ * dotted definitionId (`ui.navigate`) or its model-safe encoding
+ * (`ui_navigate`). `extraToolNames` covers locally added tools such as
+ * `suggest_followups`.
+ */
+export declare function assertModuleRegistryParity(options: {
+    modules: ReadonlyArray<ModuleDefinition>;
+    servedToolNames: Iterable<string>;
+    extraToolNames?: Iterable<string>;
+}): void;

package/dist/cjs/server/testing/registry-parity.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertModuleRegistryParity = assertModuleRegistryParity;
+const local_tool_bindings_js_1 = require("../../runtime/local-tool-bindings.js");
+/**
+ * Assert that every tool a module references is actually served by the
+ * execution registry / manifest. Modules referencing retired names once
+ * shipped an app whose model could not call a single domain tool while every
+ * fixture-based probe stayed green — this check must always run against the
+ * real served names, never against a test fixture.
+ *
+ * `servedToolNames` accepts manifest names in either spelling: the signed
+ * dotted definitionId (`ui.navigate`) or its model-safe encoding
+ * (`ui_navigate`). `extraToolNames` covers locally added tools such as
+ * `suggest_followups`.
+ */
+function assertModuleRegistryParity(options) {
+    const served = new Set();
+    for (const name of options.servedToolNames) {
+        served.add(name);
+        served.add((0, local_tool_bindings_js_1.modelFacingToolName)(name));
+    }
+    for (const name of options.extraToolNames ?? []) {
+        served.add(name);
+        served.add((0, local_tool_bindings_js_1.modelFacingToolName)(name));
+    }
+    const offenders = [];
+    for (const module of options.modules) {
+        for (const tool of module.tools) {
+            if (!served.has(tool) && !served.has((0, local_tool_bindings_js_1.modelFacingToolName)(tool))) {
+                offenders.push(`${module.id}: ${tool}`);
+            }
+        }
+    }
+    if (offenders.length > 0) {
+        throw new Error('Module tools unknown to the served registry '
+            + '(module configuration drift):\n'
+            + offenders.join('\n'));
+    }
+}

package/dist/cjs/server/testing/schema-consistency.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runSchemaConsistencyTest = runSchemaConsistencyTest;
 const vitest_1 = require("vitest");
+const zod_introspect_js_1 = require("./zod-introspect.js");
 /**
  * Verifies that tool output field types match the input field types
  * of downstream tools in declared workflow chains.
@@ -21,36 +22,14 @@ function runSchemaConsistencyTest(toolRegistry, options) {
                 // Target tool must have inputSchema with the target field
                 const toSchema = toTool.inputSchema;
                 (0, vitest_1.expect)(toSchema, `Target tool "${chain.to}" has no inputSchema`).toBeDefined();
-                const toShape = getShape(toSchema);
+                const toShape = (0, zod_introspect_js_1.getObjectShape)(toSchema);
                 (0, vitest_1.expect)(toShape, `Target tool "${chain.to}" inputSchema is not an object`).not.toBeNull();
-                const targetField = resolveField(toShape, chain.targetField);
+                const targetField = toShape[chain.targetField] ?? null;
                 (0, vitest_1.expect)(targetField, `Target field "${chain.targetField}" not found in ${chain.to} inputSchema`).not.toBeNull();
                 // Verify type compatibility
-                const targetType = getBaseTypeName(targetField);
-                (0, vitest_1.expect)(['ZodString', 'ZodNumber', 'ZodArray', 'ZodEnum', 'ZodBoolean'].includes(targetType), `Target field "${chain.targetField}" in ${chain.to} has unrecognized type: ${targetType}`).toBe(true);
+                const targetType = (0, zod_introspect_js_1.getBaseType)(targetField);
+                (0, vitest_1.expect)(['string', 'number', 'array', 'enum', 'boolean'].includes(targetType ?? ''), `Target field "${chain.targetField}" in ${chain.to} has unrecognized type: ${targetType}`).toBe(true);
             });
         }
     });
 }
-function getShape(schema) {
-    const def = schema._def;
-    if (def.typeName === 'ZodObject' && typeof def.shape === 'function') {
-        return def.shape();
-    }
-    if ((def.typeName === 'ZodEffects' || def.typeName === 'ZodOptional') && def.innerType) {
-        return getShape(def.innerType);
-    }
-    return null;
-}
-function resolveField(shape, path) {
-    if (shape[path])
-        return shape[path];
-    return null;
-}
-function getBaseTypeName(schema) {
-    const def = schema._def;
-    if (def.typeName === 'ZodOptional' || def.typeName === 'ZodNullable' || def.typeName === 'ZodDefault') {
-        return def.innerType ? getBaseTypeName(def.innerType) : def.typeName;
-    }
-    return def.typeName;
-}

package/dist/cjs/server/testing/smoke.d.ts

@@ -1,10 +1,11 @@
 import type { ModuleDefinition } from '../../types.js';
+export { TOOL_NAME_PATTERN } from '../../runtime/local-tool-bindings.js';
 /**
  * Auto-generates smoke tests from module definitions.
  *
  * Tests:
  * - Every module has at least 1 tool
- * - All tool names use snake_case
+ * - All tool names follow the naming convention
  * - No duplicate tool names within a module
  * - If a tool registry is provided, all module tools exist in it
  */

package/dist/cjs/server/testing/smoke.js

@@ -1,14 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_NAME_PATTERN = void 0;
 exports.runSmokeTest = runSmokeTest;
 const vitest_1 = require("vitest");
 const helpers_js_1 = require("./helpers.js");
+var local_tool_bindings_js_1 = require("../../runtime/local-tool-bindings.js");
+Object.defineProperty(exports, "TOOL_NAME_PATTERN", { enumerable: true, get: function () { return local_tool_bindings_js_1.TOOL_NAME_PATTERN; } });
+const local_tool_bindings_js_2 = require("../../runtime/local-tool-bindings.js");
 /**
  * Auto-generates smoke tests from module definitions.
  *
  * Tests:
  * - Every module has at least 1 tool
- * - All tool names use snake_case
+ * - All tool names follow the naming convention
  * - No duplicate tool names within a module
  * - If a tool registry is provided, all module tools exist in it
  */
@@ -31,9 +35,9 @@ function runSmokeTest(modules, toolRegistry) {
         });
         (0, vitest_1.describe)('tool naming conventions', () => {
             const allTools = Object.values(toolsByModule).flat();
-            (0, vitest_1.it)('all tool names use snake_case', () => {
+            (0, vitest_1.it)('all tool names follow the naming convention', () => {
                 for (const tool of allTools) {
-                    (0, vitest_1.expect)(tool, `Tool "${tool}" should be snake_case`).toMatch(/^[a-z][a-z0-9_]*$/);
+                    (0, vitest_1.expect)(tool, `Tool "${tool}" should be a definitionId or snake_case name`).toMatch(local_tool_bindings_js_2.TOOL_NAME_PATTERN);
                 }
             });
             (0, vitest_1.it)('no duplicate tool names within a module', () => {

package/dist/cjs/server/testing/types.d.ts

@@ -47,7 +47,7 @@ export interface SimulatedPipelineResult {
     tools: string[];
     module: string | null;
     intent: IntentClassification;
-    strategy?: 'single' | 'expanded' | 'all';
+    strategy?: 'single' | 'expanded' | 'all' | 'none';
 }
 export interface AiTestSuite {
     /** Auto-generated smoke tests: module completeness, tool naming, no duplicates */

package/dist/cjs/server/testing/zod-introspect.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Schema introspection helpers (Zod v3/v4 and generated JSON Schema).
+ *
+ * Centralizes all access to Zod's internal `_zod.def` representation so the
+ * test-suite generators (`edge-cases.ts`, `schema-consistency.ts`) don't each
+ * reach into internals independently. If a future Zod version changes its
+ * internal shape, only this file — covered by `zod-introspect.test.ts` — needs
+ * updating, and the unit tests will catch a silent regression (introspection
+ * returning nothing) instead of letting it ship as a green-but-empty suite.
+ */
+/** The normalized Zod v4 type tag (e.g. 'object', 'string', 'array', 'enum'). */
+export declare function getSchemaType(schema: unknown): string | undefined;
+/**
+ * True if the field is optional, nullable, or has a default — i.e. an input
+ * is not strictly required to provide a concrete value. Matches the historical
+ * behaviour of the edge-case generator, which skips the "rejects missing"
+ * boundary test for any of these.
+ */
+export declare function isOptional(schema: unknown): boolean;
+/** Strip optional/nullable/default/pipe wrappers to the base schema. */
+export declare function unwrap<T = unknown>(schema: T): T;
+/** The base Zod type tag after unwrapping (e.g. an optional string → 'string'). */
+export declare function getBaseType(schema: unknown): string | undefined;
+/**
+ * The field map of an object schema, unwrapping optional/default/pipe wrappers.
+ * Returns null for non-object schemas.
+ */
+export declare function getObjectShape(schema: unknown): Record<string, unknown> | null;
+/** The string members of an enum schema (after unwrapping). */
+export declare function getEnumValues(schema: unknown): string[];
+/** The element schema of an array (after unwrapping), or null. */
+export declare function getArrayElement(schema: unknown): unknown | null;
+/** The `.max(n)` length constraint on an array schema, or null. */
+export declare function getArrayMax(schema: unknown): number | null;
+/** True if a string schema carries the given format check (e.g. 'uuid'). */
+export declare function hasStringFormat(schema: unknown, format: string): boolean;
+/** True if a string schema is a UUID. */
+export declare function isUuidString(schema: unknown): boolean;