@velum-labs/routekit-eval-service 1.3.2 → 1.5.0

package/dist/adapters/eval-trial-accounting.d.ts

@@ -0,0 +1,32 @@
+import type { EvalTrialBinding, EvalTrialClaim, EvalTrialGatewayObservation, EvalTrialRequestIntent, EvalTrialRequestSettlement } from "../eval-trial-authority-protocol.js";
+declare const EvalTrialAccountingError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "EvalTrialAccountingError";
+} & Readonly<A>;
+export declare class EvalTrialAccountingError extends EvalTrialAccountingError_base<{
+    readonly detail: string;
+}> {
+}
+/** One canonical observation projection shared by both G6 adapters/CLI owner. */
+export declare const evalTrialGatewayObservationDigest: (observation: EvalTrialGatewayObservation) => string;
+export type EvalTrialSettlementValidator = {
+    /**
+     * Returns cumulative actually reconciled upstream attempts. Throws a finite,
+     * sanitized typed error on unknown exposure or mismatched/stale proof.
+     */
+    readonly accept: (input: {
+        readonly request: EvalTrialRequestIntent;
+        readonly observation: EvalTrialGatewayObservation;
+        readonly settlement: EvalTrialRequestSettlement;
+    }) => number;
+};
+/**
+ * Shared transient validation, NOT a durable store or provider receipt issuer.
+ * Exactly one instance belongs to one already-claimed trial. There is no
+ * unknown->closed healing, retry admission, or authority fallback here.
+ */
+export declare const makeEvalTrialSettlementValidator: (input: {
+    readonly binding: EvalTrialBinding;
+    readonly bindingDigest: string;
+    readonly claim: EvalTrialClaim;
+}) => EvalTrialSettlementValidator;
+export {};

package/dist/adapters/eval-trial-accounting.js

@@ -0,0 +1,135 @@
+import { createHash } from "node:crypto";
+import { Data } from "effect";
+export class EvalTrialAccountingError extends Data.TaggedError("EvalTrialAccountingError") {
+}
+const failure = (detail) => new EvalTrialAccountingError({ detail });
+const isDigest = (value) => typeof value === "string" && /^[a-f0-9]{64}$/u.test(value);
+const isId = (value) => typeof value === "string" && /^[a-z0-9][a-z0-9._:/-]{0,255}$/iu.test(value);
+/** One canonical observation projection shared by both G6 adapters/CLI owner. */
+export const evalTrialGatewayObservationDigest = (observation) => createHash("sha256")
+    .update(JSON.stringify({
+    fetchInvocations: observation.fetchInvocations,
+    headersObserved: observation.headersObserved,
+    ...(observation.httpStatus === undefined ? {} : { httpStatus: observation.httpStatus }),
+    ...(observation.modelCallId === undefined ? {} : { modelCallId: observation.modelCallId }),
+    responseBytes: observation.responseBytes,
+    responseDigest: observation.responseDigest,
+    rawEof: observation.rawEof,
+    terminal: observation.terminal,
+    ...(observation.responseId === undefined ? {} : { responseId: observation.responseId }),
+    failure: observation.failure
+}))
+    .digest("hex");
+/**
+ * Shared transient validation, NOT a durable store or provider receipt issuer.
+ * Exactly one instance belongs to one already-claimed trial. There is no
+ * unknown->closed healing, retry admission, or authority fallback here.
+ */
+export const makeEvalTrialSettlementValidator = (input) => {
+    const { binding, bindingDigest, claim } = input;
+    const providerAttemptIds = new Set();
+    const requestIds = new Set();
+    const ingressIds = new Set();
+    const modelCallIds = new Set();
+    const evidenceDigests = new Set([claim.initialEvidenceDigest]);
+    let lastRequestSequence = 0;
+    let lastEvidenceDigest = claim.initialEvidenceDigest;
+    let poisoned = false;
+    return {
+        accept: ({ request, observation, settlement }) => {
+            if (poisoned)
+                throw failure("trial settlement validation is poisoned; continuation is forbidden");
+            // Any thrown validation exception keeps this transient guard poisoned.
+            // The authoritative owner must independently persist the same fail-closed
+            // disposition, including when the process dies before this guard runs.
+            poisoned = true;
+            if (settlement === undefined || settlement === null || settlement.state !== "closed") {
+                throw failure("upstream request exposure is unknown; continuation is forbidden");
+            }
+            const proof = settlement;
+            if (!isDigest(bindingDigest) ||
+                !isId(claim.claimId) ||
+                !isDigest(claim.initialEvidenceDigest) ||
+                claim.bindingDigest !== bindingDigest ||
+                claim.trialId !== binding.trialId ||
+                claim.sessionId !== binding.session.sessionId ||
+                request.bindingDigest !== bindingDigest ||
+                request.trialId !== binding.trialId ||
+                request.sessionId !== binding.session.sessionId ||
+                request.model !== binding.candidateModel ||
+                request.role !== "candidate" ||
+                request.destination !== binding.session.responsesUrl ||
+                !isId(request.requestId) ||
+                requestIds.has(request.requestId) ||
+                !isDigest(request.requestDigest) ||
+                !isDigest(request.ingressRequestDigest) ||
+                !Number.isSafeInteger(request.sequence) ||
+                request.sequence !== lastRequestSequence + 1 ||
+                !Number.isSafeInteger(request.requestBytes) ||
+                request.requestBytes < 1 ||
+                request.requestBytes > 16 * 1024 * 1024 ||
+                (request.requestedOutputTokens !== undefined &&
+                    (!Number.isSafeInteger(request.requestedOutputTokens) ||
+                        request.requestedOutputTokens < 1)) ||
+                observation.fetchInvocations !== 1 ||
+                observation.headersObserved !== true ||
+                observation.rawEof !== true ||
+                !Number.isSafeInteger(observation.responseBytes) ||
+                observation.responseBytes < 0 ||
+                observation.responseBytes > 64 * 1024 * 1024 ||
+                !isDigest(observation.responseDigest) ||
+                !Number.isSafeInteger(observation.httpStatus) ||
+                observation.httpStatus < 100 ||
+                observation.httpStatus > 599 ||
+                !isId(observation.modelCallId) ||
+                modelCallIds.has(observation.modelCallId) ||
+                !["unobserved", "completed", "failed", "incomplete", "invalid"].includes(observation.terminal) ||
+                ![
+                    "none",
+                    "transport",
+                    "wire",
+                    "budget",
+                    "deadline",
+                    "interrupted",
+                    "local-lifecycle"
+                ].includes(observation.failure) ||
+                (observation.responseId !== undefined && !isId(observation.responseId)) ||
+                proof.claimId !== claim.claimId ||
+                proof.bindingDigest !== bindingDigest ||
+                proof.trialId !== binding.trialId ||
+                proof.sessionId !== binding.session.sessionId ||
+                proof.requestId !== request.requestId ||
+                proof.requestDigest !== request.requestDigest ||
+                proof.ingressRequestDigest !== request.ingressRequestDigest ||
+                proof.gatewayObservationDigest !== evalTrialGatewayObservationDigest(observation) ||
+                proof.grantId !== binding.session.grantId ||
+                proof.executionDigest !== binding.session.executionDigest ||
+                proof.issuerIdentity !== binding.session.issuerIdentity ||
+                proof.maximumProviderAttempts !== binding.session.maximumProviderAttempts ||
+                proof.beforeEvidenceDigest !== lastEvidenceDigest ||
+                !isDigest(proof.evidenceDigest) ||
+                evidenceDigests.has(proof.evidenceDigest) ||
+                !isId(proof.ingressId) ||
+                ingressIds.has(proof.ingressId) ||
+                !Array.isArray(proof.newProviderAttemptIds) ||
+                proof.newProviderAttemptIds.length === 0 ||
+                proof.newProviderAttemptIds.length > binding.session.maximumProviderAttempts ||
+                proof.newProviderAttemptIds.some((id) => !isId(id) || providerAttemptIds.has(id)) ||
+                new Set(proof.newProviderAttemptIds).size !== proof.newProviderAttemptIds.length ||
+                providerAttemptIds.size + proof.newProviderAttemptIds.length >
+                    binding.session.maximumProviderAttempts) {
+                throw failure("authoritative reconciliation did not match the exact request and reviewed grant");
+            }
+            for (const attemptId of proof.newProviderAttemptIds)
+                providerAttemptIds.add(attemptId);
+            requestIds.add(request.requestId);
+            ingressIds.add(proof.ingressId);
+            modelCallIds.add(observation.modelCallId);
+            evidenceDigests.add(proof.evidenceDigest);
+            lastRequestSequence = request.sequence;
+            lastEvidenceDigest = proof.evidenceDigest;
+            poisoned = false;
+            return providerAttemptIds.size;
+        }
+    };
+};

package/dist/adapters/repository-agent-checkout.d.ts

@@ -0,0 +1,23 @@
+import type { RepositoryCommandRecipeV1 } from "@velum-labs/routekit-eval-setup";
+import { Effect } from "effect";
+import { EvalServiceRepositoryAgentError } from "../errors.js";
+import type { RepositoryAgentCommandResult, RepositoryAgentIsolationEvidence, RepositoryAgentTools, RepositoryAgentToolTraceEvent } from "../repository-agent-protocol.js";
+export type RepositoryAgentCheckoutSession = {
+    readonly checkout: string;
+    readonly isolation: RepositoryAgentIsolationEvidence;
+    readonly tools: RepositoryAgentTools;
+    readonly preparationResults: readonly RepositoryAgentCommandResult[];
+    readonly trace: readonly RepositoryAgentToolTraceEvent[];
+    readonly capturePatch: Effect.Effect<string, EvalServiceRepositoryAgentError>;
+    readonly captureChangedPaths: Effect.Effect<readonly string[], EvalServiceRepositoryAgentError>;
+};
+export declare const acquireRepositoryAgentCheckout: (input: {
+    readonly repositoryRoot: string;
+    readonly commit: string;
+    readonly allowedTools: readonly string[];
+    readonly allowedRecipes: readonly RepositoryCommandRecipeV1[];
+    readonly trustedPreparationRecipes?: readonly RepositoryCommandRecipeV1[];
+    readonly candidateValidationRecipes?: readonly RepositoryCommandRecipeV1[];
+    readonly gradeRecipeIds?: readonly string[];
+    readonly protectedControlPaths?: readonly string[];
+}) => Effect.Effect<RepositoryAgentCheckoutSession, EvalServiceRepositoryAgentError, import("effect/Scope").Scope>;