@workbench-ai/workbench-protocol 0.0.40

package/dist/adapter-manifest.d.ts

@@ -0,0 +1,50 @@
+export interface WorkbenchAdapterManifest {
+    id: string;
+    protocol: "workbench.adapter.v1";
+    setup: string[];
+    command: string;
+    auth?: WorkbenchAdapterAuthManifest;
+    refs?: string[];
+}
+export interface WorkbenchAdapterAuthManifest {
+    methods?: Record<string, WorkbenchAdapterAuthMethodManifest>;
+    slots?: Record<string, {
+        methods?: Record<string, WorkbenchAdapterAuthMethodManifest>;
+    }>;
+}
+export interface WorkbenchAdapterAuthFileManifest {
+    path: string;
+    required?: boolean;
+}
+export interface WorkbenchAdapterAuthEnvManifest {
+    name: string;
+    required?: boolean;
+}
+export interface WorkbenchAdapterAuthMethodManifest {
+    env?: WorkbenchAdapterAuthEnvManifest[];
+    files?: WorkbenchAdapterAuthFileManifest[];
+    command?: string;
+}
+export interface WorkbenchAdapterInvocationLike {
+    use: string;
+    auth?: unknown;
+    with?: unknown;
+}
+export interface WorkbenchAdapterAuthRequirement {
+    adapterId: string;
+    slot?: string;
+    profile: string;
+}
+export declare function adapterCommandName(adapterId: string): string;
+export declare function cloneWorkbenchAdapterManifest(manifest: WorkbenchAdapterManifest): WorkbenchAdapterManifest;
+export declare function parseWorkbenchAdapterManifest(source: string, label?: string): WorkbenchAdapterManifest;
+export declare function workbenchAdapterManifestRequiresAuth(manifest: WorkbenchAdapterManifest): boolean;
+export declare function collectWorkbenchAdapterInvocations(roots: readonly WorkbenchAdapterInvocationLike[], manifests: readonly WorkbenchAdapterManifest[] | Map<string, WorkbenchAdapterManifest>): WorkbenchAdapterInvocationLike[];
+export declare function collectWorkbenchAdapterAuthRequirements(roots: readonly WorkbenchAdapterInvocationLike[], manifests: readonly WorkbenchAdapterManifest[] | Map<string, WorkbenchAdapterManifest>): WorkbenchAdapterAuthRequirement[];
+export declare function withDefaultWorkbenchAdapterAuthProfiles<T extends {
+    improve?: WorkbenchAdapterInvocationLike;
+    run: WorkbenchAdapterInvocationLike;
+    grade: WorkbenchAdapterInvocationLike;
+}>(spec: T, manifests: readonly WorkbenchAdapterManifest[] | Map<string, WorkbenchAdapterManifest>): T;
+export declare function withDefaultWorkbenchAdapterAuth<T extends WorkbenchAdapterInvocationLike>(invocation: T, manifests: readonly WorkbenchAdapterManifest[] | Map<string, WorkbenchAdapterManifest>): T;
+//# sourceMappingURL=adapter-manifest.d.ts.map

package/dist/adapter-manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-manifest.d.ts","sourceRoot":"","sources":["../src/adapter-manifest.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,wBAAwB;IACvC,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,sBAAsB,CAAC;IACjC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,4BAA4B,CAAC;IACpC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,4BAA4B;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kCAAkC,CAAC,CAAC;IAC7D,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QACrB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,kCAAkC,CAAC,CAAC;KAC9D,CAAC,CAAC;CACJ;AAED,MAAM,WAAW,gCAAgC;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,+BAA+B;IAC9C,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,kCAAkC;IACjD,GAAG,CAAC,EAAE,+BAA+B,EAAE,CAAC;IACxC,KAAK,CAAC,EAAE,gCAAgC,EAAE,CAAC;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,8BAA8B;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,+BAA+B;IAC9C,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,wBAAwB,GACjC,wBAAwB,CAO1B;AAED,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,MAAM,EACd,KAAK,SAA2B,GAC/B,wBAAwB,CA6B1B;AAED,wBAAgB,oCAAoC,CAClD,QAAQ,EAAE,wBAAwB,GACjC,OAAO,CAET;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,SAAS,8BAA8B,EAAE,EAChD,SAAS,EAAE,SAAS,wBAAwB,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,wBAAwB,CAAC,GACrF,8BAA8B,EAAE,CAUlC;AAED,wBAAgB,uCAAuC,CACrD,KAAK,EAAE,SAAS,8BAA8B,EAAE,EAChD,SAAS,EAAE,SAAS,wBAAwB,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,wBAAwB,CAAC,GACrF,+BAA+B,EAAE,CAcnC;AAED,wBAAgB,uCAAuC,CAAC,CAAC,SAAS;IAChE,OAAO,CAAC,EAAE,8BAA8B,CAAC;IACzC,GAAG,EAAE,8BAA8B,CAAC;IACpC,KAAK,EAAE,8BAA8B,CAAC;CACvC,EACC,IAAI,EAAE,CAAC,EACP,SAAS,EAAE,SAAS,wBAAwB,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,wBAAwB,CAAC,GACrF,CAAC,CASH;AAED,wBAAgB,+BAA+B,CAAC,CAAC,SAAS,8BAA8B,EACtF,UAAU,EAAE,CAAC,EACb,SAAS,EAAE,SAAS,wBAAwB,EAAE,GAAG,GAAG,CAAC,MAAM,EAAE,wBAAwB,CAAC,GACrF,CAAC,CAKH"}

package/dist/adapter-manifest.js

@@ -0,0 +1,448 @@
+import YAML from "yaml";
+export function adapterCommandName(adapterId) {
+    return `workbench-adapter-${adapterId}`;
+}
+export function cloneWorkbenchAdapterManifest(manifest) {
+    return {
+        ...manifest,
+        setup: [...manifest.setup],
+        ...(manifest.auth ? { auth: cloneJson(manifest.auth) } : {}),
+        ...(manifest.refs ? { refs: [...manifest.refs] } : {}),
+    };
+}
+export function parseWorkbenchAdapterManifest(source, label = "workbench.adapter.yaml") {
+    const parsed = YAML.parse(source);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error(`${label} must be a YAML object.`);
+    }
+    const record = parsed;
+    rejectUnknownManifestKeys(record, label, ["id", "protocol", "setup", "command", "auth", "refs"]);
+    const id = readAdapterId(record.id, `${label}.id`);
+    if (record.protocol !== "workbench.adapter.v1") {
+        throw new Error(`${label}.protocol must be workbench.adapter.v1.`);
+    }
+    const command = typeof record.command === "string" && record.command.trim()
+        ? record.command.trim()
+        : adapterCommandName(id);
+    const setup = record.setup === undefined
+        ? []
+        : readStringArray(record.setup, `${label}.setup`);
+    const refs = record.refs === undefined
+        ? undefined
+        : readAdapterRefs(record.refs, `${label}.refs`);
+    const auth = readAuth(record.auth, `${label}.auth`);
+    return {
+        id,
+        protocol: "workbench.adapter.v1",
+        setup,
+        command,
+        ...(auth ? { auth } : {}),
+        ...(refs ? { refs } : {}),
+    };
+}
+export function workbenchAdapterManifestRequiresAuth(manifest) {
+    return defaultWorkbenchAdapterAuthForManifest(manifest) !== undefined;
+}
+export function collectWorkbenchAdapterInvocations(roots, manifests) {
+    const manifestById = manifestMap(manifests);
+    const collected = [];
+    const queue = roots.map((root) => normalizeInvocationLike(root)).filter(isInvocationLike);
+    while (queue.length > 0) {
+        const invocation = queue.shift();
+        collected.push(invocation);
+        queue.push(...nestedWorkbenchAdapterInvocations(invocation, manifestById));
+    }
+    return collected;
+}
+export function collectWorkbenchAdapterAuthRequirements(roots, manifests) {
+    const manifestById = manifestMap(manifests);
+    const targets = new Map();
+    for (const invocation of collectWorkbenchAdapterInvocations(roots, manifestById)) {
+        const manifest = manifestById.get(invocation.use);
+        const requirements = adapterAuthRequirementsForInvocation(invocation, manifest);
+        if (requirements.length === 0) {
+            continue;
+        }
+        for (const target of requirements) {
+            targets.set(adapterAuthRequirementKey(target), target);
+        }
+    }
+    return [...targets.values()];
+}
+export function withDefaultWorkbenchAdapterAuthProfiles(spec, manifests) {
+    const manifestById = manifestMap(manifests);
+    const clone = cloneJson(spec);
+    if (clone.improve) {
+        clone.improve = withDefaultWorkbenchAdapterAuth(clone.improve, manifestById);
+    }
+    clone.run = withDefaultWorkbenchAdapterAuth(clone.run, manifestById);
+    clone.grade = withDefaultWorkbenchAdapterAuth(clone.grade, manifestById);
+    return clone;
+}
+export function withDefaultWorkbenchAdapterAuth(invocation, manifests) {
+    return applyDefaultWorkbenchAdapterAuth(cloneJson(invocation), manifestMap(manifests));
+}
+function applyDefaultWorkbenchAdapterAuth(invocation, manifestById) {
+    const manifest = manifestById.get(invocation.use);
+    if (manifest && invocation.auth === undefined) {
+        const defaultAuth = defaultWorkbenchAdapterAuthForManifest(manifest);
+        if (defaultAuth !== undefined) {
+            invocation.auth = defaultAuth;
+        }
+    }
+    if (!manifest?.refs?.length) {
+        return invocation;
+    }
+    const config = invocationConfig(invocation);
+    for (const pointer of manifest.refs) {
+        const value = readJsonPointer(config, pointer);
+        if (Array.isArray(value)) {
+            for (let index = 0; index < value.length; index += 1) {
+                const nested = normalizeInvocationLike(value[index]);
+                if (nested) {
+                    value[index] = applyDefaultWorkbenchAdapterAuth(nested, manifestById);
+                }
+            }
+            continue;
+        }
+        const nested = normalizeInvocationLike(value);
+        if (nested) {
+            const parent = readJsonPointerParent(config, pointer);
+            if (parent) {
+                const withDefaults = applyDefaultWorkbenchAdapterAuth(nested, manifestById);
+                if (Array.isArray(parent.container) && typeof parent.key === "number") {
+                    parent.container[parent.key] = withDefaults;
+                }
+                else if (!Array.isArray(parent.container) && typeof parent.key === "string") {
+                    parent.container[parent.key] = withDefaults;
+                }
+            }
+        }
+    }
+    return invocation;
+}
+function nestedWorkbenchAdapterInvocations(invocation, manifestById) {
+    const manifest = manifestById.get(invocation.use);
+    if (!manifest?.refs?.length) {
+        return [];
+    }
+    const config = invocationConfig(invocation);
+    return manifest.refs.flatMap((pointer) => {
+        const value = readJsonPointer(config, pointer);
+        if (Array.isArray(value)) {
+            return value.map((entry) => normalizeInvocationLike(entry)).filter(isInvocationLike);
+        }
+        const nested = normalizeInvocationLike(value);
+        return nested ? [nested] : [];
+    });
+}
+function manifestMap(manifests) {
+    return manifests instanceof Map
+        ? manifests
+        : new Map(manifests.map((manifest) => [manifest.id, manifest]));
+}
+function invocationConfig(invocation) {
+    return invocation.with;
+}
+function defaultWorkbenchAdapterAuthForManifest(manifest) {
+    const auth = manifest.auth;
+    if (!auth) {
+        return undefined;
+    }
+    if (auth.methods && Object.keys(auth.methods).length > 0) {
+        return "default";
+    }
+    const slotNames = adapterAuthSlotNames(auth);
+    if (slotNames.length === 0) {
+        return undefined;
+    }
+    return Object.fromEntries(slotNames.map((slot) => [slot, "default"]));
+}
+function adapterAuthRequirementsForInvocation(invocation, manifest) {
+    const auth = invocation.auth;
+    if (typeof auth === "string") {
+        const slotTargets = adapterAuthSlotNames(manifest?.auth).map((slot) => ({
+            adapterId: invocation.use,
+            slot,
+            profile: auth,
+        }));
+        return manifest?.auth?.methods && Object.keys(manifest.auth.methods).length > 0
+            ? [{ adapterId: invocation.use, profile: auth }, ...slotTargets]
+            : slotTargets.length > 0
+                ? slotTargets
+                : [{ adapterId: invocation.use, profile: auth }];
+    }
+    if (auth && typeof auth === "object" && !Array.isArray(auth)) {
+        return Object.entries(auth)
+            .filter((entry) => typeof entry[1] === "string")
+            .map(([slot, profile]) => ({
+            adapterId: invocation.use,
+            slot,
+            profile,
+        }));
+    }
+    if (!manifest || !workbenchAdapterManifestRequiresAuth(manifest)) {
+        return [];
+    }
+    const defaultAuth = defaultWorkbenchAdapterAuthForManifest(manifest);
+    if (typeof defaultAuth === "string") {
+        return [{ adapterId: invocation.use, profile: defaultAuth }];
+    }
+    if (defaultAuth && typeof defaultAuth === "object") {
+        return Object.entries(defaultAuth).map(([slot, profile]) => ({
+            adapterId: invocation.use,
+            slot,
+            profile,
+        }));
+    }
+    return [];
+}
+function adapterAuthSlotNames(auth) {
+    return auth?.slots ? Object.keys(auth.slots).sort() : [];
+}
+function adapterAuthRequirementKey(target) {
+    return `${target.adapterId}/${target.slot ?? "_"}/${target.profile}`;
+}
+function normalizeInvocationLike(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    if (typeof record.use !== "string" || record.use.length === 0) {
+        return null;
+    }
+    return record;
+}
+function isInvocationLike(value) {
+    return value !== null;
+}
+function readJsonPointer(root, pointer) {
+    if (pointer === "") {
+        return root;
+    }
+    if (!pointer.startsWith("/")) {
+        return undefined;
+    }
+    let current = root;
+    for (const rawSegment of pointer.slice(1).split("/")) {
+        const segment = decodeJsonPointerSegment(rawSegment);
+        if (Array.isArray(current)) {
+            const index = Number(segment);
+            if (!Number.isInteger(index) || index < 0 || index >= current.length) {
+                return undefined;
+            }
+            current = current[index];
+            continue;
+        }
+        if (!current || typeof current !== "object") {
+            return undefined;
+        }
+        current = current[segment];
+    }
+    return current;
+}
+function readJsonPointerParent(root, pointer) {
+    if (!pointer.startsWith("/") || pointer === "") {
+        return null;
+    }
+    const rawSegments = pointer.slice(1).split("/");
+    const last = decodeJsonPointerSegment(rawSegments.pop());
+    const parent = readJsonPointer(root, rawSegments.length === 0 ? "" : `/${rawSegments.join("/")}`);
+    if (Array.isArray(parent)) {
+        const index = Number(last);
+        return Number.isInteger(index) && index >= 0 && index < parent.length
+            ? { container: parent, key: index }
+            : null;
+    }
+    if (parent && typeof parent === "object") {
+        return { container: parent, key: last };
+    }
+    return null;
+}
+function decodeJsonPointerSegment(segment) {
+    return segment.replace(/~1/gu, "/").replace(/~0/gu, "~");
+}
+function cloneJson(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function readAdapterId(value, label) {
+    if (typeof value !== "string" || !/^[a-z][a-z0-9-]*$/u.test(value)) {
+        throw new Error(`${label} must be a lowercase adapter id.`);
+    }
+    return value;
+}
+function rejectUnknownManifestKeys(record, label, allowed) {
+    const extras = Object.keys(record).filter((key) => !allowed.includes(key));
+    if (extras.length > 0) {
+        throw new Error(`${label} includes unsupported ${extras.length === 1 ? "field" : "fields"}: ${extras.join(", ")}.`);
+    }
+}
+function readStringArray(value, label) {
+    if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string" && entry.trim().length > 0)) {
+        throw new Error(`${label} must be a list of non-empty strings.`);
+    }
+    return value.map((entry) => entry.trim());
+}
+function readAdapterRefs(value, label) {
+    const refs = readStringArray(value, label);
+    for (const ref of refs) {
+        if (ref !== "" && !ref.startsWith("/")) {
+            throw new Error(`${label} entries must be JSON pointers.`);
+        }
+    }
+    return refs;
+}
+function readAuth(value, label) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${label} must be an object.`);
+    }
+    const record = value;
+    rejectUnknownManifestKeys(record, label, ["methods", "slots"]);
+    const methods = record.methods === undefined
+        ? undefined
+        : readAuthMethods(record.methods, `${label}.methods`);
+    const slots = record.slots === undefined
+        ? undefined
+        : readAuthSlots(record.slots, `${label}.slots`);
+    if (methods && slots) {
+        throw new Error(`${label} must use either methods or slots, not both.`);
+    }
+    if (!methods && !slots) {
+        throw new Error(`${label} must declare methods or slots.`);
+    }
+    return {
+        ...(methods ? { methods } : {}),
+        ...(slots ? { slots } : {}),
+    };
+}
+function readAuthSlots(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${label} must be an object.`);
+    }
+    const slots = {};
+    for (const [slot, config] of Object.entries(value).sort()) {
+        if (!/^[a-z][a-z0-9-]*$/u.test(slot)) {
+            throw new Error(`${label} keys must be lowercase auth slot names.`);
+        }
+        if (!config || typeof config !== "object" || Array.isArray(config)) {
+            throw new Error(`${label}.${slot} must be an object.`);
+        }
+        const record = config;
+        rejectUnknownManifestKeys(record, `${label}.${slot}`, ["methods"]);
+        const methods = readAuthMethods(record.methods, `${label}.${slot}.methods`);
+        slots[slot] = { methods };
+    }
+    if (Object.keys(slots).length === 0) {
+        throw new Error(`${label} must include at least one slot.`);
+    }
+    return slots;
+}
+function readAuthMethods(value, label) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error(`${label} must be an object.`);
+    }
+    const methods = {};
+    for (const [method, config] of Object.entries(value).sort()) {
+        if (!/^[a-z][a-z0-9-]*$/u.test(method)) {
+            throw new Error(`${label} keys must be lowercase auth method names.`);
+        }
+        if (!config || typeof config !== "object" || Array.isArray(config)) {
+            throw new Error(`${label}.${method} must be an object.`);
+        }
+        methods[method] = readAuthMethod(config, `${label}.${method}`);
+    }
+    if (Object.keys(methods).length === 0) {
+        throw new Error(`${label} must include at least one method.`);
+    }
+    return methods;
+}
+function readAuthMethod(record, label) {
+    rejectUnknownManifestKeys(record, label, ["env", "files", "command"]);
+    const env = record.env === undefined
+        ? undefined
+        : readAuthEnv(record.env, `${label}.env`);
+    const files = record.files === undefined
+        ? undefined
+        : readAuthFiles(record.files, `${label}.files`);
+    const command = record.command === undefined
+        ? undefined
+        : readNonEmptyString(record.command, `${label}.command`);
+    if (!env && !files && !command) {
+        throw new Error(`${label} must declare env, files, or command.`);
+    }
+    return {
+        ...(env ? { env } : {}),
+        ...(files ? { files } : {}),
+        ...(command ? { command } : {}),
+    };
+}
+function readAuthFiles(value, label) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new Error(`${label} must be a non-empty list.`);
+    }
+    return value.map((entry, index) => {
+        if (typeof entry === "string") {
+            return { path: readAuthFilePath(entry, `${label}[${index}]`) };
+        }
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+            throw new Error(`${label}[${index}] must be a file path or object.`);
+        }
+        const record = entry;
+        rejectUnknownManifestKeys(record, `${label}[${index}]`, ["path", "required"]);
+        return {
+            path: readAuthFilePath(record.path, `${label}[${index}].path`),
+            ...readRequiredFlag(record.required, `${label}[${index}].required`),
+        };
+    });
+}
+function readAuthEnv(value, label) {
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new Error(`${label} must be a non-empty list.`);
+    }
+    return value.map((entry, index) => {
+        if (typeof entry === "string") {
+            return { name: readAuthEnvName(entry, `${label}[${index}]`) };
+        }
+        if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+            throw new Error(`${label}[${index}] must be an env name or object.`);
+        }
+        const record = entry;
+        rejectUnknownManifestKeys(record, `${label}[${index}]`, ["name", "required"]);
+        return {
+            name: readAuthEnvName(record.name, `${label}[${index}].name`),
+            ...readRequiredFlag(record.required, `${label}[${index}].required`),
+        };
+    });
+}
+function readRequiredFlag(value, label) {
+    if (value === undefined || value === true) {
+        return {};
+    }
+    if (value === false) {
+        return { required: false };
+    }
+    throw new Error(`${label} must be a boolean.`);
+}
+function readAuthEnvName(value, label) {
+    const name = readNonEmptyString(value, label);
+    if (!/^[A-Z_][A-Z0-9_]*$/u.test(name)) {
+        throw new Error(`${label} must be an environment variable name.`);
+    }
+    return name;
+}
+function readAuthFilePath(value, label) {
+    const filePath = readNonEmptyString(value, label).replace(/\\/gu, "/").replace(/^\/+/u, "");
+    if (!filePath || filePath.split("/").some((part) => part === "." || part === ".." || part === "")) {
+        throw new Error(`${label} must be a safe relative file path.`);
+    }
+    return filePath;
+}
+function readNonEmptyString(value, label) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`${label} must be a non-empty string.`);
+    }
+    return value.trim();
+}

package/dist/adapter-protocol.d.ts

@@ -0,0 +1,59 @@
+import type { Json, UsageSummary, WorkbenchExecutionSpec } from "@workbench-ai/workbench-contract";
+export interface WorkbenchAdapterCommandRequest {
+    protocol: "workbench.adapter.v1";
+    execution: {
+        id: string;
+        jobId?: string;
+        purpose: WorkbenchExecutionSpec["purpose"];
+        role: "optimizer" | "runner" | "grader";
+        candidateId?: string;
+        trialIndex?: number;
+        sampleIndex?: number;
+        caseId?: string;
+    };
+    adapter: {
+        use: string;
+        with?: Json;
+        auth?: Json;
+    };
+    auth?: Json;
+    benchmark?: {
+        name?: string;
+        description?: string;
+    };
+    candidate?: {
+        path?: string;
+    };
+    optimizer?: {
+        edits?: string[];
+    };
+    task?: {
+        text?: string;
+    };
+    expectedOutputs?: Array<{
+        name?: string;
+        path?: string;
+    }>;
+    paths: {
+        workspace: string;
+        input?: string;
+        output: string;
+        candidate?: string;
+        task?: string;
+        runnerOutput?: string;
+        traces?: string;
+    };
+}
+export interface WorkbenchAdapterResultMetadata {
+    ok?: boolean;
+    summary?: string;
+    feedback?: Json;
+    usage?: UsageSummary;
+}
+export declare function readWorkbenchAdapterCommandRequest(configuredPath?: string): Promise<WorkbenchAdapterCommandRequest>;
+export declare function normalizeWorkbenchAdapterCommandRequest(value: unknown): WorkbenchAdapterCommandRequest;
+export declare function ensureWorkbenchAdapterOutputDir(request: WorkbenchAdapterCommandRequest): Promise<void>;
+export declare function workbenchAdapterResultPath(outputRoot: string): string;
+export declare function writeWorkbenchAdapterResultMetadata(outputRoot: string, result: WorkbenchAdapterResultMetadata): Promise<void>;
+export declare function readWorkbenchAdapterResultMetadata(outputRoot: string): Promise<WorkbenchAdapterResultMetadata>;
+//# sourceMappingURL=adapter-protocol.d.ts.map

package/dist/adapter-protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-protocol.d.ts","sourceRoot":"","sources":["../src/adapter-protocol.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,IAAI,EACJ,YAAY,EACZ,sBAAsB,EACvB,MAAM,kCAAkC,CAAC;AAE1C,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,EAAE,sBAAsB,CAAC;IACjC,SAAS,EAAE;QACT,EAAE,EAAE,MAAM,CAAC;QACX,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,OAAO,EAAE,sBAAsB,CAAC,SAAS,CAAC,CAAC;QAC3C,IAAI,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;QACxC,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,OAAO,EAAE;QACP,GAAG,EAAE,MAAM,CAAC;QACZ,IAAI,CAAC,EAAE,IAAI,CAAC;QACZ,IAAI,CAAC,EAAE,IAAI,CAAC;KACb,CAAC;IACF,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,SAAS,CAAC,EAAE;QACV,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,CAAC;IACF,SAAS,CAAC,EAAE;QACV,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC;IACF,SAAS,CAAC,EAAE;QACV,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;KAClB,CAAC;IACF,IAAI,CAAC,EAAE;QACL,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC;IACF,eAAe,CAAC,EAAE,KAAK,CAAC;QACtB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC,CAAC;IACH,KAAK,EAAE;QACL,SAAS,EAAE,MAAM,CAAC;QAClB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC;CACH;AAED,MAAM,WAAW,8BAA8B;IAC7C,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB;AAED,wBAAsB,kCAAkC,CACtD,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,8BAA8B,CAAC,CAOzC;AAED,wBAAgB,uCAAuC,CACrD,KAAK,EAAE,OAAO,GACb,8BAA8B,CA8ChC;AAED,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,8BAA8B,GACtC,OAAO,CAAC,IAAI,CAAC,CAEf;AAED,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAErE;AAED,wBAAsB,mCAAmC,CACvD,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,8BAA8B,GACrC,OAAO,CAAC,IAAI,CAAC,CAIf;AAED,wBAAsB,kCAAkC,CACtD,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,8BAA8B,CAAC,CAkBzC"}

package/dist/adapter-protocol.js

@@ -0,0 +1,186 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export async function readWorkbenchAdapterCommandRequest(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);
+}
+export function normalizeWorkbenchAdapterCommandRequest(value) {
+    const record = requiredJsonRecord(value, "adapter request");
+    if (record.protocol !== "workbench.adapter.v1") {
+        throw new Error("Adapter request protocol must be workbench.adapter.v1.");
+    }
+    const execution = requiredJsonRecord(record.execution, "adapter request execution");
+    const adapter = requiredJsonRecord(record.adapter, "adapter request adapter");
+    const paths = requiredJsonRecord(record.paths, "adapter request paths");
+    const purpose = requiredPurpose(execution.purpose, "adapter request execution.purpose");
+    const role = executionPurposeRole(purpose);
+    const use = requiredString(adapter.use, "adapter request adapter.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: {
+            use,
+            with: adapter.with !== undefined ? adapter.with : {},
+            ...(adapter.auth !== undefined ? { auth: adapter.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) }
+            : {}),
+        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 } : {}),
+            ...(typeof paths.traces === "string" ? { traces: paths.traces } : {}),
+        },
+    };
+}
+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 async function writeWorkbenchAdapterResultMetadata(outputRoot, result) {
+    const resultPath = workbenchAdapterResultPath(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 {};
+    }
+    const parsed = JSON.parse(source);
+    const record = jsonRecord(parsed);
+    return {
+        ...(record.ok === true || record.ok === false ? { ok: record.ok } : {}),
+        ...(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");
+    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");
+    return {
+        ...(typeof record.path === "string" ? { path: record.path } : {}),
+    };
+}
+function normalizeAdapterCommandOptimizer(value) {
+    const record = requiredJsonRecord(value, "adapter request optimizer");
+    return {
+        edits: Array.isArray(record.edits)
+            ? record.edits.filter((entry) => typeof entry === "string")
+            : [],
+    };
+}
+function normalizeAdapterCommandTask(value) {
+    const record = requiredJsonRecord(value, "adapter request task");
+    return {
+        ...(typeof record.text === "string" ? { text: record.text } : {}),
+    };
+}
+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 === "run-task" || value === "grade-task") {
+        return value;
+    }
+    throw new Error(`${label} must be improve, run-task, or grade-task.`);
+}
+function requiredString(value, label) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`${label} is required.`);
+    }
+    return value;
+}
+function executionPurposeRole(purpose) {
+    if (purpose === "improve") {
+        return "optimizer";
+    }
+    if (purpose === "run-task") {
+        return "runner";
+    }
+    return "grader";
+}
+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/index.d.ts

@@ -0,0 +1,3 @@
+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";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +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"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { adapterCommandName, cloneWorkbenchAdapterManifest, collectWorkbenchAdapterAuthRequirements, collectWorkbenchAdapterInvocations, parseWorkbenchAdapterManifest, workbenchAdapterManifestRequiresAuth, withDefaultWorkbenchAdapterAuth, withDefaultWorkbenchAdapterAuthProfiles, } from "./adapter-manifest.js";
+export { ensureWorkbenchAdapterOutputDir, normalizeWorkbenchAdapterCommandRequest, readWorkbenchAdapterCommandRequest, readWorkbenchAdapterResultMetadata, workbenchAdapterResultPath, writeWorkbenchAdapterResultMetadata, } from "./adapter-protocol.js";

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@workbench-ai/workbench-protocol",
+  "version": "0.0.40",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "yaml": "^2.8.2",
+    "@workbench-ai/workbench-contract": "0.0.40"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.1",
+    "typescript": "^5.9.2",
+    "vitest": "^3.2.4"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run --config vitest.config.ts"
+  }
+}