@loopingai/core 0.1.0

package/dist/subtasks/types.d.ts

@@ -0,0 +1,321 @@
+import type { ResolvedRecipe, SubtaskParams } from "../contract/recipe.js";
+export type SubtaskStatus = "pending" | "running" | "completed" | "failed" | "skipped" | "canceled";
+/** A per-caller, SQLite-assigned, monotonically increasing Subtask identifier. */
+export type SubtaskId = number;
+/**
+ * An exact, verbatim snapshot of one selected Session history message, copied
+ * onto the Subtask at decomposition time. The decomposition model selects which
+ * messages to reference; it never rewrites their content. User-turn provenance
+ * (author/channel) is already inline in the message text's `<turn>` wrapper.
+ */
+export interface SubtaskReference {
+    role: "user" | "assistant";
+    text: string;
+}
+/**
+ * One part of a Subtask's result. Text-only today; file/data kinds are additive
+ * later. Internal to the agent — the terminal A2A Task collapses these to a
+ * single text reply for the gateway/human.
+ */
+export interface SubtaskResultPart {
+    kind: "text";
+    text: string;
+}
+/**
+ * Creation input for one Subtask, before it is persisted. `dependsOn` uses
+ * draft-local keys (not yet-unknown {@link SubtaskId}s); the data layer resolves
+ * them to SQLite-assigned ids when the decomposition is created. `ordinal` is
+ * derived from the draft's position in the decomposition array.
+ */
+export interface SubtaskDraft {
+    localKey: string;
+    type: string;
+    prompt: string;
+    references: SubtaskReference[];
+    /** Draft-local keys of prerequisite drafts. */
+    dependsOn: string[];
+    /** The type's required inputs, already validated for shape. */
+    params: SubtaskParams;
+}
+/**
+ * Session state the parent resolved *from* a Subtask's params at execution
+ * start — the part of an execution's context the model can never supply.
+ *
+ * Deliberately outside {@link RecipeExecutionRequest}: it is not part of an
+ * execution's identity and it can change under us, so fingerprinting it would
+ * make a retry look like a different request. It travels as a separate argument,
+ * the same discipline as the chunk number.
+ */
+export type SubtaskRuntime = Record<string, unknown>;
+/**
+ * Narrow a {@link SubtaskRuntime} to the shape a plugin resolved for itself.
+ *
+ * Runtime is an open bag because core cannot know what a domain needs — the
+ * predecessor repo declared ARC's four fields (`cardId`, `cookies`, `guid`,
+ * `frame`) right here in the delegation types, which meant core imported a
+ * domain's types and every unrelated agent carried them. A plugin now writes and
+ * reads its own slice, and the only thing core does with the bag is carry it.
+ *
+ * The unchecked cast is the point: the plugin that wrote the slice is the plugin
+ * reading it, so the assertion is local and its blast radius is one module.
+ */
+export declare function runtimeAs<T>(runtime: SubtaskRuntime): T;
+/**
+ * A user-facing progress note a tool emits mid-execution (e.g. a game level-up).
+ * The resumable runner collects these and ends the current chunk so the parent
+ * DO can post them promptly; `key` is a stable dedupe id the gateway keys on.
+ */
+export interface ProgressEvent {
+    key: string;
+    text: string;
+}
+/**
+ * One durable chunk's outcome as the facet reports it to the parent DO. `done`
+ * false means the run yielded a chunk boundary and the Workflow must run another
+ * chunk; `done` true carries the terminal {@link RecipeExecutionResult}. Progress
+ * events accumulated during the chunk ride along either way.
+ */
+export type RecipeChunkResult = {
+    done: false;
+    progress: ProgressEvent[];
+} | {
+    done: true;
+    result: RecipeExecutionResult;
+    progress: ProgressEvent[];
+};
+/**
+ * The parent DO's projection of a chunk outcome for the Workflow (RPC-safe, no
+ * result parts — those are persisted on the row). `status` is `running` until the
+ * run is `done`, then the terminal Subtask status.
+ */
+export interface SubtaskChunkOutcome {
+    done: boolean;
+    status: SubtaskStatus;
+    progress: ProgressEvent[];
+}
+/**
+ * Generated output of one completed prerequisite Subtask, loaded by the parent
+ * from its durable row for a dependent's invocation. `type` is the
+ * prerequisite's semantic type — used only to label the rendered section;
+ * dependency output is always presented as generated, never as conversation
+ * evidence.
+ */
+export interface DependencyResult {
+    subtaskId: SubtaskId;
+    type: string;
+    resultParts: SubtaskResultPart[];
+}
+/**
+ * RPC-safe input for one isolated `RecipeSubagent` execution, assembled by the
+ * parent at execution start: the already-resolved (and code-validated) Recipe,
+ * the Subtask's non-session prompt, its verbatim reference snapshots, and the
+ * generated results of its completed dependencies. The child re-validates the
+ * Recipe defensively but never resolves one itself.
+ */
+export interface RecipeExecutionRequest {
+    taskId: string;
+    subtaskId: SubtaskId;
+    /**
+     * The Subtask's semantic type — what the work *is*, and what owns the params
+     * contract. Distinct from `recipe.key`, which names the execution
+     * configuration it runs under: several types may share one Recipe.
+     */
+    type: string;
+    recipe: ResolvedRecipe;
+    prompt: string;
+    references: SubtaskReference[];
+    dependencyResults: DependencyResult[];
+    /**
+     * The Subtask's validated params. Part of the execution's identity — two plays
+     * of different games are different work — so this IS fingerprinted, unlike
+     * {@link SubtaskRuntime}, which is deliberately excluded: the leased scorecard
+     * can legitimately differ between two chunks of one run, and must not make a
+     * retry look like a different execution.
+     */
+    params: SubtaskParams;
+}
+/**
+ * Terminal outcome of one `RecipeSubagent` execution (RPC-safe). `modelId` is a
+ * diagnostic only — which model produced the outcome (null when validation
+ * failed before any model call); it is never persisted on the Subtask row.
+ * Transient platform faults are not results: they throw so the enclosing
+ * Workflow step can retry.
+ */
+export type RecipeExecutionResult = {
+    status: "completed";
+    resultParts: SubtaskResultPart[];
+    modelId: string;
+} | {
+    status: "failed";
+    error: string;
+    modelId: string | null;
+};
+/**
+ * One Subtask as the delegating model emits it. The model selects references
+ * by **catalog index only** — it never emits reference text, and application code
+ * snapshots the catalog entry's exact role+text onto the Subtask (see
+ * `agent/subtasks/decomposition.ts`). `dependsOn` uses draft-local keys, resolved
+ * to SQLite-assigned {@link SubtaskId}s by the data layer.
+ */
+export interface SubtaskProposal {
+    localKey: string;
+    type: string;
+    prompt: string;
+    /**
+     * 1-based indices into the ephemeral, per-round reference catalog. Optional:
+     * omitted when the subtask needs no verbatim history, and always absent from a
+     * *reconstructed* historical call, whose references were resolved rounds ago.
+     */
+    referenceIndexes?: number[];
+    /** Draft-local keys of prerequisite proposals. */
+    dependsOn: string[];
+    /** The type's required inputs; omitted for a type that takes none. */
+    params?: SubtaskParams;
+}
+/**
+ * The model's complete `delegate` call: the acknowledgment the user sees while
+ * the work runs, plus one through eight Subtask proposals. Validated against the
+ * round's ephemeral catalog before anything is persisted; invalid output fails
+ * the attempt (and, with both models exhausted, the round) rather than being
+ * silently repaired.
+ */
+export interface DecompositionProposal {
+    reply: string;
+    subtasks: SubtaskProposal[];
+}
+/**
+ * Terminal outcome of one main-agent round (RPC-safe).
+ *
+ * `replied` is the terminal answer — the round chose to answer the user rather
+ * than delegate, and the Workflow delivers it. `delegated` means the round's
+ * Subtask rows are durable and Phase 2 should run them, after which another round
+ * begins. `failed` means both models produced unusable output; no Subtask is ever
+ * synthesized to cover for it. `canceled` means the caller cancelled during the
+ * round: nothing was persisted and nothing was published. Transient platform
+ * faults are not results: they throw so the enclosing Workflow step can retry
+ * (mirrors {@link RecipeExecutionResult}).
+ *
+ * `turns` is what this round cost, which the Workflow meters against the Task's
+ * budget. This is the **only** type that carries it, and it carries it because the
+ * count has to cross an RPC boundary to reach a Workflow in another isolate;
+ * everything inside the DO shares one mutable {@link file://../budget.ts TurnBudget}
+ * instead. The field is attached in a single place — see `runTaskTurn` — so no
+ * branch can drop it and no branch can invent it.
+ *
+ * The idempotent recovery paths — a round replayed from durable rows rather than
+ * re-inferred — therefore report **0** structurally: they return before any model
+ * runs, so the budget they hand back is untouched. That is exact on a clean
+ * replay, where the Workflow's own cached step return already carries the original
+ * number, and under-counts by one round when a step crashed mid-flight and re-ran.
+ * Accepted rather than fixed: a replying round writes no durable row at all, so
+ * nothing exists to hang a per-round count on, and the wall clock bounds the
+ * crash-loop case anyway.
+ */
+export type TurnTaskResult = {
+    status: "replied";
+    reply: string;
+    turns: number;
+} | {
+    status: "delegated";
+    reply: string;
+    subtasks: Subtask[];
+    turns: number;
+} | {
+    status: "failed";
+    error: string;
+    turns: number;
+} | {
+    status: "canceled";
+    turns: number;
+};
+/**
+ * Distributive `Omit` — applies per member, so the discriminated union survives.
+ * A plain `Omit<TurnTaskResult, "turns">` collapses all four into one loose shape
+ * whose `reply` and `subtasks` are independently optional.
+ */
+type WithoutTurns<T> = T extends unknown ? Omit<T, "turns"> : never;
+/**
+ * What a round decided, before its cost is attached. The DO's round logic returns
+ * this and lets one wrapper bill the budget, rather than every branch remembering
+ * to report a number it did not compute.
+ */
+export type TurnVerdict = WithoutTurns<TurnTaskResult>;
+/**
+ * One branch's outcome as a later round sees it — a plain, RPC-safe subset of the
+ * durable {@link Subtask} row, loaded across **every** round in stable ordinal
+ * order. Completed, failed, and skipped branches are all included so the reply
+ * can use available successes and disclose relevant failures.
+ *
+ * Carries `round`, `prompt` and `dependsOn` — not for composing, but for
+ * reconstructing the per-round `delegate` call that produced these branches (see
+ * `agent/subtasks/delegate.ts`). Unlike {@link SubtaskNode}, this projection is
+ * built inside the DO and returns only a reply, so the 1 MiB Workflow-step cap
+ * that keeps the scheduler's view narrow does not apply. `references` still stays
+ * out: it is unbounded history text, and the call's shape does not need it.
+ */
+export interface CompositionBranch {
+    subtaskId: SubtaskId;
+    round: number;
+    ordinal: number;
+    type: string;
+    prompt: string;
+    dependsOn: SubtaskId[];
+    params: SubtaskParams;
+    status: SubtaskStatus;
+    resultParts: SubtaskResultPart[] | null;
+    error: string | null;
+}
+/**
+ * The `scan:<n>` wave projection (RPC-safe): either the caller cancelled, or the
+ * refreshed DAG after blocked branches were skipped. Returning the verdict with
+ * the nodes is what lets the Workflow drop its separate cancellation probe — one
+ * round trip, and no gap between asking and acting.
+ */
+export type SubtaskScan = {
+    canceled: true;
+} | {
+    canceled: false;
+    nodes: SubtaskNode[];
+};
+/**
+ * The scheduler's view of one Subtask (Phase 2) — everything needed to pick the
+ * next dependency-ready wave, and nothing else.
+ *
+ * Deliberately excludes `prompt`, `references`, and `resultParts`: a Workflow
+ * step return is capped at 1 MiB, and a reference is a verbatim history snapshot
+ * bounded only by `MAX_INBOUND_TEXT_BYTES`, so a wave scan returning full rows
+ * would overflow on a large task. The durable rows — not Workflow state — are the
+ * source of truth, so the Workflow carries ids and statuses and re-reads the rest
+ * through the parent when it actually needs it.
+ */
+export interface SubtaskNode {
+    id: SubtaskId;
+    ordinal: number;
+    status: SubtaskStatus;
+    dependsOn: SubtaskId[];
+}
+/** Durable state owned by the main agent for one delegated unit of work. */
+export interface Subtask {
+    id: SubtaskId;
+    taskId: string;
+    /** The main-agent round that delegated this Subtask (0-based). */
+    round: number;
+    /** Position within the parent Task, increasing across every round. */
+    ordinal: number;
+    type: string;
+    recipeId: string | null;
+    recipeVersion: number | null;
+    prompt: string;
+    references: SubtaskReference[];
+    dependsOn: SubtaskId[];
+    /** The type's required inputs, validated at delegation time. */
+    params: SubtaskParams;
+    status: SubtaskStatus;
+    resultParts: SubtaskResultPart[] | null;
+    error: string | null;
+    createdAt: number;
+    updatedAt: number;
+    completedAt: number | null;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/subtasks/types.d.ts.map

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

package/dist/subtasks/types.js

@@ -0,0 +1,16 @@
+/**
+ * Narrow a {@link SubtaskRuntime} to the shape a plugin resolved for itself.
+ *
+ * Runtime is an open bag because core cannot know what a domain needs — the
+ * predecessor repo declared ARC's four fields (`cardId`, `cookies`, `guid`,
+ * `frame`) right here in the delegation types, which meant core imported a
+ * domain's types and every unrelated agent carried them. A plugin now writes and
+ * reads its own slice, and the only thing core does with the bag is carry it.
+ *
+ * The unchecked cast is the point: the plugin that wrote the slice is the plugin
+ * reading it, so the assertion is local and its blast radius is one module.
+ */
+export function runtimeAs(runtime) {
+    return runtime;
+}
+//# sourceMappingURL=types.js.map

package/dist/subtasks/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/subtasks/types.ts"],"names":[],"mappings":"AAyDA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,SAAS,CAAI,OAAuB;IAClD,OAAO,OAAY,CAAC;AACtB,CAAC"}

package/dist/testing/auth.d.ts

@@ -0,0 +1,12 @@
+export interface GatewayTokenOptions {
+    audience?: string;
+    issuer?: string;
+    /** Relative string ("5m"), absolute epoch seconds, or Date. Past values expire the token. */
+    expiresIn?: string | number | Date;
+    identity?: Record<string, unknown>;
+    /** Claim the identity is carried in. Defaults to core's `IDENTITY_CLAIM`. */
+    identityClaim?: string;
+}
+/** Sign a short-lived EdDSA gateway JWT using the test gateway key. */
+export declare function makeGatewayToken(options?: GatewayTokenOptions): Promise<string>;
+//# sourceMappingURL=auth.d.ts.map

package/dist/testing/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/testing/auth.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,6FAA6F;IAC7F,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,6EAA6E;IAC7E,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,uEAAuE;AACvE,wBAAsB,gBAAgB,CACpC,OAAO,GAAE,mBAAwB,GAChC,OAAO,CAAC,MAAM,CAAC,CAmBjB"}

package/dist/testing/auth.js

@@ -0,0 +1,25 @@
+import { importJWK, SignJWT } from "jose";
+import { IDENTITY_CLAIM } from "../a2a/verify.js";
+import { TEST_GATEWAY_PRIVATE_JWK, GATEWAY_ORIGIN, AGENT_ORIGIN } from "./fixtures.js";
+/** Sign a short-lived EdDSA gateway JWT using the test gateway key. */
+export async function makeGatewayToken(options = {}) {
+    const privateKey = await importJWK(TEST_GATEWAY_PRIVATE_JWK, "EdDSA");
+    return new SignJWT({
+        [options.identityClaim ?? IDENTITY_CLAIM]: options.identity ?? {
+            key: "custom:1:test-agent",
+            name: "Test Agent",
+            kind: "custom",
+            workspaceId: 1
+        }
+    })
+        .setProtectedHeader({
+        alg: "EdDSA",
+        kid: TEST_GATEWAY_PRIVATE_JWK.kid,
+        jku: `${GATEWAY_ORIGIN}/.well-known/jwks.json`
+    })
+        .setIssuer(options.issuer ?? GATEWAY_ORIGIN)
+        .setAudience(options.audience ?? AGENT_ORIGIN)
+        .setExpirationTime(options.expiresIn ?? "5m")
+        .sign(privateKey);
+}
+//# sourceMappingURL=auth.js.map

package/dist/testing/auth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../src/testing/auth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC1C,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EACL,wBAAwB,EACxB,cAAc,EACd,YAAY,EACb,MAAM,eAAe,CAAC;AAYvB,uEAAuE;AACvE,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,UAA+B,EAAE;IAEjC,MAAM,UAAU,GAAG,MAAM,SAAS,CAAC,wBAAwB,EAAE,OAAO,CAAC,CAAC;IACtE,OAAO,IAAI,OAAO,CAAC;QACjB,CAAC,OAAO,CAAC,aAAa,IAAI,cAAc,CAAC,EAAE,OAAO,CAAC,QAAQ,IAAI;YAC7D,GAAG,EAAE,qBAAqB;YAC1B,IAAI,EAAE,YAAY;YAClB,IAAI,EAAE,QAAQ;YACd,WAAW,EAAE,CAAC;SACf;KACF,CAAC;SACC,kBAAkB,CAAC;QAClB,GAAG,EAAE,OAAO;QACZ,GAAG,EAAE,wBAAwB,CAAC,GAAG;QACjC,GAAG,EAAE,GAAG,cAAc,wBAAwB;KAC/C,CAAC;SACD,SAAS,CAAC,OAAO,CAAC,MAAM,IAAI,cAAc,CAAC;SAC3C,WAAW,CAAC,OAAO,CAAC,QAAQ,IAAI,YAAY,CAAC;SAC7C,iBAAiB,CAAC,OAAO,CAAC,SAAS,IAAI,IAAI,CAAC;SAC5C,IAAI,CAAC,UAAU,CAAC,CAAC;AACtB,CAAC"}

package/dist/testing/do.d.ts

@@ -0,0 +1,30 @@
+import { AgentDB, type AgentDBOptions } from "../db/db.js";
+/**
+ * Durable Object test helpers.
+ *
+ * The predecessor hardcoded its own DO binding and exposed one `with*` wrapper
+ * per named `AgentDB` domain — including one for a domain that belonged to a
+ * plugin. Both are parameterized here: a consumer binds their namespace once,
+ * and {@link DoTestHelpers.withDb} hands over the whole `AgentDB` rather than
+ * pre-selecting a table.
+ */
+export interface DoTestHelpers {
+    /** Fresh, unique DO stub per test — state never leaks between tests. */
+    freshStub(label: string): DurableObjectStub;
+    /** Run `fn` inside a fresh DO instance with a migrated {@link AgentDB}. */
+    withDb<T>(label: string, fn: (db: AgentDB) => T): Promise<T>;
+}
+/**
+ * `ctx` is protected in the DO type system but public at runtime. Cast once so
+ * callers don't repeat the assertion.
+ */
+export declare function doStorage(instance: unknown): DurableObjectStorage;
+/**
+ * Bind the helpers to a consumer's DO namespace.
+ *
+ * ```ts
+ * const { freshStub, withDb } = makeDoHelpers(env.MyAgent);
+ * ```
+ */
+export declare function makeDoHelpers(ns: DurableObjectNamespace, defaults?: AgentDBOptions): DoTestHelpers;
+//# sourceMappingURL=do.d.ts.map

package/dist/testing/do.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"do.d.ts","sourceRoot":"","sources":["../../src/testing/do.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAE3D;;;;;;;;GAQG;AAEH,MAAM,WAAW,aAAa;IAC5B,wEAAwE;IACxE,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,iBAAiB,CAAC;IAC5C,2EAA2E;IAC3E,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,OAAO,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAC9D;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,OAAO,GAAG,oBAAoB,CAEjE;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,EAAE,EAAE,sBAAsB,EAC1B,QAAQ,GAAE,cAAmC,GAC5C,aAAa,CAYf"}

package/dist/testing/do.js

@@ -0,0 +1,26 @@
+import { runInDurableObject } from "cloudflare:test";
+import { AgentDB } from "../db/db.js";
+/**
+ * `ctx` is protected in the DO type system but public at runtime. Cast once so
+ * callers don't repeat the assertion.
+ */
+export function doStorage(instance) {
+    return instance.ctx.storage;
+}
+/**
+ * Bind the helpers to a consumer's DO namespace.
+ *
+ * ```ts
+ * const { freshStub, withDb } = makeDoHelpers(env.MyAgent);
+ * ```
+ */
+export function makeDoHelpers(ns, defaults = { maxSubtasks: 8 }) {
+    const freshStub = (label) => ns.get(ns.idFromName(`test:${label}:${crypto.randomUUID()}`));
+    return {
+        freshStub,
+        withDb(label, fn) {
+            return runInDurableObject(freshStub(label), (instance) => fn(new AgentDB(doStorage(instance), defaults)));
+        }
+    };
+}
+//# sourceMappingURL=do.js.map

package/dist/testing/do.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"do.js","sourceRoot":"","sources":["../../src/testing/do.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,OAAO,EAAuB,MAAM,aAAa,CAAC;AAmB3D;;;GAGG;AACH,MAAM,UAAU,SAAS,CAAC,QAAiB;IACzC,OAAQ,QAAuD,CAAC,GAAG,CAAC,OAAO,CAAC;AAC9E,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAC3B,EAA0B,EAC1B,WAA2B,EAAE,WAAW,EAAE,CAAC,EAAE;IAE7C,MAAM,SAAS,GAAG,CAAC,KAAa,EAAE,EAAE,CAClC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,KAAK,IAAI,MAAM,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,CAAC;IAEhE,OAAO;QACL,SAAS;QACT,MAAM,CAAI,KAAa,EAAE,EAAsB;YAC7C,OAAO,kBAAkB,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,QAAQ,EAAE,EAAE,CACvD,EAAE,CAAC,IAAI,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC,CAAC,CAC/C,CAAC;QACJ,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/testing/fake-session.d.ts

@@ -0,0 +1,27 @@
+import type { ToolSet } from "ai";
+import type { SessionMessage } from "agents/experimental/memory/session";
+import type { SessionLike } from "../agent/session.js";
+/**
+ * An in-memory {@link SessionLike} standing in for the DO's real continuous
+ * Session. Shared by the turn, decomposition, and composition specs so a change
+ * to the Session contract breaks in one place.
+ *
+ * Mirrors the two real behaviors the phased pipeline depends on:
+ *
+ * - `appendMessage` **dedupes by id** — appending an existing id is a no-op, the
+ *   property that makes deterministic-id appends exactly-once on a step re-run.
+ * - `getMessage` reads the raw stored message back.
+ */
+export declare class FakeSession implements SessionLike {
+    messages: SessionMessage[];
+    system: string;
+    /** Compaction overlays to report — non-empty gates the `recall` tool on. */
+    compactions: unknown[];
+    appendMessage(m: SessionMessage): void;
+    getHistory(): Promise<SessionMessage[]>;
+    getMessage(id: string): Promise<SessionMessage | null>;
+    refreshSystemPrompt(): Promise<string>;
+    tools(): Promise<ToolSet>;
+    getCompactions(): Promise<unknown[]>;
+}
+//# sourceMappingURL=fake-session.d.ts.map

package/dist/testing/fake-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-session.d.ts","sourceRoot":"","sources":["../../src/testing/fake-session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC;AAClC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;;;;;;;;GAUG;AACH,qBAAa,WAAY,YAAW,WAAW;IAC7C,QAAQ,EAAE,cAAc,EAAE,CAAM;IAChC,MAAM,SAAsC;IAC5C,4EAA4E;IAC5E,WAAW,EAAE,OAAO,EAAE,CAAM;IAE5B,aAAa,CAAC,CAAC,EAAE,cAAc;IAIzB,UAAU;IAGV,UAAU,CAAC,EAAE,EAAE,MAAM;IAGrB,mBAAmB;IAGnB,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC;IAGzB,cAAc;CAGrB"}

package/dist/testing/fake-session.js

@@ -0,0 +1,38 @@
+/**
+ * An in-memory {@link SessionLike} standing in for the DO's real continuous
+ * Session. Shared by the turn, decomposition, and composition specs so a change
+ * to the Session contract breaks in one place.
+ *
+ * Mirrors the two real behaviors the phased pipeline depends on:
+ *
+ * - `appendMessage` **dedupes by id** — appending an existing id is a no-op, the
+ *   property that makes deterministic-id appends exactly-once on a step re-run.
+ * - `getMessage` reads the raw stored message back.
+ */
+export class FakeSession {
+    messages = [];
+    system = "SOUL BLOCK\n\n## memory\n(empty)";
+    /** Compaction overlays to report — non-empty gates the `recall` tool on. */
+    compactions = [];
+    appendMessage(m) {
+        if (this.messages.some((existing) => existing.id === m.id))
+            return;
+        this.messages.push(m);
+    }
+    async getHistory() {
+        return this.messages;
+    }
+    async getMessage(id) {
+        return this.messages.find((m) => m.id === id) ?? null;
+    }
+    async refreshSystemPrompt() {
+        return this.system;
+    }
+    async tools() {
+        return {};
+    }
+    async getCompactions() {
+        return this.compactions;
+    }
+}
+//# sourceMappingURL=fake-session.js.map

package/dist/testing/fake-session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-session.js","sourceRoot":"","sources":["../../src/testing/fake-session.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,MAAM,OAAO,WAAW;IACtB,QAAQ,GAAqB,EAAE,CAAC;IAChC,MAAM,GAAG,kCAAkC,CAAC;IAC5C,4EAA4E;IAC5E,WAAW,GAAc,EAAE,CAAC;IAE5B,aAAa,CAAC,CAAiB;QAC7B,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC;YAAE,OAAO;QACnE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACxB,CAAC;IACD,KAAK,CAAC,UAAU;QACd,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IACD,KAAK,CAAC,UAAU,CAAC,EAAU;QACzB,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,IAAI,IAAI,CAAC;IACxD,CAAC;IACD,KAAK,CAAC,mBAAmB;QACvB,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IACD,KAAK,CAAC,KAAK;QACT,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,KAAK,CAAC,cAAc;QAClB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;CACF"}

package/dist/testing/fixtures.d.ts

@@ -0,0 +1,27 @@
+import { type JWK } from "jose";
+import { type Message, type Task, type TaskState } from "@a2a-js/sdk";
+/** The gateway origin used in all tests. Must match vitest.config.ts and the MockAgent setup. */
+export declare const GATEWAY_ORIGIN = "https://gateway.test";
+/** Agent origin matching `url.origin` for requests to `http://localhost`. */
+export declare const AGENT_ORIGIN = "http://localhost";
+/** Fixed Ed25519 private JWK used as A2A_SIGNING_KEY in tests. */
+export declare const TEST_AGENT_PRIVATE_JWK: JWK & {
+    kid: string;
+};
+/** Fixed Ed25519 private JWK for signing gateway JWTs in tests. */
+export declare const TEST_GATEWAY_PRIVATE_JWK: JWK & {
+    kid: string;
+};
+/** Public JWKS the gateway would serve at its `jku` (the private key minus `d`). */
+export declare function gatewayPublicJwks(): string;
+/**
+ * Build an A2A v1.0 `TaskStatus` for tests. The generated protobuf types require
+ * every field to be present (`message` included, holding `undefined` when there
+ * is none), so this keeps the specs from spelling that out each time.
+ */
+export declare function testStatus(state: TaskState, message?: Message): NonNullable<Task["status"]>;
+/** An agent-role `Message` carrying a single v1.0 text part. */
+export declare function testAgentMessage(messageId: string, text: string, contextId?: string, taskId?: string): Message;
+/** A complete v1.0 `Task` in the given state. */
+export declare function testTask(id: string, contextId: string, state: TaskState, message?: Message): Task;
+//# sourceMappingURL=fixtures.d.ts.map

package/dist/testing/fixtures.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../../src/testing/fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,GAAG,EAAE,MAAM,MAAM,CAAC;AAChC,OAAO,EAAQ,KAAK,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,SAAS,EAAE,MAAM,aAAa,CAAC;AAE5E,iGAAiG;AACjG,eAAO,MAAM,cAAc,yBAAyB,CAAC;AAErD,6EAA6E;AAC7E,eAAO,MAAM,YAAY,qBAAqB,CAAC;AAE/C,kEAAkE;AAClE,eAAO,MAAM,sBAAsB,EAAE,GAAG,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAMvD,CAAC;AAEF,mEAAmE;AACnE,eAAO,MAAM,wBAAwB,EAAE,GAAG,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAMzD,CAAC;AAEF,oFAAoF;AACpF,wBAAgB,iBAAiB,IAAI,MAAM,CAG1C;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,SAAS,EAChB,OAAO,CAAC,EAAE,OAAO,GAChB,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAE7B;AAED,gEAAgE;AAChE,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,SAAS,SAAK,EACd,MAAM,SAAK,GACV,OAAO,CAkBT;AAED,iDAAiD;AACjD,wBAAgB,QAAQ,CACtB,EAAE,EAAE,MAAM,EACV,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,SAAS,EAChB,OAAO,CAAC,EAAE,OAAO,GAChB,IAAI,CASN"}

package/dist/testing/fixtures.js

@@ -0,0 +1,67 @@
+import {} from "jose";
+import { Role } from "@a2a-js/sdk";
+/** The gateway origin used in all tests. Must match vitest.config.ts and the MockAgent setup. */
+export const GATEWAY_ORIGIN = "https://gateway.test";
+/** Agent origin matching `url.origin` for requests to `http://localhost`. */
+export const AGENT_ORIGIN = "http://localhost";
+/** Fixed Ed25519 private JWK used as A2A_SIGNING_KEY in tests. */
+export const TEST_AGENT_PRIVATE_JWK = {
+    crv: "Ed25519",
+    d: "sbR9EgZV1zUY-K6ENkvSLY8c8Q9kJ9NnxsXc4GVx_1g",
+    x: "1dXrUHeE89GBnZbd7MjzJK-3Xvu7khZCK9ZrQauZQ6s",
+    kty: "OKP",
+    kid: "test-agent-key-1"
+};
+/** Fixed Ed25519 private JWK for signing gateway JWTs in tests. */
+export const TEST_GATEWAY_PRIVATE_JWK = {
+    crv: "Ed25519",
+    d: "OVKcn3LDH-qybNIdUbr7T9wbmlxNk2maU4_nILbaLKY",
+    x: "jYiAbquXL6db7RihLvp2nsp1ShAolDI0tGOjuwsZVnI",
+    kty: "OKP",
+    kid: "test-gw-key-1"
+};
+/** Public JWKS the gateway would serve at its `jku` (the private key minus `d`). */
+export function gatewayPublicJwks() {
+    const { d: _d, ...pub } = TEST_GATEWAY_PRIVATE_JWK;
+    return JSON.stringify({ keys: [{ ...pub, use: "sig", alg: "EdDSA" }] });
+}
+/**
+ * Build an A2A v1.0 `TaskStatus` for tests. The generated protobuf types require
+ * every field to be present (`message` included, holding `undefined` when there
+ * is none), so this keeps the specs from spelling that out each time.
+ */
+export function testStatus(state, message) {
+    return { state, message, timestamp: new Date().toISOString() };
+}
+/** An agent-role `Message` carrying a single v1.0 text part. */
+export function testAgentMessage(messageId, text, contextId = "", taskId = "") {
+    return {
+        messageId,
+        contextId,
+        taskId,
+        role: Role.ROLE_AGENT,
+        parts: [
+            {
+                content: { $case: "text", value: text },
+                metadata: undefined,
+                filename: "",
+                mediaType: "text/plain"
+            }
+        ],
+        metadata: undefined,
+        extensions: [],
+        referenceTaskIds: []
+    };
+}
+/** A complete v1.0 `Task` in the given state. */
+export function testTask(id, contextId, state, message) {
+    return {
+        id,
+        contextId,
+        status: testStatus(state, message),
+        artifacts: [],
+        history: [],
+        metadata: undefined
+    };
+}
+//# sourceMappingURL=fixtures.js.map

package/dist/testing/fixtures.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fixtures.js","sourceRoot":"","sources":["../../src/testing/fixtures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,MAAM,MAAM,CAAC;AAChC,OAAO,EAAE,IAAI,EAA2C,MAAM,aAAa,CAAC;AAE5E,iGAAiG;AACjG,MAAM,CAAC,MAAM,cAAc,GAAG,sBAAsB,CAAC;AAErD,6EAA6E;AAC7E,MAAM,CAAC,MAAM,YAAY,GAAG,kBAAkB,CAAC;AAE/C,kEAAkE;AAClE,MAAM,CAAC,MAAM,sBAAsB,GAA0B;IAC3D,GAAG,EAAE,SAAS;IACd,CAAC,EAAE,6CAA6C;IAChD,CAAC,EAAE,6CAA6C;IAChD,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,kBAAkB;CACxB,CAAC;AAEF,mEAAmE;AACnE,MAAM,CAAC,MAAM,wBAAwB,GAA0B;IAC7D,GAAG,EAAE,SAAS;IACd,CAAC,EAAE,6CAA6C;IAChD,CAAC,EAAE,6CAA6C;IAChD,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,eAAe;CACrB,CAAC;AAEF,oFAAoF;AACpF,MAAM,UAAU,iBAAiB;IAC/B,MAAM,EAAE,CAAC,EAAE,EAAE,EAAE,GAAG,GAAG,EAAE,GAAG,wBAAwB,CAAC;IACnD,OAAO,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;AAC1E,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,UAAU,CACxB,KAAgB,EAChB,OAAiB;IAEjB,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC;AACjE,CAAC;AAED,gEAAgE;AAChE,MAAM,UAAU,gBAAgB,CAC9B,SAAiB,EACjB,IAAY,EACZ,SAAS,GAAG,EAAE,EACd,MAAM,GAAG,EAAE;IAEX,OAAO;QACL,SAAS;QACT,SAAS;QACT,MAAM;QACN,IAAI,EAAE,IAAI,CAAC,UAAU;QACrB,KAAK,EAAE;YACL;gBACE,OAAO,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE;gBACvC,QAAQ,EAAE,SAAS;gBACnB,QAAQ,EAAE,EAAE;gBACZ,SAAS,EAAE,YAAY;aACxB;SACF;QACD,QAAQ,EAAE,SAAS;QACnB,UAAU,EAAE,EAAE;QACd,gBAAgB,EAAE,EAAE;KACrB,CAAC;AACJ,CAAC;AAED,iDAAiD;AACjD,MAAM,UAAU,QAAQ,CACtB,EAAU,EACV,SAAiB,EACjB,KAAgB,EAChB,OAAiB;IAEjB,OAAO;QACL,EAAE;QACF,SAAS;QACT,MAAM,EAAE,UAAU,CAAC,KAAK,EAAE,OAAO,CAAC;QAClC,SAAS,EAAE,EAAE;QACb,OAAO,EAAE,EAAE;QACX,QAAQ,EAAE,SAAS;KACpB,CAAC;AACJ,CAAC"}