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

package/dist/services/case-pipeline-v2/service.js

@@ -0,0 +1,477 @@
+import { createHash } from "node:crypto";
+import { join } from "node:path";
+import { Effect, Layer, Schema } from "effect";
+import { makeCaseCheckpointStoreV1 } from "../../case-checkpoint-store.js";
+import { PIPELINE_STAGES } from "../../case-pipeline-protocol.js";
+import { assertPipelineCheckpointChainV2, assertPipelineCheckpointReplayV2, decodePipelineScientificIdentityV2, PIPELINE_STAGES_V2, pipelineCheckpointDescriptorDigestV2, pipelineDigestV2, pipelineScientificIdentityDigestV2 } from "../../case-pipeline-protocol-v2.js";
+import { RepositoryCommandExecutionPort } from "../../adapters/repository-command-runner.js";
+import { RepositoryFoundryError } from "../../errors.js";
+import { assertRepositoryFoundryModelPlanV1, repositoryFoundryModelAssignmentV1 } from "../../repository-language-model-protocol.js";
+import { runCasePipelineV1 } from "../case-pipeline/service.js";
+import { RepositoryCommandObservability } from "../command-observability/service.js";
+import { RepositoryFoundryLanguageModel } from "../language-model/service.js";
+/** The platform port executes commands in the real isolated checkout, with the runner's exact environment. */
+export const makeRepositoryCommandExecutionPortV2 = (ports) => ({
+    run: (command) => ports.execution
+        .run({
+        operationId: command.operationId,
+        runtimeRoot: command.cwd,
+        command: [
+            "/usr/bin/env",
+            "-i",
+            ...Object.entries(command.environment).map(([key, value]) => `${key}=${value}`),
+            command.executable,
+            ...command.args
+        ],
+        timeoutMs: command.timeoutMs
+    })
+        .pipe(Effect.mapError((cause) => new RepositoryFoundryError({
+        operation: "run-command",
+        detail: `execution port failed: ${cause.detail}`,
+        cause
+    })))
+});
+const failure = (operation, detail, cause) => new RepositoryFoundryError({
+    operation,
+    detail,
+    ...(cause === undefined ? {} : { cause })
+});
+const stageIndex = (stage) => PIPELINE_STAGES.indexOf(stage);
+const REPOSITORY_URI = "routekit://repository";
+const CASE_URI = "routekit://case";
+const mapStrings = (value, transform) => {
+    if (typeof value === "string")
+        return transform(value);
+    if (Array.isArray(value))
+        return value.map((entry) => mapStrings(entry, transform));
+    if (value === null || typeof value !== "object")
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, mapStrings(entry, transform)]));
+};
+const replacePath = (value, from, to) => {
+    if (value === from)
+        return to;
+    return value.startsWith(`${from}/`) ? `${to}${value.slice(from.length)}` : value;
+};
+const portableValue = (value, runtimeRoot, caseDirectory) => mapStrings(value, (text) => {
+    const withoutCase = caseDirectory === undefined ? text : replacePath(text, caseDirectory, CASE_URI);
+    return replacePath(withoutCase, runtimeRoot, REPOSITORY_URI);
+});
+const runtimeValue = (value, runtimeRoot, caseDirectory) => mapStrings(value, (text) => replacePath(replacePath(text, CASE_URI, caseDirectory), REPOSITORY_URI, runtimeRoot));
+export const repositoryBehaviorMapDigestV2 = (map) => pipelineDigestV2(portableValue(map, map.repository.root));
+const mappedRole = (role) => {
+    switch (role) {
+        case "repository-analyst":
+            return "seed-author";
+        case "specification-writer":
+        case "trajectory-designer":
+            return "specification-author";
+        case "specification-critic-a":
+        case "specification-critic-b":
+        case "trajectory-critic":
+            return "specification-reviewer";
+        case "oracle-designer":
+            return "oracle-author";
+        case "valid-solution-generator-a":
+        case "valid-solution-generator-b":
+            return "control-author";
+        case "adversary":
+        case "held-out-adversary":
+            return "adversary-author";
+        case "solution-critic-a":
+        case "solution-critic-b":
+        case "held-out-solution-critic-a":
+        case "held-out-solution-critic-b":
+        case "oracle-critic":
+        case "hill-climb-planner":
+            return "oracle-critic";
+        case "quality-reviewer":
+            return "admission-reviewer";
+        default:
+            throw new Error(`unsupported portable foundry role ${JSON.stringify(role)}`);
+    }
+};
+const stageForRole = (role) => {
+    switch (mappedRole(role)) {
+        case "seed-author":
+            return "seed";
+        case "specification-author":
+        case "specification-reviewer":
+            return "spec";
+        case "oracle-author":
+            return role === "hill-climb-planner" ? "tournament" : "oracle";
+        case "control-author":
+            return "controls";
+        case "adversary-author":
+            return role === "held-out-adversary" ? "challenge" : "tournament";
+        case "oracle-critic":
+            return role.startsWith("held-out-") ? "challenge" : "tournament";
+        case "admission-reviewer":
+            return "admit";
+    }
+};
+const modelPlanV1 = (identity) => {
+    const byRole = new Map(identity.modelPlan.map((binding) => [binding.role, binding]));
+    const assignments = [
+        "repository-analyst",
+        "specification-writer",
+        "specification-critic-a",
+        "specification-critic-b",
+        "trajectory-designer",
+        "trajectory-critic",
+        "oracle-designer",
+        "valid-solution-generator-a",
+        "valid-solution-generator-b",
+        "adversary",
+        "solution-critic-a",
+        "solution-critic-b",
+        "held-out-adversary",
+        "held-out-solution-critic-a",
+        "held-out-solution-critic-b",
+        "quality-reviewer",
+        "hill-climb-planner",
+        "oracle-critic"
+    ].map((role) => {
+        const portableRole = mappedRole(role);
+        const binding = byRole.get(portableRole);
+        if (binding === undefined) {
+            throw new Error(`portable foundry model plan is missing role ${portableRole}`);
+        }
+        return {
+            role: role,
+            model: binding.model,
+            reasoningEffort: binding.reasoningEffort
+        };
+    });
+    const plan = { version: 1, assignments };
+    assertRepositoryFoundryModelPlanV1(plan);
+    return plan;
+};
+const encodePayload = (payload) => Buffer.from(JSON.stringify(payload), "utf8");
+const decodePayload = (descriptor, bytes) => {
+    if (bytes.byteLength !== descriptor.payloadBytes) {
+        throw new Error("portable checkpoint payload byte length does not match its descriptor");
+    }
+    const digest = createHash("sha256").update(bytes).digest("hex");
+    if (digest !== descriptor.payloadDigest) {
+        throw new Error("portable checkpoint payload digest does not match its descriptor");
+    }
+    const value = JSON.parse(Buffer.from(bytes).toString("utf8"));
+    if (typeof value !== "object" ||
+        value === null ||
+        !("version" in value) ||
+        value.version !== 2 ||
+        !("action" in value) ||
+        !("stage" in value) ||
+        !PIPELINE_STAGES.includes(value.stage)) {
+        throw new Error("portable checkpoint payload is not a supported V2 operation");
+    }
+    if (value.action === "delete-from") {
+        return { version: 2, action: "delete-from", stage: value.stage };
+    }
+    if (value.action === "write" && "value" in value) {
+        return {
+            version: 2,
+            action: "write",
+            stage: value.stage,
+            value: value.value
+        };
+    }
+    throw new Error("portable checkpoint payload action is invalid");
+};
+const makeLanguageModelLayerV2 = (identity, ports) => {
+    const complete = (input) => Effect.gen(function* () {
+        const portableRole = yield* Effect.try({
+            try: () => mappedRole(input.assignment.role),
+            catch: (cause) => failure("invoke-language-model", "model role is not allowlisted", cause)
+        });
+        const binding = identity.modelPlan.find(({ role }) => role === portableRole);
+        if (binding === undefined ||
+            binding.model !== input.assignment.model ||
+            binding.reasoningEffort !== input.assignment.reasoningEffort ||
+            input.maximumOutputTokens > binding.maximumOutputTokens) {
+            return yield* failure("invoke-language-model", `model call does not match the immutable ${portableRole} binding`);
+        }
+        const response = yield* ports.model
+            .complete({
+            operationId: input.operationId,
+            caseId: identity.caseId,
+            stage: stageForRole(input.assignment.role),
+            role: portableRole,
+            model: binding.model,
+            reasoningEffort: binding.reasoningEffort,
+            input: JSON.stringify({
+                instructions: input.instructions,
+                input: input.input,
+                schemaName: input.schemaName,
+                reviewInputVersion: input.reviewInputVersion
+            }),
+            maximumOutputTokens: input.maximumOutputTokens
+        })
+            .pipe(Effect.mapError((cause) => failure("invoke-language-model", cause.detail, cause)));
+        const decoded = yield* Effect.try({
+            try: () => {
+                const parsed = JSON.parse(response.text);
+                return Schema.decodeUnknownSync(input.outputSchema, {
+                    onExcessProperty: "error"
+                })(parsed);
+            },
+            catch: (cause) => failure("invoke-language-model", "model response did not satisfy the requested structured schema", cause)
+        });
+        return {
+            value: decoded,
+            call: {
+                operationId: input.operationId,
+                role: input.assignment.role,
+                model: binding.model,
+                reasoningEffort: binding.reasoningEffort,
+                callId: response.callId
+            }
+        };
+    });
+    const service = {
+        generateAssignedStructured: complete,
+        generateStructured: (input) => {
+            const assignment = repositoryFoundryModelAssignmentV1(input.plan, input.role);
+            return complete({ ...input, assignment });
+        }
+    };
+    return Layer.succeed(RepositoryFoundryLanguageModel, service);
+};
+export const makePortableCheckpointStoreV2 = Effect.fn("CasePipelineV2.makeCheckpointStore")(function* (input) {
+    const identityDigest = pipelineScientificIdentityDigestV2(input.identity);
+    const caseDirectory = join(input.runtimeRoot, ".routekit", "evals", "cloud", identityDigest.slice(0, 24));
+    const local = makeCaseCheckpointStoreV1({ caseDirectory });
+    const loaded = [
+        ...(yield* input.ports.checkpoints
+            .list(identityDigest)
+            .pipe(Effect.mapError((cause) => failure("checkpoint-store", cause.detail, cause))))
+    ].sort((left, right) => left.sequence - right.sequence);
+    yield* Effect.try({
+        try: () => {
+            assertPipelineCheckpointChainV2(input.identity, loaded);
+            const terminal = loaded.filter(({ kind }) => kind === "terminal");
+            if (terminal.length > 1 ||
+                (terminal.length === 1 &&
+                    (loaded.at(-1) !== terminal[0] || terminal[0]?.stage !== "admit"))) {
+                throw new Error("the accepted terminal checkpoint must be the unique admit chain head");
+            }
+        },
+        catch: (cause) => failure("checkpoint-store", "checkpoint chain is invalid", cause)
+    });
+    for (const descriptor of loaded) {
+        const bytes = yield* input.ports.checkpoints
+            .read(descriptor)
+            .pipe(Effect.mapError((cause) => failure("checkpoint-store", cause.detail, cause)));
+        const payload = yield* Effect.try({
+            try: () => decodePayload(descriptor, bytes),
+            catch: (cause) => failure("checkpoint-store", "checkpoint payload is invalid", cause)
+        });
+        if (payload.action === "write") {
+            yield* local.writeStage(payload.stage, runtimeValue(payload.value, input.runtimeRoot, caseDirectory));
+        }
+        else {
+            yield* local.deleteFrom(payload.stage);
+        }
+    }
+    const descriptors = [...loaded];
+    const loopIterations = new Map();
+    let highestStageIndex = loaded.reduce((highest, descriptor) => Math.max(highest, PIPELINE_STAGES_V2.indexOf(descriptor.stage)), -1);
+    const append = Effect.fn("CasePipelineV2.appendCheckpoint")(function* (appendInput) {
+        const { payload } = appendInput;
+        if (descriptors.at(-1)?.kind === "terminal") {
+            return yield* failure("checkpoint-store", "the accepted terminal checkpoint is already the immutable chain head");
+        }
+        const bytes = encodePayload(payload);
+        const payloadDigest = createHash("sha256").update(bytes).digest("hex");
+        const sequence = (descriptors.at(-1)?.sequence ?? 0) + 1;
+        const actualStageIndex = stageIndex(payload.stage);
+        const movesBack = actualStageIndex < highestStageIndex;
+        const repeatsStage = descriptors.length > 0 && actualStageIndex <= highestStageIndex;
+        highestStageIndex = Math.max(highestStageIndex, actualStageIndex);
+        const descriptorStage = PIPELINE_STAGES_V2[highestStageIndex] ?? "seed";
+        const loopName = payload.action === "delete-from"
+            ? `invalidate-${payload.stage}`
+            : `checkpoint-${payload.stage}`;
+        const loopIteration = loopIterations.get(loopName) ?? 0;
+        if (movesBack || repeatsStage || payload.action === "delete-from") {
+            loopIterations.set(loopName, loopIteration + 1);
+        }
+        const createdAt = (yield* input.ports.clock.now.pipe(Effect.mapError((cause) => failure("checkpoint-store", cause.detail, cause)))).toISOString();
+        const descriptor = {
+            version: 2,
+            checkpointId: `checkpoint-${String(sequence)}-${payloadDigest.slice(0, 16)}`,
+            identityDigest,
+            attemptGeneration: input.attemptGeneration,
+            sequence,
+            kind: appendInput.terminal
+                ? "terminal"
+                : movesBack || repeatsStage || payload.action === "delete-from"
+                    ? "loop"
+                    : "stage",
+            stage: descriptorStage,
+            ...(!appendInput.terminal && (movesBack || repeatsStage || payload.action === "delete-from")
+                ? { loopName, loopIteration }
+                : {}),
+            parentDigest: descriptors.length === 0
+                ? identityDigest
+                : pipelineCheckpointDescriptorDigestV2(descriptors.at(-1)),
+            payloadDigest,
+            payloadBytes: bytes.byteLength,
+            createdAt
+        };
+        const accepted = yield* input.ports.checkpoints
+            .put(descriptor, bytes)
+            .pipe(Effect.mapError((cause) => failure("checkpoint-store", cause.detail, cause)));
+        yield* Effect.try({
+            try: () => {
+                assertPipelineCheckpointReplayV2(descriptor, accepted);
+                assertPipelineCheckpointChainV2(input.identity, [...descriptors, accepted]);
+            },
+            catch: (cause) => failure("checkpoint-store", "checkpoint authority acknowledged a conflicting descriptor", cause)
+        });
+        descriptors.push(accepted);
+        return accepted;
+    });
+    const store = {
+        caseDirectory: local.caseDirectory,
+        stagePath: local.stagePath,
+        readStage: local.readStage,
+        writeStage: (stage, value) => append({
+            payload: {
+                version: 2,
+                action: "write",
+                stage,
+                value: portableValue(value, input.runtimeRoot, caseDirectory)
+            }
+        }).pipe(Effect.andThen(local.writeStage(stage, value))),
+        deleteFrom: (stage) => append({ payload: { version: 2, action: "delete-from", stage } }).pipe(Effect.andThen(local.deleteFrom(stage))),
+        readState: local.readState,
+        writeState: local.writeState,
+        appendLedger: local.appendLedger,
+        readLedger: local.readLedger,
+        writeCall: local.writeCall,
+        readWorkCheckpoint: local.readWorkCheckpoint,
+        writeWorkCheckpoint: local.writeWorkCheckpoint,
+        deleteWorkCheckpoint: local.deleteWorkCheckpoint
+    };
+    return {
+        store,
+        descriptors: () => [...descriptors],
+        completeAdmit: (admit) => {
+            const payload = {
+                version: 2,
+                action: "write",
+                stage: "admit",
+                value: portableValue(admit, input.runtimeRoot, caseDirectory)
+            };
+            const terminal = descriptors.find(({ kind }) => kind === "terminal");
+            if (terminal !== undefined) {
+                return Effect.try({
+                    try: () => {
+                        const bytes = encodePayload(payload);
+                        const payloadDigest = createHash("sha256").update(bytes).digest("hex");
+                        if (terminal.payloadDigest !== payloadDigest ||
+                            terminal.payloadBytes !== bytes.byteLength) {
+                            throw new Error("terminal checkpoint replay conflicts with the durable admit result");
+                        }
+                        return terminal;
+                    },
+                    catch: (cause) => failure("checkpoint-store", "terminal checkpoint replay conflicts with the durable admit result", cause)
+                });
+            }
+            return append({
+                payload,
+                terminal: true
+            });
+        }
+    };
+});
+const assertRepositoryBinding = (identity, map) => {
+    if (map.repository.commit !== identity.repository.commitSha ||
+        map.repository.tree !== identity.repository.treeSha ||
+        repositoryBehaviorMapDigestV2(map) !== identity.policy.repositoryModelDigest) {
+        throw new Error("repository behavior map does not match the portable foundry identity");
+    }
+};
+export const runCasePipelineV2 = Effect.fn("CasePipelineV2.run")(function* (input) {
+    const identity = yield* Effect.try({
+        try: () => {
+            const decoded = decodePipelineScientificIdentityV2(input.identity);
+            assertRepositoryBinding(decoded, input.map);
+            if (!Number.isInteger(input.attemptGeneration) || input.attemptGeneration < 1) {
+                throw new Error("attempt generation must be a positive integer");
+            }
+            if (input.runtimeRoot.trim().length === 0) {
+                throw new Error("runtime root must be non-empty");
+            }
+            return decoded;
+        },
+        catch: (cause) => failure("execute-generation", "portable foundry input is invalid", cause)
+    });
+    yield* input.ports.repository
+        .materialize(identity, input.runtimeRoot)
+        .pipe(Effect.mapError((cause) => failure("resolve-repository", cause.detail, cause)));
+    yield* input.ports.repository
+        .verify(identity, input.runtimeRoot)
+        .pipe(Effect.mapError((cause) => failure("resolve-repository", cause.detail, cause)));
+    const portableStore = yield* makePortableCheckpointStoreV2({
+        identity,
+        runtimeRoot: input.runtimeRoot,
+        attemptGeneration: input.attemptGeneration,
+        ports: input.ports
+    });
+    const plan = yield* Effect.try({
+        try: () => modelPlanV1(identity),
+        catch: (cause) => failure("execute-generation", "model plan cannot execute the V1 foundry", cause)
+    });
+    const primary = plan.assignments[0];
+    const runtimeMap = {
+        ...input.map,
+        repository: {
+            ...input.map.repository,
+            root: input.runtimeRoot,
+            requestedRef: identity.repository.commitSha
+        },
+        commands: input.map.commands.map((command) => ({
+            ...command,
+            cwd: replacePath(command.cwd, input.map.repository.root, input.runtimeRoot)
+        }))
+    };
+    const result = yield* runCasePipelineV1({
+        context: {
+            repositoryRoot: input.runtimeRoot,
+            caseId: identity.caseId,
+            caseDirectory: portableStore.store.caseDirectory,
+            dimension: identity.dimension,
+            primaryModel: primary.model,
+            reasoningEffort: primary.reasoningEffort,
+            modelPlan: plan,
+            budget: {
+                maxModelCalls: identity.budget.maximumModelCalls,
+                maxWallMs: identity.budget.maximumWallTimeMs
+            },
+            referenceCommit: identity.source.referenceCommitSha,
+            requestedRef: identity.repository.commitSha,
+            oracleRepetitions: identity.policy.oracleRepetitions,
+            oracleConcurrency: identity.policy.oracleConcurrency,
+            foldLimit: identity.policy.foldLimit
+        },
+        map: runtimeMap,
+        store: portableStore.store
+    }).pipe(Effect.provide(Layer.mergeAll(makeLanguageModelLayerV2(identity, input.ports), Layer.succeed(RepositoryCommandExecutionPort, makeRepositoryCommandExecutionPortV2(input.ports)), Layer.succeed(RepositoryCommandObservability, {
+        observe: (event) => input.ports.progress.observeCommand?.(event)
+    }))));
+    if (result.admit !== undefined &&
+        result.state.stage === "done" &&
+        (result.state.status === "admitted" || result.state.status === "rejected")) {
+        yield* portableStore.completeAdmit(result.admit);
+    }
+    return {
+        identityDigest: pipelineScientificIdentityDigestV2(identity),
+        runtimeRoot: input.runtimeRoot,
+        attemptGeneration: input.attemptGeneration,
+        checkpoints: portableStore.descriptors(),
+        result
+    };
+});

package/dist/services/command-observability/service.d.ts

@@ -0,0 +1,13 @@
+import { Context } from "effect";
+import type { RepositoryCommandObservationV1 } from "../../repository-execution-protocol.js";
+export type RepositoryCommandObservabilityShape = {
+    /**
+     * Nonblocking operational telemetry. Implementations must enqueue and return;
+     * command execution and terminalization never wait for log delivery.
+     */
+    readonly observe: (event: RepositoryCommandObservationV1) => void;
+};
+declare const RepositoryCommandObservability_base: Context.ServiceClass<RepositoryCommandObservability, "@velum-labs/routekit-eval-setup/RepositoryCommandObservability", RepositoryCommandObservabilityShape>;
+export declare class RepositoryCommandObservability extends RepositoryCommandObservability_base {
+}
+export {};

package/dist/services/command-observability/service.js

@@ -0,0 +1,3 @@
+import { Context } from "effect";
+export class RepositoryCommandObservability extends Context.Service()("@velum-labs/routekit-eval-setup/RepositoryCommandObservability") {
+}

package/dist/services/dimension-labeling/service.d.ts

@@ -0,0 +1,77 @@
+import { type RoutingBasisV3 } from "@velum-labs/routekit-eval-contracts";
+import { Context, Effect, Layer } from "effect";
+import { RepositoryFoundryError } from "../../errors.js";
+import type { RepositoryBenchmarkCaseV1 } from "../../repository-benchmark-protocol.js";
+import { type RepositoryReviewedDimensionLabelV1 } from "../../repository-routing-benchmark-protocol.js";
+import { type RepositoryRoutingModelCallV1, type RepositoryRoutingModelPlanV1 } from "../../repository-routing-model-protocol.js";
+import { RepositoryFoundryLanguageModel } from "../language-model/service.js";
+export type RepositoryDimensionLabelingResultV1 = {
+    readonly version: 1;
+    readonly reviewed: RepositoryReviewedDimensionLabelV1;
+    readonly modelCalls: readonly RepositoryRoutingModelCallV1[];
+};
+export type DimensionLabelingShape = {
+    readonly authorReviewedLabel: (input: {
+        readonly operationId: string;
+        readonly basis: RoutingBasisV3;
+        readonly benchmarkCase: RepositoryBenchmarkCaseV1;
+        readonly modelPlan: RepositoryRoutingModelPlanV1;
+    }) => Effect.Effect<RepositoryDimensionLabelingResultV1, RepositoryFoundryError>;
+};
+declare const DimensionLabeling_base: Context.ServiceClass<DimensionLabeling, "@velum-labs/routekit-eval-setup/DimensionLabeling", DimensionLabelingShape>;
+export declare class DimensionLabeling extends DimensionLabeling_base {
+}
+export declare const authorRepositoryReviewedDimensionLabelV1: (input: {
+    readonly operationId: string;
+    readonly basis: RoutingBasisV3;
+    readonly benchmarkCase: RepositoryBenchmarkCaseV1;
+    readonly modelPlan: RepositoryRoutingModelPlanV1;
+}) => Effect.Effect<{
+    version: 1;
+    reviewed: {
+        readonly version: 1;
+        readonly caseId: string;
+        readonly label: {
+            readonly caseId: string;
+            readonly basisDigest: string;
+            readonly scores: readonly {
+                readonly dimensionId: string;
+                readonly score: number;
+            }[];
+            readonly unknownProbability: number;
+        };
+        readonly basisDigest: string;
+        readonly authorModel: string;
+        readonly reviews: readonly {
+            readonly outcome: "approve" | "reject";
+            readonly detail: string;
+            readonly model: string;
+            readonly evidenceIds: readonly string[];
+            readonly reviewerId: string;
+            readonly primaryDimensionId: string;
+            readonly independentLabel: {
+                readonly caseId: string;
+                readonly basisDigest: string;
+                readonly scores: readonly {
+                    readonly dimensionId: string;
+                    readonly score: number;
+                }[];
+                readonly unknownProbability: number;
+            };
+            readonly callId?: string | undefined;
+        }[];
+        readonly authorEvidenceIds: readonly string[];
+        readonly authorDetail: string;
+        readonly authorCallId?: string | undefined;
+    };
+    modelCalls: {
+        readonly operationId: string;
+        readonly role: "dimension-labeler" | "dimension-critic-terra" | "dimension-critic-luna";
+        readonly model: string;
+        readonly reasoningEffort: import("../../repository-language-model-protocol.js").RepositoryFoundryReasoningEffortV1;
+        readonly callId?: string;
+    }[];
+}, RepositoryFoundryError, RepositoryFoundryLanguageModel>;
+export declare const makeDimensionLabeling: Effect.Effect<DimensionLabelingShape, never, RepositoryFoundryLanguageModel>;
+export declare const DimensionLabelingLive: Layer.Layer<DimensionLabeling, never, RepositoryFoundryLanguageModel>;
+export {};