@artemiskit/core 0.5.2 → 0.6.0

package/dist/agent-workflow/simulated-tools.d.ts

@@ -0,0 +1,35 @@
+import { type WorkflowJson, type WorkflowPolicy } from './schema.js';
+type JsonObject = {
+    [key: string]: WorkflowJson;
+};
+type ToolFailureCode = 'undeclared_tool' | 'permission_denied' | 'invalid_input' | 'invalid_state' | 'not_found' | 'output_limit' | 'invalid_policy' | 'tool_error';
+export interface SimulatedToolEvidence {
+    tool: string;
+    version: '1';
+    status: 'succeeded' | 'denied' | 'invalid' | 'failed';
+    code?: ToolFailureCode;
+}
+export type SimulatedToolResult = {
+    status: 'succeeded';
+    output: WorkflowJson;
+    state: JsonObject;
+    evidence: SimulatedToolEvidence;
+} | {
+    status: 'denied' | 'invalid' | 'failed';
+    code: ToolFailureCode;
+    evidence: SimulatedToolEvidence;
+};
+/**
+ * One deterministic simulated call, with isolated input/output state and metadata-only evidence.
+ * Budgets are declarative here: a future environment runner owns action counts and deadlines.
+ * `side_effects` governs external effects; declared local state writes never authorize real effects.
+ */
+export declare function executeSimulatedTool(request: {
+    tool: string;
+    input: unknown;
+    state: unknown;
+    policy: WorkflowPolicy;
+    declaredTools: readonly string[];
+}): SimulatedToolResult;
+export {};
+//# sourceMappingURL=simulated-tools.d.ts.map

package/dist/agent-workflow/simulated-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulated-tools.d.ts","sourceRoot":"","sources":["../../src/agent-workflow/simulated-tools.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,cAAc,EAIpB,MAAM,UAAU,CAAC;AAElB,KAAK,UAAU,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAA;CAAE,CAAC;AAClD,KAAK,eAAe,GAChB,iBAAiB,GACjB,mBAAmB,GACnB,eAAe,GACf,eAAe,GACf,WAAW,GACX,cAAc,GACd,gBAAgB,GAChB,YAAY,CAAC;AACjB,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,GAAG,CAAC;IACb,MAAM,EAAE,WAAW,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;IACtD,IAAI,CAAC,EAAE,eAAe,CAAC;CACxB;AACD,MAAM,MAAM,mBAAmB,GAC3B;IACE,MAAM,EAAE,WAAW,CAAC;IACpB,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,EAAE,UAAU,CAAC;IAClB,QAAQ,EAAE,qBAAqB,CAAC;CACjC,GACD;IACE,MAAM,EAAE,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;IACxC,IAAI,EAAE,eAAe,CAAC;IACtB,QAAQ,EAAE,qBAAqB,CAAC;CACjC,CAAC;AAqCN;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,OAAO,CAAC;IACf,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,cAAc,CAAC;IACvB,aAAa,EAAE,SAAS,MAAM,EAAE,CAAC;CAClC,GAAG,mBAAmB,CAgJtB"}

package/dist/agent-workflow/target.d.ts

@@ -0,0 +1,230 @@
+import { z } from 'zod';
+import type { ModelClient, TokenUsage, ToolCall } from '../adapters/types.js';
+declare const requestSchema: z.ZodObject<{
+    messages: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<["system", "user", "assistant", "tool"]>;
+        content: z.ZodString;
+        toolCallId: z.ZodOptional<z.ZodString>;
+        tool_calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"function">;
+            function: z.ZodObject<{
+                name: z.ZodString;
+                arguments: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                name: string;
+                arguments: string;
+            }, {
+                name: string;
+                arguments: string;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }, {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }>, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        role: "system" | "user" | "assistant" | "tool";
+        content: string;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[] | undefined;
+        toolCallId?: string | undefined;
+    }, {
+        role: "system" | "user" | "assistant" | "tool";
+        content: string;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[] | undefined;
+        toolCallId?: string | undefined;
+    }>, "many">;
+    tools: z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        function: z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strict", z.ZodTypeAny, {
+            name: string;
+            parameters: Record<string, unknown>;
+            description?: string | undefined;
+        }, {
+            name: string;
+            parameters: Record<string, unknown>;
+            description?: string | undefined;
+        }>;
+    }, "strict", z.ZodTypeAny, {
+        function: {
+            name: string;
+            parameters: Record<string, unknown>;
+            description?: string | undefined;
+        };
+        type: "function";
+    }, {
+        function: {
+            name: string;
+            parameters: Record<string, unknown>;
+            description?: string | undefined;
+        };
+        type: "function";
+    }>, "many">;
+    model: z.ZodOptional<z.ZodString>;
+    generation: z.ZodObject<{
+        maxTokens: z.ZodNumber;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        topP: z.ZodOptional<z.ZodNumber>;
+        seed: z.ZodOptional<z.ZodNumber>;
+        stop: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strict", z.ZodTypeAny, {
+        maxTokens: number;
+        stop?: string[] | undefined;
+        seed?: number | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+    }, {
+        maxTokens: number;
+        stop?: string[] | undefined;
+        seed?: number | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+    }>;
+    budgets: z.ZodObject<{
+        timeoutMs: z.ZodNumber;
+        maxToolCalls: z.ZodNumber;
+    }, "strict", z.ZodTypeAny, {
+        timeoutMs: number;
+        maxToolCalls: number;
+    }, {
+        timeoutMs: number;
+        maxToolCalls: number;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    tools: {
+        function: {
+            name: string;
+            parameters: Record<string, unknown>;
+            description?: string | undefined;
+        };
+        type: "function";
+    }[];
+    generation: {
+        maxTokens: number;
+        stop?: string[] | undefined;
+        seed?: number | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+    };
+    budgets: {
+        timeoutMs: number;
+        maxToolCalls: number;
+    };
+    messages: {
+        role: "system" | "user" | "assistant" | "tool";
+        content: string;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[] | undefined;
+        toolCallId?: string | undefined;
+    }[];
+    model?: string | undefined;
+}, {
+    tools: {
+        function: {
+            name: string;
+            parameters: Record<string, unknown>;
+            description?: string | undefined;
+        };
+        type: "function";
+    }[];
+    generation: {
+        maxTokens: number;
+        stop?: string[] | undefined;
+        seed?: number | undefined;
+        temperature?: number | undefined;
+        topP?: number | undefined;
+    };
+    budgets: {
+        timeoutMs: number;
+        maxToolCalls: number;
+    };
+    messages: {
+        role: "system" | "user" | "assistant" | "tool";
+        content: string;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[] | undefined;
+        toolCallId?: string | undefined;
+    }[];
+    model?: string | undefined;
+}>;
+export type AgentTurnRequest = z.infer<typeof requestSchema>;
+export type AgentTargetFailure = {
+    status: 'unsupported' | 'invalid' | 'error';
+    code: 'invalid_request' | 'tool_use_unsupported' | 'invalid_response' | 'target_error' | 'timeout' | 'aborted';
+};
+export type AgentTargetCapabilities = {
+    status: 'available';
+    toolUse: boolean;
+    /** ModelClient has no AbortSignal contract. Timeouts bound waiting, not transport work. */
+    transportCancellation: false;
+};
+export type AgentTurnResult = AgentTargetFailure | {
+    status: 'completed';
+    id: string;
+    model: string;
+    message: {
+        role: 'assistant';
+        content: string;
+        tool_calls?: ToolCall[];
+    };
+    /** Adapter-reported counts only; zero can mean unavailable in existing adapters. */
+    tokens: TokenUsage;
+    latencyMs: number;
+    finishReason?: 'stop' | 'length' | 'tool_calls' | 'content_filter';
+};
+/** One bounded model turn. Tool execution, policy enforcement, and scoring belong to the harness. */
+export interface AgentTarget {
+    readonly provider: string;
+    capabilities(options: {
+        timeoutMs: number;
+    }, signal?: AbortSignal): Promise<AgentTargetCapabilities | AgentTargetFailure>;
+    turn(request: AgentTurnRequest, signal?: AbortSignal): Promise<AgentTurnResult>;
+}
+/**
+ * Bridge existing adapters without provider-specific dispatch. Callers must configure adapter
+ * transport timeouts/retries separately: cancellation here cannot stop an in-flight provider call.
+ * Returned text/tool arguments are working conversation data, not sanitized retained evidence.
+ */
+export declare function createModelClientTarget(client: ModelClient): AgentTarget;
+export {};
+//# sourceMappingURL=target.d.ts.map

package/dist/agent-workflow/target.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"target.d.ts","sourceRoot":"","sources":["../../src/agent-workflow/target.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAmB,WAAW,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAqB5F,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCR,CAAC;AAkBZ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC7D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,aAAa,GAAG,SAAS,GAAG,OAAO,CAAC;IAC5C,IAAI,EACA,iBAAiB,GACjB,sBAAsB,GACtB,kBAAkB,GAClB,cAAc,GACd,SAAS,GACT,SAAS,CAAC;CACf,CAAC;AACF,MAAM,MAAM,uBAAuB,GAAG;IACpC,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB,2FAA2F;IAC3F,qBAAqB,EAAE,KAAK,CAAC;CAC9B,CAAC;AACF,MAAM,MAAM,eAAe,GACvB,kBAAkB,GAClB;IACE,MAAM,EAAE,WAAW,CAAC;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE;QAAE,IAAI,EAAE,WAAW,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,QAAQ,EAAE,CAAA;KAAE,CAAC;IACzE,oFAAoF;IACpF,MAAM,EAAE,UAAU,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,YAAY,GAAG,gBAAgB,CAAC;CACpE,CAAC;AAEN,qGAAqG;AACrG,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,YAAY,CACV,OAAO,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,EAC9B,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,uBAAuB,GAAG,kBAAkB,CAAC,CAAC;IACzD,IAAI,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,eAAe,CAAC,CAAC;CACjF;AA0DD;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAiHxE"}

package/dist/artifacts/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * Artifacts module exports
  */
-export * from './types';
-export { createRunManifest } from './manifest';
+export * from './types.js';
+export { createRunManifest } from './manifest.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/artifacts/manifest.d.ts

@@ -1,7 +1,7 @@
 /**
  * Run manifest generation utilities
  */
-import type { CaseResult, CostProvenance, ExecutionProvenance, ManifestRedactionInfo, ResolvedConfig, RunAttemptEvidence, RunConfig, RunManifest, WorkloadIdentity } from './types';
+import type { CaseResult, CostProvenance, ExecutionProvenance, ManifestRedactionInfo, ResolvedConfig, RunAttemptEvidence, RunConfig, RunManifest, WorkloadIdentity } from './types.js';
 /**
  * Create a new run manifest
  */

package/dist/artifacts/types.d.ts

@@ -162,9 +162,9 @@ export interface CaseResult {
     /** Redaction information for this case */
     redaction?: CaseRedactionInfo;
     /** Ordered tool activity captured for an enabled tool loop. */
-    toolTrace?: import('../tools').ToolTraceEntry[];
+    toolTrace?: import('../tools/index.js').ToolTraceEntry[];
     /** Terminal status for an enabled tool loop. */
-    toolLoop?: import('../tools').ToolLoopSummary;
+    toolLoop?: import('../tools/index.js').ToolLoopSummary;
 }
 /**
  * Cost estimation details

package/dist/comparison/eligibility.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Compatibility decisions for comparisons of saved scenario-evaluation runs.
+ *
+ * This contract compares declared evidence only. A matching digest proves the
+ * same canonical workload/rubric was declared; it does not attest to provider
+ * behaviour or replace a future assessment-profile compatibility decision.
+ */
+import type { RunManifest } from '../artifacts/types.js';
+export type ComparisonEligibilityStatus = 'compatible' | 'qualified' | 'incomparable';
+export type ComparisonEligibilityReasonCode = 'scenario_mismatch' | 'workload_identity_missing' | 'rubric_identity_missing' | 'workload_mismatch' | 'rubric_mismatch' | 'execution_provenance_missing' | 'target_provider_changed' | 'target_model_changed' | 'generation_settings_changed';
+/** A bounded, machine-readable reason for a comparison decision. */
+export interface ComparisonEligibilityReason {
+    code: ComparisonEligibilityReasonCode;
+}
+/**
+ * Versioned decision that accompanies every comparison. `qualified` permits
+ * a visibly-qualified delta; `incomparable` prohibits a delta entirely.
+ */
+export interface ComparisonEligibility {
+    schema_version: '1';
+    status: ComparisonEligibilityStatus;
+    reasons: ComparisonEligibilityReason[];
+}
+export declare function assessComparisonEligibility(baseline: RunManifest, current: RunManifest): ComparisonEligibility;
+export declare function isComparisonAvailable(eligibility: ComparisonEligibility): boolean;
+//# sourceMappingURL=eligibility.d.ts.map

package/dist/comparison/eligibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eligibility.d.ts","sourceRoot":"","sources":["../../src/comparison/eligibility.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtD,MAAM,MAAM,2BAA2B,GAAG,YAAY,GAAG,WAAW,GAAG,cAAc,CAAC;AAEtF,MAAM,MAAM,+BAA+B,GACvC,mBAAmB,GACnB,2BAA2B,GAC3B,yBAAyB,GACzB,mBAAmB,GACnB,iBAAiB,GACjB,8BAA8B,GAC9B,yBAAyB,GACzB,sBAAsB,GACtB,6BAA6B,CAAC;AAElC,oEAAoE;AACpE,MAAM,WAAW,2BAA2B;IAC1C,IAAI,EAAE,+BAA+B,CAAC;CACvC;AAED;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,cAAc,EAAE,GAAG,CAAC;IACpB,MAAM,EAAE,2BAA2B,CAAC;IACpC,OAAO,EAAE,2BAA2B,EAAE,CAAC;CACxC;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,WAAW,EACrB,OAAO,EAAE,WAAW,GACnB,qBAAqB,CAmDvB;AAED,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,qBAAqB,GAAG,OAAO,CAEjF"}

package/dist/comparison/index.d.ts

@@ -0,0 +1,2 @@
+export { assessComparisonEligibility, isComparisonAvailable, type ComparisonEligibility, type ComparisonEligibilityReason, type ComparisonEligibilityReasonCode, type ComparisonEligibilityStatus, } from './eligibility.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/comparison/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/comparison/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,qBAAqB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,2BAA2B,EAChC,KAAK,+BAA+B,EACpC,KAAK,2BAA2B,GACjC,MAAM,eAAe,CAAC"}

package/dist/evaluators/combined.d.ts

@@ -1,8 +1,8 @@
 /**
  * Combined evaluator - evaluates multiple expectations with and/or logic
  */
-import type { Expected } from '../scenario/schema';
-import type { Evaluator, EvaluatorContext, EvaluatorResult } from './types';
+import type { Expected } from '../scenario/schema.js';
+import type { Evaluator, EvaluatorContext, EvaluatorResult } from './types.js';
 export declare class CombinedEvaluator implements Evaluator {
     readonly type = "combined";
     evaluate(response: string, expected: Expected, context?: EvaluatorContext): Promise<EvaluatorResult>;

package/dist/evaluators/contains.d.ts

@@ -1,8 +1,8 @@
 /**
  * Contains evaluator - checks if response contains specific values
  */
-import type { Expected } from '../scenario/schema';
-import type { Evaluator, EvaluatorResult } from './types';
+import type { Expected } from '../scenario/schema.js';
+import type { Evaluator, EvaluatorResult } from './types.js';
 export declare class ContainsEvaluator implements Evaluator {
     readonly type = "contains";
     evaluate(response: string, expected: Expected): Promise<EvaluatorResult>;

package/dist/evaluators/exact.d.ts

@@ -1,8 +1,8 @@
 /**
  * Exact match evaluator
  */
-import type { Expected } from '../scenario/schema';
-import type { Evaluator, EvaluatorResult } from './types';
+import type { Expected } from '../scenario/schema.js';
+import type { Evaluator, EvaluatorResult } from './types.js';
 export declare class ExactEvaluator implements Evaluator {
     readonly type = "exact";
     evaluate(response: string, expected: Expected): Promise<EvaluatorResult>;

package/dist/evaluators/fuzzy.d.ts

@@ -1,8 +1,8 @@
 /**
  * Fuzzy match evaluator using Levenshtein distance
  */
-import type { Expected } from '../scenario/schema';
-import type { Evaluator, EvaluatorResult } from './types';
+import type { Expected } from '../scenario/schema.js';
+import type { Evaluator, EvaluatorResult } from './types.js';
 export declare class FuzzyEvaluator implements Evaluator {
     readonly type = "fuzzy";
     evaluate(response: string, expected: Expected): Promise<EvaluatorResult>;

package/dist/evaluators/index.d.ts

@@ -1,7 +1,7 @@
 /**
  * Evaluators module - exports all evaluator types and utilities
  */
-import type { Evaluator } from './types';
+import type { Evaluator } from './types.js';
 /**
  * Get an evaluator by type
  */
@@ -14,16 +14,16 @@ export declare function registerEvaluator(type: string, evaluator: Evaluator): v
  * List available evaluator types
  */
 export declare function listEvaluators(): string[];
-export * from './types';
-export { ExactEvaluator } from './exact';
-export { RegexEvaluator } from './regex';
-export { FuzzyEvaluator } from './fuzzy';
-export { ContainsEvaluator } from './contains';
-export { NotContainsEvaluator } from './not-contains';
-export { CombinedEvaluator } from './combined';
-export { JsonSchemaEvaluator } from './json-schema';
-export { LLMGraderEvaluator } from './llm-grader';
-export { SimilarityEvaluator } from './similarity';
-export { InlineEvaluator, SUPPORTED_EXPRESSIONS } from './inline';
-export { ToolTraceEvaluator } from './tool-trace';
+export * from './types.js';
+export { ExactEvaluator } from './exact.js';
+export { RegexEvaluator } from './regex.js';
+export { FuzzyEvaluator } from './fuzzy.js';
+export { ContainsEvaluator } from './contains.js';
+export { NotContainsEvaluator } from './not-contains.js';
+export { CombinedEvaluator } from './combined.js';
+export { JsonSchemaEvaluator } from './json-schema.js';
+export { LLMGraderEvaluator } from './llm-grader.js';
+export { SimilarityEvaluator } from './similarity.js';
+export { InlineEvaluator, SUPPORTED_EXPRESSIONS } from './inline.js';
+export { ToolTraceEvaluator } from './tool-trace.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/evaluators/inline.d.ts

@@ -9,8 +9,8 @@
  * - Regex matching: response.match(/pattern/)
  * - JSON parsing: JSON.parse(response)
  */
-import type { Expected } from '../scenario/schema';
-import type { Evaluator, EvaluatorContext, EvaluatorResult } from './types';
+import type { Expected } from '../scenario/schema.js';
+import type { Evaluator, EvaluatorContext, EvaluatorResult } from './types.js';
 export declare class InlineEvaluator implements Evaluator {
     readonly type = "inline";
     evaluate(response: string, expected: Expected, _context?: EvaluatorContext): Promise<EvaluatorResult>;

package/dist/evaluators/json-schema.d.ts

@@ -1,8 +1,8 @@
 /**
  * JSON Schema evaluator - validates response against a JSON schema
  */
-import type { Expected } from '../scenario/schema';
-import type { Evaluator, EvaluatorResult } from './types';
+import type { Expected } from '../scenario/schema.js';
+import type { Evaluator, EvaluatorResult } from './types.js';
 export declare class JsonSchemaEvaluator implements Evaluator {
     readonly type = "json_schema";
     evaluate(response: string, expected: Expected): Promise<EvaluatorResult>;

package/dist/evaluators/llm-grader.d.ts

@@ -1,8 +1,8 @@
 /**
  * LLM-based grader evaluator
  */
-import type { Expected } from '../scenario/schema';
-import type { Evaluator, EvaluatorContext, EvaluatorResult } from './types';
+import type { Expected } from '../scenario/schema.js';
+import type { Evaluator, EvaluatorContext, EvaluatorResult } from './types.js';
 export declare class LLMGraderEvaluator implements Evaluator {
     readonly type = "llm_grader";
     evaluate(response: string, expected: Expected, context?: EvaluatorContext): Promise<EvaluatorResult>;

package/dist/evaluators/not-contains.d.ts

@@ -1,8 +1,8 @@
 /**
  * Not Contains evaluator - checks if response does NOT contain specific values
  */
-import type { Expected } from '../scenario/schema';
-import type { Evaluator, EvaluatorResult } from './types';
+import type { Expected } from '../scenario/schema.js';
+import type { Evaluator, EvaluatorResult } from './types.js';
 export declare class NotContainsEvaluator implements Evaluator {
     readonly type = "not_contains";
     evaluate(response: string, expected: Expected): Promise<EvaluatorResult>;

package/dist/evaluators/regex.d.ts

@@ -1,8 +1,8 @@
 /**
  * Regex pattern evaluator
  */
-import type { Expected } from '../scenario/schema';
-import type { Evaluator, EvaluatorResult } from './types';
+import type { Expected } from '../scenario/schema.js';
+import type { Evaluator, EvaluatorResult } from './types.js';
 export declare class RegexEvaluator implements Evaluator {
     readonly type = "regex";
     evaluate(response: string, expected: Expected): Promise<EvaluatorResult>;

package/dist/evaluators/similarity.d.ts

@@ -3,8 +3,8 @@
  * Uses vector embeddings for semantic similarity matching when available,
  * falls back to LLM-based semantic comparison otherwise.
  */
-import type { Expected } from '../scenario/schema';
-import type { Evaluator, EvaluatorContext, EvaluatorResult } from './types';
+import type { Expected } from '../scenario/schema.js';
+import type { Evaluator, EvaluatorContext, EvaluatorResult } from './types.js';
 export declare class SimilarityEvaluator implements Evaluator {
     readonly type = "similarity";
     evaluate(response: string, expected: Expected, context?: EvaluatorContext): Promise<EvaluatorResult>;

package/dist/evaluators/tool-trace.d.ts

@@ -1,5 +1,5 @@
-import type { Expected } from '../scenario/schema';
-import type { Evaluator, EvaluatorContext, EvaluatorResult } from './types';
+import type { Expected } from '../scenario/schema.js';
+import type { Evaluator, EvaluatorContext, EvaluatorResult } from './types.js';
 export declare class ToolTraceEvaluator implements Evaluator {
     readonly type = "tool_trace";
     evaluate(_response: string, expected: Expected, context?: EvaluatorContext): Promise<EvaluatorResult>;

package/dist/evaluators/types.d.ts

@@ -1,9 +1,9 @@
 /**
  * Evaluator types and interfaces
  */
-import type { ModelClient } from '../adapters/types';
-import type { Expected, TestCase } from '../scenario/schema';
-import type { ToolTraceEntry } from '../tools';
+import type { ModelClient } from '../adapters/types.js';
+import type { Expected, TestCase } from '../scenario/schema.js';
+import type { ToolTraceEntry } from '../tools/index.js';
 /**
  * Context provided to evaluators
  */

package/dist/index.d.ts

@@ -2,17 +2,19 @@
  * @artemiskit/core
  * Core library for Artemis Agent Reliability Toolkit
  */
-export * from './adapters';
-export * from './scenario';
-export * from './evaluators';
-export * from './runner';
-export * from './storage';
-export * from './artifacts';
-export * from './provenance';
-export * from './utils';
-export * from './redaction';
-export * from './cost';
-export * from './tools';
-export * from './agent-evaluation';
-export * from './validator';
+export * from './adapters/index.js';
+export * from './scenario/index.js';
+export * from './evaluators/index.js';
+export * from './runner/index.js';
+export * from './storage/index.js';
+export * from './artifacts/index.js';
+export * from './provenance/index.js';
+export * from './comparison/index.js';
+export * from './utils/index.js';
+export * from './redaction/index.js';
+export * from './cost/index.js';
+export * from './tools/index.js';
+export * from './agent-evaluation/index.js';
+export * from './agent-workflow/index.js';
+export * from './validator/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,cAAc,YAAY,CAAC;AAG3B,cAAc,YAAY,CAAC;AAG3B,cAAc,cAAc,CAAC;AAG7B,cAAc,UAAU,CAAC;AAGzB,cAAc,WAAW,CAAC;AAG1B,cAAc,aAAa,CAAC;AAG5B,cAAc,cAAc,CAAC;AAG7B,cAAc,SAAS,CAAC;AAGxB,cAAc,aAAa,CAAC;AAG5B,cAAc,QAAQ,CAAC;AAGvB,cAAc,SAAS,CAAC;AAGxB,cAAc,oBAAoB,CAAC;AAGnC,cAAc,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,cAAc,YAAY,CAAC;AAG3B,cAAc,YAAY,CAAC;AAG3B,cAAc,cAAc,CAAC;AAG7B,cAAc,UAAU,CAAC;AAGzB,cAAc,WAAW,CAAC;AAG1B,cAAc,aAAa,CAAC;AAG5B,cAAc,cAAc,CAAC;AAG7B,cAAc,cAAc,CAAC;AAG7B,cAAc,SAAS,CAAC;AAGxB,cAAc,aAAa,CAAC;AAG5B,cAAc,QAAQ,CAAC;AAGvB,cAAc,SAAS,CAAC;AAGxB,cAAc,oBAAoB,CAAC;AAGnC,cAAc,kBAAkB,CAAC;AAGjC,cAAc,aAAa,CAAC"}