@loopingai/core 0.1.0

package/dist/subagent/workspace.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The narrow file-store surface the resumable runner and its tool families use.
+ *
+ * Core declares the *interface* and the caps; it does not declare a backend.
+ * The predecessor backed this with `@cloudflare/shell`, which is experimental
+ * ("expect breaking changes") — so an agent that never delegates file work should
+ * not carry it. `@loopingai/plugins/workspace` supplies the shell-backed
+ * implementation and the model-facing `ws_read`/`ws_write`/`ws_list` tools; core
+ * only needs to be able to *name* a workspace, because {@link ToolFamilyContext}
+ * hands one to every tool family.
+ */
+export interface WorkspaceHandle {
+    /** File content, or null if the file does not exist. */
+    read(path: string): Promise<string | null>;
+    /** Write (create or overwrite) a text file. Parent directories are created. */
+    write(path: string, content: string): Promise<void>;
+    /** Whether a file or directory exists at the path. */
+    exists(path: string): Promise<boolean>;
+    /** Delete a file. Returns whether a file was removed. */
+    remove(path: string): Promise<boolean>;
+    /** Immediate entries under `dir` (default root): their path and byte size. */
+    list(dir?: string): Promise<WorkspaceEntry[]>;
+    /** Parse a JSON file, or null if it does not exist. Throws on malformed JSON. */
+    readJson<T>(path: string): Promise<T | null>;
+    /** Serialize a value to a JSON file (pretty-printed). */
+    writeJson(path: string, value: unknown): Promise<void>;
+}
+export interface WorkspaceEntry {
+    path: string;
+    type: "file" | "directory" | "symlink";
+    size: number;
+}
+/**
+ * The backend surface {@link makeWorkspaceHandle} needs, declared **structurally**
+ * rather than as `Pick<Workspace, …>`.
+ *
+ * That is the whole reason core can stay free of `@cloudflare/shell`: a shell
+ * `Workspace` satisfies this by construction, and so does a plain in-memory fake
+ * in a test, without either being named here.
+ */
+export interface WorkspaceBacking {
+    readFile(path: string): Promise<string | null>;
+    writeFile(path: string, content: string): Promise<void>;
+    exists(path: string): Promise<boolean>;
+    deleteFile(path: string): Promise<boolean>;
+    readDir(dir?: string): Promise<readonly WorkspaceEntry[]>;
+    getWorkspaceInfo(): Promise<{
+        fileCount: number;
+    }>;
+}
+/** Per-file byte ceiling — safely under the 2 MB Durable Object SQLite row limit. */
+export declare const WORKSPACE_MAX_FILE_BYTES: number;
+/** Max number of files in one workspace — a cheap guard against runaway writes. */
+export declare const WORKSPACE_MAX_FILES = 200;
+export declare class WorkspaceLimitError extends Error {
+    constructor(message: string);
+}
+/**
+ * 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 declare function makeWorkspaceHandle(ws: WorkspaceBacking): WorkspaceHandle;
+//# sourceMappingURL=workspace.d.ts.map

package/dist/subagent/workspace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/subagent/workspace.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,MAAM,WAAW,eAAe;IAC9B,wDAAwD;IACxD,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC3C,+EAA+E;IAC/E,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,sDAAsD;IACtD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvC,yDAAyD;IACzD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvC,8EAA8E;IAC9E,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC;IAC9C,iFAAiF;IACjF,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAC7C,yDAAyD;IACzD,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACxD;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAAC;IACvC,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC/C,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvC,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3C,OAAO,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,cAAc,EAAE,CAAC,CAAC;IAC1D,gBAAgB,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACpD;AAED,qFAAqF;AACrF,eAAO,MAAM,wBAAwB,QAAa,CAAC;AACnD,mFAAmF;AACnF,eAAO,MAAM,mBAAmB,MAAM,CAAC;AAEvC,qBAAa,mBAAoB,SAAQ,KAAK;gBAChC,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,gBAAgB,GAAG,eAAe,CA8CzE"}

package/dist/subagent/workspace.js

@@ -0,0 +1,53 @@
+/** 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`);
+            }
+            if (!(await ws.exists(path))) {
+                const { fileCount } = await ws.getWorkspaceInfo();
+                if (fileCount >= WORKSPACE_MAX_FILES) {
+                    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));
+        }
+    };
+}
+//# sourceMappingURL=workspace.js.map

package/dist/subagent/workspace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workspace.js","sourceRoot":"","sources":["../../src/subagent/workspace.ts"],"names":[],"mappings":"AAmDA,qFAAqF;AACrF,MAAM,CAAC,MAAM,wBAAwB,GAAG,GAAG,GAAG,IAAI,CAAC;AACnD,mFAAmF;AACnF,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAG,CAAC;AAEvC,MAAM,OAAO,mBAAoB,SAAQ,KAAK;IAC5C,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC;IACpC,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CAAC,EAAoB;IACtD,MAAM,UAAU,GAAG,CAAC,CAAS,EAAU,EAAE,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;IAE7E,OAAO;QACL,IAAI,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC;QAEjC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO;YACvB,MAAM,KAAK,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC;YAClC,IAAI,KAAK,GAAG,wBAAwB,EAAE,CAAC;gBACrC,MAAM,IAAI,mBAAmB,CAC3B,SAAS,IAAI,QAAQ,KAAK,oBAAoB,wBAAwB,aAAa,CACpF,CAAC;YACJ,CAAC;YACD,IAAI,CAAC,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;gBAC7B,MAAM,EAAE,SAAS,EAAE,GAAG,MAAM,EAAE,CAAC,gBAAgB,EAAE,CAAC;gBAClD,IAAI,SAAS,IAAI,mBAAmB,EAAE,CAAC;oBACrC,MAAM,IAAI,mBAAmB,CAC3B,2BAA2B,SAAS,eAAe,mBAAmB,GAAG,CAC1E,CAAC;gBACJ,CAAC;YACH,CAAC;YACD,MAAM,EAAE,CAAC,SAAS,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QACpC,CAAC;QAED,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC;QAEjC,MAAM,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC;QAErC,KAAK,CAAC,IAAI,CAAC,GAAG;YACZ,MAAM,OAAO,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YACtC,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;gBACzB,IAAI,EAAE,CAAC,CAAC,IAAI;gBACZ,IAAI,EAAE,CAAC,CAAC,IAAI;gBACZ,IAAI,EAAE,CAAC,CAAC,IAAI;aACb,CAAC,CAAC,CAAC;QACN,CAAC;QAED,KAAK,CAAC,QAAQ,CAAI,IAAY;YAC5B,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YACpC,OAAO,GAAG,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAO,CAAC;QACtD,CAAC;QAED,KAAK,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK;YACzB,MAAM,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;QACzD,CAAC;KACF,CAAC;AACJ,CAAC"}

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://../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.
+ * Recall results, system prompts, and context blocks 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;
+//# sourceMappingURL=catalog.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../src/subtasks/catalog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAGzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,WAAW,qBAAsB,SAAQ,gBAAgB;IAC7D,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAIlE"}

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://../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.
+ * Recall results, system prompts, and context blocks 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;
+}
+//# sourceMappingURL=catalog.js.map

package/dist/subtasks/catalog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.js","sourceRoot":"","sources":["../../src/subtasks/catalog.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAclD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,iBAAiB,CAAC,OAAuB;IACvD,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM,IAAI,OAAO,CAAC,IAAI,KAAK,WAAW;QAAE,OAAO,KAAK,CAAC;IAC1E,IAAI,mBAAmB,CAAC,OAAO,CAAC;QAAE,OAAO,KAAK,CAAC;IAC/C,OAAO,WAAW,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC;AAChD,CAAC"}

package/dist/subtasks/decomposition.d.ts

@@ -0,0 +1,90 @@
+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.
+ *
+ * Two invariants live 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.
+ * - **The dependency graph is a validated DAG.** Unknown, duplicate,
+ *   self-referential, and cyclic edges are all rejected here. The data layer's
+ *   `createDecomposition` re-checks the cheap structural rules as a storage guard,
+ *   but full cycle detection is this module's job.
+ *
+ * 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, and the difference used
+ * to be a hole. This schema reaches the model through a **control** tool, which has
+ * no `execute` — so the SDK's input validation never ran on it, and a blank value
+ * the model was shown the pattern for sailed through anyway. What enforces it is
+ * {@link file://../control.ts control.ts}, which parses every control call with its
+ * 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<{
+        localKey: z.ZodString;
+        type: z.ZodEnum<{
+            [x: string]: string;
+        }>;
+        prompt: z.ZodString;
+        referenceIndexes: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        dependsOn: z.ZodArray<z.ZodString>;
+        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, duplicate local keys, unknown/duplicate reference indices, and unknown,
+ * duplicate, self-referential, or cyclic dependency edges. 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[];
+};
+//# sourceMappingURL=decomposition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decomposition.d.ts","sourceRoot":"","sources":["../../src/subtasks/decomposition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAC1D,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EACV,qBAAqB,EACrB,YAAY,EAEb,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,2EAA2E;AAC3E,qBAAa,4BAA6B,SAAQ,KAAK;gBACzC,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,MAAM,gBAIqB,CAAC;AA2B5D;;;;;;;;;;;;GAYG;AACH,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,mBAAmB,EAC1B,WAAW,EAAE,MAAM;;;;;;;;;;;;;;kBAMpB;AAiED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,qBAAqB,EAC/B,OAAO,EAAE,qBAAqB,EAAE,EAChC,KAAK,EAAE,mBAAmB,GACzB;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,YAAY,EAAE,CAAA;CAAE,CA6D3C"}

package/dist/subtasks/decomposition.js

@@ -0,0 +1,205 @@
+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.
+ *
+ * Two invariants live 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.
+ * - **The dependency graph is a validated DAG.** Unknown, duplicate,
+ *   self-referential, and cyclic edges are all rejected here. The data layer's
+ *   `createDecomposition` re-checks the cheap structural rules as a storage guard,
+ *   but full cycle detection is this module's job.
+ *
+ * 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, and the difference used
+ * to be a hole. This schema reaches the model through a **control** tool, which has
+ * no `execute` — so the SDK's input validation never ran on it, and a blank value
+ * the model was shown the pattern for sailed through anyway. What enforces it is
+ * {@link file://../control.ts control.ts}, which parses every control call with its
+ * 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({
+        localKey: nonBlank("localKey"),
+        // 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(),
+        dependsOn: z.array(nonBlank("dependsOn entry")),
+        /**
+         * 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)
+    });
+}
+/**
+ * Reject an edge set that contains a cycle, by Kahn's algorithm over the
+ * draft-local keys: repeatedly remove nodes with no unresolved prerequisites; if
+ * any node survives, it is part of (or downstream of) a cycle.
+ */
+function assertAcyclic(proposal) {
+    const remaining = new Map(proposal.subtasks.map((s) => [s.localKey, new Set(s.dependsOn)]));
+    let progressed = true;
+    while (progressed && remaining.size > 0) {
+        progressed = false;
+        for (const [key, deps] of remaining) {
+            // Ready when every prerequisite has already been removed.
+            if ([...deps].every((d) => !remaining.has(d))) {
+                remaining.delete(key);
+                progressed = true;
+            }
+        }
+    }
+    if (remaining.size > 0) {
+        throw new DecompositionValidationError(`dependency cycle among subtasks: ${[...remaining.keys()].join(", ")}`);
+    }
+}
+/**
+ * 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.
+ */
+function resolveReferences(localKey, referenceIndexes, catalog) {
+    if (!referenceIndexes)
+        return [];
+    const seen = new Set();
+    for (const index of referenceIndexes) {
+        if (seen.has(index)) {
+            throw new DecompositionValidationError(`subtask ${localKey} references index ${index} more than once`);
+        }
+        seen.add(index);
+        if (index > catalog.length) {
+            throw new DecompositionValidationError(`subtask ${localKey} 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, duplicate local keys, unknown/duplicate reference indices, and unknown,
+ * duplicate, self-referential, or cyclic dependency edges. On success, array order
+ * is preserved — the data layer derives each Subtask's `ordinal` from it.
+ */
+export function resolveDecomposition(proposal, catalog, types) {
+    const keys = new Set();
+    for (const s of proposal.subtasks) {
+        if (keys.has(s.localKey)) {
+            throw new DecompositionValidationError(`duplicate subtask local key: ${s.localKey}`);
+        }
+        keys.add(s.localKey);
+    }
+    // Every key must be registered before any edge is checked: an edge may point
+    // forward to a subtask defined later in the array.
+    for (const s of proposal.subtasks) {
+        const seen = new Set();
+        for (const dep of s.dependsOn) {
+            if (dep === s.localKey) {
+                throw new DecompositionValidationError(`subtask ${s.localKey} depends on itself`);
+            }
+            if (!keys.has(dep)) {
+                throw new DecompositionValidationError(`subtask ${s.localKey} depends on unknown key: ${dep}`);
+            }
+            if (seen.has(dep)) {
+                throw new DecompositionValidationError(`subtask ${s.localKey} depends on ${dep} more than once`);
+            }
+            seen.add(dep);
+        }
+    }
+    assertAcyclic(proposal);
+    const drafts = proposal.subtasks.map((s) => {
+        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(`subtask ${s.localKey}: ${err.message}`);
+        }
+        return {
+            localKey: s.localKey,
+            type,
+            prompt: s.prompt.trim(),
+            references: resolveReferences(s.localKey, s.referenceIndexes, catalog),
+            dependsOn: [...s.dependsOn],
+            params
+        };
+    });
+    return { reply: proposal.reply.trim(), drafts };
+}
+//# sourceMappingURL=decomposition.js.map

package/dist/subtasks/decomposition.js.map

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

package/dist/subtasks/delegate.d.ts

@@ -0,0 +1,77 @@
+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
+ * (`recall`, `browser_*`, `set_context`), 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://../history.ts}). Later rounds rebuild it
+ * rather than storing it.
+ */
+export declare function delegateToolCallId(taskId: string, round: number): string;
+/**
+ * One branch's outcome, as the tool result carries it. `output` is null for any
+ * branch that did not complete.
+ *
+ * There is no `error` field, and that is deliberate: internal diagnostics never
+ * reach the model. It discloses *that* something failed, in user-safe words; the
+ * durable row keeps the detail.
+ *
+ * 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.
+ */
+export declare function delegateCallInput(reply: string, branches: CompositionBranch[]): DecompositionProposal;
+/** Rebuild one round's call result from its durable rows, in stable ordinal order. */
+export declare function delegateCallOutput(branches: CompositionBranch[]): DelegateSubtaskOutcome[];
+//# sourceMappingURL=delegate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"delegate.d.ts","sourceRoot":"","sources":["../../src/subtasks/delegate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,IAAI,EAAE,MAAM,IAAI,CAAC;AAErC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,EACV,iBAAiB,EACjB,qBAAqB,EACrB,SAAS,EACT,aAAa,EACd,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,kBAAkB,aAAa,CAAC;AAE7C;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,mBAAmB,EAC1B,WAAW,EAAE,MAAM,GAClB,IAAI,CAQN;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAExE;AAeD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,SAAS,EAAE,SAAS,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,aAAa,CAAC;IACtB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,iBAAiB,EAAE,GAC5B,qBAAqB,CAavB;AAED,sFAAsF;AACtF,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,iBAAiB,EAAE,GAC5B,sBAAsB,EAAE,CAU1B"}