@wrenai/genbi 0.0.1

package/dist-server/harness/loop/executor.js

@@ -0,0 +1,380 @@
+import { generateText, isStepCount, ToolLoopAgent } from "ai";
+import { resolveStepModel } from "../providers/index.js";
+import { WRITE_ARTIFACT_TOOL_NAME } from "../tools/index.js";
+import { AgentScopeError, InvalidRepairFoldError, RepairExhaustedError, StepBudgetExhaustedError } from "./errors.js";
+import { passthroughGuardEvaluator } from "./guard.js";
+const SUPPORTED_COMPONENT_TYPE = "analytical";
+const SUPPORTED_TRIGGER = "one_shot";
+const SUPPORTED_OUTCOME = "none";
+/**
+ * Runs an agent's `steps[]` over a dataflow artifact state (option (b)):
+ * a step becomes runnable once every artifact it `consumes` is present, and
+ * on completion it stores its `produces` artifact. Step order is *derived*
+ * from consumes/produces satisfaction, not from the array's emergent index.
+ *
+ * Tool granularity is agent-level in the bundle, not per-step: if the agent
+ * declares `tools`, every (non-repair_fold) step runs as a `ToolLoopAgent`
+ * turn with the injected tool set (tool calls are emergent — a given step
+ * may make zero); otherwise every step is a single `generateText` call.
+ * A future milestone may refine this to scope tools per step.
+ *
+ * `realization.kind: "repair_fold"` steps are recognized but never run as
+ * independent top-level steps — instead each one folds into its
+ * `fold_into` target's tool-loop as a bounded error-recovery turn: when the
+ * target step's most recent turn surfaces a tool-execution error, the next
+ * turn's model and instructions swap to the repair step's, bounded by
+ * `max_attempts`. The DAG stays acyclic — this is a loop-internal retry, not
+ * a dataflow back-edge — and exhaustion is a loud failure
+ * ({@link RepairExhaustedError}), never a silent swallow or infinite retry.
+ *
+ * Returns the final dataflow artifact state — not a render envelope
+ * (the two-stage structured-output envelope is built in `harness/render/`).
+ */
+export async function executeAgent(agent, ctx) {
+    assertV1Scope(agent);
+    const artifacts = new Map();
+    const evaluateGuard = ctx.evaluateGuard ?? passthroughGuardEvaluator;
+    // Tool granularity is agent-level in the bundle (`agent.tools[]`), not
+    // per-step — so gate the ToolLoopAgent-vs-generateText choice on the
+    // bundle's declaration, not on whatever happens to be in the injected
+    // tool set (which the caller may size differently today, since real
+    // `agent.tools[]` -> AI SDK tool resolution happens elsewhere).
+    const hasTools = agent.tools.length > 0;
+    // repair_fold steps never run as independent top-level steps — they're
+    // consumed by the fold-into-loop logic below, keyed by their fold_into
+    // target's step name.
+    const repairByTarget = buildRepairFoldMap(agent, hasTools);
+    const pending = agent.steps.filter((step) => step.realization.kind !== "repair_fold");
+    while (pending.length > 0) {
+        const readyIndex = pending.findIndex((step) => isConsumesSatisfied(step, artifacts));
+        if (readyIndex === -1) {
+            // No remaining step's consumes can ever be satisfied — e.g. its sole
+            // producer is a repair_fold step, which never runs as a top-level step.
+            break;
+        }
+        const [step] = pending.splice(readyIndex, 1);
+        if (!step)
+            break;
+        if (!evaluateGuard({ step, artifacts })) {
+            // A real guard would skip this step's execution and leave
+            // its `produces` artifact absent. The default guard used here never does this.
+            continue;
+        }
+        const prompt = renderStepPrompt(step, ctx.userInput, artifacts);
+        const model = resolveStepModel(step, ctx.binding, ctx.registry);
+        const repairStep = repairByTarget.get(step.name);
+        const stepId = step.name;
+        // `step.start`/`step.finish` bracket each bundle step.
+        // In-process has no sub-agent/Task mechanism, so `depth` is always 0 and
+        // `parent` is never set here (see `ExecuteAgentContext.onEvent`'s doc
+        // comment).
+        ctx.onEvent?.({ kind: "step.start", stepId, name: step.name, tier: step.tier, depth: 0 });
+        let text;
+        let repaired = false;
+        try {
+            if (repairStep) {
+                // Validated up front in buildRepairFoldMap: a repair_fold target is
+                // always a tools-bearing step, so hasTools is guaranteed true here.
+                const result = await runToolLoopStepWithRepair(model, ctx.tools, prompt, repairStep, ctx.binding, ctx.registry, stepId, ctx.onToolCallOutcome, ctx.onEvent, ctx.maxSteps);
+                if (result.exhausted) {
+                    throw new StepBudgetExhaustedError(stepId, ctx.maxSteps, artifacts.size);
+                }
+                text = result.text;
+                repaired = result.repaired;
+            }
+            else if (hasTools) {
+                const result = await runToolLoopStep(model, ctx.tools, prompt, stepId, ctx.onToolCallOutcome, ctx.onEvent, ctx.maxSteps);
+                if (result.exhausted) {
+                    throw new StepBudgetExhaustedError(stepId, ctx.maxSteps, artifacts.size);
+                }
+                text = result.text;
+            }
+            else {
+                text = await runSingleGenerateStep(model, prompt);
+            }
+        }
+        catch (error) {
+            ctx.onEvent?.({ kind: "step.finish", stepId, name: step.name, status: "error", detail: describeError(error) });
+            throw error;
+        }
+        artifacts.set(step.produces, text);
+        // Surface the step's own reasoning/output — the text it just
+        // produced (already about to be stored as `step.produces`'s artifact) —
+        // bounded via the same `summarizeToolOutput` truncation a tool result
+        // uses, so a long LLM step's output doesn't blow up the work-log frame.
+        const detail = summarizeToolOutput(text);
+        ctx.onEvent?.({
+            kind: "step.finish",
+            stepId,
+            name: step.name,
+            status: "ok",
+            ...(detail !== undefined ? { detail } : {}),
+        });
+        // The repair step's own `produces` artifact only appears when a repair
+        // turn actually ran — never on the ordinary success path (see the
+        // `repaired_result` absence assertion).
+        if (repairStep && repaired) {
+            artifacts.set(repairStep.produces, text);
+        }
+    }
+    return artifacts;
+}
+/**
+ * Validates and indexes every `repair_fold` step by its `fold_into` target
+ * step name. The fold-into-loop contract is closed: `when` must be exactly
+ * `{ guard: "on_failure", target: <fold_into> }`, the target must exist
+ * among the agent's steps, at most one repair may bind to a given target,
+ * and — since this mechanism only ever detects failure via a tool-error content part on
+ * the target's tool-loop turn — the target must be a tools-bearing step.
+ * Any violation is a loud `InvalidRepairFoldError` at agent-start, not a
+ * silent fall-back to skipping the repair step.
+ */
+function buildRepairFoldMap(agent, hasTools) {
+    const map = new Map();
+    const stepNames = new Set(agent.steps.map((step) => step.name));
+    for (const step of agent.steps) {
+        if (step.realization.kind !== "repair_fold")
+            continue;
+        const foldInto = step.realization.fold_into;
+        if (!foldInto) {
+            throw new InvalidRepairFoldError(step.name, "realization.fold_into is required");
+        }
+        if (!stepNames.has(foldInto)) {
+            throw new InvalidRepairFoldError(step.name, `fold_into target "${foldInto}" is not a step on this agent`);
+        }
+        if (!step.when || step.when.guard !== "on_failure" || step.when.target !== foldInto) {
+            throw new InvalidRepairFoldError(step.name, `expected when = { guard: "on_failure", target: "${foldInto}" }`);
+        }
+        if (map.has(foldInto)) {
+            throw new InvalidRepairFoldError(step.name, `step "${foldInto}" already has a repair_fold bound to it`);
+        }
+        if (!hasTools) {
+            throw new InvalidRepairFoldError(step.name, `fold_into target "${foldInto}" must be a tools-bearing step (the fold-into-loop mechanism detects failure via a tool-error)`);
+        }
+        map.set(foldInto, step);
+    }
+    return map;
+}
+function assertV1Scope(agent) {
+    if (agent.component_type !== SUPPORTED_COMPONENT_TYPE ||
+        agent.trigger !== SUPPORTED_TRIGGER ||
+        agent.outcome !== SUPPORTED_OUTCOME) {
+        throw new AgentScopeError(agent.id, agent.component_type, agent.trigger, agent.outcome);
+    }
+}
+function isConsumesSatisfied(step, artifacts) {
+    return step.consumes.every((artifactName) => artifacts.has(artifactName));
+}
+async function runSingleGenerateStep(model, prompt) {
+    const result = await generateText({ model, prompt });
+    return result.text;
+}
+async function runToolLoopStep(model, tools, prompt, stepId, onToolCallOutcome, onEvent, maxSteps) {
+    const agentRunner = new ToolLoopAgent({
+        model,
+        tools,
+        ...(maxSteps !== undefined ? { stopWhen: isStepCount(maxSteps) } : {}),
+    });
+    const result = await agentRunner.generate({ prompt });
+    reportToolCallOutcomes(result.steps, stepId, onToolCallOutcome, onEvent);
+    return { text: result.text, exhausted: isBudgetExhausted(result, maxSteps) };
+}
+/**
+ * The fold-into-loop mechanism: runs `prompt` as a `ToolLoopAgent` turn
+ * exactly like {@link runToolLoopStep}, except `prepareStep` inspects the
+ * immediately-preceding turn for a tool-execution error (a `type:
+ * "tool-error"` content part — the shape the AI SDK gives a caught tool
+ * `execute` rejection, confirmed against `@ai-sdk/mcp`'s JSON-RPC error
+ * path). On error, the *next* turn's model and instructions are swapped to
+ * the repair step's (its `tier` resolved the same way any step's tier is),
+ * folding the repair in as a bounded error-recovery turn rather than a
+ * separate top-level step. Bounded by `repairStep.realization.max_attempts`
+ * (default 1); once exhausted, a further tool-error throws
+ * {@link RepairExhaustedError} instead of retrying again.
+ */
+async function runToolLoopStepWithRepair(model, tools, prompt, repairStep, binding, registry, stepId, onToolCallOutcome, onEvent, maxSteps) {
+    const maxAttempts = repairStep.realization.max_attempts ?? 1;
+    const repairModel = resolveStepModel(repairStep, binding, registry);
+    const foldTarget = repairStep.realization.fold_into ?? repairStep.name;
+    let attemptsUsed = 0;
+    let repaired = false;
+    const agentRunner = new ToolLoopAgent({
+        model,
+        tools,
+        ...(maxSteps !== undefined ? { stopWhen: isStepCount(maxSteps) } : {}),
+        prepareStep: ({ steps }) => {
+            const lastStep = steps[steps.length - 1];
+            if (!lastStep || !stepHasToolError(lastStep)) {
+                return {};
+            }
+            if (attemptsUsed >= maxAttempts) {
+                throw new RepairExhaustedError(foldTarget, repairStep.name, maxAttempts);
+            }
+            attemptsUsed += 1;
+            repaired = true;
+            return { model: repairModel, instructions: repairStep.prompt };
+        },
+    });
+    const result = await agentRunner.generate({ prompt });
+    reportToolCallOutcomes(result.steps, stepId, onToolCallOutcome, onEvent);
+    return { text: result.text, repaired, exhausted: isBudgetExhausted(result, maxSteps) };
+}
+/**
+ * Detects whether a completed `ToolLoopAgent` turn was cut off by its
+ * configured step budget rather than finishing on its own. `isStepCount`'s
+ * own stop condition is an exact-equality check (`steps.length ===
+ * stepCount`, `ai`'s `stop-condition.ts`) — indistinguishable, by step count
+ * alone, from a model that happens to finish naturally on exactly the
+ * budget's last step. `finishReason` disambiguates: a clean finish sets it to
+ * `"stop"` (`generate-text.ts`'s main loop only resolves output when
+ * `lastStep.finishReason === "stop"`); a turn cut off mid-flight — the model
+ * still had a tool call queued when the budget's step count was hit — never
+ * reaches that state, so its last step's `finishReason` is something else
+ * (typically `"tool-calls"`). Always `false` when no budget was configured
+ * (`maxSteps === undefined`), so a caller that never opts in (the Ask path)
+ * can never see this heuristic fire.
+ */
+function isBudgetExhausted(result, maxSteps) {
+    if (maxSteps === undefined)
+        return false;
+    return result.steps.length >= maxSteps && result.finishReason !== "stop";
+}
+function stepHasToolError(step) {
+    return step.content.some((part) => part.type === "tool-error");
+}
+/**
+ * This function, widened for the live-event layer: walks every step's content parts from a
+ * completed `ToolLoopAgent` turn and reports each outcome to
+ * `onToolCallOutcome` ({@link ToolCallOutcome}) — this is the sole place
+ * tool-call outcomes are observed, so the deterministic gate and the
+ * FLOOR `StepTrace` both see outcomes from ordinary steps and from
+ * repair-folded turns alike. A no-op for a given concern when neither
+ * `onToolCallOutcome` nor `onEvent` is registered.
+ *
+ * Also emits, when `onEvent` is set: a `tool.call` for every `tool-call`
+ * part (before its outcome is known — `status: "running"`), a `tool.result`
+ * for every `tool-result`/`tool-error` part, and — best-effort, since the
+ * bundle's native `write_artifact` tool has no `artifactKind` field of its
+ * own (input is just `{path, content}`) — an `artifact` event defaulting
+ * `artifactKind` to `"report"` whenever that tool call succeeds. This is a
+ * documented limitation, not a real classification signal.
+ */
+function reportToolCallOutcomes(steps, stepId, onToolCallOutcome, onEvent) {
+    if (!onToolCallOutcome && !onEvent)
+        return;
+    for (const step of steps) {
+        for (const part of step.content) {
+            if (part.type === "tool-call") {
+                onEvent?.({
+                    kind: "tool.call",
+                    stepId,
+                    callId: part.toolCallId,
+                    tool: part.toolName,
+                    ...(part.input !== undefined ? { input: part.input } : {}),
+                    depth: 0,
+                    status: "running",
+                });
+            }
+            else if (part.type === "tool-result") {
+                onToolCallOutcome?.({
+                    tool: part.toolName,
+                    outcome: "success",
+                    callId: part.toolCallId,
+                    ...(part.input !== undefined ? { input: part.input } : {}),
+                    ...(part.output !== undefined ? { output: part.output } : {}),
+                });
+                const summary = summarizeToolOutput(part.output);
+                onEvent?.({
+                    kind: "tool.result",
+                    stepId,
+                    callId: part.toolCallId,
+                    tool: part.toolName,
+                    status: "success",
+                    ...(summary !== undefined ? { summary } : {}),
+                });
+                if (part.toolName === WRITE_ARTIFACT_TOOL_NAME) {
+                    const location = extractArtifactPath(part.input);
+                    if (location !== undefined) {
+                        onEvent?.({
+                            kind: "artifact",
+                            // Best-effort default — the native `write_artifact` tool has
+                            // no `artifactKind` concept in its input/output schema (see
+                            // this function's doc comment).
+                            name: basenameOf(location),
+                            artifactKind: "report",
+                            location,
+                        });
+                    }
+                }
+            }
+            else if (part.type === "tool-error") {
+                const error = describeError(part.error);
+                onToolCallOutcome?.({
+                    tool: part.toolName,
+                    outcome: "error",
+                    callId: part.toolCallId,
+                    ...(part.input !== undefined ? { input: part.input } : {}),
+                    error,
+                });
+                onEvent?.({
+                    kind: "tool.result",
+                    stepId,
+                    callId: part.toolCallId,
+                    tool: part.toolName,
+                    status: "error",
+                    error,
+                });
+            }
+        }
+    }
+}
+/**
+ * Best-effort, bounded-length human summary of a tool's `output`, for
+ * `ToolResultEvent.summary`. Exported so `harness/session/run.ts` can build a
+ * `TraceStep.detail` for a successful outcome from the same seam, without
+ * duplicating the truncation logic.
+ */
+export function summarizeToolOutput(output) {
+    if (output === undefined)
+        return undefined;
+    const text = typeof output === "string" ? output : JSON.stringify(output);
+    const MAX_LENGTH = 200;
+    return text.length > MAX_LENGTH ? `${text.slice(0, MAX_LENGTH)}…` : text;
+}
+function describeError(error) {
+    const text = error instanceof Error ? error.message : typeof error === "string" ? error : JSON.stringify(error);
+    // Bounded like summarizeToolOutput: this string is now persisted into the
+    // display worklog's `detail` (via the tool.result/step.finish events), so a
+    // pathological huge error message must not bloat trace_json.
+    const MAX_LENGTH = 200;
+    return text.length > MAX_LENGTH ? `${text.slice(0, MAX_LENGTH)}…` : text;
+}
+function extractArtifactPath(input) {
+    if (typeof input !== "object" || input === null)
+        return undefined;
+    const path = input.path;
+    return typeof path === "string" ? path : undefined;
+}
+function basenameOf(filePath) {
+    const segments = filePath.split(/[/\\]/);
+    return segments[segments.length - 1] || filePath;
+}
+/**
+ * Builds the message sent for a step: the user's question (always present,
+ * so steps with `consumes: []` like `resolve_intent` can still see it),
+ * the step's own prompt, and the resolved values of every artifact it
+ * consumes.
+ */
+function renderStepPrompt(step, userInput, artifacts) {
+    const sections = [`User's question: ${userInput}`, step.prompt];
+    if (step.consumes.length > 0) {
+        const consumedSection = step.consumes
+            .map((name) => `${name}: ${formatArtifactValue(artifacts.get(name))}`)
+            .join("\n");
+        sections.push(`Consumed artifacts:\n${consumedSection}`);
+    }
+    return sections.join("\n\n");
+}
+function formatArtifactValue(value) {
+    return typeof value === "string" ? value : JSON.stringify(value);
+}

package/dist-server/harness/loop/guard.d.ts

@@ -0,0 +1,16 @@
+import type { Step } from "../bundle/schema.js";
+/** Snapshot handed to a guard evaluator immediately before a step would run. */
+export interface StepGuardContext {
+    readonly step: Step;
+    readonly artifacts: ReadonlyMap<string, unknown>;
+}
+/**
+ * Decides whether a runnable step should actually execute. This is the seam
+ * reserved for `when` guard semantics (`on_failure` folds into the repair-fold
+ * retry turn; `on_flag` / `on_missing` drive a guarded-skip) — both are not
+ * yet implemented. The executor always calls this hook before
+ * running a step; the default implementation here is a pass-through no-op so
+ * the seam exists without any guard behavior attached to it yet.
+ */
+export type GuardEvaluator = (ctx: StepGuardContext) => boolean;
+export declare const passthroughGuardEvaluator: GuardEvaluator;

package/dist-server/harness/loop/guard.js

@@ -0,0 +1 @@
+export const passthroughGuardEvaluator = () => true;

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

@@ -0,0 +1,5 @@
+export { executeAgent, summarizeToolOutput } from "./executor.js";
+export type { DataflowArtifacts, ExecuteAgentContext, ToolCallOutcome, ToolCallOutcomeListener } from "./executor.js";
+export { AgentScopeError, InvalidRepairFoldError, RepairExhaustedError, StepBudgetExhaustedError } from "./errors.js";
+export { passthroughGuardEvaluator } from "./guard.js";
+export type { GuardEvaluator, StepGuardContext } from "./guard.js";

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

@@ -0,0 +1,3 @@
+export { executeAgent, summarizeToolOutput } from "./executor.js";
+export { AgentScopeError, InvalidRepairFoldError, RepairExhaustedError, StepBudgetExhaustedError } from "./errors.js";
+export { passthroughGuardEvaluator } from "./guard.js";

package/dist-server/harness/native-producer/index.d.ts

@@ -0,0 +1,109 @@
+import type { AgentEvent, RouteOptions, RouteResult } from "../index.js";
+/**
+ * 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 declare const NATIVE_PRODUCER_VERSION: "1";
+export type NativeProducerVendor = "claude" | "codex";
+export type NativeProducerErrorCode = "unsupported_version" | "scope_mismatch" | "invalid_request" | "malformed_output" | "missing_replay" | "timeout" | "cancelled" | "producer_failed";
+export interface NativeProducerScope {
+    readonly bindingDigest: string;
+}
+export interface NativeProducerRequest {
+    readonly version: typeof NATIVE_PRODUCER_VERSION;
+    readonly vendor: NativeProducerVendor;
+    readonly agentId: string;
+    readonly input: string;
+    readonly scope: NativeProducerScope;
+    /** Host-selected idempotency key; never derived from prompt text. */
+    readonly idempotencyKey: string;
+}
+/** A bounded, host-validated artifact pointer; never a local filesystem path. */
+export interface NativeProducerArtifactReference {
+    readonly id: string;
+    readonly kind: "dashboard" | "report" | "chart";
+    readonly digest: string;
+    readonly idempotencyKey: string;
+}
+export type NativeProducerLifecycleState = "accepted" | "running" | "completed" | "failed";
+export interface NativeProducerLifecycle {
+    readonly state: NativeProducerLifecycleState;
+}
+export interface NativeProducerSuccess {
+    readonly version: typeof NATIVE_PRODUCER_VERSION;
+    readonly status: "completed";
+    readonly lifecycle: readonly NativeProducerLifecycle[];
+    /** Sanitized final result only; never an unparsed dispatcher stream. */
+    readonly result: {
+        readonly text: string;
+    };
+    readonly artifacts: readonly NativeProducerArtifactReference[];
+}
+export interface NativeProducerFailure {
+    readonly version: typeof NATIVE_PRODUCER_VERSION;
+    readonly status: "failed";
+    readonly lifecycle: readonly NativeProducerLifecycle[];
+    /** Stable category only. Raw subprocess errors are intentionally not surfaced. */
+    readonly error: {
+        readonly code: NativeProducerErrorCode;
+    };
+    readonly artifacts: readonly [];
+}
+export type NativeProducerResponse = NativeProducerSuccess | NativeProducerFailure;
+export interface NativeProducerDispatchInput {
+    readonly vendor: NativeProducerVendor;
+    readonly agentId: string;
+    readonly input: string;
+    readonly scope: NativeProducerScope;
+    readonly idempotencyKey: string;
+    readonly signal: AbortSignal;
+    readonly fence: NativeProducerHostFence;
+    /** Events are available only for local bookkeeping; they never cross this contract. */
+    readonly onEvent: (event: AgentEvent) => void;
+}
+/** Host-only bridge to durable session, binding, and artifact state. */
+export interface NativeProducerHostFence {
+    readonly bindingDigest: string;
+    validateRun(request: NativeProducerRequest): boolean;
+    validateRoute(request: NativeProducerRequest, userProject: string): boolean;
+    validateArtifact(reference: NativeProducerArtifactReference, request: NativeProducerRequest): boolean;
+}
+export interface NativeProducerDispatchResult {
+    readonly text: string;
+    readonly artifacts?: readonly NativeProducerArtifactReference[];
+}
+export type NativeProducerDispatch = (input: NativeProducerDispatchInput) => Promise<NativeProducerDispatchResult>;
+export interface NativeProducerOptions {
+    readonly fence: NativeProducerHostFence;
+    readonly dispatch: NativeProducerDispatch;
+    readonly timeoutMs?: number;
+    /** Host cancellation; it aborts only this producer's selected dispatcher. */
+    readonly signal?: AbortSignal;
+}
+/**
+ * A deterministic record of an already-sanitized producer response. It is
+ * deliberately independent of the raw dispatcher cassette format: callers
+ * replay a stable host contract, not a vendor's opaque wire bytes.
+ */
+export interface NativeProducerCassette {
+    readonly version: typeof NATIVE_PRODUCER_VERSION;
+    readonly key: string;
+    readonly vendor: NativeProducerVendor;
+    readonly agentId: string;
+    readonly scope: NativeProducerScope;
+    readonly response: NativeProducerResponse;
+}
+/** Stable, prompt-free cassette selector for one host-owned idempotent run. */
+export declare function nativeProducerCassetteKey(request: NativeProducerRequest): string;
+/** Runs one noninteractive dispatch and always returns a typed, fail-closed response. */
+export declare function produceNoninteractiveNative(request: unknown, options: NativeProducerOptions): Promise<NativeProducerResponse>;
+/** Replays a sanitized producer cassette; absence, drift, and scope changes fail closed. */
+export declare function replayNoninteractiveNative(request: unknown, cassette: unknown, fence: NativeProducerHostFence): NativeProducerResponse;
+/** Creates a checked-in/replayable record only from an already-safe response. */
+export declare function createNativeProducerCassette(key: string, request: unknown, response: unknown, fence: NativeProducerHostFence): NativeProducerCassette;
+/**
+ * Adapts existing subscription dispatchers without widening their protocol.
+ * The native producer only admits the vendor selected by the route options.
+ */
+export declare function createRouteNativeProducer(route: (options: RouteOptions) => Promise<RouteResult>, baseOptions: Omit<RouteOptions, "question" | "agentId" | "onEvent" | "signal">): NativeProducerDispatch;