@sanity/ailf 4.5.0 → 5.0.0

package/dist/adapters/attribution/per-entry-attribution-writer.js

@@ -0,0 +1,49 @@
+/**
+ * per-entry-attribution-writer.ts — Zod schema for the per-judgment
+ * attribution artifact (ATTR-01) emitted by Phase 4's
+ * `ComputeAttributionStep` and read back by Phase 5's diagnosis runner.
+ *
+ * The schema asserts `satisfies z.ZodType<JudgmentAttribution>` against
+ * the canonical domain type in `packages/core/src/types/attribution.ts`
+ * (D0045 / W0187) — drift between schema and type is a build error.
+ *
+ * Phase 1 lands the SHAPE only — no compute, no file I/O. Phase 4 wires
+ * the writer; Phase 5 wires the reader. Both `satisfies` against this
+ * single source-of-truth schema.
+ *
+ * `hallucinationCheckedAgainst` is REQUIRED (Pitfall #11): consumers
+ * must be able to audit citation grounding without re-deriving the
+ * resolvable-set. The canonical task field is `contextDocs`; do NOT
+ * invent `expectedDocs` / `usedDocs` synonyms.
+ *
+ * @see docs/decisions/D0045-type-architecture-and-contract-enforcement.md
+ * @see docs/decisions/D0049-shared-confidence-contract.md
+ * @see docs/decisions/D0052-judgment-ref-granularity.md
+ * @see docs/design-docs/actionability-ladder/04-per-document-attribution-ensemble.md
+ */
+import { z } from "zod";
+import { ConfidenceSchema } from "../../_vendor/ailf-core/schemas/index.js";
+const DocAttributionSchema = z.object({
+    documentId: z.string().min(1),
+    slug: z.string().optional(),
+    score: z.number().min(0).max(1),
+    signals: z.object({
+        citation: z.number().min(0).max(1).optional(),
+        canonical: z.number().min(0).max(1).optional(),
+        retrieved: z.number().min(0).max(1).optional(),
+    }),
+    confidence: ConfidenceSchema,
+});
+/**
+ * Canonical schema for {@link JudgmentAttribution}. Persisted at
+ * `runs/{runId}/attribution/{entryKey}.json` (Phase 4) and parsed by
+ * the diagnosis runner on read (Phase 5).
+ */
+export const JudgmentAttributionSchema = z.object({
+    judgmentRef: z.string().min(1),
+    taskId: z.string().min(1),
+    modelId: z.string().min(1),
+    dimension: z.string().min(1),
+    attributions: z.array(DocAttributionSchema),
+    hallucinationCheckedAgainst: z.array(z.string()),
+});

package/dist/adapters/config-sources/file-config-adapter.js

@@ -125,6 +125,7 @@ function mapEvalConfigToResolvedConfig(config, rootDir) {
         noCache: config.noCache ?? false,
         noRemoteCache: config.noRemoteCache ?? false,
         graderReplications: config.execution?.graderReplications,
+        borderlineReplications: config.execution?.borderlineReplications,
         graderContext: config.grader?.context,
         urls: config.urls,
         headers: config.agentic?.headers,

package/dist/adapters/grader-outputs/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * grader-outputs adapter barrel — named re-exports only (W0124 / D0045).
+ *
+ * The grader-output schema lives here so it enters the D0045
+ * `pnpm check-trust-boundary-satisfies` SCAN_ROOTS gate.
+ */
+export { GraderJudgmentSchema, graderJudgmentsVersion, } from "./promptfoo-grader-output.js";
+export type { GraderJudgment } from "../../_vendor/ailf-core/index.d.ts";
+export { LegacyGraderJudgmentSchema } from "./legacy/index.js";
+export type { LegacyGraderJudgment } from "../../_vendor/ailf-core/index.d.ts";

package/dist/adapters/grader-outputs/index.js

@@ -0,0 +1,8 @@
+/**
+ * grader-outputs adapter barrel — named re-exports only (W0124 / D0045).
+ *
+ * The grader-output schema lives here so it enters the D0045
+ * `pnpm check-trust-boundary-satisfies` SCAN_ROOTS gate.
+ */
+export { GraderJudgmentSchema, graderJudgmentsVersion, } from "./promptfoo-grader-output.js";
+export { LegacyGraderJudgmentSchema } from "./legacy/index.js";

package/dist/adapters/grader-outputs/legacy/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * legacy grader-outputs adapter sub-barrel — named re-exports only
+ * (W0124 / D0045).
+ *
+ * Read-only schema for the Phase 1 free-prose grader-output shape,
+ * invoked only by historical-report rendering paths through Phase 7
+ * (GRAD-06 cutover). The schema lives here so it enters the D0045
+ * `pnpm check-trust-boundary-satisfies` SCAN_ROOTS gate.
+ */
+export { LegacyGraderJudgmentSchema } from "./promptfoo-grader-output-legacy.js";
+export type { LegacyGraderJudgment } from "../../../_vendor/ailf-core/index.d.ts";

package/dist/adapters/grader-outputs/legacy/index.js

@@ -0,0 +1,10 @@
+/**
+ * legacy grader-outputs adapter sub-barrel — named re-exports only
+ * (W0124 / D0045).
+ *
+ * Read-only schema for the Phase 1 free-prose grader-output shape,
+ * invoked only by historical-report rendering paths through Phase 7
+ * (GRAD-06 cutover). The schema lives here so it enters the D0045
+ * `pnpm check-trust-boundary-satisfies` SCAN_ROOTS gate.
+ */
+export { LegacyGraderJudgmentSchema } from "./promptfoo-grader-output-legacy.js";

package/dist/adapters/grader-outputs/legacy/promptfoo-grader-output-legacy.d.ts

@@ -0,0 +1,49 @@
+/**
+ * promptfoo-grader-output-legacy.ts — Zod schema for the Phase 1
+ * free-prose grader-output shape, used by historical-report rendering
+ * paths.
+ *
+ * READ-ONLY: invoked only by historical-report rendering paths through
+ * Phase 7 (GRAD-06 cutover). Reports are immutable events — once a
+ * Report is written to Content Lake, the structured grader-judgment
+ * shape it captures cannot be back-filled. The legacy schema exists so
+ * pre-Phase-3 reports continue to deserialize cleanly.
+ *
+ * Live grader output that fails the strict {@link GraderJudgmentSchema}
+ * parse must NOT fall back to this schema. Drop to
+ * `failureMode: "unclassified"` instead. Strict and legacy schemas are
+ * deliberate siblings, not a legacy/canonical pair to consolidate.
+ *
+ * The schema asserts `satisfies z.ZodType<LegacyGraderJudgment>` against
+ * the canonical domain type in
+ * `packages/core/src/types/legacy-grader-judgment.ts` (D0045 / W0187) —
+ * drift between schema and type is a build error. The domain type is
+ * authored independently in `@sanity/ailf-core`; this file authors ONLY
+ * the schema and never derives the domain type from the schema itself
+ * (no schema-derived self-reference allowed by D0045).
+ *
+ * @see docs/decisions/D0045-type-architecture-and-contract-enforcement.md
+ * @see ../promptfoo-grader-output.ts — the strict (live-path) sibling
+ * @see docs/design-docs/actionability-ladder/03-structured-grader-judgments.md
+ *      §"Backwards compatibility"
+ */
+import { z } from "zod";
+/**
+ * Canonical schema for {@link LegacyGraderJudgment}. Mirrors the Phase 1
+ * superset core (`taskId`, `modelId`, `dimension`, `reason`, `score`,
+ * optional `outputFailure`). NO GRAD-02 additive fields — those are by
+ * construction absent on pre-Phase-3 output.
+ *
+ * Intentionally NOT `.strict()` — pre-Phase-3 reports may carry stray
+ * keys; the legacy parser tolerates them so historical-report rendering
+ * keeps working through the GRAD-06 cutover.
+ */
+export declare const LegacyGraderJudgmentSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    modelId: z.ZodString;
+    dimension: z.ZodString;
+    reason: z.ZodString;
+    score: z.ZodNumber;
+    outputFailure: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type { LegacyGraderJudgment } from "../../../_vendor/ailf-core/index.d.ts";

package/dist/adapters/grader-outputs/legacy/promptfoo-grader-output-legacy.js

@@ -0,0 +1,48 @@
+/**
+ * promptfoo-grader-output-legacy.ts — Zod schema for the Phase 1
+ * free-prose grader-output shape, used by historical-report rendering
+ * paths.
+ *
+ * READ-ONLY: invoked only by historical-report rendering paths through
+ * Phase 7 (GRAD-06 cutover). Reports are immutable events — once a
+ * Report is written to Content Lake, the structured grader-judgment
+ * shape it captures cannot be back-filled. The legacy schema exists so
+ * pre-Phase-3 reports continue to deserialize cleanly.
+ *
+ * Live grader output that fails the strict {@link GraderJudgmentSchema}
+ * parse must NOT fall back to this schema. Drop to
+ * `failureMode: "unclassified"` instead. Strict and legacy schemas are
+ * deliberate siblings, not a legacy/canonical pair to consolidate.
+ *
+ * The schema asserts `satisfies z.ZodType<LegacyGraderJudgment>` against
+ * the canonical domain type in
+ * `packages/core/src/types/legacy-grader-judgment.ts` (D0045 / W0187) —
+ * drift between schema and type is a build error. The domain type is
+ * authored independently in `@sanity/ailf-core`; this file authors ONLY
+ * the schema and never derives the domain type from the schema itself
+ * (no schema-derived self-reference allowed by D0045).
+ *
+ * @see docs/decisions/D0045-type-architecture-and-contract-enforcement.md
+ * @see ../promptfoo-grader-output.ts — the strict (live-path) sibling
+ * @see docs/design-docs/actionability-ladder/03-structured-grader-judgments.md
+ *      §"Backwards compatibility"
+ */
+import { z } from "zod";
+/**
+ * Canonical schema for {@link LegacyGraderJudgment}. Mirrors the Phase 1
+ * superset core (`taskId`, `modelId`, `dimension`, `reason`, `score`,
+ * optional `outputFailure`). NO GRAD-02 additive fields — those are by
+ * construction absent on pre-Phase-3 output.
+ *
+ * Intentionally NOT `.strict()` — pre-Phase-3 reports may carry stray
+ * keys; the legacy parser tolerates them so historical-report rendering
+ * keeps working through the GRAD-06 cutover.
+ */
+export const LegacyGraderJudgmentSchema = z.object({
+    taskId: z.string().min(1),
+    modelId: z.string().min(1),
+    dimension: z.string().min(1),
+    reason: z.string(),
+    score: z.number(),
+    outputFailure: z.boolean().optional(),
+});

package/dist/adapters/grader-outputs/promptfoo-grader-output.d.ts

@@ -0,0 +1,102 @@
+/**
+ * promptfoo-grader-output.ts — Zod schema for the structured grader output
+ * (GRAD-02) emitted by the promptfoo grader process and consumed by the
+ * eval pipeline.
+ *
+ * The schema asserts `satisfies z.ZodType<GraderJudgment>` against the
+ * canonical domain type in `packages/core/src/types/grader-judgment.ts`
+ * (D0045 / W0187) — drift between schema and type is a build error.
+ * The domain type was authored independently in Plan 01-01; this file
+ * authors ONLY the schema and never derives the domain type from the
+ * schema itself (no schema-derived self-reference allowed by D0045).
+ *
+ * `graderJudgmentsVersion` is co-located with the schema (VER-01 D-02 —
+ * source-of-truth file owns its version constant). Bumped by hand when
+ * the grader rubric, prompt template, or judgment shape changes.
+ *
+ * Phase 3 will replace the inline `JSON.parse` at
+ * `pipeline/calculate-scores.ts:380-392` (Pitfall #4) so all grader
+ * output flows through this schema.
+ *
+ * @see docs/decisions/D0045-type-architecture-and-contract-enforcement.md
+ * @see docs/decisions/D0049-shared-confidence-contract.md
+ * @see docs/decisions/D0052-judgment-ref-granularity.md
+ * @see docs/design-docs/actionability-ladder/03-structured-grader-judgments.md
+ */
+import { z } from "zod";
+/**
+ * VER-01 D-02 — co-located version constant. Bumped by hand when the
+ * grader rubric, prompt template, or judgment shape changes in a way
+ * that should invalidate cached Diagnoses.
+ *
+ * Phase 3 GRAD-05 bumped this from `"0.1.0"` to `"1.0.0"` (semver
+ * major) — the additive GRAD-02 surface is now required + the schema
+ * is `.strict()`. AILF has no installed external base; the legacy
+ * parser at `./legacy/promptfoo-grader-output-legacy.ts` is the named
+ * consumer for already-stored historical reports.
+ */
+export declare const graderJudgmentsVersion = "1.0.0";
+/**
+ * Canonical schema for {@link GraderJudgment}. Required fields mirror
+ * the existing pipeline core (Doc 03 §"existing, unchanged"):
+ * `taskId`, `modelId`, `dimension`, `reason`, `score`. Phase 3 GRAD-05
+ * has tightened the additive surface to required and added `.strict()`
+ * — the schema rejects unknown fields (defense-in-depth against future
+ * prompt-injection attempts that try to smuggle keys through the
+ * grader emission).
+ *
+ * Branded `JudgmentId` is represented at runtime by a non-empty string;
+ * the schema routes the brand through `brandedString<"JudgmentId">()`
+ * — the project's single audited cast site for branded-string
+ * schemas (project typescript rule: no `as` on `unknown`).
+ */
+export declare const GraderJudgmentSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    modelId: z.ZodString;
+    dimension: z.ZodString;
+    reason: z.ZodString;
+    score: z.ZodNumber;
+    outputFailure: z.ZodOptional<z.ZodBoolean>;
+    judgmentId: z.ZodType<import("@sanity/ailf-core").Brand<string, "JudgmentId">, unknown, z.core.$ZodTypeInternals<import("@sanity/ailf-core").Brand<string, "JudgmentId">, unknown>>;
+    subJudgments: z.ZodArray<z.ZodObject<{
+        criterionId: z.ZodString;
+        met: z.ZodBoolean;
+        evidence: z.ZodString;
+        confidence: z.ZodObject<{
+            level: z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+            }>;
+            signalsPresent: z.ZodNumber;
+            derivation: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    docCitations: z.ZodArray<z.ZodObject<{
+        documentId: z.ZodString;
+        slug: z.ZodOptional<z.ZodString>;
+        role: z.ZodEnum<{
+            supports: "supports";
+            contradicts: "contradicts";
+            missing: "missing";
+            irrelevant: "irrelevant";
+        }>;
+        hallucinated: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    failureMode: z.ZodString;
+    confidence: z.ZodObject<{
+        level: z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+        }>;
+        signalsPresent: z.ZodNumber;
+        derivation: z.ZodString;
+    }, z.core.$strip>;
+    hallucinationCheckedAgainst: z.ZodArray<z.ZodString>;
+    metadata: z.ZodObject<{
+        graderModel: z.ZodString;
+        graderJudgmentsVersion: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+export type { GraderJudgment } from "../../_vendor/ailf-core/index.d.ts";

package/dist/adapters/grader-outputs/promptfoo-grader-output.js

@@ -0,0 +1,93 @@
+/**
+ * promptfoo-grader-output.ts — Zod schema for the structured grader output
+ * (GRAD-02) emitted by the promptfoo grader process and consumed by the
+ * eval pipeline.
+ *
+ * The schema asserts `satisfies z.ZodType<GraderJudgment>` against the
+ * canonical domain type in `packages/core/src/types/grader-judgment.ts`
+ * (D0045 / W0187) — drift between schema and type is a build error.
+ * The domain type was authored independently in Plan 01-01; this file
+ * authors ONLY the schema and never derives the domain type from the
+ * schema itself (no schema-derived self-reference allowed by D0045).
+ *
+ * `graderJudgmentsVersion` is co-located with the schema (VER-01 D-02 —
+ * source-of-truth file owns its version constant). Bumped by hand when
+ * the grader rubric, prompt template, or judgment shape changes.
+ *
+ * Phase 3 will replace the inline `JSON.parse` at
+ * `pipeline/calculate-scores.ts:380-392` (Pitfall #4) so all grader
+ * output flows through this schema.
+ *
+ * @see docs/decisions/D0045-type-architecture-and-contract-enforcement.md
+ * @see docs/decisions/D0049-shared-confidence-contract.md
+ * @see docs/decisions/D0052-judgment-ref-granularity.md
+ * @see docs/design-docs/actionability-ladder/03-structured-grader-judgments.md
+ */
+import { z } from "zod";
+import { brandedString, ConfidenceSchema } from "../../_vendor/ailf-core/schemas/index.js";
+/**
+ * VER-01 D-02 — co-located version constant. Bumped by hand when the
+ * grader rubric, prompt template, or judgment shape changes in a way
+ * that should invalidate cached Diagnoses.
+ *
+ * Phase 3 GRAD-05 bumped this from `"0.1.0"` to `"1.0.0"` (semver
+ * major) — the additive GRAD-02 surface is now required + the schema
+ * is `.strict()`. AILF has no installed external base; the legacy
+ * parser at `./legacy/promptfoo-grader-output-legacy.ts` is the named
+ * consumer for already-stored historical reports.
+ */
+export const graderJudgmentsVersion = "1.0.0";
+const DocCitationRoleSchema = z.enum([
+    "supports",
+    "contradicts",
+    "missing",
+    "irrelevant",
+]);
+const DocCitationSchema = z.object({
+    documentId: z.string().min(1),
+    slug: z.string().optional(),
+    role: DocCitationRoleSchema,
+    hallucinated: z.boolean().optional(),
+});
+const CriterionSubJudgmentSchema = z.object({
+    criterionId: z.string().min(1),
+    met: z.boolean(),
+    evidence: z.string().max(280),
+    confidence: ConfidenceSchema,
+});
+/**
+ * Canonical schema for {@link GraderJudgment}. Required fields mirror
+ * the existing pipeline core (Doc 03 §"existing, unchanged"):
+ * `taskId`, `modelId`, `dimension`, `reason`, `score`. Phase 3 GRAD-05
+ * has tightened the additive surface to required and added `.strict()`
+ * — the schema rejects unknown fields (defense-in-depth against future
+ * prompt-injection attempts that try to smuggle keys through the
+ * grader emission).
+ *
+ * Branded `JudgmentId` is represented at runtime by a non-empty string;
+ * the schema routes the brand through `brandedString<"JudgmentId">()`
+ * — the project's single audited cast site for branded-string
+ * schemas (project typescript rule: no `as` on `unknown`).
+ */
+export const GraderJudgmentSchema = z
+    .object({
+    // ── Existing pipeline core (required — Doc 03 §"existing, unchanged") ─
+    taskId: z.string().min(1),
+    modelId: z.string().min(1),
+    dimension: z.string().min(1),
+    reason: z.string(),
+    score: z.number(),
+    outputFailure: z.boolean().optional(),
+    // ── GRAD-02 additive — required from Phase 3 GRAD-05 ───────────────
+    judgmentId: brandedString(),
+    subJudgments: z.array(CriterionSubJudgmentSchema),
+    docCitations: z.array(DocCitationSchema),
+    failureMode: z.string(),
+    confidence: ConfidenceSchema,
+    hallucinationCheckedAgainst: z.array(z.string()),
+    metadata: z.object({
+        graderModel: z.string().min(1),
+        graderJudgmentsVersion: z.string().min(1),
+    }),
+})
+    .strict();

package/dist/adapters/index.d.ts

@@ -10,3 +10,6 @@ export { PromptfooEvalAdapter } from "./eval-runners/index.js";
 export { ConsoleLogger, type ConsoleLoggerOptions, JsonLogger, QuietLogger, } from "./loggers/index.js";
 export { CliConfigAdapter, FileConfigAdapter } from "./config-sources/index.js";
 export { DtsPackageSurface, InMemoryPackageSurface, type DtsPackageSurfaceOptions, type PackageRootResolver, parseDtsExports, type ParsedDtsExports, } from "./package-surface/index.js";
+export { GraderJudgmentSchema, graderJudgmentsVersion, } from "./grader-outputs/index.js";
+export { AttributionMetaSchema, JudgmentAttributionSchema, } from "./attribution/index.js";
+export type { AttributionMeta, DocAttribution, GraderJudgment, JudgmentAttribution, } from "../_vendor/ailf-core/index.d.ts";

package/dist/adapters/index.js

@@ -10,3 +10,7 @@ export { PromptfooEvalAdapter } from "./eval-runners/index.js";
 export { ConsoleLogger, JsonLogger, QuietLogger, } from "./loggers/index.js";
 export { CliConfigAdapter, FileConfigAdapter } from "./config-sources/index.js";
 export { DtsPackageSurface, InMemoryPackageSurface, parseDtsExports, } from "./package-surface/index.js";
+// Phase 1 Plan 02 — actionability-ladder adapter schemas (GRAD-02, ATTR-01).
+// Named re-exports only (W0124 / D0045).
+export { GraderJudgmentSchema, graderJudgmentsVersion, } from "./grader-outputs/index.js";
+export { AttributionMetaSchema, JudgmentAttributionSchema, } from "./attribution/index.js";

package/dist/adapters/llm/anthropic-llm-client.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Anthropic adapter for the LLMClient port.
+ *
+ * Uses fetch() against the Messages API — same transport pattern as the
+ * existing grader. No SDK dependency. Centralizes retry, rate-limit handling,
+ * cost accounting, and per-call telemetry tagging via `context.feature`.
+ *
+ * Anthropic does not have a first-class JSON mode like OpenAI. For
+ * `completeStructured`, the adapter uses the API's top-level `system`
+ * field to instruct the model to return JSON only (top-level system is
+ * harder for user-controlled content in `prompt` to override than a
+ * user-turn prefix), then strips any surrounding ``` fences before
+ * parsing through the Zod schema (parse-don't-validate).
+ *
+ * Per `.claude/rules/eval-pipeline.md` and `.claude/rules/typescript.md`:
+ * the adapter never reads `process.env`. Typed constructor args only.
+ */
+import { type LLMClient, type LLMCompleteArgs, type LLMCompleteStructuredArgs, type LLMCompletion, type LLMStructuredCompletion, type Logger } from "../../_vendor/ailf-core/index.d.ts";
+import type { ModelPricing } from "./pricing.js";
+import { type RetryPolicy } from "./retry.js";
+export interface AnthropicLLMClientOptions {
+    apiKey: string;
+    baseUrl?: string;
+    /** Pricing keyed by canonical model id (without `anthropic:` prefix or `messages:` segment). */
+    pricing?: Record<string, ModelPricing>;
+    retryPolicy?: Partial<RetryPolicy>;
+    logger?: Logger;
+    sleep?: (ms: number) => Promise<void>;
+    rng?: () => number;
+    /** API version header. Default "2023-06-01" — matches the existing grader. */
+    apiVersion?: string;
+}
+export declare class AnthropicLLMClient implements LLMClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly apiVersion;
+    private readonly pricing;
+    private readonly retryPolicy;
+    private readonly logger?;
+    private readonly sleep?;
+    private readonly rng?;
+    constructor(options: AnthropicLLMClientOptions);
+    complete(args: LLMCompleteArgs): Promise<LLMCompletion>;
+    completeStructured<T>(args: LLMCompleteStructuredArgs<T>): Promise<LLMStructuredCompletion<T>>;
+    private callApi;
+    private computeCost;
+    private logTelemetry;
+}

package/dist/adapters/llm/anthropic-llm-client.js

@@ -0,0 +1,205 @@
+/**
+ * Anthropic adapter for the LLMClient port.
+ *
+ * Uses fetch() against the Messages API — same transport pattern as the
+ * existing grader. No SDK dependency. Centralizes retry, rate-limit handling,
+ * cost accounting, and per-call telemetry tagging via `context.feature`.
+ *
+ * Anthropic does not have a first-class JSON mode like OpenAI. For
+ * `completeStructured`, the adapter uses the API's top-level `system`
+ * field to instruct the model to return JSON only (top-level system is
+ * harder for user-controlled content in `prompt` to override than a
+ * user-turn prefix), then strips any surrounding ``` fences before
+ * parsing through the Zod schema (parse-don't-validate).
+ *
+ * Per `.claude/rules/eval-pipeline.md` and `.claude/rules/typescript.md`:
+ * the adapter never reads `process.env`. Typed constructor args only.
+ */
+import { AnthropicResponseSchema, splitModelId, } from "../../_vendor/ailf-core/index.js";
+import { DEFAULT_RETRY_POLICY, parseRetryAfterSeconds, runWithRetry, } from "./retry.js";
+const DEFAULT_BASE_URL = "https://api.anthropic.com/v1/messages";
+const DEFAULT_API_VERSION = "2023-06-01";
+const DEFAULT_MAX_TOKENS = 4096;
+/**
+ * Pricing reference: https://www.anthropic.com/pricing#api
+ * Update when models or vendor pricing changes.
+ */
+const DEFAULT_PRICING = {
+    "claude-opus-4-6": { inputPer1k: 0.015, outputPer1k: 0.075 },
+    "claude-opus-4-5-20251101": { inputPer1k: 0.015, outputPer1k: 0.075 },
+    "claude-sonnet-4-6": { inputPer1k: 0.003, outputPer1k: 0.015 },
+};
+const STRUCTURED_SYSTEM = "Respond with only a single JSON object that conforms to the requested schema. " +
+    "Do not include any prose, commentary, or markdown code fences. " +
+    "Return raw JSON only.";
+export class AnthropicLLMClient {
+    apiKey;
+    baseUrl;
+    apiVersion;
+    pricing;
+    retryPolicy;
+    logger;
+    sleep;
+    rng;
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+        this.apiVersion = options.apiVersion ?? DEFAULT_API_VERSION;
+        this.pricing = { ...DEFAULT_PRICING, ...(options.pricing ?? {}) };
+        this.retryPolicy = {
+            ...DEFAULT_RETRY_POLICY,
+            ...(options.retryPolicy ?? {}),
+        };
+        if (options.logger)
+            this.logger = options.logger;
+        if (options.sleep)
+            this.sleep = options.sleep;
+        if (options.rng)
+            this.rng = options.rng;
+    }
+    async complete(args) {
+        const { modelName } = splitModelId(args.model);
+        const body = buildBody(modelName, args.prompt, {
+            temperature: args.temperature,
+            maxTokens: args.maxTokens,
+            stop: args.stop,
+        });
+        const data = await this.callApi(body);
+        const text = extractText(data.content);
+        if (text === "") {
+            throw new Error(`Anthropic returned empty completion for model ${args.model}`);
+        }
+        const usage = extractUsage(data.usage);
+        const cost = this.computeCost(modelName, usage);
+        this.logTelemetry(args.context, args.model, usage, cost);
+        return { text, usage, cost, model: args.model };
+    }
+    async completeStructured(args) {
+        const { modelName } = splitModelId(args.model);
+        const body = buildBody(modelName, args.prompt, {
+            temperature: args.temperature,
+            maxTokens: args.maxTokens,
+            system: STRUCTURED_SYSTEM,
+        });
+        const data = await this.callApi(body);
+        const raw = extractText(data.content);
+        if (raw === "") {
+            throw new Error(`Anthropic returned empty structured completion for model ${args.model}`);
+        }
+        const stripped = stripJsonFence(raw);
+        let parsed;
+        try {
+            parsed = JSON.parse(stripped);
+        }
+        catch (err) {
+            throw new Error(`Anthropic structured completion returned invalid JSON for model ${args.model}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+        }
+        const value = args.schema.parse(parsed);
+        const usage = extractUsage(data.usage);
+        const cost = this.computeCost(modelName, usage);
+        this.logTelemetry(args.context, args.model, usage, cost);
+        return { value, usage, cost, model: args.model };
+    }
+    async callApi(body) {
+        return runWithRetry({
+            policy: this.retryPolicy,
+            ...(this.sleep ? { sleep: this.sleep } : {}),
+            ...(this.rng ? { rng: this.rng } : {}),
+            attempt: async () => {
+                const response = await fetch(this.baseUrl, {
+                    method: "POST",
+                    headers: {
+                        "x-api-key": this.apiKey,
+                        "anthropic-version": this.apiVersion,
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify(body),
+                });
+                if (!response.ok) {
+                    const text = await response.text();
+                    const retryAfter = parseRetryAfterSeconds(response.headers.get("retry-after"));
+                    return {
+                        ok: false,
+                        status: response.status,
+                        body: text,
+                        ...(retryAfter !== undefined
+                            ? { retryAfterSeconds: retryAfter }
+                            : {}),
+                    };
+                }
+                const json = await response.json();
+                const data = AnthropicResponseSchema.parse(json);
+                if (data.error?.message) {
+                    throw new Error(`Anthropic API error: ${data.error.message}`);
+                }
+                return { ok: true, value: data };
+            },
+        });
+    }
+    computeCost(modelName, usage) {
+        const price = this.pricing[modelName];
+        if (!price) {
+            this.logger?.warn(`Anthropic cost unknown for model "${modelName}" — recording cost=0. Add it to AnthropicLLMClientOptions.pricing.`);
+            return 0;
+        }
+        return ((usage.promptTokens / 1000) * price.inputPer1k +
+            (usage.completionTokens / 1000) * price.outputPer1k);
+    }
+    logTelemetry(context, model, usage, cost) {
+        if (!this.logger)
+            return;
+        const tag = context ? ` feature=${context.feature}` : "";
+        const runTag = context?.runId ? ` runId=${context.runId}` : "";
+        const cardTag = context?.cardId ? ` cardId=${context.cardId}` : "";
+        this.logger.debug(`LLM call (anthropic)${tag}${runTag}${cardTag} model=${model} ` +
+            `prompt_tokens=${usage.promptTokens} completion_tokens=${usage.completionTokens} ` +
+            `cost_usd=${cost.toFixed(6)}`);
+    }
+}
+function buildBody(modelName, prompt, opts) {
+    const body = {
+        model: modelName,
+        max_tokens: opts.maxTokens ?? DEFAULT_MAX_TOKENS,
+        messages: [{ role: "user", content: prompt }],
+    };
+    if (opts.temperature !== undefined)
+        body.temperature = opts.temperature;
+    if (opts.stop && opts.stop.length > 0)
+        body.stop_sequences = opts.stop;
+    if (opts.system)
+        body.system = opts.system;
+    return body;
+}
+/**
+ * Concatenate every `text` content block. Anthropic responses can interleave
+ * `text` and `tool_use` blocks; for non-tool calls there's typically one
+ * text block, but joining is the robust default.
+ */
+function extractText(content) {
+    if (!content)
+        return "";
+    const parts = [];
+    for (const block of content) {
+        if (block.type === "text" && typeof block.text === "string") {
+            parts.push(block.text);
+        }
+    }
+    return parts.join("");
+}
+function extractUsage(usage) {
+    return {
+        promptTokens: usage?.input_tokens ?? 0,
+        completionTokens: usage?.output_tokens ?? 0,
+    };
+}
+/**
+ * Strip a single ```json ... ``` or ``` ... ``` fence wrapper if present.
+ * Anthropic occasionally wraps JSON despite the system instruction.
+ */
+function stripJsonFence(text) {
+    const trimmed = text.trim();
+    const fenceMatch = trimmed.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/);
+    if (fenceMatch)
+        return fenceMatch[1].trim();
+    return trimmed;
+}