@workbench-ai/workbench-built-in-adapters 0.0.46

package/dist/agent-turn.d.ts

@@ -0,0 +1,31 @@
+import type { SurfaceSnapshotFile, UsageSummary } from "@workbench-ai/workbench-contract";
+import { type JsonValue } from "@workbench-ai/agent-driver";
+import type { WorkbenchExecutionEventPublisher } from "@workbench-ai/workbench-core";
+export interface AgentProviderSpec {
+    use: string;
+    model?: string;
+    effort?: string;
+}
+export interface WorkbenchAgentTurnRequest {
+    role: "optimizer" | "runner" | "engine";
+    provider: AgentProviderSpec;
+    adapterAuthRoot?: string;
+    adapterAuthRequest?: JsonValue;
+    adapterAuthEnv?: Record<string, string>;
+    workspaceRoot: string;
+    cwd: string;
+    prompt: string;
+    traceRoot: string;
+    jobId: string;
+    eventPublisher?: WorkbenchExecutionEventPublisher;
+}
+export interface WorkbenchAgentTurnResult {
+    output: string;
+    traceFiles: SurfaceSnapshotFile[];
+    metadata: Record<string, JsonValue>;
+    usage?: UsageSummary;
+}
+export type WorkbenchAgentTurnExecutor = (request: WorkbenchAgentTurnRequest) => Promise<WorkbenchAgentTurnResult>;
+export declare function executeWorkbenchAgentTurn(executor: (request: WorkbenchAgentTurnRequest) => Promise<WorkbenchAgentTurnResult>, request: WorkbenchAgentTurnRequest): Promise<WorkbenchAgentTurnResult>;
+export declare function defaultWorkbenchAgentTurnExecutor(request: WorkbenchAgentTurnRequest): Promise<WorkbenchAgentTurnResult>;
+//# sourceMappingURL=agent-turn.d.ts.map

package/dist/agent-turn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-turn.d.ts","sourceRoot":"","sources":["../src/agent-turn.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAEV,mBAAmB,EACnB,YAAY,EACb,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAQL,KAAK,SAAS,EAEf,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EACV,gCAAgC,EACjC,MAAM,8BAA8B,CAAC;AAetC,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,yBAAyB;IACxC,IAAI,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;IACxC,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,kBAAkB,CAAC,EAAE,SAAS,CAAC;IAC/B,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,aAAa,EAAE,MAAM,CAAC;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,CAAC,EAAE,gCAAgC,CAAC;CACnD;AAED,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,mBAAmB,EAAE,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IACpC,KAAK,CAAC,EAAE,YAAY,CAAC;CACtB;AAED,MAAM,MAAM,0BAA0B,GAAG,CAAC,OAAO,EAAE,yBAAyB,KAAK,OAAO,CAAC,wBAAwB,CAAC,CAAC;AAoCnH,wBAAsB,yBAAyB,CAC7C,QAAQ,EAAE,CAAC,OAAO,EAAE,yBAAyB,KAAK,OAAO,CAAC,wBAAwB,CAAC,EACnF,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,wBAAwB,CAAC,CAenC;AAED,wBAAsB,iCAAiC,CACrD,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,wBAAwB,CAAC,CA2FnC"}

package/dist/agent-turn.js

@@ -0,0 +1,384 @@
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+import { DEFAULT_HARNESS_CANCEL, DEFAULT_HARNESS_RETRY, resolveRuntimeHome, } from "@workbench-ai/agent-driver";
+import { importWorkbenchRuntime } from "./runtime.js";
+const DEFAULT_AGENT_TURN_MAX_ATTEMPTS = 3;
+const DEFAULT_AGENT_TURN_RETRY_BASE_MS = 5_000;
+const DEFAULT_AGENT_TURN_RETRY_MAX_MS = 30_000;
+const AGENT_HARNESS_REGISTRY = {
+    codex: {
+        executable: "codex",
+        installHint: "@openai/codex",
+        defaultConfig: {
+            sandbox_mode: "danger-full-access",
+        },
+        async load() {
+            const module = await import("@workbench-ai/agent-driver-openai-codex");
+            return module.codexHarness();
+        },
+    },
+    claude: {
+        executable: "claude",
+        installHint: "@anthropic-ai/claude-code",
+        defaultConfig: {
+            max_turns: 64,
+            permission_mode: "bypassPermissions",
+        },
+        async load() {
+            const module = await import("@workbench-ai/agent-driver-anthropic-claude-code");
+            return module.claudeCodeHarness();
+        },
+    },
+    pi: {
+        executable: "pi",
+        installHint: "@mariozechner/pi-coding-agent",
+        async load() {
+            const module = await import("@workbench-ai/agent-driver-badlogic-pi-coding-agent");
+            return module.piCodingAgentHarness();
+        },
+    },
+};
+export async function executeWorkbenchAgentTurn(executor, request) {
+    const maxAttempts = workbenchAgentTurnMaxAttempts();
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        try {
+            return await executor(request);
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt >= maxAttempts || !isTransientAgentTurnError(error)) {
+                throw error;
+            }
+            await sleep(agentTurnRetryDelayMs(attempt));
+        }
+    }
+    throw lastError instanceof Error ? lastError : new Error(String(lastError ?? "Agent turn failed."));
+}
+export async function defaultWorkbenchAgentTurnExecutor(request) {
+    const execFileAsync = promisify(execFile);
+    await ensureAgentExecutableOnPath(request.provider.use, execFileAsync);
+    const provider = await loadAgentHarnessProvider(request.provider.use);
+    const agentHome = resolveRuntimeHome();
+    const stageSessionPath = path.join(request.traceRoot, "session");
+    await fs.mkdir(stageSessionPath, { recursive: true });
+    const restoreEnv = applyAdapterAuthEnv(request.adapterAuthEnv);
+    try {
+        const plan = await buildAgentHarnessExecutionPlan(provider, request.provider, request.workspaceRoot, agentHome, {
+            root: request.adapterAuthRoot,
+            request: request.adapterAuthRequest,
+        });
+        const readiness = await provider.checkReadiness?.({
+            repoRoot: request.workspaceRoot,
+            runtimeHome: agentHome,
+            plan,
+        });
+        const readinessErrors = readiness?.availability_errors ?? [];
+        if (readinessErrors.length > 0) {
+            throw new Error(readinessErrors.join("\n"));
+        }
+        const adapter = provider.create();
+        const stageId = `workbench-${request.role}`;
+        let activeSession = null;
+        try {
+            await fs.writeFile(path.join(stageSessionPath, "agent-request.json"), `${JSON.stringify({
+                role: request.role,
+                provider: request.provider.use,
+                workspaceRoot: request.workspaceRoot,
+                cwd: request.cwd,
+                jobId: request.jobId,
+            }, null, 2)}\n`);
+            activeSession = await adapter.startSession({
+                repoRoot: request.workspaceRoot,
+                runtimeHome: agentHome,
+                plan,
+                ownerId: "workbench",
+                executionId: createWorkbenchAgentTurnId("workbench_exec"),
+                attemptNumber: 1,
+                stageId,
+                stageRunIndex: 1,
+                workspacePath: request.cwd,
+                ownerStageId: stageId,
+                sessionMode: "fresh",
+                persistedSession: null,
+                stageSessionPath,
+            });
+            const runtime = await importWorkbenchRuntime();
+            const eventsFile = path.join(stageSessionPath, "events.ndjson");
+            const rawEventsFile = path.join(stageSessionPath, "raw-events.ndjson");
+            const turnResult = await adapter.startTurn(activeSession, {
+                prompt: request.prompt,
+                eventsFile,
+                rawEventsFile,
+                stageSpanId: createWorkbenchAgentTurnId("workbench_span"),
+                plan,
+                livePersistence: agentLivePersistenceForPublisher(request.eventPublisher, request.role),
+            });
+            const usage = runtime.extractExecutionUsageFromTrace(turnResult.trace, request.provider, provider.manifest.id, turnResult.events);
+            const eventCount = Math.max(turnResult.events.length, traceEventCount(turnResult.trace));
+            await writeAgentTraceFile(path.join(stageSessionPath, "trace.json"), turnResult.trace);
+            await fs.writeFile(path.join(stageSessionPath, "agent-result.json"), `${JSON.stringify({
+                sessionId: turnResult.sessionId,
+                finalOutput: turnResult.finalOutput,
+                eventCount,
+                ...(usage ? { usage } : {}),
+            }, null, 2)}\n`);
+            return {
+                output: turnResult.finalOutput,
+                traceFiles: await runtime.readOutputTraceFiles(request.traceRoot, `.workbench/traces/${request.jobId}/${request.role}`),
+                metadata: {
+                    providerId: provider.manifest.id,
+                    sessionId: turnResult.sessionId,
+                    eventCount,
+                },
+                ...(usage ? { usage } : {}),
+            };
+        }
+        finally {
+            if (activeSession) {
+                await activeSession.adapter.closeSession(activeSession).catch(() => undefined);
+            }
+        }
+    }
+    finally {
+        restoreEnv();
+    }
+}
+function agentLivePersistenceForPublisher(publisher, role) {
+    if (!publisher?.enabled) {
+        return undefined;
+    }
+    return {
+        ...(publisher.flushWindowMs ? { flushWindowMs: publisher.flushWindowMs } : {}),
+        async onFlush(batch) {
+            const traceBundle = batch.traceBundle;
+            if (traceBundle.spans.length === 0 &&
+                traceBundle.events.length === 0 &&
+                traceBundle.summaries.length === 0) {
+                return;
+            }
+            await publisher.publish([{
+                    source: "adapter",
+                    role,
+                    schema: "workbench.trace.delta.v1",
+                    payload: toJsonPayload(traceBundle),
+                }]).catch(() => undefined);
+        },
+    };
+}
+function createWorkbenchAgentTurnId(prefix) {
+    return `${prefix}_${randomUUID().replace(/-/gu, "")}`;
+}
+async function writeAgentTraceFile(filePath, trace) {
+    try {
+        await fs.writeFile(filePath, `${JSON.stringify(trace, null, 2)}\n`);
+    }
+    catch {
+        // Trace files are diagnostic only; the agent turn result remains authoritative.
+    }
+}
+function traceEventCount(trace) {
+    const traceRecord = trace && typeof trace === "object" && !Array.isArray(trace)
+        ? trace
+        : {};
+    return Array.isArray(traceRecord.events) ? traceRecord.events.length : 0;
+}
+async function loadAgentHarnessProvider(providerName) {
+    return await agentHarnessRegistration(providerName).load();
+}
+async function ensureAgentExecutableOnPath(providerName, execFileAsync) {
+    const executable = agentExecutableName(providerName);
+    try {
+        await execFileAsync("sh", ["-c", `command -v ${quoteShellArg(executable)} >/dev/null 2>&1`], {
+            maxBuffer: 1024 * 1024,
+            timeout: 5_000,
+        });
+    }
+    catch {
+        throw new Error(`Agent provider "${providerName}" requires "${executable}" on PATH. Install ${agentExecutableInstallHint(providerName)} in the adapter runtime.`);
+    }
+}
+function agentExecutableName(providerName) {
+    return agentHarnessRegistration(providerName).executable;
+}
+function agentExecutableInstallHint(providerName) {
+    return agentHarnessRegistration(providerName).installHint;
+}
+function agentHarnessRegistration(providerName) {
+    const registration = AGENT_HARNESS_REGISTRY[providerName];
+    if (!registration) {
+        throw new Error(`Unsupported first-party agent adapter: ${providerName}`);
+    }
+    return registration;
+}
+async function buildAgentHarnessExecutionPlan(provider, providerSpec, workspaceRoot, agentHome, adapterAuth) {
+    const turnTimeoutMs = provider.manifest.defaults.turn_timeout_ms ?? 3_600_000;
+    const harness = {
+        id: provider.manifest.id,
+        auth: await resolveAgentHarnessAuth(provider, providerSpec, workspaceRoot, agentHome, adapterAuth),
+        ...(firstNonEmpty(providerSpec.model, provider.manifest.defaults.model) ? { model: firstNonEmpty(providerSpec.model, provider.manifest.defaults.model) } : {}),
+        ...(firstNonEmpty(providerSpec.effort, provider.manifest.defaults.effort) ? { effort: firstNonEmpty(providerSpec.effort, provider.manifest.defaults.effort) } : {}),
+        turn_timeout_ms: turnTimeoutMs,
+        stall_timeout_ms: Math.max(provider.manifest.defaults.stall_timeout_ms ?? 0, turnTimeoutMs),
+        config: resolveAgentHarnessConfig(provider, defaultWorkbenchAgentHarnessConfig(provider, providerSpec.use)),
+        retry: DEFAULT_HARNESS_RETRY,
+        cancel: DEFAULT_HARNESS_CANCEL,
+    };
+    return {
+        workspace: {
+            mode: "project",
+            prune_ttl_seconds: 604_800,
+        },
+        harness,
+    };
+}
+function defaultWorkbenchAgentHarnessConfig(provider, providerName) {
+    const fallback = (provider.manifest.defaults.config ?? {});
+    return {
+        ...fallback,
+        ...(AGENT_HARNESS_REGISTRY[providerName]?.defaultConfig ?? {}),
+    };
+}
+async function resolveAgentHarnessAuth(provider, providerSpec, workspaceRoot, agentHome, adapterAuth) {
+    const subject = adapterAuthHarnessSubject(adapterAuth.request, providerSpec.use) ??
+        (provider.manifest.defaults.auth ?? {});
+    const parsed = provider.schemas.auth.safeParse(subject);
+    if (!parsed.success) {
+        throw new Error(`Agent provider "${provider.manifest.id}" auth is invalid: ${formatValidationIssues(parsed.error.issues)}`);
+    }
+    void workspaceRoot;
+    void agentHome;
+    return { ...parsed.data };
+}
+function adapterAuthHarnessSubject(auth, providerName) {
+    const record = jsonRecord(auth);
+    const self = jsonRecord(record?.self);
+    const adapters = jsonRecord(record?.adapters);
+    const provider = jsonRecord(adapters?.[providerName]);
+    const entry = jsonRecord(self?.default) ??
+        jsonRecord(provider?.default) ??
+        jsonRecord(record?.default);
+    if (!entry) {
+        return null;
+    }
+    const method = typeof entry.method === "string" ? entry.method : "";
+    if (method === "bedrock") {
+        return { strategy: "bedrock_env" };
+    }
+    const filesRoot = typeof entry.filesRoot === "string" ? entry.filesRoot : "";
+    if (filesRoot) {
+        return {
+            strategy: "profile_path",
+            path: filesRoot,
+        };
+    }
+    const env = jsonRecord(entry.env);
+    const [envName] = Object.keys(env ?? {}).sort();
+    if (envName) {
+        return {
+            strategy: "secret_ref",
+            ref: envName,
+        };
+    }
+    return null;
+}
+function resolveAgentHarnessConfig(provider, fallback) {
+    const parsed = provider.schemas.config.safeParse(fallback);
+    if (!parsed.success) {
+        throw new Error(`Agent provider "${provider.manifest.id}" config is invalid: ${formatValidationIssues(parsed.error.issues)}`);
+    }
+    return { ...parsed.data };
+}
+function applyAdapterAuthEnv(env) {
+    if (!env || Object.keys(env).length === 0) {
+        return () => undefined;
+    }
+    const previous = new Map();
+    for (const [name, value] of Object.entries(env)) {
+        previous.set(name, process.env[name]);
+        process.env[name] = value;
+    }
+    return () => {
+        for (const [name, value] of previous) {
+            if (value === undefined) {
+                delete process.env[name];
+            }
+            else {
+                process.env[name] = value;
+            }
+        }
+    };
+}
+function jsonRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : null;
+}
+function toJsonPayload(value) {
+    const normalized = JSON.parse(JSON.stringify(value ?? null));
+    return isJsonValue(normalized) ? normalized : null;
+}
+function isJsonValue(value) {
+    if (value === null ||
+        typeof value === "string" ||
+        typeof value === "boolean" ||
+        (typeof value === "number" && Number.isFinite(value))) {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        return value.every(isJsonValue);
+    }
+    return value !== null &&
+        typeof value === "object" &&
+        Object.values(value).every(isJsonValue);
+}
+function workbenchAgentTurnMaxAttempts() {
+    const raw = Number.parseInt(process.env.WORKBENCH_AGENT_TURN_MAX_ATTEMPTS ?? "", 10);
+    return Number.isSafeInteger(raw) && raw > 0 ? raw : DEFAULT_AGENT_TURN_MAX_ATTEMPTS;
+}
+function agentTurnRetryDelayMs(attempt) {
+    const fallback = process.env.NODE_ENV === "test" ? 1 : DEFAULT_AGENT_TURN_RETRY_BASE_MS;
+    const raw = Number.parseInt(process.env.WORKBENCH_AGENT_TURN_RETRY_BASE_MS ?? "", 10);
+    const baseDelay = Number.isSafeInteger(raw) && raw >= 0 ? raw : fallback;
+    return Math.min(baseDelay * 2 ** Math.max(0, attempt - 1), DEFAULT_AGENT_TURN_RETRY_MAX_MS);
+}
+function isTransientAgentTurnError(error) {
+    const message = error instanceof Error
+        ? `${error.message}\n${error.stack ?? ""}\n${String(error.cause ?? "")}`
+        : String(error);
+    if (isNativeCaCertificateFailure(message)) {
+        return false;
+    }
+    return /\b(fetch failed|error sending request|stream disconnected before completion|ECONNRESET|ETIMEDOUT|EAI_AGAIN|ENETUNREACH|ECONNREFUSED|socket hang up|network error|UND_ERR_|signal SIGTERM)/iu.test(message);
+}
+function isNativeCaCertificateFailure(message) {
+    return /\bno native root CA certificates found\b|install ca-certificates/iu.test(message);
+}
+async function sleep(ms) {
+    if (ms <= 0) {
+        return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+function firstNonEmpty(...values) {
+    for (const value of values) {
+        if (typeof value === "string" && value.length > 0) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function formatValidationIssues(issues) {
+    return issues
+        .map((issue) => {
+        const issuePath = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+        return `${issuePath}: ${issue.message}`;
+    })
+        .join("; ");
+}
+function quoteShellArg(value) {
+    return `'${value.replace(/'/gu, "'\\''")}'`;
+}

package/dist/bin/claude.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=claude.d.ts.map

package/dist/bin/claude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude.d.ts","sourceRoot":"","sources":["../../src/bin/claude.ts"],"names":[],"mappings":""}

package/dist/bin/claude.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { executeWorkbenchBuiltInAdapterCommand } from "../execute.js";
+await executeWorkbenchBuiltInAdapterCommand({ adapterId: "claude" });

package/dist/bin/codex.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=codex.d.ts.map

package/dist/bin/codex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../src/bin/codex.ts"],"names":[],"mappings":""}

package/dist/bin/codex.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { executeWorkbenchBuiltInAdapterCommand } from "../execute.js";
+await executeWorkbenchBuiltInAdapterCommand({ adapterId: "codex" });

package/dist/bin/command.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=command.d.ts.map

package/dist/bin/command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../src/bin/command.ts"],"names":[],"mappings":""}

package/dist/bin/command.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { executeWorkbenchBuiltInAdapterCommand } from "../execute.js";
+await executeWorkbenchBuiltInAdapterCommand({ adapterId: "command" });

package/dist/bin/pi.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=pi.d.ts.map

package/dist/bin/pi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pi.d.ts","sourceRoot":"","sources":["../../src/bin/pi.ts"],"names":[],"mappings":""}

package/dist/bin/pi.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { executeWorkbenchBuiltInAdapterCommand } from "../execute.js";
+await executeWorkbenchBuiltInAdapterCommand({ adapterId: "pi" });

package/dist/bin/rubric.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=rubric.d.ts.map

package/dist/bin/rubric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rubric.d.ts","sourceRoot":"","sources":["../../src/bin/rubric.ts"],"names":[],"mappings":""}

package/dist/bin/rubric.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { executeWorkbenchBuiltInAdapterCommand } from "../execute.js";
+await executeWorkbenchBuiltInAdapterCommand({ adapterId: "rubric" });

package/dist/bin/tests.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=tests.d.ts.map

package/dist/bin/tests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tests.d.ts","sourceRoot":"","sources":["../../src/bin/tests.ts"],"names":[],"mappings":""}

package/dist/bin/tests.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { executeWorkbenchBuiltInAdapterCommand } from "../execute.js";
+await executeWorkbenchBuiltInAdapterCommand({ adapterId: "tests" });

package/dist/bin/workbench.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=workbench.d.ts.map

package/dist/bin/workbench.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workbench.d.ts","sourceRoot":"","sources":["../../src/bin/workbench.ts"],"names":[],"mappings":""}

package/dist/bin/workbench.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { executeWorkbenchBuiltInAdapterCommand } from "../execute.js";
+await executeWorkbenchBuiltInAdapterCommand({ adapterId: "workbench" });

package/dist/execute.d.ts

@@ -0,0 +1,13 @@
+import type { Json } from "@workbench-ai/workbench-contract";
+import type { WorkbenchAgentTurnExecutor } from "./agent-turn.ts";
+export interface ExecuteWorkbenchBuiltInAdapterCommandOptions {
+    adapterId?: string;
+    requestPath?: string;
+    outputRoot?: string;
+    agentExecutor?: WorkbenchAgentTurnExecutor;
+    adapterAuthRoot?: string;
+    adapterAuthRequest?: Json;
+    adapterAuthEnv?: Record<string, string>;
+}
+export declare function executeWorkbenchBuiltInAdapterCommand(args?: ExecuteWorkbenchBuiltInAdapterCommandOptions): Promise<void>;
+//# sourceMappingURL=execute.d.ts.map

package/dist/execute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute.d.ts","sourceRoot":"","sources":["../src/execute.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAEV,IAAI,EAKL,MAAM,kCAAkC,CAAC;AAY1C,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;AA4CD,wBAAsB,qCAAqC,CACzD,IAAI,GAAE,4CAAiD,GACtD,OAAO,CAAC,IAAI,CAAC,CAiEf"}