@noetic-tools/core 0.0.1

package/dist/types/shell-adapter.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Prefix used by ShellAdapter implementations to signal a timeout-induced
+ * kill via the Error.message channel. Format: `${TIMEOUT_ERROR_PREFIX}${seconds}`.
+ * Callers parse the seconds back out of `error.message`.
+ *
+ * @public
+ */
+export declare const TIMEOUT_ERROR_PREFIX = "timeout:";
+/** @public Options for a single shell command execution. */
+export interface ShellExecOptions {
+    /** Working directory for the command. */
+    cwd: string;
+    /** Environment variables (merged with process defaults for local, used directly for emulated). */
+    env?: Record<string, string>;
+    /** Timeout in seconds. */
+    timeout?: number;
+    /** Standard input to pipe into the command. */
+    stdin?: string;
+    /** Abort signal for cancellation support. */
+    signal?: AbortSignal;
+    /** Streaming callback invoked as output data arrives. */
+    onData?: (data: Buffer) => void;
+}
+/** @public Result of a shell command execution. */
+export interface ShellExecResult {
+    stdout: string;
+    stderr: string;
+    exitCode: number | null;
+}
+/** @public Shell execution abstraction for agent runtime operations. */
+export interface ShellAdapter {
+    /** Execute a shell command string and return its result. */
+    exec(command: string, options: ShellExecOptions): Promise<ShellExecResult>;
+}

package/dist/types/shell-adapter.js

@@ -0,0 +1,10 @@
+//#region Constants
+/**
+ * Prefix used by ShellAdapter implementations to signal a timeout-induced
+ * kill via the Error.message channel. Format: `${TIMEOUT_ERROR_PREFIX}${seconds}`.
+ * Callers parse the seconds back out of `error.message`.
+ *
+ * @public
+ */
+export const TIMEOUT_ERROR_PREFIX = 'timeout:';
+//#endregion

package/dist/types/steering.d.ts

@@ -0,0 +1,89 @@
+import type { LLMResponse } from './common';
+import type { ExecutionContext, MemoryScope } from './memory';
+/** @public Enumeration of actions a steering rule can take on a tool call or model response. */
+export declare const SteeringAction: {
+    Allow: string;
+    Deny: string;
+    Guide: string;
+};
+export type SteeringAction = (typeof SteeringAction)[keyof typeof SteeringAction];
+/** @public Discriminator for ledger entry types recorded during steering evaluation. */
+export declare const LedgerEntryKind: {
+    ToolCall: string;
+    ModelTurn: string;
+    Custom: string;
+};
+export type LedgerEntryKind = (typeof LedgerEntryKind)[keyof typeof LedgerEntryKind];
+/** @public Result of evaluating steering rules: an action and optional guidance message. */
+export interface SteeringDecision {
+    action: SteeringAction;
+    guidance?: string;
+}
+/** @public A single entry in the steering ledger, recording a tool call, model turn, or custom event. */
+export interface LedgerEntry {
+    kind: LedgerEntryKind;
+    timestamp: number;
+    toolName?: string;
+    toolArgs?: unknown;
+    success?: boolean;
+    durationMs?: number;
+    model?: string;
+    tokenUsage?: {
+        input: number;
+        output: number;
+    };
+    custom?: Record<string, unknown>;
+    ruleId?: string;
+    action?: SteeringAction;
+    guidance?: string;
+}
+/** @public Parameters passed to a steering rule's `beforeToolCall` evaluation. */
+export interface BeforeToolCallParams<TState = unknown> {
+    toolName: string;
+    toolArgs: unknown;
+    ctx: ExecutionContext;
+    state: TState;
+}
+/** @public Value returned by a `beforeToolCall` steering hook with a decision and optional state update. */
+export interface BeforeToolCallResult<TState = unknown> {
+    decision: SteeringDecision;
+    state?: TState;
+}
+/** @public Parameters passed to a steering rule's `afterModelCall` evaluation. */
+export interface AfterModelCallParams<TState = unknown> {
+    response: LLMResponse;
+    ctx: ExecutionContext;
+    state: TState;
+}
+/** @public Value returned by an `afterModelCall` steering hook with a decision and optional state update. */
+export interface AfterModelCallResult<TState = unknown> {
+    decision: SteeringDecision;
+    state?: TState;
+}
+/** @public A named rule evaluated by the steering layer before tool calls or after model responses. */
+export interface SteeringRule {
+    id: string;
+    name?: string;
+    appliesTo: ('beforeToolCall' | 'afterModelCall')[];
+    predicate?: (params: BeforeToolCallParams | AfterModelCallParams) => SteeringDecision;
+    llmEval?: {
+        mode: 'sync' | 'async';
+        prompt: string;
+        model?: string;
+    };
+}
+/** @public Top-level configuration for the steering subsystem, including rules and limits. */
+export interface SteeringConfig {
+    rules: SteeringRule[];
+    maxLedgerEntries?: number;
+    maxRetries?: number;
+    scope?: MemoryScope;
+}
+/** @public Mutable runtime state maintained by the steering layer across an execution. */
+export interface SteeringState {
+    ledger: LedgerEntry[];
+    pendingAsync: Array<{
+        ruleId: string;
+        guidance: string;
+    }>;
+}

package/dist/types/steering.js

@@ -0,0 +1,14 @@
+//#region Enums
+/** @public Enumeration of actions a steering rule can take on a tool call or model response. */
+export const SteeringAction = {
+    Allow: 'allow',
+    Deny: 'deny',
+    Guide: 'guide',
+};
+/** @public Discriminator for ledger entry types recorded during steering evaluation. */
+export const LedgerEntryKind = {
+    ToolCall: 'tool_call',
+    ModelTurn: 'model_turn',
+    Custom: 'custom',
+};
+//#endregion

package/dist/types/step.d.ts

@@ -0,0 +1,206 @@
+import type { ZodType } from 'zod';
+import type { Channel } from './channel';
+import type { ModelParams, RetryPolicy, StepMeta, Tool } from './common';
+import type { Context } from './context';
+import type { NoeticError } from './error';
+import type { ContextMemory, MemoryConfig, MemoryLayer } from './memory';
+/**
+ * Cumulative execution snapshot passed to loop `until` predicates.
+ * @public
+ */
+export interface Snapshot {
+    /** Number of loop iterations completed so far. */
+    stepCount: number;
+    /** Aggregate token usage across all iterations. */
+    tokens: {
+        input: number;
+        output: number;
+        total: number;
+    };
+    /** Wall-clock time in ms since the loop started. */
+    elapsed: number;
+    /** Cumulative cost across all iterations. */
+    cost: number;
+    /** Raw output of the most recent iteration. */
+    lastOutput: unknown;
+    /** Stringified text of the most recent iteration output. */
+    lastText: string;
+    /** Array of all prior iteration outputs (bounded by `maxHistorySize`). */
+    history: unknown[];
+    /** Nesting depth of the current execution context. */
+    depth: number;
+    /** Metadata from the most recent step execution (token usage, tool calls, etc.). */
+    lastStepMeta?: StepMeta | null;
+}
+/**
+ * Decision returned by a loop `until` predicate.
+ * @public
+ */
+export interface Verdict {
+    /** When true, the loop terminates after this iteration. */
+    stop: boolean;
+    /** Human-readable explanation of why the loop stopped (logged in traces). */
+    reason?: string;
+    /** Feedback string injected into the next iteration's context (ignored when `stop` is true). */
+    feedback?: string;
+}
+/** @public Predicate function evaluated after each loop iteration to decide whether to stop. */
+export type Until = (snapshot: Snapshot) => Verdict | Promise<Verdict>;
+/**
+ * Outcome of a single path in a `settle`-mode fork (mirrors `Promise.allSettled`).
+ * @public
+ */
+export interface SettleResult<O> {
+    /** Id of the step that produced this result. */
+    stepId: string;
+    /** Whether the path completed successfully or threw. */
+    status: 'fulfilled' | 'rejected';
+    /** The path's return value (present when `status` is `'fulfilled'`). */
+    value?: O;
+    /** The error that caused rejection (present when `status` is `'rejected'`). */
+    error?: NoeticError;
+}
+/** @public Discriminated union of all step kinds that can be composed into an execution tree. */
+export type Step<TMemory = ContextMemory, I = unknown, O = unknown> = StepRun<TMemory, I, O> | StepLLM<TMemory, I, O> | StepTool<TMemory, I, O> | StepBranch<TMemory, I, O> | StepFork<TMemory, I, O> | StepSpawn<TMemory, I, O> | StepProvide<TMemory, I, O> | StepLoop<TMemory, I, O> | StepEvery<TMemory, I, O>;
+/** @public A step that executes arbitrary async logic via a user-supplied function. */
+export interface StepRun<TMemory = ContextMemory, I = unknown, O = unknown> {
+    kind: 'run';
+    id: string;
+    execute: (input: I, ctx: Context<TMemory>) => Promise<O>;
+    retry?: RetryPolicy;
+}
+/** @public A step that sends a prompt to a language model and returns its response. */
+export interface StepLLM<_TMemory = ContextMemory, _I = unknown, O = unknown> {
+    kind: 'llm';
+    id: string;
+    model: string;
+    instructions?: string;
+    tools?: Tool[];
+    output?: ZodType<O>;
+    params?: ModelParams;
+    /** Controls framework event emission for this step. Defaults to `true`. Set `false` to suppress all framework events. A filter function receives `(eventType, data)` and returns `boolean`. */
+    emit?: boolean | ((eventType: string, data: Record<string, unknown>) => boolean);
+}
+/** @public A step that invokes a single tool directly, bypassing the LLM. */
+export interface StepTool<_TMemory = ContextMemory, I = unknown, O = unknown> {
+    kind: 'tool';
+    id: string;
+    tool: Tool<ZodType<I>, ZodType<O>>;
+    args?: Partial<I>;
+}
+/** @public A step that dynamically selects and executes one of several possible sub-steps. */
+export interface StepBranch<TMemory = ContextMemory, I = unknown, O = unknown> {
+    kind: 'branch';
+    id: string;
+    route: (input: I, ctx: Context<TMemory>) => Step<TMemory, I, O> | null | Promise<Step<TMemory, I, O> | null>;
+    _optimizable?: Step<TMemory>[];
+}
+/** @public Union of fork step variants (`race`, `all`, `settle`) for concurrent path execution. */
+export type StepFork<TMemory = ContextMemory, I = unknown, O = unknown> = StepForkRace<TMemory, I, O> | StepForkAll<TMemory, I, O> | StepForkSettle<TMemory, I, O>;
+/** @public A fork step that returns the result of the first path to complete. */
+export interface StepForkRace<TMemory = ContextMemory, I = unknown, O = unknown> {
+    kind: 'fork';
+    id: string;
+    mode: 'race';
+    paths: (input: I, ctx: Context<TMemory>) => Step<TMemory, I, O>[];
+    concurrency?: number;
+    _optimizable?: Step<TMemory>[];
+}
+/** @public A fork step that runs all paths and merges their results. */
+export interface StepForkAll<TMemory = ContextMemory, I = unknown, O = unknown> {
+    kind: 'fork';
+    id: string;
+    mode: 'all';
+    paths: (input: I, ctx: Context<TMemory>) => Step<TMemory, I, O>[];
+    merge: (results: O[], ctx: Context<TMemory>) => O;
+    concurrency?: number;
+    _optimizable?: Step<TMemory>[];
+}
+/** @public A fork step that runs all paths and collects fulfilled/rejected outcomes. */
+export interface StepForkSettle<TMemory = ContextMemory, I = unknown, O = unknown> {
+    kind: 'fork';
+    id: string;
+    mode: 'settle';
+    paths: (input: I, ctx: Context<TMemory>) => Step<TMemory, I, O>[];
+    merge: (results: SettleResult<O>[], ctx: Context<TMemory>) => O;
+    concurrency?: number;
+    _optimizable?: Step<TMemory>[];
+}
+/**
+ * A step that provides memory layers to its child without creating an isolated context.
+ * Like React's Context.Provider — layers are available to all descendant steps.
+ * Spawn and detachedSpawn break the inheritance chain.
+ * @public
+ */
+export interface StepProvide<TMemory = ContextMemory, I = unknown, O = unknown> {
+    kind: 'provide';
+    id: string;
+    child: Step<TMemory, I, O>;
+    memory: MemoryConfig | MemoryLayer[];
+}
+/** @public A step that launches a child execution with its own memory scope. */
+export interface StepSpawn<TMemory = ContextMemory, I = unknown, O = unknown> {
+    kind: 'spawn';
+    id: string;
+    child: Step<TMemory, I, O>;
+    memory?: MemoryConfig | MemoryLayer[];
+    timeout?: number;
+}
+/**
+ * A loop step that iterates a body step until a termination predicate is satisfied.
+ * @public
+ */
+export interface StepLoop<TMemory = ContextMemory, I = unknown, O = unknown> {
+    kind: 'loop';
+    /** Unique step identifier used in traces and error messages. */
+    id: string;
+    /** Steps to execute sequentially on each iteration. */
+    steps: ReadonlyArray<Step<TMemory, I, O>>;
+    /** Termination predicate evaluated after each iteration with a cumulative snapshot. */
+    until: Until;
+    /** Hard safety cap on iterations (default: 1000). */
+    maxIterations?: number;
+    /** Maximum number of entries kept in the snapshot history array. */
+    maxHistorySize?: number;
+    /** Optional channel for injecting messages into the loop mid-execution. */
+    inbox?: Channel<string>;
+    /** Ms to wait on inbox before the loop parks itself (default: 0 = no parking). */
+    parkTimeout?: number;
+    /** Transforms the previous iteration's output into the next iteration's input. */
+    prepareNext?: (output: O, verdict: Verdict, ctx: Context<TMemory>) => I;
+    /** Per-iteration error handler: retry the iteration, skip it, or abort the loop. */
+    onError?: (error: NoeticError, ctx: Context<TMemory>) => 'retry' | 'skip' | 'abort';
+}
+/**
+ * Error policy for the `every` operator when its body step throws.
+ * - `'continue'` (default): emit a span event recording the error and continue parking.
+ * - `'fail'`: re-throw, terminating the operator.
+ * @public
+ */
+export type EveryErrorPolicy = 'continue' | 'fail';
+/**
+ * A step that runs a body step on a fixed-interval schedule, optionally woken
+ * sooner by a wake channel. Runs forever until the executing context is cancelled.
+ *
+ * The operator output is `void` — `every` does not accumulate iteration outputs.
+ * The `O` type parameter exists only to anchor the body step's output type.
+ *
+ * @public
+ */
+export interface StepEvery<TMemory = ContextMemory, I = unknown, O = unknown> {
+    kind: 'every';
+    /** Unique step identifier used in traces and error messages. */
+    id: string;
+    /** Body step executed on each iteration. */
+    step: Step<TMemory, I, O>;
+    /** Park duration between iterations in milliseconds. Must be >= 0. */
+    ms: number;
+    /** Optional channel that wakes the parking interval when any value arrives. */
+    wakeOn?: Channel<unknown>;
+    /** Behavior when `step` throws. Defaults to `'continue'`. */
+    onError?: EveryErrorPolicy;
+    /** Random jitter applied to the park duration in milliseconds. Must be >= 0. Default 0. */
+    jitter?: number;
+}
+/** @public Function signature used by the interpreter to recursively execute a step. */
+export type ExecuteStepFn = <TMemory, I, O>(step: Step<TMemory, I, O>, input: I, ctx: Context<TMemory>) => Promise<O>;

package/dist/types/step.js

@@ -0,0 +1 @@
+export {};

package/dist/types/subprocess-adapter.d.ts

@@ -0,0 +1,41 @@
+export type SubprocessStatus = 'starting' | 'running' | 'paused' | 'completed' | 'failed' | 'stopped' | 'stale';
+export interface SubprocessRequest {
+    command: string;
+    args?: ReadonlyArray<string>;
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    detached?: boolean;
+    stdin?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface SubprocessHandle {
+    id: string;
+    status: SubprocessStatus;
+    startedAt: string;
+    updatedAt?: string;
+    metadata?: Record<string, unknown>;
+}
+export type SubprocessControlResult = {
+    kind: 'ok';
+    handle: SubprocessHandle;
+} | {
+    kind: 'unsupported';
+    handle: SubprocessHandle;
+    message: string;
+} | {
+    kind: 'not_found';
+    handleId: string;
+};
+export interface SubprocessStopResult {
+    kind: 'stopped' | 'not_found';
+    handleId: string;
+    handle?: SubprocessHandle;
+}
+export interface SubprocessAdapter {
+    spawn(request: SubprocessRequest): Promise<SubprocessHandle>;
+    get(handleId: string): Promise<SubprocessHandle | null>;
+    stop(handleId: string, reason?: string): Promise<SubprocessStopResult>;
+    pause(handleId: string): Promise<SubprocessControlResult>;
+    resume(handleId: string): Promise<SubprocessControlResult>;
+    isAlive(handle: SubprocessHandle): Promise<boolean>;
+}

package/dist/types/subprocess-adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/types/tool-context.d.ts

@@ -0,0 +1,34 @@
+import type { TurnContext } from '@openrouter/agent';
+import type { StepMeta } from './common';
+import type { Context } from './context';
+import type { FsAdapter } from './fs-adapter';
+import type { Item } from './items';
+import type { AgentHarnessContract } from './runtime';
+import type { ShellAdapter } from './shell-adapter';
+/** @public Accessor for reading and writing per-layer state from within a tool execution. */
+export interface ToolMemory {
+    get<T>(layerId: string): T | undefined;
+    set<T>(layerId: string, state: T): void;
+}
+/**
+ * Context provided to a tool's `execute` function at invocation time.
+ * @public
+ */
+export interface ToolExecutionContext {
+    /** The current step execution context (access to item log, parent id, etc.). */
+    readonly ctx: Context;
+    /** The harness instance executing this tool. */
+    readonly harness: AgentHarnessContract;
+    /** Filesystem adapter for virtual or real filesystem access. */
+    readonly fs: FsAdapter;
+    /** Shell adapter for virtual or real shell command execution. */
+    readonly shell: ShellAdapter;
+    /** Per-layer memory accessor for reading/writing tool-specific state. */
+    readonly memory: ToolMemory;
+    /** The fully assembled conversation view at the point of tool invocation. */
+    readonly assembledView: ReadonlyArray<Item>;
+    /** Metadata from the most recent step execution (token usage, tool calls, etc.). */
+    readonly lastStepMeta: StepMeta | null;
+    /** OpenRouter turn context, when using the OpenRouter SDK adapter. */
+    readonly turnContext?: TurnContext;
+}

package/dist/types/tool-context.js

@@ -0,0 +1 @@
+export {};

package/dist/unstable.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @unstable
+ * Unstable exports for framework extenders.
+ *
+ * Symbols exported from this module may change in any minor release.
+ * They are intended for authors of custom memory layers, runtime backends,
+ * and other framework extensions. Do not depend on them in application code.
+ */
+/** @unstable Unsafe cast utility for bridging internal type boundaries. */
+export { frameworkCast } from './interpreter/framework-cast';
+/** @unstable Budget allocation algorithm for memory layer token budgets. */
+export type { BudgetAllocation, BudgetLimits } from './memory/budget';
+/** @unstable Budget allocation and checking utilities. */
+export { allocateBudgets, checkBudget } from './memory/budget';
+/** @unstable Layer state store type for managing per-layer state during execution. */
+export type { LayerStateStore } from './memory/layer-lifecycle';
+/** @unstable Factory for creating layer state stores. */
+export { createLayerStateStore } from './memory/layer-lifecycle';
+/** @unstable View assembly algorithm that converges memory layer outputs into the LLM context. */
+export { assembleView } from './memory/projector';
+/** @unstable Factory for creating scoped storage wrappers around a StorageAdapter. */
+export { createScopedStorage } from './memory/scope';
+/**
+ * @unstable Internal helper used by sync agent-spawn paths (worktree isolation)
+ * to seed a child's cwd snapshot without touching `previousCwd`. Not part of
+ * the public surface — call sites must hold exclusive use of the parent ctx.
+ */
+export { retargetCwdForSpawn } from './runtime/cwd-helpers';

package/dist/unstable.js

@@ -0,0 +1,24 @@
+/**
+ * @unstable
+ * Unstable exports for framework extenders.
+ *
+ * Symbols exported from this module may change in any minor release.
+ * They are intended for authors of custom memory layers, runtime backends,
+ * and other framework extensions. Do not depend on them in application code.
+ */
+/** @unstable Unsafe cast utility for bridging internal type boundaries. */
+export { frameworkCast } from './interpreter/framework-cast';
+/** @unstable Budget allocation and checking utilities. */
+export { allocateBudgets, checkBudget } from './memory/budget';
+/** @unstable Factory for creating layer state stores. */
+export { createLayerStateStore } from './memory/layer-lifecycle';
+/** @unstable View assembly algorithm that converges memory layer outputs into the LLM context. */
+export { assembleView } from './memory/projector';
+/** @unstable Factory for creating scoped storage wrappers around a StorageAdapter. */
+export { createScopedStorage } from './memory/scope';
+/**
+ * @unstable Internal helper used by sync agent-spawn paths (worktree isolation)
+ * to seed a child's cwd snapshot without touching `previousCwd`. Not part of
+ * the public surface — call sites must hold exclusive use of the parent ctx.
+ */
+export { retargetCwdForSpawn } from './runtime/cwd-helpers';

package/dist/until/combinators.d.ts

@@ -0,0 +1,17 @@
+import type { Until } from '../types/step';
+/**
+ * Combines predicates with OR semantics; stops the loop when any predicate says stop.
+ *
+ * @public
+ * @param predicates - Until predicates to evaluate.
+ * @returns A combined `Until` that short-circuits on the first stop verdict.
+ */
+export declare function any(...predicates: Until[]): Until;
+/**
+ * Combines predicates with AND semantics; stops the loop only when all predicates say stop.
+ *
+ * @public
+ * @param predicates - Until predicates to evaluate.
+ * @returns A combined `Until` that requires all predicates to be satisfied.
+ */
+export declare function all(...predicates: Until[]): Until;

package/dist/until/combinators.js

@@ -0,0 +1,49 @@
+/**
+ * Combines predicates with OR semantics; stops the loop when any predicate says stop.
+ *
+ * @public
+ * @param predicates - Until predicates to evaluate.
+ * @returns A combined `Until` that short-circuits on the first stop verdict.
+ */
+export function any(...predicates) {
+    return async (snapshot) => {
+        for (const pred of predicates) {
+            const verdict = await pred(snapshot);
+            if (verdict.stop) {
+                return verdict;
+            }
+        }
+        return {
+            stop: false,
+        };
+    };
+}
+/**
+ * Combines predicates with AND semantics; stops the loop only when all predicates say stop.
+ *
+ * @public
+ * @param predicates - Until predicates to evaluate.
+ * @returns A combined `Until` that requires all predicates to be satisfied.
+ */
+export function all(...predicates) {
+    return async (snapshot) => {
+        const verdicts = [];
+        for (const pred of predicates) {
+            const verdict = await pred(snapshot);
+            verdicts.push(verdict);
+            if (!verdict.stop) {
+                return {
+                    stop: false,
+                };
+            }
+        }
+        const reasons = verdicts
+            .map((v) => v.reason)
+            .filter(Boolean)
+            .join('; ');
+        return {
+            stop: true,
+            reason: reasons || 'All predicates satisfied',
+        };
+    };
+}

package/dist/until/never.d.ts

@@ -0,0 +1,9 @@
+import type { Until } from '../types/step';
+/**
+ * Termination predicate that never stops the loop. Use with `every`-like
+ * forever-loops or with explicit cancellation paths.
+ *
+ * @public
+ * @returns An `Until` predicate that always returns `{ stop: false }`.
+ */
+export declare function never(): Until;

package/dist/until/never.js

@@ -0,0 +1,12 @@
+/**
+ * Termination predicate that never stops the loop. Use with `every`-like
+ * forever-loops or with explicit cancellation paths.
+ *
+ * @public
+ * @returns An `Until` predicate that always returns `{ stop: false }`.
+ */
+export function never() {
+    return () => ({
+        stop: false,
+    });
+}

package/dist/until/predicates.d.ts

@@ -0,0 +1,43 @@
+import type { EmbedFn } from '../types/embed';
+import type { StorageAdapter } from '../types/memory';
+import type { Until } from '../types/step';
+import { never } from './never';
+/** @public Async verification function that checks loop output and optionally returns feedback. */
+export type VerifyFn = (output: unknown) => Promise<{
+    pass: boolean;
+    feedback?: string;
+}>;
+/** @public Configuration for the `converged` until predicate, supporting exact or embedding-based similarity. */
+export interface ConvergeConfig {
+    /** Similarity threshold. Default 1 (exact match). When embed is provided and threshold < 1, uses cosine similarity. */
+    threshold?: number;
+    /** When provided with threshold < 1, enables embedding-based similarity comparison. */
+    embed?: EmbedFn;
+    /** Persist previous output vector across ephemeral invocations. */
+    cache?: StorageAdapter;
+}
+/**
+ * Namespace of built-in loop termination predicates.
+ *
+ * @public
+ */
+export declare const until: {
+    /** Stops the loop after `n` steps. @public */
+    maxSteps(n: number): Until;
+    /** Stops the loop when accumulated cost reaches `usd`. @public */
+    maxCost(usd: number): Until;
+    /** Stops the loop when elapsed time reaches `ms` milliseconds. @public */
+    maxDuration(ms: number): Until;
+    /** Stops the loop when the last model response contains no tool calls. @public */
+    noToolCalls(): Until;
+    /** Never stops the loop — pairs with operators like `every` that rely on cancellation. @public */
+    never: typeof never;
+    /** Stops the loop when the verify function returns `{ pass: true }`. @public */
+    verified(fn: VerifyFn): Until;
+    /** Stops the loop when consecutive outputs are similar (exact equality or embedding cosine similarity). @public */
+    converged(opts: ConvergeConfig): Until;
+    /** Stops the loop when the last output text contains the given marker string. @public */
+    outputContains(marker: string): Until;
+    /** Wraps an arbitrary `Until` function as a named predicate. @public */
+    custom(fn: Until): Until;
+};