@artemiskit/core 0.3.0 → 0.4.1

package/src/scenario/schema.ts

@@ -20,6 +20,7 @@ export const ProviderSchema = z.enum([
   'ollama',
   'langchain',
   'deepagents',
+  'ling',
   'custom',
 ]);
 
@@ -60,6 +61,9 @@ export const ProviderConfigSchema = z
     // DeepAgents specific
     captureTraces: z.boolean().optional(),
     captureMessages: z.boolean().optional(),
+    thinking: z.object({ type: z.enum(['enabled', 'disabled']) }).optional(),
+    enableSearch: z.boolean().optional(),
+    searchOptions: z.record(z.unknown()).optional(),
   })
   .optional();
 
@@ -91,6 +95,8 @@ const BaseExpectedSchema = z.discriminatedUnion('type', [
     model: z.string().optional(),
     provider: ProviderSchema.optional(),
     threshold: z.number().min(0).max(1).default(0.7),
+    /** Require exact, validated JSON from the judge for assurance assessments. */
+    strict: z.boolean().optional().default(false),
   }),
 
   z.object({
@@ -116,6 +122,14 @@ const BaseExpectedSchema = z.discriminatedUnion('type', [
     config: z.record(z.unknown()).optional(),
   }),
 
+  z.object({
+    type: z.literal('tool_trace'),
+    requiredTools: z.array(z.string()).optional(),
+    forbiddenTools: z.array(z.string()).optional(),
+    ordered: z.boolean().optional().default(false),
+    maxCalls: z.number().int().min(0).optional(),
+  }),
+
   z.object({
     type: z.literal('similarity'),
     value: z.string(),
@@ -155,10 +169,39 @@ export const ExpectedSchema = z.union([BaseExpectedSchema, CombinedExpectedSchem
  * Chat message schema
  */
 export const ChatMessageSchema = z.object({
-  role: z.enum(['system', 'user', 'assistant']),
+  role: z.enum(['system', 'user', 'assistant', 'tool']),
   content: z.string(),
+  name: z.string().optional(),
+  toolCallId: z.string().optional(),
+  tool_calls: z
+    .array(
+      z.object({
+        id: z.string(),
+        type: z.literal('function'),
+        function: z.object({ name: z.string(), arguments: z.string() }),
+      })
+    )
+    .optional(),
 });
 
+const ToolSchema = z
+  .object({
+    type: z.literal('function'),
+    function: z.object({
+      name: z.string(),
+      description: z.string().optional(),
+      parameters: z.record(z.unknown()),
+    }),
+  })
+  .strict();
+const ToolFixtureSchema = z
+  .object({
+    when: z.record(z.unknown()).optional(),
+    result: z.unknown().optional(),
+    error: z.string().optional(),
+  })
+  .strict();
+
 /**
  * Variables schema - key-value pairs for template substitution
  */
@@ -211,6 +254,18 @@ export const ScenarioSchema = z.object({
     .object({
       systemPrompt: z.string().optional(),
       functions: z.array(z.unknown()).optional(),
+      tools: z.array(ToolSchema).optional(),
+      fixtures: z.record(z.array(ToolFixtureSchema)).optional(),
+      toolLoop: z
+        .object({
+          enabled: z.boolean().default(false),
+          maxSteps: z.number().int().min(1).max(10).default(5),
+          timeoutMs: z.number().int().min(1).max(300_000).default(60_000),
+          maxToolResultBytes: z.number().int().min(1).max(1_048_576).default(32_768),
+          rejectDuplicateCalls: z.boolean().default(true),
+        })
+        .strict()
+        .optional(),
     })
     .optional(),
   cases: z.array(TestCaseSchema).min(1),

package/src/storage/local.test.ts

@@ -77,6 +77,30 @@ describe('LocalStorageAdapter', () => {
     expect(loaded.metrics.success_rate).toBe(0.8);
   });
 
+  test('rejects malformed evaluator evidence before writing a standard run', async () => {
+    const malformed = {
+      ...mockManifest,
+      run_id: 'invalid-evidence',
+      cases: [
+        {
+          id: 'case-1',
+          ok: false,
+          score: 0,
+          matcherType: 'custom',
+          latencyMs: 1,
+          tokens: { prompt: 0, completion: 0, total: 0 },
+          prompt: 'prompt',
+          response: 'response',
+          expected: {},
+          tags: [],
+          evidence: { evaluator: 'custom', threshold: 2 },
+        },
+      ],
+    } as RunManifest;
+
+    await expect(storage.save(malformed)).rejects.toThrow('invalid evidence threshold');
+  });
+
   test('throws error for non-existent run', async () => {
     await expect(storage.load('non-existent-run')).rejects.toThrow('Run not found');
   });

package/src/storage/local.ts

@@ -4,7 +4,14 @@
 
 import { mkdir, readFile, readdir, unlink, writeFile } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
-import type { AnyManifest, RedTeamManifest, RunManifest, StressManifest } from '../artifacts/types';
+import {
+  type AnyManifest,
+  type RedTeamManifest,
+  type RunManifest,
+  type StressManifest,
+  assertRunManifestIntegrity,
+  isRunManifest,
+} from '../artifacts/types';
 import type {
   BaselineMetadata,
   BaselineStorageAdapter,
@@ -78,6 +85,9 @@ export class LocalStorageAdapter implements BaselineStorageAdapter {
   }
 
   async save(manifest: AnyManifest): Promise<string> {
+    if (isRunManifest(manifest)) {
+      assertRunManifestIntegrity(manifest);
+    }
     const dir = join(this.basePath, manifest.project);
     await mkdir(dir, { recursive: true });
 
@@ -106,7 +116,8 @@ export class LocalStorageAdapter implements BaselineStorageAdapter {
     if (getManifestType(manifest) !== 'run') {
       throw new Error(`Run ${runId} is not a standard run manifest`);
     }
-    return manifest as RunManifest;
+    assertRunManifestIntegrity(manifest);
+    return manifest;
   }
 
   async loadRedTeam(runId: string): Promise<RedTeamManifest> {

package/src/storage/supabase.test.ts

@@ -181,6 +181,41 @@ describe('SupabaseStorageAdapter', () => {
       const result = await adapter.save(manifest);
 
       expect(result).toBe('test-project/test-run-123.json');
+      expect(mockUpsert.mock.calls[0][0]).toMatchObject({
+        total_attempts: 10,
+        valid_evaluations: 10,
+        invalid_evaluations: 0,
+        outcome_rate_denominator: 10,
+      });
+    });
+
+    it('should save manifest integrity counts without using invalid measurements as outcomes', async () => {
+      const manifest = createMockManifest({
+        cases: [],
+        metrics: {
+          ...createMockManifest().metrics,
+          total_attempts: 7,
+          valid_evaluations: 4,
+          invalid_evaluations: 2,
+          outcome_rate_denominator: 4,
+          passed_cases: 3,
+          failed_cases: 1,
+          success_rate: 0.75,
+        },
+      });
+      mockStorage.mockReturnValue({ upload: mock(() => Promise.resolve({ error: null })) });
+      const mockUpsert = mock(() => Promise.resolve({ error: null }));
+      mockFrom.mockReturnValue({ upsert: mockUpsert });
+
+      await adapter.save(manifest);
+
+      expect(mockUpsert.mock.calls[0][0]).toMatchObject({
+        total_attempts: 7,
+        valid_evaluations: 4,
+        invalid_evaluations: 2,
+        outcome_rate_denominator: 4,
+        success_rate: 0.75,
+      });
     });
 
     it('should throw error on storage upload failure', async () => {
@@ -206,6 +241,22 @@ describe('SupabaseStorageAdapter', () => {
 
       await expect(adapter.save(manifest)).rejects.toThrow('Failed to save run metadata');
     });
+
+    it('rejects malformed evaluator evidence before uploading a manifest', async () => {
+      const manifest = createMockManifest({
+        cases: [
+          {
+            ...createMockCaseResult('case-invalid-evidence', false),
+            evidence: { evaluator: 'custom', validation: { status: 'unknown' } },
+          } as never,
+        ],
+      });
+      const upload = mock(() => Promise.resolve({ error: null }));
+      mockStorage.mockReturnValue({ upload });
+
+      await expect(adapter.save(manifest)).rejects.toThrow('invalid evidence validation');
+      expect(upload).not.toHaveBeenCalled();
+    });
   });
 
   describe('load', () => {
@@ -253,6 +304,36 @@ describe('SupabaseStorageAdapter', () => {
 
       await expect(adapter.load('non-existent')).rejects.toThrow('Run not found');
     });
+
+    it('rejects a downloaded manifest with malformed evaluator evidence', async () => {
+      const manifest = createMockManifest({
+        cases: [
+          {
+            ...createMockCaseResult('case-invalid-evidence', false),
+            evidence: { evaluator: 'custom', score: Number.NaN },
+          } as never,
+        ],
+      });
+      mockFrom.mockReturnValue({
+        select: mock(() => ({
+          eq: mock(() => ({
+            single: mock(() =>
+              Promise.resolve({
+                data: { manifest_path: 'test-project/test-run-123.json' },
+                error: null,
+              })
+            ),
+          })),
+        })),
+      });
+      mockStorage.mockReturnValue({
+        download: mock(() =>
+          Promise.resolve({ data: new Blob([JSON.stringify(manifest)]), error: null })
+        ),
+      });
+
+      await expect(adapter.load('test-run-123')).rejects.toThrow('invalid evidence score');
+    });
   });
 
   describe('list', () => {
@@ -577,6 +658,34 @@ describe('SupabaseStorageAdapter', () => {
       expect(result).toBe('uuid-123');
     });
 
+    it('should retain an invalid case status with bounded evidence and attempts', async () => {
+      const caseResult = createMockCaseResultRecord({
+        status: 'invalid',
+        attempts: 2,
+        evidence: {
+          evaluator: 'llm_grader',
+          validation: { status: 'invalid', code: 'grader_failure' },
+        },
+      });
+      const mockUpsert = mock(() => ({
+        select: mock(() => ({
+          single: mock(() => Promise.resolve({ data: { id: 'uuid-123' }, error: null })),
+        })),
+      }));
+      mockFrom.mockReturnValue({ upsert: mockUpsert });
+
+      await adapter.saveCaseResult(caseResult);
+
+      expect(mockUpsert.mock.calls[0][0]).toMatchObject({
+        status: 'invalid',
+        attempts: 2,
+        evidence: {
+          evaluator: 'llm_grader',
+          validation: { status: 'invalid', code: 'grader_failure' },
+        },
+      });
+    });
+
     it('should throw error on save failure', async () => {
       const caseResult = createMockCaseResultRecord();
 
@@ -980,9 +1089,10 @@ describe('Type Safety', () => {
   });
 
   it('should have valid CaseResultStatus types', () => {
-    const statuses: CaseResultRecord['status'][] = ['passed', 'failed', 'error'];
+    const statuses: CaseResultRecord['status'][] = ['passed', 'failed', 'invalid', 'error'];
     expect(statuses).toContain('passed');
     expect(statuses).toContain('failed');
+    expect(statuses).toContain('invalid');
     expect(statuses).toContain('error');
   });
 });

package/src/storage/supabase.ts

@@ -3,7 +3,12 @@
  */
 
 import { type SupabaseClient, createClient } from '@supabase/supabase-js';
-import type { CaseResult, RunManifest } from '../artifacts/types';
+import {
+  type CaseResult,
+  type RunManifest,
+  assertRunManifestIntegrity,
+  getCaseEvaluationStatus,
+} from '../artifacts/types';
 import type {
   AnalyticsStorageAdapter,
   BaselineMetadata,
@@ -31,7 +36,8 @@ function mapCaseToRecord(runId: string, caseResult: CaseResult): CaseResultRecor
     runId,
     caseId: caseResult.id,
     caseName: caseResult.name,
-    status: caseResult.error ? 'error' : caseResult.ok ? 'passed' : 'failed',
+    status: getCaseEvaluationStatus(caseResult),
+    attempts: caseResult.attempts ?? 1,
     score: caseResult.score,
     matcherType: caseResult.matcherType,
     reason: caseResult.reason,
@@ -41,6 +47,7 @@ function mapCaseToRecord(runId: string, caseResult: CaseResult): CaseResultRecor
     completionTokens: caseResult.tokens.completion,
     totalTokens: caseResult.tokens.total,
     error: caseResult.error,
+    evidence: caseResult.evidence,
     tags: caseResult.tags,
   };
 }
@@ -61,6 +68,7 @@ export class SupabaseStorageAdapter implements AnalyticsStorageAdapter {
   // ============================================================================
 
   async save(manifest: RunManifest): Promise<string> {
+    assertRunManifestIntegrity(manifest);
     const filePath = `${manifest.project}/${manifest.run_id}.json`;
 
     const { error: uploadError } = await this.client.storage
@@ -84,6 +92,11 @@ export class SupabaseStorageAdapter implements AnalyticsStorageAdapter {
       total_cases: manifest.metrics.total_cases,
       passed_cases: manifest.metrics.passed_cases,
       failed_cases: manifest.metrics.failed_cases,
+      total_attempts: manifest.metrics.total_attempts ?? manifest.metrics.total_cases,
+      valid_evaluations: manifest.metrics.valid_evaluations ?? manifest.metrics.total_cases,
+      invalid_evaluations: manifest.metrics.invalid_evaluations ?? 0,
+      outcome_rate_denominator:
+        manifest.metrics.outcome_rate_denominator ?? manifest.metrics.total_cases,
       median_latency_ms: manifest.metrics.median_latency_ms,
       p95_latency_ms: manifest.metrics.p95_latency_ms,
       total_tokens: manifest.metrics.total_tokens,
@@ -130,7 +143,9 @@ export class SupabaseStorageAdapter implements AnalyticsStorageAdapter {
     }
 
     const text = await data.text();
-    return JSON.parse(text);
+    const manifest: unknown = JSON.parse(text);
+    assertRunManifestIntegrity(manifest);
+    return manifest;
   }
 
   async list(options?: ListOptions): Promise<RunListItem[]> {
@@ -405,6 +420,7 @@ export class SupabaseStorageAdapter implements AnalyticsStorageAdapter {
       case_id: result.caseId,
       case_name: result.caseName,
       status: result.status,
+      attempts: result.attempts ?? 1,
       score: result.score,
       matcher_type: result.matcherType,
       reason: result.reason,
@@ -414,6 +430,7 @@ export class SupabaseStorageAdapter implements AnalyticsStorageAdapter {
       completion_tokens: result.completionTokens,
       total_tokens: result.totalTokens,
       error: result.error,
+      evidence: result.evidence,
       tags: result.tags || [],
     };
 
@@ -440,6 +457,7 @@ export class SupabaseStorageAdapter implements AnalyticsStorageAdapter {
       case_id: r.caseId,
       case_name: r.caseName,
       status: r.status,
+      attempts: r.attempts ?? 1,
       score: r.score,
       matcher_type: r.matcherType,
       reason: r.reason,
@@ -449,6 +467,7 @@ export class SupabaseStorageAdapter implements AnalyticsStorageAdapter {
       completion_tokens: r.completionTokens,
       total_tokens: r.totalTokens,
       error: r.error,
+      evidence: r.evidence,
       tags: r.tags || [],
     }));
 
@@ -481,6 +500,7 @@ export class SupabaseStorageAdapter implements AnalyticsStorageAdapter {
       caseId: r.case_id,
       caseName: r.case_name,
       status: r.status,
+      attempts: r.attempts,
       score: r.score,
       matcherType: r.matcher_type,
       reason: r.reason,
@@ -490,6 +510,7 @@ export class SupabaseStorageAdapter implements AnalyticsStorageAdapter {
       completionTokens: r.completion_tokens,
       totalTokens: r.total_tokens,
       error: r.error,
+      evidence: r.evidence,
       tags: r.tags,
       createdAt: r.created_at,
     }));
@@ -531,6 +552,7 @@ export class SupabaseStorageAdapter implements AnalyticsStorageAdapter {
       caseId: r.case_id,
       caseName: r.case_name,
       status: r.status,
+      attempts: r.attempts,
       score: r.score,
       matcherType: r.matcher_type,
       reason: r.reason,
@@ -540,6 +562,7 @@ export class SupabaseStorageAdapter implements AnalyticsStorageAdapter {
       completionTokens: r.completion_tokens,
       totalTokens: r.total_tokens,
       error: r.error,
+      evidence: r.evidence,
       tags: r.tags,
       createdAt: r.created_at,
     }));

package/src/storage/types.ts

@@ -2,7 +2,13 @@
  * Storage types and interfaces
  */
 
-import type { AnyManifest, RedTeamManifest, RunManifest, StressManifest } from '../artifacts/types';
+import type {
+  AnyManifest,
+  CaseEvaluationEvidence,
+  RedTeamManifest,
+  RunManifest,
+  StressManifest,
+} from '../artifacts/types';
 
 /**
  * Run listing item
@@ -181,7 +187,7 @@ export interface BaselineStorageAdapter extends StorageAdapter {
 /**
  * Status of an individual case result
  */
-export type CaseResultStatus = 'passed' | 'failed' | 'error';
+export type CaseResultStatus = 'passed' | 'failed' | 'invalid' | 'error';
 
 /**
  * Individual case result record for storage
@@ -197,6 +203,8 @@ export interface CaseResultRecord {
   caseName?: string;
   /** Result status */
   status: CaseResultStatus;
+  /** Number of execution attempts represented by this terminal result. */
+  attempts?: number;
   /** Score from 0.0 to 1.0 */
   score: number;
   /** Type of matcher used */
@@ -215,6 +223,8 @@ export interface CaseResultRecord {
   totalTokens: number;
   /** Error message if status is 'error' */
   error?: string;
+  /** Sanitized evaluator evidence retained for review. */
+  evidence?: CaseEvaluationEvidence;
   /** Tags for categorization */
   tags?: string[];
   /** ISO timestamp when created */

package/src/tools/fixture-executor.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, it } from 'bun:test';
+import { FixtureToolExecutor } from './fixture-executor';
+
+const tools = [
+  {
+    type: 'function' as const,
+    function: {
+      name: 'get_weather',
+      parameters: {
+        type: 'object',
+        additionalProperties: false,
+        required: ['city'],
+        properties: { city: { type: 'string' } },
+      },
+    },
+  },
+];
+
+const call = (arguments_: string, name = 'get_weather') => ({
+  id: 'call-1',
+  type: 'function' as const,
+  function: { name, arguments: arguments_ },
+});
+
+describe('FixtureToolExecutor', () => {
+  it('returns a deterministic matching fixture result', async () => {
+    const executor = new FixtureToolExecutor({
+      tools,
+      fixtures: { get_weather: [{ when: { city: 'Lagos' }, result: { temperature_c: 28 } }] },
+    });
+
+    await expect(executor.execute(call('{"city":"Lagos"}'))).resolves.toEqual({
+      status: 'success',
+      result: { temperature_c: 28 },
+    });
+  });
+
+  it('rejects undeclared tools, invalid JSON, and unmatched fixtures', async () => {
+    const executor = new FixtureToolExecutor({ tools, fixtures: { get_weather: [] } });
+
+    await expect(executor.execute(call('{}', 'delete_weather'))).resolves.toMatchObject({
+      status: 'error',
+      error: { code: 'TOOL_UNKNOWN' },
+    });
+    await expect(executor.execute(call('{city:Lagos}'))).resolves.toMatchObject({
+      status: 'error',
+      error: { code: 'TOOL_ARGUMENTS_INVALID' },
+    });
+    await expect(executor.execute(call('{"city":"Lagos"}'))).resolves.toMatchObject({
+      status: 'error',
+      error: { code: 'TOOL_FIXTURE_NOT_FOUND' },
+    });
+  });
+
+  it('returns controlled fixture errors and result-size failures', async () => {
+    const errorExecutor = new FixtureToolExecutor({
+      tools,
+      fixtures: { get_weather: [{ error: 'Weather service is unavailable.' }] },
+    });
+    const limitedExecutor = new FixtureToolExecutor({
+      tools,
+      fixtures: { get_weather: [{ result: { forecast: 'x'.repeat(32) } }] },
+      maxToolResultBytes: 16,
+    });
+
+    await expect(errorExecutor.execute(call('{"city":"Lagos"}'))).resolves.toMatchObject({
+      status: 'error',
+      error: { code: 'TOOL_EXECUTION_FAILED' },
+    });
+    await expect(limitedExecutor.execute(call('{"city":"Lagos"}'))).resolves.toMatchObject({
+      status: 'error',
+      error: { code: 'TOOL_RESULT_TOO_LARGE' },
+    });
+  });
+
+  it('rejects unsafe fixture configuration and fixtures for undeclared tools', () => {
+    expect(
+      () =>
+        new FixtureToolExecutor({
+          tools,
+          fixtures: { get_weather: [{ result: { command: 'curl example.invalid' } }] },
+        })
+    ).toThrow('TOOL_FIXTURE_UNSAFE');
+    expect(() => new FixtureToolExecutor({ tools, fixtures: { no_such_tool: [] } })).toThrow(
+      'TOOL_UNKNOWN'
+    );
+  });
+});

package/src/tools/fixture-executor.ts

@@ -0,0 +1,112 @@
+import type { ToolCall, ToolDefinition } from '../adapters/types';
+import { validateToolArguments } from './schema-validator';
+import type {
+  FixtureExecutorOptions,
+  ToolExecutionContext,
+  ToolExecutionResult,
+  ToolFixture,
+  ToolFixtures,
+} from './types';
+
+const DISALLOWED_FIXTURE_FIELDS = new Set(['command', 'url', 'path', 'code', 'environment', 'env']);
+
+export class FixtureToolExecutor {
+  private readonly tools = new Map<string, ToolDefinition>();
+  private readonly fixtures: ToolFixtures;
+  private readonly maxToolResultBytes: number;
+
+  constructor({ tools, fixtures, maxToolResultBytes = 32_768 }: FixtureExecutorOptions) {
+    for (const tool of tools) this.tools.set(tool.function.name, tool);
+    for (const [name, entries] of Object.entries(fixtures)) {
+      if (!this.tools.has(name)) {
+        throw new Error(`TOOL_UNKNOWN: fixture declared for undeclared tool '${name}'`);
+      }
+      entries.forEach(assertSafeFixture);
+    }
+    this.fixtures = fixtures;
+    this.maxToolResultBytes = maxToolResultBytes;
+  }
+
+  async execute(call: ToolCall, _context?: ToolExecutionContext): Promise<ToolExecutionResult> {
+    const tool = this.tools.get(call.function.name);
+    if (!tool) {
+      return error('TOOL_UNKNOWN', `Tool '${call.function.name}' is not declared.`);
+    }
+
+    const validated = validateToolArguments(call.function.arguments, tool.function.parameters);
+    if (!validated.valid) return { status: 'error', error: validated.error };
+
+    const fixture = this.fixtures[call.function.name]?.find((candidate) =>
+      matches(candidate.when, validated.arguments ?? {})
+    );
+    if (!fixture) {
+      return error('TOOL_FIXTURE_NOT_FOUND', `No fixture matched tool '${call.function.name}'.`);
+    }
+    if (fixture.error) return error('TOOL_EXECUTION_FAILED', fixture.error);
+
+    const serialized = JSON.stringify(fixture.result ?? {});
+    if (
+      serialized === undefined ||
+      new TextEncoder().encode(serialized).byteLength > this.maxToolResultBytes
+    ) {
+      return error(
+        'TOOL_RESULT_TOO_LARGE',
+        `Tool '${call.function.name}' result exceeds the configured limit.`
+      );
+    }
+    return { status: 'success', result: fixture.result ?? {} };
+  }
+}
+
+function error(
+  code: NonNullable<ToolExecutionResult['error']>['code'],
+  message: string
+): ToolExecutionResult {
+  return { status: 'error', error: { code, message } };
+}
+
+function matches(
+  when: Record<string, unknown> | undefined,
+  args: Record<string, unknown>
+): boolean {
+  return !when || Object.entries(when).every(([key, value]) => deepEqual(args[key], value));
+}
+
+function deepEqual(left: unknown, right: unknown): boolean {
+  if (Object.is(left, right)) return true;
+  if (!left || !right || typeof left !== 'object' || typeof right !== 'object') return false;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return (
+      Array.isArray(left) &&
+      Array.isArray(right) &&
+      left.length === right.length &&
+      left.every((value, index) => deepEqual(value, right[index]))
+    );
+  }
+  const leftRecord = left as Record<string, unknown>;
+  const rightRecord = right as Record<string, unknown>;
+  const keys = Object.keys(rightRecord);
+  return (
+    keys.length === Object.keys(leftRecord).length &&
+    keys.every((key) => deepEqual(leftRecord[key], rightRecord[key]))
+  );
+}
+
+function assertSafeFixture(fixture: ToolFixture): void {
+  assertSafeValue(fixture.when);
+  assertSafeValue(fixture.result);
+}
+
+function assertSafeValue(value: unknown): void {
+  if (!value || typeof value !== 'object') return;
+  if (Array.isArray(value)) {
+    value.forEach(assertSafeValue);
+    return;
+  }
+  for (const [key, child] of Object.entries(value as Record<string, unknown>)) {
+    if (DISALLOWED_FIXTURE_FIELDS.has(key.toLowerCase())) {
+      throw new Error(`TOOL_FIXTURE_UNSAFE: '${key}' is not permitted in fixture data.`);
+    }
+    assertSafeValue(child);
+  }
+}

package/src/tools/index.ts

@@ -0,0 +1,3 @@
+export * from './fixture-executor';
+export * from './schema-validator';
+export * from './types';