@t2000/engine 1.7.0 → 1.9.0

package/dist/index.d.ts

@@ -94,6 +94,19 @@ interface RecipeStep {
     on_error?: RecipeStepOnError;
     input_template?: Record<string, string>;
     cost_per_unit?: string;
+    /**
+     * [SPEC 7 P2.5 Layer 4] When true, this step is part of a multi-write
+     * Payment Stream bundle group. Steps with `bundle: true` MUST resolve
+     * to confirm-tier write tools that carry `bundleable: true` in
+     * `TOOL_FLAGS` (validated at recipe load time). The loader fails fast
+     * on auto-tier writes / read-only tools / non-bundleable confirm tools
+     * (`pay_api`, `save_contact`) inside a `bundle: true` group.
+     *
+     * The engine emits parallel `tool_use` blocks for `bundle: true`
+     * steps in the same turn; the permission gate (Layer 2) collapses
+     * them into a single bundled `pending_action`.
+     */
+    bundle?: boolean;
 }
 interface Recipe {
     name: string;
@@ -889,6 +902,27 @@ interface PendingActionModifiableField {
     /** Optional asset symbol (e.g. "USDC", "SUI", "vSUI") for amount fields. */
     asset?: string;
 }
+/**
+ * [SPEC 7 v0.4 Layer 2] One step inside a multi-write Payment Stream
+ * `PendingAction`. Single-write actions never carry `steps[]`; the
+ * legacy `toolName`/`toolUseId`/`input`/`attemptId` fields cover them.
+ */
+interface PendingActionStep {
+    toolName: string;
+    toolUseId: string;
+    /**
+     * Per-step UUID v4 stamped at emit time. Hosts write one
+     * `TurnMetrics` row per step keyed on this id; the resume route's
+     * `updateMany({ where: { attemptId } })` extends trivially to the
+     * per-step shape (loop `stepResults`, update each row).
+     */
+    attemptId: string;
+    input: unknown;
+    /** Per-step user-facing summary (rendered in the PermissionCard). */
+    description: string;
+    /** Optional modifiable fields for THIS step (rare in v1; sourced from `tool-modifiable-fields.ts`). */
+    modifiableFields?: PendingActionModifiableField[];
+}
 /**
  * Serializable description of a write tool that needs user approval.
  * Stored in the session so the client can act on it in a separate request.
@@ -935,17 +969,88 @@ interface PendingAction {
      * matching the pair, which is exactly the false-resolution bug Item 3
      * exists to kill. Also survives session persistence so the resume call
      * can read it back from the rehydrated `PendingAction`.
+     *
+     * **Bundles:** when `steps !== undefined` (multi-write Payment Stream),
+     * the top-level `attemptId` mirrors `steps[0].attemptId` per SPEC 7
+     * § Layer 2 line 463 ("`steps[0]` mirrors the top-level
+     * toolName/toolUseId/input/attemptId for hosts that haven't been
+     * updated"). Pre-bundle hosts that key TurnMetrics rows on top-level
+     * `attemptId` collide cleanly with the bundle-aware host's step-0 row.
+     * Bundle-aware hosts iterate `steps[]` and write N TurnMetrics rows
+     * (one per step `attemptId`); the resume route's
+     * `updateMany({ where: { attemptId } })` keys still work because the
+     * route loops `stepResults` and updates each per-step row.
      */
     attemptId: string;
+    /**
+     * [SPEC 7 v0.4 Layer 2] When set, this `pending_action` represents a
+     * multi-write Payment Stream. Single-step bundles are NOT created — the
+     * engine emits the legacy single-write shape when N=1. Hosts that haven't
+     * been updated read `toolName`/`toolUseId`/`input` (which mirror
+     * `steps[0]`); newer hosts iterate `steps`.
+     *
+     * Bundleable tools (v1): `save_deposit`, `withdraw`, `borrow`,
+     * `repay_debt`, `send_transfer`, `swap_execute`, `claim_rewards`,
+     * `volo_stake`, `volo_unstake`. Non-bundleable: `pay_api`
+     * (HTTPS coupling), `save_contact` (Postgres only).
+     */
+    steps?: PendingActionStep[];
+    /**
+     * [SPEC 7 v0.3 Quote-Refresh] Milliseconds since the upstream read tools
+     * that fed this bundle's composition completed. Engine stamps at emit
+     * time using `Date.now() - min(tool_result.timestamp)` across the listed
+     * `regenerateInput.toolUseIds`. Host renders as a "QUOTE Ns OLD" badge in
+     * the PermissionCard header. Only set on bundled `pending_action`s.
+     */
+    quoteAge?: number;
+    /**
+     * [SPEC 7 v0.3 Quote-Refresh] True when the bundle was composed from
+     * re-runnable read tools (`swap_quote`, `rates_info`, `balance_check`,
+     * `portfolio_analysis`). False when amounts came from user-provided
+     * inputs that don't depend on upstream quotes. Single-write
+     * `pending_action`s set this to `false` (regenerate is N≥2 only).
+     */
+    canRegenerate?: boolean;
+    /**
+     * [SPEC 7 v0.3 Quote-Refresh] Engine-internal payload listing which
+     * upstream read `tool_use` ids to re-fire when the user taps REGENERATE.
+     * Host echoes this back via `POST /api/engine/regenerate`; engine re-runs
+     * each tool with the same input (no LLM call), rebuilds the bundle, and
+     * emits a fresh `pending_action` with new per-step `attemptId`s.
+     */
+    regenerateInput?: {
+        toolUseIds: string[];
+    };
 }
 /**
  * Response from the client when resolving a pending action.
  * - `approved: false` → tool is declined, LLM is told "user declined"
  * - `approved: true` with `executionResult` → engine uses the client-provided result
+ *   (single-write path)
+ * - `approved: true` with `stepResults` → engine pushes one `tool_result`
+ *   block per step into the conversation (bundle path)
  */
 interface PermissionResponse {
     approved: boolean;
+    /** Single-write (legacy) execution result. Ignored when `stepResults` is set. */
     executionResult?: unknown;
+    /**
+     * [SPEC 7 v0.4 Layer 2] Per-step results for a bundle resume. One entry
+     * per step in the original `PendingAction.steps`, in the same order.
+     * Each carries the step's `toolUseId` + `attemptId` so the host's resume
+     * route can update the matching `TurnMetrics` row.
+     *
+     * **Atomic semantics:** PTB execution is atomic at the Sui layer. If the
+     * host detects a bundle-level failure, it should populate every entry
+     * with `isError: true` carrying the same error message (so the LLM
+     * narrates the failure once, not N times).
+     */
+    stepResults?: Array<{
+        toolUseId: string;
+        attemptId: string;
+        result: unknown;
+        isError: boolean;
+    }>;
 }
 type PermissionLevel = 'auto' | 'confirm' | 'explicit';
 interface ToolResult<T = unknown> {
@@ -1046,6 +1151,24 @@ interface ToolFlags {
     producesArtifact?: boolean;
     costAware?: boolean;
     maxRetries?: number;
+    /**
+     * [SPEC 7 v0.4 Layer 2] Opt-in: this write tool can participate in a
+     * multi-write Payment Stream. When the LLM emits ≥2 `tool_use` blocks
+     * in a single assistant turn AND every block resolves to a `confirm`-tier
+     * write tool with `bundleable: true`, the engine collapses them into one
+     * `pending_action` with `steps[]` instead of yielding N times. Default
+     * `false` — silently opt-out. v1 set: `save_deposit`, `withdraw`,
+     * `borrow`, `repay_debt`, `send_transfer`, `swap_execute`,
+     * `claim_rewards`, `volo_stake`, `volo_unstake`.
+     *
+     * **Permanently non-bundleable:**
+     *  - `pay_api` — recipient/amount/currency aren't known at LLM intent
+     *    time (gateway 402 challenge resolves them at route time, after a
+     *    network round-trip the engine has no knowledge of). PTB cannot be
+     *    composed at compose time.
+     *  - `save_contact` — Postgres-only, no on-chain effect.
+     */
+    bundleable?: boolean;
 }
 type PreflightResult = {
     valid: true;
@@ -1412,6 +1535,14 @@ declare class QueryEngine {
     private runPostWriteRefresh;
     interrupt(): void;
     getMessages(): readonly Message[];
+    /**
+     * [SPEC 7 P2.4b] Read-only access to the engine's tool registry.
+     * Exposed so out-of-band utilities like `regenerateBundle` can call
+     * `composeBundleFromToolResults({ tools: engine.getTools(), ... })`
+     * without forcing the host to hand-thread the tool array. Mirrors
+     * `getMessages()` access pattern.
+     */
+    getTools(): readonly Tool[];
     getMatchedRecipe(): Recipe | null;
     getContextBudget(): ContextBudget;
     reset(): void;
@@ -1466,6 +1597,168 @@ declare class QueryEngine {
  */
 declare function validateHistory(messages: Message[]): Message[];
 
+/**
+ * SPEC 7 v0.3 Quote-Refresh ReviewCard — per-tool result freshness budgets.
+ *
+ * When a Payment Stream `pending_action` is composed at T=0 from upstream
+ * read results, the user may take 30–60s to read + tap APPROVE. By that
+ * time some upstream results have drifted (Cetus quotes refresh in
+ * ~30s; NAVI APYs change slower). The host renders a "QUOTE Ns OLD"
+ * badge and pulses the REGENERATE button when `quoteAge >
+ * bundleShortestTtl(...)` so the user is nudged toward a fresh
+ * composition. The TTL is a UX hint — it does NOT gate correctness.
+ * The actual safety net is Sui's on-chain dry-run + `minOut` reverts.
+ *
+ * **Why per-tool, not per-bundle.** A bundle that depends on `swap_quote`
+ * (30s drift) AND `rates_info` (90s drift) inherits the SHORTEST member
+ * TTL — that's the freshness ceiling we can promise. Mixing in a
+ * stable-floor read like `balance_check` (120s) doesn't loosen the
+ * ceiling; the user still cares about the 30s quote going stale.
+ *
+ * **Where this lives.** Engine emits `quoteAge` + `regenerateInput` on
+ * the bundled `pending_action`; the host imports `bundleShortestTtl` to
+ * decide when the regenerate button auto-pulses. Adding a new
+ * re-runnable read tool: append it to `TOOL_TTL_MS` here AND ensure the
+ * bundle composer's contributing-reads detector picks it up.
+ */
+declare const TOOL_TTL_MS: Record<string, number>;
+/** Default TTL for read tools not in `TOOL_TTL_MS` (60s — conservative). */
+declare const DEFAULT_TOOL_TTL_MS = 60000;
+/**
+ * Resolve the shortest TTL among a set of tool_use_ids. Hosts call this
+ * to decide when the regenerate button should auto-pulse.
+ *
+ * @param toolUseIds — the set of upstream read `tool_use` ids that fed
+ *   the bundle composition (what the engine stamps into
+ *   `PendingAction.regenerateInput.toolUseIds`).
+ * @param toolNamesById — `tool_use_id` → `toolName` map, built by the
+ *   host from the same turn's tool_use blocks.
+ * @returns The smallest TTL in milliseconds. Empty input returns
+ *   `DEFAULT_TOOL_TTL_MS`.
+ */
+declare function bundleShortestTtl(toolUseIds: string[], toolNamesById: Record<string, string>): number;
+/** The set of read tools whose results re-fire on REGENERATE. */
+declare const REGENERATABLE_READ_TOOLS: ReadonlySet<string>;
+
+/**
+ * SPEC 7 v0.3 Quote-Refresh ReviewCard — engine-side bundle regeneration.
+ *
+ * When a user takes 30–60s to read a multi-step Payment Stream
+ * `pending_action`, the upstream read results that fed bundle composition
+ * (Cetus quotes, NAVI APYs, wallet balances) drift. Today the user has to
+ * either approve with stale data (Sui dry-run is the safety gate, but the
+ * UX is "did this just lie to me?") or cancel and re-prompt the LLM
+ * (loses the narrative thread). The Quote-Refresh ReviewCard adds a
+ * third option: an explicit REGENERATE button that re-fires the
+ * upstream reads (no LLM call), rebuilds the bundle in place, and
+ * yields a fresh `pending_action` with new per-step `attemptId`s.
+ *
+ * **What this function does NOT do.**
+ *  - Run the LLM. Regenerate is "re-evaluate the same intent against
+ *    fresh state" — the writes' tool names + inputs stay identical;
+ *    only the upstream read TIMESTAMPS change (and any downstream
+ *    derivations the host made off them).
+ *  - Run the bundle on-chain. The host still presents the new
+ *    PermissionCard for confirmation; user can approve, regenerate
+ *    again, or deny.
+ *  - Mutate `TurnMetrics` rows. The host route owns analytics — see
+ *    `audric/apps/web/app/api/engine/regenerate/route.ts`.
+ *
+ * **Spec 1 / Spec 2 invariants preserved.**
+ *  - Each regeneration produces its own per-step `attemptId` (UUID v4),
+ *    so the host can write a fresh `TurnMetrics` row keyed on it.
+ *  - The original `pending_action`'s `attemptId` stays valid for the
+ *    host's `pendingActionOutcome = 'regenerated'` update — no
+ *    accidental over-write of the original row.
+ *
+ * **Why synchronous (no SSE).** The chat stream that originally
+ * yielded the bundled `pending_action` has already closed by the time
+ * the user taps Regenerate (`useEngine.ts` flips `isStreaming: false`
+ * on `pending_action`). Reopening a stream for a sub-second round-trip
+ * would be heavier than the host needs. Instead, the host endpoint
+ * calls this function synchronously and returns
+ * `{ success, newPendingAction, timelineEvents[] }` in the response
+ * body — host renders `timelineEvents[]` as a "↻ Regenerated · Ns"
+ * group above the new card.
+ */
+
+/**
+ * One event in the `timelineEvents[]` array returned to the host.
+ * Mirrors the engine's normal SSE event shapes for `tool_start` and
+ * `tool_result` so the host can push them onto its timeline as if they
+ * had streamed live.
+ */
+type RegenerateTimelineEvent = {
+    type: 'tool_start';
+    toolName: string;
+    toolUseId: string;
+    input: unknown;
+} | {
+    type: 'tool_result';
+    toolName: string;
+    toolUseId: string;
+    result: unknown;
+    isError: boolean;
+    durationMs: number;
+};
+interface RegenerateSuccess {
+    success: true;
+    /**
+     * Fresh `pending_action` with new per-step `attemptId`s. The host
+     * swaps this in for the original `PermissionCard` payload; the
+     * existing PermissionCard renderer requires no changes — it sees a
+     * fresh action with a fresh `quoteAge` of ~0ms.
+     */
+    newPendingAction: PendingAction;
+    /**
+     * Re-fired upstream read events the host renders as a
+     * "↻ Regenerated · Ns" group above the new card. Order: every
+     * `tool_start` for one read is paired with its `tool_result`; reads
+     * are processed serially (so durations sum cleanly for the group
+     * label).
+     */
+    timelineEvents: RegenerateTimelineEvent[];
+}
+interface RegenerateFailure {
+    success: false;
+    reason: 'pending_action_not_found' | 'cannot_regenerate' | 'engine_error';
+    message: string;
+}
+type RegenerateResult = RegenerateSuccess | RegenerateFailure;
+/**
+ * Re-fire the upstream reads that fed a bundled pending_action and
+ * compose a fresh bundle. The engine MUST be created with the same
+ * tool registry + ToolContext as the chat turn that produced the
+ * original action. The host typically reaches this by calling
+ * `createEngine({ address, session })` on the same session that
+ * persisted the pending_action.
+ *
+ * **Side effect.** On success, this mutates the engine's message
+ * history by appending one synthetic assistant message (carrying the
+ * regenerated `tool_use` blocks) and one user message (carrying the
+ * fresh `tool_result` blocks). This is so the LLM sees the fresh
+ * data when the user approves the new bundle and the engine resumes.
+ * The host should persist `engine.getMessages()` back to its session
+ * store after a successful regenerate.
+ *
+ * **Failure modes.**
+ *  - `pending_action_not_found` — the action isn't a bundle (no
+ *    `steps`, or fewer than 2 steps). Single-write actions can't be
+ *    regenerated by design.
+ *  - `cannot_regenerate` — the action's `canRegenerate` flag is
+ *    false, OR no contributing read tool_use_ids could be located in
+ *    session history.
+ *  - `engine_error` — a tool re-execution threw, OR bundle
+ *    composition rejected (defensive — should not happen if the
+ *    original bundle was valid).
+ *
+ * Errors in tool re-execution short-circuit the whole regenerate
+ * (bundle composition would inherit a broken read result). The host
+ * surfaces this as a toast: "Could not regenerate. The original card
+ * is still valid."
+ */
+declare function regenerateBundle(engine: QueryEngine, action: PendingAction): Promise<RegenerateResult>;
+
 interface BuildToolOptions<TInput, TOutput> {
     name: string;
     description: string;
@@ -1614,6 +1907,11 @@ declare class MemorySessionStore implements SessionStore {
  *   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)
+ *   bundleable      — [SPEC 7 Layer 2] can participate in a multi-write Payment Stream
+ *                     PTB. Set on every confirm-tier write whose on-chain effect is
+ *                     fully expressible at compose time. Excluded: `pay_api` (recipient/
+ *                     amount/currency unknown until gateway 402 challenge resolves at
+ *                     route time) and `save_contact` (Postgres-only, no on-chain effect).
  */
 declare const TOOL_FLAGS: Record<string, ToolFlags>;
 /**
@@ -1625,6 +1923,18 @@ 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;
+/**
+ * [SPEC 7 P2.5 Layer 4] True if this tool is in the v1 bundleable set.
+ *
+ * Used by the recipe loader's `bundle: true` validation — recipes that
+ * declare `bundle: true` on a step MUST point to a tool that returns
+ * `true` here. The set is the 9 confirm-tier write tools whose on-chain
+ * effect is fully expressible at compose time:
+ *
+ *   save_deposit, withdraw, borrow, repay_debt, send_transfer,
+ *   swap_execute, claim_rewards, volo_stake, volo_unstake.
+ */
+declare function isBundleableTool(name: string): boolean;
 
 /**
  * Routes each turn to the appropriate thinking effort level based on
@@ -3338,4 +3648,4 @@ declare function getTelemetrySink(): TelemetrySink;
 /** Restore the default noop sink. Used by test teardowns. */
 declare function resetTelemetrySink(): void;
 
-export { type AddressPortfolio, AnthropicProvider, type AnthropicProviderConfig, type AudricHistoryRecord, type AudricPortfolioResult, type AwaitOrFetchOpts, 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_LEASE_SEC, DEFAULT_PERMISSION_CONFIG, DEFAULT_POLL_BUDGET_MS, DEFAULT_POLL_INTERVAL_MS, DEFAULT_SYSTEM_PROMPT, type DefiCacheEntry, type DefiCacheStore, type DefiProtocol, type DefiSummary, EFFORT_THINKING_BUDGET_CAPS, EarlyToolDispatcher, type EngineConfig, type EngineEvent, type EvalSummaryParseResult, type EvaluationItem, type EvaluationStatus, type FetchLock, type GuardCheckResult, type GuardConfig, type GuardEvent, type GuardInjection, type GuardResult, type GuardRunnerState, type GuardTier, type GuardVerdict, type HarnessShape, type HealthFactorResult, InMemoryDefiCacheStore, InMemoryFetchLock, InMemoryNaviCacheStore, InMemoryWalletCacheStore, InvalidAddressError, type LLMProvider, type McpCallResult, McpClientManager, McpResponseCache, type McpServerConfig, type McpServerConnection, type McpToolAdapterConfig, type McpToolDescriptor, MemorySessionStore, type Message, NAVI_ADDR_TTL_SEC, NAVI_MCP_CONFIG, NAVI_MCP_URL, NAVI_RATES_TTL_SEC, NAVI_SERVER_NAME, type NaviCacheEntry, type NaviCacheStore, type NaviRawCoin, type NaviRawHealthFactor, type NaviRawPool, type NaviRawPosition, type NaviRawPositionsResponse, type NaviRawProtocolStats, type NaviRawRewardsResponse, type NaviReadOptions, NaviTools, type NormalizedAddress, type OutputConfig, PERMISSION_PRESETS, type PendingAction, type PendingActionModifiableField, type PendingReward, type PendingToolCall, type PermissionLevel, type PermissionOperation, type PermissionResponse, type PermissionRule, type PortfolioCoin, 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, SUINS_NAME_REGEX, SUI_ADDRESS_REGEX, SUI_ADDRESS_STRICT_REGEX, type SavingsResult, type ServerPositionData, type SessionData, type SessionStore, type StateType, type StopReason, type SuiCoinBalance, SuinsNotRegisteredError, SuinsRpcError, type SystemBlock, type SystemPrompt, TOOL_FLAGS, TOOL_MODIFIABLE_FIELDS, type TelemetrySink, type TelemetryTags, type ThinkingConfig, type ThinkingEffort, type TodoItem$1 as TodoItem, type Tool, type ToolChoice, type ToolContext, type ToolDefinition, type ToolFlags, type ToolJsonSchema, type ToolResult, TxMutex, type UpdateTodoInput, type TodoItem as UpdateTodoItem, type UserFinancialProfile, type UserPermissionConfig, WRITE_TOOLS, type WalletCacheEntry, type WalletCacheStore, type WalletCoin, _resetNaviCircuitBreaker, activitySummaryTool, adaptAllMcpTools, adaptAllServerTools, adaptMcpTool, applyToolFlags, awaitOrFetch, balanceCheckTool, borrowTool, budgetToolResult, buildCachedSystemPrompt, buildMcpTools, buildProactivenessInstructions, buildProfileContext, buildSelfEvaluationInstruction, buildStateContext, buildTool, claimRewardsTool, clampThinkingForEffort, classifyEffort, clearPortfolioCache, clearPortfolioCacheFor, clearPriceMapCache, compactMessages, createGuardRunnerState, engineToSSE, estimateTokens, explainTxTool, extractConversationText, extractMcpText, fetchAddressDefiPortfolio, fetchAddressPortfolio, fetchAudricHistory, fetchAudricPortfolio, fetchAvailableRewards, fetchBalance, fetchHealthFactor, fetchPositions, fetchProtocolStats, fetchRates, fetchSavings, fetchTokenPrices, fetchWalletCoins, findTool, getAudricApiBase, getDefaultTools, getDefiCacheStore, getFetchLock, getMcpManager, getModifiableFields, getNaviCacheStore, getTelemetrySink, getToolFlags, getWalletAddress, getWalletCacheStore, guardArtifactPreview, guardStaleData, harnessShapeForEffort, hasNaviMcp, healthCheckTool, loadRecipes, looksLikeSuiNs, microcompact, mppServicesTool, naviKey, normalizeAddressInput, parseEvalSummary, parseMcpJson, parseRecipe, parseSSE, payApiTool, portfolioAnalysisTool, protocolDeepDiveTool, ratesInfoTool, registerEngineTools, renderCanvasTool, repayDebtTool, requireAgent, resetDefiCacheStore, resetFetchLock, resetNaviCacheStore, resetTelemetrySink, resetWalletCacheStore, resolveAddressToSuinsViaRpc, resolvePermissionTier, resolveSuinsTool, resolveSuinsViaRpc, resolveUsdValue, runGuards, runTools, saveContactTool, saveDepositTool, savingsInfoTool, sendTransferTool, serializeSSE, setDefiCacheStore, setFetchLock, setNaviCacheStore, setTelemetrySink, setWalletCacheStore, spendingAnalyticsTool, swapExecuteTool, swapQuoteTool, tokenPricesTool, toolNameToOperation, toolsToDefinitions, transactionHistoryTool, transformBalance, transformHealthFactor, transformPositions, transformRates, transformRewards, transformSavings, updateGuardStateAfterToolResult, updateTodoTool, validateHistory, voloStakeTool, voloStatsTool, voloUnstakeTool, webSearchTool, withdrawTool, yieldSummaryTool };
+export { type AddressPortfolio, AnthropicProvider, type AnthropicProviderConfig, type AudricHistoryRecord, type AudricPortfolioResult, type AwaitOrFetchOpts, 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_LEASE_SEC, DEFAULT_PERMISSION_CONFIG, DEFAULT_POLL_BUDGET_MS, DEFAULT_POLL_INTERVAL_MS, DEFAULT_SYSTEM_PROMPT, DEFAULT_TOOL_TTL_MS, type DefiCacheEntry, type DefiCacheStore, type DefiProtocol, type DefiSummary, EFFORT_THINKING_BUDGET_CAPS, EarlyToolDispatcher, type EngineConfig, type EngineEvent, type EvalSummaryParseResult, type EvaluationItem, type EvaluationStatus, type FetchLock, type GuardCheckResult, type GuardConfig, type GuardEvent, type GuardInjection, type GuardResult, type GuardRunnerState, type GuardTier, type GuardVerdict, type HarnessShape, type HealthFactorResult, InMemoryDefiCacheStore, InMemoryFetchLock, InMemoryNaviCacheStore, InMemoryWalletCacheStore, InvalidAddressError, type LLMProvider, type McpCallResult, McpClientManager, McpResponseCache, type McpServerConfig, type McpServerConnection, type McpToolAdapterConfig, type McpToolDescriptor, MemorySessionStore, type Message, NAVI_ADDR_TTL_SEC, NAVI_MCP_CONFIG, NAVI_MCP_URL, NAVI_RATES_TTL_SEC, NAVI_SERVER_NAME, type NaviCacheEntry, type NaviCacheStore, type NaviRawCoin, type NaviRawHealthFactor, type NaviRawPool, type NaviRawPosition, type NaviRawPositionsResponse, type NaviRawProtocolStats, type NaviRawRewardsResponse, type NaviReadOptions, NaviTools, type NormalizedAddress, type OutputConfig, PERMISSION_PRESETS, type PendingAction, type PendingActionModifiableField, type PendingActionStep, type PendingReward, type PendingToolCall, type PermissionLevel, type PermissionOperation, type PermissionResponse, type PermissionRule, type PortfolioCoin, type PositionEntry, type PreflightResult, type ProtocolStats, type ProviderEvent, QueryEngine, READ_TOOLS, REGENERATABLE_READ_TOOLS, type RatesResult, type Recipe, type RecipePrerequisite, RecipeRegistry, type RecipeStep, type RecipeStepOnError, type RegenerateFailure, type RegenerateResult, type RegenerateSuccess, type RegenerateTimelineEvent, RetryTracker, type SSEEvent, SUINS_NAME_REGEX, SUI_ADDRESS_REGEX, SUI_ADDRESS_STRICT_REGEX, type SavingsResult, type ServerPositionData, type SessionData, type SessionStore, type StateType, type StopReason, type SuiCoinBalance, SuinsNotRegisteredError, SuinsRpcError, type SystemBlock, type SystemPrompt, TOOL_FLAGS, TOOL_MODIFIABLE_FIELDS, TOOL_TTL_MS, type TelemetrySink, type TelemetryTags, type ThinkingConfig, type ThinkingEffort, type TodoItem$1 as TodoItem, type Tool, type ToolChoice, type ToolContext, type ToolDefinition, type ToolFlags, type ToolJsonSchema, type ToolResult, TxMutex, type UpdateTodoInput, type TodoItem as UpdateTodoItem, type UserFinancialProfile, type UserPermissionConfig, WRITE_TOOLS, type WalletCacheEntry, type WalletCacheStore, type WalletCoin, _resetNaviCircuitBreaker, activitySummaryTool, adaptAllMcpTools, adaptAllServerTools, adaptMcpTool, applyToolFlags, awaitOrFetch, balanceCheckTool, borrowTool, budgetToolResult, buildCachedSystemPrompt, buildMcpTools, buildProactivenessInstructions, buildProfileContext, buildSelfEvaluationInstruction, buildStateContext, buildTool, bundleShortestTtl, claimRewardsTool, clampThinkingForEffort, classifyEffort, clearPortfolioCache, clearPortfolioCacheFor, clearPriceMapCache, compactMessages, createGuardRunnerState, engineToSSE, estimateTokens, explainTxTool, extractConversationText, extractMcpText, fetchAddressDefiPortfolio, fetchAddressPortfolio, fetchAudricHistory, fetchAudricPortfolio, fetchAvailableRewards, fetchBalance, fetchHealthFactor, fetchPositions, fetchProtocolStats, fetchRates, fetchSavings, fetchTokenPrices, fetchWalletCoins, findTool, getAudricApiBase, getDefaultTools, getDefiCacheStore, getFetchLock, getMcpManager, getModifiableFields, getNaviCacheStore, getTelemetrySink, getToolFlags, getWalletAddress, getWalletCacheStore, guardArtifactPreview, guardStaleData, harnessShapeForEffort, hasNaviMcp, healthCheckTool, isBundleableTool, loadRecipes, looksLikeSuiNs, microcompact, mppServicesTool, naviKey, normalizeAddressInput, parseEvalSummary, parseMcpJson, parseRecipe, parseSSE, payApiTool, portfolioAnalysisTool, protocolDeepDiveTool, ratesInfoTool, regenerateBundle, registerEngineTools, renderCanvasTool, repayDebtTool, requireAgent, resetDefiCacheStore, resetFetchLock, resetNaviCacheStore, resetTelemetrySink, resetWalletCacheStore, resolveAddressToSuinsViaRpc, resolvePermissionTier, resolveSuinsTool, resolveSuinsViaRpc, resolveUsdValue, runGuards, runTools, saveContactTool, saveDepositTool, savingsInfoTool, sendTransferTool, serializeSSE, setDefiCacheStore, setFetchLock, setNaviCacheStore, setTelemetrySink, setWalletCacheStore, spendingAnalyticsTool, swapExecuteTool, swapQuoteTool, tokenPricesTool, toolNameToOperation, toolsToDefinitions, transactionHistoryTool, transformBalance, transformHealthFactor, transformPositions, transformRates, transformRewards, transformSavings, updateGuardStateAfterToolResult, updateTodoTool, validateHistory, voloStakeTool, voloStatsTool, voloUnstakeTool, webSearchTool, withdrawTool, yieldSummaryTool };