@workbench-ai/workbench-built-in-adapters 0.0.68 → 0.0.69

package/dist/agent-turn.js

@@ -244,9 +244,9 @@ function defaultWorkbenchAgentConfig(provider, providerName) {
     };
 }
 async function resolveAgentAuth(provider, providerSpec, workspaceRoot, agentHome, adapterAuth) {
-    const skill = adapterAuthProviderOption(adapterAuth.request, providerSpec.use) ??
+    const authConfig = adapterAuthProviderOption(adapterAuth.request, providerSpec.use) ??
         (provider.manifest.defaults.auth ?? {});
-    const parsed = provider.schemas.auth.safeParse(skill);
+    const parsed = provider.schemas.auth.safeParse(authConfig);
     if (!parsed.success) {
         throw new Error(`Agent provider "${provider.manifest.id}" auth is invalid: ${formatValidationIssues(parsed.error.issues)}`);
     }

package/dist/execute.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../src/execute.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAEV,IAAI,EAKL,MAAM,kCAAkC,CAAC;AAoB1C,OAAO,KAAK,EAEV,0BAA0B,EAG3B,MAAM,iBAAiB,CAAC;AAQzB,MAAM,WAAW,4CAA4C;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,0BAA0B,CAAC;IAC3C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,kBAAkB,CAAC,EAAE,IAAI,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzC;AAyDD,wBAAsB,qCAAqC,CACzD,IAAI,GAAE,4CAAiD,GACtD,OAAO,CAAC,IAAI,CAAC,CAiDf"}
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../src/execute.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAEV,IAAI,EAKL,MAAM,kCAAkC,CAAC;AAqB1C,OAAO,KAAK,EAEV,0BAA0B,EAG3B,MAAM,iBAAiB,CAAC;AAOzB,MAAM,WAAW,4CAA4C;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,0BAA0B,CAAC;IAC3C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,kBAAkB,CAAC,EAAE,IAAI,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzC;AA2DD,wBAAsB,qCAAqC,CACzD,IAAI,GAAE,4CAAiD,GACtD,OAAO,CAAC,IAAI,CAAC,CAyDf"}

package/dist/execute.js

@@ -2,10 +2,10 @@ import { spawn } from "node:child_process";
 import { promises as fs } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { jsonRecord, normalizeRelativePath, readSurfaceFiles, writeSurfaceFiles, } from "@workbench-ai/workbench-core";
-import { ensureWorkbenchAdapterOutputDir, readWorkbenchAdapterOperationResult, readWorkbenchAdapterOperationRequest, runWorkbenchRuntimeOperationSequence, writeWorkbenchAdapterOperationResult, workbenchAdapterOperationResultPath, } from "@workbench-ai/workbench-protocol";
+import { createWorkbenchExecutionEventPublisher, jsonRecord, normalizeRelativePath, publishCommandStepEvent, readSurfaceFiles, writeSurfaceFiles, } from "@workbench-ai/workbench-core";
+import { ensureWorkbenchAdapterOutputDir, readWorkbenchAdapterOperationResult, readWorkbenchAdapterOperationRequest, writeWorkbenchAdapterOperationResult, workbenchAdapterOperationResultPath, } from "@workbench-ai/workbench-protocol";
 import YAML from "yaml";
-import { isWorkbenchBuiltInAdapterId, adapterCommandName, } from "./manifests.js";
+import { isWorkbenchBuiltInAdapterId, } from "./manifests.js";
 import { importWorkbenchRuntime } from "./runtime.js";
 const DIRECT_ADAPTER_HANDLERS = {
     command: executeCommandAdapterRequest,
@@ -33,10 +33,19 @@ export async function executeWorkbenchBuiltInAdapterCommand(args = {}) {
         adapterAuthRoot: args.adapterAuthRoot,
         adapterAuthRequest: args.adapterAuthRequest ?? request.auth,
         adapterAuthEnv: args.adapterAuthEnv,
+        eventPublisher: eventPublisherForAdapterRequest(request),
     };
     const directHandler = DIRECT_ADAPTER_HANDLERS[adapterId];
     if (directHandler) {
-        await directHandler(request);
+        await publishDirectAdapterStep(agentOptions.eventPublisher, adapterId, request, "started");
+        try {
+            await directHandler(request);
+            await publishDirectAdapterStep(agentOptions.eventPublisher, adapterId, request, "succeeded");
+        }
+        catch (error) {
+            await publishDirectAdapterStep(agentOptions.eventPublisher, adapterId, request, "failed", error);
+            throw error;
+        }
         return;
     }
     if (adapterId === "rubric") {
@@ -60,6 +69,23 @@ export async function executeWorkbenchBuiltInAdapterCommand(args = {}) {
         throw new Error(`Agent adapter ${adapterId} cannot handle ${request.operation}.`);
     }
 }
+async function publishDirectAdapterStep(publisher, adapterId, request, status, error) {
+    await publishCommandStepEvent(publisher, {
+        step: `${adapterId}.${request.operation}`,
+        status,
+        role: directAdapterProgressRole(request.operation),
+        ...(error ? { error: error instanceof Error ? error.message : String(error) } : {}),
+    });
+}
+function directAdapterProgressRole(operation) {
+    if (operation === "skill.run") {
+        return "runner";
+    }
+    if (operation === "skill.improve") {
+        return "improver";
+    }
+    return "engine";
+}
 async function executeWorkbenchEngineRequest(request) {
     if (request.operation === "engine.resolve") {
         await executeWorkbenchEngineResolveRequest(request);
@@ -92,42 +118,8 @@ async function executeWorkbenchEngineResolveRequest(request) {
     });
 }
 async function executeWorkbenchEngineRunRequest(request) {
-    const outcome = await workbenchEngineGradingIsolation(request) === "separate"
-        ? await runWorkbenchEngineSeparateGrading(request)
-        : await runWorkbenchEngineSharedGrading(request);
-    if (!outcome.result) {
-        throw new Error("Workbench engine scoring completed without an engine result.");
-    }
-    await writeSurfaceFiles(request.paths.output, outcome.files.map((file) => remapRuntimeControlTraceFile(request, file)));
-    const usage = await workbenchEngineOutcomeUsage(outcome);
-    await writeWorkbenchAdapterOperationResult(request.paths.output, {
-        protocol: "workbench.adapter-result.v1",
-        operation: "engine.run",
-        ok: true,
-        value: outcome.result,
-        ...(usage ? { usage } : {}),
-        ...(outcome.summary !== undefined ? { summary: outcome.summary } : {}),
-        ...(outcome.feedback !== undefined ? { feedback: outcome.feedback } : {}),
-    });
-}
-async function workbenchEngineOutcomeUsage(outcome) {
-    const runtime = await importWorkbenchRuntime();
-    const operationUsage = outcome.usage
-        ? undefined
-        : runtime.mergeUsageSummaries(outcome.operationResults.map((result) => {
-            if (result.operation === "skill.run") {
-                return runtime.assignUsageRole("runner", result.usage);
-            }
-            if (result.operation === "engine.run") {
-                return runtime.assignUsageRole("engine", result.usage);
-            }
-            return result.usage;
-        }));
-    const runtimeUsage = runtime.mergeUsageSummaries([outcome.usage, operationUsage]);
-    const resultUsage = runtimeUsage?.engine
-        ? undefined
-        : runtime.assignUsageRole("engine", outcome.result?.usage);
-    return runtime.mergeUsageSummaries([runtimeUsage, resultUsage]);
+    void request;
+    throw new Error("Workbench engine.run is no longer an orchestration adapter. Run the selected skill in core and invoke the score adapter directly.");
 }
 function workbenchEngineCasesPath(request) {
     const config = adapterCommandConfigRecord(request);
@@ -141,139 +133,6 @@ function workbenchEngineCasesPath(request) {
     }
     throw new Error("Workbench engine cases must be an object with path.");
 }
-function workbenchEngineScoreInvocation(request) {
-    const score = jsonRecord(adapterCommandConfigRecord(request).score);
-    if (!score || typeof score.use !== "string" || score.use.length === 0) {
-        throw new Error("Workbench engine requires invocation.with.score.use.");
-    }
-    return {
-        use: score.use,
-        with: (score.with ?? {}),
-        ...(score.auth !== undefined ? { auth: score.auth } : {}),
-        command: typeof score.command === "string" && score.command.length > 0
-            ? score.command
-            : adapterCommandName(score.use),
-    };
-}
-function workbenchEngineSkillInvocation(request) {
-    const skill = request.context?.skill?.run;
-    if (!skill?.use || !skill.command) {
-        throw new Error("Workbench engine requires context.skill.run.use and context.skill.run.command.");
-    }
-    return {
-        use: skill.use,
-        with: (skill.with ?? {}),
-        ...(skill.auth !== undefined ? { auth: skill.auth } : {}),
-        command: skill.command,
-    };
-}
-async function workbenchEngineGradingIsolation(request) {
-    const grading = jsonRecord(adapterCommandConfigRecord(request).grading);
-    const isolation = grading?.isolation;
-    if (isolation !== undefined &&
-        isolation !== "shared" &&
-        isolation !== "separate") {
-        throw new Error("Workbench engine grading.isolation must be shared or separate.");
-    }
-    if (await workbenchEnginePrivateFilesPresent(request)) {
-        return "separate";
-    }
-    return isolation ?? "shared";
-}
-async function workbenchEnginePrivateFilesPresent(request) {
-    if (!request.paths.enginePrivate) {
-        return false;
-    }
-    const files = await readOptionalSurfaceFiles(request.paths.enginePrivate);
-    return files.length > 0;
-}
-async function runWorkbenchEngineSharedGrading(request) {
-    const inputs = await workbenchEngineRuntimeInputs(request);
-    const skill = workbenchEngineSkillInvocation(request);
-    const score = workbenchEngineScoreInvocation(request);
-    const result = await runWorkbenchRuntimeOperationSequence({
-        inputs,
-        prepare: true,
-        operations: [
-            { label: "skill", operation: "skill.run", invocation: skill },
-            { label: "score", operation: "engine.run", invocation: score },
-        ],
-    });
-    assertRuntimeControlResultOk(result, "Workbench shared grading");
-    return result;
-}
-async function runWorkbenchEngineSeparateGrading(request) {
-    const inputs = await workbenchEngineRuntimeInputs(request);
-    const skill = workbenchEngineSkillInvocation(request);
-    const score = workbenchEngineScoreInvocation(request);
-    const runtime = await importWorkbenchRuntime();
-    const runner = await runWorkbenchRuntimeOperationSequence({
-        inputs: {
-            skill: inputs.skill,
-            case: inputs.case,
-            traces: inputs.traces,
-        },
-        prepare: true,
-        collectWorkspace: true,
-        operations: [
-            { label: "skill", operation: "skill.run", invocation: skill },
-        ],
-    });
-    assertRuntimeControlResultOk(runner, "Workbench separate runner");
-    const grader = await runWorkbenchRuntimeOperationSequence({
-        inputs: {
-            skill: inputs.skill,
-            case: inputs.case,
-            enginePrivate: inputs.enginePrivate,
-            traces: inputs.traces,
-            workspace: runner.workspaceFiles ?? [],
-            output: runner.files.filter((file) => !runtime.isWorkbenchInternalOutputPath(file.path)),
-        },
-        prepare: false,
-        operations: [
-            { label: "score", operation: "engine.run", invocation: score },
-        ],
-    });
-    assertRuntimeControlResultOk(grader, "Workbench separate grader");
-    return {
-        ...grader,
-        files: dedupeSurfaceFiles([...runner.files, ...grader.files]),
-        fileChanges: [...new Set([...runner.fileChanges, ...grader.fileChanges])].sort(),
-        usage: runtime.mergeUsageSummaries([runner.usage, grader.usage]),
-        operationResults: [...runner.operationResults, ...grader.operationResults],
-    };
-}
-async function workbenchEngineRuntimeInputs(request) {
-    const [skill, caseFiles, enginePrivate, traces] = await Promise.all([
-        readOptionalSurfaceFiles(request.paths.skills ?? request.paths.skill),
-        readOptionalSurfaceFiles(request.paths.case),
-        readOptionalSurfaceFiles(request.paths.enginePrivate),
-        readOptionalSurfaceFiles(request.paths.traces),
-    ]);
-    return {
-        skill,
-        case: caseFiles,
-        enginePrivate,
-        traces,
-    };
-}
-async function readOptionalSurfaceFiles(root) {
-    if (!root) {
-        return [];
-    }
-    return await readSurfaceFiles(root).catch((error) => {
-        if (error.code === "ENOENT") {
-            return [];
-        }
-        throw error;
-    });
-}
-function assertRuntimeControlResultOk(result, label) {
-    if (result.ok) {
-        return;
-    }
-    throw new Error(`${label} failed${result.error ? `: ${result.error}` : "."}`);
-}
 function dedupeSurfaceFiles(files) {
     const byPath = new Map();
     for (const file of files) {
@@ -285,31 +144,13 @@ function dedupeSurfaceFiles(files) {
     }
     return [...byPath.values()].sort((left, right) => left.path.localeCompare(right.path));
 }
-function remapRuntimeControlTraceFile(request, file) {
-    const normalized = normalizeRelativePath(file.path);
-    if (!normalized.startsWith(".workbench/traces/")) {
-        return { ...file, path: normalized };
-    }
-    const segments = normalized.split("/");
-    const rest = segments.length >= 6
-        ? segments.slice(5)
-        : segments.length >= 3
-            ? segments.slice(3)
-            : [];
-    if (rest.length === 0) {
-        return { ...file, path: normalized };
-    }
-    return {
-        ...file,
-        path: `.workbench/traces/${request.jobId ?? request.id}/${rest.join("/")}`,
-    };
-}
 function safeInternalPathSegment(value) {
     const safe = value.replace(/[^a-z0-9._-]+/giu, "_").replace(/^_+|_+$/gu, "");
     return safe || "nested";
 }
 async function executeCommandAdapterRequest(request) {
     const command = requiredAdapterCommandString(request, "command");
+    await ensureRunSkillDirectories(request);
     const before = request.operation === "skill.improve"
         ? await snapshotEditableSkillWorkspace(request)
         : null;
@@ -337,6 +178,7 @@ async function executeTestsEngineRequest(request) {
     if (request.operation !== "engine.run") {
         throw new Error(`Tests adapter cannot handle ${request.operation}.`);
     }
+    await ensureRunSkillDirectories(request);
     const testsRoot = requiredRequestPath(request.paths.enginePrivate, "paths.enginePrivate");
     const verifierRoot = testsVerifierOutputDir(request.paths.output);
     await fs.rm(verifierRoot, { recursive: true, force: true }).catch(() => undefined);
@@ -344,8 +186,6 @@ async function executeTestsEngineRequest(request) {
     const script = await firstExistingFile([
         path.join(testsRoot, "test.sh"),
         path.join(testsRoot, "run.sh"),
-        path.join(testsRoot, "tests", "test.sh"),
-        path.join(testsRoot, "tests", "run.sh"),
     ]);
     if (!script) {
         throw new Error(`Tests engine requires ${path.join(testsRoot, "test.sh")}.`);
@@ -356,6 +196,7 @@ async function executeTestsEngineRequest(request) {
         CASE_DIR: request.paths.case ?? path.join(request.paths.workspace, "input", "case"),
         OUTPUT_DIR: request.paths.output,
         WORKBENCH_TESTS_VERIFIER_DIR: verifierRoot,
+        WORKBENCH_CASE_ID: request.context?.attempt?.caseId ?? "current",
     });
     const result = await readTestsResult({
         verifierRoot,
@@ -407,8 +248,18 @@ function commandAdapterEnvironment(request) {
         TRACE_DIR: request.paths.traces ?? path.join(request.paths.workspace, "input", "traces"),
         OUTPUT_DIR: request.paths.output,
         WORKBENCH_SKILL_PATCH: commandSkillPatchPath(request),
+        WORKBENCH_CASE_ID: request.context?.attempt?.caseId ?? "current",
     };
 }
+async function ensureRunSkillDirectories(request) {
+    if (request.operation === "skill.improve") {
+        return;
+    }
+    await Promise.all([
+        request.paths.skills ? fs.mkdir(request.paths.skills, { recursive: true }) : Promise.resolve(),
+        request.paths.skill ? fs.mkdir(request.paths.skill, { recursive: true }) : Promise.resolve(),
+    ]);
+}
 function commandSkillPatchPath(request) {
     return path.join(request.paths.output, COMMAND_SKILL_PATCH_FILE);
 }
@@ -418,17 +269,25 @@ async function readSkillPatchFile(filePath) {
     }
     const record = jsonRecord(JSON.parse(await fs.readFile(filePath, "utf8")));
     const rawFiles = Array.isArray(record.files) ? record.files : [];
-    const files = rawFiles.flatMap((entry) => {
+    const files = rawFiles.map((entry, index) => {
         if (!isPatchSurfaceSnapshotFile(entry)) {
-            return [];
+            throw new Error(`Skill patch file ${filePath} files[${index}] must be an object with string path and content fields, got: ${describePatchEntry(entry)}.`);
         }
-        return [{
-                ...entry,
-                path: normalizeRelativePath(entry.path),
-            }];
+        return {
+            ...entry,
+            path: normalizeRelativePath(entry.path),
+        };
     });
+    if (record.fileChanges !== undefined && !Array.isArray(record.fileChanges)) {
+        throw new Error(`Skill patch file ${filePath} fileChanges must be an array of strings when provided.`);
+    }
     const fileChanges = Array.isArray(record.fileChanges)
-        ? record.fileChanges.flatMap((entry) => typeof entry === "string" ? [normalizeRelativePath(entry)] : [])
+        ? record.fileChanges.map((entry, index) => {
+            if (typeof entry !== "string") {
+                throw new Error(`Skill patch file ${filePath} fileChanges[${index}] must be a string path, got: ${describePatchEntry(entry)}.`);
+            }
+            return normalizeRelativePath(entry);
+        })
         : files.map((file) => file.path);
     return {
         files,
@@ -437,6 +296,20 @@ async function readSkillPatchFile(filePath) {
         ...(record.feedback !== undefined ? { feedback: record.feedback } : {}),
     };
 }
+function describePatchEntry(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (Array.isArray(value)) {
+        return "an array";
+    }
+    if (typeof value === "object") {
+        const record = value;
+        const keys = Object.keys(record);
+        return `an object with key${keys.length === 1 ? "" : "s"} [${keys.join(", ")}]`;
+    }
+    return `a ${typeof value}`;
+}
 function isPatchSurfaceSnapshotFile(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return false;
@@ -636,10 +509,9 @@ async function readTestsResult(args) {
         }
         return normalizeTestsResult({ reward: score }, args.caseId);
     }
-    return normalizeTestsResult({
-        score: 1,
-        summary: "Tests passed.",
-    }, args.caseId);
+    throw new Error("Tests engine did not find reward.json or reward.txt under its verifier output directory " +
+        `(${args.verifierRoot}). The tests script must write a reward to ` +
+        "$WORKBENCH_TESTS_VERIFIER_DIR/reward.json or $WORKBENCH_TESTS_VERIFIER_DIR/reward.txt.");
 }
 function testsVerifierOutputDir(outputRoot) {
     return path.join(outputRoot, ".workbench", "internal", "verifier");
@@ -786,6 +658,19 @@ function requiredAdapterCommandString(request, key) {
     }
     return value;
 }
+function eventPublisherForAdapterRequest(request) {
+    if (!request.progress) {
+        return undefined;
+    }
+    return createWorkbenchExecutionEventPublisher({
+        projectId: request.progress.projectId,
+        runId: request.progress.runId,
+        jobId: request.progress.jobId,
+        executionId: request.progress.executionId,
+        attempt: request.progress.attempt,
+        target: request.progress.target,
+    });
+}
 async function executeBuiltInAgentTurn(executor, request) {
     const { defaultWorkbenchAgentTurnExecutor, executeWorkbenchAgentTurn, } = await import("./agent-turn.js");
     return await executeWorkbenchAgentTurn(executor ?? defaultWorkbenchAgentTurnExecutor, request);
@@ -806,6 +691,7 @@ async function writeAgentSkillOutput(request, workload, adapter, options = {}) {
         prompt: buildAgentSkillPrompt(workload, adapter),
         traceRoot,
         jobId: workload.job.id,
+        eventPublisher: options.eventPublisher,
     });
     const outputPath = path.join(request.paths.output, "skill-summary.md");
     await fs.mkdir(path.dirname(outputPath), { recursive: true });
@@ -874,6 +760,7 @@ async function writeAgentSkillRevisionOutput(request, workload, improver, option
             prompt: buildAgentImproverPrompt(workload),
             traceRoot,
             jobId: workload.job.id,
+            eventPublisher: options.eventPublisher,
         });
         const skillPatch = await createSkillPatchFromWorkspace({
             beforeRoot: before.root,
@@ -954,6 +841,7 @@ async function writeRubricJudgeResult(request, workload, engine, options = {}) {
         adapterAuthRequest: options.adapterAuthRequest,
         adapterAuthEnv: options.adapterAuthEnv,
         runtime,
+        eventPublisher: options.eventPublisher,
     }));
     const usage = runtime.mergeUsageSummaries(criterionRuns.map((run) => run.usage));
     const result = rubricJudgeResultFromCriteria({
@@ -1072,6 +960,7 @@ async function runRubricCriterionJudge(args) {
         traceRoot: path.join(traceRoot, "judge"),
         tracePath,
         jobId: args.workload.job.id,
+        eventPublisher: args.eventPublisher,
     });
     let usage = args.runtime.assignUsageRole("engine", agentResult.usage);
     try {
@@ -1101,6 +990,7 @@ async function runRubricCriterionJudge(args) {
             traceRoot: path.join(traceRoot, "repair"),
             tracePath: repairTracePath,
             jobId: args.workload.job.id,
+            eventPublisher: args.eventPublisher,
         });
         usage = args.runtime.mergeUsageSummaries([
             usage,

package/dist/runtime.js

@@ -12,11 +12,11 @@ export async function importWorkbenchRuntime() {
     return await runtimeModule;
 }
 async function importWorkbenchRuntimeUncached() {
-    const skills = runtimeImportOptions();
+    const specifiers = runtimeImportOptions();
     let lastError;
-    for (const skill of skills) {
+    for (const specifier of specifiers) {
         try {
-            return await import(__rewriteRelativeImportExtension(skill));
+            return await import(__rewriteRelativeImportExtension(specifier));
         }
         catch (error) {
             lastError = error;
@@ -30,5 +30,5 @@ function runtimeImportOptions() {
         "/app/products/workbench/packages/core/src/index.ts",
         new URL("../../core/src/index.ts", import.meta.url).href,
         "@workbench-ai/workbench-core",
-    ].filter((skill) => typeof skill === "string" && skill.length > 0);
+    ].filter((specifier) => typeof specifier === "string" && specifier.length > 0);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workbench-ai/workbench-built-in-adapters",
-  "version": "0.0.68",
+  "version": "0.0.69",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/workbench-ai/workbench.git",
@@ -32,12 +32,12 @@
   ],
   "dependencies": {
     "yaml": "^2.8.2",
-    "@workbench-ai/agent-driver-anthropic-claude-code": "0.0.46",
-    "@workbench-ai/workbench-core": "0.0.68",
-    "@workbench-ai/workbench-contract": "0.0.68",
-    "@workbench-ai/workbench-protocol": "0.0.68",
     "@workbench-ai/agent-driver-openai-codex": "0.0.46",
-    "@workbench-ai/agent-driver": "0.0.46"
+    "@workbench-ai/agent-driver": "0.0.46",
+    "@workbench-ai/workbench-contract": "0.0.69",
+    "@workbench-ai/workbench-protocol": "0.0.69",
+    "@workbench-ai/agent-driver-anthropic-claude-code": "0.0.46",
+    "@workbench-ai/workbench-core": "0.0.69"
   },
   "devDependencies": {
     "@types/node": "^24.3.1",