@loopingai/core 0.1.0

package/dist/agent/inference.d.ts

@@ -0,0 +1,52 @@
+import type { StepResult, ToolSet } from "ai";
+/**
+ * Shared Workers-AI plumbing for the agent's inference operations — the pieces
+ * every model call needs regardless of *which* operation it belongs to.
+ *
+ * The two loops themselves are deliberately separate, not layered on a common
+ * one: the main agent's Session-coupled round lives in
+ * {@link file://./turn.ts turn.ts}, and the Session-less subagent loop in
+ * {@link file://../subagent/run.ts run.ts}. They share error classification and
+ * progress streaming; their control flow has nothing in common worth abstracting.
+ */
+/**
+ * Called with each **intermediate** assistant content message — text the model
+ * emits in a step that also makes tool calls (`finishReason:"tool-calls"`), i.e.
+ * before the final reply. Used to stream those messages out live; the final reply
+ * is the operation's return value, not an `onContent` call. `stepIndex` is the
+ * 0-based step ordinal (stable enough across a primary→fallback re-run for the
+ * gateway to dedupe on). Best-effort — the caller must swallow its own failures.
+ */
+export type OnContent = (text: string, stepIndex: number) => void | Promise<void>;
+/**
+ * Whether an error is a transient availability condition rather than a
+ * deterministic bad-output one.
+ *
+ * The distinction decides who handles it: transient throws out of the attempt loop
+ * so the Workflow step retries the whole round, while everything else burns the
+ * model slot and hands over to the fallback. Classifying a capacity blip as
+ * deterministic is the expensive mistake — it spends both slots on an outage and
+ * fails a Task that would have succeeded a second later.
+ *
+ * Structured signals first: the SDK's own `APICallError.isRetryable`, then the
+ * status code, then `RetryError` (raised once the SDK's internal backoff is
+ * exhausted). The message fragments stay as the last resort for the Workers-AI
+ * error codes, which arrive as prose on a plain `Error`.
+ */
+export declare function isTransientAiError(err: unknown): boolean;
+/**
+ * Returns a fresh `onStepEnd` callback for one `generateText` attempt.
+ * Fires `onContent` for each intermediate step (text that accompanies tool
+ * calls); the final step is skipped because its text is the operation's return
+ * value. A fresh handler per attempt resets the 0-based `stepIndex` counter so a
+ * primary→fallback re-run reuses the same indices and the gateway dedupes.
+ *
+ * `terminalToolNames` are the loop's **halting** control tools (e.g. the main
+ * agent's `delegate`): a step that calls one still has `finishReason:"tool-calls"`,
+ * but it is the round's *final* step, and its accompanying text is the round's
+ * acknowledgment — which the caller publishes separately as a milestone. Streaming
+ * it here too would double-post the same text under a second messageId, so those
+ * steps are skipped. Default `[]` (the subagent loop has no control tools).
+ */
+export declare function buildIntermediateContentHandler(onContent: OnContent, terminalToolNames?: string[]): (step: StepResult<ToolSet>) => Promise<void>;
+//# sourceMappingURL=inference.d.ts.map

package/dist/agent/inference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inference.d.ts","sourceRoot":"","sources":["../../src/agent/inference.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,UAAU,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC;AAG5D;;;;;;;;;GASG;AAEH;;;;;;;GAOG;AACH,MAAM,MAAM,SAAS,GAAG,CACtB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,KACd,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAoB1B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAWxD;AAOD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,+BAA+B,CAC7C,SAAS,EAAE,SAAS,EACpB,iBAAiB,GAAE,MAAM,EAAO,GAC/B,CAAC,IAAI,EAAE,UAAU,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAU9C"}

package/dist/agent/inference.js

@@ -0,0 +1,79 @@
+import { APICallError, RetryError } from "ai";
+/** Workers-AI error codes and message fragments that mean "try again later". */
+const TRANSIENT_MESSAGE_FRAGMENTS = [
+    "3040",
+    "3046",
+    "capacity temporarily exceeded",
+    "request timeout",
+    "rate limit",
+    "too many requests",
+    "overloaded",
+    "service unavailable"
+];
+/** HTTP statuses worth another attempt: timeout, conflict, throttle, any 5xx. */
+function isRetryableStatus(status) {
+    if (status === undefined)
+        return false;
+    return status === 408 || status === 409 || status === 429 || status >= 500;
+}
+/**
+ * Whether an error is a transient availability condition rather than a
+ * deterministic bad-output one.
+ *
+ * The distinction decides who handles it: transient throws out of the attempt loop
+ * so the Workflow step retries the whole round, while everything else burns the
+ * model slot and hands over to the fallback. Classifying a capacity blip as
+ * deterministic is the expensive mistake — it spends both slots on an outage and
+ * fails a Task that would have succeeded a second later.
+ *
+ * Structured signals first: the SDK's own `APICallError.isRetryable`, then the
+ * status code, then `RetryError` (raised once the SDK's internal backoff is
+ * exhausted). The message fragments stay as the last resort for the Workers-AI
+ * error codes, which arrive as prose on a plain `Error`.
+ */
+export function isTransientAiError(err) {
+    if (APICallError.isInstance(err)) {
+        if (err.isRetryable)
+            return true;
+        if (isRetryableStatus(err.statusCode))
+            return true;
+    }
+    if (RetryError.isInstance(err))
+        return true;
+    if (!(err instanceof Error))
+        return false;
+    const message = err.message.toLowerCase();
+    return TRANSIENT_MESSAGE_FRAGMENTS.some((fragment) => message.includes(fragment));
+}
+/** A step is "intermediate" when it makes tool calls — more content follows. */
+function isIntermediateStep(step) {
+    return step.finishReason === "tool-calls";
+}
+/**
+ * Returns a fresh `onStepEnd` callback for one `generateText` attempt.
+ * Fires `onContent` for each intermediate step (text that accompanies tool
+ * calls); the final step is skipped because its text is the operation's return
+ * value. A fresh handler per attempt resets the 0-based `stepIndex` counter so a
+ * primary→fallback re-run reuses the same indices and the gateway dedupes.
+ *
+ * `terminalToolNames` are the loop's **halting** control tools (e.g. the main
+ * agent's `delegate`): a step that calls one still has `finishReason:"tool-calls"`,
+ * but it is the round's *final* step, and its accompanying text is the round's
+ * acknowledgment — which the caller publishes separately as a milestone. Streaming
+ * it here too would double-post the same text under a second messageId, so those
+ * steps are skipped. Default `[]` (the subagent loop has no control tools).
+ */
+export function buildIntermediateContentHandler(onContent, terminalToolNames = []) {
+    let stepIndex = 0;
+    return async (step) => {
+        const i = stepIndex++;
+        if (!isIntermediateStep(step))
+            return;
+        if (step.toolCalls.some((c) => terminalToolNames.includes(c.toolName)))
+            return;
+        const content = step.text.trim();
+        if (content)
+            await onContent(content, i);
+    };
+}
+//# sourceMappingURL=inference.js.map

package/dist/agent/inference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inference.js","sourceRoot":"","sources":["../../src/agent/inference.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,IAAI,CAAC;AA0B9C,gFAAgF;AAChF,MAAM,2BAA2B,GAAG;IAClC,MAAM;IACN,MAAM;IACN,+BAA+B;IAC/B,iBAAiB;IACjB,YAAY;IACZ,mBAAmB;IACnB,YAAY;IACZ,qBAAqB;CACtB,CAAC;AAEF,iFAAiF;AACjF,SAAS,iBAAiB,CAAC,MAA0B;IACnD,IAAI,MAAM,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IACvC,OAAO,MAAM,KAAK,GAAG,IAAI,MAAM,KAAK,GAAG,IAAI,MAAM,KAAK,GAAG,IAAI,MAAM,IAAI,GAAG,CAAC;AAC7E,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,kBAAkB,CAAC,GAAY;IAC7C,IAAI,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;QACjC,IAAI,GAAG,CAAC,WAAW;YAAE,OAAO,IAAI,CAAC;QACjC,IAAI,iBAAiB,CAAC,GAAG,CAAC,UAAU,CAAC;YAAE,OAAO,IAAI,CAAC;IACrD,CAAC;IACD,IAAI,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IAC5C,IAAI,CAAC,CAAC,GAAG,YAAY,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAC1C,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;IAC1C,OAAO,2BAA2B,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CACnD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAC3B,CAAC;AACJ,CAAC;AAED,gFAAgF;AAChF,SAAS,kBAAkB,CAAC,IAAoC;IAC9D,OAAO,IAAI,CAAC,YAAY,KAAK,YAAY,CAAC;AAC5C,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,+BAA+B,CAC7C,SAAoB,EACpB,oBAA8B,EAAE;IAEhC,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,OAAO,KAAK,EAAE,IAAI,EAAE,EAAE;QACpB,MAAM,CAAC,GAAG,SAAS,EAAE,CAAC;QACtB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC;YAAE,OAAO;QACtC,IAAI,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,iBAAiB,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;YACpE,OAAO;QACT,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QACjC,IAAI,OAAO;YAAE,MAAM,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC;IAC3C,CAAC,CAAC;AACJ,CAAC"}

package/dist/agent/model.d.ts

@@ -0,0 +1,75 @@
+import type { LanguageModel } from "ai";
+import type { ModelConfig } from "../config.js";
+/**
+ * The Workers-AI model pair every loop runs on, built per agent instance.
+ *
+ * The predecessor read `env.AI` and five config constants as module-level
+ * imports. Neither survives packaging: `env` does not exist at module scope on
+ * Workers, and a module constant cannot be overridden by a consumer. So this is
+ * a factory over an injected binding and an injected {@link ModelConfig}.
+ */
+/**
+ * Embed a batch of texts for episodic recall. Uses the same Workers-AI + AI
+ * Gateway path as the chat models so embeddings get the same gateway
+ * observability/caching. The output dimension must match the Vectorize index.
+ */
+export type Embed = (texts: string[]) => Promise<number[][]>;
+/**
+ * Custom metadata attached to the AI Gateway log for every call a pair makes.
+ * The gateway's own `metadata` is otherwise `null`, so a model call can only be
+ * tied back to its task by timestamp; stamping `{ taskId, round }` (a turn) or
+ * `{ taskId, subtaskId }` (a chunk) makes correlation exact. Values are limited
+ * to the gateway's accepted scalar set.
+ */
+export type GatewayMetadata = Record<string, number | string | boolean>;
+export interface ModelOverrides {
+    /** Test override for the primary slot. */
+    model?: LanguageModel;
+    /** Test override for the fallback slot. */
+    fallbackModel?: LanguageModel;
+    /**
+     * Workers-AI id for the primary slot (a recipe's, already code-validated
+     * against the allowlist by `validateRecipe`). Defaults to the configured
+     * `chatModelId`.
+     */
+    primaryModelId?: string;
+    /**
+     * Workers-AI id for the fallback slot (already code-validated). Defaults to
+     * the configured `fallbackChatModelId`.
+     */
+    fallbackModelId?: string;
+    /** AI Gateway log metadata for correlation — see {@link GatewayMetadata}. */
+    metadata?: GatewayMetadata;
+}
+/** The primary/fallback models (lazily memoized) plus their ids for logging. */
+export interface ModelPair {
+    primary: () => LanguageModel;
+    fallback: () => LanguageModel;
+    primaryId: () => string;
+    fallbackId: () => string;
+}
+export interface ModelRuntime {
+    /**
+     * Lazily build + memoize a primary/fallback model pair (overridable in tests,
+     * id-parameterized for recipes). No allowlisting happens here —
+     * `validateRecipe` is the single validation owner for recipe-supplied ids.
+     */
+    createModelPair(overrides?: ModelOverrides): ModelPair;
+    embedTexts: Embed;
+}
+export interface ModelRuntimeDeps {
+    /** The `AI` binding. Read lazily — see {@link createModelRuntime}. */
+    ai: Ai;
+    config: ModelConfig;
+}
+/**
+ * Build the model runtime for one agent instance.
+ *
+ * The provider is constructed on first *use*, not here. During `wrangler deploy`
+ * Cloudflare evaluates module scope to validate the new version, and bindings
+ * are not populated at that point — constructing eagerly makes `createWorkersAI`
+ * throw "you must provide either a binding or credentials". The same laziness
+ * protects a consumer who builds their runtime early.
+ */
+export declare function createModelRuntime(deps: ModelRuntimeDeps): ModelRuntime;
+//# sourceMappingURL=model.d.ts.map

package/dist/agent/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../src/agent/model.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,IAAI,CAAC;AAExC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD;;;;;;;GAOG;AAEH;;;;GAIG;AACH,MAAM,MAAM,KAAK,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;AAE7D;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;AAExE,MAAM,WAAW,cAAc;IAC7B,0CAA0C;IAC1C,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,2CAA2C;IAC3C,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,eAAe,CAAC;CAC5B;AAED,gFAAgF;AAChF,MAAM,WAAW,SAAS;IACxB,OAAO,EAAE,MAAM,aAAa,CAAC;IAC7B,QAAQ,EAAE,MAAM,aAAa,CAAC;IAC9B,SAAS,EAAE,MAAM,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,eAAe,CAAC,SAAS,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;IACvD,UAAU,EAAE,KAAK,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,sEAAsE;IACtE,EAAE,EAAE,EAAE,CAAC;IACP,MAAM,EAAE,WAAW,CAAC;CACrB;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,gBAAgB,GAAG,YAAY,CAuDvE"}

package/dist/agent/model.js

@@ -0,0 +1,62 @@
+import { createWorkersAI } from "workers-ai-provider";
+import { embedMany } from "ai";
+/**
+ * Build the model runtime for one agent instance.
+ *
+ * The provider is constructed on first *use*, not here. During `wrangler deploy`
+ * Cloudflare evaluates module scope to validate the new version, and bindings
+ * are not populated at that point — constructing eagerly makes `createWorkersAI`
+ * throw "you must provide either a binding or credentials". The same laziness
+ * protects a consumer who builds their runtime early.
+ */
+export function createModelRuntime(deps) {
+    const { config } = deps;
+    let provider;
+    const workersai = () => (provider ??= createWorkersAI({
+        binding: deps.ai,
+        gateway: { id: config.aiGatewayId }
+    }));
+    /**
+     * Per-model Workers-AI settings: pin the gateway id (so per-call metadata does
+     * not drop the gateway route), attach correlation metadata when supplied, and
+     * set the reasoning budget.
+     *
+     * Always returns a settings object, even with no metadata: `reasoning_effort`
+     * has to reach the binding on every call, and an `undefined` return drops it.
+     */
+    const chatSettings = (metadata) => ({
+        gateway: { id: config.aiGatewayId, ...(metadata ? { metadata } : {}) },
+        reasoning_effort: config.reasoningEffort
+    });
+    return {
+        createModelPair(overrides = {}) {
+            const primaryId = overrides.primaryModelId ?? config.chatModelId;
+            const fallbackId = overrides.fallbackModelId ?? config.fallbackChatModelId;
+            let primary;
+            let fallback;
+            const settings = chatSettings(overrides.metadata);
+            return {
+                primary: () => (primary ??= overrides.model ?? workersai()(primaryId, settings)),
+                fallback: () => (fallback ??=
+                    overrides.fallbackModel ??
+                        overrides.model ??
+                        workersai()(fallbackId, settings)),
+                primaryId: () => primaryId,
+                fallbackId: () => fallbackId
+            };
+        },
+        async embedTexts(texts) {
+            if (texts.length === 0)
+                return [];
+            const { embeddings } = await embedMany({
+                model: workersai().embedding(config.embeddingModelId),
+                values: texts,
+                // Failures surface to the caller (best-effort archival swallows them);
+                // the SDK's retry/backoff would only add latency on a hard failure.
+                maxRetries: 0
+            });
+            return embeddings;
+        }
+    };
+}
+//# sourceMappingURL=model.js.map

package/dist/agent/model.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.js","sourceRoot":"","sources":["../../src/agent/model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEtD,OAAO,EAAE,SAAS,EAAE,MAAM,IAAI,CAAC;AAwE/B;;;;;;;;GAQG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAsB;IACvD,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACxB,IAAI,QAAwD,CAAC;IAC7D,MAAM,SAAS,GAAG,GAAG,EAAE,CACrB,CAAC,QAAQ,KAAK,eAAe,CAAC;QAC5B,OAAO,EAAE,IAAI,CAAC,EAAE;QAChB,OAAO,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,WAAW,EAAE;KACpC,CAAC,CAAC,CAAC;IAEN;;;;;;;OAOG;IACH,MAAM,YAAY,GAAG,CAAC,QAA0B,EAAE,EAAE,CAAC,CAAC;QACpD,OAAO,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,WAAW,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE;QACtE,gBAAgB,EAAE,MAAM,CAAC,eAAe;KACzC,CAAC,CAAC;IAEH,OAAO;QACL,eAAe,CAAC,YAA4B,EAAE;YAC5C,MAAM,SAAS,GAAG,SAAS,CAAC,cAAc,IAAI,MAAM,CAAC,WAAW,CAAC;YACjE,MAAM,UAAU,GACd,SAAS,CAAC,eAAe,IAAI,MAAM,CAAC,mBAAmB,CAAC;YAC1D,IAAI,OAAkC,CAAC;YACvC,IAAI,QAAmC,CAAC;YACxC,MAAM,QAAQ,GAAG,YAAY,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;YAClD,OAAO;gBACL,OAAO,EAAE,GAAG,EAAE,CACZ,CAAC,OAAO,KAAK,SAAS,CAAC,KAAK,IAAI,SAAS,EAAE,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;gBACnE,QAAQ,EAAE,GAAG,EAAE,CACb,CAAC,QAAQ;oBACP,SAAS,CAAC,aAAa;wBACvB,SAAS,CAAC,KAAK;wBACf,SAAS,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;gBACtC,SAAS,EAAE,GAAG,EAAE,CAAC,SAAS;gBAC1B,UAAU,EAAE,GAAG,EAAE,CAAC,UAAU;aAC7B,CAAC;QACJ,CAAC;QAED,KAAK,CAAC,UAAU,CAAC,KAAe;YAC9B,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,EAAE,CAAC;YAClC,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,SAAS,CAAC;gBACrC,KAAK,EAAE,SAAS,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,gBAAgB,CAAC;gBACrD,MAAM,EAAE,KAAK;gBACb,uEAAuE;gBACvE,oEAAoE;gBACpE,UAAU,EAAE,CAAC;aACd,CAAC,CAAC;YACH,OAAO,UAAU,CAAC;QACpB,CAAC;KACF,CAAC;AACJ,CAAC"}

package/dist/agent/session.d.ts

@@ -0,0 +1,92 @@
+import type { LanguageModel, ToolSet } from "ai";
+import { Session } from "agents/experimental/memory/session";
+import type { SessionMessage } from "agents/experimental/memory/session";
+import { createCompactFunction } from "agents/experimental/memory/utils";
+/**
+ * The one continuous {@link Session} an agent Durable Object owns. Ported from
+ * the looping-gateway admin agent's `shared/session.ts` (single Session per DO —
+ * soul + memory + compaction). Recall (Vectorize) archival is Phase 3: the
+ * `onArchive` seam is present but left unwired for now.
+ */
+/**
+ * The SQLite-backed host the Sessions API needs — satisfied by the Agents SDK
+ * `Agent` (`this.sql`).
+ */
+export interface SessionHost {
+    sql<T = Record<string, string | number | boolean | null>>(strings: TemplateStringsArray, ...values: (string | number | boolean | null)[]): T[];
+}
+/** The subset of `Session` the agent loop drives — lets tests inject a fake. */
+export interface SessionLike {
+    appendMessage(message: SessionMessage, parentId?: string | null): Promise<unknown> | unknown;
+    getHistory(): Promise<SessionMessage[]>;
+    /**
+     * Read one message by id, or null. Reads the **raw stored row**, so it is
+     * unaffected by compaction overlays — a message folded into a summary is still
+     * readable here. That is what makes {@link appendOnce}'s read-back a reliable
+     * recovery path for a phase whose Workflow step re-ran.
+     */
+    getMessage(id: string): Promise<SessionMessage | null>;
+    refreshSystemPrompt(): Promise<string>;
+    tools(): Promise<ToolSet>;
+    /** Compaction overlays so far — non-empty ⇒ an episodic archive exists. */
+    getCompactions(): Promise<unknown[]>;
+}
+/**
+ * Append a message with a deterministic id exactly once, and return the text that
+ * is **durably stored** under that id.
+ *
+ * `Session.appendMessage` is already idempotent by id: appending an id that
+ * exists is a no-op. The read-back is what matters for a re-run phase — if the
+ * step crashed after appending and the retry re-inferred a *different* reply, the
+ * append no-ops and this returns the original, durable text. The Session and the
+ * value the caller goes on to deliver therefore never disagree.
+ *
+ * Falls back to the message's own text if the read-back returns null (it cannot,
+ * having just been appended) rather than failing a phase over a missing echo.
+ */
+export declare function appendOnce(session: SessionLike, message: SessionMessage): Promise<string>;
+export interface AgentSessionOptions {
+    /** Read-only identity block injected into the system prompt every turn. */
+    soul: () => string | Promise<string>;
+    /** Description of the writable SQLite `"memory"` scratchpad the model self-edits. */
+    memoryDescription: string;
+    /** Soft cap (tokens) for the `"memory"` block. */
+    memoryMaxTokens: number;
+    /** History token threshold that triggers compaction. */
+    compactAfterTokens: number;
+    /**
+     * Tokens of recent history compaction keeps verbatim. Coupled to
+     * {@link compactAfterTokens} — see `SessionConfig.compactTailTokens` for the
+     * invariant that binds them, which `resolveConfig` enforces.
+     */
+    compactTailTokens: number;
+    /**
+     * Output-token ceiling for the summarizer call. An unbounded summary is not
+     * the risk; a silently truncated one is — it becomes this caller's memory of
+     * everything that scrolled out, with no way to tell it was cut short.
+     */
+    maxOutputTokens: number;
+    /**
+     * Archive the raw messages displaced by each compaction (episodic recall).
+     * Best-effort: a throw here must never abort compaction. (Wired in Phase 3.)
+     */
+    onArchive?: (messages: SessionMessage[]) => Promise<void>;
+}
+type CompactFn = ReturnType<typeof createCompactFunction>;
+/**
+ * Wrap a compaction function so the raw messages it folds into a summary are
+ * also handed to `onArchive` (which embeds them for later recall). The displaced
+ * range is `fromMessageId..toMessageId` of the result, sliced from the `history`
+ * the compaction saw. Archival failure is swallowed — compaction must still
+ * shorten history even if the recall store is briefly unavailable.
+ */
+export declare function archivingCompaction(base: CompactFn, onArchive?: (messages: SessionMessage[]) => Promise<void>): CompactFn;
+/**
+ * Build the one continuous `Session` an agent Durable Object owns: a read-only
+ * `"soul"` identity block + a writable `"memory"` scratchpad, with history
+ * compaction summarized by the same model. All of a caller's turns (any channel
+ * or thread) accumulate into this single conversation.
+ */
+export declare function buildAgentSession(agent: SessionHost, model: LanguageModel, opts: AgentSessionOptions): Session;
+export {};
+//# sourceMappingURL=session.d.ts.map

package/dist/agent/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/agent/session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC;AAEjD,OAAO,EAAE,OAAO,EAAE,MAAM,oCAAoC,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AACzE,OAAO,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AAGzE;;;;;GAKG;AAEH;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC,EACtD,OAAO,EAAE,oBAAoB,EAC7B,GAAG,MAAM,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC,EAAE,GAC9C,CAAC,EAAE,CAAC;CACR;AAED,gFAAgF;AAChF,MAAM,WAAW,WAAW;IAC1B,aAAa,CACX,OAAO,EAAE,cAAc,EACvB,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,GACvB,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;IAC9B,UAAU,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC;IACxC;;;;;OAKG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAAC;IACvD,mBAAmB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IACvC,KAAK,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1B,2EAA2E;IAC3E,cAAc,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;CACtC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE,WAAW,EACpB,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,MAAM,CAAC,CAIjB;AAED,MAAM,WAAW,mBAAmB;IAClC,2EAA2E;IAC3E,IAAI,EAAE,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACrC,qFAAqF;IACrF,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kDAAkD;IAClD,eAAe,EAAE,MAAM,CAAC;IACxB,wDAAwD;IACxD,kBAAkB,EAAE,MAAM,CAAC;IAC3B;;;;OAIG;IACH,iBAAiB,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,eAAe,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,cAAc,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3D;AAED,KAAK,SAAS,GAAG,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1D;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,SAAS,EACf,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,cAAc,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,GACxD,SAAS,CAiBX;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,WAAW,EAClB,KAAK,EAAE,aAAa,EACpB,IAAI,EAAE,mBAAmB,GACxB,OAAO,CA2BT"}

package/dist/agent/session.js

@@ -0,0 +1,80 @@
+import { generateText } from "ai";
+import { Session } from "agents/experimental/memory/session";
+import { createCompactFunction } from "agents/experimental/memory/utils";
+import { sessionText } from "./history.js";
+/**
+ * Append a message with a deterministic id exactly once, and return the text that
+ * is **durably stored** under that id.
+ *
+ * `Session.appendMessage` is already idempotent by id: appending an id that
+ * exists is a no-op. The read-back is what matters for a re-run phase — if the
+ * step crashed after appending and the retry re-inferred a *different* reply, the
+ * append no-ops and this returns the original, durable text. The Session and the
+ * value the caller goes on to deliver therefore never disagree.
+ *
+ * Falls back to the message's own text if the read-back returns null (it cannot,
+ * having just been appended) rather than failing a phase over a missing echo.
+ */
+export async function appendOnce(session, message) {
+    await session.appendMessage(message);
+    const stored = await session.getMessage(message.id);
+    return stored ? sessionText(stored) : sessionText(message);
+}
+/**
+ * Wrap a compaction function so the raw messages it folds into a summary are
+ * also handed to `onArchive` (which embeds them for later recall). The displaced
+ * range is `fromMessageId..toMessageId` of the result, sliced from the `history`
+ * the compaction saw. Archival failure is swallowed — compaction must still
+ * shorten history even if the recall store is briefly unavailable.
+ */
+export function archivingCompaction(base, onArchive) {
+    if (!onArchive)
+        return base;
+    return async (history, options) => {
+        const result = await base(history, options);
+        if (result) {
+            const from = history.findIndex((m) => m.id === result.fromMessageId);
+            const to = history.findIndex((m) => m.id === result.toMessageId);
+            if (from !== -1 && to !== -1) {
+                try {
+                    await onArchive(history.slice(from, to + 1));
+                }
+                catch (err) {
+                    console.error("[recall] archive on compaction failed", err);
+                }
+            }
+        }
+        return result;
+    };
+}
+/**
+ * Build the one continuous `Session` an agent Durable Object owns: a read-only
+ * `"soul"` identity block + a writable `"memory"` scratchpad, with history
+ * compaction summarized by the same model. All of a caller's turns (any channel
+ * or thread) accumulate into this single conversation.
+ */
+export function buildAgentSession(agent, model, opts) {
+    const compact = archivingCompaction(createCompactFunction({
+        // The one boundary worth owning. `protectHead` (3) and `minTailMessages`
+        // (2) keep the SDK defaults: the head is the conversation's opening and is
+        // cheap, and the tail floor is a safety net rather than a budget.
+        tailTokenBudget: opts.compactTailTokens,
+        // Bounded like every other call: an unbounded summary is not the risk, a
+        // silently truncated one is — it becomes this caller's memory of everything
+        // that scrolled out, with no way to tell it was cut short.
+        summarize: (prompt) => generateText({
+            model,
+            prompt,
+            maxOutputTokens: opts.maxOutputTokens
+        }).then((r) => r.text)
+    }), opts.onArchive);
+    return Session.create(agent)
+        .withContext("soul", { provider: { get: async () => opts.soul() } })
+        .withContext("memory", {
+        description: opts.memoryDescription,
+        maxTokens: opts.memoryMaxTokens
+    })
+        .onCompaction(compact)
+        .compactAfter(opts.compactAfterTokens);
+}
+//# sourceMappingURL=session.js.map

package/dist/agent/session.js.map

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

package/dist/config.d.ts

@@ -0,0 +1,159 @@
+/**
+ * The shapes of everything an agent tunes, plus a working set of defaults.
+ *
+ * In the predecessor repos this file held bare `export const`s that ~12 modules
+ * imported directly. That is what this package cannot do: a module-level constant
+ * read at import time is not overridable by a consumer, and it freezes the value
+ * into the module graph before `env` exists. So core owns the *shapes* and a
+ * baseline; a consuming agent passes overrides to {@link resolveConfig} once, at
+ * DO start, and the resolved object is threaded through explicitly.
+ *
+ * The distinction against {@link file://./platform.ts} stays sharp: nothing here
+ * is a platform fact, and nothing there is tunable.
+ */
+/** Model ids and per-call generation settings. */
+export interface ModelConfig {
+    /** Workers AI model for the tool loop. Must support function calling. */
+    chatModelId: string;
+    /**
+     * Tried when the primary throws. Should be a *different vendor and family* —
+     * a same-family fallback shares the failure mode you are falling back from.
+     */
+    fallbackChatModelId: string;
+    /** AI Gateway slug; `"default"` auto-provisions on first request. */
+    aiGatewayId: string;
+    /**
+     * Output-token ceiling for every chat call. Left unset, the binding applies a
+     * per-model default which a reasoning model spends on `reasoning_content`
+     * before emitting the tool call — a truncated round that reads as a clean
+     * answer. Generous on purpose: it bounds a runaway, it does not ration.
+     */
+    maxOutputTokens: number;
+    /** Reasoning budget forwarded on the binding's `inputs` by workers-ai-provider. */
+    reasoningEffort: "low" | "medium" | "high";
+    /**
+     * Embedding model backing recall. Its dimension/metric must match the
+     * Vectorize index (1024-dim, cosine); changing it means recreating the index.
+     */
+    embeddingModelId: string;
+}
+/**
+ * An execution budget, in the only two currencies that mean anything: **turns**
+ * (what it costs) and **wall clock** (how long it can run away for).
+ *
+ * Rounds, chunks and steps are *mechanics*, not budgets — a round is the
+ * delegate/answer loop, a chunk is a durable slice sized by the Workers step
+ * timeout. None of them is tunable and none belongs here. Conflating the two is
+ * what once made an overnight runaway look healthy to every cap in the system.
+ *
+ * Reaching either ceiling does the same thing at either level: one final call
+ * with **no tools** — "you have spent your budget, answer now from what you
+ * have". A ceiling yields an answer; it never drops the work.
+ */
+export interface AgentLimits {
+    /**
+     * Tool-loop steps, summed across every round *and* across the
+     * primary→fallback attempt within a round — a fallback attempt is real spend.
+     */
+    maxTurns: number;
+    /**
+     * Measured from the first durable step. Note for whoever implements
+     * escalation: this must be **rebased** after a `step.waitForEvent(...)`
+     * returns, or a human's thinking time is charged to the agent and a task that
+     * asks a question at minute 5 is dead before the answer arrives. Turns need no
+     * such care — waiting costs none.
+     */
+    maxWallMs: number;
+}
+/** Session memory + compaction tuning. */
+export interface SessionConfig {
+    /** Soft cap (tokens) for the self-edited `"memory"` scratchpad block. */
+    memoryMaxTokens: number;
+    /** Live-history token threshold that triggers automatic compaction. */
+    compactAfterTokens: number;
+    /**
+     * Tokens of the most recent history compaction keeps **verbatim**.
+     *
+     * Read this together with {@link compactAfterTokens}; neither means anything
+     * alone. After a compaction the floor is `system + protectHead + summary +
+     * tail`, so the conversation that must accumulate before compaction fires
+     * again is `Δ = compactAfterTokens − floor`, and the SDK sizes each summary at
+     * 20% of the middle it folded, so at equilibrium `S ≈ 0.2Δ`.
+     *
+     * INVARIANT: `compactAfterTokens − compactTailTokens >= 10_000`, asserted in
+     * `session.spec.ts`. Below it the fixed floor eats the gap and compaction
+     * fires on nearly every append, each firing spending a summarizer call on a
+     * near-empty middle. Never lower the threshold without lowering the tail too.
+     */
+    compactTailTokens: number;
+    /** One-line description shown to the model for the writable `"memory"` block. */
+    memoryDescription: string;
+}
+/** Episodic-recall (Vectorize) tuning. */
+export interface RecallConfig {
+    /** Default number of archived messages one `recall` query returns. */
+    topK: number;
+    /**
+     * Max chars of a message's text stored in its vector metadata. Keeps each
+     * vector under Vectorize's ~10 KiB/vector limit; recall returns this snippet
+     * plus provenance, not the full original message.
+     */
+    metadataTextMax: number;
+}
+export interface CoreConfig {
+    model: ModelConfig;
+    /** What bounds the MAIN agent across every round of one task. */
+    mainAgentLimits: AgentLimits;
+    /**
+     * The baseline every subagent branch runs under. A recipe may override either
+     * field — to any positive integer, larger included — and inherits the baseline
+     * for whatever it does not validly declare. A default, not a ceiling.
+     */
+    subagentLimits: AgentLimits;
+    /**
+     * How many of the most recent assistant turns keep their tool **results** in a
+     * subagent's rolling window. Older results are stubbed; the tool *calls* and
+     * the model's own text always survive the full `historyWindow`, because that
+     * is where a recipe's model keeps whatever it wrote down for itself.
+     *
+     * A mechanic of the window, not a property of a domain — which is why it is
+     * deliberately not a recipe field: recipe fields are fingerprinted, and
+     * changing a fingerprint strands every in-flight run behind a mismatch that
+     * costs it its whole history.
+     */
+    toolOutputWindow: number;
+    /**
+     * Upper bound on subtasks per **round** — a core invariant: a delegating round
+     * emits `1..maxSubtasks` subtasks, which is also what bounds its fan-out (all
+     * dependency-ready subtasks run concurrently, with no other concurrency cap).
+     *
+     * Not a budget but a shape: it is what the delegation schema offers the model,
+     * and the data layer re-checks it as the durable guard.
+     */
+    maxSubtasks: number;
+    session: SessionConfig;
+    recall: RecallConfig;
+}
+/**
+ * A working baseline. Every value is overridable; none is a ceiling. These are
+ * the values both predecessor agents converged on in production, so they are a
+ * reasonable place to start rather than an opinion about your domain.
+ */
+export declare const DEFAULT_CORE_CONFIG: CoreConfig;
+/** One level of optionality per nested group — enough for a config this shallow. */
+export type CoreConfigOverrides = {
+    [K in keyof CoreConfig]?: CoreConfig[K] extends object ? Partial<CoreConfig[K]> : CoreConfig[K];
+};
+export declare class ConfigError extends Error {
+    constructor(message: string);
+}
+/**
+ * Merge overrides onto {@link DEFAULT_CORE_CONFIG} and check the invariants that
+ * are cheap to get wrong and expensive to notice.
+ *
+ * Called once, at DO start, and the result threaded explicitly from there. Do
+ * not call it per-request: the point of resolving is that every module downstream
+ * reads the same object.
+ */
+export declare function resolveConfig(overrides?: CoreConfigOverrides): CoreConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,kDAAkD;AAClD,MAAM,WAAW,WAAW;IAC1B,yEAAyE;IACzE,WAAW,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAC5B,qEAAqE;IACrE,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,eAAe,EAAE,MAAM,CAAC;IACxB,mFAAmF;IACnF,eAAe,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,CAAC;IAC3C;;;OAGG;IACH,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;;OAMG;IACH,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,0CAA0C;AAC1C,MAAM,WAAW,aAAa;IAC5B,yEAAyE;IACzE,eAAe,EAAE,MAAM,CAAC;IACxB,uEAAuE;IACvE,kBAAkB,EAAE,MAAM,CAAC;IAC3B;;;;;;;;;;;;;OAaG;IACH,iBAAiB,EAAE,MAAM,CAAC;IAC1B,iFAAiF;IACjF,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,0CAA0C;AAC1C,MAAM,WAAW,YAAY;IAC3B,sEAAsE;IACtE,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,WAAW,CAAC;IACnB,iEAAiE;IACjE,eAAe,EAAE,WAAW,CAAC;IAC7B;;;;OAIG;IACH,cAAc,EAAE,WAAW,CAAC;IAC5B;;;;;;;;;;OAUG;IACH,gBAAgB,EAAE,MAAM,CAAC;IACzB;;;;;;;OAOG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,aAAa,CAAC;IACvB,MAAM,EAAE,YAAY,CAAC;CACtB;AAED;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,UAsBjC,CAAC;AAEF,oFAAoF;AACpF,MAAM,MAAM,mBAAmB,GAAG;KAC/B,CAAC,IAAI,MAAM,UAAU,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,SAAS,MAAM,GAClD,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,GACtB,UAAU,CAAC,CAAC,CAAC;CAClB,CAAC;AAEF,qBAAa,WAAY,SAAQ,KAAK;gBACxB,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,SAAS,GAAE,mBAAwB,GAAG,UAAU,CA4C7E"}