@aragon-agent/core 0.1.3

package/dist/engine/agent.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Agent — the main class for the Agent engine.
+ *
+ * Wraps the agent loop, message management, steering/follow-up queues,
+ * tool registry/executor, and idle watchdog into a single cohesive API
+ * that provides a full agentic LLM execution engine.
+ */
+import type { Message, ThinkingLevel, UserMessage } from '../llm/types.js';
+import type { ProviderRegistry } from '../llm/providers/index.js';
+import type { AgentTool } from '../tools/types.js';
+import type { AgentEventListener } from '../types.js';
+import type { CodeActSandbox, ModelRef } from './agent-loop.js';
+export interface AgentConfig {
+    /** The initial system prompt. */
+    systemPrompt: string;
+    /** Model reference (provider + model ID + optional base URL). */
+    model: ModelRef;
+    /** Tools available to the agent. */
+    tools: AgentTool[];
+    /** Extended thinking level (Anthropic). Defaults to 'off'. */
+    thinkingLevel?: ThinkingLevel;
+    /** The LLM provider registry for streaming completions. */
+    providerRegistry: ProviderRegistry;
+    /** Resolver for API keys by provider ID. */
+    getApiKey: (providerId: string) => string | undefined;
+    /** Optional CodeAct sandbox for JS code execution. */
+    sandbox?: CodeActSandbox;
+    /** Maximum output tokens per LLM call. `undefined` = use provider default. */
+    maxTokens?: number;
+    /** Timeout configuration. */
+    timeouts?: {
+        /** Single LLM call timeout (ms). Default: 300_000 (5 min). */
+        llmCallTimeout?: number;
+        /** Agent idle timeout — no events for this long triggers abort (ms). Default: 60_000 (60 s). */
+        idleTimeout?: number;
+        /** Per-tool execution timeout (ms). Default: 120_000 (2 min). */
+        toolTimeout?: number;
+        /** Code execution timeout (ms). Default: 30_000 (30 s). */
+        codeTimeout?: number;
+    };
+}
+export interface AgentState {
+    readonly systemPrompt: string;
+    readonly model: ModelRef;
+    readonly thinkingLevel: ThinkingLevel;
+    readonly tools: AgentTool[];
+    readonly messages: readonly Message[];
+    readonly isRunning: boolean;
+}
+export declare class Agent {
+    private readonly messageManager;
+    private readonly messageQueueManager;
+    private readonly toolRegistry;
+    private readonly toolExecutor;
+    private readonly watchdog;
+    private readonly listeners;
+    private systemPrompt;
+    private model;
+    private thinkingLevel;
+    private currentTools;
+    private readonly providerRegistry;
+    private readonly getApiKeyFn;
+    private readonly sandbox?;
+    private maxTokens;
+    private readonly llmCallTimeout;
+    private readonly idleTimeout;
+    private readonly toolTimeout;
+    private readonly codeTimeout;
+    private abortController;
+    private running;
+    private idlePromiseResolvers;
+    constructor(config: AgentConfig);
+    get state(): AgentState;
+    /**
+     * Send a user message and run the Agent loop until completion.
+     * Always emits `agent_start` at the beginning and `agent_end` at the end,
+     * even if an error occurs.
+     */
+    prompt(message: string | UserMessage): Promise<void>;
+    /**
+     * Resume the Agent loop from the current message state.
+     * Useful for retrying after an error without re-sending the user message.
+     */
+    continue(): Promise<void>;
+    /** Abort the currently running Agent loop. */
+    abort(): void;
+    /**
+     * Wait until the Agent is idle (not running).
+     * Resolves immediately if the Agent is already idle.
+     */
+    waitForIdle(): Promise<void>;
+    /**
+     * Subscribe to Agent events.
+     * @returns An unsubscribe function.
+     */
+    subscribe(listener: AgentEventListener): () => void;
+    /** Inject a high-priority steering message (interrupts tool execution). */
+    steer(message: string): void;
+    /** Queue a low-priority follow-up message (consumed after end_turn). */
+    followUp(message: string): void;
+    setModel(model: ModelRef): void;
+    setSystemPrompt(prompt: string): void;
+    setThinkingLevel(level: ThinkingLevel): void;
+    setMaxTokens(value: number | undefined): void;
+    setTools(tools: AgentTool[]): void;
+    clearMessages(): void;
+    /** Append a single message to the conversation history (used by direct-mode flows). */
+    appendMessage(message: Message): void;
+    /** Replace the entire message history (used when loading a conversation from DB). */
+    replaceMessages(messages: Message[]): void;
+    /** Clear both steering and follow-up message queues. */
+    clearAllQueues(): void;
+    /**
+     * Emit an event to all listeners and kick the watchdog.
+     * Listener errors are caught and logged to prevent crashing the loop.
+     */
+    private emit;
+    /**
+     * Synchronize the ToolRegistry with the provided tool array.
+     * Removes tools no longer present and adds new ones.
+     */
+    private syncToolRegistry;
+    /**
+     * Run the agent loop wrapped with lifecycle events and error handling.
+     * Guarantees: agent_start is emitted first, agent_end is always emitted
+     * in the finally block, and the watchdog is always stopped.
+     */
+    private runLoopWithLifecycle;
+}

package/dist/engine/agent.js

@@ -0,0 +1,283 @@
+/**
+ * Agent — the main class for the Agent engine.
+ *
+ * Wraps the agent loop, message management, steering/follow-up queues,
+ * tool registry/executor, and idle watchdog into a single cohesive API
+ * that provides a full agentic LLM execution engine.
+ */
+import { ToolRegistry } from '../tools/registry.js';
+import { ToolExecutor } from '../tools/executor.js';
+import { MessageManager } from './message-manager.js';
+import { MessageQueueManager } from './steering.js';
+import { IdleWatchdog } from './watchdog.js';
+import { runAgentLoop } from './agent-loop.js';
+// ---------------------------------------------------------------------------
+// Default timeouts
+// ---------------------------------------------------------------------------
+const DEFAULT_LLM_CALL_TIMEOUT = 300_000;
+const DEFAULT_IDLE_TIMEOUT = 60_000;
+const DEFAULT_TOOL_TIMEOUT = 120_000;
+const DEFAULT_CODE_TIMEOUT = 30_000;
+// ---------------------------------------------------------------------------
+// Agent
+// ---------------------------------------------------------------------------
+export class Agent {
+    // --- Internal components ---
+    messageManager = new MessageManager();
+    messageQueueManager = new MessageQueueManager();
+    toolRegistry = new ToolRegistry();
+    toolExecutor;
+    watchdog;
+    listeners = new Set();
+    // --- Configuration (mutable via setters) ---
+    systemPrompt;
+    model;
+    thinkingLevel;
+    currentTools;
+    providerRegistry;
+    getApiKeyFn;
+    sandbox;
+    // --- LLM generation parameters ---
+    maxTokens;
+    // --- Timeouts ---
+    llmCallTimeout;
+    idleTimeout;
+    toolTimeout;
+    codeTimeout;
+    // --- Runtime state ---
+    abortController = null;
+    running = false;
+    idlePromiseResolvers = [];
+    constructor(config) {
+        this.systemPrompt = config.systemPrompt;
+        this.model = { ...config.model };
+        this.thinkingLevel = config.thinkingLevel ?? 'off';
+        this.currentTools = [...config.tools];
+        this.providerRegistry = config.providerRegistry;
+        this.getApiKeyFn = config.getApiKey;
+        this.sandbox = config.sandbox;
+        this.maxTokens = config.maxTokens;
+        // Timeouts
+        this.llmCallTimeout = config.timeouts?.llmCallTimeout ?? DEFAULT_LLM_CALL_TIMEOUT;
+        this.idleTimeout = config.timeouts?.idleTimeout ?? DEFAULT_IDLE_TIMEOUT;
+        this.toolTimeout = config.timeouts?.toolTimeout ?? DEFAULT_TOOL_TIMEOUT;
+        this.codeTimeout = config.timeouts?.codeTimeout ?? DEFAULT_CODE_TIMEOUT;
+        // Register initial tools
+        this.syncToolRegistry(config.tools);
+        // Tool executor
+        this.toolExecutor = new ToolExecutor(this.toolRegistry, {
+            defaultTimeout: this.toolTimeout,
+        });
+        // Watchdog — on timeout, abort the agent
+        this.watchdog = new IdleWatchdog(this.idleTimeout, () => {
+            console.error('[Agent] idle watchdog fired — aborting');
+            this.abort();
+        });
+    }
+    // =========================================================================
+    // Public readonly state
+    // =========================================================================
+    get state() {
+        return {
+            systemPrompt: this.systemPrompt,
+            model: { ...this.model },
+            thinkingLevel: this.thinkingLevel,
+            tools: [...this.currentTools],
+            messages: this.messageManager.getAll(),
+            isRunning: this.running,
+        };
+    }
+    // =========================================================================
+    // Core methods
+    // =========================================================================
+    /**
+     * Send a user message and run the Agent loop until completion.
+     * Always emits `agent_start` at the beginning and `agent_end` at the end,
+     * even if an error occurs.
+     */
+    async prompt(message) {
+        if (this.running) {
+            throw new Error('Agent is already running. Call abort() first or wait for idle.');
+        }
+        const userMessage = typeof message === 'string'
+            ? { role: 'user', content: message, timestamp: Date.now() }
+            : message;
+        this.messageManager.push(userMessage);
+        await this.runLoopWithLifecycle();
+    }
+    /**
+     * Resume the Agent loop from the current message state.
+     * Useful for retrying after an error without re-sending the user message.
+     */
+    async continue() {
+        if (this.running) {
+            throw new Error('Agent is already running. Call abort() first or wait for idle.');
+        }
+        await this.runLoopWithLifecycle();
+    }
+    /** Abort the currently running Agent loop. */
+    abort() {
+        if (this.abortController) {
+            this.abortController.abort();
+        }
+    }
+    /**
+     * Wait until the Agent is idle (not running).
+     * Resolves immediately if the Agent is already idle.
+     */
+    waitForIdle() {
+        if (!this.running) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            this.idlePromiseResolvers.push(resolve);
+        });
+    }
+    // =========================================================================
+    // Event subscription
+    // =========================================================================
+    /**
+     * Subscribe to Agent events.
+     * @returns An unsubscribe function.
+     */
+    subscribe(listener) {
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    // =========================================================================
+    // Message queues
+    // =========================================================================
+    /** Inject a high-priority steering message (interrupts tool execution). */
+    steer(message) {
+        this.messageQueueManager.pushSteering(message);
+    }
+    /** Queue a low-priority follow-up message (consumed after end_turn). */
+    followUp(message) {
+        this.messageQueueManager.pushFollowUp(message);
+    }
+    // =========================================================================
+    // State mutation
+    // =========================================================================
+    setModel(model) {
+        this.model = { ...model };
+    }
+    setSystemPrompt(prompt) {
+        this.systemPrompt = prompt;
+    }
+    setThinkingLevel(level) {
+        this.thinkingLevel = level;
+    }
+    setMaxTokens(value) {
+        this.maxTokens = value;
+    }
+    setTools(tools) {
+        this.currentTools = [...tools];
+        this.syncToolRegistry(tools);
+    }
+    clearMessages() {
+        this.messageManager.clear();
+    }
+    /** Append a single message to the conversation history (used by direct-mode flows). */
+    appendMessage(message) {
+        this.messageManager.push(message);
+    }
+    /** Replace the entire message history (used when loading a conversation from DB). */
+    replaceMessages(messages) {
+        this.messageManager.restore(messages);
+    }
+    /** Clear both steering and follow-up message queues. */
+    clearAllQueues() {
+        this.messageQueueManager.clearAll();
+    }
+    // =========================================================================
+    // Internal
+    // =========================================================================
+    /**
+     * Emit an event to all listeners and kick the watchdog.
+     * Listener errors are caught and logged to prevent crashing the loop.
+     */
+    emit(event) {
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            }
+            catch (err) {
+                console.error('[Agent] listener error:', err);
+            }
+        }
+        this.watchdog.kick();
+    }
+    /**
+     * Synchronize the ToolRegistry with the provided tool array.
+     * Removes tools no longer present and adds new ones.
+     */
+    syncToolRegistry(tools) {
+        const newNames = new Set(tools.map((t) => t.name));
+        // Remove tools no longer in the set.
+        for (const existing of this.toolRegistry.getAll()) {
+            if (!newNames.has(existing.name)) {
+                this.toolRegistry.unregister(existing.name);
+            }
+        }
+        // Add or update tools.
+        for (const tool of tools) {
+            if (this.toolRegistry.has(tool.name)) {
+                // Unregister and re-register to update the definition.
+                this.toolRegistry.unregister(tool.name);
+            }
+            this.toolRegistry.register(tool);
+        }
+    }
+    /**
+     * Run the agent loop wrapped with lifecycle events and error handling.
+     * Guarantees: agent_start is emitted first, agent_end is always emitted
+     * in the finally block, and the watchdog is always stopped.
+     */
+    async runLoopWithLifecycle() {
+        this.running = true;
+        this.abortController = new AbortController();
+        this.watchdog.start();
+        this.emit({ type: 'agent_start' });
+        try {
+            await runAgentLoop({
+                providerRegistry: this.providerRegistry,
+                toolRegistry: this.toolRegistry,
+                toolExecutor: this.toolExecutor,
+                messageManager: this.messageManager,
+                messageQueueManager: this.messageQueueManager,
+                getApiKey: this.getApiKeyFn,
+                emit: (event) => this.emit(event),
+                sandbox: this.sandbox,
+                model: this.model,
+                systemPrompt: this.systemPrompt,
+                thinkingLevel: this.thinkingLevel,
+                maxTokens: this.maxTokens,
+                signal: this.abortController.signal,
+                timeouts: {
+                    llmCallTimeout: this.llmCallTimeout,
+                    toolTimeout: this.toolTimeout,
+                    codeTimeout: this.codeTimeout,
+                },
+            });
+        }
+        catch (err) {
+            console.error('[Agent] loop error:', err);
+        }
+        finally {
+            this.watchdog.stop();
+            this.running = false;
+            this.abortController = null;
+            this.emit({
+                type: 'agent_end',
+                messages: this.messageManager.getAll(),
+            });
+            // Resolve all pending waitForIdle() callers.
+            for (const resolve of this.idlePromiseResolvers) {
+                resolve();
+            }
+            this.idlePromiseResolvers = [];
+        }
+    }
+}

package/dist/engine/message-manager.d.ts

@@ -0,0 +1,26 @@
+/**
+ * MessageManager — manages the conversation message history for an Agent.
+ *
+ * Provides append, read, clear, and restore operations over a mutable
+ * message array.  The `getAll()` method returns a readonly view so
+ * consumers cannot accidentally mutate the internal state.
+ */
+import type { Message } from '../llm/types.js';
+export declare class MessageManager {
+    private messages;
+    /** Append a message to the history. */
+    push(message: Message): void;
+    /** Return a readonly snapshot of all messages. */
+    getAll(): readonly Message[];
+    /** Remove all messages from the history. */
+    clear(): void;
+    /**
+     * Replace the entire message history with an externally provided array.
+     * Used when restoring a conversation from persistent storage.
+     */
+    restore(messages: Message[]): void;
+    /** Return the last `n` messages (or fewer if history is shorter). */
+    getLast(n: number): Message[];
+    /** The number of messages currently in the history. */
+    get length(): number;
+}

package/dist/engine/message-manager.js

@@ -0,0 +1,39 @@
+/**
+ * MessageManager — manages the conversation message history for an Agent.
+ *
+ * Provides append, read, clear, and restore operations over a mutable
+ * message array.  The `getAll()` method returns a readonly view so
+ * consumers cannot accidentally mutate the internal state.
+ */
+export class MessageManager {
+    messages = [];
+    /** Append a message to the history. */
+    push(message) {
+        this.messages.push(message);
+    }
+    /** Return a readonly snapshot of all messages. */
+    getAll() {
+        return this.messages;
+    }
+    /** Remove all messages from the history. */
+    clear() {
+        this.messages = [];
+    }
+    /**
+     * Replace the entire message history with an externally provided array.
+     * Used when restoring a conversation from persistent storage.
+     */
+    restore(messages) {
+        this.messages = [...messages];
+    }
+    /** Return the last `n` messages (or fewer if history is shorter). */
+    getLast(n) {
+        if (n <= 0)
+            return [];
+        return this.messages.slice(-n);
+    }
+    /** The number of messages currently in the history. */
+    get length() {
+        return this.messages.length;
+    }
+}

package/dist/engine/steering.d.ts

@@ -0,0 +1,27 @@
+/**
+ * MessageQueueManager — manages steering and follow-up message queues.
+ *
+ * Steering messages have high priority: they interrupt the current tool
+ * execution batch and are injected before the next LLM turn.
+ *
+ * Follow-up messages have low priority: they are consumed only when the
+ * Agent loop would otherwise exit (end_turn with no pending work).
+ */
+export declare class MessageQueueManager {
+    private readonly steeringQueue;
+    private readonly followUpQueue;
+    /** Enqueue a high-priority steering message. */
+    pushSteering(message: string): void;
+    /** Drain and return all pending steering messages (empties the queue). */
+    drainSteering(): string[];
+    /** Whether there are pending steering messages. */
+    hasSteering(): boolean;
+    /** Enqueue a low-priority follow-up message. */
+    pushFollowUp(message: string): void;
+    /** Drain and return all pending follow-up messages (empties the queue). */
+    drainFollowUp(): string[];
+    /** Whether there are pending follow-up messages. */
+    hasFollowUp(): boolean;
+    /** Clear both queues. */
+    clearAll(): void;
+}

package/dist/engine/steering.js

@@ -0,0 +1,51 @@
+/**
+ * MessageQueueManager — manages steering and follow-up message queues.
+ *
+ * Steering messages have high priority: they interrupt the current tool
+ * execution batch and are injected before the next LLM turn.
+ *
+ * Follow-up messages have low priority: they are consumed only when the
+ * Agent loop would otherwise exit (end_turn with no pending work).
+ */
+export class MessageQueueManager {
+    steeringQueue = [];
+    followUpQueue = [];
+    // -----------------------------------------------------------------------
+    // Steering
+    // -----------------------------------------------------------------------
+    /** Enqueue a high-priority steering message. */
+    pushSteering(message) {
+        this.steeringQueue.push(message);
+    }
+    /** Drain and return all pending steering messages (empties the queue). */
+    drainSteering() {
+        return this.steeringQueue.splice(0);
+    }
+    /** Whether there are pending steering messages. */
+    hasSteering() {
+        return this.steeringQueue.length > 0;
+    }
+    // -----------------------------------------------------------------------
+    // Follow-up
+    // -----------------------------------------------------------------------
+    /** Enqueue a low-priority follow-up message. */
+    pushFollowUp(message) {
+        this.followUpQueue.push(message);
+    }
+    /** Drain and return all pending follow-up messages (empties the queue). */
+    drainFollowUp() {
+        return this.followUpQueue.splice(0);
+    }
+    /** Whether there are pending follow-up messages. */
+    hasFollowUp() {
+        return this.followUpQueue.length > 0;
+    }
+    // -----------------------------------------------------------------------
+    // Lifecycle
+    // -----------------------------------------------------------------------
+    /** Clear both queues. */
+    clearAll() {
+        this.steeringQueue.length = 0;
+        this.followUpQueue.length = 0;
+    }
+}

package/dist/engine/watchdog.d.ts

@@ -0,0 +1,24 @@
+/**
+ * IdleWatchdog — fires a callback if no activity occurs within a
+ * configurable timeout window.
+ *
+ * The Agent calls `kick()` on every emitted event to reset the timer.
+ * If the timer expires (no events for `timeoutMs`), the watchdog invokes
+ * the `onTimeout` callback which typically calls `Agent.abort()`.
+ */
+export declare class IdleWatchdog {
+    private timeoutMs;
+    private readonly onTimeout;
+    private timerId;
+    private running;
+    constructor(timeoutMs: number, onTimeout: () => void);
+    /** Reset the idle timer.  Must be called on every Agent event. */
+    kick(): void;
+    /** Start the watchdog.  Begins (or restarts) the idle timer. */
+    start(): void;
+    /** Stop the watchdog and cancel any pending timer. */
+    stop(): void;
+    /** Update the timeout duration.  Takes effect on the next `kick()`. */
+    setTimeout(ms: number): void;
+    private clearTimer;
+}

package/dist/engine/watchdog.js

@@ -0,0 +1,50 @@
+/**
+ * IdleWatchdog — fires a callback if no activity occurs within a
+ * configurable timeout window.
+ *
+ * The Agent calls `kick()` on every emitted event to reset the timer.
+ * If the timer expires (no events for `timeoutMs`), the watchdog invokes
+ * the `onTimeout` callback which typically calls `Agent.abort()`.
+ */
+export class IdleWatchdog {
+    timeoutMs;
+    onTimeout;
+    timerId = null;
+    running = false;
+    constructor(timeoutMs, onTimeout) {
+        this.timeoutMs = timeoutMs;
+        this.onTimeout = onTimeout;
+    }
+    /** Reset the idle timer.  Must be called on every Agent event. */
+    kick() {
+        if (!this.running)
+            return;
+        this.clearTimer();
+        this.timerId = setTimeout(() => {
+            this.onTimeout();
+        }, this.timeoutMs);
+    }
+    /** Start the watchdog.  Begins (or restarts) the idle timer. */
+    start() {
+        this.running = true;
+        this.kick();
+    }
+    /** Stop the watchdog and cancel any pending timer. */
+    stop() {
+        this.running = false;
+        this.clearTimer();
+    }
+    /** Update the timeout duration.  Takes effect on the next `kick()`. */
+    setTimeout(ms) {
+        this.timeoutMs = ms;
+    }
+    // -----------------------------------------------------------------------
+    // Internal
+    // -----------------------------------------------------------------------
+    clearTimer() {
+        if (this.timerId !== null) {
+            clearTimeout(this.timerId);
+            this.timerId = null;
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Agent core — barrel export.
+ *
+ * This is the single entry point for importing agent-core functionality.
+ * Other tasks will expand this file as more modules are added (engine, tools,
+ * sandbox).
+ */
+export type { ContentPart, TextContentPart, ImageContentPart, ContentBlock, TextBlock, ThinkingBlock, ToolCallBlock, Message, UserMessage, AssistantMessage, ToolResultMessage, StopReason, TokenUsage, ThinkingLevel, StreamEvent, TextDeltaEvent, ThinkingStartEvent, ThinkingDeltaEvent, ToolCallStartEvent, ToolCallDeltaEvent, ToolCallEndEvent, DoneEvent, ErrorEvent, ToolDefinition, JSONSchema, ModelInfo, ModelCost, } from './llm/types.js';
+export { THINKING_BUDGET } from './llm/types.js';
+export type { LLMProvider, LLMRequest, LLMErrorType, } from './llm/provider.js';
+export { LLMError, classifyHttpError, wrapFetchError, } from './llm/provider.js';
+export type { SSEEvent } from './llm/stream-utils.js';
+export { parseSSEStream, consumeStream, } from './llm/stream-utils.js';
+export { ProviderRegistry, initProviders, getProviderRegistry, setProviderRegistry, streamLLM, completeLLM, } from './llm/providers/index.js';
+export { AnthropicProvider } from './llm/providers/anthropic.js';
+export { OpenAIProvider } from './llm/providers/openai.js';
+export { GoogleProvider } from './llm/providers/google.js';
+export { ModelRegistry, getModelRegistry, setModelRegistry, } from './llm/model-registry.js';
+export type { JSONSchema7, ToolResultContent, ToolResult, ToolProgressUpdate, ToolExecutionContext, ToolExecuteFn, AgentTool, ToolDefinition as AgentToolDefinition, ToolRegistryEvent, ToolExecutionResult, } from './tools/types.js';
+export { textResult, errorResult, imageResult, multiResult, defineTool, } from './tools/helpers.js';
+export type { DefineToolConfig } from './tools/helpers.js';
+export { ToolRegistry } from './tools/registry.js';
+export type { ToolRegistryListener } from './tools/registry.js';
+export { ToolParamValidator, ToolValidationError, formatValidationErrors, } from './tools/validator.js';
+export type { ValidationError } from './tools/validator.js';
+export { ToolExecutor } from './tools/executor.js';
+export type { ToolExecutorOptions } from './tools/executor.js';
+export { SkillRegistry } from './skills/skill-registry.js';
+export { parseFrontmatter } from './skills/frontmatter.js';
+export { validateSkillFrontmatter, validateStagedSkill } from './skills/validate.js';
+export { renderSkillCatalog, renderSkillBody, renderSkillInvocation, renderSkillFindResults, rankCatalogRecords, applySkillArguments, suggestSkillNames, sanitizeForPromptBlock, } from './skills/disclosure.js';
+export { createSkillTool } from './skills/skill-tool.js';
+export { createSkillFindTool } from './skills/skill-find-tool.js';
+export { computeToolPolicy, evaluateToolCall } from './skills/tool-policy.js';
+export { SKILL_CATALOG_MAX_BYTES, SKILL_BODY_MAX_BYTES, SKILL_RESULT_MAX_BYTES, ALWAYS_SKILLS_MAX_BYTES, SKILL_MD_MAX_BYTES, SKILL_DESC_LINE_MAX, SKILL_FILES_MAX, SKILL_FIND_MAX_BYTES, SKILL_NAME_PATTERN, } from './skills/constants.js';
+export type { SkillScope, SkillActivation, SkillFrontmatter, SkillRecord, SkillFileRef, SkillHost, SkillManifest, SkillValidationIssue, SkillCatalogOptions, SkillBodyOptions, SkillFindOptions, SkillIntegrity, SkillUsageStat, SkillUsageMap, SkillInvocationOptions, SkillPlatform, SkillPolicyView, SkillToolPolicyMode, ToolPolicyDecision, ToolPolicyInput, ToolPolicySource, ToolPolicyVerdict, } from './skills/types.js';
+export type { AgentEvent, AgentEventListener, AgentStartEvent, AgentEndEvent, TurnStartEvent, TurnEndEvent, MessageUpdateEvent, ToolExecutionStartEvent, ToolExecutionEndEvent, CodeExecutionStartEvent, CodeExecutionEndEvent, } from './types.js';
+export { Agent } from './engine/agent.js';
+export type { AgentConfig, AgentState } from './engine/agent.js';
+export type { ModelRef } from './engine/agent-loop.js';
+export type { CodeActSandbox, CodeActResult } from './engine/agent-loop.js';
+export { MessageManager } from './engine/message-manager.js';
+export { MessageQueueManager } from './engine/steering.js';
+export { IdleWatchdog } from './engine/watchdog.js';
+export type { SandboxConfig, ExecuteOptions, ExecuteResult, ConsoleEntry, SandboxToolCall, } from './sandbox/types.js';
+export { Agent as AragonAgent } from './engine/agent.js';