@artemiskit/core 0.5.3 → 0.6.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/agent-workflow/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,MAAM,MAAM,YAAY,GACpB,IAAI,GACJ,OAAO,GACP,MAAM,GACN,MAAM,GACN,YAAY,EAAE,GACd;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAAA;CAAE,CAAC;AAGpC,yFAAyF;AACzF,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CA8CpE;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAQ7D;AAqBD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BtB,CAAC;AACZ,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AA2IlE,iGAAiG;AACjG,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GASb,CAAC;AACpB,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

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

@@ -0,0 +1,113 @@
+import type { TokenUsage } from '../adapters/types.js';
+import { type WorkflowEnvironmentFactory, type WorkflowState } from './environment.js';
+import { type AgentWorkflow } from './schema.js';
+import type { AgentTarget, AgentTurnRequest } from './target.js';
+export type AgentWorkflowExecution = 'completed' | 'unsupported' | 'invalid' | 'failed' | 'cancelled' | 'timeout' | 'budget_exceeded';
+export type AgentWorkflowReason = 'finished' | 'invalid_workflow' | 'invalid_options' | 'invalid_fixture' | 'target_unavailable' | 'invalid_response' | 'target_error' | 'tool_use_unsupported' | 'preflight_failed' | 'environment_unavailable' | 'invalid_environment' | 'tool_failed' | 'policy_denied' | 'cancelled' | 'deadline' | 'max_actions' | 'max_model_requests' | 'max_tool_calls' | 'max_tokens' | 'usage_unavailable' | 'transcript_limit';
+export interface AgentWorkflowEvent {
+    sequence: number;
+    elapsedMs: number;
+    type: 'started' | 'model_requested' | 'model_completed' | 'tool_requested' | 'tool_completed' | 'preflight_completed' | 'finished';
+    phase: 'execution' | 'preflight';
+    operationId?: string;
+    requestedCallIdHash?: string;
+    tool?: string;
+    status?: 'completed' | 'denied' | 'invalid' | 'failed';
+}
+export interface AgentWorkflowRecord {
+    schemaVersion: '1';
+    engine: 'native';
+    execution: AgentWorkflowExecution;
+    reason: AgentWorkflowReason;
+    policy: 'passed' | 'denied';
+    configuration?: {
+        sha256: string;
+        provider: {
+            sha256: string;
+            display?: string;
+        };
+        model: {
+            sha256: string;
+            display?: string;
+        };
+        generation: {
+            maxTokens: number;
+            temperature: number;
+        };
+        limits: AgentWorkflow['environment']['policy']['budgets'];
+    };
+    taskVerification: 'unavailable';
+    environment: 'simulated' | 'sandbox' | 'unknown';
+    capability: {
+        advertised: boolean | null;
+        transportCancellation: boolean;
+        preflight: 'not_requested' | 'passed' | 'failed';
+        observedModelHash?: string;
+        observedModel?: {
+            sha256: string;
+            display?: string;
+        };
+    };
+    usage: {
+        status: 'reported' | 'partial' | 'unavailable';
+        reported: TokenUsage;
+        missingRequests: number;
+        inFlightUnknown: boolean;
+        preflight: TokenUsage;
+    };
+    budgets: {
+        actions: number;
+        modelRequests: number;
+        toolCalls: number;
+        modelRequestAccounting: 'target_invocations';
+        transportAttempts: 'unavailable';
+        tokenOvershoot: number;
+        elapsedMs: number;
+    };
+    cleanup: {
+        status: 'completed' | 'unresolved';
+        artifacts: 'discarded' | 'retained' | 'unknown';
+        pendingOperations: number;
+    };
+    artifacts: {
+        state: 'available' | 'unavailable';
+        stateSha256?: string;
+        files?: {
+            pathSha256: string;
+            contentSha256: string;
+            bytes: number;
+        }[];
+        omittedFiles?: number;
+    };
+    events: AgentWorkflowEvent[];
+    droppedEvents: number;
+}
+export interface AgentWorkflowResult {
+    /** Metadata only. Safe default persistence boundary, never contains model text or fixture content. */
+    record: AgentWorkflowRecord;
+    /** Sensitive working data; persist only with an explicit application policy. */
+    state: WorkflowState | null;
+    transcript: AgentTurnRequest['messages'];
+}
+export interface AgentWorkflowSessionOptions {
+    workflow: AgentWorkflow;
+    target: AgentTarget;
+    fixtureRoot?: string;
+    environmentFactory?: WorkflowEnvironmentFactory;
+    preflight?: boolean;
+    preflightOnly?: boolean;
+    signal?: AbortSignal;
+    /** Total bounded drain/snapshot/close period: 1000 ms simulated, 6000 ms sandbox by default. */
+    cleanupTimeoutMs?: number;
+    onEvent?: (event: AgentWorkflowEvent) => void;
+}
+export interface AgentWorkflowSession {
+    readonly state: 'idle' | 'running' | 'cancelling' | 'completed';
+    run(): Promise<AgentWorkflowResult>;
+    cancel(): void;
+    events(): AsyncIterable<AgentWorkflowEvent>;
+}
+/** Native host-owned loop. No adapter or model may change authority or replenish run budgets. */
+export declare function createAgentWorkflowSession(options: AgentWorkflowSessionOptions): AgentWorkflowSession;
+export declare function runAgentWorkflow(options: AgentWorkflowSessionOptions): Promise<AgentWorkflowResult>;
+//# sourceMappingURL=session.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/agent-workflow/session.ts"],"names":[],"mappings":"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"}

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,243 @@
+import { z } from 'zod';
+import type { ModelClient, TokenUsage, ToolCall } from '../adapters/types.js';
+export declare const agentTurnRequestSchema: 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 agentTurnRequestSchema>;
+export type AgentTargetFailure = {
+    rejectedCall?: {
+        requestedCallIdHash: string;
+        tool: string;
+        reason: 'undeclared_tool' | 'invalid_arguments' | 'duplicate_id';
+    };
+    tokens?: TokenUsage;
+    usageAvailable?: boolean;
+    status: 'unsupported' | 'invalid' | 'error';
+    code: 'invalid_request' | 'tool_use_unsupported' | 'invalid_response' | 'target_error' | 'timeout' | 'aborted';
+};
+export type AgentTargetCapabilities = {
+    status: 'available';
+    toolUse: boolean;
+    transportCancellation: boolean;
+};
+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;
+    usageAvailable?: boolean;
+    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>;
+    /** Wait for underlying callbacks hidden behind a bounded turn facade. */
+    drain?(options: {
+        timeoutMs: number;
+    }): Promise<{
+        pendingOperations: number;
+    }>;
+}
+export declare function validWorkflowTranscript(messages: AgentTurnRequest['messages']): boolean;
+/**
+ * Bridge existing adapters without provider-specific dispatch. Workflow calls disable supported
+ * transport retries and propagate abort only when the adapter declares transport cancellation.
+ * Returned text/tool arguments are working conversation data, not sanitized retained evidence.
+ */
+export declare function createModelClientTarget(client: ModelClient): AgentTarget;
+//# 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":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAmB,WAAW,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAsB5F,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCxB,CAAC;AAmBZ,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,kBAAkB,GAAG;IAC/B,YAAY,CAAC,EAAE;QACb,mBAAmB,EAAE,MAAM,CAAC;QAC5B,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,iBAAiB,GAAG,mBAAmB,GAAG,cAAc,CAAC;KAClE,CAAC;IACF,MAAM,CAAC,EAAE,UAAU,CAAC;IACpB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,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,qBAAqB,EAAE,OAAO,CAAC;CAChC,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,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,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;IAChF,yEAAyE;IACzE,KAAK,CAAC,CAAC,OAAO,EAAE;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC;QAAE,iBAAiB,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAChF;AAgCD,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,gBAAgB,CAAC,UAAU,CAAC,GAAG,OAAO,CAwBvF;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,WAAW,GAAG,WAAW,CAsKxE"}

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

@@ -5,7 +5,7 @@
  * 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';
+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. */

package/dist/comparison/index.d.ts

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

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
  */