@attest-ai/core 1.0.0 → 1.0.1

package/dist/cjs/index.d.cts

@@ -1,38 +1,18 @@
-import { InitializeResult, ProtocolLogger, ProtocolDiagnostic, Trace, Assertion, BatchBudget, BatchContext, EvaluateBatchResult, DriftReport, SimulatePersona, ConversationMessage, SimulateFaultConfig, Step, AssertionResult, Usage, Outcome } from './proto/index.cjs';
+import { ProtocolLogger, ProtocolDiagnostic, Trace, Assertion, BatchBudget, BatchContext, EvaluateBatchResult, DriftReport, SimulatePersona, ConversationMessage, SimulateFaultConfig, InitializeResult, Usage, Step, AssertionResult, Outcome } from './proto/index.cjs';
 export { AgentId, AssertionId, AssertionSpec, BiasProbe, ConstraintSpec, ContentSpec, ERR_ASSERTION_ERROR, ERR_ENGINE_ERROR, ERR_INVALID_TRACE, ERR_PROVIDER_ERROR, ERR_SESSION_ERROR, ERR_TIMEOUT, EffectSpec, EmbeddingSpec, EngineTimeoutError, ErrorData, EvaluateBatchParams, Exchange, FailureClass, GenerateUserMessageParams, GenerateUserMessageResult, Handoff, InitializeParams, JudgeAgreement, JudgeMetadata, LlmJudgeSpec, OTLPConversionError, OUTCOME_FAIL, OUTCOME_PASS, OUTCOME_SKIP, PluginSpec, ProtocolDesyncError, ProtocolDiagnosticBuffer, ProtocolDiagnosticKind, ProtocolError, QueryDriftParams, QueryDriftResult, REASON_BUDGET_EXHAUSTED, REASON_JUDGE_ABSTAINED, REASON_MISSING_EVIDENCE, REASON_PROVIDER_NOT_CONFIGURED, REASON_PROVIDER_UNAVAILABLE, REASON_REPLAY_MISS, REASON_SHORT_CIRCUITED, REASON_SIMULATION, RPCError, RPCRequest, RPCResponse, STATUS_HARD_FAIL, STATUS_NOT_EVALUATED, STATUS_PASS, STATUS_SOFT_FAIL, STEP_AGENT_CALL, STEP_LLM_CALL, STEP_RETRIEVAL, STEP_TOOL_CALL, SchemaSpec, ShutdownResult, StepError, SubmitPluginResultParams, TYPE_CONSTRAINT, TYPE_CONTENT, TYPE_EFFECT, TYPE_EMBEDDING, TYPE_LLM_JUDGE, TYPE_PLUGIN, TYPE_SCHEMA, TYPE_TRACE, TYPE_TRACE_TREE, TraceId, TraceMetadata, TraceSpec, TraceTreeSpec, Turn, agentId, assertionId, decodeResponse, encodeRequest, extractId, extractResult, layerForType, previewLine, traceId } from './proto/index.cjs';
 import { ChildProcess } from 'node:child_process';
 import { Interface } from 'node:readline';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { EventEmitter } from 'node:events';
 
-declare const VERSION = "1.0.0";
-declare const ENGINE_VERSION = "1.0.0";
+declare const VERSION = "1.0.1";
+declare const ENGINE_VERSION = "1.0.1";
 
-declare class EngineManager {
-    private enginePath;
-    private readonly logLevel;
-    private process;
-    private reader;
-    private initialized;
-    private requestId;
-    private initResult;
-    constructor(options?: {
-        enginePath?: string;
-        logLevel?: string;
-    });
-    start(): Promise<InitializeResult>;
-    /** Send initialize and check the engine's version and capabilities. */
-    private initialize;
-    stop(): Promise<void>;
-    sendRequest(method: string, params: Record<string, unknown>): Promise<unknown>;
-    private sendRequestInternal;
-    get isRunning(): boolean;
-    /** Expose process for AttestClient reader loop access */
-    get childProcess(): ChildProcess | null;
-    /** Expose readline interface for AttestClient reader loop */
-    get readlineInterface(): Interface | null;
+/** Budget a timed-out request may have consumed; null means the whole remaining budget. */
+interface BudgetReservation {
+    readonly judgeCalls: number | null;
+    readonly usd: number | null;
 }
-
 interface AttestClientOptions {
     /** Logger override. When omitted, warnings only emit if ATTEST_DEBUG_PROTOCOL=1. */
     logger?: ProtocolLogger;
@@ -62,6 +42,7 @@ declare class AttestClient {
     private writeChain;
     private readerActive;
     private lineHandler;
+    private attachedReader;
     private readonly logger;
     private readonly diagnosticBuffer;
     private readonly diagnosticListeners;
@@ -73,19 +54,40 @@ declare class AttestClient {
     onProtocolDiagnostic(listener: (diagnostic: ProtocolDiagnostic) => void): () => void;
     /** Snapshot of the diagnostic ring buffer (most recent last). */
     protocolDiagnostics(): readonly ProtocolDiagnostic[];
+    /**
+     * Attach the id-routed reader to the engine's stdout. Idempotent; `sendRequest` starts it
+     * on first use, so calling it is optional.
+     */
     startReader(): void;
     stopReader(): void;
     private recordDiagnostic;
     private maybeTriggerDesync;
     private handleLine;
     private handleDecodeFailure;
+    /** Reject every request still waiting for a response. */
+    rejectPending(err: Error): void;
     private failAll;
+    /**
+     * Send one request and resolve with the result of the response that carries its id.
+     *
+     * After a timeout the engine is restarted (its late response can no longer be matched),
+     * every other pending request is rejected, and the new engine gets the remaining session
+     * budget.
+     */
     sendRequest(method: string, params: Record<string, unknown>, timeoutMs?: number): Promise<unknown>;
+    /** `sendRequest` without the restart-on-timeout step, for the engine's own handshake. */
+    sendWithoutRestart(method: string, params: Record<string, unknown>, timeoutMs: number): Promise<unknown>;
+    private send;
+    /** A failed pipe write names the engine's stderr tail; the original error stays as `cause` and `code`. */
+    private describeWriteError;
+    private recoverFromTimeout;
     evaluateBatch(trace: Trace, assertions: readonly Assertion[], options?: {
         timeout?: number;
         budget?: BatchBudget;
         context?: BatchContext;
     }): Promise<EvaluateBatchResult>;
+    /** Reject a response whose assertion ids differ from the ids that were sent. */
+    private requireSentAssertionIds;
     submitPluginResult(traceId: string, pluginName: string, assertionId: string, status: string, score: number, explanation: string, options?: {
         timeout?: number;
     }): Promise<boolean>;
@@ -103,6 +105,70 @@ declare class AttestClient {
  */
 declare function requireSimulationCapability(init: InitializeResult | null | undefined): void;
 
+declare class EngineManager {
+    private enginePath;
+    private readonly logLevel;
+    private readonly initializeTimeoutMs;
+    private process;
+    private reader;
+    private initialized;
+    private initResult;
+    private routedClient;
+    /** The running engine's stderr tail; each launch owns a fresh one so a killed engine cannot write into it. */
+    private stderr;
+    private restarting;
+    private configuredBudget;
+    private usedJudgeCalls;
+    private usedUsd;
+    private heldJudgeCalls;
+    private heldUsd;
+    /** Spend the SDK cannot observe may have happened; a restart then leaves no budget. */
+    private unknownSpend;
+    constructor(options?: {
+        enginePath?: string;
+        logLevel?: string;
+        initializeTimeoutMs?: number;
+    });
+    /**
+     * Start the engine and complete the `initialize` handshake. Rejects when the engine exits,
+     * closes its pipes or fails to answer within the initialize timeout; the error carries the
+     * tail of the engine's stderr.
+     */
+    start(): Promise<InitializeResult>;
+    /** Spawn the engine and run `initialize` on it; the engine is stopped when that fails. */
+    private launch;
+    /** Send initialize and check the engine's version and capabilities. */
+    private initialize;
+    stop(): Promise<void>;
+    /** Close the pipes, reject pending requests and stop the engine process (SIGKILL when `force`). */
+    private terminate;
+    /**
+     * Replace the engine after a request timed out: its late response can no longer be told
+     * apart from a new one. The new engine gets the remaining session budget: the configured
+     * limit minus the usage already returned, minus what the abandoned requests may still have
+     * reserved. A restart that leaves no budget makes later model calls
+     * `not_evaluated(budget_exhausted)`.
+     */
+    restartAfterTimeout(abandoned: readonly BudgetReservation[]): Promise<void>;
+    /** An engine reply the SDK cannot account for (no usage, an RPC error, a dropped reply) may have spent budget. */
+    markUnknownSpend(): void;
+    private restart;
+    /** Count the usage an evaluate_batch result reported against the session budget. */
+    recordUsage(usage: Usage): void;
+    /** Resolves once an engine restart in progress has finished. */
+    whenReady(): Promise<void>;
+    /** Tail of the engine's stderr: the reason an engine died. */
+    get stderrTail(): string;
+    /** The client that routes this engine's responses by id; replaced when the engine restarts. */
+    get client(): AttestClient | undefined;
+    sendRequest(method: string, params: Record<string, unknown>): Promise<unknown>;
+    get isRunning(): boolean;
+    /** Expose process for AttestClient reader loop access */
+    get childProcess(): ChildProcess | null;
+    /** Expose readline interface for AttestClient reader loop */
+    get readlineInterface(): Interface | null;
+}
+
 declare class TraceBuilder {
     private traceId;
     private agentId;

package/dist/esm/cli.js

@@ -8,8 +8,8 @@ import * as path4 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/version.ts
-var VERSION = "1.0.0";
-var ENGINE_VERSION = "1.0.0";
+var VERSION = "1.0.1";
+var ENGINE_VERSION = "1.0.1";
 
 // src/engine-manager.ts
 import { spawn, spawnSync } from "child_process";