@t2000/engine 0.31.3 → 0.33.0

package/dist/index.d.ts

@@ -5,9 +5,251 @@ import { Tool as Tool$1 } from '@modelcontextprotocol/sdk/types.js';
 import * as _t2000_sdk from '@t2000/sdk';
 import { T2000 } from '@t2000/sdk';
 
+/** Rough token count for a message array. */
+declare function estimateTokens(messages: Message[]): number;
+interface CompactOptions {
+    /** Max token budget for the conversation. Default 100_000. */
+    maxTokens?: number;
+    /** Number of recent messages to always keep uncompacted. Default 6. */
+    keepRecentCount?: number;
+    /** System prompt token estimate (subtracted from budget). Default 500. */
+    systemPromptTokens?: number;
+    /** LLM-based summarizer for old turns. When provided, replaces old turns with a summary. */
+    summarizer?: (messages: Message[]) => Promise<string>;
+}
+interface ContextBudgetConfig {
+    /** Total context window size in tokens. Default 200_000 (Sonnet 4.6). */
+    contextLimit?: number;
+    /** Trigger compaction at this fraction of contextLimit. Default 0.85. */
+    compactThreshold?: number;
+    /** Emit a warning at this fraction of contextLimit. Default 0.70. */
+    warnThreshold?: number;
+}
+declare class ContextBudget {
+    private estimatedTokens;
+    private readonly contextLimit;
+    private readonly compactThreshold;
+    private readonly warnThreshold;
+    constructor(config?: ContextBudgetConfig);
+    /** Update with actual input_tokens from the API usage event. */
+    update(inputTokens: number): void;
+    /** True when the session should be compacted (at 85% of context limit). */
+    shouldCompact(): boolean;
+    /** True when nearing the limit (at 70% of context limit). */
+    shouldWarn(): boolean;
+    /** Current token count. */
+    get tokens(): number;
+    /** Remaining tokens before compaction triggers. */
+    get remaining(): number;
+    /** Usage ratio (0..1). */
+    get usage(): number;
+    reset(): void;
+}
+/**
+ * Compact a conversation that exceeds the token budget.
+ *
+ * Strategy:
+ * 1. Always preserve the most recent `keepRecentCount` messages (the active context).
+ * 2. If an LLM `summarizer` is provided, summarize old turns into a brief recap and
+ *    replace them with a synthetic summary turn pair.
+ * 3. For older messages, summarise tool_result content to a brief one-liner.
+ * 4. If still over budget, drop the oldest messages (keeping the first user message
+ *    for context continuity).
+ *
+ * Returns a new array — does not mutate the input.
+ */
+declare function compactMessages(messages: readonly Message[], opts?: CompactOptions): Promise<Message[]>;
+
+interface RecipeStepRequirement {
+    step?: string;
+    field?: string;
+    confirmation?: boolean;
+}
+interface RecipeStepOnError {
+    action: 'abort' | 'refuse' | 'report' | 'retry';
+    message: string;
+    suggest?: string;
+}
+interface RecipePrerequisite {
+    field: string;
+    prompt: string;
+}
+interface RecipeStep {
+    name: string;
+    tool?: string;
+    service?: string;
+    purpose: string;
+    cost?: string;
+    output?: {
+        type: string;
+        key: string;
+    };
+    gate?: 'none' | 'preview' | 'review' | 'estimate';
+    gate_prompt?: string;
+    requires?: RecipeStepRequirement[];
+    rules?: string[];
+    condition?: string;
+    notes?: string;
+    flags?: Partial<ToolFlags>;
+    on_error?: RecipeStepOnError;
+    input_template?: Record<string, string>;
+    cost_per_unit?: string;
+}
+interface Recipe {
+    name: string;
+    description: string;
+    triggers: string[];
+    services?: string[];
+    prerequisites?: RecipePrerequisite[];
+    steps: RecipeStep[];
+}
+
+/**
+ * Stores loaded recipes and matches user messages to the most specific recipe
+ * using longest-trigger-match-wins.
+ */
+declare class RecipeRegistry {
+    private recipes;
+    /** Load all recipes from a directory of YAML files. */
+    loadDir(yamlDir: string): void;
+    /** Register a single recipe from a YAML string. */
+    loadYaml(yamlContent: string): void;
+    /** Register a pre-parsed Recipe object. */
+    register(recipe: Recipe): void;
+    /** All loaded recipes. */
+    all(): readonly Recipe[];
+    /**
+     * Match a user message to the most specific recipe.
+     * Longest trigger phrase match wins. Returns null if no match.
+     */
+    match(userMessage: string): Recipe | null;
+    /**
+     * Format a matched recipe as a compact context block for the system prompt.
+     * Injected dynamically — only when the recipe matches.
+     */
+    toPromptContext(recipe: Recipe): string;
+}
+
+/**
+ * Load all recipe YAML files from a directory.
+ * Throws on validation errors — recipes should fail at load time, not runtime.
+ */
+declare function loadRecipes(yamlDir: string): Recipe[];
+/**
+ * Parse a single recipe from a YAML string (useful for embedded/bundled recipes).
+ */
+declare function parseRecipe(yamlContent: string): Recipe;
+
+interface PendingToolCall {
+    id: string;
+    name: string;
+    input: unknown;
+}
+declare class TxMutex {
+    private queue;
+    private locked;
+    acquire(): Promise<void>;
+    release(): void;
+}
+declare function runTools(pending: PendingToolCall[], tools: Tool[], context: ToolContext, txMutex: TxMutex): AsyncGenerator<EngineEvent>;
+
+type GuardVerdict = 'pass' | 'hint' | 'warn' | 'block';
+type GuardTier = 'safety' | 'financial' | 'ux';
+interface GuardResult {
+    verdict: GuardVerdict;
+    gate: string;
+    tier: GuardTier;
+    message?: string;
+}
+interface GuardInjection {
+    _gate: string;
+    _hint?: string;
+    _warning?: string;
+    _error?: string;
+}
+interface GuardCheckResult {
+    blocked: boolean;
+    blockReason?: string;
+    blockGate?: string;
+    injections: GuardInjection[];
+    events: GuardEvent[];
+}
+interface GuardEvent {
+    timestamp: number;
+    toolName: string;
+    toolUseId: string;
+    gate: string;
+    verdict: GuardVerdict;
+    tier: GuardTier;
+    message?: string;
+}
+interface GuardConfig {
+    balanceValidation?: boolean;
+    healthFactor?: {
+        warnBelow: number;
+        blockBelow: number;
+    } | false;
+    largeTransfer?: {
+        warnAbove: number;
+        strongWarnAbove: number;
+    } | false;
+    slippage?: boolean;
+    staleData?: boolean;
+    irreversibility?: boolean;
+    artifactPreview?: boolean;
+    costWarning?: boolean;
+    retryProtection?: boolean;
+    inputValidation?: boolean;
+}
+declare const DEFAULT_GUARD_CONFIG: GuardConfig;
+declare class BalanceTracker {
+    private lastBalanceAt;
+    private lastWriteAt;
+    recordRead(): void;
+    recordWrite(): void;
+    isStale(): boolean;
+    hasEverRead(): boolean;
+}
+declare class RetryTracker {
+    private executed;
+    private key;
+    record(toolName: string, input: unknown, result: unknown): void;
+    isBlocked(toolName: string, input: unknown): {
+        blocked: boolean;
+        previousResult?: unknown;
+    };
+}
+declare function guardArtifactPreview(result: unknown): GuardInjection | null;
+declare function guardStaleData(toolFlags: ToolFlags): GuardInjection | null;
+interface GuardRunnerState {
+    balanceTracker: BalanceTracker;
+    retryTracker: RetryTracker;
+    lastHealthFactor: number | null;
+}
+declare function createGuardRunnerState(): GuardRunnerState;
+declare function runGuards(tool: Tool, call: PendingToolCall, state: GuardRunnerState, config: GuardConfig, conversationContext: {
+    fullText: string;
+    lastAssistantText: string;
+}): GuardCheckResult;
+declare function updateGuardStateAfterToolResult(toolName: string, tool: Tool | undefined, input: unknown, result: unknown, isError: boolean, state: GuardRunnerState): void;
+declare function extractConversationText(messages: Array<{
+    role: string;
+    content: unknown;
+}>): {
+    fullText: string;
+    lastAssistantText: string;
+};
+
 type ContentBlock = {
     type: 'text';
     text: string;
+} | {
+    type: 'thinking';
+    thinking: string;
+    signature: string;
+} | {
+    type: 'redacted_thinking';
+    data: string;
 } | {
     type: 'tool_use';
     id: string;
@@ -24,6 +266,12 @@ interface Message {
     content: ContentBlock[];
 }
 type EngineEvent = {
+    type: 'thinking_delta';
+    text: string;
+} | {
+    type: 'thinking_done';
+    signature?: string;
+} | {
     type: 'text_delta';
     text: string;
 } | {
@@ -78,6 +326,12 @@ interface PendingAction {
         content: string;
         isError: boolean;
     }>;
+    /** Guard injections (hints/warnings) from pre-execution checks. */
+    guardInjections?: Array<{
+        _gate: string;
+        _hint?: string;
+        _warning?: string;
+    }>;
 }
 /**
  * Response from the client when resolving a pending action.
@@ -132,6 +386,21 @@ interface ToolJsonSchema {
     properties: Record<string, unknown>;
     required?: string[];
 }
+interface ToolFlags {
+    mutating?: boolean;
+    requiresBalance?: boolean;
+    affectsHealth?: boolean;
+    irreversible?: boolean;
+    producesArtifact?: boolean;
+    costAware?: boolean;
+    maxRetries?: number;
+}
+type PreflightResult = {
+    valid: true;
+} | {
+    valid: false;
+    error: string;
+};
 interface Tool<TInput = unknown, TOutput = unknown> {
     name: string;
     description: string;
@@ -141,7 +410,31 @@ interface Tool<TInput = unknown, TOutput = unknown> {
     isConcurrencySafe: boolean;
     isReadOnly: boolean;
     permissionLevel: PermissionLevel;
+    flags: ToolFlags;
+    preflight?: (input: unknown) => PreflightResult;
+}
+type ThinkingEffort = 'low' | 'medium' | 'high' | 'max';
+type ThinkingConfig = {
+    type: 'disabled';
+} | {
+    type: 'adaptive';
+    display?: 'summarized' | 'omitted';
+} | {
+    type: 'enabled';
+    budgetTokens: number;
+    display?: 'summarized' | 'omitted';
+};
+interface OutputConfig {
+    effort?: ThinkingEffort;
+}
+interface SystemBlock {
+    type: 'text';
+    text: string;
+    cache_control?: {
+        type: 'ephemeral';
+    };
 }
+type SystemPrompt = string | SystemBlock[];
 interface EngineConfig {
     provider: LLMProvider;
     agent?: unknown;
@@ -152,13 +445,15 @@ interface EngineConfig {
     /** Fresh on-chain position reader — called per tool invocation, bypasses MCP caching. */
     positionFetcher?: (address: string) => Promise<ServerPositionData>;
     tools?: Tool[];
-    systemPrompt?: string;
+    systemPrompt?: SystemPrompt;
     model?: string;
     maxTurns?: number;
     maxTokens?: number;
     temperature?: number;
     /** Force tool usage on the first LLM turn (prevents text-only refusals). */
     toolChoice?: ToolChoice;
+    thinking?: ThinkingConfig;
+    outputConfig?: OutputConfig;
     /** Environment variables forwarded to tool context (API keys, URLs). */
     env?: Record<string, string>;
     costTracker?: {
@@ -166,6 +461,14 @@ interface EngineConfig {
         inputCostPerToken?: number;
         outputCostPerToken?: number;
     };
+    /** Guard runner configuration (RE-2.2). Omit to disable guards. */
+    guards?: GuardConfig;
+    /** Recipe registry for multi-step workflow guidance (RE-3.1). */
+    recipes?: RecipeRegistry;
+    /** Context budget tracking configuration (RE-3.3). */
+    contextBudget?: ContextBudgetConfig;
+    /** LLM-based summarizer for context compaction (RE-3.3). */
+    contextSummarizer?: (messages: Message[]) => Promise<string>;
 }
 interface LLMProvider {
     chat(params: ChatParams): AsyncGenerator<ProviderEvent>;
@@ -176,12 +479,14 @@ type ToolChoice = 'auto' | 'any' | {
 };
 interface ChatParams {
     messages: Message[];
-    systemPrompt: string;
+    systemPrompt: SystemPrompt;
     tools: ToolDefinition[];
     model?: string;
     maxTokens?: number;
     temperature?: number;
     toolChoice?: ToolChoice;
+    thinking?: ThinkingConfig;
+    outputConfig?: OutputConfig;
     signal?: AbortSignal;
 }
 interface ToolDefinition {
@@ -190,6 +495,16 @@ interface ToolDefinition {
     input_schema: ToolJsonSchema;
 }
 type ProviderEvent = {
+    type: 'thinking_delta';
+    text: string;
+} | {
+    type: 'thinking_done';
+    thinking: string;
+    signature: string;
+} | {
+    type: 'redacted_thinking';
+    data: string;
+} | {
     type: 'text_delta';
     text: string;
 } | {
@@ -258,6 +573,8 @@ declare class QueryEngine {
     private readonly maxTokens;
     private readonly temperature;
     private readonly toolChoice;
+    private readonly thinking;
+    private readonly outputConfig;
     private readonly agent;
     private readonly mcpManager;
     private readonly walletAddress;
@@ -267,8 +584,15 @@ declare class QueryEngine {
     private readonly env;
     private readonly txMutex;
     private readonly costTracker;
+    private readonly guardConfig;
+    private readonly guardState;
+    private readonly recipes;
+    private readonly contextBudget;
+    private readonly contextSummarizer;
+    private matchedRecipe;
     private messages;
     private abortController;
+    private guardEvents;
     constructor(config: EngineConfig);
     /**
      * Submit a user message and stream engine events.
@@ -288,7 +612,10 @@ declare class QueryEngine {
     resumeWithToolResult(action: PendingAction, response: PermissionResponse): AsyncGenerator<EngineEvent>;
     interrupt(): void;
     getMessages(): readonly Message[];
+    getMatchedRecipe(): Recipe | null;
+    getContextBudget(): ContextBudget;
     reset(): void;
+    getGuardEvents(): readonly GuardEvent[];
     loadMessages(messages: Message[]): void;
     setServerPositions(data: EngineConfig['serverPositions']): void;
     getUsage(): CostSnapshot;
@@ -321,6 +648,8 @@ interface BuildToolOptions<TInput, TOutput> {
     call: (input: TInput, context: ToolContext) => Promise<ToolResult<TOutput>>;
     isReadOnly?: boolean;
     permissionLevel?: PermissionLevel;
+    flags?: ToolFlags;
+    preflight?: (input: TInput) => PreflightResult;
 }
 declare function buildTool<TInput, TOutput>(opts: BuildToolOptions<TInput, TOutput>): Tool<TInput, TOutput>;
 declare function toolsToDefinitions(tools: Tool[]): {
@@ -330,20 +659,13 @@ declare function toolsToDefinitions(tools: Tool[]): {
 }[];
 declare function findTool(tools: Tool[], name: string): Tool | undefined;
 
-interface PendingToolCall {
-    id: string;
-    name: string;
-    input: unknown;
-}
-declare class TxMutex {
-    private queue;
-    private locked;
-    acquire(): Promise<void>;
-    release(): void;
-}
-declare function runTools(pending: PendingToolCall[], tools: Tool[], context: ToolContext, txMutex: TxMutex): AsyncGenerator<EngineEvent>;
-
 type SSEEvent = {
+    type: 'thinking_delta';
+    text: string;
+} | {
+    type: 'thinking_done';
+    signature?: string;
+} | {
     type: 'text_delta';
     text: string;
 } | {
@@ -418,28 +740,126 @@ declare class MemorySessionStore implements SessionStore {
     private evictExpired;
 }
 
-/** Rough token count for a message array. */
-declare function estimateTokens(messages: Message[]): number;
-interface CompactOptions {
-    /** Max token budget for the conversation. Default 100_000. */
-    maxTokens?: number;
-    /** Number of recent messages to always keep uncompacted. Default 6. */
-    keepRecentCount?: number;
-    /** System prompt token estimate (subtracted from budget). Default 500. */
-    systemPromptTokens?: number;
-}
 /**
- * Compact a conversation that exceeds the token budget.
+ * Central registry of tool flags for the guard runner (RE-2.2).
  *
- * Strategy:
- * 1. Always preserve the most recent `keepRecentCount` messages (the active context).
- * 2. For older messages, summarise tool_result content to a brief one-liner.
- * 3. If still over budget, drop the oldest messages (keeping the first user message
- *    for context continuity).
+ * Flags are declarative metadata that guards read to decide what checks to run.
+ * Read-only tools have no flags by default (empty object).
  *
- * Returns a new array — does not mutate the input.
+ * Flag meanings:
+ *   mutating        — changes on-chain state (deposit, swap, send, borrow)
+ *   requiresBalance — needs sufficient funds to execute
+ *   affectsHealth   — can change borrow health factor
+ *   irreversible    — physical mail, external transfers — can't undo
+ *   producesArtifact — returns images, documents, generated content
+ *   costAware       — has a monetary cost the user should know about
+ *   maxRetries      — max calls with same input (default: unlimited for reads, 1 for writes)
+ */
+declare const TOOL_FLAGS: Record<string, ToolFlags>;
+/**
+ * Apply flags from the central registry to a tool array.
+ * Tools not in the registry get empty flags (read-only tools).
+ */
+declare function applyToolFlags<T extends Tool>(tools: T[]): T[];
+/**
+ * Get flags for a tool by name. Returns empty flags if not registered.
+ */
+declare function getToolFlags(name: string): ToolFlags;
+
+/**
+ * Routes each turn to the appropriate thinking effort level based on
+ * message content, matched recipe, and session write history.
+ *
+ * Heuristics only — no LLM call. Cost per session becomes proportional
+ * to actual query complexity rather than a fixed budget.
+ */
+declare function classifyEffort(model: string, userMessage: string, matchedRecipe: Recipe | null, sessionWriteCount: number): ThinkingEffort;
+
+/**
+ * Build a cacheable system prompt array from static and dynamic parts.
+ *
+ * Anthropic caches system prompt blocks marked with `cache_control: { type: 'ephemeral' }`.
+ * Static blocks (identity, tool descriptions) are cached across turns. Dynamic blocks
+ * (user profile, positions, state) change per-turn and are NOT cached.
+ *
+ * Cache breakpoints are placed at the end of each static block — Anthropic caches
+ * from the start of the prompt up to the last cache_control marker.
  */
-declare function compactMessages(messages: readonly Message[], opts?: CompactOptions): Message[];
+declare function buildCachedSystemPrompt(staticParts: string[], dynamicPart?: string): SystemBlock[];
+
+/**
+ * Intelligence Layer prompt builders (F1, F2, F5).
+ * Pure functions — no DB or Redis dependencies.
+ * Consumed by the host app's dynamic context assembly.
+ */
+interface UserFinancialProfile {
+    userId: string;
+    riskAppetite: 'conservative' | 'moderate' | 'aggressive';
+    financialLiteracy: 'novice' | 'intermediate' | 'advanced';
+    prefersBriefResponses: boolean;
+    prefersExplainers: boolean;
+    currencyFraming: 'usdc' | 'fiat';
+    primaryGoals: string[];
+    knownPatterns: string[];
+    riskConfidence: number;
+    literacyConfidence: number;
+    lastInferredAt: Date | null;
+}
+/**
+ * Build system prompt context from a user's financial profile.
+ * Returns empty string if profile is absent or confidence is too low.
+ * Takes the profile object directly — no DB query.
+ */
+declare function buildProfileContext(profile: UserFinancialProfile | null): string;
+declare function buildProactivenessInstructions(profile: UserFinancialProfile | null): string;
+declare function buildSelfEvaluationInstruction(): string;
+
+/**
+ * Conversation State Machine — F4 of the Intelligence Layer.
+ *
+ * Types, pure context builder, and a generic state manager interface.
+ * The Redis implementation lives in the host app (audric) since it depends on @upstash/redis.
+ */
+type ConversationState = {
+    type: 'idle';
+} | {
+    type: 'mid_recipe';
+    recipeName: string;
+    currentStep: number;
+    totalSteps: number;
+    completedStepOutputs: Record<string, Record<string, string | number>>;
+    startedAt: number;
+} | {
+    type: 'awaiting_confirmation';
+    action: string;
+    amount?: number;
+    recipient?: string;
+    proposedAt: number;
+    expiresAt: number;
+} | {
+    type: 'post_error';
+    failedAction: string;
+    errorMessage: string;
+    occurredAt: number;
+    partialState?: string;
+} | {
+    type: 'post_liquidation_warning';
+    healthFactor: number;
+    warnedAt: number;
+} | {
+    type: 'onboarding';
+    sessionNumber: number;
+    hasBalance: boolean;
+    hasSavedBefore: boolean;
+};
+type StateType = ConversationState['type'];
+interface ConversationStateStore {
+    get(): Promise<ConversationState>;
+    set(state: ConversationState): Promise<void>;
+    transition(to: ConversationState): Promise<void>;
+    reset(): Promise<void>;
+}
+declare function buildStateContext(state: ConversationState): string;
 
 interface McpToolDescriptor {
     name: string;
@@ -1246,4 +1666,4 @@ declare function clearPriceCache(): void;
 
 declare const DEFAULT_SYSTEM_PROMPT = "You are a financial agent on Sui. You manage money and access paid APIs via MPP micropayments.\n\n## Response rules\n- 1-2 sentences max. No bullet lists unless asked. No preambles.\n- Never say \"Would you like me to...\", \"Sure!\", \"Great question!\", \"Absolutely!\" \u2014 just do it or say you can't.\n- Lead with the result. After tool calls, state the outcome with real numbers. Done.\n- Present amounts as $1,234.56 and rates as X.XX% APY.\n- Show top 3 results unless asked for more. Summarize totals in one line.\n\n## Execution rule\nOnly offer to execute actions you have tools for. If you retrieved a quote, data, or information but have no tool to act on it, give the user the result and tell them where to execute manually \u2014 in one sentence. Never say \"Would you like me to proceed?\" unless you have a tool that can actually proceed.\n\n## Before acting\n- ALWAYS call a read tool first before any write tool \u2014 balance_check before save/send/borrow, savings_info before withdraw.\n- Show real numbers from tools \u2014 never fabricate rates, amounts, or balances.\n- When user says \"all\" or an imprecise amount, call the read tool first to get the exact number.\n\n## Tool usage\n- Use tools proactively \u2014 don't refuse requests you can handle.\n- For real-world questions (weather, search, news, prices), use pay_api. Tell the user the cost first.\n- For broad market data (yields across protocols, token prices, TVL, protocol comparisons), use defillama_* tools.\n- To discover Sui protocols, use defillama_sui_protocols first, then defillama_protocol_info with the slug.\n- Run multiple read-only tools in parallel when you need several data points.\n- If a tool errors, say what went wrong and what to try instead. One sentence.\n\n## Savings = USDC only (critical)\n- save_deposit accepts ONLY USDC. No other token can be deposited into savings.\n- When asked \"how much can I save?\", report only the user's USDC wallet balance (saveableUsdc field from balance_check). Other tokens like GOLD, SUI, USDT are NOT saveable and NOT savings positions \u2014 they are just wallet holdings.\n- NEVER say a non-USDC token is \"in savings\" or \"earning APY in savings\" unless it appears in the savings_info positions list. Wallet holdings \u2260 savings.\n- If user wants to save non-USDC tokens, tell them to swap to USDC first. Do NOT auto-chain swap + deposit.\n\n## Multi-step flows\n- \"How much X for Y?\": swap_quote first, then swap_execute if user confirms.\n- \"Swap then save\": swap_execute \u2192 balance_check \u2192 save_deposit. Confirm each step.\n- \"Buy $X of token\": defillama_token_prices \u2192 calculate amount \u2192 swap_execute.\n- \"Best yield on SUI\": compare rates_info (NAVI lending) + defillama_yield_pools (broader) + volo_stats.\n- withdraw supports legacy positions: USDC, USDe, USDsui, SUI. Pass asset param to withdraw a specific token.\n- \"Deposit SUI to earn yield\": volo_stake for SUI liquid staking. save_deposit is USDC only.\n- \"What protocols are on Sui?\": defillama_sui_protocols \u2192 defillama_protocol_info for details.\n\n## Safety\n- Never encourage risky financial behavior.\n- Warn when health factor < 1.5.\n- All amounts in USDC unless stated otherwise.";
 
-export { AnthropicProvider, type AnthropicProviderConfig, type BalancePrices, type BalanceResult, type BuildToolOptions, CANVAS_TEMPLATES, type CanvasTemplate, type ChatParams, type CompactOptions, type ContentBlock, type CostSnapshot, CostTracker, type CostTrackerConfig, DEFAULT_SYSTEM_PROMPT, type EngineConfig, type EngineEvent, type HealthFactorResult, type LLMProvider, type McpCallResult, McpClientManager, McpResponseCache, type McpServerConfig, type McpServerConnection, type McpToolAdapterConfig, type McpToolDescriptor, MemorySessionStore, type Message, NAVI_MCP_CONFIG, NAVI_MCP_URL, NAVI_SERVER_NAME, type NaviRawCoin, type NaviRawHealthFactor, type NaviRawPool, type NaviRawPosition, type NaviRawPositionsResponse, type NaviRawProtocolStats, type NaviRawRewardsResponse, type NaviReadOptions, NaviTools, type PendingAction, type PendingReward, type PendingToolCall, type PermissionLevel, type PermissionResponse, type PositionEntry, type ProtocolStats, type ProviderEvent, QueryEngine, READ_TOOLS, type RatesResult, type SSEEvent, type SavingsResult, type ServerPositionData, type SessionData, type SessionStore, type StopReason, type SuiCoinBalance, type Tool, type ToolChoice, type ToolContext, type ToolDefinition, type ToolJsonSchema, type ToolResult, TxMutex, WRITE_TOOLS, type WalletCoin, activitySummaryTool, adaptAllMcpTools, adaptAllServerTools, adaptMcpTool, balanceCheckTool, borrowTool, buildMcpTools, buildTool, claimRewardsTool, clearPriceCache, compactMessages, defillamaChainTvlTool, defillamaPriceChangeTool, defillamaProtocolFeesTool, defillamaProtocolInfoTool, defillamaSuiProtocolsTool, defillamaTokenPricesTool, defillamaYieldPoolsTool, engineToSSE, estimateTokens, explainTxTool, extractMcpText, fetchAvailableRewards, fetchBalance, fetchHealthFactor, fetchPositions, fetchProtocolStats, fetchRates, fetchSavings, fetchTokenPrices, fetchWalletCoins, findTool, getDefaultTools, getMcpManager, getWalletAddress, hasNaviMcp, healthCheckTool, mppServicesTool, parseMcpJson, parseSSE, payApiTool, portfolioAnalysisTool, protocolDeepDiveTool, ratesInfoTool, registerEngineTools, renderCanvasTool, repayDebtTool, requireAgent, runTools, saveContactTool, saveDepositTool, savingsInfoTool, sendTransferTool, serializeSSE, spendingAnalyticsTool, swapExecuteTool, swapQuoteTool, toolsToDefinitions, transactionHistoryTool, transformBalance, transformHealthFactor, transformPositions, transformRates, transformRewards, transformSavings, validateHistory, voloStakeTool, voloStatsTool, voloUnstakeTool, webSearchTool, withdrawTool, yieldSummaryTool };
+export { AnthropicProvider, type AnthropicProviderConfig, type BalancePrices, type BalanceResult, BalanceTracker, type BuildToolOptions, CANVAS_TEMPLATES, type CanvasTemplate, type ChatParams, type CompactOptions, type ContentBlock, ContextBudget, type ContextBudgetConfig, type ConversationState, type ConversationStateStore, type CostSnapshot, CostTracker, type CostTrackerConfig, DEFAULT_GUARD_CONFIG, DEFAULT_SYSTEM_PROMPT, type EngineConfig, type EngineEvent, type GuardCheckResult, type GuardConfig, type GuardEvent, type GuardInjection, type GuardResult, type GuardRunnerState, type GuardTier, type GuardVerdict, type HealthFactorResult, type LLMProvider, type McpCallResult, McpClientManager, McpResponseCache, type McpServerConfig, type McpServerConnection, type McpToolAdapterConfig, type McpToolDescriptor, MemorySessionStore, type Message, NAVI_MCP_CONFIG, NAVI_MCP_URL, NAVI_SERVER_NAME, type NaviRawCoin, type NaviRawHealthFactor, type NaviRawPool, type NaviRawPosition, type NaviRawPositionsResponse, type NaviRawProtocolStats, type NaviRawRewardsResponse, type NaviReadOptions, NaviTools, type OutputConfig, type PendingAction, type PendingReward, type PendingToolCall, type PermissionLevel, type PermissionResponse, type PositionEntry, type PreflightResult, type ProtocolStats, type ProviderEvent, QueryEngine, READ_TOOLS, type RatesResult, type Recipe, type RecipePrerequisite, RecipeRegistry, type RecipeStep, type RecipeStepOnError, RetryTracker, type SSEEvent, type SavingsResult, type ServerPositionData, type SessionData, type SessionStore, type StateType, type StopReason, type SuiCoinBalance, type SystemBlock, type SystemPrompt, TOOL_FLAGS, type ThinkingConfig, type ThinkingEffort, type Tool, type ToolChoice, type ToolContext, type ToolDefinition, type ToolFlags, type ToolJsonSchema, type ToolResult, TxMutex, type UserFinancialProfile, WRITE_TOOLS, type WalletCoin, activitySummaryTool, adaptAllMcpTools, adaptAllServerTools, adaptMcpTool, applyToolFlags, balanceCheckTool, borrowTool, buildCachedSystemPrompt, buildMcpTools, buildProactivenessInstructions, buildProfileContext, buildSelfEvaluationInstruction, buildStateContext, buildTool, claimRewardsTool, classifyEffort, clearPriceCache, compactMessages, createGuardRunnerState, defillamaChainTvlTool, defillamaPriceChangeTool, defillamaProtocolFeesTool, defillamaProtocolInfoTool, defillamaSuiProtocolsTool, defillamaTokenPricesTool, defillamaYieldPoolsTool, engineToSSE, estimateTokens, explainTxTool, extractConversationText, extractMcpText, fetchAvailableRewards, fetchBalance, fetchHealthFactor, fetchPositions, fetchProtocolStats, fetchRates, fetchSavings, fetchTokenPrices, fetchWalletCoins, findTool, getDefaultTools, getMcpManager, getToolFlags, getWalletAddress, guardArtifactPreview, guardStaleData, hasNaviMcp, healthCheckTool, loadRecipes, mppServicesTool, parseMcpJson, parseRecipe, parseSSE, payApiTool, portfolioAnalysisTool, protocolDeepDiveTool, ratesInfoTool, registerEngineTools, renderCanvasTool, repayDebtTool, requireAgent, runGuards, runTools, saveContactTool, saveDepositTool, savingsInfoTool, sendTransferTool, serializeSSE, spendingAnalyticsTool, swapExecuteTool, swapQuoteTool, toolsToDefinitions, transactionHistoryTool, transformBalance, transformHealthFactor, transformPositions, transformRates, transformRewards, transformSavings, updateGuardStateAfterToolResult, validateHistory, voloStakeTool, voloStatsTool, voloUnstakeTool, webSearchTool, withdrawTool, yieldSummaryTool };