@noetic-tools/core 0.0.1

package/dist/conditions/conditions.js

@@ -0,0 +1,271 @@
+import { z } from 'zod';
+import { createMessage, extractAssistantText, trackUsage } from '../interpreter/message-helpers';
+import { cosineSimilarity } from './cosine-similarity';
+//#endregion
+//#region Helpers
+function serializeInput(input) {
+    return typeof input === 'string' ? input : JSON.stringify(input);
+}
+function hashLabel(label) {
+    return `embed:${encodeURIComponent(label)}`;
+}
+async function getLabelVectors(embed, labels, ref) {
+    if (ref.storage) {
+        const storage = ref.storage;
+        const keys = labels.map(hashLabel);
+        const fetched = await Promise.all(keys.map((k) => storage.get(k)));
+        const missingIndices = [];
+        for (let i = 0; i < fetched.length; i++) {
+            if (!fetched[i]) {
+                missingIndices.push(i);
+            }
+        }
+        let freshEmbeddings = [];
+        if (missingIndices.length > 0) {
+            const missingLabels = missingIndices.map((i) => labels[i]);
+            // embed returns readonly number[][], spread each row into a mutable copy
+            freshEmbeddings = (await embed(missingLabels)).map((v) => Array.from(v));
+            await Promise.all(missingIndices.map((idx, j) => storage.set(keys[idx], freshEmbeddings[j])));
+        }
+        const results = new Array(labels.length);
+        let freshIndex = 0;
+        for (let i = 0; i < fetched.length; i++) {
+            results[i] = fetched[i] ?? freshEmbeddings[freshIndex++];
+        }
+        return results;
+    }
+    if (ref.memory) {
+        return ref.memory;
+    }
+    const vectors = await embed(labels);
+    ref.memory = vectors;
+    return vectors;
+}
+//#endregion
+//#region Clause Builders
+/**
+ * Creates a conditional clause that routes to the given step when the condition is true.
+ *
+ * @public
+ * @param condition - Async predicate evaluated against the input and context.
+ * @param step - Step to execute when the condition matches.
+ * @returns A `WhenClause` for use in `semanticRoute`.
+ */
+export function when(condition, step) {
+    return {
+        kind: 'when',
+        condition,
+        step,
+    };
+}
+/**
+ * Creates a fallback clause that always matches, used as the last clause in `semanticRoute`.
+ *
+ * @public
+ * @param step - Step to execute when no prior `when` clause matches.
+ * @returns An `OtherwiseClause` for use in `semanticRoute`.
+ */
+export function otherwise(step) {
+    return {
+        kind: 'otherwise',
+        step,
+    };
+}
+//#endregion
+//#region Route Builders
+function isOtherwise(clause) {
+    return clause.kind === 'otherwise';
+}
+/**
+ * Builds a route function from an ordered list of `when`/`otherwise` clauses.
+ * Evaluates clauses sequentially, returning the first matching step or `null`.
+ *
+ * @public
+ * @param clauses - Ordered `WhenClause` and optional trailing `OtherwiseClause`.
+ * @returns A route function suitable for `branch({ route })`.
+ */
+export function semanticRoute(...clauses) {
+    return async (input, ctx) => {
+        for (const clause of clauses) {
+            if (isOtherwise(clause)) {
+                return clause.step;
+            }
+            const matched = await clause.condition(input, ctx);
+            if (matched) {
+                return clause.step;
+            }
+        }
+        return null;
+    };
+}
+export function semanticSwitch(opts) {
+    const threshold = opts.threshold ?? 0.7;
+    // Normalize to advanced form
+    const cases = Array.isArray(opts.cases)
+        ? opts.cases.map((c) => ({
+            labels: Array.isArray(c.labels)
+                ? c.labels
+                : [
+                    c.labels,
+                ],
+            step: c.step,
+        }))
+        : Object.entries(opts.cases).map(([label, step]) => ({
+            labels: [
+                label,
+            ],
+            step,
+        }));
+    const allLabels = cases.flatMap((c) => c.labels);
+    const labelToCaseIndex = cases.flatMap((c, i) => c.labels.map(() => i));
+    const vectorCache = {
+        memory: null,
+        storage: opts.cache,
+    };
+    return async (input, _ctx) => {
+        const text = serializeInput(input);
+        const [inputVector] = await opts.embed([
+            text,
+        ]);
+        const labelVectors = await getLabelVectors(opts.embed, allLabels, vectorCache);
+        let bestScore = Number.NEGATIVE_INFINITY;
+        let bestCaseIndex = -1;
+        for (let i = 0; i < allLabels.length; i++) {
+            const score = cosineSimilarity(inputVector, labelVectors[i]);
+            if (score > bestScore) {
+                bestScore = score;
+                bestCaseIndex = labelToCaseIndex[i];
+            }
+        }
+        if (bestScore < threshold) {
+            return opts.default ?? null;
+        }
+        return cases[bestCaseIndex].step;
+    };
+}
+export function embeddingMatch(embedOrOpts, label, threshold) {
+    // Simple form
+    if (typeof embedOrOpts === 'function') {
+        const embed = embedOrOpts;
+        if (label === undefined || threshold === undefined) {
+            throw new Error('embeddingMatch: label and threshold are required in simple form');
+        }
+        const singleLabel = label;
+        const thresh = threshold;
+        const vectorCache = {
+            memory: null,
+        };
+        return async (input, _ctx) => {
+            const text = serializeInput(input);
+            // On first call, batch input + label into one embed request
+            if (!vectorCache.memory) {
+                const [inputVector, labelVector] = await embed([
+                    text,
+                    singleLabel,
+                ]);
+                vectorCache.memory = [
+                    labelVector,
+                ];
+                return cosineSimilarity(inputVector, labelVector) >= thresh;
+            }
+            const [inputVector] = await embed([
+                text,
+            ]);
+            return cosineSimilarity(inputVector, vectorCache.memory[0]) >= thresh;
+        };
+    }
+    // Advanced form
+    const opts = embedOrOpts;
+    const matchMode = opts.match ?? 'any';
+    const vectorCache = {
+        memory: null,
+        storage: opts.cache,
+    };
+    return async (input, _ctx) => {
+        const text = serializeInput(input);
+        const [inputVector] = await opts.embed([
+            text,
+        ]);
+        const labelVectors = await getLabelVectors(opts.embed, opts.labels, vectorCache);
+        if (matchMode === 'any') {
+            return labelVectors.some((vec) => cosineSimilarity(inputVector, vec) >= opts.threshold);
+        }
+        return labelVectors.every((vec) => cosineSimilarity(inputVector, vec) >= opts.threshold);
+    };
+}
+//#endregion
+//#region Combinators
+/**
+ * Combines conditions with OR semantics; returns true on the first truthy condition.
+ *
+ * @public
+ * @param conditions - Conditions to evaluate.
+ * @returns A `Condition` that short-circuits on the first match.
+ */
+export function anyCondition(...conditions) {
+    return async (input, ctx) => {
+        for (const condition of conditions) {
+            if (await condition(input, ctx)) {
+                return true;
+            }
+        }
+        return false;
+    };
+}
+/**
+ * Combines conditions with AND semantics; returns false on the first falsy condition.
+ *
+ * @public
+ * @param conditions - Conditions to evaluate.
+ * @returns A `Condition` that short-circuits on the first non-match.
+ */
+export function allCondition(...conditions) {
+    return async (input, ctx) => {
+        for (const condition of conditions) {
+            if (!(await condition(input, ctx))) {
+                return false;
+            }
+        }
+        return true;
+    };
+}
+//#endregion
+//#region aiCondition
+const AiConditionResponseSchema = z.object({
+    answer: z.boolean(),
+});
+/**
+ * Creates a condition that uses an LLM to classify the input as true or false.
+ *
+ * @public
+ * @param opts - Configuration with model identifier and classification prompt.
+ * @returns A `Condition` that delegates boolean classification to the model.
+ */
+export function aiCondition(opts) {
+    return async (input, ctx) => {
+        const text = serializeInput(input);
+        const systemPrompt = `You are a boolean classifier. Given the user's input, answer the following question with JSON: {"answer": true} or {"answer": false}.\n\nQuestion: ${opts.prompt}`;
+        const items = [
+            createMessage(systemPrompt, 'developer'),
+            createMessage(text, 'user'),
+        ];
+        const response = await ctx.harness.callModel({
+            model: opts.model,
+            items,
+            params: {
+                temperature: 0,
+            },
+        });
+        trackUsage(ctx, response);
+        const responseText = extractAssistantText(response.items);
+        try {
+            const parsed = JSON.parse(responseText);
+            const validated = AiConditionResponseSchema.parse(parsed);
+            return validated.answer;
+        }
+        catch {
+            return false;
+        }
+    };
+}
+//#endregion

package/dist/conditions/cosine-similarity.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Cosine similarity between two vectors.
+ * Returns a value in [-1, 1]. Throws on dimension mismatch.
+ * Returns 0 for zero-magnitude vectors.
+ *
+ * @public
+ * @param a - First vector.
+ * @param b - Second vector (must have the same length as `a`).
+ * @returns Cosine similarity score.
+ */
+export declare function cosineSimilarity(a: readonly number[], b: readonly number[]): number;

package/dist/conditions/cosine-similarity.js

@@ -0,0 +1,28 @@
+/**
+ * Cosine similarity between two vectors.
+ * Returns a value in [-1, 1]. Throws on dimension mismatch.
+ * Returns 0 for zero-magnitude vectors.
+ *
+ * @public
+ * @param a - First vector.
+ * @param b - Second vector (must have the same length as `a`).
+ * @returns Cosine similarity score.
+ */
+export function cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+        throw new Error(`Dimension mismatch: ${a.length} vs ${b.length}`);
+    }
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        dot += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    const magnitude = Math.sqrt(normA * normB);
+    if (magnitude === 0) {
+        return 0;
+    }
+    return dot / magnitude;
+}

package/dist/conditions/index.d.ts

@@ -0,0 +1,3 @@
+export type { Condition, OtherwiseClause, WhenClause } from './conditions';
+export { aiCondition, allCondition, anyCondition, embeddingMatch, otherwise, semanticRoute, semanticSwitch, when, } from './conditions';
+export { cosineSimilarity } from './cosine-similarity';

package/dist/conditions/index.js

@@ -0,0 +1,2 @@
+export { aiCondition, allCondition, anyCondition, embeddingMatch, otherwise, semanticRoute, semanticSwitch, when, } from './conditions';
+export { cosineSimilarity } from './cosine-similarity';

package/dist/errors/noetic-config-error.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @public
+ * Configuration-time error thrown during construction and setup.
+ *
+ * `NoeticConfigError` is separate from `NoeticError`. The two are never interchangeable:
+ * - `NoeticError` — thrown during execution (LLM failures, fork failures, budget exceeded).
+ * - `NoeticConfigError` — thrown during construction (invalid step config, missing env vars, runtime misconfiguration).
+ *
+ * @example
+ * ```ts
+ * try {
+ *   loop({ id: '', steps: [], until: until.maxSteps(10) });
+ * } catch (e) {
+ *   if (isNoeticConfigError(e)) {
+ *     console.error(e.code, e.hint);
+ *   }
+ * }
+ * ```
+ */
+export declare class NoeticConfigError extends Error {
+    /** SCREAMING_SNAKE_CASE code uniquely identifying this error condition. */
+    readonly code: string;
+    /** Complete sentence describing what the user should do next. */
+    readonly hint: string;
+    /** Link to the relevant docs page, if available. */
+    readonly docsUrl?: string;
+    constructor(opts: {
+        code: string;
+        message: string;
+        hint: string;
+        docsUrl?: string;
+    });
+}
+/**
+ * @public
+ * Type guard for `NoeticConfigError`.
+ *
+ * @param e - Value to check.
+ * @returns `true` if `e` is a `NoeticConfigError`.
+ */
+export declare function isNoeticConfigError(e: unknown): e is NoeticConfigError;

package/dist/errors/noetic-config-error.js

@@ -0,0 +1,44 @@
+/**
+ * @public
+ * Configuration-time error thrown during construction and setup.
+ *
+ * `NoeticConfigError` is separate from `NoeticError`. The two are never interchangeable:
+ * - `NoeticError` — thrown during execution (LLM failures, fork failures, budget exceeded).
+ * - `NoeticConfigError` — thrown during construction (invalid step config, missing env vars, runtime misconfiguration).
+ *
+ * @example
+ * ```ts
+ * try {
+ *   loop({ id: '', steps: [], until: until.maxSteps(10) });
+ * } catch (e) {
+ *   if (isNoeticConfigError(e)) {
+ *     console.error(e.code, e.hint);
+ *   }
+ * }
+ * ```
+ */
+export class NoeticConfigError extends Error {
+    /** SCREAMING_SNAKE_CASE code uniquely identifying this error condition. */
+    code;
+    /** Complete sentence describing what the user should do next. */
+    hint;
+    /** Link to the relevant docs page, if available. */
+    docsUrl;
+    constructor(opts) {
+        super(opts.message);
+        this.name = 'NoeticConfigError';
+        this.code = opts.code;
+        this.hint = opts.hint;
+        this.docsUrl = opts.docsUrl;
+    }
+}
+/**
+ * @public
+ * Type guard for `NoeticConfigError`.
+ *
+ * @param e - Value to check.
+ * @returns `true` if `e` is a `NoeticConfigError`.
+ */
+export function isNoeticConfigError(e) {
+    return e instanceof NoeticConfigError;
+}

package/dist/errors/noetic-error.d.ts

@@ -0,0 +1,18 @@
+import type { NoeticError } from '../types/error';
+/**
+ * Runtime error thrown during step execution (LLM failures, fork failures, budget exceeded, etc.).
+ *
+ * @public
+ */
+export declare class NoeticErrorImpl extends Error {
+    readonly noeticError: NoeticError;
+    constructor(error: NoeticError);
+}
+/**
+ * Type guard for `NoeticErrorImpl`.
+ *
+ * @public
+ * @param e - Value to check.
+ * @returns `true` if `e` is a `NoeticErrorImpl`.
+ */
+export declare function isNoeticError(e: unknown): e is NoeticErrorImpl;

package/dist/errors/noetic-error.js

@@ -0,0 +1,52 @@
+/**
+ * Runtime error thrown during step execution (LLM failures, fork failures, budget exceeded, etc.).
+ *
+ * @public
+ */
+export class NoeticErrorImpl extends Error {
+    noeticError;
+    constructor(error) {
+        super(formatMessage(error));
+        this.name = 'NoeticError';
+        this.noeticError = error;
+    }
+}
+/**
+ * Type guard for `NoeticErrorImpl`.
+ *
+ * @public
+ * @param e - Value to check.
+ * @returns `true` if `e` is a `NoeticErrorImpl`.
+ */
+export function isNoeticError(e) {
+    return e instanceof NoeticErrorImpl;
+}
+function formatMessage(error) {
+    switch (error.kind) {
+        case 'step_failed':
+            return `Step '${error.stepId}' failed: ${error.cause.message}`;
+        case 'llm_refused':
+            return `LLM refused at step '${error.stepId}': ${error.refusal}`;
+        case 'llm_parse_error':
+            return `LLM parse error at step '${error.stepId}': failed to parse output`;
+        case 'llm_rate_limit':
+            return `LLM rate limited at step '${error.stepId}'${error.retryAfter ? ` (retry after ${error.retryAfter}ms)` : ''}`;
+        case 'fork_partial':
+            return `Fork '${error.stepId}' partial failure: ${error.succeeded.length} succeeded, ${error.failed.length} failed`;
+        case 'channel_timeout':
+            return `Channel '${error.channelName}' timed out after ${error.timeout}ms`;
+        case 'channel_closed':
+            return `Channel '${error.channelName}' is closed`;
+        case 'cancelled':
+            return `Cancelled${error.reason ? `: ${error.reason}` : ''}`;
+        case 'budget_exceeded':
+            return `Budget exceeded: ${error.field} limit ${error.limit}, actual ${error.actual}`;
+        case 'steering_denied':
+            return `Steering denied${error.guidance ? `: ${error.guidance}` : ''}`;
+        default: {
+            const _exhaustive = error;
+            void _exhaustive;
+            return 'NoeticError: unknown kind';
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,152 @@
+/** @public */
+export { createInMemoryFsAdapter } from './adapters/in-memory-fs-adapter';
+/** @public */
+export { createInMemoryShellAdapter } from './adapters/in-memory-shell-adapter';
+/** @public */
+export { createInMemorySubprocessAdapter } from './adapters/in-memory-subprocess-adapter';
+/** @public */
+export { createLocalFsAdapter } from './adapters/local-fs-adapter';
+/** @public */
+export { type CreateLocalShellAdapterOptions, createLocalShellAdapter, type LocalShellAdapter, } from './adapters/local-shell-adapter';
+/** @public */
+export { type CreateLocalSubprocessAdapterOptions, createLocalSubprocessAdapter, defaultProcessSignaller, type ProcessSignaller, type SubprocessSignal, } from './adapters/local-subprocess-adapter';
+/** @public */
+export { createOpenRouterEmbed } from './adapters/openrouter';
+/** @public */
+export { channel } from './builders/channel-builder';
+/** @public */
+export { branch, fork } from './builders/control-flow-builders';
+/** @public */
+export type { EveryOptions } from './builders/every';
+/** @public */
+export { every } from './builders/every';
+/** @public */
+export { layerData, layerFn } from './builders/layer-provides-builders';
+/** @public */
+export type { LoopConfig } from './builders/loop-builder';
+/** @public */
+export { loop } from './builders/loop-builder';
+/** @public */
+export { memory } from './builders/memory-builder';
+/** @public */
+export { provide } from './builders/provide-builder';
+/** @public */
+export { spawn } from './builders/spawn-builder';
+/** @public */
+export { step } from './builders/step-builders';
+/** @public */
+export { tool, toolWithGenerator } from './builders/tool-builder';
+/** @public */
+export type { Condition, OtherwiseClause, WhenClause } from './conditions';
+/** @public */
+export { aiCondition, allCondition, anyCondition, cosineSimilarity, embeddingMatch, otherwise, semanticRoute, semanticSwitch, when, } from './conditions';
+/** @public */
+export { isNoeticConfigError, NoeticConfigError } from './errors/noetic-config-error';
+/** @public */
+export { isNoeticError, NoeticErrorImpl } from './errors/noetic-error';
+/** @public */
+export { execute } from './interpreter/execute';
+/** @public */
+export type { DurableTaskState, DurableTaskStateConfig } from './memory/layers/durable-task-state';
+/** @public */
+export { durableTaskState } from './memory/layers/durable-task-state';
+/** @public */
+export { fileReference } from './memory/layers/file-reference';
+/** @public */
+export type { HistoryWindowConfig } from './memory/layers/history-window';
+/** @public */
+export { historyWindow } from './memory/layers/history-window';
+/** @public */
+export type { ObservationalMemoryConfig, ObservationalState, } from './memory/layers/observational-memory';
+/** @public */
+export { observationalMemory } from './memory/layers/observational-memory';
+/** @public */
+export type { PlanEnterSessionCallback, PlanExecutionEntry, PlanExitCallback, PlanMemoryConfig, PlanState, } from './memory/layers/plan';
+/** @public */
+export { PlanPhase, planMemory } from './memory/layers/plan';
+/** @public */
+export { staticContent } from './memory/layers/static-content';
+/** @public */
+export { steering } from './memory/layers/steering';
+/** @public */
+export { toolMemoryLayer } from './memory/layers/tool-memory-layer';
+/** @public */
+export type { WorkingMemoryConfig, WorkingMemoryState } from './memory/layers/working-memory';
+/** @public */
+export { workingMemory } from './memory/layers/working-memory';
+/** @public */
+export { stripUnresolvedToolCalls } from './memory/strip-unresolved';
+/** @public */
+export { InMemoryExporter, NoopExporter } from './observability/trace-exporter';
+/** @public */
+export { createInMemoryStorage } from './runtime/in-memory-storage';
+/** @public */
+export type { FlowNode, ForkFlowNode, LlmFlowNode, SequenceFlowNode, SpawnFlowNode, SubagentFlowNode, } from './patterns/flow';
+/** @public */
+export { FlowSchema, flowDepth, validateFlow, walkFlow } from './patterns/flow';
+/** @public */
+export type { InterviewOpts, InterviewQuestionAnswer, InterviewResult } from './patterns/interview';
+/** @public */
+export { interview } from './patterns/interview';
+/** @public */
+export type { PlanConstraints, PlanNode } from './patterns/plans';
+/** @public */
+export { adaptivePlan, compilePlan, PlanNodeSchema } from './patterns/plans';
+/** @public */
+export { ralphWiggum } from './patterns/ralph-wiggum';
+/** @public */
+export { react } from './patterns/react';
+/** @public */
+export { AgentHarness } from './runtime/agent-harness';
+/** @public */
+export { defaultItemSchemaRegistry, ItemSchema, ItemSchemaRegistry } from './schemas/item';
+/** @public */
+export type { Channel, ChannelHandle, ExternalChannel } from './types/channel';
+/** @public */
+export type { LLMResponse, LlmProviderConfig, ModelParams, RetryPolicy, StepMeta, TokenUsage, Tool, ToolMemoryDeclaration, } from './types/common';
+/** @public */
+export { getToolCwd, setToolCwd, snapshotCwdState } from './runtime/cwd-helpers';
+/** @public */
+export type { Context, CwdState, ItemLog, LastLayerUsage, LayerUsageEntry, } from './types/context';
+/** @public */
+export type { DetachedHandle } from './types/detached';
+/** @public */
+export { DetachedStatus } from './types/detached';
+/** @public */
+export type { EmbedFn } from './types/embed';
+/** @public */
+export type { NoeticError } from './types/error';
+/** @public */
+export type { ContentPart, DeveloperMessageExtensionItem, ExecuteInput, ExtendedItem, ExtensionItem, FileSearchItem, FunctionCallItem, FunctionCallOutputItem, ImageGenerationItem, InferExtendedItem, InputMessageItem, InputTextPart, Item, ItemBase, ItemSchemaExtensions, MessageItem, OutputItem, OutputTextPart, ReasoningItem, ReasoningTextPart, RefusalPart, ServerToolItem, SummaryTextPart, WebSearchItem, } from './types/items';
+/** @public */
+export type { BudgetConfig, CompleteParams, ContextMemory, DisposeParams, ExecutionContext, ExecutionOutcome, InferMemory, InferMemoryShape, InitParams, InitResult, LayerDataDecl, LayerFunctionDecl, LayerProvides, LayerTimeouts, MemoryConfig, MemoryHooks, MemoryLayer, MemoryScope, ProjectionPolicy, RecallParams, RecallResult, ReturnParams, ReturnResult, ScopedStorage, SpawnParams, SpawnResult, StorageAdapter, StoreParams, StoreResult, } from './types/memory';
+/** @public */
+export { Slot } from './types/memory';
+/** @public */
+export type { MemoryTraceSpan, Span, TraceExporter } from './types/observability';
+/** @public */
+export type { FrameworkStreamEvent, HarnessResponse, SdkStreamEvent, StreamEvent, StreamingItem, } from './types/harness-result';
+/** @public */
+export type { AgentConfig, AgentHarnessContract, AgentHooks, CallModelRequest, DeliveryMode, ExecuteOptions, HarnessStatus, RecallLayerOutput, SessionScope, } from './types/runtime';
+/** @public */
+export type { AfterModelCallParams, AfterModelCallResult, BeforeToolCallParams, BeforeToolCallResult, LedgerEntry, SteeringConfig, SteeringDecision, SteeringRule, SteeringState, } from './types/steering';
+/** @public */
+export { LedgerEntryKind, SteeringAction } from './types/steering';
+/** @public */
+export type { ExecuteStepFn, SettleResult, Snapshot, Step, StepBranch, StepFork, StepForkAll, StepForkRace, StepForkSettle, StepLLM, StepLoop, StepProvide, StepRun, StepSpawn, StepTool, Until, Verdict, } from './types/step';
+/** @public */
+export type { FsAdapter, FsStats } from './types/fs-adapter';
+/** @public */
+export type { ShellAdapter, ShellExecOptions, ShellExecResult } from './types/shell-adapter';
+/** @public */
+export { TIMEOUT_ERROR_PREFIX } from './types/shell-adapter';
+/** @public */
+export type { SubprocessAdapter, SubprocessControlResult, SubprocessHandle, SubprocessRequest, SubprocessStatus, SubprocessStopResult, } from './types/subprocess-adapter';
+/** @public */
+export type { ToolExecutionContext, ToolMemory } from './types/tool-context';
+/** @public */
+export { all, any } from './until/combinators';
+/** @public */
+export type { ConvergeConfig, VerifyFn } from './until/predicates';
+/** @public */
+export { until } from './until/predicates';