@wrenai/genbi 0.0.1

package/dist-server/harness/native-producer/index.js

@@ -0,0 +1,302 @@
+/**
+ * Host-owned contract for deterministic, noninteractive dispatch.  This is
+ * intentionally not the interactive terminal protocol: it contains no bytes
+ * from a PTY, dispatcher stream, prompt, tool input/output, or credential.
+ */
+export const NATIVE_PRODUCER_VERSION = "1";
+const MAX_RESULT_TEXT = 16 * 1024;
+const MAX_CASSETTE_BYTES = 64 * 1024;
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+const SAFE_DIGEST = /^sha256:[a-f0-9]{64}$/;
+/** Stable, prompt-free cassette selector for one host-owned idempotent run. */
+export function nativeProducerCassetteKey(request) {
+    return `${request.vendor}__${request.agentId}__${request.idempotencyKey}`;
+}
+/** Runs one noninteractive dispatch and always returns a typed, fail-closed response. */
+export async function produceNoninteractiveNative(request, options) {
+    const parsed = validateRequest(request);
+    if (parsed === undefined)
+        return failed("invalid_request");
+    if (parsed.version !== NATIVE_PRODUCER_VERSION)
+        return failed("unsupported_version");
+    if (parsed.scope.bindingDigest !== options.fence.bindingDigest || !options.fence.validateRun(parsed))
+        return failed("scope_mismatch");
+    if (options.signal?.aborted)
+        return failed("cancelled");
+    const controller = new AbortController();
+    const timeoutMs = options.timeoutMs ?? 10 * 60 * 1000;
+    let stop;
+    const timeout = setTimeout(() => {
+        stop = "timeout";
+        controller.abort();
+    }, timeoutMs);
+    const cancel = () => {
+        stop = "cancelled";
+        controller.abort();
+    };
+    options.signal?.addEventListener("abort", cancel, { once: true });
+    const events = [];
+    try {
+        const dispatch = options.dispatch({
+            vendor: parsed.vendor,
+            agentId: parsed.agentId,
+            input: parsed.input,
+            scope: parsed.scope,
+            idempotencyKey: parsed.idempotencyKey,
+            signal: controller.signal,
+            fence: options.fence,
+            // Keep the private, potentially rich event stream inside the host. The
+            // bounded public lifecycle below is intentionally synthesized instead.
+            onEvent: (event) => events.push(event),
+        });
+        const result = await awaitWithAbort(dispatch, controller.signal);
+        if (stop === "timeout")
+            return failed("timeout");
+        if (!options.fence.validateRun(parsed))
+            return failed("scope_mismatch");
+        return complete(result, parsed, options.fence);
+    }
+    catch (error) {
+        if (stop === "timeout")
+            return failed("timeout");
+        if (isAbortError(error) || controller.signal.aborted)
+            return failed("cancelled");
+        return failed("producer_failed");
+    }
+    finally {
+        clearTimeout(timeout);
+        options.signal?.removeEventListener("abort", cancel);
+        // The dispatcher callback is intentionally retained only until completion.
+        events.length = 0;
+    }
+}
+/** Replays a sanitized producer cassette; absence, drift, and scope changes fail closed. */
+export function replayNoninteractiveNative(request, cassette, fence) {
+    const parsed = validateRequest(request);
+    if (parsed === undefined)
+        return failed("invalid_request");
+    if (parsed.version !== NATIVE_PRODUCER_VERSION)
+        return failed("unsupported_version");
+    const parsedCassette = validateCassette(cassette, parsed.input);
+    if (isRecord(cassette) && typeof cassette.version === "string" && cassette.version !== NATIVE_PRODUCER_VERSION) {
+        return failed("unsupported_version");
+    }
+    if (parsedCassette === undefined)
+        return failed("missing_replay");
+    if (parsed.scope.bindingDigest !== fence.bindingDigest || !fence.validateRun(parsed))
+        return failed("scope_mismatch");
+    if (parsedCassette.version !== NATIVE_PRODUCER_VERSION)
+        return failed("unsupported_version");
+    if (parsedCassette.vendor !== parsed.vendor ||
+        parsedCassette.agentId !== parsed.agentId ||
+        !sameScope(parsedCassette.scope, parsed.scope))
+        return failed("scope_mismatch");
+    if (parsedCassette.key !== nativeProducerCassetteKey(parsed))
+        return failed("missing_replay");
+    if (parsedCassette.response.status === "completed" && !parsedCassette.response.artifacts.every((artifact) => fence.validateArtifact(artifact, parsed))) {
+        return failed("scope_mismatch");
+    }
+    return parsedCassette.response;
+}
+/** Creates a checked-in/replayable record only from an already-safe response. */
+export function createNativeProducerCassette(key, request, response, fence) {
+    const parsed = validateRequest(request);
+    const parsedResponse = validateResponse(response, parsed?.input);
+    if (!parsed || !parsedResponse || parsed.scope.bindingDigest !== fence.bindingDigest || !fence.validateRun(parsed) || !SAFE_ID.test(key) || (parsedResponse.status === "completed" && !parsedResponse.artifacts.every((artifact) => fence.validateArtifact(artifact, parsed)))) {
+        throw new Error("native producer cassette is invalid");
+    }
+    if (key !== nativeProducerCassetteKey(parsed)) {
+        throw new Error("native producer cassette key does not match its idempotent request");
+    }
+    const cassette = {
+        version: NATIVE_PRODUCER_VERSION,
+        key,
+        vendor: parsed.vendor,
+        agentId: parsed.agentId,
+        scope: parsed.scope,
+        response: parsedResponse,
+    };
+    if (Buffer.byteLength(JSON.stringify(cassette)) > MAX_CASSETTE_BYTES) {
+        throw new Error("native producer cassette exceeds its bounded contract");
+    }
+    return cassette;
+}
+/**
+ * Adapts existing subscription dispatchers without widening their protocol.
+ * The native producer only admits the vendor selected by the route options.
+ */
+export function createRouteNativeProducer(route, baseOptions) {
+    return async (input) => {
+        const choice = baseOptions.authChoice;
+        if (choice.mode !== "subscription" || choice.provider !== input.vendor) {
+            throw new Error("native producer vendor does not match the configured route");
+        }
+        const request = {
+            version: NATIVE_PRODUCER_VERSION,
+            vendor: input.vendor,
+            agentId: input.agentId,
+            input: input.input,
+            scope: input.scope,
+            idempotencyKey: input.idempotencyKey,
+        };
+        if (!input.fence.validateRoute(request, baseOptions.userProject)) {
+            throw new Error("native producer route fence rejected the request");
+        }
+        const result = await route({
+            ...baseOptions,
+            question: input.input,
+            agentId: input.agentId,
+            onEvent: input.onEvent,
+            signal: input.signal,
+        });
+        return { text: resultText(result) };
+    };
+}
+function resultText(result) {
+    if (result.backend === "agent") {
+        if (result.kind === "refusal")
+            throw new Error("producer refused result");
+        return JSON.stringify(result.envelope);
+    }
+    return result.finalText;
+}
+function complete(value, request, fence) {
+    if (!isRecord(value) || typeof value.text !== "string" || !value.text.trim())
+        return failed("malformed_output");
+    const text = sanitizeResultText(value.text, request.input);
+    if (text === undefined)
+        return failed("malformed_output");
+    const artifacts = value.artifacts === undefined ? [] : value.artifacts;
+    if (!Array.isArray(artifacts) || !artifacts.every((artifact) => validArtifact(artifact) && fence.validateArtifact(artifact, request))) {
+        return failed("malformed_output");
+    }
+    const rebuiltArtifacts = rebuildArtifacts(artifacts);
+    if (!rebuiltArtifacts)
+        return failed("malformed_output");
+    return {
+        version: NATIVE_PRODUCER_VERSION,
+        status: "completed",
+        lifecycle: [{ state: "accepted" }, { state: "running" }, { state: "completed" }],
+        result: { text },
+        artifacts: rebuiltArtifacts,
+    };
+}
+function failed(code) {
+    return {
+        version: NATIVE_PRODUCER_VERSION,
+        status: "failed",
+        lifecycle: [{ state: "accepted" }, { state: "running" }, { state: "failed" }],
+        error: { code },
+        artifacts: [],
+    };
+}
+function validateRequest(value) {
+    if (!isRecord(value) || !onlyKeys(value, ["version", "vendor", "agentId", "input", "scope", "idempotencyKey"]))
+        return undefined;
+    if (typeof value.version !== "string" || (value.vendor !== "claude" && value.vendor !== "codex") || typeof value.agentId !== "string" || typeof value.input !== "string" || typeof value.idempotencyKey !== "string")
+        return undefined;
+    if (!SAFE_ID.test(value.agentId) || !SAFE_ID.test(value.idempotencyKey) || value.input.length === 0 || value.input.length > MAX_RESULT_TEXT)
+        return undefined;
+    const scope = validateScope(value.scope);
+    if (!scope)
+        return undefined;
+    return { version: value.version, vendor: value.vendor, agentId: value.agentId, input: value.input, scope, idempotencyKey: value.idempotencyKey };
+}
+function validateCassette(value, prompt) {
+    if (!isRecord(value) || !onlyKeys(value, ["version", "key", "vendor", "agentId", "scope", "response"]))
+        return undefined;
+    if (value.version !== NATIVE_PRODUCER_VERSION || !SAFE_ID.test(String(value.key)) || (value.vendor !== "claude" && value.vendor !== "codex") || !SAFE_ID.test(String(value.agentId)))
+        return undefined;
+    const scope = validateScope(value.scope);
+    const response = validateResponse(value.response, prompt);
+    if (!scope || !response)
+        return undefined;
+    return { version: NATIVE_PRODUCER_VERSION, key: value.key, vendor: value.vendor, agentId: value.agentId, scope, response };
+}
+function validateResponse(value, prompt) {
+    if (!isRecord(value) || value.version !== NATIVE_PRODUCER_VERSION || !Array.isArray(value.lifecycle))
+        return undefined;
+    if (value.status === "completed" && isRecord(value.result) && typeof value.result.text === "string" && Array.isArray(value.artifacts)) {
+        if (!onlyKeys(value, ["version", "status", "lifecycle", "result", "artifacts"]))
+            return undefined;
+        const lifecycle = rebuildLifecycle(value.lifecycle, "completed");
+        const text = sanitizeResultText(value.result.text, prompt);
+        const artifacts = rebuildArtifacts(value.artifacts);
+        if (!lifecycle || text === undefined || !artifacts || !onlyKeys(value.result, ["text"]))
+            return undefined;
+        return { version: NATIVE_PRODUCER_VERSION, status: "completed", lifecycle, result: { text }, artifacts };
+    }
+    if (value.status === "failed" && isRecord(value.error) && typeof value.error.code === "string" && Array.isArray(value.artifacts) && value.artifacts.length === 0 && validErrorCode(value.error.code)) {
+        if (!onlyKeys(value, ["version", "status", "lifecycle", "error", "artifacts"]))
+            return undefined;
+        const lifecycle = rebuildLifecycle(value.lifecycle, "failed");
+        if (!lifecycle || !onlyKeys(value.error, ["code"]))
+            return undefined;
+        return { version: NATIVE_PRODUCER_VERSION, status: "failed", lifecycle, error: { code: value.error.code }, artifacts: [] };
+    }
+    return undefined;
+}
+function validateScope(value) {
+    if (!isRecord(value) || !onlyKeys(value, ["bindingDigest"]) || typeof value.bindingDigest !== "string" || !SAFE_DIGEST.test(value.bindingDigest))
+        return undefined;
+    return { bindingDigest: value.bindingDigest };
+}
+function validArtifact(value) {
+    return isRecord(value) && onlyKeys(value, ["id", "kind", "digest", "idempotencyKey"]) && SAFE_ID.test(String(value.id)) && SAFE_ID.test(String(value.idempotencyKey)) && SAFE_DIGEST.test(String(value.digest)) && ["dashboard", "report", "chart"].includes(String(value.kind));
+}
+function sanitizeResultText(text, prompt) {
+    if (Buffer.byteLength(text) > MAX_RESULT_TEXT ||
+        /[\u0000-\u001f\u007f-\u009f]/.test(text) ||
+        (prompt !== undefined && text.includes(prompt)) ||
+        /^\s*(?:\{|\[)/.test(text) ||
+        /\b(?:tool(?:[_ -]?(?:call|result|input|output))?|mcp(?:[_ -]?(?:tool|server|message))?|capability(?:[_ -]?(?:token|credential|grant))?|(?:api[_ -]?key|secret|token|password|authorization|credential))\b\s*[:=]|\bBearer\s+[A-Za-z0-9._-]+|\/(?:Users|home)\//i.test(text))
+        return undefined;
+    return text.replace(/\b[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\b/gi, "[redacted-id]");
+}
+function awaitWithAbort(promise, signal) {
+    if (signal.aborted)
+        return Promise.reject(new DOMException("cancelled", "AbortError"));
+    return new Promise((resolve, reject) => {
+        const abort = () => reject(new DOMException("cancelled", "AbortError"));
+        signal.addEventListener("abort", abort, { once: true });
+        promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+    });
+}
+function isAbortError(error) {
+    return error instanceof DOMException && error.name === "AbortError";
+}
+function validErrorCode(value) {
+    return ["unsupported_version", "scope_mismatch", "invalid_request", "malformed_output", "missing_replay", "timeout", "cancelled", "producer_failed"].includes(value);
+}
+function rebuildLifecycle(value, terminal) {
+    if (value.length !== 3)
+        return undefined;
+    const states = ["accepted", "running", terminal];
+    const rebuilt = [];
+    for (let index = 0; index < states.length; index += 1) {
+        const entry = value[index];
+        if (!isRecord(entry) || !onlyKeys(entry, ["state"]) || entry.state !== states[index])
+            return undefined;
+        rebuilt.push({ state: states[index] });
+    }
+    return rebuilt;
+}
+function rebuildArtifacts(value) {
+    const rebuilt = [];
+    for (const artifact of value) {
+        if (!validArtifact(artifact))
+            return undefined;
+        const record = artifact;
+        rebuilt.push({ id: record.id, kind: record.kind, digest: record.digest, idempotencyKey: record.idempotencyKey });
+    }
+    return rebuilt;
+}
+function sameScope(a, b) {
+    return a.bindingDigest === b.bindingDigest;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function onlyKeys(value, allowed) {
+    return Object.keys(value).every((key) => allowed.includes(key));
+}

package/dist-server/harness/npm-package-resolve.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Resolves a binary shipped by an installed npm package's own `bin` field, using Node's module
+ * resolution rooted at this file — not `PATH`, and not a directory walk.
+ *
+ * This is what lets the `warble` binary and its dispatchers resolve to the exact pinned
+ * `@warble/*` version declared in `apps/genbi/package.json`, regardless of what else happens to be
+ * on `PATH` and regardless of how the current process was launched. `pnpm run <script>` prepends
+ * `node_modules/.bin` to `PATH`, so a bare `PATH` probe already tends to find a workspace-installed
+ * package when the process was started that way — but a process started directly (`node
+ * dist-server/server/bin.js`, a packaged deployment, a test runner) inherits no such `PATH`, and
+ * even when it does, `PATH` order rather than the pinned dependency version is what would decide
+ * the outcome. Resolving through `require.resolve` instead is deterministic in both cases: it
+ * always finds the version this package actually depends on.
+ *
+ * Returns `undefined` — never throws — when the package isn't installed, declares no matching
+ * `bin` entry, or the resolved file doesn't exist on disk, so callers can fall through to their
+ * next resolution tier.
+ */
+export declare function resolveInstalledPackageBin(packageName: string, binName: string): string | undefined;
+/**
+ * Named, explicit opt-in that re-enables the legacy "sibling `warble` git checkout"
+ * development-mode resolution tier in `resolveWarbleBinary`, `resolveAgentSdkCli`, and
+ * `resolveCodexLocalCli`. Off by default: once the pinned `@warble/*` packages are installed,
+ * silently preferring an ambient sibling checkout over them would make it easy to test against the
+ * wrong Warble version without noticing. Set to `"1"` only when deliberately developing GenBI
+ * against an uninstalled, unreleased Warble checkout.
+ */
+export declare function isWarbleSiblingCheckoutDevModeEnabled(): boolean;

package/dist-server/harness/npm-package-resolve.js

@@ -0,0 +1,47 @@
+import { createRequire } from "node:module";
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+/**
+ * Resolves a binary shipped by an installed npm package's own `bin` field, using Node's module
+ * resolution rooted at this file — not `PATH`, and not a directory walk.
+ *
+ * This is what lets the `warble` binary and its dispatchers resolve to the exact pinned
+ * `@warble/*` version declared in `apps/genbi/package.json`, regardless of what else happens to be
+ * on `PATH` and regardless of how the current process was launched. `pnpm run <script>` prepends
+ * `node_modules/.bin` to `PATH`, so a bare `PATH` probe already tends to find a workspace-installed
+ * package when the process was started that way — but a process started directly (`node
+ * dist-server/server/bin.js`, a packaged deployment, a test runner) inherits no such `PATH`, and
+ * even when it does, `PATH` order rather than the pinned dependency version is what would decide
+ * the outcome. Resolving through `require.resolve` instead is deterministic in both cases: it
+ * always finds the version this package actually depends on.
+ *
+ * Returns `undefined` — never throws — when the package isn't installed, declares no matching
+ * `bin` entry, or the resolved file doesn't exist on disk, so callers can fall through to their
+ * next resolution tier.
+ */
+export function resolveInstalledPackageBin(packageName, binName) {
+    try {
+        const require = createRequire(import.meta.url);
+        const pkgJsonPath = require.resolve(`${packageName}/package.json`);
+        const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
+        const binField = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.[binName];
+        if (binField === undefined)
+            return undefined;
+        const resolved = path.resolve(path.dirname(pkgJsonPath), binField);
+        return existsSync(resolved) ? resolved : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Named, explicit opt-in that re-enables the legacy "sibling `warble` git checkout"
+ * development-mode resolution tier in `resolveWarbleBinary`, `resolveAgentSdkCli`, and
+ * `resolveCodexLocalCli`. Off by default: once the pinned `@warble/*` packages are installed,
+ * silently preferring an ambient sibling checkout over them would make it easy to test against the
+ * wrong Warble version without noticing. Set to `"1"` only when deliberately developing GenBI
+ * against an uninstalled, unreleased Warble checkout.
+ */
+export function isWarbleSiblingCheckoutDevModeEnabled() {
+    return process.env.WREN_HARNESS_ALLOW_WARBLE_SIBLING_CHECKOUT === "1";
+}

package/dist-server/harness/providers/adapters/anthropic.d.ts

@@ -0,0 +1,7 @@
+import type { LanguageModel } from "ai";
+export declare const ANTHROPIC_ADAPTER_ID = "anthropic";
+export interface AnthropicAdapterConfig {
+    readonly model: string;
+    readonly apiKey?: string;
+}
+export declare function createAnthropicAdapter(config: AnthropicAdapterConfig): LanguageModel;

package/dist-server/harness/providers/adapters/anthropic.js

@@ -0,0 +1,6 @@
+import { createAnthropic } from "@ai-sdk/anthropic";
+export const ANTHROPIC_ADAPTER_ID = "anthropic";
+export function createAnthropicAdapter(config) {
+    const provider = createAnthropic(config.apiKey !== undefined ? { apiKey: config.apiKey } : {});
+    return provider.languageModel(config.model);
+}

package/dist-server/harness/providers/adapters/mock.d.ts

@@ -0,0 +1,4 @@
+import { MockLanguageModelV4 } from "ai/test";
+export declare const MOCK_ADAPTER_ID = "mock";
+export type MockAdapterConfig = ConstructorParameters<typeof MockLanguageModelV4>[0];
+export declare function createMockAdapter(config?: MockAdapterConfig): MockLanguageModelV4;

package/dist-server/harness/providers/adapters/mock.js

@@ -0,0 +1,5 @@
+import { MockLanguageModelV4 } from "ai/test";
+export const MOCK_ADAPTER_ID = "mock";
+export function createMockAdapter(config = {}) {
+    return new MockLanguageModelV4(config);
+}

package/dist-server/harness/providers/adapters/openai-compatible.d.ts

@@ -0,0 +1,10 @@
+import type { LanguageModel } from "ai";
+export declare const OPENAI_COMPATIBLE_ADAPTER_ID = "openai-compatible";
+export interface OpenAICompatibleAdapterConfig {
+    readonly baseURL: string;
+    readonly model: string;
+    readonly apiKey?: string;
+    /** Provider name reported in telemetry/errors. Defaults to the adapter id. */
+    readonly name?: string;
+}
+export declare function createOpenAICompatibleAdapter(config: OpenAICompatibleAdapterConfig): LanguageModel;

package/dist-server/harness/providers/adapters/openai-compatible.js

@@ -0,0 +1,10 @@
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+export const OPENAI_COMPATIBLE_ADAPTER_ID = "openai-compatible";
+export function createOpenAICompatibleAdapter(config) {
+    const provider = createOpenAICompatible({
+        name: config.name ?? OPENAI_COMPATIBLE_ADAPTER_ID,
+        baseURL: config.baseURL,
+        ...(config.apiKey !== undefined ? { apiKey: config.apiKey } : {}),
+    });
+    return provider.languageModel(config.model);
+}

package/dist-server/harness/providers/binding.d.ts

@@ -0,0 +1,23 @@
+import type { LanguageModel } from "ai";
+import type { ProviderRegistry } from "./registry.js";
+/** Names an adapter id + the config to realize it with. */
+export interface AdapterSpec<Config = unknown> {
+    readonly adapter: string;
+    readonly config: Config;
+}
+/**
+ * Runtime-injected tier -> adapter binding. This is a plain object supplied
+ * by the caller at run time — it is never read from a bundle and must never
+ * be committed to a bundle fixture. `tier` names are open strings owned by
+ * the bundle's steps; the binding only needs to cover the tiers a given run
+ * actually uses.
+ */
+export interface TierBinding {
+    readonly tiers: Readonly<Record<string, AdapterSpec>>;
+}
+/** Resolve an open-string tier name to a concrete language model instance. */
+export declare function resolveTierModel(binding: TierBinding, tier: string, registry: ProviderRegistry): LanguageModel;
+/** Convenience: resolve the model for a bundle step via its `tier` field. */
+export declare function resolveStepModel(step: {
+    readonly tier: string;
+}, binding: TierBinding, registry: ProviderRegistry): LanguageModel;

package/dist-server/harness/providers/binding.js

@@ -0,0 +1,13 @@
+import { UnknownTierError } from "./errors.js";
+/** Resolve an open-string tier name to a concrete language model instance. */
+export function resolveTierModel(binding, tier, registry) {
+    const spec = binding.tiers[tier];
+    if (!spec) {
+        throw new UnknownTierError(tier);
+    }
+    return registry.create(spec.adapter, spec.config);
+}
+/** Convenience: resolve the model for a bundle step via its `tier` field. */
+export function resolveStepModel(step, binding, registry) {
+    return resolveTierModel(binding, step.tier, registry);
+}

package/dist-server/harness/providers/errors.d.ts

@@ -0,0 +1,6 @@
+export declare class UnknownAdapterError extends Error {
+    constructor(adapterId: string);
+}
+export declare class UnknownTierError extends Error {
+    constructor(tier: string);
+}

package/dist-server/harness/providers/errors.js

@@ -0,0 +1,12 @@
+export class UnknownAdapterError extends Error {
+    constructor(adapterId) {
+        super(`no provider adapter registered for id: "${adapterId}"`);
+        this.name = "UnknownAdapterError";
+    }
+}
+export class UnknownTierError extends Error {
+    constructor(tier) {
+        super(`no binding entry for tier: "${tier}"`);
+        this.name = "UnknownTierError";
+    }
+}

package/dist-server/harness/providers/index.d.ts

@@ -0,0 +1,18 @@
+export { UnknownAdapterError, UnknownTierError } from "./errors.js";
+export { createProviderRegistry } from "./registry.js";
+export type { AdapterFactory, ProviderRegistry } from "./registry.js";
+export { resolveStepModel, resolveTierModel } from "./binding.js";
+export type { AdapterSpec, TierBinding } from "./binding.js";
+export { createMockAdapter, MOCK_ADAPTER_ID } from "./adapters/mock.js";
+export type { MockAdapterConfig } from "./adapters/mock.js";
+export { createOpenAICompatibleAdapter, OPENAI_COMPATIBLE_ADAPTER_ID, } from "./adapters/openai-compatible.js";
+export type { OpenAICompatibleAdapterConfig } from "./adapters/openai-compatible.js";
+export { ANTHROPIC_ADAPTER_ID, createAnthropicAdapter } from "./adapters/anthropic.js";
+export type { AnthropicAdapterConfig } from "./adapters/anthropic.js";
+import { type ProviderRegistry } from "./registry.js";
+/**
+ * A provider registry pre-populated with the built-in adapters
+ * (`mock`, `openai-compatible`, `anthropic`). Callers can still
+ * `register()` additional adapter ids onto the returned registry.
+ */
+export declare function createDefaultProviderRegistry(): ProviderRegistry;

package/dist-server/harness/providers/index.js

@@ -0,0 +1,22 @@
+export { UnknownAdapterError, UnknownTierError } from "./errors.js";
+export { createProviderRegistry } from "./registry.js";
+export { resolveStepModel, resolveTierModel } from "./binding.js";
+export { createMockAdapter, MOCK_ADAPTER_ID } from "./adapters/mock.js";
+export { createOpenAICompatibleAdapter, OPENAI_COMPATIBLE_ADAPTER_ID, } from "./adapters/openai-compatible.js";
+export { ANTHROPIC_ADAPTER_ID, createAnthropicAdapter } from "./adapters/anthropic.js";
+import { createAnthropicAdapter, ANTHROPIC_ADAPTER_ID } from "./adapters/anthropic.js";
+import { createMockAdapter, MOCK_ADAPTER_ID } from "./adapters/mock.js";
+import { createOpenAICompatibleAdapter, OPENAI_COMPATIBLE_ADAPTER_ID, } from "./adapters/openai-compatible.js";
+import { createProviderRegistry } from "./registry.js";
+/**
+ * A provider registry pre-populated with the built-in adapters
+ * (`mock`, `openai-compatible`, `anthropic`). Callers can still
+ * `register()` additional adapter ids onto the returned registry.
+ */
+export function createDefaultProviderRegistry() {
+    const registry = createProviderRegistry();
+    registry.register(MOCK_ADAPTER_ID, createMockAdapter);
+    registry.register(OPENAI_COMPATIBLE_ADAPTER_ID, createOpenAICompatibleAdapter);
+    registry.register(ANTHROPIC_ADAPTER_ID, createAnthropicAdapter);
+    return registry;
+}

package/dist-server/harness/providers/registry.d.ts

@@ -0,0 +1,16 @@
+import type { LanguageModel } from "ai";
+export type AdapterFactory<Config = unknown> = (config: Config) => LanguageModel;
+export interface ProviderRegistry {
+    /** Register (or override) the adapter for an open-string adapter id. */
+    register<Config = unknown>(adapterId: string, factory: AdapterFactory<Config>): void;
+    /** Whether an adapter is registered for this id. */
+    has(adapterId: string): boolean;
+    /** Realize a language model instance for the given adapter id + config. */
+    create(adapterId: string, config: unknown): LanguageModel;
+}
+/**
+ * Create an empty, injectable provider registry keyed on an open-string
+ * adapter id. Callers register built-in and/or custom adapters onto it;
+ * the registry itself has no opinion on what ids exist.
+ */
+export declare function createProviderRegistry(): ProviderRegistry;

package/dist-server/harness/providers/registry.js

@@ -0,0 +1,24 @@
+import { UnknownAdapterError } from "./errors.js";
+/**
+ * Create an empty, injectable provider registry keyed on an open-string
+ * adapter id. Callers register built-in and/or custom adapters onto it;
+ * the registry itself has no opinion on what ids exist.
+ */
+export function createProviderRegistry() {
+    const adapters = new Map();
+    return {
+        register(adapterId, factory) {
+            adapters.set(adapterId, factory);
+        },
+        has(adapterId) {
+            return adapters.has(adapterId);
+        },
+        create(adapterId, config) {
+            const factory = adapters.get(adapterId);
+            if (!factory) {
+                throw new UnknownAdapterError(adapterId);
+            }
+            return factory(config);
+        },
+    };
+}