@workbench-ai/workbench-protocol 0.0.43 → 0.0.45

package/dist/adapter-protocol.js

@@ -1,145 +1,237 @@
 import { promises as fs } from "node:fs";
 import path from "node:path";
-export async function readWorkbenchAdapterCommandRequest(configuredPath) {
+import { normalizeWorkbenchEngineResolveResult, } from "./engine-resolve-result.js";
+import { normalizeWorkbenchAdapterOperation, } from "./adapter-manifest.js";
+export const WORKBENCH_ADAPTER_PROTOCOL = "workbench.adapter.v3";
+export const WORKBENCH_ADAPTER_RESULT_PROTOCOL = "workbench.adapter-result.v1";
+export const WORKBENCH_ADAPTER_RESULT_FILE = "workbench-result.json";
+export async function readWorkbenchAdapterOperationRequest(configuredPath) {
     const requestPath = configuredPath ?? process.env.WORKBENCH_ADAPTER_REQUEST;
     if (!requestPath) {
         throw new Error("WORKBENCH_ADAPTER_REQUEST is required.");
     }
     const parsed = JSON.parse(await fs.readFile(requestPath, "utf8"));
-    return normalizeWorkbenchAdapterCommandRequest(parsed);
+    return normalizeWorkbenchAdapterOperationRequest(parsed);
 }
-export function normalizeWorkbenchAdapterCommandRequest(value) {
+export function normalizeWorkbenchAdapterOperationRequest(value) {
     const record = requiredJsonRecord(value, "adapter request");
-    if (record.protocol !== "workbench.adapter.v1") {
-        throw new Error("Adapter request protocol must be workbench.adapter.v1.");
+    if (record.protocol !== WORKBENCH_ADAPTER_PROTOCOL) {
+        throw new Error(`Adapter request protocol must be ${WORKBENCH_ADAPTER_PROTOCOL}.`);
     }
-    const execution = requiredJsonRecord(record.execution, "adapter request execution");
-    const adapter = requiredJsonRecord(record.adapter, "adapter request adapter");
+    const invocation = requiredJsonRecord(record.invocation, "adapter request invocation");
     const paths = requiredJsonRecord(record.paths, "adapter request paths");
-    const purpose = requiredPurpose(execution.purpose, "adapter request execution.purpose");
-    const role = normalizeExecutionRole(execution.role, purpose);
-    const use = requiredString(adapter.use, "adapter request adapter.use");
+    rejectUnknownJsonKeys(paths, "adapter request paths", [
+        "workspace",
+        "cwd",
+        "output",
+        "result",
+        "subject",
+        "case",
+        "traces",
+        "enginePrivate",
+        "logs",
+    ]);
+    const operation = requiredOperation(record.operation, "adapter request operation");
+    const use = requiredString(invocation.use, "adapter request invocation.use");
     return {
-        protocol: "workbench.adapter.v1",
-        execution: {
-            id: requiredString(execution.id, "adapter request execution.id"),
-            ...(typeof execution.jobId === "string" ? { jobId: execution.jobId } : {}),
-            purpose,
-            role,
-            ...(typeof execution.candidateId === "string" ? { candidateId: execution.candidateId } : {}),
-            ...(typeof execution.trialIndex === "number" ? { trialIndex: execution.trialIndex } : {}),
-            ...(typeof execution.sampleIndex === "number" ? { sampleIndex: execution.sampleIndex } : {}),
-            ...(typeof execution.caseId === "string" ? { caseId: execution.caseId } : {}),
-        },
-        adapter: {
+        protocol: WORKBENCH_ADAPTER_PROTOCOL,
+        id: requiredString(record.id, "adapter request id"),
+        ...(typeof record.jobId === "string" ? { jobId: record.jobId } : {}),
+        operation,
+        invocation: {
             use,
-            with: adapter.with !== undefined ? adapter.with : {},
-            ...(adapter.auth !== undefined ? { auth: adapter.auth } : {}),
+            with: invocation.with !== undefined ? invocation.with : {},
+            ...(invocation.auth !== undefined ? { auth: invocation.auth } : {}),
         },
         ...(record.auth !== undefined ? { auth: record.auth } : {}),
-        ...(record.benchmark !== undefined ? { benchmark: normalizeAdapterCommandBenchmark(record.benchmark) } : {}),
-        ...(record.candidate !== undefined ? { candidate: normalizeAdapterCommandCandidate(record.candidate) } : {}),
-        ...(record.optimizer !== undefined ? { optimizer: normalizeAdapterCommandOptimizer(record.optimizer) } : {}),
-        ...(record.task !== undefined ? { task: normalizeAdapterCommandTask(record.task) } : {}),
-        ...(Array.isArray(record.expectedOutputs)
-            ? { expectedOutputs: normalizeAdapterCommandExpectedOutputs(record.expectedOutputs) }
-            : {}),
+        ...(record.context !== undefined ? { context: normalizeAdapterRequestContext(record.context) } : {}),
         paths: {
             workspace: requiredString(paths.workspace, "adapter request paths.workspace"),
             output: requiredString(paths.output, "adapter request paths.output"),
-            ...(typeof paths.input === "string" ? { input: paths.input } : {}),
-            ...(typeof paths.candidate === "string" ? { candidate: paths.candidate } : {}),
-            ...(typeof paths.task === "string" ? { task: paths.task } : {}),
-            ...(typeof paths.runnerOutput === "string" ? { runnerOutput: paths.runnerOutput } : {}),
+            result: requiredString(paths.result, "adapter request paths.result"),
+            ...(typeof paths.case === "string" ? { case: paths.case } : {}),
             ...(typeof paths.traces === "string" ? { traces: paths.traces } : {}),
             ...(typeof paths.cwd === "string" ? { cwd: paths.cwd } : {}),
             ...(typeof paths.subject === "string" ? { subject: paths.subject } : {}),
-            ...(typeof paths.tests === "string" ? { tests: paths.tests } : {}),
+            ...(typeof paths.enginePrivate === "string" ? { enginePrivate: paths.enginePrivate } : {}),
             ...(typeof paths.logs === "string" ? { logs: paths.logs } : {}),
-            ...(typeof paths.artifacts === "string" ? { artifacts: paths.artifacts } : {}),
-            ...(typeof paths.scorecard === "string" ? { scorecard: paths.scorecard } : {}),
         },
     };
 }
 export async function ensureWorkbenchAdapterOutputDir(request) {
     await fs.mkdir(request.paths.output, { recursive: true });
 }
-export function workbenchAdapterResultPath(outputRoot) {
-    return path.join(outputRoot, ".workbench", "result.json");
+export function workbenchAdapterOperationResultPath(outputRoot) {
+    return path.join(outputRoot, WORKBENCH_ADAPTER_RESULT_FILE);
 }
-export async function writeWorkbenchAdapterResultMetadata(outputRoot, result) {
-    const resultPath = workbenchAdapterResultPath(outputRoot);
+export async function writeWorkbenchAdapterOperationResult(outputRoot, result) {
+    const normalized = normalizeWorkbenchAdapterOperationResult(result);
+    const resultPath = workbenchAdapterOperationResultPath(outputRoot);
     await fs.mkdir(path.dirname(resultPath), { recursive: true });
-    await fs.writeFile(resultPath, `${JSON.stringify(result, null, 2)}\n`);
-}
-export async function readWorkbenchAdapterResultMetadata(outputRoot) {
-    const source = await fs.readFile(workbenchAdapterResultPath(outputRoot), "utf8").catch((error) => {
-        if (error.code === "ENOENT") {
-            return null;
-        }
-        throw error;
-    });
-    if (source === null) {
-        return {};
+    await fs.writeFile(resultPath, `${JSON.stringify(normalized, null, 2)}\n`);
+}
+export async function readWorkbenchAdapterOperationResult(outputRoot, operation) {
+    const parsed = JSON.parse(await fs.readFile(workbenchAdapterOperationResultPath(outputRoot), "utf8"));
+    return normalizeWorkbenchAdapterOperationResult(parsed, operation);
+}
+export function normalizeWorkbenchAdapterOperationResult(value, operation) {
+    const record = requiredJsonRecord(value, WORKBENCH_ADAPTER_RESULT_FILE);
+    if (record.protocol !== WORKBENCH_ADAPTER_RESULT_PROTOCOL) {
+        throw new Error(`${WORKBENCH_ADAPTER_RESULT_FILE}.protocol must be ${WORKBENCH_ADAPTER_RESULT_PROTOCOL}.`);
+    }
+    const resultOperation = requiredOperation(record.operation, `${WORKBENCH_ADAPTER_RESULT_FILE}.operation`);
+    const expectedOperation = operation
+        ? normalizeWorkbenchAdapterOperation(operation, "expected adapter result operation")
+        : undefined;
+    if (expectedOperation && resultOperation !== expectedOperation) {
+        throw new Error(`${WORKBENCH_ADAPTER_RESULT_FILE}.operation must be ${expectedOperation}.`);
     }
-    const parsed = JSON.parse(source);
-    const record = jsonRecord(parsed);
     return {
+        protocol: WORKBENCH_ADAPTER_RESULT_PROTOCOL,
+        operation: resultOperation,
         ...(record.ok === true || record.ok === false ? { ok: record.ok } : {}),
+        ...(record.value !== undefined
+            ? { value: normalizeOperationResultValue(resultOperation, record.value) }
+            : {}),
         ...(typeof record.summary === "string" ? { summary: record.summary } : {}),
         ...(record.feedback !== undefined ? { feedback: record.feedback } : {}),
         ...(record.usage !== undefined ? { usage: normalizeUsageSummary(record.usage) } : {}),
     };
 }
-function normalizeAdapterCommandExpectedOutputs(value) {
-    return value.flatMap((entry) => {
-        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
-            return [];
-        }
-        return [{
-                ...(typeof entry.name === "string" ? { name: entry.name } : {}),
-                ...(typeof entry.path === "string" ? { path: entry.path } : {}),
-            }];
-    });
-}
-function normalizeAdapterCommandBenchmark(value) {
-    const record = requiredJsonRecord(value, "adapter request benchmark");
+export function assertWorkbenchAdapterOperationResultOk(result, label = "Adapter operation") {
+    if (result.ok !== false) {
+        return;
+    }
+    throw new Error(`${label} returned ok false${result.summary ? `: ${result.summary}` : "."}`);
+}
+function normalizeOperationResultValue(operation, value) {
+    if (operation === "engine.resolve") {
+        return normalizeWorkbenchEngineResolveResult(value);
+    }
+    if (operation === "engine.run") {
+        return normalizeResult(value, `${WORKBENCH_ADAPTER_RESULT_FILE}.value`);
+    }
+    if (operation === "optimizer.improve") {
+        return normalizeSubjectPatch(value, `${WORKBENCH_ADAPTER_RESULT_FILE}.value`);
+    }
+    if (value === undefined || value === null) {
+        return null;
+    }
+    return value;
+}
+function normalizeAdapterRequestContext(value) {
+    const record = requiredJsonRecord(value, "adapter request context");
+    return {
+        ...(record.benchmark !== undefined ? { benchmark: normalizeBenchmarkContext(record.benchmark) } : {}),
+        ...(record.subject !== undefined ? { subject: normalizeSubjectContext(record.subject) } : {}),
+        ...(record.optimizer !== undefined ? { optimizer: normalizeOptimizerContext(record.optimizer) } : {}),
+        ...(record.attempt !== undefined ? { attempt: normalizeAttemptContext(record.attempt) } : {}),
+        ...(record.case !== undefined ? { case: normalizeCaseContext(record.case) } : {}),
+    };
+}
+function normalizeBenchmarkContext(value) {
+    const record = requiredJsonRecord(value, "adapter request context.benchmark");
     return {
         ...(typeof record.name === "string" ? { name: record.name } : {}),
         ...(typeof record.description === "string" ? { description: record.description } : {}),
     };
 }
-function normalizeAdapterCommandCandidate(value) {
-    const record = requiredJsonRecord(value, "adapter request candidate");
+function normalizeSubjectContext(value) {
+    const record = requiredJsonRecord(value, "adapter request context.subject");
     return {
+        ...(typeof record.id === "string" ? { id: record.id } : {}),
         ...(typeof record.path === "string" ? { path: record.path } : {}),
+        ...(record.run !== undefined ? { run: normalizeContextInvocation(record.run, "adapter request context.subject.run") } : {}),
+    };
+}
+function normalizeContextInvocation(value, label) {
+    const record = requiredJsonRecord(value, label);
+    const use = requiredString(record.use, `${label}.use`);
+    return {
+        use,
+        with: record.with !== undefined ? record.with : {},
+        ...(record.auth !== undefined ? { auth: record.auth } : {}),
+        ...(typeof record.command === "string" && record.command.trim() ? { command: record.command } : {}),
     };
 }
-function normalizeAdapterCommandOptimizer(value) {
-    const record = requiredJsonRecord(value, "adapter request optimizer");
+function normalizeOptimizerContext(value) {
+    const record = requiredJsonRecord(value, "adapter request context.optimizer");
     return {
         edits: Array.isArray(record.edits)
             ? record.edits.filter((entry) => typeof entry === "string")
             : [],
     };
 }
-function normalizeAdapterCommandTask(value) {
-    const record = requiredJsonRecord(value, "adapter request task");
+function normalizeAttemptContext(value) {
+    const record = requiredJsonRecord(value, "adapter request context.attempt");
+    return {
+        ...(typeof record.attemptIndex === "number" ? { attemptIndex: record.attemptIndex } : {}),
+        ...(typeof record.sampleIndex === "number" ? { sampleIndex: record.sampleIndex } : {}),
+        ...(typeof record.caseId === "string" ? { caseId: record.caseId } : {}),
+    };
+}
+function normalizeCaseContext(value) {
+    const record = requiredJsonRecord(value, "adapter request context.case");
     return {
-        ...(typeof record.text === "string" ? { text: record.text } : {}),
+        ...(typeof record.id === "string" ? { id: record.id } : {}),
+        ...(typeof record.prompt === "string" ? { prompt: record.prompt } : {}),
     };
 }
+function normalizeResult(value, label) {
+    const record = requiredJsonRecord(value, label);
+    if (typeof record.score !== "number" || !Number.isFinite(record.score)) {
+        throw new Error(`${label}.score must be a finite number.`);
+    }
+    return {
+        score: record.score,
+        ...(isNumberRecord(record.metrics) ? { metrics: record.metrics } : {}),
+        ...(Array.isArray(record.cases) ? { cases: record.cases } : {}),
+        ...(record.usage !== undefined ? { usage: normalizeUsageSummary(record.usage) } : {}),
+        ...(typeof record.summary === "string" ? { summary: record.summary } : {}),
+        ...(record.feedback !== undefined ? { feedback: record.feedback } : {}),
+    };
+}
+function normalizeSubjectPatch(value, label) {
+    const record = requiredJsonRecord(value, label);
+    if (!Array.isArray(record.files)) {
+        throw new Error(`${label}.files must be an array.`);
+    }
+    if (!Array.isArray(record.fileChanges) || !record.fileChanges.every((entry) => typeof entry === "string")) {
+        throw new Error(`${label}.fileChanges must be a string array.`);
+    }
+    return {
+        files: record.files,
+        fileChanges: [...record.fileChanges],
+        ...(typeof record.summary === "string" ? { summary: record.summary } : {}),
+        ...(record.feedback !== undefined ? { feedback: record.feedback } : {}),
+    };
+}
+function normalizeUsageSummary(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function isNumberRecord(value) {
+    return !!value &&
+        typeof value === "object" &&
+        !Array.isArray(value) &&
+        Object.values(value).every((entry) => typeof entry === "number" && Number.isFinite(entry));
+}
 function requiredJsonRecord(value, label) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         throw new Error(`${label} must be an object.`);
     }
     return value;
 }
-function requiredPurpose(value, label) {
-    if (value === "improve" || value === "trial" || value === "run-task" || value === "grade-task") {
-        return value;
+function rejectUnknownJsonKeys(record, label, allowed) {
+    const allowedSet = new Set(allowed);
+    const unknown = Object.keys(record).filter((key) => !allowedSet.has(key));
+    if (unknown.length > 0) {
+        throw new Error(`${label} includes unsupported fields: ${unknown.join(", ")}.`);
     }
-    throw new Error(`${label} must be improve, trial, run-task, or grade-task.`);
+}
+function requiredOperation(value, label) {
+    return normalizeWorkbenchAdapterOperation(value, label);
 }
 function requiredString(value, label) {
     if (typeof value !== "string" || value.length === 0) {
@@ -147,55 +239,3 @@ function requiredString(value, label) {
     }
     return value;
 }
-function executionPurposeRole(purpose) {
-    if (purpose === "improve") {
-        return "optimizer";
-    }
-    if (purpose === "run-task") {
-        return "runner";
-    }
-    if (purpose === "trial") {
-        return "runner";
-    }
-    return "grader";
-}
-function normalizeExecutionRole(value, purpose) {
-    if (value === "optimizer" || value === "runner" || value === "grader") {
-        return value;
-    }
-    return executionPurposeRole(purpose);
-}
-function jsonRecord(value) {
-    return value && typeof value === "object" && !Array.isArray(value)
-        ? value
-        : {};
-}
-function normalizeUsageSummary(value) {
-    const record = jsonRecord(value);
-    return {
-        ...(record.total !== undefined ? { total: normalizeExecutionUsage(record.total) } : {}),
-        ...(record.optimizer !== undefined ? { optimizer: normalizeExecutionUsage(record.optimizer) } : {}),
-        ...(record.runner !== undefined ? { runner: normalizeExecutionUsage(record.runner) } : {}),
-        ...(record.grader !== undefined ? { grader: normalizeExecutionUsage(record.grader) } : {}),
-    };
-}
-function normalizeExecutionUsage(value) {
-    const record = jsonRecord(value);
-    return {
-        ...(typeof record.provider === "string" ? { provider: record.provider } : {}),
-        ...(typeof record.model === "string" ? { model: record.model } : {}),
-        ...(typeof record.inputTokens === "number" ? { inputTokens: record.inputTokens } : {}),
-        ...(typeof record.uncachedInputTokens === "number" ? { uncachedInputTokens: record.uncachedInputTokens } : {}),
-        ...(typeof record.cachedInputTokens === "number" ? { cachedInputTokens: record.cachedInputTokens } : {}),
-        ...(typeof record.cacheCreationInputTokens === "number" ? { cacheCreationInputTokens: record.cacheCreationInputTokens } : {}),
-        ...(typeof record.cacheReadInputTokens === "number" ? { cacheReadInputTokens: record.cacheReadInputTokens } : {}),
-        ...(typeof record.outputTokens === "number" ? { outputTokens: record.outputTokens } : {}),
-        ...(typeof record.reasoningOutputTokens === "number" ? { reasoningOutputTokens: record.reasoningOutputTokens } : {}),
-        ...(typeof record.totalTokens === "number" ? { totalTokens: record.totalTokens } : {}),
-        ...(typeof record.costUsd === "number" ? { costUsd: record.costUsd } : {}),
-        ...(record.costSource === "provider" || record.costSource === "estimated" || record.costSource === "mixed"
-            ? { costSource: record.costSource }
-            : {}),
-        ...(typeof record.pricingSource === "string" ? { pricingSource: record.pricingSource } : {}),
-    };
-}

package/dist/engine-resolve-result.d.ts

@@ -0,0 +1,31 @@
+import type { SurfaceSnapshotFile, WorkbenchExecutionNetworkPolicy, WorkbenchExecutionResources } from "@workbench-ai/workbench-contract";
+export interface WorkbenchEngineCaseEnvironmentSpec {
+    dockerfile?: string;
+    workdir?: string;
+    resources?: Partial<WorkbenchExecutionResources>;
+    network?: WorkbenchExecutionNetworkPolicy;
+}
+export interface WorkbenchEngineCaseSpec {
+    version: 3;
+    prompt: string;
+    environment?: WorkbenchEngineCaseEnvironmentSpec;
+}
+export interface WorkbenchEngineCaseFiles {
+    subjectVisible?: SurfaceSnapshotFile[];
+    enginePrivate?: SurfaceSnapshotFile[];
+    source?: SurfaceSnapshotFile[];
+}
+export interface WorkbenchEngineCase {
+    id: string;
+    case: WorkbenchEngineCaseSpec;
+    files: WorkbenchEngineCaseFiles;
+}
+export interface WorkbenchEngineResolveResult {
+    cases: WorkbenchEngineCase[];
+    environment?: WorkbenchEngineCaseEnvironmentSpec;
+}
+export declare function normalizeWorkbenchEngineResolveResult(value: unknown, label?: string): WorkbenchEngineResolveResult;
+export declare function normalizeWorkbenchEngineCase(value: unknown, label: string): WorkbenchEngineCase;
+export declare function normalizeWorkbenchEngineCaseFiles(value: unknown, label: string): WorkbenchEngineCaseFiles;
+export declare function normalizeWorkbenchEngineCaseSpec(value: unknown, label: string): WorkbenchEngineCaseSpec;
+//# sourceMappingURL=engine-resolve-result.d.ts.map

package/dist/engine-resolve-result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-resolve-result.d.ts","sourceRoot":"","sources":["../src/engine-resolve-result.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,mBAAmB,EACnB,+BAA+B,EAC/B,2BAA2B,EAC5B,MAAM,kCAAkC,CAAC;AAE1C,MAAM,WAAW,kCAAkC;IACjD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,OAAO,CAAC,2BAA2B,CAAC,CAAC;IACjD,OAAO,CAAC,EAAE,+BAA+B,CAAC;CAC3C;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,CAAC,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,kCAAkC,CAAC;CAClD;AAED,MAAM,WAAW,wBAAwB;IACvC,cAAc,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACvC,aAAa,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACtC,MAAM,CAAC,EAAE,mBAAmB,EAAE,CAAC;CAChC;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,uBAAuB,CAAC;IAC9B,KAAK,EAAE,wBAAwB,CAAC;CACjC;AAED,MAAM,WAAW,4BAA4B;IAC3C,KAAK,EAAE,mBAAmB,EAAE,CAAC;IAC7B,WAAW,CAAC,EAAE,kCAAkC,CAAC;CAClD;AAED,wBAAgB,qCAAqC,CACnD,KAAK,EAAE,OAAO,EACd,KAAK,SAA0B,GAC9B,4BAA4B,CAkB9B;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,mBAAmB,CAWrB;AAED,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,wBAAwB,CAc1B;AAED,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,uBAAuB,CAezB"}

package/dist/engine-resolve-result.js

@@ -0,0 +1,162 @@
+import path from "node:path";
+export function normalizeWorkbenchEngineResolveResult(value, label = "engine.resolve result") {
+    const record = requiredRecord(value, label);
+    if (!Array.isArray(record.cases)) {
+        throw new Error(`${label}.cases must be an array.`);
+    }
+    const cases = record.cases.map((entry, index) => normalizeWorkbenchEngineCase(entry, `${label}.cases[${index}]`));
+    const duplicate = firstDuplicate(cases.map((engineCase) => engineCase.id));
+    if (duplicate) {
+        throw new Error(`${label} contains duplicate case id: ${duplicate}`);
+    }
+    return {
+        cases,
+        ...(record.environment !== undefined
+            ? { environment: normalizeCaseEnvironment(record.environment, `${label}.environment`) }
+            : {}),
+    };
+}
+export function normalizeWorkbenchEngineCase(value, label) {
+    const record = requiredRecord(value, label);
+    rejectUnknownKeys(record, label, ["id", "case", "files"]);
+    if (typeof record.id !== "string" || record.id.trim().length === 0) {
+        throw new Error(`${label}.id must be a non-empty string.`);
+    }
+    return {
+        id: normalizeRelativePath(record.id, `${label}.id`),
+        case: normalizeWorkbenchEngineCaseSpec(record.case, `${label}.case`),
+        files: normalizeWorkbenchEngineCaseFiles(record.files, `${label}.files`),
+    };
+}
+export function normalizeWorkbenchEngineCaseFiles(value, label) {
+    const record = requiredRecord(value, label);
+    rejectUnknownKeys(record, label, ["subjectVisible", "enginePrivate", "source"]);
+    return {
+        ...(record.subjectVisible !== undefined
+            ? { subjectVisible: normalizeEngineResolveFiles(record.subjectVisible, `${label}.subjectVisible`) }
+            : {}),
+        ...(record.enginePrivate !== undefined
+            ? { enginePrivate: normalizeEngineResolveFiles(record.enginePrivate, `${label}.enginePrivate`) }
+            : {}),
+        ...(record.source !== undefined
+            ? { source: normalizeEngineResolveFiles(record.source, `${label}.source`) }
+            : {}),
+    };
+}
+export function normalizeWorkbenchEngineCaseSpec(value, label) {
+    const record = requiredRecord(value, label);
+    if (record.version !== 3) {
+        throw new Error(`${label}.version must be 3.`);
+    }
+    if (typeof record.prompt !== "string" || record.prompt.trim().length === 0) {
+        throw new Error(`${label}.prompt must be a non-empty string.`);
+    }
+    return {
+        version: 3,
+        prompt: record.prompt,
+        ...(record.environment !== undefined
+            ? { environment: normalizeCaseEnvironment(record.environment, `${label}.environment`) }
+            : {}),
+    };
+}
+function normalizeCaseEnvironment(value, label) {
+    const record = requiredRecord(value, label);
+    const resources = record.resources === undefined
+        ? undefined
+        : normalizeCaseResources(record.resources, `${label}.resources`);
+    const network = record.network === undefined
+        ? undefined
+        : normalizeNetworkPolicy(record.network, `${label}.network`);
+    return {
+        ...(typeof record.dockerfile === "string" && record.dockerfile.trim()
+            ? { dockerfile: record.dockerfile }
+            : {}),
+        ...(typeof record.workdir === "string" && record.workdir.trim()
+            ? { workdir: record.workdir }
+            : {}),
+        ...(resources ? { resources } : {}),
+        ...(network ? { network } : {}),
+    };
+}
+function normalizeCaseResources(value, label) {
+    const record = requiredRecord(value, label);
+    return {
+        ...(typeof record.cpu === "number" ? { cpu: record.cpu } : {}),
+        ...(typeof record.memoryGb === "number" ? { memoryGb: record.memoryGb } : {}),
+        ...(typeof record.diskGb === "number" ? { diskGb: record.diskGb } : {}),
+        ...(typeof record.timeoutMinutes === "number" ? { timeoutMinutes: record.timeoutMinutes } : {}),
+    };
+}
+function normalizeNetworkPolicy(value, label) {
+    const record = requiredRecord(value, label);
+    if (record.egress !== "none" &&
+        record.egress !== "allowlist" &&
+        record.egress !== "open") {
+        throw new Error(`${label}.egress must be none, allowlist, or open.`);
+    }
+    return {
+        egress: record.egress,
+        ...(Array.isArray(record.allow)
+            ? { allow: record.allow.filter((entry) => typeof entry === "string") }
+            : {}),
+    };
+}
+function normalizeEngineResolveFiles(value, label) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value)) {
+        throw new Error(`${label} must be an array.`);
+    }
+    return value.map((entry, index) => {
+        const record = requiredRecord(entry, `${label}[${index}]`);
+        if (typeof record.path !== "string" || record.path.trim().length === 0) {
+            throw new Error(`${label}[${index}].path must be a non-empty string.`);
+        }
+        if (typeof record.content !== "string") {
+            throw new Error(`${label}[${index}].content must be a string.`);
+        }
+        const encoding = record.encoding === "base64" ? "base64" : "utf8";
+        const kind = record.kind === "binary" || encoding === "base64" ? "binary" : "text";
+        return {
+            path: normalizeRelativePath(record.path, `${label}[${index}].path`),
+            kind,
+            encoding,
+            content: record.content,
+            executable: record.executable === true,
+        };
+    }).sort((left, right) => left.path.localeCompare(right.path));
+}
+function normalizeRelativePath(filePath, label) {
+    const normalized = path.posix.normalize(filePath.replace(/\\/gu, "/").replace(/^\/+/u, ""));
+    if (!normalized || normalized === "." || normalized.includes("\0")) {
+        throw new Error(`${label} must be a non-empty relative path.`);
+    }
+    if (normalized === ".." || normalized.startsWith("../") || path.posix.isAbsolute(normalized)) {
+        throw new Error(`${label} must not escape the engine-resolve result.`);
+    }
+    return normalized;
+}
+function requiredRecord(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${label} must be an object.`);
+    }
+    return value;
+}
+function rejectUnknownKeys(record, label, allowed) {
+    const allowedSet = new Set(allowed);
+    const unknown = Object.keys(record).filter((key) => !allowedSet.has(key));
+    if (unknown.length > 0) {
+        throw new Error(`${label} includes unsupported fields: ${unknown.join(", ")}.`);
+    }
+}
+function firstDuplicate(values) {
+    const seen = new Set();
+    for (const value of values) {
+        if (seen.has(value)) {
+            return value;
+        }
+        seen.add(value);
+    }
+    return null;
+}

package/dist/index.d.ts

@@ -1,3 +1,5 @@
-export { adapterCommandName, cloneWorkbenchAdapterManifest, collectWorkbenchAdapterAuthRequirements, collectWorkbenchAdapterInvocations, parseWorkbenchAdapterManifest, workbenchAdapterManifestRequiresAuth, withDefaultWorkbenchAdapterAuth, withDefaultWorkbenchAdapterAuthProfiles, type WorkbenchAdapterAuthEnvManifest, type WorkbenchAdapterAuthFileManifest, type WorkbenchAdapterAuthManifest, type WorkbenchAdapterAuthMethodManifest, type WorkbenchAdapterAuthRequirement, type WorkbenchAdapterInvocationLike, type WorkbenchAdapterManifest, } from "./adapter-manifest.ts";
-export { ensureWorkbenchAdapterOutputDir, normalizeWorkbenchAdapterCommandRequest, readWorkbenchAdapterCommandRequest, readWorkbenchAdapterResultMetadata, workbenchAdapterResultPath, writeWorkbenchAdapterResultMetadata, type WorkbenchAdapterCommandRequest, type WorkbenchAdapterResultMetadata, } from "./adapter-protocol.ts";
+export { WORKBENCH_ADAPTER_MANIFEST_PROTOCOL, adapterCommandName, assertWorkbenchAdapterOperationSupport, cloneWorkbenchAdapterManifest, collectWorkbenchAdapterAuthRequirements, collectWorkbenchAdapterInvocations, collectWorkbenchAdapterOperationIssues, collectWorkbenchAdapterOperationRequirements, parseWorkbenchAdapterManifest, normalizeWorkbenchAdapterOperation, workbenchAdapterManifestSupportsOperation, workbenchAdapterOperationCommand, workbenchAdapterManifestRequiresAuth, withDefaultWorkbenchAdapterAuth, withDefaultWorkbenchAdapterAuthProfiles, type WorkbenchPrimitiveAdapterOperation, type WorkbenchAdapterOperation, type WorkbenchAdapterOperationManifest, type WorkbenchAdapterSlotManifest, type WorkbenchAdapterAuthEnvManifest, type WorkbenchAdapterAuthFileManifest, type WorkbenchAdapterAuthManifest, type WorkbenchAdapterAuthMethodManifest, type WorkbenchAdapterAuthRequirement, type WorkbenchAdapterInvocationLike, type WorkbenchAdapterManifest, type WorkbenchAdapterOperationRequirement, } from "./adapter-manifest.ts";
+export { WORKBENCH_ADAPTER_PROTOCOL, WORKBENCH_ADAPTER_RESULT_FILE, WORKBENCH_ADAPTER_RESULT_PROTOCOL, assertWorkbenchAdapterOperationResultOk, ensureWorkbenchAdapterOutputDir, normalizeWorkbenchAdapterOperationRequest, normalizeWorkbenchAdapterOperationResult, readWorkbenchAdapterOperationRequest, readWorkbenchAdapterOperationResult, workbenchAdapterOperationResultPath, writeWorkbenchAdapterOperationResult, type WorkbenchAdapterOperationRequest, type WorkbenchAdapterOperationResult, type WorkbenchAdapterOperationResultValue, } from "./adapter-protocol.ts";
+export { normalizeWorkbenchEngineCase, normalizeWorkbenchEngineCaseFiles, normalizeWorkbenchEngineCaseSpec, normalizeWorkbenchEngineResolveResult, type WorkbenchEngineCase, type WorkbenchEngineCaseFiles, type WorkbenchEngineCaseEnvironmentSpec, type WorkbenchEngineCaseSpec, type WorkbenchEngineResolveResult, } from "./engine-resolve-result.ts";
+export { adapterResult, adapterSlot, adapterSlotInvocation, defineAdapter, defineEngineResolver, defineSubject, defineEngineRunner, defineOptimizer, operationDefinitionForRequest, runSubjectFromEngine, runDefinedAdapter, workbenchAdapterManifestFromDefinition, type WorkbenchAdapterDefinition, type WorkbenchAdapterHandlerContext, type WorkbenchAdapterHandlerReturn, type WorkbenchAdapterOperationDefinition, type WorkbenchAdapterOperationHandler, type RunDefinedWorkbenchAdapterOptions, } from "./adapter-definition.ts";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,6BAA6B,EAC7B,uCAAuC,EACvC,kCAAkC,EAClC,6BAA6B,EAC7B,oCAAoC,EACpC,+BAA+B,EAC/B,uCAAuC,EACvC,KAAK,+BAA+B,EACpC,KAAK,gCAAgC,EACrC,KAAK,4BAA4B,EACjC,KAAK,kCAAkC,EACvC,KAAK,+BAA+B,EACpC,KAAK,8BAA8B,EACnC,KAAK,wBAAwB,GAC9B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,+BAA+B,EAC/B,uCAAuC,EACvC,kCAAkC,EAClC,kCAAkC,EAClC,0BAA0B,EAC1B,mCAAmC,EACnC,KAAK,8BAA8B,EACnC,KAAK,8BAA8B,GACpC,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mCAAmC,EACnC,kBAAkB,EAClB,sCAAsC,EACtC,6BAA6B,EAC7B,uCAAuC,EACvC,kCAAkC,EAClC,sCAAsC,EACtC,4CAA4C,EAC5C,6BAA6B,EAC7B,kCAAkC,EAClC,yCAAyC,EACzC,gCAAgC,EAChC,oCAAoC,EACpC,+BAA+B,EAC/B,uCAAuC,EACvC,KAAK,kCAAkC,EACvC,KAAK,yBAAyB,EAC9B,KAAK,iCAAiC,EACtC,KAAK,4BAA4B,EACjC,KAAK,+BAA+B,EACpC,KAAK,gCAAgC,EACrC,KAAK,4BAA4B,EACjC,KAAK,kCAAkC,EACvC,KAAK,+BAA+B,EACpC,KAAK,8BAA8B,EACnC,KAAK,wBAAwB,EAC7B,KAAK,oCAAoC,GAC1C,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,0BAA0B,EAC1B,6BAA6B,EAC7B,iCAAiC,EACjC,uCAAuC,EACvC,+BAA+B,EAC/B,yCAAyC,EACzC,wCAAwC,EACxC,oCAAoC,EACpC,mCAAmC,EACnC,mCAAmC,EACnC,oCAAoC,EACpC,KAAK,gCAAgC,EACrC,KAAK,+BAA+B,EACpC,KAAK,oCAAoC,GAC1C,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EACL,4BAA4B,EAC5B,iCAAiC,EACjC,gCAAgC,EAChC,qCAAqC,EACrC,KAAK,mBAAmB,EACxB,KAAK,wBAAwB,EAC7B,KAAK,kCAAkC,EACvC,KAAK,uBAAuB,EAC5B,KAAK,4BAA4B,GAClC,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,aAAa,EACb,WAAW,EACX,qBAAqB,EACrB,aAAa,EACb,oBAAoB,EACpB,aAAa,EACb,kBAAkB,EAClB,eAAe,EACf,6BAA6B,EAC7B,oBAAoB,EACpB,iBAAiB,EACjB,sCAAsC,EACtC,KAAK,0BAA0B,EAC/B,KAAK,8BAA8B,EACnC,KAAK,6BAA6B,EAClC,KAAK,mCAAmC,EACxC,KAAK,gCAAgC,EACrC,KAAK,iCAAiC,GACvC,MAAM,yBAAyB,CAAC"}

package/dist/index.js

@@ -1,2 +1,4 @@
-export { adapterCommandName, cloneWorkbenchAdapterManifest, collectWorkbenchAdapterAuthRequirements, collectWorkbenchAdapterInvocations, parseWorkbenchAdapterManifest, workbenchAdapterManifestRequiresAuth, withDefaultWorkbenchAdapterAuth, withDefaultWorkbenchAdapterAuthProfiles, } from "./adapter-manifest.js";
-export { ensureWorkbenchAdapterOutputDir, normalizeWorkbenchAdapterCommandRequest, readWorkbenchAdapterCommandRequest, readWorkbenchAdapterResultMetadata, workbenchAdapterResultPath, writeWorkbenchAdapterResultMetadata, } from "./adapter-protocol.js";
+export { WORKBENCH_ADAPTER_MANIFEST_PROTOCOL, adapterCommandName, assertWorkbenchAdapterOperationSupport, cloneWorkbenchAdapterManifest, collectWorkbenchAdapterAuthRequirements, collectWorkbenchAdapterInvocations, collectWorkbenchAdapterOperationIssues, collectWorkbenchAdapterOperationRequirements, parseWorkbenchAdapterManifest, normalizeWorkbenchAdapterOperation, workbenchAdapterManifestSupportsOperation, workbenchAdapterOperationCommand, workbenchAdapterManifestRequiresAuth, withDefaultWorkbenchAdapterAuth, withDefaultWorkbenchAdapterAuthProfiles, } from "./adapter-manifest.js";
+export { WORKBENCH_ADAPTER_PROTOCOL, WORKBENCH_ADAPTER_RESULT_FILE, WORKBENCH_ADAPTER_RESULT_PROTOCOL, assertWorkbenchAdapterOperationResultOk, ensureWorkbenchAdapterOutputDir, normalizeWorkbenchAdapterOperationRequest, normalizeWorkbenchAdapterOperationResult, readWorkbenchAdapterOperationRequest, readWorkbenchAdapterOperationResult, workbenchAdapterOperationResultPath, writeWorkbenchAdapterOperationResult, } from "./adapter-protocol.js";
+export { normalizeWorkbenchEngineCase, normalizeWorkbenchEngineCaseFiles, normalizeWorkbenchEngineCaseSpec, normalizeWorkbenchEngineResolveResult, } from "./engine-resolve-result.js";
+export { adapterResult, adapterSlot, adapterSlotInvocation, defineAdapter, defineEngineResolver, defineSubject, defineEngineRunner, defineOptimizer, operationDefinitionForRequest, runSubjectFromEngine, runDefinedAdapter, workbenchAdapterManifestFromDefinition, } from "./adapter-definition.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workbench-ai/workbench-protocol",
-  "version": "0.0.43",
+  "version": "0.0.45",
   "type": "module",
   "repository": {
     "type": "git",
@@ -20,7 +20,7 @@
   ],
   "dependencies": {
     "yaml": "^2.8.2",
-    "@workbench-ai/workbench-contract": "0.0.43"
+    "@workbench-ai/workbench-contract": "0.0.45"
   },
   "devDependencies": {
     "@types/node": "^24.3.1",