@dynamicagents/core 0.9.0

package/dist/subagent/workspace.js

@@ -0,0 +1,127 @@
+/**
+ * An in-memory {@link WorkspaceBacking} — the fallback when no installed plugin
+ * declares one.
+ *
+ * Deliberately **not durable**, and that is the honest behaviour rather than a
+ * shortcut: a durable stand-in would have to invent a storage layout that a real
+ * backend would then have to migrate away from. An agent that delegates file
+ * work installs a backend; one that does not never writes a file, and pays
+ * nothing for the option. What this buys is that `createAgentRuntime` composes
+ * without a workspace plugin at all, so `SubagentRuntime.workspaceBacking` can
+ * stay required and a host never writes a null check.
+ *
+ * Scoped per call, so each execution gets its own map, exactly as a facet's own
+ * SQLite would give it its own tables. Contents are lost on isolate eviction —
+ * the resumable runner treats a lost workspace as a resumable state everywhere
+ * it matters.
+ *
+ * Signature matches {@link AgentPlugin.workspaceBacking}; both arguments are
+ * ignored.
+ */
+export function memoryWorkspaceBacking(_sql, _name) {
+    const files = new Map();
+    /** Immediate children of `dir`, as `readDir` reports them. */
+    const entriesUnder = (dir) => {
+        const prefix = dir === "" ? "" : `${dir}/`;
+        const seen = new Map();
+        for (const [path, content] of files) {
+            if (!path.startsWith(prefix))
+                continue;
+            const rest = path.slice(prefix.length);
+            if (rest === "")
+                continue;
+            const slash = rest.indexOf("/");
+            if (slash === -1) {
+                seen.set(path, {
+                    path,
+                    type: "file",
+                    size: new TextEncoder().encode(content).length
+                });
+            }
+            else {
+                // A directory exists only because something under it does, so report it
+                // once and say nothing about its size.
+                const child = `${prefix}${rest.slice(0, slash)}`;
+                seen.set(child, { path: child, type: "directory", size: 0 });
+            }
+        }
+        return [...seen.values()];
+    };
+    return {
+        readFile: async (path) => files.get(normalize(path)) ?? null,
+        writeFile: async (path, content) => {
+            files.set(normalize(path), content);
+        },
+        // Directories are implied by their contents, so a path with anything under
+        // it exists even though nothing ever created it.
+        exists: async (path) => {
+            const key = normalize(path);
+            return files.has(key) || entriesUnder(key).length > 0;
+        },
+        deleteFile: async (path) => files.delete(normalize(path)),
+        readDir: async (dir) => entriesUnder(normalize(dir ?? "")),
+        getWorkspaceInfo: async () => ({ fileCount: files.size })
+    };
+}
+/** Strip the leading/trailing slashes that would otherwise key two paths apart. */
+function normalize(path) {
+    return path.replace(/^\/+|\/+$/g, "");
+}
+/** Per-file byte ceiling — safely under the 2 MB Durable Object SQLite row limit. */
+export const WORKSPACE_MAX_FILE_BYTES = 512 * 1024;
+/** Max number of files in one workspace — a cheap guard against runaway writes. */
+export const WORKSPACE_MAX_FILES = 200;
+export class WorkspaceLimitError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "WorkspaceLimitError";
+    }
+}
+/**
+ * Build a {@link WorkspaceHandle} over a shell workspace (or a test fake),
+ * enforcing the per-file and file-count caps. The caps degrade a misbehaving
+ * recipe to an explicit error rather than letting it exceed the DO row limit or
+ * fill storage.
+ */
+export function makeWorkspaceHandle(ws) {
+    const byteLength = (s) => new TextEncoder().encode(s).length;
+    return {
+        read: (path) => ws.readFile(path),
+        async write(path, content) {
+            const bytes = byteLength(content);
+            if (bytes > WORKSPACE_MAX_FILE_BYTES) {
+                throw new WorkspaceLimitError(`file "${path}" is ${bytes} bytes, over the ${WORKSPACE_MAX_FILE_BYTES}-byte limit`);
+            }
+            // The cap bounds how many files exist, so it may only refuse a write that
+            // *creates* one. `exists` is the wrong question: it is true for a
+            // directory too (filesystem semantics, which every real backing has), so
+            // at the cap a write to `notes` — with `notes/a.txt` present — read as an
+            // overwrite and added a 201st file. `readFile` returning null is the only
+            // honest test for "there is no file here", and it runs solely when the
+            // workspace is already full, so the ordinary write still costs one call.
+            const { fileCount } = await ws.getWorkspaceInfo();
+            if (fileCount >= WORKSPACE_MAX_FILES &&
+                (await ws.readFile(path)) === null) {
+                throw new WorkspaceLimitError(`workspace already holds ${fileCount} files (max ${WORKSPACE_MAX_FILES})`);
+            }
+            await ws.writeFile(path, content);
+        },
+        exists: (path) => ws.exists(path),
+        remove: (path) => ws.deleteFile(path),
+        async list(dir) {
+            const entries = await ws.readDir(dir);
+            return entries.map((e) => ({
+                path: e.path,
+                type: e.type,
+                size: e.size
+            }));
+        },
+        async readJson(path) {
+            const raw = await ws.readFile(path);
+            return raw === null ? null : JSON.parse(raw);
+        },
+        async writeJson(path, value) {
+            await this.write(path, JSON.stringify(value, null, 2));
+        }
+    };
+}

package/dist/subtasks/catalog.d.ts

@@ -0,0 +1,40 @@
+import type { SessionMessage } from "agents/experimental/memory/session";
+import type { SubtaskReference } from "./types.js";
+/**
+ * One entry of the ephemeral, per-round reference catalog: a verbatim
+ * `user`/`assistant` turn plus the 1-based index the model selects it by.
+ * Structurally a {@link SubtaskReference} with an `index`, so selecting an entry
+ * and snapshotting it onto a Subtask is a plain subset copy.
+ */
+export interface ReferenceCatalogEntry extends SubtaskReference {
+    /** 1-based, ephemeral, per-round index the model references. */
+    index: number;
+}
+/**
+ * Whether a history message is a referenceable turn: a verbatim `user` or
+ * `assistant` turn with actual content.
+ *
+ * Compaction summaries are excluded via the SDK's `isCompactionMessage` (their
+ * `compaction_` id prefix) — they are generated text, never original conversation
+ * evidence. Whitespace-only turns are excluded because there is nothing to
+ * reference.
+ *
+ * This is the single eligibility rule, and it has exactly one caller:
+ * {@link file://../round/turn.ts renderTurnMessages} numbers the messages it accepts
+ * *and* marks those same messages with their `[ref N]` index, in one pass. One
+ * predicate, one walk — the marked messages and the catalog indices cannot drift.
+ *
+ * What that leaves eligible: verbatim `user` and `assistant` turns with content.
+ * System prompts, context blocks, and anything a tool injected never appear as
+ * plain history messages, so they are excluded structurally. Whitespace-only
+ * turns are skipped — there is nothing to reference, and since the model only
+ * ever selects from the catalog the renderer returns, skipping them cannot
+ * misalign indices.
+ *
+ * The inbound user turn is appended to the Session before the round infers, so
+ * one catalog covers both the current task input and past turns. The selected
+ * entries' exact text is snapshotted onto the Subtask when the round delegates,
+ * so nothing is resolved lazily and later compaction cannot affect a Subtask in
+ * flight.
+ */
+export declare function isCatalogEligible(message: SessionMessage): boolean;

package/dist/subtasks/catalog.js

@@ -0,0 +1,36 @@
+import { isCompactionMessage } from "agents/experimental/memory/utils";
+import { sessionText } from "../agent/history.js";
+/**
+ * Whether a history message is a referenceable turn: a verbatim `user` or
+ * `assistant` turn with actual content.
+ *
+ * Compaction summaries are excluded via the SDK's `isCompactionMessage` (their
+ * `compaction_` id prefix) — they are generated text, never original conversation
+ * evidence. Whitespace-only turns are excluded because there is nothing to
+ * reference.
+ *
+ * This is the single eligibility rule, and it has exactly one caller:
+ * {@link file://../round/turn.ts renderTurnMessages} numbers the messages it accepts
+ * *and* marks those same messages with their `[ref N]` index, in one pass. One
+ * predicate, one walk — the marked messages and the catalog indices cannot drift.
+ *
+ * What that leaves eligible: verbatim `user` and `assistant` turns with content.
+ * System prompts, context blocks, and anything a tool injected never appear as
+ * plain history messages, so they are excluded structurally. Whitespace-only
+ * turns are skipped — there is nothing to reference, and since the model only
+ * ever selects from the catalog the renderer returns, skipping them cannot
+ * misalign indices.
+ *
+ * The inbound user turn is appended to the Session before the round infers, so
+ * one catalog covers both the current task input and past turns. The selected
+ * entries' exact text is snapshotted onto the Subtask when the round delegates,
+ * so nothing is resolved lazily and later compaction cannot affect a Subtask in
+ * flight.
+ */
+export function isCatalogEligible(message) {
+    if (message.role !== "user" && message.role !== "assistant")
+        return false;
+    if (isCompactionMessage(message))
+        return false;
+    return sessionText(message).trim().length > 0;
+}

package/dist/subtasks/decomposition.d.ts

@@ -0,0 +1,85 @@
+import { z } from "zod";
+import type { ReferenceCatalogEntry } from "./catalog.js";
+import { type SubtaskTypeRegistry } from "./subtask-types.js";
+import type { DecompositionProposal, SubtaskDraft } from "./types.js";
+/**
+ * Pure validation and resolution of a `delegate` call's input. No model, no
+ * Session, no database — given a {@link DecompositionProposal} and the ephemeral
+ * reference catalog it was generated against, this either produces the drafts to
+ * persist or throws.
+ *
+ * One invariant lives here: **the model selects references by index only.** It
+ * emits catalog indices; this module copies the catalog entry's exact role+text
+ * onto the draft. Model output never becomes reference text, so a Subtask cannot
+ * carry a rewritten, summarized, or fabricated "quote" of the conversation.
+ *
+ * A proposal's subtasks are **independent of one another**: they all run at once
+ * and none can read another's output, so there is no graph to validate and
+ * nothing to order. Sequencing is expressed across rounds instead — the main
+ * agent delegates, reads the results, and delegates the next step.
+ *
+ * Invalid output is never repaired: a throw fails the attempt, which falls back to
+ * the other model, and two failed attempts fail the parent Task. Silently
+ * synthesizing a general Subtask would deliver plausible work the user never asked
+ * for.
+ */
+/** A model proposal that cannot be resolved into a valid decomposition. */
+export declare class DecompositionValidationError extends Error {
+    constructor(message: string);
+}
+/**
+ * A required string that is not whitespace.
+ *
+ * Written as a `.regex()` rather than the equivalent `.refine()`, deliberately.
+ * Both are enforced wherever this schema is actually run, but a refinement is
+ * **invisible to the model**: custom checks do not survive JSON-Schema conversion,
+ * so the rule would be one the model is held to without ever being shown it.
+ * `/\S/` converts to `"pattern": "\\S"` next to `"minLength": 1`, so the
+ * constraint reaches the model as part of the tool schema, on every field, with
+ * no per-field `.describe()` needed to restate it.
+ *
+ * Being shown a rule is not the same as being held to it. This schema reaches
+ * the model through a **control** tool, which has no `execute`, so the SDK never
+ * validates its input — what enforces the constraint is
+ * {@link file://../agent/control.ts control.ts}, which parses every control call
+ * with the tool's own schema before the round uses it.
+ */
+export declare const nonBlank: (label: string) => z.ZodString;
+/**
+ * The `delegate` tool's input schema. The per-round bound is enforced here
+ * (the model is told it, and the SDK rejects a call that breaks it) and again in
+ * the data layer, which owns the durable invariant.
+ *
+ * Blank strings are rejected at the schema edge rather than deep in execution: an
+ * empty `prompt` would otherwise burn a Subtask slot and only fail later, inside
+ * the child, with no useful diagnostic.
+ *
+ * `referenceIndexes` is optional because this one schema also has to describe the
+ * calls **reconstructed from durable rows** in later rounds, whose references
+ * were resolved to verbatim snapshots at the time and no longer have indices.
+ */
+export declare function makeDecompositionProposalSchema(types: SubtaskTypeRegistry, maxSubtasks: number): z.ZodObject<{
+    reply: z.ZodString;
+    subtasks: z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        prompt: z.ZodString;
+        referenceIndexes: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        params: z.ZodOptional<z.ZodObject<{
+            [x: string]: z.ZodType<string | undefined, unknown, z.core.$ZodTypeInternals<string | undefined, unknown>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Resolve a validated model proposal into the drafts to persist.
+ *
+ * Throws {@link DecompositionValidationError} on any structural problem: blank
+ * fields, unknown or duplicate reference indices, and params a type refuses. On
+ * success, array order is preserved — the data layer derives each Subtask's
+ * `ordinal` from it.
+ */
+export declare function resolveDecomposition(proposal: DecompositionProposal, catalog: ReferenceCatalogEntry[], types: SubtaskTypeRegistry): {
+    reply: string;
+    drafts: SubtaskDraft[];
+};

package/dist/subtasks/decomposition.js

@@ -0,0 +1,156 @@
+import { z } from "zod";
+import { SubtaskParamsError } from "./subtask-types.js";
+/**
+ * Pure validation and resolution of a `delegate` call's input. No model, no
+ * Session, no database — given a {@link DecompositionProposal} and the ephemeral
+ * reference catalog it was generated against, this either produces the drafts to
+ * persist or throws.
+ *
+ * One invariant lives here: **the model selects references by index only.** It
+ * emits catalog indices; this module copies the catalog entry's exact role+text
+ * onto the draft. Model output never becomes reference text, so a Subtask cannot
+ * carry a rewritten, summarized, or fabricated "quote" of the conversation.
+ *
+ * A proposal's subtasks are **independent of one another**: they all run at once
+ * and none can read another's output, so there is no graph to validate and
+ * nothing to order. Sequencing is expressed across rounds instead — the main
+ * agent delegates, reads the results, and delegates the next step.
+ *
+ * Invalid output is never repaired: a throw fails the attempt, which falls back to
+ * the other model, and two failed attempts fail the parent Task. Silently
+ * synthesizing a general Subtask would deliver plausible work the user never asked
+ * for.
+ */
+/** A model proposal that cannot be resolved into a valid decomposition. */
+export class DecompositionValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "DecompositionValidationError";
+    }
+}
+/**
+ * A required string that is not whitespace.
+ *
+ * Written as a `.regex()` rather than the equivalent `.refine()`, deliberately.
+ * Both are enforced wherever this schema is actually run, but a refinement is
+ * **invisible to the model**: custom checks do not survive JSON-Schema conversion,
+ * so the rule would be one the model is held to without ever being shown it.
+ * `/\S/` converts to `"pattern": "\\S"` next to `"minLength": 1`, so the
+ * constraint reaches the model as part of the tool schema, on every field, with
+ * no per-field `.describe()` needed to restate it.
+ *
+ * Being shown a rule is not the same as being held to it. This schema reaches
+ * the model through a **control** tool, which has no `execute`, so the SDK never
+ * validates its input — what enforces the constraint is
+ * {@link file://../agent/control.ts control.ts}, which parses every control call
+ * with the tool's own schema before the round uses it.
+ */
+export const nonBlank = (label) => z
+    .string()
+    .min(1)
+    .regex(/\S/, { message: `${label} must not be blank` });
+function makeSubtaskProposalSchema(types) {
+    return z.object({
+        // A closed enum, not prose: an invented type is rejected by the tool schema
+        // itself rather than silently resolving to some default recipe.
+        type: z.enum(types.enumKeys()),
+        prompt: nonBlank("prompt"),
+        referenceIndexes: z.array(z.number().int().min(1)).optional(),
+        /**
+         * The type's required inputs — ids the model quotes from a tool result.
+         * Every key any type declares is named here, gathered from those types by
+         * `SubtaskTypeRegistry.paramProperties`; which of them a given type actually
+         * *requires* is the per-type contract, checked below.
+         *
+         * Named keys rather than a free-form record, deliberately: a record's value
+         * schema is the JSON Schema `additionalProperties` slot, which the AI SDK's
+         * strict-mode pass overwrites with `false` — turning "any string key" into
+         * "no key at all" and leaving the model no legal way to send params it was
+         * told to send. Explicit properties survive that pass, and say more besides.
+         */
+        params: z.object(types.paramProperties()).optional()
+    });
+}
+/**
+ * The `delegate` tool's input schema. The per-round bound is enforced here
+ * (the model is told it, and the SDK rejects a call that breaks it) and again in
+ * the data layer, which owns the durable invariant.
+ *
+ * Blank strings are rejected at the schema edge rather than deep in execution: an
+ * empty `prompt` would otherwise burn a Subtask slot and only fail later, inside
+ * the child, with no useful diagnostic.
+ *
+ * `referenceIndexes` is optional because this one schema also has to describe the
+ * calls **reconstructed from durable rows** in later rounds, whose references
+ * were resolved to verbatim snapshots at the time and no longer have indices.
+ */
+export function makeDecompositionProposalSchema(types, maxSubtasks) {
+    return z.object({
+        reply: nonBlank("reply"),
+        subtasks: z.array(makeSubtaskProposalSchema(types)).min(1).max(maxSubtasks)
+    });
+}
+/**
+ * Snapshot the selected catalog entries onto a draft: validate every index against
+ * the catalog, reject duplicates, and copy each entry's exact role+text. Indexes
+ * are stored ascending so a Subtask's references read in conversation order
+ * regardless of the order the model listed them.
+ *
+ * `label` names the offending subtask by its 1-based position in the proposal —
+ * the only handle a subtask has, and the one the model can map back to what it
+ * just wrote.
+ */
+function resolveReferences(label, referenceIndexes, catalog) {
+    if (!referenceIndexes)
+        return [];
+    const seen = new Set();
+    for (const index of referenceIndexes) {
+        if (seen.has(index)) {
+            throw new DecompositionValidationError(`${label} references index ${index} more than once`);
+        }
+        seen.add(index);
+        if (index > catalog.length) {
+            throw new DecompositionValidationError(`${label} references unknown catalog index ${index} ` +
+                `(catalog has ${catalog.length} ${catalog.length === 1 ? "entry" : "entries"})`);
+        }
+    }
+    return [...referenceIndexes]
+        .sort((a, b) => a - b)
+        .map((index) => {
+        // The catalog is 1-based; copy role+text verbatim (never the model's words).
+        const entry = catalog[index - 1];
+        return { role: entry.role, text: entry.text };
+    });
+}
+/**
+ * Resolve a validated model proposal into the drafts to persist.
+ *
+ * Throws {@link DecompositionValidationError} on any structural problem: blank
+ * fields, unknown or duplicate reference indices, and params a type refuses. On
+ * success, array order is preserved — the data layer derives each Subtask's
+ * `ordinal` from it.
+ */
+export function resolveDecomposition(proposal, catalog, types) {
+    const drafts = proposal.subtasks.map((s, index) => {
+        const label = `subtask ${index + 1}`;
+        const type = s.type.trim();
+        let params;
+        try {
+            // Shape only. Whether an id names a row that exists — and is still usable —
+            // is a question for durable state, answered when the execution starts.
+            params = types.validateParams(type, s.params);
+        }
+        catch (err) {
+            if (!(err instanceof SubtaskParamsError))
+                throw err;
+            throw new DecompositionValidationError(`${label}: ${err.message}`);
+        }
+        return {
+            type,
+            prompt: s.prompt.trim(),
+            references: resolveReferences(label, s.referenceIndexes, catalog),
+            params
+        };
+    });
+    return { reply: proposal.reply.trim(), drafts };
+}

package/dist/subtasks/delegate.d.ts

@@ -0,0 +1,120 @@
+import { type Tool } from "ai";
+import type { SubtaskTypeRegistry } from "./subtask-types.js";
+import type { CompositionBranch, DecompositionProposal, SubtaskId, SubtaskStatus } from "./types.js";
+/**
+ * The `delegate` tool — the single act by which the main agent hands work to
+ * subagents, and the shape both ends of that act agree on.
+ *
+ * Delegation is a **durable tool call**: a round emits it for real (the model
+ * picks it and fills its input), the Workflow performs it over minutes or hours,
+ * and a later round reassembles the call with its result to keep working. The two
+ * halves are separated by a Workflow boundary, not by a fiction — nothing here is
+ * fabricated on the model's behalf.
+ *
+ * This module owns the tool's identity because every round depends on it
+ * agreeing: a later round pairs a synthesized `tool-result` to an earlier round's
+ * `tool-call` by name and id, and a mismatch would not throw — it would silently
+ * produce a malformed history that the model quietly misreads.
+ */
+export declare const DELEGATE_TOOL_NAME = "delegate";
+/**
+ * The tool as the model sees it. Deliberately **without `execute`**: the Workflow
+ * performs this call, durably, outside the inference — so there is nothing for the
+ * SDK to run, and the tool loop halts on the call rather than trying to continue
+ * past it. That is what makes it a *control* tool: unlike the agent's work tools
+ * (`set_context`, and whatever the installed plugins offer), calling it ends the
+ * round.
+ *
+ * Its `inputSchema` is the delegation contract itself, and it is the **only**
+ * declaration of this tool. One schema has to serve both directions — the calls
+ * the model emits now, and the calls reconstructed from durable rows in later
+ * rounds — because a provider cannot be shown two shapes for one tool name in a
+ * single request. See {@link delegateCallInput} for how a durable row is rendered
+ * back into it.
+ *
+ * Built per registry rather than declared as a module constant: both the type
+ * enum in its schema and the catalogue in its description are facts about which
+ * plugins are installed, and in the predecessor repo both were frozen at import
+ * time — which is exactly what made the type set unoverridable.
+ */
+export declare function makeDelegateTool(types: SubtaskTypeRegistry, maxSubtasks: number): Tool;
+/**
+ * The call's id, derived from the parent Task and the round that emitted it —
+ * deterministic and replay-safe, the same discipline as the Session message ids
+ * it sits alongside (see {@link file://../agent/history.ts}). Later rounds rebuild it
+ * rather than storing it.
+ *
+ * **Underscores, not colons, and this is load-bearing.** Unlike a Session message
+ * id, this one is sent to a provider as a `tool_use.id`, and Anthropic validates
+ * that field against `^[a-zA-Z0-9_-]+$`. The colon-separated form this used to
+ * return failed every round from the first delegation onwards — round 0 was fine
+ * because the model authors its own ids, and round 1 reconstructs this one, so
+ * the request 400d deterministically on both the primary and the fallback until
+ * the deterministic join fired. Workers AI never validated the field, which is
+ * why it took a Claude-backed agent to surface it.
+ *
+ * Nothing persists this: both halves of the pair are rebuilt together on every
+ * request, so changing the shape needs no migration. There is no longer a
+ * provider-side backstop in core — the adapter that carried one went with
+ * `./anthropic` in 0.8.0 — so a provider added here that validates tool-call ids
+ * needs to sanitize them on its own way out.
+ */
+export declare function delegateToolCallId(taskId: string, round: number): string;
+/**
+ * One branch's outcome, as the tool result carries it. `output` carries the
+ * branch's report when it completed and its failure reason when it did not.
+ *
+ * **A failed branch says why, and that is a reversal worth explaining.** This
+ * used to be `null` for anything that did not complete, on the principle that
+ * internal diagnostics never reach the model. The principle was right about
+ * *diagnostics* and wrong about this field: what a facet writes into `error` is
+ * not a stack trace, it is a sentence addressed to the delegating model —
+ * "there is no checkout in this workspace yet… clone the repository before
+ * delegating", "every credential has reached its limit; send this request again
+ * after that". Withholding those left the parent with `status: "failed"` and
+ * nothing else, and a parent that cannot tell a transient failure from a
+ * permanent one retries. In the run that prompted this it retried twelve times
+ * over nine minutes, then apologised to the user for a wall it was never shown.
+ *
+ * What replaces the old rule is a constraint on the writer rather than a filter
+ * here: **an `error` is model-visible, so a facet must write it in words that
+ * are safe for one to read and act on.** Bounded by {@link MAX_OUTPUT_CHARS} on
+ * the way through, because a facet that ignores that is a context-window
+ * problem rather than a disclosure one.
+ *
+ * Still one field, not two. The model's question is "what came back from this
+ * branch", and `status` already says which kind of answer it is getting.
+ *
+ * A type alias, not an interface: this is serialized as the tool result's
+ * `JSONValue`, and only aliases get the implicit index signature that satisfies.
+ */
+export type DelegateSubtaskOutcome = {
+    subtaskId: SubtaskId;
+    type: string;
+    status: SubtaskStatus;
+    output: string | null;
+};
+/**
+ * Rebuild one round's call input from its durable rows, in stable ordinal order.
+ * Typed as {@link DecompositionProposal} — the same type the model's own calls
+ * are validated into — so the reconstructed call and an emitted one cannot drift
+ * apart in shape.
+ *
+ * `referenceIndexes` is omitted rather than faked: this round's references were
+ * snapshotted verbatim onto the rows when it ran, and the catalog they were
+ * chosen from is long gone.
+ *
+ * A subtask proposal carries no identifier of its own, so the model pairs each
+ * entry here with its outcome **by position**: both arrays are built from the
+ * same ordinal-ordered `branches`, and the outcome additionally repeats `type`
+ * and carries the durable `subtaskId`.
+ */
+export declare function delegateCallInput(reply: string, branches: CompositionBranch[]): DecompositionProposal;
+/**
+ * Rebuild one round's call result from its durable rows, in stable ordinal order.
+ *
+ * A completed branch reports its parts; any other branch reports its `error`, or
+ * `null` when it has none to give — a cancelled branch usually does not, and
+ * inventing a sentence for it would be worse than the absence.
+ */
+export declare function delegateCallOutput(branches: CompositionBranch[]): DelegateSubtaskOutcome[];