@workbench-ai/workbench-core 0.0.64 → 0.0.66

package/dist/inspection.js

@@ -0,0 +1,217 @@
+import { buildCandidateLineage, buildWorkbenchEvaluationComparison, } from "@workbench-ai/workbench-contract";
+import { buildCandidateCaseExecutionRefs, buildWorkbenchExecutionEvidence, } from "./execution-evidence.js";
+import { candidateRecordWithoutDerivedFields, createCandidateFilePreview, createCaseReview, summarizeCandidateFiles, } from "./index.js";
+export class WorkbenchInspectionError extends Error {
+    status;
+    statusCode;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = "WorkbenchInspectionError";
+        this.status = options.status ?? 400;
+        this.statusCode = this.status;
+    }
+}
+export function createWorkbenchInspection(backend) {
+    return {
+        snapshot: () => backend.snapshot(),
+        spec: (input = {}) => backend.spec(input),
+        sourceFiles: async (input = {}) => {
+            const files = await backend.sourceFiles(input);
+            return summarizeCandidateFiles(files, files.map((file) => file.path));
+        },
+        sourcePreview: async (input) => createCandidateFilePreview({
+            files: await backend.sourceFiles(input),
+            path: input.path,
+            view: input.view,
+        }),
+        candidate: async (input) => candidateRecordWithoutDerivedFields(await backend.candidate(input)),
+        candidateFiles: async (input) => {
+            const result = await backend.candidateFiles(input);
+            return summarizeCandidateFiles(result.files, result.changedPaths);
+        },
+        candidatePreview: async (input) => createCandidateFilePreview({
+            files: (await backend.candidateFiles(input)).files,
+            path: input.path,
+            view: input.view,
+        }),
+        evaluations: async () => {
+            const snapshot = await backend.snapshot();
+            return buildWorkbenchEvaluationComparison(snapshot.evaluations);
+        },
+        evaluation: (input) => backend.evaluation(input),
+        caseReview: async (input) => {
+            if (backend.caseReview) {
+                return await backend.caseReview(input);
+            }
+            const candidate = await backend.candidate({ id: input.candidateId });
+            const jobs = (await backend.run({ id: input.runId, includeJobs: true })).jobs ?? [];
+            return createCaseReview({
+                candidate,
+                caseId: input.caseId,
+                executions: buildCandidateCaseExecutionRefs({
+                    jobs,
+                    candidateId: input.candidateId,
+                    caseId: input.caseId,
+                    sampleIndex: input.sampleIndex,
+                }),
+            });
+        },
+        run: (input) => backend.run(input),
+        executionTrace: async (input) => {
+            if (backend.executionTrace) {
+                return await backend.executionTrace(input);
+            }
+            if (!backend.jobInRun || !backend.traceForJob) {
+                throw new WorkbenchInspectionError("Execution traces are not available for this Workbench inspection backend.", { status: 404 });
+            }
+            const jobs = [await backend.jobInRun(input)];
+            return {
+                projectId: backend.projectId,
+                runId: input.runId,
+                executions: buildWorkbenchExecutionEvidence({
+                    jobs,
+                    traceIdPrefix: `${backend.projectId}-execution`,
+                    traceForJob: backend.traceForJob,
+                    traceSessionsForJob: backend.traceSessionsForJob,
+                }),
+            };
+        },
+        executionFiles: async (input) => {
+            const files = await backend.executionFiles(input);
+            return summarizeCandidateFiles(files, files.map((file) => file.path));
+        },
+        executionPreview: async (input) => createCandidateFilePreview({
+            files: await backend.executionFiles(input),
+            path: input.path,
+            view: input.view,
+        }),
+        lineage: async () => {
+            const snapshot = await backend.snapshot();
+            return buildCandidateLineage({
+                summaries: snapshot.summaries,
+                activeId: snapshot.activeId,
+            });
+        },
+        diagnose: async (input = {}) => {
+            const snapshot = await backend.snapshot();
+            return await diagnoseWorkbenchFailures({
+                snapshot,
+                backend,
+                targetId: input.targetId?.trim() || null,
+            });
+        },
+    };
+}
+async function diagnoseWorkbenchFailures(args) {
+    const targetRun = args.targetId
+        ? args.snapshot.runs.find((run) => run.id === args.targetId)
+        : null;
+    const targetEvaluation = args.targetId
+        ? args.snapshot.evaluations.find((evaluation) => evaluation.id === args.targetId)
+        : null;
+    const failures = [];
+    if (args.targetId && targetRun) {
+        const detail = await args.backend.run({ id: targetRun.id, includeJobs: true });
+        failures.push(...runFailures(detail.run));
+        failures.push(...jobFailures(detail.jobs ?? []));
+    }
+    else if (args.targetId && targetEvaluation) {
+        const evaluation = await args.backend.evaluation({ id: targetEvaluation.id });
+        failures.push(...evaluationFailures(evaluation));
+    }
+    else {
+        for (const run of args.snapshot.runs) {
+            failures.push(...runFailures(run));
+        }
+        for (const evaluation of args.snapshot.evaluations) {
+            failures.push(...evaluationSummaryFailures(evaluation));
+        }
+    }
+    return {
+        targetId: args.targetId,
+        failures,
+        failedRunCount: failures.filter((failure) => failure.kind === "run").length,
+        failedEvaluationCount: failures.filter((failure) => failure.kind === "evaluation").length,
+        failedJobCount: failures.filter((failure) => failure.kind === "job").length,
+    };
+}
+function runFailures(run) {
+    if (run.status !== "finished" || (run.outcome !== "error" && run.outcome !== "cancelled")) {
+        return [];
+    }
+    return [{
+            kind: "run",
+            id: run.id,
+            runId: run.id,
+            candidateId: run.outputCandidateId ?? run.candidateId ?? undefined,
+            status: run.outcome,
+            ...(run.error ? { error: run.error } : {}),
+        }];
+}
+function evaluationSummaryFailures(evaluation) {
+    if (evaluation.status === "completed" &&
+        evaluation.errorSampleCount === 0 &&
+        !evaluation.error) {
+        return [];
+    }
+    return [{
+            kind: "evaluation",
+            id: evaluation.id,
+            evaluationId: evaluation.id,
+            runId: evaluation.runId,
+            candidateId: evaluation.candidateId,
+            status: evaluation.status,
+            ...(evaluation.error ? { error: evaluation.error } : {}),
+        }];
+}
+function evaluationFailures(evaluation) {
+    const failures = evaluationSummaryFailures(evaluation);
+    for (const sample of evaluation.evaluation.samples) {
+        if (!sample.error && !(sample.cases ?? []).some((entry) => entry.status && entry.status !== "completed")) {
+            continue;
+        }
+        failures.push({
+            kind: "sample",
+            id: `${evaluation.id}:sample:${sample.index}`,
+            evaluationId: evaluation.id,
+            runId: evaluation.runId,
+            candidateId: evaluation.candidateId,
+            sampleIndex: sample.index,
+            status: sample.status,
+            ...(sample.error ? { error: sample.error } : {}),
+        });
+        for (const result of sample.cases ?? []) {
+            if (!result.status || result.status === "completed") {
+                continue;
+            }
+            failures.push({
+                kind: "case",
+                id: `${evaluation.id}:case:${result.id}:sample:${sample.index}`,
+                evaluationId: evaluation.id,
+                runId: evaluation.runId,
+                candidateId: evaluation.candidateId,
+                caseId: result.id,
+                sampleIndex: sample.index,
+                status: result.status,
+            });
+        }
+    }
+    return failures;
+}
+function jobFailures(jobs) {
+    return jobs
+        .filter((job) => isFailedJobStatus(job.status))
+        .map((job) => ({
+        kind: "job",
+        id: job.id,
+        jobId: job.id,
+        runId: job.runId,
+        candidateId: job.candidateId,
+        status: job.status,
+        attemptIndex: typeof job.attempt === "number" ? job.attempt : undefined,
+        ...(job.error ? { error: job.error } : {}),
+    }));
+}
+function isFailedJobStatus(status) {
+    return status === "failed" || status === "cancelled";
+}

package/dist/runtime-utils.d.ts

@@ -1,10 +1,15 @@
-import type { Json } from "@workbench-ai/workbench-contract";
+import type { Json, SurfaceSnapshotFile } from "@workbench-ai/workbench-contract";
 export declare function importNodeModule<T>(specifier: string): Promise<T>;
 export declare function nodeBuiltin(name: string): string;
 export declare function asRuntimeRecord(value: unknown): Record<string, unknown>;
 export declare function jsonRecord(value: unknown): Record<string, Json>;
 export declare function numberValue(value: unknown): number | undefined;
 export declare function stringValue(value: unknown): string | undefined;
+export declare function normalizeRelativePath(filePath: string): string;
+export declare function writeSurfaceFiles(root: string, files: readonly SurfaceSnapshotFile[]): Promise<void>;
+export declare function readSurfaceFiles(root: string, options?: {
+    ignorePath?: (path: string) => boolean;
+}): Promise<SurfaceSnapshotFile[]>;
 export declare function isJsonPayload(value: unknown): value is import("@workbench-ai/workbench-contract").Json;
 export declare function resolveDockerRuntimeImageRef(imageRef: string, options: {
     runtimeRegistry: string;

package/dist/runtime-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-utils.d.ts","sourceRoot":"","sources":["../src/runtime-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,IAAI,EACL,MAAM,kCAAkC,CAAC;AAE1C,wBAAsB,gBAAgB,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAEvE;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAIvE;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAI/D;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAE9D;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAE9D;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,kCAAkC,EAAE,IAAI,CAWtG;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE;IAAE,eAAe,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAAE,GAChF,MAAM,CASR;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE9D;AAeD,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAS7E;AAED,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,SAAS,OAAO,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CASjG;AAoBD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKnD"}
+{"version":3,"file":"runtime-utils.d.ts","sourceRoot":"","sources":["../src/runtime-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,IAAI,EACJ,mBAAmB,EACpB,MAAM,kCAAkC,CAAC;AAE1C,wBAAsB,gBAAgB,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAEvE;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAIvE;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAI/D;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAE9D;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAE9D;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAU9D;AAED,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS,mBAAmB,EAAE,GACpC,OAAO,CAAC,IAAI,CAAC,CAgBf;AAED,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IAAE,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;CAAO,GACvD,OAAO,CAAC,mBAAmB,EAAE,CAAC,CA+ChC;AAwBD,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,OAAO,kCAAkC,EAAE,IAAI,CAWtG;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE;IAAE,eAAe,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAAE,GAChF,MAAM,CASR;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE9D;AAeD,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAS7E;AAED,wBAAgB,wBAAwB,CAAC,UAAU,EAAE,SAAS,OAAO,EAAE,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CASjG;AAoBD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKnD"}

package/dist/runtime-utils.js

@@ -28,6 +28,98 @@ export function numberValue(value) {
 export function stringValue(value) {
     return typeof value === "string" && value.length > 0 ? value : undefined;
 }
+export function normalizeRelativePath(filePath) {
+    const normalized = filePath.replace(/\\/gu, "/").replace(/^\/+/u, "");
+    if (!normalized || normalized.includes("\0")) {
+        throw new Error("File paths must be non-empty relative paths.");
+    }
+    const parts = normalized.split("/");
+    if (parts.some((part) => part === ".." || part === "." || part === "")) {
+        throw new Error(`Unsafe relative file path: ${filePath}`);
+    }
+    return normalized;
+}
+export async function writeSurfaceFiles(root, files) {
+    const fs = await importNodeModule(nodeBuiltin("fs/promises"));
+    const path = await importNodeModule(nodeBuiltin("path"));
+    await fs.mkdir(root, { recursive: true });
+    for (const file of files) {
+        const target = path.join(root, normalizeRelativePath(file.path));
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        const body = file.encoding === "base64"
+            ? Buffer.from(file.content, "base64")
+            : Buffer.from(file.content, "utf8");
+        await fs.writeFile(target, body);
+        if (file.executable) {
+            await fs.chmod(target, 0o755).catch(() => undefined);
+        }
+    }
+}
+export async function readSurfaceFiles(root, options = {}) {
+    const fs = await importNodeModule(nodeBuiltin("fs/promises"));
+    const path = await importNodeModule(nodeBuiltin("path"));
+    const utf8Decoder = new TextDecoder("utf-8", { fatal: true });
+    const files = [];
+    async function walk(directory) {
+        const entries = await fs
+            .readdir(directory, { withFileTypes: true })
+            .catch(() => []);
+        for (const entry of entries) {
+            const absolutePath = path.join(directory, entry.name);
+            const relativePath = normalizeRelativePath(path.relative(root, absolutePath).replace(/\\/gu, "/"));
+            if (options.ignorePath?.(relativePath)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                await walk(absolutePath);
+                continue;
+            }
+            if (!entry.isFile()) {
+                continue;
+            }
+            let body;
+            let stats;
+            try {
+                body = await fs.readFile(absolutePath);
+                stats = await fs.stat(absolutePath);
+            }
+            catch (error) {
+                if (isVanishedWalkEntry(error)) {
+                    continue;
+                }
+                throw error;
+            }
+            const content = encodeSurfaceSnapshotContent(body, utf8Decoder);
+            files.push({
+                path: relativePath,
+                kind: content.encoding === "base64" ? "binary" : "text",
+                encoding: content.encoding,
+                content: content.content,
+                executable: (stats.mode & 0o111) !== 0,
+            });
+        }
+    }
+    await walk(root);
+    return files.sort((left, right) => left.path.localeCompare(right.path));
+}
+function isVanishedWalkEntry(error) {
+    const code = error?.code;
+    return code === "ENOENT" || code === "ENOTDIR";
+}
+function encodeSurfaceSnapshotContent(body, utf8Decoder) {
+    try {
+        return {
+            encoding: "utf8",
+            content: utf8Decoder.decode(body),
+        };
+    }
+    catch {
+        return {
+            encoding: "base64",
+            content: body.toString("base64"),
+        };
+    }
+}
 export function isJsonPayload(value) {
     if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
         return Number.isFinite(value) || typeof value !== "number";

package/dist/sandbox-backends/index.d.ts

@@ -1,37 +1,29 @@
 import type { WorkbenchExecutionRuntimeInput } from "../execution-runtime-types.ts";
 import type { SandboxBackendCapabilities, SandboxExecutionFileStore, SandboxPlane } from "../sandbox-plane.ts";
-import { type WorkbenchSandboxProviderName } from "./names.ts";
-export { DOCKER_SANDBOX_BACKEND, resolveWorkbenchSandboxProviderName, type WorkbenchSandboxProviderName, } from "./names.ts";
+import { type WorkbenchSandboxBackendName } from "./names.ts";
+export { DOCKER_SANDBOX_BACKEND, resolveWorkbenchSandboxBackendName, type WorkbenchSandboxBackendName, } from "./names.ts";
 export { createDockerSandboxBackendDescriptor, createDockerSandboxPlane, } from "./docker.ts";
 export interface SandboxHostHealthExpectation {
-    provider: WorkbenchSandboxProviderName;
-    backend: string;
+    backend: WorkbenchSandboxBackendName;
     capabilities: SandboxBackendCapabilities;
 }
-export interface SandboxProviderRequestedResources {
+export interface SandboxBackendRequestedResources {
     cpu: number;
     memoryGb: number;
     diskGb?: number;
     timeoutMinutes?: number;
 }
-export interface SandboxProviderHostCost {
+export interface SandboxBackendHostCost {
     cpu: number;
     memoryGb: number;
     diskGb: number;
 }
-export interface SandboxProviderLeaseRequest {
-    scope: string;
-    units: number;
+export interface SandboxBackendAdmission {
+    backend: WorkbenchSandboxBackendName;
+    hostCost: SandboxBackendHostCost;
 }
-export interface SandboxProviderAdmission {
-    provider: WorkbenchSandboxProviderName;
-    hostCost: SandboxProviderHostCost;
-    providerLeases: SandboxProviderLeaseRequest[];
-}
-export declare function createSandboxBackendPlaneForProvider(provider: string, args: WorkbenchExecutionRuntimeInput, startedAt: string, fileStore: SandboxExecutionFileStore): SandboxPlane;
-export declare function sandboxHostHealthExpectationForProvider(provider: WorkbenchSandboxProviderName): SandboxHostHealthExpectation;
-export declare function assertSandboxHostHealthForProvider(value: unknown, provider: WorkbenchSandboxProviderName): void;
-export declare function sandboxProviderDefaultMaxConcurrentJobs(_provider: WorkbenchSandboxProviderName): number | null;
-export declare function sandboxProviderAdmissionForResources(provider: WorkbenchSandboxProviderName, resources: SandboxProviderRequestedResources): SandboxProviderAdmission;
-export declare function sandboxProviderLeaseScope(provider: WorkbenchSandboxProviderName): string;
+export declare function createSandboxBackendPlaneForBackend(backend: string, args: WorkbenchExecutionRuntimeInput, startedAt: string, fileStore: SandboxExecutionFileStore): SandboxPlane;
+export declare function sandboxHostHealthExpectationForBackend(backend: WorkbenchSandboxBackendName): SandboxHostHealthExpectation;
+export declare function assertSandboxHostHealthForBackend(value: unknown, backend: WorkbenchSandboxBackendName): void;
+export declare function sandboxBackendAdmissionForResources(backend: WorkbenchSandboxBackendName, resources: SandboxBackendRequestedResources): SandboxBackendAdmission;
 //# sourceMappingURL=index.d.ts.map

package/dist/sandbox-backends/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sandbox-backends/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,8BAA8B,EAC/B,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EACV,0BAA0B,EAE1B,yBAAyB,EACzB,YAAY,EACb,MAAM,qBAAqB,CAAC;AAK7B,OAAO,EAEL,KAAK,4BAA4B,EAElC,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,sBAAsB,EACtB,mCAAmC,EACnC,KAAK,4BAA4B,GAClC,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,oCAAoC,EACpC,wBAAwB,GACzB,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,EAAE,4BAA4B,CAAC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,0BAA0B,CAAC;CAC1C;AAED,MAAM,WAAW,iCAAiC;IAChD,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,uBAAuB;IACtC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,EAAE,4BAA4B,CAAC;IACvC,QAAQ,EAAE,uBAAuB,CAAC;IAClC,cAAc,EAAE,2BAA2B,EAAE,CAAC;CAC/C;AAED,wBAAgB,oCAAoC,CAClD,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,8BAA8B,EACpC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,yBAAyB,GACnC,YAAY,CAMd;AAED,wBAAgB,uCAAuC,CACrD,QAAQ,EAAE,4BAA4B,GACrC,4BAA4B,CAS9B;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,4BAA4B,GACrC,IAAI,CAeN;AAED,wBAAgB,uCAAuC,CACrD,SAAS,EAAE,4BAA4B,GACtC,MAAM,GAAG,IAAI,CAEf;AAED,wBAAgB,oCAAoC,CAClD,QAAQ,EAAE,4BAA4B,EACtC,SAAS,EAAE,iCAAiC,GAC3C,wBAAwB,CAkB1B;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,4BAA4B,GACrC,MAAM,CAER"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sandbox-backends/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,8BAA8B,EAC/B,MAAM,+BAA+B,CAAC;AACvC,OAAO,KAAK,EACV,0BAA0B,EAE1B,yBAAyB,EACzB,YAAY,EACb,MAAM,qBAAqB,CAAC;AAK7B,OAAO,EAEL,KAAK,2BAA2B,EAEjC,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,sBAAsB,EACtB,kCAAkC,EAClC,KAAK,2BAA2B,GACjC,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,oCAAoC,EACpC,wBAAwB,GACzB,MAAM,aAAa,CAAC;AAErB,MAAM,WAAW,4BAA4B;IAC3C,OAAO,EAAE,2BAA2B,CAAC;IACrC,YAAY,EAAE,0BAA0B,CAAC;CAC1C;AAED,MAAM,WAAW,gCAAgC;IAC/C,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,sBAAsB;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,2BAA2B,CAAC;IACrC,QAAQ,EAAE,sBAAsB,CAAC;CAClC;AAED,wBAAgB,mCAAmC,CACjD,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,8BAA8B,EACpC,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,yBAAyB,GACnC,YAAY,CAMd;AAED,wBAAgB,sCAAsC,CACpD,OAAO,EAAE,2BAA2B,GACnC,4BAA4B,CAQ9B;AAED,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,2BAA2B,GACnC,IAAI,CAYN;AAED,wBAAgB,mCAAmC,CACjD,OAAO,EAAE,2BAA2B,EACpC,SAAS,EAAE,gCAAgC,GAC1C,uBAAuB,CAiBzB"}

package/dist/sandbox-backends/index.js

@@ -1,34 +1,30 @@
 import { isWorkbenchExecutionNetworkEgress, } from "@workbench-ai/workbench-contract";
 import { createDockerSandboxBackendDescriptor, createDockerSandboxPlane, } from "./docker.js";
-import { DOCKER_SANDBOX_BACKEND, resolveWorkbenchSandboxProviderName, } from "./names.js";
-export { DOCKER_SANDBOX_BACKEND, resolveWorkbenchSandboxProviderName, } from "./names.js";
+import { DOCKER_SANDBOX_BACKEND, resolveWorkbenchSandboxBackendName, } from "./names.js";
+export { DOCKER_SANDBOX_BACKEND, resolveWorkbenchSandboxBackendName, } from "./names.js";
 export { createDockerSandboxBackendDescriptor, createDockerSandboxPlane, } from "./docker.js";
-export function createSandboxBackendPlaneForProvider(provider, args, startedAt, fileStore) {
-    const resolved = resolveWorkbenchSandboxProviderName(provider);
+export function createSandboxBackendPlaneForBackend(backend, args, startedAt, fileStore) {
+    const resolved = resolveWorkbenchSandboxBackendName(backend);
     if (resolved !== DOCKER_SANDBOX_BACKEND) {
-        throw new Error(`Unsupported local sandbox provider ${provider}.`);
+        throw new Error(`Unsupported local sandbox backend ${backend}.`);
     }
     return createDockerSandboxPlane(args, startedAt, fileStore);
 }
-export function sandboxHostHealthExpectationForProvider(provider) {
-    if (provider !== DOCKER_SANDBOX_BACKEND) {
-        resolveWorkbenchSandboxProviderName(provider);
+export function sandboxHostHealthExpectationForBackend(backend) {
+    if (backend !== DOCKER_SANDBOX_BACKEND) {
+        resolveWorkbenchSandboxBackendName(backend);
     }
     return {
-        provider,
-        backend: provider,
+        backend,
         capabilities: createDockerSandboxBackendDescriptor().capabilities,
     };
 }
-export function assertSandboxHostHealthForProvider(value, provider) {
-    const expected = sandboxHostHealthExpectationForProvider(provider);
+export function assertSandboxHostHealthForBackend(value, backend) {
+    const expected = sandboxHostHealthExpectationForBackend(backend);
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         throw new Error("sandbox host health response must be an object.");
     }
     const record = value;
-    if (record.provider !== expected.provider) {
-        throw new Error(`sandbox host provider ${String(record.provider ?? "missing")} does not match expected ${expected.provider}.`);
-    }
     if (record.backend !== expected.backend) {
         throw new Error(`sandbox host backend ${String(record.backend ?? "missing")} does not match expected ${expected.backend}.`);
     }
@@ -36,12 +32,9 @@ export function assertSandboxHostHealthForProvider(value, provider) {
         throw new Error(`sandbox host capabilities are invalid for backend ${expected.backend}.`);
     }
 }
-export function sandboxProviderDefaultMaxConcurrentJobs(_provider) {
-    return null;
-}
-export function sandboxProviderAdmissionForResources(provider, resources) {
-    if (provider !== DOCKER_SANDBOX_BACKEND) {
-        resolveWorkbenchSandboxProviderName(provider);
+export function sandboxBackendAdmissionForResources(backend, resources) {
+    if (backend !== DOCKER_SANDBOX_BACKEND) {
+        resolveWorkbenchSandboxBackendName(backend);
     }
     assertPositiveResource(resources.cpu, "resources.cpu");
     assertPositiveResource(resources.memoryGb, "resources.memoryGb");
@@ -49,18 +42,14 @@ export function sandboxProviderAdmissionForResources(provider, resources) {
         assertPositiveResource(resources.diskGb, "resources.diskGb");
     }
     return {
-        provider,
+        backend,
         hostCost: {
             cpu: resources.cpu,
             memoryGb: resources.memoryGb,
             diskGb: resources.diskGb ?? 1,
         },
-        providerLeases: [],
     };
 }
-export function sandboxProviderLeaseScope(provider) {
-    throw new Error(`Local sandbox provider ${provider} does not use provider leases.`);
-}
 function isSandboxBackendCapabilities(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return false;

package/dist/sandbox-backends/names.d.ts

@@ -1,6 +1,5 @@
 export declare const DOCKER_SANDBOX_BACKEND = "docker";
 export type WorkbenchSandboxBackendName = typeof DOCKER_SANDBOX_BACKEND;
-export type WorkbenchSandboxProviderName = WorkbenchSandboxBackendName;
-export declare function isWorkbenchSandboxProviderName(value: string): value is WorkbenchSandboxProviderName;
-export declare function resolveWorkbenchSandboxProviderName(value: string | null | undefined): WorkbenchSandboxProviderName;
+export declare function isWorkbenchSandboxBackendName(value: string): value is WorkbenchSandboxBackendName;
+export declare function resolveWorkbenchSandboxBackendName(value: string | null | undefined): WorkbenchSandboxBackendName;
 //# sourceMappingURL=names.d.ts.map

package/dist/sandbox-backends/names.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../../src/sandbox-backends/names.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,WAAW,CAAC;AAE/C,MAAM,MAAM,2BAA2B,GAAG,OAAO,sBAAsB,CAAC;AAExE,MAAM,MAAM,4BAA4B,GAAG,2BAA2B,CAAC;AAEvE,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,4BAA4B,CAEnG;AAED,wBAAgB,mCAAmC,CACjD,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/B,4BAA4B,CAS9B"}
+{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../../src/sandbox-backends/names.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,WAAW,CAAC;AAE/C,MAAM,MAAM,2BAA2B,GAAG,OAAO,sBAAsB,CAAC;AAExE,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,2BAA2B,CAEjG;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC/B,2BAA2B,CAS7B"}

package/dist/sandbox-backends/names.js

@@ -1,14 +1,14 @@
 export const DOCKER_SANDBOX_BACKEND = "docker";
-export function isWorkbenchSandboxProviderName(value) {
+export function isWorkbenchSandboxBackendName(value) {
     return value === DOCKER_SANDBOX_BACKEND;
 }
-export function resolveWorkbenchSandboxProviderName(value) {
+export function resolveWorkbenchSandboxBackendName(value) {
     const normalized = value?.trim();
     if (!normalized) {
-        throw new Error("Sandbox provider is required.");
+        throw new Error("Sandbox backend is required.");
     }
-    if (isWorkbenchSandboxProviderName(normalized)) {
+    if (isWorkbenchSandboxBackendName(normalized)) {
         return normalized;
     }
-    throw new Error(`Unsupported local sandbox provider ${normalized}. Supported providers: docker.`);
+    throw new Error(`Unsupported local sandbox backend ${normalized}. Supported backends: docker.`);
 }

package/dist/sandbox-inputs.d.ts

@@ -1,15 +1,15 @@
-import type { BlobObjectRef, HostedWorkbenchJob, Json, SurfaceSnapshotFile, WorkbenchExecutionCapability, WorkbenchExecutionResult, WorkbenchExecutionSpec, WorkbenchSandboxExecutionMetadata } from "@workbench-ai/workbench-contract";
+import type { BlobObjectRef, RemoteWorkbenchJob, Json, SurfaceSnapshotFile, WorkbenchExecutionCapability, WorkbenchExecutionResult, WorkbenchExecutionSpec, WorkbenchSandboxExecutionMetadata } from "@workbench-ai/workbench-contract";
 import { type SandboxCreateRequest, type SandboxExecutionFileStore, type SandboxMaterializedInput } from "./sandbox-plane.ts";
 import type { WorkbenchExecutionRuntimeInput } from "./execution-runtime-types.ts";
-export declare function readWorkbenchExecutionSpec(job: HostedWorkbenchJob): WorkbenchExecutionSpec;
+export declare function readWorkbenchExecutionSpec(job: RemoteWorkbenchJob): WorkbenchExecutionSpec;
 export declare function createWorkbenchSandboxFileStore(args: WorkbenchExecutionRuntimeInput): SandboxExecutionFileStore;
 export declare function materializeWorkbenchSandboxInput(args: WorkbenchExecutionRuntimeInput, execution: WorkbenchExecutionSpec, input: WorkbenchExecutionSpec["inputs"][number]): SandboxMaterializedInput;
 export declare function materializedFileInput(input: WorkbenchExecutionSpec["inputs"][number], files: readonly SurfaceSnapshotFile[]): SandboxMaterializedInput;
 export declare function createSandboxAdapterRequest(args: WorkbenchExecutionRuntimeInput, request: SandboxCreateRequest, startedAt: string): Json;
-export declare function sanitizeWorkbenchExecutionJobForSandbox(job: HostedWorkbenchJob, execution: WorkbenchExecutionSpec): HostedWorkbenchJob;
+export declare function sanitizeWorkbenchExecutionJobForSandbox(job: RemoteWorkbenchJob, execution: WorkbenchExecutionSpec): RemoteWorkbenchJob;
 export declare function materializedInputForSandboxRequest(input: SandboxMaterializedInput): Record<string, Json>;
 export declare function executionResultFromCompletedSandboxJob(args: {
-    completedJob: HostedWorkbenchJob;
+    completedJob: RemoteWorkbenchJob;
     execution: WorkbenchExecutionSpec;
     startedAt: string;
     backend: string;
@@ -21,7 +21,7 @@ export declare function executionResultFromCompletedSandboxJob(args: {
 export declare function outputPayloadForContract(output: Record<string, unknown>, outputName: string): Json | undefined;
 export declare function sandboxOutputRef(capability: WorkbenchExecutionCapability, outputName: string, body: string): Promise<BlobObjectRef>;
 export declare function sha256Hex(body: string): Promise<string>;
-export declare function withSandboxCompletionMetadata(job: HostedWorkbenchJob, metadata: WorkbenchSandboxExecutionMetadata): HostedWorkbenchJob;
-export declare function attachSandboxMetadataToJob(job: HostedWorkbenchJob, metadata: unknown): HostedWorkbenchJob;
+export declare function withSandboxCompletionMetadata(job: RemoteWorkbenchJob, metadata: WorkbenchSandboxExecutionMetadata): RemoteWorkbenchJob;
+export declare function attachSandboxMetadataToJob(job: RemoteWorkbenchJob, metadata: unknown): RemoteWorkbenchJob;
 export declare function isSurfaceSnapshotFile(value: unknown): value is SurfaceSnapshotFile;
 //# sourceMappingURL=sandbox-inputs.d.ts.map

package/dist/trace-files.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trace-files.d.ts","sourceRoot":"","sources":["../src/trace-files.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,yBAAyB,EAC1B,MAAM,kCAAkC,CAAC;AAO1C,eAAO,MAAM,oBAAoB,sBAAsB,CAAC;AAExD,wBAAsB,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAiChH;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,mBAAmB,EAAE,GAAG,MAAM,EAAE,CAK9E;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,MAAM,CAET;AAED,wBAAgB,gCAAgC,CAAC,IAAI,EAAE;IACrD,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,yBAAyB,CAAC;CACpC,GAAG,MAAM,CAET;AAED,wBAAgB,8BAA8B,CAAC,IAAI,EAAE;IACnD,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,MAAM,CAKT"}
+{"version":3,"file":"trace-files.d.ts","sourceRoot":"","sources":["../src/trace-files.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,mBAAmB,EACnB,yBAAyB,EAC1B,MAAM,kCAAkC,CAAC;AAO1C,eAAO,MAAM,oBAAoB,sBAAsB,CAAC;AAExD,wBAAsB,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAOhH;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,mBAAmB,EAAE,GAAG,MAAM,EAAE,CAK9E;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE;IAC/C,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,MAAM,CAET;AAED,wBAAgB,gCAAgC,CAAC,IAAI,EAAE;IACrD,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,yBAAyB,CAAC;CACpC,GAAG,MAAM,CAET;AAED,wBAAgB,8BAA8B,CAAC,IAAI,EAAE;IACnD,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,MAAM,CAKT"}

package/dist/trace-files.js

@@ -1,38 +1,12 @@
-import { importNodeModule, nodeBuiltin, } from "./runtime-utils.js";
+import { normalizeRelativePath, readSurfaceFiles, } from "./runtime-utils.js";
 export const WORKBENCH_TRACE_ROOT = ".workbench/traces";
 export async function readOutputTraceFiles(outputRoot, traceRoot) {
-    const fs = await importNodeModule(nodeBuiltin("fs/promises"));
-    const path = await importNodeModule(nodeBuiltin("path"));
-    const decoder = new TextDecoder("utf-8", { fatal: true });
-    const files = [];
-    async function walk(directory) {
-        const entries = await fs.readdir(directory, { withFileTypes: true }).catch(() => []);
-        for (const entry of entries) {
-            const absolutePath = path.join(directory, entry.name);
-            if (entry.isDirectory()) {
-                const relativeDirectory = normalizeRelativePath(path.relative(outputRoot, absolutePath).replace(/\\/gu, "/"));
-                if (shouldSkipTraceDirectory(relativeDirectory)) {
-                    continue;
-                }
-                await walk(absolutePath);
-                continue;
-            }
-            if (!entry.isFile()) {
-                continue;
-            }
-            const body = await fs.readFile(absolutePath);
-            const content = encodeTraceFileContent(body, decoder);
-            files.push({
-                path: normalizeRelativePath(`${traceRoot}/${path.relative(outputRoot, absolutePath).replace(/\\/gu, "/")}`),
-                kind: content.encoding === "base64" ? "binary" : "text",
-                encoding: content.encoding,
-                content: content.content,
-                executable: false,
-            });
-        }
-    }
-    await walk(outputRoot);
-    return files;
+    return (await readSurfaceFiles(outputRoot, { ignorePath: shouldSkipTraceDirectory }))
+        .map((file) => ({
+        ...file,
+        path: normalizeRelativePath(`${traceRoot}/${file.path}`),
+        executable: false,
+    }));
 }
 export function traceFilePaths(files) {
     return files
@@ -62,20 +36,6 @@ function shouldSkipTraceDirectory(relativeDirectory) {
         || relativeDirectory.endsWith("/session/workspace")
         || relativeDirectory.includes("/session/workspace/");
 }
-function encodeTraceFileContent(body, utf8Decoder) {
-    try {
-        return {
-            encoding: "utf8",
-            content: utf8Decoder.decode(body),
-        };
-    }
-    catch {
-        return {
-            encoding: "base64",
-            content: body.toString("base64"),
-        };
-    }
-}
 function sanitizeTracePathSegment(value) {
     const sanitized = value
         .trim()
@@ -89,6 +49,3 @@ function tracePurposeSequence(purpose) {
     }
     return 2;
 }
-function normalizeRelativePath(filePath) {
-    return filePath.replace(/\\/gu, "/").replace(/^\/+/u, "").replace(/\/+/gu, "/");
-}