@workbench-ai/workbench-core 0.0.46

package/dist/adapter-auth.d.ts

@@ -0,0 +1,63 @@
+export type WorkbenchAdapterAuthStatus = "connected" | "reauth_required" | "disconnected";
+export interface WorkbenchAdapterAuthTarget {
+    adapterId: string;
+    slot?: string;
+    profile: string;
+}
+export interface WorkbenchAdapterAuthFile {
+    path: string;
+    content: string;
+    encoding: "utf8" | "base64";
+    mode?: number;
+}
+export interface WorkbenchAdapterAuthEnvVar {
+    name: string;
+    value: string;
+}
+export interface WorkbenchAdapterAuthBundle {
+    adapterId: string;
+    slot?: string;
+    profile: string;
+    method: string;
+    status: "connected";
+    version: number;
+    files: WorkbenchAdapterAuthFile[];
+    env?: WorkbenchAdapterAuthEnvVar[];
+    updatedAt: string;
+}
+export interface WorkbenchAdapterAuthStatusRecord {
+    adapterId: string;
+    slot?: string;
+    profile: string;
+    status: WorkbenchAdapterAuthStatus;
+    version: number;
+    method?: string;
+    updatedAt?: string;
+    reason?: string;
+}
+export interface WorkbenchAdapterAuthStore {
+    get(target: WorkbenchAdapterAuthTarget): Promise<WorkbenchAdapterAuthBundle | null>;
+    put(bundle: WorkbenchAdapterAuthBundle): Promise<WorkbenchAdapterAuthBundle>;
+    disconnect(target: WorkbenchAdapterAuthTarget, reason?: string): Promise<void>;
+    markReauthRequired(target: WorkbenchAdapterAuthTarget, reason: string): Promise<void>;
+    status(target: WorkbenchAdapterAuthTarget): Promise<WorkbenchAdapterAuthStatusRecord>;
+    listStatus(): Promise<WorkbenchAdapterAuthStatusRecord[]>;
+}
+export declare function defaultWorkbenchAdapterAuthStoreRoot(): string;
+export declare function localWorkbenchAdapterAuthStore(root?: string): WorkbenchAdapterAuthStore;
+export declare function parseWorkbenchAdapterAuthTarget(value: string, profile?: string): WorkbenchAdapterAuthTarget;
+export declare function normalizeWorkbenchAdapterAuthTarget(target: {
+    adapterId: string;
+    slot?: string;
+    profile?: string;
+}): WorkbenchAdapterAuthTarget;
+export declare function createWorkbenchAdapterAuthBundle(args: {
+    target: WorkbenchAdapterAuthTarget;
+    method: string;
+    files?: WorkbenchAdapterAuthFile[];
+    env?: Record<string, string> | WorkbenchAdapterAuthEnvVar[];
+    now?: string;
+}): WorkbenchAdapterAuthBundle;
+export declare function adapterAuthEnv(bundle: WorkbenchAdapterAuthBundle): Record<string, string>;
+export declare function sanitizeWorkbenchAdapterAuthBundle(value: unknown): WorkbenchAdapterAuthBundle;
+//# sourceMappingURL=adapter-auth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"adapter-auth.d.ts","sourceRoot":"","sources":["../src/adapter-auth.ts"],"names":[],"mappings":"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"}

package/dist/adapter-auth.js

@@ -0,0 +1,244 @@
+import { promises as fs } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+const ADAPTER_AUTH_STORE_VERSION = 1;
+const DEFAULT_AUTH_PROFILE = "default";
+export function defaultWorkbenchAdapterAuthStoreRoot() {
+    return path.join(os.homedir(), ".workbench", "adapter-auth");
+}
+export function localWorkbenchAdapterAuthStore(root = defaultWorkbenchAdapterAuthStoreRoot()) {
+    return new FileWorkbenchAdapterAuthStore(root);
+}
+export function parseWorkbenchAdapterAuthTarget(value, profile = DEFAULT_AUTH_PROFILE) {
+    const [adapterId, slot, ...rest] = value.split("/");
+    if (!adapterId || rest.length > 0) {
+        throw new Error("Adapter auth target must be adapter or adapter/slot.");
+    }
+    return normalizeWorkbenchAdapterAuthTarget({
+        adapterId,
+        ...(slot ? { slot } : {}),
+        profile,
+    });
+}
+export function normalizeWorkbenchAdapterAuthTarget(target) {
+    const adapterId = readAdapterAuthSegment(target.adapterId, "adapter id");
+    const slot = target.slot === undefined
+        ? undefined
+        : readAdapterAuthSegment(target.slot, "auth slot");
+    const profile = target.profile === undefined || target.profile === ""
+        ? DEFAULT_AUTH_PROFILE
+        : readAdapterAuthSegment(target.profile, "auth profile");
+    return {
+        adapterId,
+        ...(slot ? { slot } : {}),
+        profile,
+    };
+}
+export function createWorkbenchAdapterAuthBundle(args) {
+    const files = args.files ?? [];
+    const env = Array.isArray(args.env)
+        ? args.env
+        : Object.entries(args.env ?? {}).map(([name, value]) => ({ name, value }));
+    if (files.length === 0 && env.length === 0) {
+        throw new Error("Adapter auth requires at least one file or env var.");
+    }
+    return sanitizeWorkbenchAdapterAuthBundle({
+        ...args.target,
+        method: args.method,
+        status: "connected",
+        version: ADAPTER_AUTH_STORE_VERSION,
+        files,
+        ...(env.length > 0 ? { env } : {}),
+        updatedAt: args.now ?? new Date().toISOString(),
+    });
+}
+export function adapterAuthEnv(bundle) {
+    return Object.fromEntries((bundle.env ?? []).map((entry) => [entry.name, entry.value]));
+}
+export function sanitizeWorkbenchAdapterAuthBundle(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Adapter auth bundle must be an object.");
+    }
+    const record = value;
+    const target = normalizeWorkbenchAdapterAuthTarget({
+        adapterId: readString(record.adapterId, "adapterId"),
+        ...(record.slot !== undefined ? { slot: readString(record.slot, "slot") } : {}),
+        profile: typeof record.profile === "string" ? record.profile : DEFAULT_AUTH_PROFILE,
+    });
+    if (record.status !== "connected") {
+        throw new Error("Adapter auth bundle must be connected.");
+    }
+    const method = readAdapterAuthSegment(readString(record.method, "method"), "auth method");
+    const files = Array.isArray(record.files)
+        ? record.files.map(sanitizeWorkbenchAdapterAuthFile)
+        : [];
+    const env = Array.isArray(record.env)
+        ? record.env.map(sanitizeWorkbenchAdapterAuthEnvVar)
+        : [];
+    return {
+        ...target,
+        method,
+        status: "connected",
+        version: ADAPTER_AUTH_STORE_VERSION,
+        files,
+        ...(env.length > 0 ? { env } : {}),
+        updatedAt: typeof record.updatedAt === "string"
+            ? record.updatedAt
+            : new Date().toISOString(),
+    };
+}
+class FileWorkbenchAdapterAuthStore {
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+    async get(target) {
+        const record = await this.readRecord(target);
+        return record?.status === "connected" && record.bundle
+            ? sanitizeWorkbenchAdapterAuthBundle(record.bundle)
+            : null;
+    }
+    async put(bundle) {
+        const sanitized = sanitizeWorkbenchAdapterAuthBundle(bundle);
+        const existing = await this.readRecord(sanitized).catch(() => null);
+        const saved = {
+            ...sanitized,
+            version: Math.max(0, existing?.version ?? 0) + 1,
+            updatedAt: new Date().toISOString(),
+        };
+        await this.writeRecord({
+            target: normalizeWorkbenchAdapterAuthTarget(saved),
+            status: "connected",
+            version: saved.version,
+            updatedAt: saved.updatedAt,
+            bundle: saved,
+        });
+        return saved;
+    }
+    async disconnect(target, reason = "disconnected") {
+        const normalized = normalizeWorkbenchAdapterAuthTarget(target);
+        const existing = await this.readRecord(normalized).catch(() => null);
+        await this.writeRecord({
+            target: normalized,
+            status: "disconnected",
+            version: Math.max(0, existing?.version ?? 0) + 1,
+            updatedAt: new Date().toISOString(),
+            reason,
+        });
+    }
+    async markReauthRequired(target, reason) {
+        const normalized = normalizeWorkbenchAdapterAuthTarget(target);
+        const existing = await this.readRecord(normalized).catch(() => null);
+        await this.writeRecord({
+            target: normalized,
+            status: "reauth_required",
+            version: Math.max(0, existing?.version ?? 0),
+            updatedAt: new Date().toISOString(),
+            reason,
+            bundle: existing?.bundle,
+        });
+    }
+    async status(target) {
+        const normalized = normalizeWorkbenchAdapterAuthTarget(target);
+        const record = await this.readRecord(normalized);
+        if (!record) {
+            return { ...normalized, status: "disconnected", version: 0 };
+        }
+        return statusFromRecord(record);
+    }
+    async listStatus() {
+        const files = await fs.readdir(this.root).catch(() => []);
+        const records = await Promise.all(files
+            .filter((file) => file.endsWith(".json"))
+            .map(async (file) => await this.readRecordFile(path.join(this.root, file))));
+        return records
+            .filter((record) => Boolean(record))
+            .map(statusFromRecord)
+            .sort((left, right) => adapterAuthTargetKey(left).localeCompare(adapterAuthTargetKey(right)));
+    }
+    async readRecord(target) {
+        return await this.readRecordFile(this.recordPath(target));
+    }
+    async readRecordFile(filePath) {
+        const source = await fs.readFile(filePath, "utf8").catch((error) => {
+            if (error.code === "ENOENT") {
+                return null;
+            }
+            throw error;
+        });
+        if (source === null) {
+            return null;
+        }
+        const parsed = JSON.parse(source);
+        return parsed?.target ? parsed : null;
+    }
+    async writeRecord(record) {
+        await fs.mkdir(this.root, { recursive: true, mode: 0o700 });
+        await fs.writeFile(this.recordPath(record.target), `${JSON.stringify(record, null, 2)}\n`, {
+            mode: 0o600,
+        });
+    }
+    recordPath(target) {
+        return path.join(this.root, `${adapterAuthTargetKey(target)}.json`);
+    }
+}
+function statusFromRecord(record) {
+    return {
+        ...record.target,
+        status: record.status,
+        version: record.version,
+        ...(record.bundle?.method ? { method: record.bundle.method } : {}),
+        ...(record.updatedAt ? { updatedAt: record.updatedAt } : {}),
+        ...(record.reason ? { reason: record.reason } : {}),
+    };
+}
+function adapterAuthTargetKey(target) {
+    return [
+        target.adapterId,
+        target.slot ?? "_",
+        target.profile,
+    ].join("__");
+}
+function sanitizeWorkbenchAdapterAuthFile(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Adapter auth file must be an object.");
+    }
+    const record = value;
+    const filePath = readString(record.path, "file.path").replace(/\\/gu, "/").replace(/^\/+/u, "");
+    if (!filePath || filePath.split("/").some((part) => part === "." || part === ".." || part === "")) {
+        throw new Error(`Unsafe adapter auth file path: ${filePath}`);
+    }
+    return {
+        path: filePath,
+        content: readString(record.content, "file.content"),
+        encoding: record.encoding === "base64" ? "base64" : "utf8",
+        ...(typeof record.mode === "number" && Number.isInteger(record.mode) ? { mode: record.mode } : {}),
+    };
+}
+function sanitizeWorkbenchAdapterAuthEnvVar(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("Adapter auth env entry must be an object.");
+    }
+    const record = value;
+    const name = readString(record.name, "env.name");
+    const envValue = readString(record.value, "env.value");
+    if (!/^[A-Z_][A-Z0-9_]*$/u.test(name)) {
+        throw new Error(`Adapter auth env var is invalid: ${name}`);
+    }
+    if (!envValue.trim()) {
+        throw new Error(`Adapter auth env var ${name} is empty.`);
+    }
+    return { name, value: envValue };
+}
+function readString(value, label) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`Adapter auth ${label} must be a non-empty string.`);
+    }
+    return value;
+}
+function readAdapterAuthSegment(value, label) {
+    if (!/^[a-z][a-z0-9-]*$/u.test(value)) {
+        throw new Error(`Adapter auth ${label} must be a lowercase identifier.`);
+    }
+    return value;
+}

package/dist/execution-events.d.ts

@@ -0,0 +1,53 @@
+import type { Json, WorkbenchExecutionEvent, WorkbenchExecutionEventBatch, WorkbenchExecutionEventSource } from "@workbench-ai/workbench-contract";
+export interface WorkbenchExecutionProgressTarget {
+    url: string;
+    token: string;
+    ownerUserId?: string;
+    flushWindowMs?: number;
+    transport?: "http" | "stdout" | "both";
+}
+export interface WorkbenchExecutionEventPublisherContext {
+    projectId: string;
+    runId: string;
+    jobId: string;
+    executionId: string;
+    attempt: number;
+    target?: WorkbenchExecutionProgressTarget;
+}
+export interface WorkbenchExecutionEventInput {
+    at?: string;
+    source: WorkbenchExecutionEventSource;
+    role?: WorkbenchExecutionEvent["role"];
+    schema: WorkbenchExecutionEvent["schema"];
+    payload: Json;
+}
+export interface WorkbenchExecutionEventPublisher {
+    readonly enabled: boolean;
+    readonly flushWindowMs?: number;
+    publish(events: readonly WorkbenchExecutionEventInput[]): Promise<void>;
+    flush(): Promise<void>;
+}
+export declare const WORKBENCH_PROGRESS_STDOUT_PREFIX = "__WORKBENCH_PROGRESS__";
+export declare function createWorkbenchExecutionEventPublisher(context: WorkbenchExecutionEventPublisherContext): WorkbenchExecutionEventPublisher;
+export declare function publishCommandPhaseEvent(publisher: WorkbenchExecutionEventPublisher | undefined, args: {
+    phase: string;
+    status: "started" | "succeeded" | "failed";
+    role?: WorkbenchExecutionEvent["role"];
+    exitCode?: number;
+    error?: string;
+}): Promise<void>;
+export interface WorkbenchProgressStdoutEnvelope {
+    url: string;
+    body: {
+        type: "workbench.job.progress";
+        ownerUserId?: string;
+        progressToken: string;
+        batch: WorkbenchExecutionEventBatch;
+    };
+}
+export declare function createWorkbenchProgressStdoutParser(onEnvelope: (envelope: WorkbenchProgressStdoutEnvelope) => void): {
+    write(chunk: Buffer | string): void;
+    flush(): void;
+};
+export declare function publishWorkbenchProgressStdoutEnvelope(envelope: WorkbenchProgressStdoutEnvelope): Promise<void>;
+//# sourceMappingURL=execution-events.d.ts.map

package/dist/execution-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-events.d.ts","sourceRoot":"","sources":["../src/execution-events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,IAAI,EACJ,uBAAuB,EACvB,4BAA4B,EAC5B,6BAA6B,EAC9B,MAAM,kCAAkC,CAAC;AAE1C,MAAM,WAAW,gCAAgC;IAC/C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAC;CACxC;AAED,MAAM,WAAW,uCAAuC;IACtD,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,gCAAgC,CAAC;CAC3C;AAED,MAAM,WAAW,4BAA4B;IAC3C,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,6BAA6B,CAAC;IACtC,IAAI,CAAC,EAAE,uBAAuB,CAAC,MAAM,CAAC,CAAC;IACvC,MAAM,EAAE,uBAAuB,CAAC,QAAQ,CAAC,CAAC;IAC1C,OAAO,EAAE,IAAI,CAAC;CACf;AAED,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,OAAO,CAAC,MAAM,EAAE,SAAS,4BAA4B,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxE,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,eAAO,MAAM,gCAAgC,2BAA2B,CAAC;AAEzE,wBAAgB,sCAAsC,CACpD,OAAO,EAAE,uCAAuC,GAC/C,gCAAgC,CAsClC;AAED,wBAAsB,wBAAwB,CAC5C,SAAS,EAAE,gCAAgC,GAAG,SAAS,EACvD,IAAI,EAAE;IACJ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,SAAS,GAAG,WAAW,GAAG,QAAQ,CAAC;IAC3C,IAAI,CAAC,EAAE,uBAAuB,CAAC,MAAM,CAAC,CAAC;IACvC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GACA,OAAO,CAAC,IAAI,CAAC,CAef;AAyCD,MAAM,WAAW,+BAA+B;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE;QACJ,IAAI,EAAE,wBAAwB,CAAC;QAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,aAAa,EAAE,MAAM,CAAC;QACtB,KAAK,EAAE,4BAA4B,CAAC;KACrC,CAAC;CACH;AAED,wBAAgB,mCAAmC,CACjD,UAAU,EAAE,CAAC,QAAQ,EAAE,+BAA+B,KAAK,IAAI,GAC9D;IACD,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACpC,KAAK,IAAI,IAAI,CAAC;CACf,CA0DA;AAED,wBAAsB,sCAAsC,CAC1D,QAAQ,EAAE,+BAA+B,GACxC,OAAO,CAAC,IAAI,CAAC,CAEf"}

package/dist/execution-events.js

@@ -0,0 +1,195 @@
+export const WORKBENCH_PROGRESS_STDOUT_PREFIX = "__WORKBENCH_PROGRESS__";
+export function createWorkbenchExecutionEventPublisher(context) {
+    const target = validProgressTarget(context.target);
+    if (!target) {
+        return NOOP_EXECUTION_EVENT_PUBLISHER;
+    }
+    let seq = 0;
+    return {
+        enabled: true,
+        flushWindowMs: target.flushWindowMs,
+        async publish(inputs) {
+            if (inputs.length === 0) {
+                return;
+            }
+            const events = inputs.map((input) => ({
+                seq: ++seq,
+                at: input.at ?? new Date().toISOString(),
+                source: input.source,
+                ...(input.role ? { role: input.role } : {}),
+                schema: input.schema,
+                payload: input.payload,
+            }));
+            const batch = {
+                projectId: context.projectId,
+                runId: context.runId,
+                jobId: context.jobId,
+                executionId: context.executionId,
+                attempt: Math.max(1, Math.floor(context.attempt || 1)),
+                seqStart: events[0].seq,
+                seqEnd: events[events.length - 1].seq,
+                emittedAt: new Date().toISOString(),
+                events,
+            };
+            await publishProgressBatch(target, batch);
+        },
+        async flush() {
+            return;
+        },
+    };
+}
+export async function publishCommandPhaseEvent(publisher, args) {
+    if (!publisher?.enabled) {
+        return;
+    }
+    await publisher.publish([{
+            source: "command",
+            ...(args.role ? { role: args.role } : {}),
+            schema: "workbench.execution.phase.v1",
+            payload: {
+                phase: args.phase,
+                status: args.status,
+                ...(typeof args.exitCode === "number" ? { exitCode: args.exitCode } : {}),
+                ...(args.error ? { error: args.error } : {}),
+            },
+        }]).catch(() => undefined);
+}
+const NOOP_EXECUTION_EVENT_PUBLISHER = {
+    enabled: false,
+    async publish() {
+        return;
+    },
+    async flush() {
+        return;
+    },
+};
+function validProgressTarget(target) {
+    if (!target?.url.trim() || !target.token.trim()) {
+        return null;
+    }
+    return {
+        url: target.url.trim(),
+        token: target.token,
+        ...(typeof target.ownerUserId === "string" && target.ownerUserId.trim() ? { ownerUserId: target.ownerUserId.trim() } : {}),
+        ...(typeof target.flushWindowMs === "number" && Number.isFinite(target.flushWindowMs) && target.flushWindowMs >= 0
+            ? { flushWindowMs: target.flushWindowMs }
+            : {}),
+        ...(target.transport === "stdout" || target.transport === "both" ? { transport: target.transport } : { transport: "http" }),
+    };
+}
+async function publishProgressBatch(target, batch) {
+    const envelope = progressStdoutEnvelope(target, batch);
+    if (target.transport === "stdout" || target.transport === "both") {
+        process.stdout.write(`${WORKBENCH_PROGRESS_STDOUT_PREFIX}${JSON.stringify(envelope)}\n`);
+    }
+    if (target.transport === "stdout") {
+        return;
+    }
+    await postProgressBody(envelope);
+}
+export function createWorkbenchProgressStdoutParser(onEnvelope) {
+    let buffer = "";
+    const consumeRawEnvelope = (rawEnvelope) => {
+        const raw = rawEnvelope.trim();
+        if (!raw) {
+            return;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (isProgressStdoutEnvelope(parsed)) {
+                onEnvelope(parsed);
+            }
+        }
+        catch {
+            // Progress telemetry is best-effort and must not crash the sandbox host.
+        }
+    };
+    const drain = (final) => {
+        for (;;) {
+            const prefixIndex = buffer.indexOf(WORKBENCH_PROGRESS_STDOUT_PREFIX);
+            if (prefixIndex < 0) {
+                buffer = buffer.length > WORKBENCH_PROGRESS_STDOUT_PREFIX.length
+                    ? buffer.slice(-WORKBENCH_PROGRESS_STDOUT_PREFIX.length)
+                    : buffer;
+                return;
+            }
+            if (prefixIndex > 0) {
+                buffer = buffer.slice(prefixIndex);
+            }
+            const payloadStart = WORKBENCH_PROGRESS_STDOUT_PREFIX.length;
+            const delimiterIndex = firstExistingIndex([
+                buffer.indexOf("\n", payloadStart),
+                buffer.indexOf("\r", payloadStart),
+                buffer.indexOf(WORKBENCH_PROGRESS_STDOUT_PREFIX, payloadStart),
+            ]);
+            if (delimiterIndex < 0) {
+                if (!final) {
+                    return;
+                }
+                consumeRawEnvelope(buffer.slice(payloadStart));
+                buffer = "";
+                return;
+            }
+            consumeRawEnvelope(buffer.slice(payloadStart, delimiterIndex));
+            buffer = buffer.slice(delimiterIndex);
+            while (buffer.startsWith("\n") || buffer.startsWith("\r")) {
+                buffer = buffer.slice(1);
+            }
+        }
+    };
+    return {
+        write(chunk) {
+            buffer += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : chunk;
+            drain(false);
+        },
+        flush() {
+            drain(true);
+        },
+    };
+}
+export async function publishWorkbenchProgressStdoutEnvelope(envelope) {
+    await postProgressBody(envelope);
+}
+function firstExistingIndex(indexes) {
+    return indexes.filter((index) => index >= 0).sort((a, b) => a - b)[0] ?? -1;
+}
+function progressStdoutEnvelope(target, batch) {
+    return {
+        url: target.url,
+        body: {
+            type: "workbench.job.progress",
+            ...(target.ownerUserId ? { ownerUserId: target.ownerUserId } : {}),
+            progressToken: target.token,
+            batch,
+        },
+    };
+}
+async function postProgressBody(envelope) {
+    const response = await fetch(envelope.url, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+        },
+        body: JSON.stringify(envelope.body),
+    });
+    if (!response.ok) {
+        throw new Error(`Workbench progress publish failed with HTTP ${response.status}.`);
+    }
+}
+function isProgressStdoutEnvelope(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const record = value;
+    if (typeof record.url !== "string" || record.url.length === 0) {
+        return false;
+    }
+    const body = record.body;
+    if (!body || typeof body !== "object" || Array.isArray(body)) {
+        return false;
+    }
+    const bodyRecord = body;
+    return bodyRecord.type === "workbench.job.progress"
+        && typeof bodyRecord.progressToken === "string"
+        && Boolean(bodyRecord.batch);
+}

package/dist/execution-graph.d.ts

@@ -0,0 +1,27 @@
+import type { WorkbenchExecutionSpec } from "@workbench-ai/workbench-contract";
+import { type GenericRunSpec, type GenericEngineCaseSpec } from "./generic-spec.ts";
+export interface CompileExecutionGraphInput {
+    ownerUserId: string;
+    projectId: string;
+    runId: string;
+    subjectId: string;
+    attemptIndex: number;
+    sampleIndex?: number;
+    caseId?: string;
+    engineCase?: GenericEngineCaseSpec;
+    spec: GenericRunSpec;
+    workflow?: "eval" | "improve";
+    subjectRef?: string;
+    caseRef?: string;
+    environmentRef?: string;
+}
+export interface WorkbenchExecutionGraph {
+    nodes: WorkbenchExecutionGraphNode[];
+    executions: WorkbenchExecutionSpec[];
+}
+export interface WorkbenchExecutionGraphNode {
+    execution: WorkbenchExecutionSpec;
+    dependsOn: string[];
+}
+export declare function compileWorkbenchExecutionGraph(input: CompileExecutionGraphInput): WorkbenchExecutionGraph;
+//# sourceMappingURL=execution-graph.d.ts.map

package/dist/execution-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-graph.d.ts","sourceRoot":"","sources":["../src/execution-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,sBAAsB,EAEvB,MAAM,kCAAkC,CAAC;AAE1C,OAAO,EAKL,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAE3B,MAAM,mBAAmB,CAAC;AAE3B,MAAM,WAAW,0BAA0B;IACzC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,qBAAqB,CAAC;IACnC,IAAI,EAAE,cAAc,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,2BAA2B,EAAE,CAAC;IACrC,UAAU,EAAE,sBAAsB,EAAE,CAAC;CACtC;AAED,MAAM,WAAW,2BAA2B;IAC1C,SAAS,EAAE,sBAAsB,CAAC;IAClC,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,0BAA0B,GAAG,uBAAuB,CAoEzG"}