@dynamicagents/core 0.9.0

package/dist/subagent/index.js

@@ -0,0 +1,330 @@
+import { Agent } from "agents";
+import { z } from "zod";
+import { CHUNK_SOFT_MS } from "../platform.js";
+import { buildRecipeTools } from "../runtime/tool-families.js";
+import { RecipeValidationError, validateRecipe } from "../contract/validation.js";
+import { SubtaskParamsError } from "../subtasks/subtask-types.js";
+import { SelfOrigin } from "../a2a/self-origin.js";
+import { renderSubagentPrompt } from "./prompt.js";
+import { makeWorkspaceHandle } from "./workspace.js";
+import { fingerprintRequest } from "./fingerprint.js";
+import { runResumableChunk } from "./run.js";
+/**
+ * Message prefix of the error thrown when a child that already holds a cached
+ * terminal result receives a *different* request. Custom error classes don't
+ * survive DO RPC, so this prefix is the cross-boundary contract: it signals a
+ * parent lifecycle bug — stale children must be deleted before a genuinely new
+ * execution — and a Workflow retry after the parent's cleanup will succeed.
+ */
+export const FINGERPRINT_MISMATCH = "recipe-subagent: request fingerprint mismatch";
+/** Deterministic managed-child name for one Subtask execution. */
+export function subagentName(taskId, subtaskId) {
+    return `subtask:${taskId}:${subtaskId}`;
+}
+/** Zod mirror of {@link RecipeExecutionResult} for parsing the cached JSON. */
+const cachedResultSchema = z.discriminatedUnion("status", [
+    z.object({
+        status: z.literal("completed"),
+        resultParts: z
+            .array(z.object({ kind: z.literal("text"), text: z.string() }))
+            .min(1),
+        modelId: z.string()
+    }),
+    z.object({
+        status: z.literal("failed"),
+        error: z.string(),
+        modelId: z.string().nullable()
+    })
+]);
+/**
+ * `RecipeSubagent` — the isolated, stateless managed child that executes one
+ * Subtask under a resolved Recipe. Created as an Agents SDK sub-agent (facet)
+ * beneath the calling agent, so it needs no wrangler Durable Object binding and
+ * no `new_sqlite_classes` entry; it must only be exported from the consuming
+ * Worker's entry so `ctx.exports` can resolve it by class name.
+ *
+ * It never constructs a Session, never reads parent history beyond the
+ * references supplied on its request, never reaches durable memory, and never
+ * resolves a Recipe itself — it defensively re-validates the resolved Recipe the
+ * parent sends and accepts no configuration beyond it.
+ *
+ * Retry safety: the child persists at most one terminal result in its own
+ * SQLite, keyed by the deterministic request fingerprint, plus the rolling
+ * `run_state` of an in-progress multi-chunk run. A retry with the same
+ * fingerprint replays the terminal result or resumes the run without repeating
+ * completed work; a different request for the same child name is rejected
+ * ({@link FINGERPRINT_MISMATCH}). Transient platform faults throw and cache
+ * nothing, so the enclosing Workflow step can retry. The parent deletes the child
+ * (`deleteSubAgent`) only after its durable copy of the result succeeds, which
+ * wipes this storage — the workspace and run state included.
+ *
+ * Not "stateless" like the single-shot original: it owns per-execution durable
+ * state (the workspace and the run checkpoint), scoped to one execution and swept
+ * with the child.
+ */
+export class RecipeSubagentBase extends Agent {
+    /**
+     * Test-only `ModelPair` injection (a field, so never on the RPC stub).
+     * A whole pair — rather than model instances — so error-path tests can throw
+     * synchronously from the pair's factories, the repo convention (a rejecting
+     * `doGenerate` inside `generateText` leaks an unhandled rejection through
+     * the AI SDK telemetry span that workerd flags as a failure).
+     */
+    modelsOverride;
+    _workspace;
+    /**
+     * The chunk currently executing here, if any. In memory only — it exists to be
+     * interrupted mid-call, and an isolate that lost it has no in-flight call left
+     * to interrupt. See {@link abortRun}.
+     */
+    inflight;
+    /**
+     * This deployment's own public origin, as the parent DO passes it on every
+     * chunk, pinned from the first. In memory for the same reason {@link inflight}
+     * is: a facet is reached only through {@link executeChunk}, so an instance that
+     * lost it is an instance that will be told again before it can run anything.
+     * See {@link SelfOrigin}.
+     */
+    selfOriginMemo = new SelfOrigin();
+    async onStart() {
+        this.ensureTables();
+    }
+    /**
+     * Idempotent schema bootstrap. Also called lazily from the RPCs so
+     * `runInDurableObject`-style tests reach ready tables without RPC dispatch
+     * (mirroring how `AgentDB` migrates on construction).
+     */
+    ensureTables() {
+        this.sql `
+      CREATE TABLE IF NOT EXISTS execution_cache (
+        slot INTEGER PRIMARY KEY CHECK (slot = 1),
+        fingerprint TEXT NOT NULL,
+        result_json TEXT NOT NULL,
+        created_at INTEGER NOT NULL
+      )
+    `;
+        this.sql `
+      CREATE TABLE IF NOT EXISTS run_state (
+        slot INTEGER PRIMARY KEY CHECK (slot = 1),
+        fingerprint TEXT NOT NULL,
+        state_json TEXT NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `;
+    }
+    /** The recipe's durable workspace, backed by this facet's own SQLite storage. */
+    workspace() {
+        return (this._workspace ??= this.subagentRuntime().workspaceBacking(this.ctx.storage.sql, () => this.name));
+    }
+    /**
+     * This deployment's own public origin, if the parent has passed it to this
+     * instance yet. See {@link SelfOrigin}.
+     */
+    selfOrigin() {
+        return this.selfOriginMemo.peek();
+    }
+    /**
+     * The same, for a caller that cannot proceed without it — a facet that signs
+     * its own caller tokens, above all. Mirrors `DynamicAgent.requireSelfOrigin`,
+     * because a facet must run on the same provider, and so the same credential
+     * path, as the parent that delegated to it.
+     */
+    requireSelfOrigin() {
+        return this.selfOriginMemo.require();
+    }
+    /**
+     * Execute one durable chunk of a Subtask under the parent's resolved Recipe.
+     *
+     * A terminal outcome (completed / failed) is cached and replayed on retry. A
+     * mid-run chunk persists its rolling state to `run_state` and returns a
+     * `done: false` yield for the Workflow to run another chunk. `chunk` and
+     * `selfOrigin` are separate arguments — never part of `request` — so every
+     * chunk fingerprints identically and the cache/resume keys line up. Only
+     * transient platform faults throw (nothing cached), so a Workflow retry
+     * resumes from the last checkpoint.
+     */
+    async executeChunk(request, _chunk, runtime = {}, selfOrigin) {
+        this.ensureTables();
+        // Before `subagentRuntime()`, which is where a host builds its model runtime
+        // — and a facet running on a provider it authenticates to mint-signed reads
+        // this origin from there.
+        this.selfOriginMemo.note(selfOrigin);
+        const rt = this.subagentRuntime();
+        const fingerprint = await fingerprintRequest(request);
+        // A terminal result already exists → replay it (idempotent retry).
+        const cached = this.sql `
+      SELECT fingerprint, result_json FROM execution_cache WHERE slot = 1
+    `[0];
+        if (cached) {
+            if (cached.fingerprint !== fingerprint)
+                throw mismatch("terminal");
+            return {
+                done: true,
+                result: cachedResultSchema.parse(JSON.parse(cached.result_json)),
+                progress: []
+            };
+        }
+        // Validate the recipe up front; an unusable recipe (disabled, or with no
+        // soul) and an empty prompt are deterministic, cacheable terminal failures
+        // with no model call.
+        let recipe;
+        try {
+            recipe = validateRecipe(request.recipe, rt.policy);
+        }
+        catch (error) {
+            if (!(error instanceof RecipeValidationError))
+                throw error;
+            return this.cacheTerminal(fingerprint, {
+                status: "failed",
+                error: error.message,
+                modelId: null
+            });
+        }
+        if (request.prompt.trim() === "") {
+            return this.cacheTerminal(fingerprint, {
+                status: "failed",
+                error: "empty subtask prompt",
+                modelId: null
+            });
+        }
+        // Re-check the type's param contract, the same defensive posture as
+        // `validateRecipe`: a subtask missing a param its type requires cannot
+        // succeed, and failing here costs no model call and gives the parent a real
+        // diagnostic.
+        try {
+            rt.types.validateParams(request.type, request.params);
+        }
+        catch (error) {
+            if (!(error instanceof SubtaskParamsError))
+                throw error;
+            return this.cacheTerminal(fingerprint, {
+                status: "failed",
+                error: error.message,
+                modelId: null
+            });
+        }
+        // Resume an in-progress run, guarding against a stale child holding a
+        // *different* run (the same reuse hazard the terminal cache guards).
+        const saved = this.sql `
+      SELECT fingerprint, state_json FROM run_state WHERE slot = 1
+    `[0];
+        if (saved && saved.fingerprint !== fingerprint)
+            throw mismatch("in-progress");
+        const prev = saved
+            ? JSON.parse(saved.state_json)
+            : null;
+        const models = this.modelsOverride ??
+            rt.models.createModelPair({
+                primaryModelId: recipe.primaryModelId,
+                fallbackModelId: recipe.fallbackModelId,
+                // AI Gateway correlation: tie this child's model calls to its Subtask.
+                metadata: { taskId: request.taskId, subtaskId: request.subtaskId }
+            });
+        const workspace = makeWorkspaceHandle(this.workspace());
+        const progress = [];
+        const { tools } = buildRecipeTools(recipe.toolFamilies, rt.toolFamilies, {
+            workspace,
+            emitProgress: (event) => progress.push(event),
+            params: request.params,
+            runtime
+        });
+        const { system, prompt } = renderSubagentPrompt({ ...request, recipe });
+        const controller = new AbortController();
+        this.inflight = controller;
+        let outcome, state;
+        try {
+            ({ outcome, state } = await runResumableChunk(prev, {
+                system,
+                seedPrompt: prompt,
+                models,
+                tools,
+                limits: recipe.limits,
+                chunkSoftMs: CHUNK_SOFT_MS,
+                historyWindow: recipe.historyWindow,
+                toolOutputWindow: rt.toolOutputWindow,
+                reportMetrics: recipe.reportMetrics,
+                maxOutputTokens: rt.maxOutputTokens,
+                maxRetries: rt.maxRetries,
+                now: () => Date.now(),
+                progress,
+                checkpoint: (s) => this.saveRunState(fingerprint, s),
+                abortSignal: controller.signal
+            }));
+        }
+        finally {
+            this.inflight = undefined;
+        }
+        // The per-step checkpoint already ran; persist the final state too so a chunk
+        // that yielded without a completed step still advances durably.
+        this.saveRunState(fingerprint, state);
+        if (outcome.done) {
+            return this.cacheTerminal(fingerprint, outcome.result, outcome.progress);
+        }
+        return { done: false, progress: outcome.progress };
+    }
+    /**
+     * Interrupt the chunk running here right now, so a cancellation lands on the
+     * current model call instead of at the next chunk boundary (up to `chunkSoftMs`
+     * later — minutes, for a long recipe). Returns whether there was one to stop.
+     *
+     * Distinct from {@link abortExecution}, which releases *external* state after
+     * the fact; this only stops local work. An aborted run yields rather than
+     * producing a terminal result, so nothing is cached and the parent resolves the
+     * row itself. Reaching a facet mid-`executeChunk` works because it is awaiting
+     * a model `fetch` at the time, which does not hold the input gate closed.
+     */
+    async abortRun() {
+        if (!this.inflight)
+            return false;
+        this.inflight.abort();
+        return true;
+    }
+    /**
+     * Best-effort cleanup on cancellation: rebuild the recipe's tool families and
+     * run their `abort` hooks (e.g. release an external resource recorded in the
+     * workspace session file). Reconstructible from the workspace, so it is safe on a fresh
+     * isolate. The parent supplies the validated tool families it resolved.
+     */
+    async abortExecution(toolFamilies) {
+        this.ensureTables();
+        const rt = this.subagentRuntime();
+        const ctx = {
+            workspace: makeWorkspaceHandle(this.workspace()),
+            emitProgress: () => { },
+            params: {},
+            runtime: {}
+        };
+        const { abort } = buildRecipeTools(toolFamilies, rt.toolFamilies, ctx);
+        if (abort)
+            await abort(ctx);
+    }
+    /** Persist a terminal result to the cache and return it as a done chunk. */
+    cacheTerminal(fingerprint, result, progress = []) {
+        this.sql `
+      INSERT INTO execution_cache (slot, fingerprint, result_json, created_at)
+      VALUES (1, ${fingerprint}, ${JSON.stringify(result)}, ${Date.now()})
+      ON CONFLICT (slot) DO UPDATE SET
+        fingerprint = excluded.fingerprint,
+        result_json = excluded.result_json,
+        created_at = excluded.created_at
+    `;
+        return { done: true, result, progress };
+    }
+    /** Persist the rolling run state (called after every model turn). */
+    saveRunState(fingerprint, state) {
+        this.sql `
+      INSERT INTO run_state (slot, fingerprint, state_json, updated_at)
+      VALUES (1, ${fingerprint}, ${JSON.stringify(state)}, ${Date.now()})
+      ON CONFLICT (slot) DO UPDATE SET
+        fingerprint = excluded.fingerprint,
+        state_json = excluded.state_json,
+        updated_at = excluded.updated_at
+    `;
+    }
+}
+/** The cross-RPC stale-child error (see {@link FINGERPRINT_MISMATCH}). */
+function mismatch(phase) {
+    return new Error(`${FINGERPRINT_MISMATCH}: this child already holds a ${phase} state for a ` +
+        "different request; the parent must delete a stale child before starting a " +
+        "genuinely new execution");
+}

package/dist/subagent/prompt.d.ts

@@ -0,0 +1,32 @@
+import type { RecipeExecutionRequest } from "../subtasks/types.js";
+import type { ValidatedRecipe } from "../contract/recipe.js";
+/**
+ * Deterministic rendering of one subagent invocation. Pure — no model, no
+ * Session, no lookups: everything comes verbatim from the request. The three
+ * sections stay clearly separated and labeled so tests (and the model) can tell
+ * them apart: the execution's budget, the main-agent instruction, and the
+ * verbatim conversation reference snapshots.
+ */
+/**
+ * A request whose Recipe has been through `validateRecipe`, so its limits are
+ * merged rather than partial. Required rather than convenient: the budget line
+ * below states a number to the model, and stating "up to undefined turns" — or
+ * quietly rendering a Recipe's override as the whole budget — is worse than not
+ * telling it at all.
+ */
+export type RenderableExecution = RecipeExecutionRequest & {
+    recipe: ValidatedRecipe;
+};
+export interface RenderedInvocation {
+    /** The validated Recipe soul, verbatim — the invocation's system prompt. */
+    system: string;
+    /** The sectioned user message (budget, instruction, references). */
+    prompt: string;
+}
+/**
+ * Render the sectioned user message for one execution. Reference snapshots are
+ * emitted exactly as captured at decomposition — `[ref N]` labels with the
+ * message role, no summarizing, rewriting, or interpolation. Sections with no
+ * content are omitted entirely.
+ */
+export declare function renderSubagentPrompt(request: RenderableExecution): RenderedInvocation;

package/dist/subagent/prompt.js

@@ -0,0 +1,37 @@
+/**
+ * The budget, in the terms the runner actually enforces.
+ *
+ * Worth its own section because a subagent that does not know its budget invents
+ * one, and a *main* agent writing the prompt invents one for it: in one logged
+ * play the instruction said "you have up to 20 actions total" — 20 was the turn
+ * budget — and the subagent stopped after eleven game moves reasoning that it
+ * must be out. Turns and actions are not the same currency and this is the line
+ * that says so.
+ */
+function renderBudget(limits) {
+    const minutes = Math.round(limits.maxWallMs / 60_000);
+    return (`# Budget\nUp to ${limits.maxTurns} turns and about ${minutes} minutes. ` +
+        "One turn is one tool call, however much that call does — anything a tool " +
+        "counts internally is its own budget, not this one. Reaching either ceiling " +
+        "does not drop your work: you get one last turn, with no tools, to write up " +
+        "what you have.");
+}
+/**
+ * Render the sectioned user message for one execution. Reference snapshots are
+ * emitted exactly as captured at decomposition — `[ref N]` labels with the
+ * message role, no summarizing, rewriting, or interpolation. Sections with no
+ * content are omitted entirely.
+ */
+export function renderSubagentPrompt(request) {
+    const sections = [renderBudget(request.recipe.limits)];
+    const prompt = request.prompt.trim();
+    if (prompt !== "") {
+        sections.push(`# Task\n${prompt}`);
+    }
+    if (request.references.length > 0) {
+        const refs = request.references.map((ref, i) => `[ref ${i + 1}] (${ref.role}): ${ref.text}`);
+        sections.push("# Conversation references (verbatim snapshots of the caller's conversation)\n" +
+            refs.join("\n"));
+    }
+    return { system: request.recipe.soul, prompt: sections.join("\n\n") };
+}

package/dist/subagent/run.d.ts

@@ -0,0 +1,157 @@
+import type { ModelMessage, ToolSet } from "ai";
+import { type RecipePolicy } from "../contract/validation.js";
+import type { ModelPair } from "../agent/model.js";
+import type { ProgressEvent, RecipeChunkResult, RecipeExecutionRequest, RecipeExecutionResult } from "../subtasks/types.js";
+import type { RecipeLimits } from "../contract/recipe.js";
+/**
+ * The resumable execution runner — ONE loop for every Recipe, from a single-shot
+ * general Subtask to a long game. It runs the model/tool loop in durable
+ * **chunks**: each call advances as far as `chunkSoftMs` allows (or until the run
+ * spends its budget, or until a tool emits progress), checkpoints its rolling state
+ * after every turn, and returns either a terminal result or a "not done" yield. The
+ * facet persists the state between chunks and the Workflow runs each chunk as its
+ * own durable, retryable step — so no single step ever approaches the platform
+ * step timeout, and a crash loses at most the in-flight turn.
+ *
+ * Domain behavior lives entirely in the tool families; this runner is agnostic of
+ * what work happens beneath it. State that must outlive the small rolling context
+ * window is the recipe's responsibility to persist to its workspace.
+ */
+/** The rolling state carried across a run's chunks (persisted by the facet). */
+export interface ChunkRunState {
+    /** Windowed conversation so far (system is supplied separately, not stored here). */
+    messages: ModelMessage[];
+    /** Total model turns (tool-loop steps) across every chunk — bounds `maxTurns`. */
+    turns: number;
+    /** Total `generateText` invocations (including fallbacks and summarization). */
+    llmCalls: number;
+    /** Wall-clock start of the whole execution (for the metrics footer). */
+    startedAtMs: number;
+}
+/** Everything one chunk needs, assembled by the facet (or a test) each call. */
+export interface ChunkRunDeps {
+    system: string;
+    /** The rendered initial user message; seeds a fresh run's first chunk. */
+    seedPrompt: string;
+    models: ModelPair;
+    tools: ToolSet;
+    /** The run's budget: turns and wall clock. Nothing else. */
+    limits: RecipeLimits;
+    /**
+     * How long this chunk may run before it checkpoints and yields a fresh durable
+     * step — the Workers step-timeout guard, not a budget, and identical for every
+     * Recipe (`CHUNK_SOFT_MS` in `platform.ts`). Injected rather than imported so
+     * the runner stays testable with a fake clock.
+     */
+    chunkSoftMs: number;
+    historyWindow: number;
+    /**
+     * How many of the most recent assistant turns keep their tool results in full;
+     * older ones are stubbed by {@link elideToolOutputs}. A mechanic of the window
+     * rather than a property of a domain — see `CoreConfig.toolOutputWindow`.
+     */
+    toolOutputWindow: number;
+    reportMetrics: boolean;
+    /**
+     * Output-token ceiling for every model call in this chunk. Injected rather
+     * than imported: it is host config, and a published runner must not carry a
+     * hardcoded one.
+     */
+    maxOutputTokens: number;
+    /**
+     * `CoreConfig.model.maxRetries` — retries on *this* model, honouring the
+     * provider's `retry-after`, before the slot hands over to the fallback.
+     */
+    maxRetries: number;
+    now: () => number;
+    /** Shared sink the tool families push progress events into (fresh per chunk). */
+    progress: ProgressEvent[];
+    /** Persist rolling state after every model turn — the crash-safety checkpoint. */
+    checkpoint: (state: ChunkRunState) => void | Promise<void>;
+    /**
+     * Interrupts the in-flight model call when the parent Task is canceled. Without
+     * it a cancellation is only observed at the next chunk boundary — up to
+     * `chunkSoftMs` of unwanted play. See {@link ChunkAttempt}'s `aborted` case for
+     * why an abort is emphatically *not* a model failure.
+     */
+    abortSignal?: AbortSignal;
+}
+export interface ChunkRunOutput {
+    outcome: RecipeChunkResult;
+    state: ChunkRunState;
+}
+/**
+ * Trim the conversation to the most recent `window` turns (plus the seed message),
+ * cutting at an assistant boundary so no tool-result message is left orphaned.
+ * Older turns fall out of context — the recipe's soul directs the model to persist
+ * anything durable to its workspace, which the window never touches.
+ */
+export declare function windowMessages(messages: ModelMessage[], window: number): ModelMessage[];
+/** What replaces a tool result that has aged out of the detail window. */
+export declare const ELIDED_TOOL_OUTPUT = "[output from an earlier turn, trimmed to save context]";
+/**
+ * Shrink the window without shortening it: stub out the *payloads* of tool
+ * results the model has moved past, leaving every message, every tool call — and
+ * therefore every note the model wrote itself — exactly where it was.
+ *
+ * This is the other half of {@link windowMessages}, and it exists because the two
+ * things a rolling window holds have opposite value curves. A recipe's own
+ * reasoning and its tool-call *inputs* stay useful for as long as the run does; a
+ * tool *result* is a snapshot of a world that has since moved, and it is also
+ * where nearly all the tokens are. Dropping whole turns to bound context throws
+ * both away together, which is why a short window makes a model re-derive what it
+ * already knew.
+ *
+ * A result's output survives if any of:
+ *
+ * 1. it is within the last `keepRecent` assistant messages — the same unit
+ *    `windowMessages` counts in, so the two knobs are commensurable;
+ * 2. **it is the newest result for its tool**, at any age. Tools may hold state
+ *    about what they have already shown this chunk and answer a repeat with
+ *    "unchanged since you last looked" — a real optimization that becomes a lie
+ *    the moment the render it points at is gone. Keeping the newest per tool is
+ *    what makes "your latest view" a thing the model can still see, and it is why
+ *    `keepRecent` can be small;
+ * 3. it reports a failure or a denial — short, diagnostic, and losing *why* a
+ *    call failed costs a retry to rediscover for no saving;
+ * 4. it is already small enough that stubbing it saves nothing.
+ *
+ * Idempotent: a stubbed part is small, so a later pass leaves it alone.
+ *
+ * `keepRecent` is normalized rather than trusted — see the note on `keep` below.
+ * Zero is a legal, meaningful value: no turn is recent, so rule 1 protects
+ * nothing and rules 2-4 carry the whole of what survives.
+ */
+export declare function elideToolOutputs(messages: ModelMessage[], keepRecent: number): ModelMessage[];
+/**
+ * Run one durable chunk. Returns a terminal result (natural completion, budget
+ * exhaustion, or exhausted models) or a `done: false` yield with the progress
+ * emitted this chunk. Throws only on a transient platform fault, so the Workflow
+ * step retries and resumes from the last checkpoint.
+ */
+export declare function runResumableChunk(prev: ChunkRunState | null, deps: ChunkRunDeps): Promise<ChunkRunOutput>;
+/** Everything a whole-run (non-chunked) execution needs — for tests and callers
+ * that want a single terminal result rather than driving chunks themselves. */
+export interface RecipeRunDeps {
+    models: ModelPair;
+    tools: ToolSet;
+    now?: () => number;
+    /** The capability boundary a recipe is re-validated against inside the child. */
+    policy: RecipePolicy;
+    /** `CoreConfig.toolOutputWindow`. */
+    toolOutputWindow: number;
+    /** `CoreConfig.model.maxOutputTokens`. */
+    maxOutputTokens: number;
+    /** `CoreConfig.model.maxRetries`. */
+    maxRetries: number;
+}
+/**
+ * Run one recipe execution to a terminal result, driving {@link runResumableChunk}
+ * chunk by chunk in memory. A run that fits its budget finishes in one chunk;
+ * otherwise it loops until the budget yields a summary. Used by tests and any
+ * caller wanting the whole outcome; the facet drives chunks durably instead, for
+ * crash-safety across the Workflow.
+ *
+ * Throws only on a transient platform fault (as {@link runResumableChunk} does).
+ */
+export declare function runRecipeExecution(request: RecipeExecutionRequest, deps: RecipeRunDeps): Promise<RecipeExecutionResult>;