@adonis-agora/agent 0.30.2 → 0.33.0

package/dist/src/agent-loop.d.ts

@@ -1,7 +1,12 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import { type AgentIntake, type ElicitationRequest, type HumanReply } from './elicitation.js';
+import { type MemoryConfig } from './memory.js';
+import { type SkillsConfig } from './skills.js';
 import type { AgentStore } from './spi/agent-store.js';
 import type { HistoryWindow } from './spi/history-window.js';
 import type { ModelProvider } from './spi/model-provider.js';
 import { type AgentPricingStore } from './spi/pricing-store.js';
+import { type InputProcessor, type OutputProcessor } from './spi/processors.js';
 import type { QuotaStore } from './spi/quota-store.js';
 import type { Retriever } from './spi/retriever.js';
 import type { RolesPolicy } from './spi/roles-policy.js';
@@ -9,8 +14,8 @@ import type { SinkWriter } from './spi/token-stream-sink.js';
 import type { AiToolCtx } from './spi/tool.js';
 import { type ToolRegistry } from './tool-registry.js';
 import { type ToolTransientRetrySetting } from './tool-retry.js';
-import type { Actor, AgentRunInput, Decision, PromptBuilder, ToolCallRequest } from './types.js';
-export interface AgentLoopDeps {
+import type { Actor, AgentRunInput, Decision, PromptBuilder, ToolCallRequest, ToolDefinition } from './types.js';
+export interface AgentLoopDeps<TOutput = unknown> {
     model: ModelProvider;
     store: AgentStore;
     registry: ToolRegistry;
@@ -37,6 +42,19 @@ export interface AgentLoopDeps {
     host?: unknown;
     /** Agent-level tool allow-list (intersected with the persona's). Undefined → all tools. */
     toolAllowList?: string[];
+    /**
+     * How many agent→agent delegations deep a chain may go. Defaults to {@link MAX_DELEGATION_DEPTH}.
+     *
+     * The backstop for a chain that is merely LONG; a chain going in circles is caught by
+     * {@link maxAgentAppearances} instead, and named as such.
+     */
+    maxDelegationDepth?: number;
+    /**
+     * How many times one agent may appear on a single delegation chain. Defaults to
+     * {@link DEFAULT_MAX_AGENT_APPEARANCES}. It counts APPEARANCES, so 2 admits exactly one
+     * deliberate return to an earlier agent.
+     */
+    maxAgentAppearances?: number;
     /**
      * Enables always-on ("inject") RAG: before the turn, retrieve passages for the user message and fold
      * them into the system prompt. Its presence IS inject mode (a retriever wired as a `read` tool for
@@ -66,13 +84,138 @@ export interface AgentLoopDeps {
      */
     toolTransientRetry?: ToolTransientRetrySetting;
     /**
-     * Compacts the persisted thread history into what actually rides the model call each turn.
-     * Applied once per run, inside `hooks.step` (so durable replay reuses the SAME windowed result —
-     * required for a summarizing impl that spends its own tokens). Undefined → the full thread history
-     * is sent every turn, unchanged from before this option existed.
+     * Bounds how much of the persisted thread rides into the model call each turn. Undefined → the
+     * WHOLE thread, every message the store holds, which is unbounded: a long-lived thread eventually
+     * exceeds the provider's context limit, and pays for the full transcript on every turn until it
+     * does. Applied once per run. See {@link SlidingWindowHistory} for the built-in.
      */
     historyWindow?: HistoryWindow;
+    /**
+     * Rewrites `{ system, messages }` before EVERY model call of the turn — masking identifiers,
+     * stamping a policy preamble, collapsing an oversized tool result. Every step, not once per run,
+     * because the transcript grows between steps. Adds one `process:input:<step>` checkpoint per step;
+     * empty/undefined adds none, so a deployment with no processors records byte-identical
+     * checkpoints.
+     *
+     * Not a second {@link HistoryWindow}: that owns WHICH messages ride into the turn (pure, outside
+     * any checkpoint), this owns what they SAY (may call a model, journaled). The loop's canonical
+     * `modelMessages` is untouched — a redaction is what leaves the process, never the thread's own
+     * memory of what was said.
+     */
+    inputProcessors?: InputProcessor[];
+    /**
+     * Rules on each step's answer before anything downstream sees it, and may redact or refuse it.
+     * Adds one `process:output:<step>` checkpoint per step.
+     *
+     * **Registering any of these takes the turn's model call off the run's live sink**, because a gate
+     * that must read the answer cannot run after the answer has reached the reader. What that costs is
+     * proportional to what the chain declares: a chain whose every member declares
+     * {@link import('./spi/processors.js').OutputProcessor.incremental} keeps streaming a
+     * lookback-bounded prefix; one undeclared member holds the whole answer and releases it as a
+     * single `text` frame once the chain has passed.
+     */
+    outputProcessors?: OutputProcessor[];
+    /**
+     * Constrain the turn's answer to a schema — any [Standard Schema](https://standardschema.dev) —
+     * returned validated as `object` on the loop's result and recorded on the assistant message as a
+     * synthetic auto-executed `structured_output` tool call, the same device inject-mode retrieval
+     * uses, so no store gains a column for it.
+     *
+     * HOW IT COMPOSES WITH TOOL CALLING: as a separate formatting pass, ALWAYS. The turn runs its
+     * model→tools iteration exactly as it would without a schema; once a step comes back with no tool
+     * calls, one extra non-streamed call (`structured:<step>:<attempt>`, `tools: []`, `outputSchema`
+     * set) restates that answer as the schema. Most providers cannot serve a response format and a
+     * tool set in one request, and skipping the pass for an agent that happens to have no tools would
+     * make the checkpoint sequence depend on a tool-registry lookup — the registry of whichever
+     * process is replaying — which is exactly how a run ends up asking for a position its history has
+     * no room for. So the pass is unconditional, and it costs one model call per turn, billed as its
+     * own `structured_output` usage row.
+     */
+    outputSchema?: StandardSchemaV1<unknown, TOutput>;
+    /** Overrides the formatting pass's system prompt. Undefined → {@link DEFAULT_STRUCTURED_OUTPUT_INSTRUCTION}. */
+    outputInstruction?: string;
+    /**
+     * How many extra model calls may try to fix an answer that failed `outputSchema`, each shown the
+     * previous attempt's validation issues. Undefined → 1; `0` → fail on the first invalid reply.
+     * Bounded because a model that cannot satisfy a schema usually cannot satisfy it on the fourth try
+     * either, and every attempt is billed.
+     */
+    outputRepairAttempts?: number;
+    /**
+     * Show the formatting pass the turn's whole transcript instead of just the question and the
+     * answer. For an agent whose answer cannot be restated from its own words — one that reports on
+     * rows a tool returned and names only their total in the prose, say.
+     *
+     * OFF by default because the pass is a translation, and a translation needs the thing being
+     * translated. The transcript it would otherwise carry is the turn's entire prompt a second time,
+     * at no discount: the pass swaps the system block for the schema instruction, and the system block
+     * is the prompt cache's prefix, so nothing of the first call's cache survives into it.
+     */
+    outputFromTranscript?: boolean;
+    /**
+     * A question set the agent puts to the user BEFORE it starts working — collecting the scope, as
+     * against `awaitApproval`, which sanctions work already proposed. The questions are AUTHORED, so
+     * the turn spends no model call producing them and a client knows the total ("Question 1 of 3")
+     * the moment the form appears.
+     *
+     * The turn parks on the answers exactly as it parks on an approval, and the request persists as
+     * the same tool-call row the model's `ask` writes — see {@link AgentLoopDeps.ask}. Undefined → no
+     * intake, and a turn's checkpoint sequence is byte-identical to one that never had the option.
+     */
+    intake?: AgentIntake;
+    /**
+     * Offer the model the built-in `ask` tool, so it can put its own question set to the user when it
+     * judges the scope is missing — the same surface as {@link AgentLoopDeps.intake}, minus the "known
+     * in advance".
+     *
+     * `ask` is NOT a registered tool: it has no handler (the loop settles it against a human), and
+     * keeping it out of the `ToolRegistry` is what keeps its kind out of a process-local lookup. The
+     * loop appends its definition to the turn's tool list from THIS flag, which is module config and
+     * therefore uniform across a deployment. Undefined/false → the model never sees it.
+     */
+    ask?: boolean;
+    /**
+     * Authored procedures the model can pull in mid-turn, scoped to the actor's own scope tokens — see
+     * `skills.ts`. Undefined → no catalog block, no `skill` tool, and a turn's checkpoint sequence is
+     * byte-identical to one that never had the option.
+     *
+     * WHAT IT COSTS THE PROMPT. Four things write the system block — the agent's own prompt, the
+     * persona's, injected retrieval, and this — and the catalog is the cheapest of them by
+     * construction: one line per skill, carrying a name, a scope and a description. A skill's BODY
+     * never enters the system block at all; it arrives as a tool result, on the transcript, where
+     * {@link AgentLoopDeps.historyWindow} already governs it. So a deployment with fifty skills pays
+     * for fifty lines and for whichever bodies a turn actually asked to read.
+     */
+    skills?: SkillsConfig;
+    /**
+     * What the assistant has concluded about this actor and their organisation, carried into every
+     * turn against the same scope tokens skills use — see `memory.ts`. Undefined → no memory block, no
+     * `remember` tool, and a turn's checkpoint sequence is byte-identical to one that never had the
+     * option.
+     *
+     * WHY IT IS IN THE SYSTEM BLOCK AT ALL, when a skill's body deliberately is not. A body is read
+     * when the model decides a task needs it; a memory is worthless unless it is already in front of
+     * the model on the turn nobody thought to look for it. That is the whole capability, and it costs
+     * one line per memory, bounded by `maxMemories` here and by `maxFactChars` at write time.
+     */
+    memory?: MemoryConfig;
 }
+/** One task's outcome under {@link AgentLoopHooks.parallel}, reported instead of thrown. */
+export type SettledTask<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: unknown;
+};
+/**
+ * The {@link AgentLoopHooks.parallel} implementation for a runner whose checkpoint positions are
+ * handed out on the CALL — `@adonis-agora/durable`'s `ctx.localStep` is: it takes `pos.next()`
+ * before its first `await`. Every task is invoked here, synchronously and in list order, before any
+ * of them is awaited, which is what fixes the block of positions they occupy whatever order they
+ * then settle in. Nothing rejects: the caller decides what an individual failure means.
+ */
+export declare function settleAll<T>(tasks: readonly (() => Promise<T>)[]): Promise<SettledTask<T>[]>;
 export interface AgentLoopHooks {
     runId: string;
     /**
@@ -84,6 +227,21 @@ export interface AgentLoopHooks {
     openSink(): SinkWriter | Promise<SinkWriter>;
     /** HITL gate for an action tool. Inline resolves a pending promise; durable awaits a signal. */
     awaitApproval(call: ToolCallRequest, ctx: AiToolCtx): Promise<Decision>;
+    /**
+     * The wait an elicitation parks on. Both shipped runners map it to the SAME channel an approval
+     * uses — `tool:<runId>:<callId>` — so an answer and an approval reach a parked run by one path.
+     *
+     * Optional, and its absence changes no checkpoint: the loop falls back to `awaitApproval` and
+     * reads the decision as "the user confirmed the pre-picked answers" (approved) or "the user
+     * skipped" (rejected). That is the honest reduction of a yes/no channel, and it means a host that
+     * only ever implemented approval still runs an elicitation to completion instead of hanging.
+     *
+     * Declared as {@link HumanReply} rather than `ElicitationReply` because that is what the channel
+     * really carries: a question set is parked as a `pending_approval` action, so a `Decision` can
+     * arrive on this wait from the approvals inbox even where the host implements it. The loop reduces
+     * one to the other, so an implementer never has to.
+     */
+    awaitAnswers?(request: ElicitationRequest, ctx: AiToolCtx): Promise<HumanReply>;
     /**
      * Run another named agent and return its answer. Provided only when the host wired multi-agent
      * support (durable → child workflow, inline → nested loop). Exposed to tools as `ctx.runAgent`.
@@ -103,16 +261,75 @@ export interface AgentLoopHooks {
      * runner; the inline runner has no such notion and leaves it unset.
      */
     isControlFlowError?(error: unknown): boolean;
+    /**
+     * Run `tasks` concurrently, resolving once EVERY one has settled — one outcome per task, in INPUT
+     * order, never rejecting. Supplying it is a statement about the runner's checkpointing: each task
+     * MUST be invoked synchronously, in list order, before any is awaited, so a runner that hands out
+     * positions on the call assigns them in that order regardless of which task finishes first.
+     * {@link settleAll} is exactly that, and is what both bundled runners pass.
+     *
+     * Waiting for ALL of them is the other half of the contract. A durable runner unwinds a turn by
+     * THROWING, and a sibling abandoned part-way through its own step is a tool nobody ever runs.
+     *
+     * Absent → the loop runs a turn's tool calls one at a time, which is the honest answer for a
+     * runner whose positions are assigned anywhere other than the call.
+     */
+    parallel?<T>(tasks: readonly (() => Promise<T>)[]): Promise<SettledTask<T>[]>;
+    /**
+     * Does this run take the loop shape guarded by `id`? A runner replaying against recorded
+     * checkpoints answers `false` for a run that started before the shape changed, so that run keeps
+     * replaying the shape its history holds (`@adonis-agora/durable`'s `ctx.patched`, which consumes a
+     * position for a new run and gives it back to an old one). Absent → `true`: a runner that records
+     * no positions has no older shape to preserve.
+     */
+    patched?(id: string): Promise<boolean>;
 }
 export declare class QuotaExceededError extends Error {
     constructor();
 }
+/**
+ * How many agent→agent delegations deep a chain may go when the host names no ceiling.
+ *
+ * A backstop for a chain that is merely LONG. The cycle it would otherwise stand in for is detected
+ * directly — see {@link DEFAULT_MAX_AGENT_APPEARANCES}.
+ *
+ * WHEN IT ACTUALLY BINDS. At one appearance per agent a chain cannot be longer than the number of
+ * registered agents, so a deployment with fewer agents than this number never reaches it: the cycle
+ * guard always fires first. It starts mattering with a larger fleet than the ceiling, or once a host
+ * raises {@link AgentLoopDeps.maxAgentAppearances}, which is what lets a chain revisit an agent and
+ * therefore grow past the fleet's size.
+ */
+export declare const MAX_DELEGATION_DEPTH = 5;
+/**
+ * How many times one agent may appear on a single delegation chain, when the host names no other
+ * number. Once: a chain that reaches an agent it has already passed through is going in circles.
+ *
+ * Override with {@link AgentLoopDeps.maxAgentAppearances} — a supervisor that genuinely hands work
+ * back to an earlier agent needs a larger number, and it is the count of APPEARANCES, so 2 admits
+ * exactly one return.
+ */
+export declare const DEFAULT_MAX_AGENT_APPEARANCES = 1;
+/**
+ * The turn's tool list plus the built-ins the module offers — `ask`, `skill`. Appended from CONFIG
+ * rather than the registry, because neither is ever registered: see {@link AgentLoopDeps.ask} and
+ * {@link AgentLoopDeps.skills}.
+ */
+export declare function withBuiltInTools(args: {
+    tools: ToolDefinition[];
+    ask: boolean | undefined;
+    skills: boolean;
+    memory: boolean;
+}): ToolDefinition[];
+/** What a turn answered with: the assistant text, plus the validated `outputSchema` value if any. */
+export interface AgentLoopResult<TOutput = unknown> {
+    text: string;
+    /** Present only when {@link AgentLoopDeps.outputSchema} was set — the validated structured answer. */
+    object?: TOutput;
+}
 /**
  * The provider-agnostic agent turn, reused by both the inline and durable runners.
  * It drives the model→tools→model iteration; the runner supplies the `step`/`awaitApproval`
  * hooks that make the same loop body either in-process or a replay-safe durable workflow.
  */
-export declare function runAgentLoop(deps: AgentLoopDeps, input: AgentRunInput, hooks: AgentLoopHooks): Promise<{
-    text: string;
-}>;
+export declare function runAgentLoop<TOutput = unknown>(deps: AgentLoopDeps<TOutput>, input: AgentRunInput, hooks: AgentLoopHooks): Promise<AgentLoopResult<TOutput>>;
 //# sourceMappingURL=agent-loop.d.ts.map

package/dist/src/agent-loop.d.ts.map

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