@loopingai/core 0.1.0

package/dist/agent/control.d.ts

@@ -0,0 +1,110 @@
+import type { Tool, ToolSet } from "ai";
+import type { ReferenceCatalogEntry } from "../subtasks/catalog.js";
+import type { SubtaskTypeRegistry } from "../subtasks/subtask-types.js";
+import type { SubtaskDraft } from "../subtasks/types.js";
+/**
+ * The **control tools** — the calls that end a round — and the one thing they all
+ * need that the SDK cannot do for them: checking their own input.
+ *
+ * A work tool carries an `execute`, so the SDK validates its input against the
+ * tool's schema, runs it, and feeds any failure — bad input, unknown tool, a throw
+ * from inside — back into the loop as a failed tool result. The model sees what
+ * went wrong and gets to try again, for free, for every work tool that exists or
+ * ever will.
+ *
+ * A control tool has no `execute`. The call *is* the round's output, so the loop
+ * halts on it and none of that machinery runs: **its input is never validated at
+ * all**. That is not a subtlety, it is a hole. A `final_reply` whose `text` was
+ * blank passed `nonBlank` untouched and was delivered to the user as an empty
+ * message; a `delegate` whose payload was not a decomposition at all reached
+ * {@link resolveDecomposition} and failed there on a raw `TypeError`.
+ *
+ * So each control tool declares a {@link ControlTool.parse}, and the round runs it
+ * where the SDK would have: between the call and any use of it. `parse` either
+ * produces the {@link TurnDecision} or throws, and a throw is handed straight back
+ * to the model as a failed result for that call — the same repair loop, from the
+ * same shape of feedback, that a work tool gets from the SDK. Adding a control tool
+ * means writing its `parse`; it inherits validation and repair by existing.
+ */
+/** What one round decided. A future `escalate` is another variant here. */
+export type TurnDecision = {
+    kind: "reply";
+    text: string;
+} | {
+    kind: "delegate";
+    reply: string;
+    drafts: SubtaskDraft[];
+};
+/**
+ * Thrown by a {@link ControlTool.parse} for a call the round cannot use.
+ *
+ * Its `message` is written for the **model**, not for a log: it is what comes back
+ * in the failed tool result, and it is the only thing the next attempt knows about
+ * why this one was rejected. Say what was wrong with the call.
+ */
+export declare class ControlCallError extends Error {
+    constructor(message: string);
+}
+/** One control tool: what the model sees, and how the round reads what comes back. */
+export interface ControlTool {
+    /** The tool's name, as declared to the model. */
+    readonly name: string;
+    /** The tool as the model sees it — no `execute`, by definition. */
+    readonly tool: Tool;
+    /**
+     * How this ending competes with another emitted in the same step. The highest
+     * precedence among the tools actually called wins, and the rest are dropped.
+     *
+     * It ranks by **commitment**: `delegate` starts durable work that a reply cannot
+     * undo, so a `delegate` alongside a `final_reply` means the reply is the
+     * acknowledgment *for* that work, not an answer instead of it. A future
+     * `escalate` slots in by saying how committal it is, and nothing else changes.
+     */
+    readonly precedence: number;
+    /**
+     * Pick the one call that counts out of **every** call the attempt made to this
+     * tool, or throw a {@link ControlCallError} if a repeat is itself the error.
+     *
+     * Separate from {@link ControlTool.parse} because what a repeat means is the
+     * tool's own business — a second `delegate` would start a second batch of durable
+     * work and is refused, while a repeated `final_reply` is just the model restating
+     * its answer and the last one stands — and the round needs that answer *before* it
+     * has a decision: the call it shows back to the model in a repair has to be the
+     * same one validation rejected, not whichever happened to come first.
+     *
+     * Never called with an empty array: a tool with no calls did not end the round.
+     */
+    select(inputs: readonly unknown[]): unknown;
+    /**
+     * Turn the selected call into the round's decision, or throw a
+     * {@link ControlCallError} describing what is wrong with it.
+     *
+     * The input is `unknown` on purpose. Nothing has checked it yet — that is this
+     * method's job, and typing it as anything else would be the assumption that
+     * caused the hole this interface exists to close.
+     */
+    parse(input: unknown): TurnDecision;
+}
+/**
+ * The control tools for one round, in the order the model is shown them.
+ *
+ * Built per round rather than defined once, because validating a `delegate` needs
+ * this round's reference catalog — the same values the model was shown as
+ * `[ref N]` markers, which is what makes "reference 4" checkable at all.
+ *
+ * `delegate` is withheld from a `final` round, which has no budget left to spend on
+ * work. `final_reply` is declared on every round including that one: withhold both
+ * and the round has no legal way to end.
+ */
+export declare function controlTools(opts: {
+    catalog: ReferenceCatalogEntry[];
+    /** Whether this round may still hand out work (`false` on a `final` round). */
+    delegable: boolean;
+    /** The installed subtask types — what `delegate` may name. */
+    types: SubtaskTypeRegistry;
+    /** `CoreConfig.maxSubtasks`, the per-round fan-out bound. */
+    maxSubtasks: number;
+}): ControlTool[];
+/** The tools as the SDK takes them, in declaration order. */
+export declare function controlToolSet(tools: ControlTool[]): ToolSet;
+//# sourceMappingURL=control.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"control.d.ts","sourceRoot":"","sources":["../../src/agent/control.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC;AAOxC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAMpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAGzD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,2EAA2E;AAC3E,MAAM,MAAM,YAAY,GACpB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,YAAY,EAAE,CAAA;CAAE,CAAC;AAEhE;;;;;;GAMG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;gBAC7B,OAAO,EAAE,MAAM;CAI5B;AAED,sFAAsF;AACtF,MAAM,WAAW,WAAW;IAC1B,iDAAiD;IACjD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,mEAAmE;IACnE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB;;;;;;;;OAQG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;;;;;;;;;;;;OAYG;IACH,MAAM,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,GAAG,OAAO,CAAC;IAC5C;;;;;;;OAOG;IACH,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,CAAC;CACrC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE;IACjC,OAAO,EAAE,qBAAqB,EAAE,CAAC;IACjC,+EAA+E;IAC/E,SAAS,EAAE,OAAO,CAAC;IACnB,8DAA8D;IAC9D,KAAK,EAAE,mBAAmB,CAAC;IAC3B,6DAA6D;IAC7D,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,WAAW,EAAE,CAqEhB;AAiCD,6DAA6D;AAC7D,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,EAAE,GAAG,OAAO,CAE5D"}

package/dist/agent/control.js

@@ -0,0 +1,115 @@
+import { FINAL_REPLY_TOOL_NAME, finalReplyInputSchema, finalReplyTool } from "./final-reply.js";
+import { makeDecompositionProposalSchema, resolveDecomposition } from "../subtasks/decomposition.js";
+import { DELEGATE_TOOL_NAME, makeDelegateTool } from "../subtasks/delegate.js";
+/**
+ * Thrown by a {@link ControlTool.parse} for a call the round cannot use.
+ *
+ * Its `message` is written for the **model**, not for a log: it is what comes back
+ * in the failed tool result, and it is the only thing the next attempt knows about
+ * why this one was rejected. Say what was wrong with the call.
+ */
+export class ControlCallError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ControlCallError";
+    }
+}
+/**
+ * The control tools for one round, in the order the model is shown them.
+ *
+ * Built per round rather than defined once, because validating a `delegate` needs
+ * this round's reference catalog — the same values the model was shown as
+ * `[ref N]` markers, which is what makes "reference 4" checkable at all.
+ *
+ * `delegate` is withheld from a `final` round, which has no budget left to spend on
+ * work. `final_reply` is declared on every round including that one: withhold both
+ * and the round has no legal way to end.
+ */
+export function controlTools(opts) {
+    const tools = [
+        {
+            name: FINAL_REPLY_TOOL_NAME,
+            tool: finalReplyTool,
+            precedence: 0,
+            // The last call of a repeated set: a model that restated its answer meant
+            // the restatement.
+            select: (inputs) => inputs.at(-1),
+            parse(input) {
+                const parsed = finalReplyInputSchema.safeParse(input);
+                if (!parsed.success) {
+                    throw new ControlCallError(`${FINAL_REPLY_TOOL_NAME} input is invalid — ${issues(parsed.error)}`);
+                }
+                return { kind: "reply", text: parsed.data.text.trim() };
+            }
+        }
+    ];
+    // A round with no registered types has nothing to delegate to, so `delegate`
+    // is withheld for the same reason a `final` round withholds it: the tool would
+    // advertise an empty enum the model has no legal way to satisfy.
+    if (opts.delegable && opts.types.keys.length > 0) {
+        const proposalSchema = makeDecompositionProposalSchema(opts.types, opts.maxSubtasks);
+        tools.push({
+            name: DELEGATE_TOOL_NAME,
+            tool: makeDelegateTool(opts.types, opts.maxSubtasks),
+            precedence: 1,
+            select(inputs) {
+                if (inputs.length > 1) {
+                    throw new ControlCallError(`${DELEGATE_TOOL_NAME} was called ${inputs.length} times in one turn. ` +
+                        `Delegate once, with every subtask this round needs in that single call.`);
+                }
+                return inputs[0];
+            },
+            parse(input) {
+                const parsed = proposalSchema.safeParse(input);
+                if (!parsed.success) {
+                    throw new ControlCallError(`${DELEGATE_TOOL_NAME} input is invalid — ${issues(parsed.error)}`);
+                }
+                // Everything past the schema — unknown reference indexes, dependency
+                // cycles, a type's required params — throws its own error, already worded
+                // for the model.
+                const { reply, drafts } = resolveDecomposition({
+                    ...parsed.data,
+                    subtasks: parsed.data.subtasks.map((s) => ({
+                        ...s,
+                        params: definedParams(s.params)
+                    }))
+                }, opts.catalog, opts.types);
+                return { kind: "delegate", reply, drafts };
+            }
+        });
+    }
+    return tools;
+}
+/**
+ * Drop params the model sent as an explicit `undefined`.
+ *
+ * The delegate schema declares the union of every type's param keys, all optional,
+ * so one tool schema can serve every type (see `subtaskParamProperties`). A model
+ * that names a key and leaves it empty has sent no param, and forwarding the key
+ * with an `undefined` value would only make a missing required param report itself
+ * as a *present* one. Whether what survives satisfies the type is still
+ * `validateSubtaskParams`'s call, downstream.
+ */
+function definedParams(params) {
+    if (!params)
+        return undefined;
+    const entries = Object.entries(params).filter(([, v]) => v !== undefined);
+    return entries.length > 0
+        ? Object.fromEntries(entries)
+        : undefined;
+}
+/**
+ * A zod failure as one line the model can act on: which field, and what was wrong.
+ * The same rendering {@link file://./subtasks/subtask-types.ts validateSubtaskParams}
+ * uses, so every rejection a control call can produce reads the same way.
+ */
+function issues(error) {
+    return error.issues
+        .map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`)
+        .join("; ");
+}
+/** The tools as the SDK takes them, in declaration order. */
+export function controlToolSet(tools) {
+    return Object.fromEntries(tools.map((c) => [c.name, c.tool]));
+}
+//# sourceMappingURL=control.js.map

package/dist/agent/control.js.map

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

package/dist/agent/final-reply.d.ts

@@ -0,0 +1,49 @@
+import { z } from "zod";
+/**
+ * The `final_reply` tool — the main agent answering the user itself, and the other
+ * way a round can end.
+ *
+ * A round used to end either by calling `delegate` or by stopping with plain text,
+ * and that asymmetry was the bug: to the code, "the model answered the user" and
+ * "the model narrated an action it never took" were the same outcome — a non-empty
+ * string. A model that wrote "I'll start the game" and emitted no call completed the
+ * Task successfully, having done nothing.
+ *
+ * So prose is no longer an outcome. Both endings are now named tools, the round runs
+ * with `toolChoice: "required"`, and a round that ends any other way has failed its
+ * attempt. The *choice* is still entirely the model's — the point of the design (see
+ * {@link file://./turn.ts turn.ts}) was never that the model be steered toward
+ * delegating, only that it not be forced. Picking between two named tools is also a
+ * far easier discrimination for a small model than picking between prose and a tool,
+ * which is what the weaker fallback models kept getting wrong.
+ *
+ * This lives outside `subtasks/` deliberately: replying is not a subtask concept.
+ */
+export declare const FINAL_REPLY_TOOL_NAME = "final_reply";
+/**
+ * The tool as the model sees it. **Without `execute`**, exactly like
+ * {@link file://./subtasks/delegate.ts delegateTool}: the call *is* the round's
+ * output, so there is nothing for the SDK to run and the loop halts on it.
+ *
+ * Unlike `delegate`, this call is never reconstructed in a later round's history —
+ * a past reply is stored as, and replayed as, ordinary assistant text (history is
+ * text-only by design). The tool exists to constrain *generation*, not to become a
+ * new shape in the transcript.
+ */
+/**
+ * The call's input, exported as the zod schema rather than only as the tool's
+ * `inputSchema`, because the round has to run it itself.
+ *
+ * A tool with no `execute` never has its input validated by the SDK — the loop
+ * halts on the call and nothing checks it. That is what let a blank `text` through
+ * to the user despite {@link nonBlank}. The round now parses every control call
+ * with the tool's own schema before using it (see
+ * {@link file://./control.ts control.ts}), and needs the schema in hand to do it.
+ */
+export declare const finalReplyInputSchema: z.ZodObject<{
+    text: z.ZodString;
+}, z.core.$strip>;
+export declare const finalReplyTool: import("ai").Tool<{
+    text: string;
+}, never, import("@ai-sdk/provider-utils").Context>;
+//# sourceMappingURL=final-reply.d.ts.map

package/dist/agent/final-reply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"final-reply.d.ts","sourceRoot":"","sources":["../../src/agent/final-reply.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,eAAO,MAAM,qBAAqB,gBAAgB,CAAC;AAEnD;;;;;;;;;GASG;AACH;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB;;iBAIhC,CAAC;AAEH,eAAO,MAAM,cAAc;;mDAIzB,CAAC"}

package/dist/agent/final-reply.js

@@ -0,0 +1,52 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { nonBlank } from "../subtasks/decomposition.js";
+/**
+ * The `final_reply` tool — the main agent answering the user itself, and the other
+ * way a round can end.
+ *
+ * A round used to end either by calling `delegate` or by stopping with plain text,
+ * and that asymmetry was the bug: to the code, "the model answered the user" and
+ * "the model narrated an action it never took" were the same outcome — a non-empty
+ * string. A model that wrote "I'll start the game" and emitted no call completed the
+ * Task successfully, having done nothing.
+ *
+ * So prose is no longer an outcome. Both endings are now named tools, the round runs
+ * with `toolChoice: "required"`, and a round that ends any other way has failed its
+ * attempt. The *choice* is still entirely the model's — the point of the design (see
+ * {@link file://./turn.ts turn.ts}) was never that the model be steered toward
+ * delegating, only that it not be forced. Picking between two named tools is also a
+ * far easier discrimination for a small model than picking between prose and a tool,
+ * which is what the weaker fallback models kept getting wrong.
+ *
+ * This lives outside `subtasks/` deliberately: replying is not a subtask concept.
+ */
+export const FINAL_REPLY_TOOL_NAME = "final_reply";
+/**
+ * The tool as the model sees it. **Without `execute`**, exactly like
+ * {@link file://./subtasks/delegate.ts delegateTool}: the call *is* the round's
+ * output, so there is nothing for the SDK to run and the loop halts on it.
+ *
+ * Unlike `delegate`, this call is never reconstructed in a later round's history —
+ * a past reply is stored as, and replayed as, ordinary assistant text (history is
+ * text-only by design). The tool exists to constrain *generation*, not to become a
+ * new shape in the transcript.
+ */
+/**
+ * The call's input, exported as the zod schema rather than only as the tool's
+ * `inputSchema`, because the round has to run it itself.
+ *
+ * A tool with no `execute` never has its input validated by the SDK — the loop
+ * halts on the call and nothing checks it. That is what let a blank `text` through
+ * to the user despite {@link nonBlank}. The round now parses every control call
+ * with the tool's own schema before using it (see
+ * {@link file://./control.ts control.ts}), and needs the schema in hand to do it.
+ */
+export const finalReplyInputSchema = z.object({
+    text: nonBlank("text").describe("Your reply, in your own voice. This is shown to the user verbatim, so it must be the complete answer and must not be blank.")
+});
+export const finalReplyTool = tool({
+    description: "Answer the user and end this round. Use this whenever the request is yours to answer — anything about this conversation, your own history, memory, or tools, and anything you can settle with the tools available to you here, including work that has already come back to you.",
+    inputSchema: finalReplyInputSchema
+});
+//# sourceMappingURL=final-reply.js.map

package/dist/agent/final-reply.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"final-reply.js","sourceRoot":"","sources":["../../src/agent/final-reply.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,IAAI,CAAC;AAC1B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAExD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,CAAC,MAAM,qBAAqB,GAAG,aAAa,CAAC;AAEnD;;;;;;;;;GASG;AACH;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5C,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,QAAQ,CAC7B,6HAA6H,CAC9H;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,cAAc,GAAG,IAAI,CAAC;IACjC,WAAW,EACT,kRAAkR;IACpR,WAAW,EAAE,qBAAqB;CACnC,CAAC,CAAC"}

package/dist/agent/history.d.ts

@@ -0,0 +1,83 @@
+import type { ModelMessage } from "ai";
+import type { SessionMessage } from "agents/experimental/memory/session";
+/**
+ * Session-history glue for the agent runtime: parse the gateway-authored `<turn>`
+ * provenance wrapper, and bridge between plain text and the Agents-SDK Sessions
+ * store. No A2A types cross this boundary — the {@link file://../a2a/inbound.ts
+ * A2A adapter} has already reduced the inbound message to a plain string.
+ *
+ * The gateway inlines a `<turn from="…" id="…" channel="…" at="…">…</turn>` tag
+ * into the message text in multi-actor channels so the model (and, in later
+ * phases, recall) can attribute "who said what". This agent only *parses* that
+ * wrapper — it never authors one.
+ *
+ * We persist only the user turn and the assistant's final text: intra-turn tool
+ * steps stay inside the single `generateText` call, so stored history is plain
+ * text messages and the conversion to AI-SDK `ModelMessage`s is trivial.
+ */
+/** The fields recovered from a gateway-rendered `<turn>` wrapper. */
+export interface ParsedTurn {
+    from: string;
+    /** Slack user id, as rendered. */
+    id: string;
+    channel: string;
+    /** ISO-8601 instant. */
+    at: string;
+    /** The raw inner body. */
+    body: string;
+}
+/**
+ * Recover the structured provenance from a gateway-authored turn. Returns null
+ * for any text that isn't a `<turn>` wrapper (plain messages, assistant replies),
+ * so callers can treat the provenance as optional.
+ */
+export declare function parseTurn(text: string): ParsedTurn | null;
+/**
+ * Deterministic Session-message ids for the task round loop.
+ *
+ * A round runs inside a durable Workflow step that can re-run after a crash, so
+ * its Session appends must be exactly-once. `Session.appendMessage` already
+ * dedupes on message id (an id that exists is not re-written), so deriving the id
+ * from the task id + round makes the append idempotent for free — no
+ * read-then-write race, no duplicate turns in history on replay. Pair with
+ * {@link file://./session.ts appendOnce}, which reads the durable text back so a
+ * retry that re-inferred still returns the *stored* reply.
+ *
+ * These ids share the Session id-space with random UUIDs (plain turns) and the
+ * SDK's `compaction_`-prefixed summaries; the `task:` prefix cannot collide with
+ * either.
+ */
+/** Id of the inbound user turn for a task (appended once, by round 0). */
+export declare function taskUserMessageId(taskId: string): string;
+/**
+ * Id of the acknowledgment a **delegating** round publishes — the message the
+ * user sees while that round's Subtasks run. Also the anchor a later round finds
+ * to reattach the round's `delegate` call to (see
+ * {@link file://./turn.ts renderTurnMessages}), which is why it is derived from
+ * the round rather than stored.
+ */
+export declare function roundAckMessageId(taskId: string, round: number): string;
+/**
+ * Recognize an acknowledgment id — **any** Task's, not just the one being
+ * rendered. A Session outlives the Task that wrote it and is shared by every Task
+ * from the same caller, so its history accumulates acks the current render has no
+ * branches for: earlier Tasks' acks, and (in the window between a round's ack
+ * append and its Subtask rows) this Task's own. Both are the agent's scaffolding
+ * rather than conversation, so both must stay out of the reference catalog; the
+ * `branches`-derived anchor map alone cannot see either.
+ *
+ * Returns the parsed Task id and round so the caller can tell whose ack it is.
+ */
+export declare function parseRoundAckMessageId(id: string): {
+    taskId: string;
+    round: number;
+} | null;
+/** Id of the terminal reply — the round in which the agent answered the user. */
+export declare function finalReplyMessageId(taskId: string): string;
+/** A Sessions-store message with a caller-chosen (deterministic) id. */
+export declare function deterministicSessionMessage(id: string, role: "user" | "assistant", text: string): SessionMessage;
+/** Concatenate the text parts of a stored session message. */
+export declare function sessionText(m: SessionMessage): string;
+/** Convert stored history to AI-SDK model messages (user/assistant text only). */
+export declare function toModelMessages(history: SessionMessage[]): ModelMessage[];
+//# sourceMappingURL=history.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"history.d.ts","sourceRoot":"","sources":["../../src/agent/history.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,IAAI,CAAC;AACvC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oCAAoC,CAAC;AAEzE;;;;;;;;;;;;;;GAcG;AAEH,qEAAqE;AACrE,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,kCAAkC;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,wBAAwB;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAC;CACd;AAyBD;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI,CAYzD;AAED;;;;;;;;;;;;;;GAcG;AAEH,0EAA0E;AAC1E,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAEvE;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,MAAM,GACT;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAG1C;AAED,iFAAiF;AACjF,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED,wEAAwE;AACxE,wBAAgB,2BAA2B,CACzC,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,MAAM,GAAG,WAAW,EAC1B,IAAI,EAAE,MAAM,GACX,cAAc,CAOhB;AAED,8DAA8D;AAC9D,wBAAgB,WAAW,CAAC,CAAC,EAAE,cAAc,GAAG,MAAM,CAKrD;AAED,kFAAkF;AAClF,wBAAgB,eAAe,CAAC,OAAO,EAAE,cAAc,EAAE,GAAG,YAAY,EAAE,CAOzE"}

package/dist/agent/history.js

@@ -0,0 +1,117 @@
+const TURN_TAG_RE = /^<turn\b([^>]*)>([\s\S]*)<\/turn>$/;
+const ATTR_RE = /(\w+)="([^"]*)"/g;
+function parseAttrs(raw) {
+    const out = {};
+    let m;
+    ATTR_RE.lastIndex = 0;
+    while ((m = ATTR_RE.exec(raw)) !== null)
+        out[m[1]] = m[2];
+    return out;
+}
+const ATTR_UNESCAPES = {
+    amp: "&",
+    lt: "<",
+    gt: ">",
+    quot: '"'
+};
+/** Reverse the gateway's attribute escaping — single pass so `&amp;` round-trips. */
+function unescAttr(value) {
+    return value.replace(/&(amp|lt|gt|quot);/g, (_, e) => ATTR_UNESCAPES[e]);
+}
+/**
+ * Recover the structured provenance from a gateway-authored turn. Returns null
+ * for any text that isn't a `<turn>` wrapper (plain messages, assistant replies),
+ * so callers can treat the provenance as optional.
+ */
+export function parseTurn(text) {
+    const m = TURN_TAG_RE.exec(text);
+    if (!m)
+        return null;
+    const attrs = parseAttrs(m[1]);
+    if (!attrs.from || !attrs.id || !attrs.channel || !attrs.at)
+        return null;
+    return {
+        from: unescAttr(attrs.from),
+        id: unescAttr(attrs.id),
+        channel: unescAttr(attrs.channel),
+        at: unescAttr(attrs.at),
+        body: m[2]
+    };
+}
+/**
+ * Deterministic Session-message ids for the task round loop.
+ *
+ * A round runs inside a durable Workflow step that can re-run after a crash, so
+ * its Session appends must be exactly-once. `Session.appendMessage` already
+ * dedupes on message id (an id that exists is not re-written), so deriving the id
+ * from the task id + round makes the append idempotent for free — no
+ * read-then-write race, no duplicate turns in history on replay. Pair with
+ * {@link file://./session.ts appendOnce}, which reads the durable text back so a
+ * retry that re-inferred still returns the *stored* reply.
+ *
+ * These ids share the Session id-space with random UUIDs (plain turns) and the
+ * SDK's `compaction_`-prefixed summaries; the `task:` prefix cannot collide with
+ * either.
+ */
+/** Id of the inbound user turn for a task (appended once, by round 0). */
+export function taskUserMessageId(taskId) {
+    return `task:${taskId}:user`;
+}
+/**
+ * Id of the acknowledgment a **delegating** round publishes — the message the
+ * user sees while that round's Subtasks run. Also the anchor a later round finds
+ * to reattach the round's `delegate` call to (see
+ * {@link file://./turn.ts renderTurnMessages}), which is why it is derived from
+ * the round rather than stored.
+ */
+export function roundAckMessageId(taskId, round) {
+    return `task:${taskId}:round:${round}:ack`;
+}
+/** Matches {@link roundAckMessageId}; the trailing suffix is fixed, so the greedy
+ * task-id group cannot swallow it. */
+const ROUND_ACK_ID = /^task:(.+):round:(\d+):ack$/;
+/**
+ * Recognize an acknowledgment id — **any** Task's, not just the one being
+ * rendered. A Session outlives the Task that wrote it and is shared by every Task
+ * from the same caller, so its history accumulates acks the current render has no
+ * branches for: earlier Tasks' acks, and (in the window between a round's ack
+ * append and its Subtask rows) this Task's own. Both are the agent's scaffolding
+ * rather than conversation, so both must stay out of the reference catalog; the
+ * `branches`-derived anchor map alone cannot see either.
+ *
+ * Returns the parsed Task id and round so the caller can tell whose ack it is.
+ */
+export function parseRoundAckMessageId(id) {
+    const match = ROUND_ACK_ID.exec(id);
+    return match ? { taskId: match[1], round: Number(match[2]) } : null;
+}
+/** Id of the terminal reply — the round in which the agent answered the user. */
+export function finalReplyMessageId(taskId) {
+    return `task:${taskId}:reply:final`;
+}
+/** A Sessions-store message with a caller-chosen (deterministic) id. */
+export function deterministicSessionMessage(id, role, text) {
+    return {
+        id,
+        role,
+        createdAt: new Date(),
+        parts: [{ type: "text", text }]
+    };
+}
+/** Concatenate the text parts of a stored session message. */
+export function sessionText(m) {
+    return m.parts
+        .filter((p) => p.type === "text" && typeof p.text === "string")
+        .map((p) => p.text)
+        .join("");
+}
+/** Convert stored history to AI-SDK model messages (user/assistant text only). */
+export function toModelMessages(history) {
+    return history
+        .filter((m) => m.role === "user" || m.role === "assistant")
+        .map((m) => ({
+        role: m.role,
+        content: sessionText(m)
+    }));
+}
+//# sourceMappingURL=history.js.map

package/dist/agent/history.js.map

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

package/dist/agent/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * `@loopingai/core/agent` — the primitives a loop is built from.
+ *
+ * Core ships no loop. `turn.ts` / `loop.ts` are the agent's, because how a round
+ * ends is the one thing every agent genuinely differs on. What core owns is
+ * everything both predecessor loops needed identically: the session, the model
+ * pair with its fallback, the budget, and the control-tool abstraction that
+ * turns "the model called something that ends the round" into a checked value.
+ */
+export { newTurnBudget, stepAllowance, type TurnBudget } from "./budget.js";
+export { createModelRuntime, type Embed, type GatewayMetadata, type ModelOverrides, type ModelPair, type ModelRuntime, type ModelRuntimeDeps } from "./model.js";
+export { appendOnce, archivingCompaction, buildAgentSession, type AgentSessionOptions, type SessionHost, type SessionLike } from "./session.js";
+export { deterministicSessionMessage, finalReplyMessageId, parseRoundAckMessageId, parseTurn, roundAckMessageId, sessionText, taskUserMessageId, toModelMessages, type ParsedTurn } from "./history.js";
+export { buildIntermediateContentHandler, isTransientAiError, type OnContent } from "./inference.js";
+export { ControlCallError, controlTools, controlToolSet, type ControlTool, type TurnDecision } from "./control.js";
+export { FINAL_REPLY_TOOL_NAME, finalReplyInputSchema, finalReplyTool } from "./final-reply.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/agent/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,KAAK,UAAU,EAAE,MAAM,aAAa,CAAC;AAE5E,OAAO,EACL,kBAAkB,EAClB,KAAK,KAAK,EACV,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACtB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,UAAU,EACV,mBAAmB,EACnB,iBAAiB,EACjB,KAAK,mBAAmB,EACxB,KAAK,WAAW,EAChB,KAAK,WAAW,EACjB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,2BAA2B,EAC3B,mBAAmB,EACnB,sBAAsB,EACtB,SAAS,EACT,iBAAiB,EACjB,WAAW,EACX,iBAAiB,EACjB,eAAe,EACf,KAAK,UAAU,EAChB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,+BAA+B,EAC/B,kBAAkB,EAClB,KAAK,SAAS,EACf,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,cAAc,EACd,KAAK,WAAW,EAChB,KAAK,YAAY,EAClB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,cAAc,EACf,MAAM,kBAAkB,CAAC"}

package/dist/agent/index.js

@@ -0,0 +1,17 @@
+/**
+ * `@loopingai/core/agent` — the primitives a loop is built from.
+ *
+ * Core ships no loop. `turn.ts` / `loop.ts` are the agent's, because how a round
+ * ends is the one thing every agent genuinely differs on. What core owns is
+ * everything both predecessor loops needed identically: the session, the model
+ * pair with its fallback, the budget, and the control-tool abstraction that
+ * turns "the model called something that ends the round" into a checked value.
+ */
+export { newTurnBudget, stepAllowance } from "./budget.js";
+export { createModelRuntime } from "./model.js";
+export { appendOnce, archivingCompaction, buildAgentSession } from "./session.js";
+export { deterministicSessionMessage, finalReplyMessageId, parseRoundAckMessageId, parseTurn, roundAckMessageId, sessionText, taskUserMessageId, toModelMessages } from "./history.js";
+export { buildIntermediateContentHandler, isTransientAiError } from "./inference.js";
+export { ControlCallError, controlTools, controlToolSet } from "./control.js";
+export { FINAL_REPLY_TOOL_NAME, finalReplyInputSchema, finalReplyTool } from "./final-reply.js";
+//# sourceMappingURL=index.js.map

package/dist/agent/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/agent/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,aAAa,EAAE,aAAa,EAAmB,MAAM,aAAa,CAAC;AAE5E,OAAO,EACL,kBAAkB,EAOnB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,UAAU,EACV,mBAAmB,EACnB,iBAAiB,EAIlB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,2BAA2B,EAC3B,mBAAmB,EACnB,sBAAsB,EACtB,SAAS,EACT,iBAAiB,EACjB,WAAW,EACX,iBAAiB,EACjB,eAAe,EAEhB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,+BAA+B,EAC/B,kBAAkB,EAEnB,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,gBAAgB,EAChB,YAAY,EACZ,cAAc,EAGf,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,qBAAqB,EACrB,qBAAqB,EACrB,cAAc,EACf,MAAM,kBAAkB,CAAC"}