@loopingai/core 0.3.0 → 0.4.0

package/dist/round/turn.js

@@ -0,0 +1,497 @@
+import { generateText, hasToolCall, isStepCount } from "ai";
+import { appendOnce } from "../agent/session.js";
+import { deterministicSessionMessage, finalReplyMessageId, parseRoundAckMessageId, roundAckMessageId, sessionText, taskUserMessageId } from "../agent/history.js";
+import { buildIntermediateContentHandler, isTransientAiError } from "../agent/inference.js";
+import { controlTools, controlToolSet } from "../agent/control.js";
+import { FINAL_REPLY_TOOL_NAME } from "../agent/final-reply.js";
+import { stepAllowance } from "../agent/budget.js";
+import { DELEGATE_TOOL_NAME, delegateCallInput, delegateCallOutput, delegateToolCallId } from "../subtasks/delegate.js";
+import { isCatalogEligible } from "../subtasks/catalog.js";
+/**
+ * Build both prompt suffixes for one configured agent.
+ *
+ * The agent's contract, then whatever the delegable types have to say about being
+ * delegated — each declared by the type that owns it (`SubtaskTypeSpec`) and
+ * collected by the runtime's registry, so no domain is named by the policy. That
+ * is the rule the two prompt fields on a subtask type exist to hold: everything
+ * the main agent is told about a domain is declared by the plugin that owns it,
+ * never written inside the loop.
+ */
+export function buildTurnInstructions(policy, types, maxSubtasks, limits) {
+    const guidance = types.renderDelegationGuidance({
+        delegateTool: DELEGATE_TOOL_NAME,
+        finalReplyTool: FINAL_REPLY_TOOL_NAME
+    });
+    const open = policy.roundContract({ typeKeys: types.keys, maxSubtasks }) +
+        (guidance ? `\n\n${guidance}` : "");
+    return { open, final: open + policy.finalRoundNote(limits) };
+}
+/** Join one branch's parts into its text block. */
+function branchText(branch) {
+    return (branch.resultParts ?? []).map((p) => p.text).join("\n");
+}
+/** Group every branch by the round that delegated it, preserving ordinal order. */
+function byRound(branches) {
+    const rounds = new Map();
+    for (const branch of branches) {
+        const existing = rounds.get(branch.round);
+        if (existing)
+            existing.push(branch);
+        else
+            rounds.set(branch.round, [branch]);
+    }
+    return rounds;
+}
+/**
+ * Rebuild one round's `delegate` call and pair it with its result.
+ *
+ * Both halves are real. That round's model genuinely emitted this call; the
+ * subagents genuinely produced these outcomes. All that separates them is a
+ * Workflow boundary and, often, hours — so the pair is reconstructed here rather
+ * than carried, from the durable rows that are the record of what happened.
+ *
+ * Failed and skipped branches are included so the model can disclose them rather
+ * than quietly answering as if the work had been done; their diagnostics are not
+ * (see `delegateCallOutput`).
+ */
+function delegationPair(taskId, round, replyText, branches) {
+    const toolCallId = delegateToolCallId(taskId, round);
+    const content = [];
+    // The acknowledgment the user already saw, if it is still in history.
+    if (replyText)
+        content.push({ type: "text", text: replyText });
+    content.push({
+        type: "tool-call",
+        toolCallId,
+        toolName: DELEGATE_TOOL_NAME,
+        input: delegateCallInput(replyText ?? "", branches)
+    });
+    return [
+        { role: "assistant", content },
+        {
+            role: "tool",
+            content: [
+                {
+                    type: "tool-result",
+                    toolCallId,
+                    toolName: DELEGATE_TOOL_NAME,
+                    output: { type: "json", value: delegateCallOutput(branches) }
+                }
+            ]
+        }
+    ];
+}
+/**
+ * Render the model's view for one round: the conversation, with every earlier
+ * round's delegation restored as the call-and-result it actually was, and every
+ * referenceable turn marked with the catalog index the model selects it by.
+ *
+ * One pass, two jobs, because they have to agree. The `[ref N]` markers use
+ * `isCatalogEligible` — the same predicate the catalog is numbered with — so a
+ * marker and its entry can never drift: compaction summaries (`assistant` role,
+ * generated) stay in the messages unmarked, readable for context but structurally
+ * uncitable as conversation evidence, which is exactly the intent.
+ *
+ * A round's acknowledgment is stored as plain assistant text (history is
+ * text-only, and stays that way — `sessionText`, the catalog, compaction, and
+ * recall all read text parts). So its `delegate` call is re-attached to that
+ * message here, and the result appended after it, for this one inference call. The
+ * pair is emitted together, anchored on the ack's deterministic id, so a `tool`
+ * message can never be orphaned from its call — and an ack that has been compacted
+ * away still gets its pair, appended at the end minus the acknowledgment text: a
+ * result the model cannot place beats a malformed history.
+ *
+ * Acks are deliberately **not** catalog-eligible: they are the agent's own
+ * scaffolding, and a subtask referencing "I'm on it" as verbatim conversation
+ * evidence would be noise. That holds for every ack in the Session, not only the
+ * ones this render can pair with branches — see `parseRoundAckMessageId`.
+ *
+ * Everything here is ephemeral — scaffolding for this call only. Reference text is
+ * snapshotted from the catalog, so no `[ref N]` prefix ever reaches a Subtask, and
+ * the Session never sees any of this markup.
+ */
+export function renderTurnMessages(history, taskId, branches) {
+    const rounds = byRound(branches);
+    const ackIds = new Map([...rounds.keys()].map((round) => [roundAckMessageId(taskId, round), round]));
+    const catalog = [];
+    const messages = [];
+    const anchored = new Set();
+    for (const message of history) {
+        if (message.role !== "user" && message.role !== "assistant")
+            continue;
+        const role = message.role;
+        const text = sessionText(message);
+        const round = ackIds.get(message.id);
+        if (round !== undefined) {
+            messages.push(...delegationPair(taskId, round, text, rounds.get(round) ?? []));
+            anchored.add(round);
+            continue;
+        }
+        // An acknowledgment with no branches behind it — recognized by id, since
+        // nothing in the message body distinguishes an ack from ordinary assistant
+        // prose. This Task's own is the crash-window leftover: the ack landed, the
+        // rows did not, and this render belongs to the retry that will decide the
+        // round again. Dropping it is what makes that retry a clean re-decision —
+        // left in, it reads as "already delegated" and invites the model to answer
+        // instead of delegating, ending the Task with no work done. Another Task's
+        // ack is real history the user saw, so it stays as context, but uncitable:
+        // no round of *this* Task can hold it up as conversation evidence.
+        const ack = parseRoundAckMessageId(message.id);
+        if (ack) {
+            if (ack.taskId !== taskId)
+                messages.push({ role, content: text });
+            continue;
+        }
+        if (!isCatalogEligible(message)) {
+            // Not referenceable (a compaction summary): still context for reasoning.
+            messages.push({ role, content: text });
+            continue;
+        }
+        const index = catalog.length + 1;
+        catalog.push({ index, role, text });
+        messages.push({ role, content: `[ref ${index}] ${text}` });
+    }
+    // Rounds whose acknowledgment is no longer in history (compacted away by a
+    // concurrent task), in round order so the results still read chronologically.
+    const orphaned = [...rounds.entries()]
+        .filter(([round]) => !anchored.has(round))
+        .sort(([a], [b]) => a - b);
+    for (const [round, roundBranches] of orphaned) {
+        messages.push(...delegationPair(taskId, round, null, roundBranches));
+    }
+    return { messages, catalog };
+}
+/**
+ * Deterministic fallback reply: the successful branches' text in ordinal order,
+ * plus the policy's short note when some branches did not succeed.
+ *
+ * Used when a round's inference is unavailable but its predecessors' work is
+ * durable. Failing the whole Task because the answering model is down would throw
+ * away good results the user asked for.
+ */
+export function joinSuccessfulBranches(branches, partialNote) {
+    const successes = branches.filter((b) => b.status === "completed");
+    const body = successes.map(branchText).join("\n\n");
+    const incomplete = branches.length > successes.length;
+    return incomplete ? `${body}\n\n${partialNote}` : body;
+}
+/**
+ * One attempt against a single model: let it work, and take whichever ending it
+ * lands on.
+ *
+ * Takes the model **factory**, not a model: resolving it can throw (a missing
+ * binding, a bad id), and that has to count as this attempt failing so the other
+ * model still gets its turn.
+ *
+ * The model uses its work tools freely — answering well can genuinely need a
+ * lookup or a recall — and the loop ends by calling a control tool. None has an
+ * `execute`, so there is nothing to continue from and the loop halts on the call.
+ * Two endings in one step are resolved by `ControlTool.precedence`.
+ *
+ * Every control call is then parsed by the tool that owns it, because nothing else
+ * has: an execute-less tool's input never passes through the SDK's validation. A
+ * parse failure comes back as `rejected` — a repairable failure, not a dead
+ * attempt.
+ *
+ * Charges the budget as it goes, whether it succeeds or not: a failed attempt cost
+ * exactly as much as a successful one, and a call that died on its fourth step
+ * still spent four turns.
+ */
+async function attempt(args, control, model, instructions, messages) {
+    const final = args.mode === "final";
+    // A `final` round is handed nothing to work with, only the way out. Leaving the
+    // work tools on would invite it to spend a budget it has already spent — and
+    // the composing round has every branch result in its messages already, so the
+    // thing it needs is not a lookup but an ending.
+    const workTools = final ? {} : args.tools;
+    // One step per attempt for a `final` round: it exists to produce the answer, and
+    // that answer is deliberately spent *beyond* the budget rather than out of it.
+    //
+    // An `open` round gets whatever the shared budget still holds, read here rather
+    // than at the top of the round — so the fallback sees what the primary spent
+    // without anyone having to subtract it. See `stepAllowance` for the floor.
+    const stepBudget = final
+        ? 1
+        : stepAllowance(args.budget.allowance, args.budget.spent);
+    const content = args.onContent
+        ? buildIntermediateContentHandler(args.onContent, [
+            DELEGATE_TOOL_NAME,
+            FINAL_REPLY_TOOL_NAME
+        ])
+        : undefined;
+    try {
+        const result = await generateText({
+            model: model(),
+            instructions,
+            messages,
+            // Control tools are declared *first*: tool order is part of the prompt, and
+            // the two endings are the thing every round has to reach. Work tool names
+            // are compile-time constants and none collides with a control name, so the
+            // spread order costs nothing.
+            tools: { ...controlToolSet(control), ...workTools },
+            // Every ending is a control call, so the model must always call something.
+            // Work tools stay freely available — `required` constrains the *shape* of a
+            // step's output, not which tool is chosen.
+            toolChoice: "required",
+            maxOutputTokens: args.maxOutputTokens,
+            stopWhen: [
+                isStepCount(stepBudget),
+                // Halt on any ending this round declares, so a new control tool needs no
+                // change here.
+                ...control.map((c) => hasToolCall(c.name))
+            ],
+            // We do our own primary → fallback recovery, so disable the SDK's
+            // per-model backoff (it would only add latency and duplicate the fallback).
+            maxRetries: 0,
+            // Charged here rather than from `result.steps` so a throw mid-loop still
+            // bills the steps already spent — the `catch` below has no `result` to read.
+            onStepEnd: async (step) => {
+                args.budget.spent += 1;
+                if (content)
+                    await content(step);
+            }
+        });
+        // The most committal ending the model reached, and every call it made to that
+        // tool. Ranking by precedence rather than by position keeps "which ending
+        // wins" a property the tools declare, not a chain of ifs here.
+        const reached = control
+            .map((c) => ({
+            control: c,
+            inputs: result.toolCalls
+                .filter((call) => call.toolName === c.name)
+                .map((call) => call.input)
+        }))
+            .filter((c) => c.inputs.length > 0)
+            .sort((a, b) => b.control.precedence - a.control.precedence)[0];
+        if (reached) {
+            // The call that counts, per the tool — a repeated `final_reply` means its
+            // last one. Held outside the `try` so a rejection shows the model *that*
+            // call and not whichever came first, which it may already have moved past.
+            // Only a `select` that throws leaves it unresolved, and that error is about
+            // the repeats themselves, so the first call represents them as well as any.
+            let subject = reached.inputs[0];
+            try {
+                subject = reached.control.select(reached.inputs);
+                return { ok: true, decision: reached.control.parse(subject) };
+            }
+            catch (error) {
+                // The model ended the round but the call cannot be used. Repairable: it is
+                // handed this error and asked again, rather than costing the whole slot.
+                return {
+                    ok: false,
+                    error,
+                    rejected: {
+                        toolName: reached.control.name,
+                        input: subject
+                    }
+                };
+            }
+        }
+        // No control call. Either the model ran out of steps mid-tool-use, or it
+        // ignored `toolChoice: "required"` and narrated an action instead of taking
+        // one — the failure this whole design exists to catch. Failing the attempt
+        // hands the round to the fallback model rather than shipping the narration to
+        // the user as if it were an answer.
+        if (result.finishReason === "length") {
+            console.warn("[turn] model output truncated", {
+                taskId: args.taskId,
+                round: args.round,
+                maxOutputTokens: args.maxOutputTokens
+            });
+        }
+        return {
+            ok: false,
+            error: new Error(`round produced no decision (finishReason=${result.finishReason}, textLength=${result.text.trim().length})`)
+        };
+    }
+    catch (error) {
+        return { ok: false, error };
+    }
+}
+/**
+ * How many times one model may be shown its own rejected control call and asked
+ * again, before the round gives up on that slot.
+ *
+ * Repair belongs to the **slot**, not the round. A rejected call is not evidence
+ * that a model is unavailable — it is a model that understood the request and got
+ * the shape wrong, which is the one failure it can actually fix once it is shown
+ * the rejection. Falling straight through to the fallback instead spends a whole
+ * second model on a fresh guess that has no idea the first one failed: that is how
+ * two slots produced the identical missing-param error and killed a round either
+ * of them could have repaired.
+ *
+ * The fallback keeps its real job — covering a primary that could not answer at
+ * all — and is still reached once repairs run out, since a model that cannot get
+ * the shape right in four tries has earned a second opinion.
+ */
+const MAX_REPAIR_ATTEMPTS = 3;
+/**
+ * The id a repaired exchange is anchored on, derived from the Task and round like
+ * every other id here. Suffixed per repair, so several rejected calls can sit in
+ * one attempt's messages without colliding.
+ */
+function controlCallId(taskId, round) {
+    return `task:${taskId}:round:${round}:control`;
+}
+/**
+ * A rejected control call paired with its rejection, as the exchange the model has
+ * to see in order to fix it.
+ *
+ * This is deliberately the same shape the SDK produces for a work tool that failed
+ * — the call, then an `error-text` result carrying the reason. A work tool gets
+ * this for free and models already know how to read it; a control tool halts the
+ * loop before the SDK can, so the round builds it by hand. Nothing here is
+ * specific to which control tool was refused.
+ *
+ * Shaped as a real tool exchange rather than a prose "that was wrong" user turn,
+ * because that is what it is — and an assistant tool-call with no matching result
+ * is a malformed message list to every provider.
+ *
+ * Entirely ephemeral. These messages exist for the next `generateText` call and are
+ * never appended to the Session: the durable record of a round is the ending it
+ * landed on, and a call that was thrown out is not something a later round should
+ * be able to read back as history.
+ */
+function repairExchange(toolCallId, rejected, error) {
+    return [
+        {
+            role: "assistant",
+            content: [
+                {
+                    type: "tool-call",
+                    toolCallId,
+                    toolName: rejected.toolName,
+                    input: rejected.input
+                }
+            ]
+        },
+        {
+            role: "tool",
+            content: [
+                {
+                    type: "tool-result",
+                    toolCallId,
+                    toolName: rejected.toolName,
+                    output: {
+                        type: "error-text",
+                        value: `${String(error)}\n\n` +
+                            `The round did not end and nothing was started. Call ${rejected.toolName} ` +
+                            `again, keeping the parts that were fine and fixing only what the error names.`
+                    }
+                }
+            ]
+        }
+    ];
+}
+/**
+ * Run one round against the continuous Session: append the user turn (round 0),
+ * let the model decide over the indexed history, validate any delegation against
+ * this round's catalog, and persist what the user will see.
+ *
+ * Every append uses a deterministic id, so a Workflow-step re-run neither
+ * duplicates the turn nor changes an already-delivered reply.
+ *
+ * Two nested recoveries, and they answer different failures. Within a slot, a
+ * decomposition the catalog rejects is handed back to the *same* model as a failed
+ * tool result, up to {@link MAX_REPAIR_ATTEMPTS} times — a shape error is the one
+ * thing a model can fix once it sees it. Across slots, an attempt that produced no
+ * decision at all moves to the fallback model, which is what that slot is for.
+ *
+ * Throws only on a transient platform fault (for the Workflow step to retry).
+ * A deterministic failure that outlasts every repair on both slots, with durable
+ * work behind it, degrades to {@link joinSuccessfulBranches} rather than discarding
+ * completed branches; with nothing behind it, it resolves to `{ status: "failed" }`.
+ */
+export async function runTurn(args) {
+    const { session, taskId, round, text, systemSuffix, models, branches } = args;
+    if (round === 0) {
+        await appendOnce(session, deterministicSessionMessage(taskUserMessageId(taskId), "user", text));
+    }
+    const history = await session.getHistory();
+    const { messages, catalog } = renderTurnMessages(history, taskId, branches);
+    const system = (await session.refreshSystemPrompt()) +
+        systemSuffix +
+        (args.mode === "final" ? args.instructions.final : args.instructions.open);
+    // This round's endings, built with the catalog a `delegate` is checked against.
+    const control = controlTools({
+        catalog,
+        delegable: args.mode !== "final",
+        types: args.types,
+        maxSubtasks: args.maxSubtasks
+    });
+    const diagnostics = [];
+    const errors = [];
+    for (const slot of ["primary", "fallback"]) {
+        const modelId = slot === "primary" ? models.primaryId() : models.fallbackId();
+        const model = slot === "primary" ? models.primary : models.fallback;
+        // This slot's own view: the round's messages plus whatever repair exchange it
+        // accumulates. A fresh copy per slot, so a fallback that is reached is never
+        // handed the primary's rejected calls to be confused by.
+        const slotMessages = [...messages];
+        for (let repair = 0; repair <= MAX_REPAIR_ATTEMPTS; repair += 1) {
+            // Both slots draw on the one `args.budget`, which each attempt reads on entry
+            // and charges as it works. A fallback attempt is spend, not a free retry —
+            // and so is a repair.
+            const outcome = await attempt(args, control, model, system, slotMessages);
+            if (!outcome.ok) {
+                errors.push(outcome.error);
+                const { rejected } = outcome;
+                diagnostics.push(rejected
+                    ? `${slot} (${modelId}, attempt ${repair + 1}): ${String(outcome.error)}`
+                    : `${slot} (${modelId}): ${String(outcome.error)}`);
+                console.warn(rejected
+                    ? "[turn] control call rejected"
+                    : "[turn] model attempt failed", {
+                    taskId,
+                    round,
+                    model: modelId,
+                    ...(rejected ? { tool: rejected.toolName, repair } : {}),
+                    error: String(outcome.error)
+                });
+                // No rejected call means no ending to correct — the attempt produced
+                // nothing, which is the failure the fallback slot exists for.
+                //
+                // Otherwise repair, while this slot has both attempts and turns left. Past
+                // the allowance every attempt gets `stepAllowance`'s one-step floor, which
+                // is enough to reach an ending but not to reconsider one — so retrying
+                // there buys a worse call at a real cost.
+                if (rejected &&
+                    repair < MAX_REPAIR_ATTEMPTS &&
+                    args.budget.spent < args.budget.allowance) {
+                    slotMessages.push(...repairExchange(`${controlCallId(taskId, round)}:repair:${repair}`, rejected, outcome.error));
+                    continue;
+                }
+                break;
+            }
+            if (outcome.decision.kind === "reply") {
+                // A throw here is a storage fault: it propagates so the step retries.
+                const reply = await appendOnce(session, deterministicSessionMessage(finalReplyMessageId(taskId), "assistant", outcome.decision.text));
+                return { status: "replied", reply };
+            }
+            const stored = await appendOnce(session, deterministicSessionMessage(roundAckMessageId(taskId, round), "assistant", outcome.decision.reply));
+            return {
+                status: "delegated",
+                reply: stored,
+                drafts: outcome.decision.drafts
+            };
+        }
+    }
+    // A transient fault is not a decision failure — let the step retry rather than
+    // failing the user's Task over Workers-AI capacity.
+    const transient = errors.find((e) => isTransientAiError(e));
+    if (transient)
+        throw transient;
+    const detail = `round ${round} exhausted both models — ${diagnostics.join("; ")}`;
+    // Both models failed deterministically. Any branch results behind us are durable
+    // and useful; deliver them joined rather than failing a Task whose work is done.
+    if (branches.some((b) => b.status === "completed")) {
+        console.warn("[turn] falling back to deterministic join", {
+            taskId,
+            round
+        });
+        const reply = await appendOnce(session, deterministicSessionMessage(finalReplyMessageId(taskId), "assistant", joinSuccessfulBranches(branches, args.partialNote)));
+        return { status: "replied", reply };
+    }
+    return { status: "failed", error: detail };
+}
+//# sourceMappingURL=turn.js.map

package/dist/round/turn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn.js","sourceRoot":"","sources":["../../src/round/turn.ts"],"names":[],"mappings":"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"}

package/dist/round/workflow.d.ts

@@ -0,0 +1,109 @@
+import type { WorkflowStep } from "cloudflare:workers";
+import type { CoreConfig } from "../config.js";
+import type { GatewayIdentity } from "../a2a/verify.js";
+import type { RoundAgentBase } from "./agent.js";
+import type { RoundPolicy } from "./policy.js";
+/**
+ * The async task controller. The gateway does not wait for a synchronous reply:
+ * the Worker accepts a turn (returns a `submitted` Task) and hands the actual work
+ * to this durable Workflow, which orchestrates it end to end and delivers the
+ * reply to the gateway's push-notification webhook.
+ *
+ * The shape is a **round loop**, not a fixed sequence of phases:
+ *
+ * 0. **Pre-work** — resolve the caller's agent, mark the Task working.
+ * 1. **Round** — one main-agent inference that either answers the user (the Task
+ *    is done) or delegates durable Subtasks plus the acknowledgment the user sees
+ *    while they run.
+ * 2. **Execute** — a delegating round's Subtask DAG runs in waves, every
+ *    dependency-ready node concurrently, each in an isolated managed subagent.
+ *    Then the loop returns to 1, where the model sees the results and decides
+ *    again — answer, or delegate once more.
+ * 3. **Deliver** — persist the terminal Task, then POST a signed callback.
+ *
+ * The main agent is never forced either way. A round that has run out of budget —
+ * `mainAgentLimits`, in turns or in wall clock — is handed no tools but the
+ * answer, so it has to give one; every other round chooses. That is the whole
+ * reason this is a loop, and the whole termination argument.
+ *
+ * Why a Workflow (not a DO alarm or `waitUntil`): `step.do(...)` gives durable,
+ * independently-retried steps that survive isolate eviction, and a future
+ * `escalate` decision (ask the human, then continue) slots in cleanly as another
+ * branch of the loop built on `step.waitForEvent(...)`.
+ *
+ * A Workflow is a separate entrypoint and cannot touch the agent DO's SQLite
+ * directly, so: the task inputs travel as the workflow **payload**, and the agent
+ * runtime plus task state are reached only through **native DO RPC**.
+ *
+ * Idempotency: the instance id is derived from the gateway's `messageId`
+ * (deterministic across dispatch retries), so a re-dispatch never starts a second
+ * run. Within a run, every step is re-runnable: the Subtask rows and the Session
+ * are the source of truth, and each round recovers from them rather than
+ * re-inferring.
+ */
+export interface HandleTaskParams {
+    /** The accepted task id (echoed back to the gateway on the callback). */
+    taskId: string;
+    /** The user turn text to answer. */
+    text: string;
+    /** The verified calling gateway-agent identity (keys the DO + the Session). */
+    identity: GatewayIdentity;
+    /** A2A context id, echoed on the completed Task. */
+    contextId: string;
+    /** Gateway push-notification webhook (also the callback JWT `aud`). */
+    pushUrl: string;
+    /** Per-task validation token the gateway set; echoed in the callback header. */
+    pushToken: string;
+    /** This agent's card-signing JWKS URL — the callback JWT `jku` (pinned key). */
+    jku: string;
+}
+/**
+ * What distinguishes one agent's use of this loop from another's.
+ *
+ * The whole body below is agent-agnostic — it names no soul, no plugin and no
+ * model. Two delegating agents differ only in these values, which is why they
+ * share one workflow body behind two thin entrypoints rather than two copies of a
+ * 250-line orchestration.
+ */
+export interface HandleTaskDeps {
+    /** Route to the right DO class for the verified caller. */
+    resolveAgent: (identity: GatewayIdentity) => AgentStub;
+    /** Resolved config — the loop reads `mainAgentLimits` and `maxSubtasks`. */
+    config: CoreConfig;
+    /** The user-facing copy. Only `copy.taskFailed` is read out here. */
+    policy: RoundPolicy;
+    /**
+     * The deployment's Ed25519 private JWK, for the terminal callback. Passed
+     * rather than read off a module-scope `env` so this stays a pure function of
+     * its arguments — and so a Worker whose secret is named something else works
+     * with no change here.
+     */
+    signingKey: string;
+}
+/**
+ * The caller's agent DO stub — every phase runs through it.
+ *
+ * Typed on the abstract base rather than a concrete class: the orchestration
+ * below calls only methods the base declares, and every delegating agent's stub
+ * satisfies it.
+ */
+type AgentStub = DurableObjectStub<RoundAgentBase>;
+/**
+ * The orchestration itself, split from the `WorkflowEntrypoint` wiring so it can
+ * be driven with a fake `step` in tests (workerd forbids constructing a
+ * `WorkflowEntrypoint` outside the runtime) — and so a second agent can reuse it
+ * with different deps.
+ *
+ * Every `step.do` return here is a small projection — a status, an id, a reply.
+ * Never a Subtask row: a step return is capped at 1 MiB and a Subtask carries
+ * verbatim history snapshots, so the rows stay in the DO and the Workflow carries
+ * references to them.
+ *
+ * **Step names are durable cache keys.** Everything inside the round loop carries
+ * its round for that reason: `turn:<round>`, `deadline:<round>`,
+ * `scan:<round>:<wave>`, `cancel:<round>:<wave>`. Renaming one silently re-runs
+ * its effect on replay.
+ */
+export declare function runHandleTask(p: HandleTaskParams, step: WorkflowStep, deps: HandleTaskDeps): Promise<void>;
+export {};
+//# sourceMappingURL=workflow.d.ts.map

package/dist/round/workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../../src/round/workflow.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAGxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,WAAW,gBAAgB;IAC/B,yEAAyE;IACzE,MAAM,EAAE,MAAM,CAAC;IACf,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,+EAA+E;IAC/E,QAAQ,EAAE,eAAe,CAAC;IAC1B,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB,uEAAuE;IACvE,OAAO,EAAE,MAAM,CAAC;IAChB,gFAAgF;IAChF,SAAS,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,cAAc;IAC7B,2DAA2D;IAC3D,YAAY,EAAE,CAAC,QAAQ,EAAE,eAAe,KAAK,SAAS,CAAC;IACvD,4EAA4E;IAC5E,MAAM,EAAE,UAAU,CAAC;IACnB,qEAAqE;IACrE,MAAM,EAAE,WAAW,CAAC;IACpB;;;;;OAKG;IACH,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;GAMG;AACH,KAAK,SAAS,GAAG,iBAAiB,CAAC,cAAc,CAAC,CAAC;AAEnD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,aAAa,CACjC,CAAC,EAAE,gBAAgB,EACnB,IAAI,EAAE,YAAY,EAClB,IAAI,EAAE,cAAc,GACnB,OAAO,CAAC,IAAI,CAAC,CAqIf"}