@t2000/engine 1.3.0 → 1.5.0

package/README.md

@@ -261,8 +261,11 @@ The `submitMessage()` async generator yields `EngineEvent`:
 | Event | Fields | When |
 |-------|--------|------|
 | `text_delta` | `text` | LLM streams a text chunk |
-| `thinking_delta` | `text` | Extended thinking chunk (reasoning accordion) |
-| `thinking_done` | — | Extended thinking complete |
+| `thinking_delta` | `text`, `blockIndex` | Extended thinking chunk (reasoning accordion). **`blockIndex`** identifies which thinking block this delta belongs to so hosts can render multi-block thinking chronologically (Anthropic streams ≥1 thinking blocks per turn at high effort). |
+| `thinking_done` | `blockIndex`, `signature?`, `summaryMode?`, `evaluationItems?` | Extended thinking block complete. `blockIndex` matches the `thinking_delta` events for that block. **`summaryMode`** flips true and **`evaluationItems`** is populated when the block contained a parseable `<eval_summary>` marker — hosts render `HowIEvaluatedBlock` ("✦ HOW I EVALUATED THIS") from these fields. |
+| `todo_update` | `items`, `toolUseId` | **[SPEC 8 v0.5.1]** Side-channel event paired to every `update_todo` tool call. `items` is the full `TodoItem[]` array; hosts unconditionally replace their rendered list (the tool is idempotent). `toolUseId` keys the render to the originating call. |
+| `tool_progress` | `toolUseId`, `toolName`, `message`, `pct?` | **[SPEC 8 v0.5.1]** Mid-execution progress signal from long-running tools (Cetus swap, protocol_deep_dive, portfolio_analysis). Tools opt in via `context.progress?.(msg, pct?)`. Engine wiring lands with the Cetus SDK integration in a follow-on slice. |
+| `pending_input` | `schema`, `inputId`, `prompt?` | **[SPEC 8 v0.5.1, D2]** Reserved for SPEC 9 v0.1.2 inline forms. Engine doesn't emit under SPEC 8 — host adds a no-op handler now to avoid crashing when SPEC 9 ships emission. |
 | `tool_start` | `toolName`, `toolUseId`, `input` | Tool execution begins |
 | `tool_result` | `toolName`, `toolUseId`, `result`, `isError` | Tool execution completes |
 | `pending_action` | `action` (PendingAction with `attemptId`, `toolUseId`, `turnIndex`, `name`, `input`) | Write tool awaiting client-side execution. `attemptId` is a per-yield UUID — hosts persist it on TurnMetrics and key the resume `updateMany` on it (avoids ambiguous `(sessionId, turnIndex)` updates) |

package/dist/index.d.ts

@@ -393,7 +393,11 @@ interface AddressPortfolio {
  *     overwrite — preserves the original `pricedAt` so a UI can
  *     render "last refresh Nm ago".
  */
-declare function fetchAddressPortfolio(address: string, apiKey: string | undefined, fallbackRpcUrl?: string): Promise<AddressPortfolio>;
+declare function fetchAddressPortfolio(address: string, apiKey: string | undefined, fallbackRpcUrl?: string, opts?: {
+    retryStats?: {
+        attemptCount: number;
+    };
+}): Promise<AddressPortfolio>;
 /**
  * Multi-token price lookup. Returns a map of coinType → `{ price, change24h }`
  * with the `change24h` field populated when BlockVision returns it.
@@ -404,7 +408,11 @@ declare function fetchAddressPortfolio(address: string, apiKey: string | undefin
  * requested coins fetches only the missing 2 instead of throwing the
  * whole map away.
  */
-declare function fetchTokenPrices(coinTypes: string[], apiKey: string | undefined): Promise<Record<string, {
+declare function fetchTokenPrices(coinTypes: string[], apiKey: string | undefined, opts?: {
+    retryStats?: {
+        attemptCount: number;
+    };
+}): Promise<Record<string, {
     price: number;
     change24h?: number;
 }>>;
@@ -431,7 +439,11 @@ interface DefiSummary {
      */
     source: 'blockvision' | 'partial' | 'partial-stale' | 'degraded';
 }
-declare function fetchAddressDefiPortfolio(address: string, apiKey: string | undefined, priceHints?: Record<string, number>): Promise<DefiSummary>;
+declare function fetchAddressDefiPortfolio(address: string, apiKey: string | undefined, priceHints?: Record<string, number>, opts?: {
+    retryStats?: {
+        attemptCount: number;
+    };
+}): Promise<DefiSummary>;
 /**
  * Wipe the wallet portfolio cache plus any in-flight promises.
  *
@@ -584,6 +596,34 @@ declare function toolNameToOperation(toolName: string): PermissionOperation | un
  */
 declare function resolveUsdValue(toolName: string, input: Record<string, unknown>, priceCache: Map<string, number>): number;
 
+type EvaluationStatus = 'good' | 'warning' | 'critical' | 'info';
+interface EvaluationItem {
+    label: string;
+    status: EvaluationStatus;
+    note?: string;
+}
+interface EvalSummaryParseResult {
+    /** Always true when this object is returned (vs null when absent). */
+    summaryMode: true;
+    /** The structured rows the host renders inside the trust card. */
+    evaluationItems: EvaluationItem[];
+    /** Count of markers detected — >1 indicates an LLM compliance violation. */
+    markerCount: number;
+}
+/**
+ * Scan a thinking-block text for one or more `<eval_summary>` markers.
+ *
+ * - Returns null when no marker is present, or when the first marker's
+ *   JSON is malformed (host falls back to standard rendering).
+ * - Returns a parsed result when at least one marker contains valid JSON.
+ *   `markerCount` reflects the total number of markers seen so the
+ *   engine can emit a `evalSummaryViolationsCount` telemetry counter
+ *   when N > 1 (LLM is supposed to emit at most one per turn).
+ *
+ * The function is pure — safe to call per-thinking-block.
+ */
+declare function parseEvalSummary(thinkingText: string): EvalSummaryParseResult | null;
+
 type ContentBlock = {
     type: 'text';
     text: string;
@@ -609,12 +649,34 @@ interface Message {
     role: 'user' | 'assistant';
     content: ContentBlock[];
 }
-type EngineEvent = {
+type EngineEvent = 
+/**
+ * [SPEC 8 v0.5.1] `blockIndex` identifies which thinking block this delta
+ * belongs to. Anthropic streams multi-block thinking with rising indices
+ * across each turn (block 0, 1, 2, ...). Hosts use this to render
+ * chronologically interleaved thinking accordions instead of flattening
+ * every delta into one string. Backwards-compatible: older hosts that
+ * ignore the field still see deltas in emission order.
+ */
+{
     type: 'thinking_delta';
     text: string;
-} | {
+    blockIndex: number;
+}
+/**
+ * [SPEC 8 v0.5.1] When the thinking block contained a parseable
+ * `<eval_summary>...</eval_summary>` marker, `summaryMode` flips true
+ * and `evaluationItems` carries the structured rows. Hosts render the
+ * `HowIEvaluatedBlock` ("✦ HOW I EVALUATED THIS") trust card from
+ * these fields. Both undefined when the block had no marker (every
+ * read-only and most write turns).
+ */
+ | {
     type: 'thinking_done';
+    blockIndex: number;
     signature?: string;
+    summaryMode?: boolean;
+    evaluationItems?: EvaluationItem[];
 } | {
     type: 'text_delta';
     text: string;
@@ -651,6 +713,22 @@ type EngineEvent = {
      * UI affordances (e.g. a subtle "auto-refreshed" badge).
      */
     wasPostWriteRefresh?: boolean;
+    /**
+     * [SPEC 8 v0.5.1 B3.2] Number of HTTP attempts the tool made before
+     * succeeding (or returning the final result). Surfaced when the tool
+     * went through one or more retries inside its retry wrapper
+     * (`fetchBlockVisionWithRetry` and equivalents). Set ONLY when N > 1
+     * — a successful first try leaves the field undefined to avoid
+     * header noise in the host's `ToolBlockView`. Hosts render
+     * "TOOL · attempt N · 1.4s" subtitle when present, hidden otherwise.
+     *
+     * Plumbing: engine sets a per-tool `retryStats: { attemptCount: 1 }`
+     * counter on `ToolContext`; the BlockVision retry wrapper increments
+     * it on every retry attempt; the engine reads it back after the tool
+     * returns and surfaces here when > 1. Tools that don't use a retry
+     * wrapper never emit a value.
+     */
+    attemptCount?: number;
 } | {
     type: 'pending_action';
     action: PendingAction;
@@ -682,7 +760,115 @@ type EngineEvent = {
  */
  | {
     type: 'compaction';
+}
+/**
+ * [SPEC 8 v0.5.1] Side-channel event paired to every `update_todo` tool
+ * call. Hosts render the persistent todo card from this event (NOT from
+ * the tool_result — see `tools/update-todo.ts` § "side-channel" for
+ * rationale). Carries the full items array so the host can
+ * unconditionally replace its rendered list (the tool is idempotent —
+ * each call replaces the previous state). `toolUseId` lets the host
+ * key the render cell to the originating tool call.
+ */
+ | {
+    type: 'todo_update';
+    items: TodoItem$1[];
+    toolUseId: string;
+}
+/**
+ * [SPEC 8 v0.5.1] Mid-execution progress signal from a long-running tool
+ * (Cetus swap_execute 2-5s, protocol_deep_dive 3-8s, portfolio_analysis
+ * 1-2s). Tools opt in by calling `context.progress?.(msg, pct?)` from
+ * inside their `call` implementation. Hosts render the message + bar
+ * inside the corresponding tool block's spinner — kills the dead-air
+ * static-spinner UX that's the explicit SPEC 8 v0.3 fix target.
+ *
+ * Engine wiring (queue-and-yield in the dispatcher) lands with the
+ * Cetus integration in a follow-on slice. SPEC 8 v0.5.1 reserves the
+ * event type now so hosts can pre-wire the renderer.
+ *
+ * `pct` is 0–100 when the tool can express progress quantitatively,
+ * undefined otherwise (free-text status only).
+ */
+ | {
+    type: 'tool_progress';
+    toolUseId: string;
+    toolName: string;
+    message: string;
+    pct?: number;
+}
+/**
+ * [SPEC 8 v0.5.1, D2] Inline-form structured input event reserved for
+ * SPEC 9 v0.1.2 (`pending_input` form primitive). The engine does NOT
+ * emit this event under SPEC 8 — the type is reserved so legacy hosts
+ * can add a no-op handler now and avoid crashing when SPEC 9 ships
+ * `pending_input` emission. See SPEC 8 § "v0.5 cross-spec coupling
+ * fixes" — gap D2 — for the forward-compat rationale.
+ */
+ | {
+    type: 'pending_input';
+    /** Form schema (shape locked in SPEC 9 v0.1.2; engine treats it opaquely). */
+    schema: unknown;
+    /** Engine round-trip identifier — host posts the answer back keyed on this. */
+    inputId: string;
+    /** Optional human-readable prompt the LLM wants the host to display above the form. */
+    prompt?: string;
+}
+/**
+ * [SPEC 8 v0.5.1 B3.2] One-shot per-turn declaration of which adaptive
+ * harness shape this turn is running under. Emitted at the start of
+ * `submitMessage` BEFORE `agentLoop` begins (not on `resumeWithToolResult`
+ * — resume is a continuation of the same turn, not a new shape decision).
+ *
+ * Derived from `classifyEffort()` on the host side: `low → 'lean'`,
+ * `medium → 'standard'`, `high → 'rich'`, `max → 'max'`. Hosts use it
+ * to (a) pre-allocate UI affordances (todo surface for `rich+`),
+ * (b) stamp `TurnMetrics.harnessShape` for dashboard segmentation,
+ * and (c) gate optional features (e.g. forbid `update_todo` rendering
+ * on `lean` even if a misbehaving LLM emits one).
+ *
+ * If absent, hosts MUST default to `'legacy'` for telemetry purposes
+ * (existing engines that don't emit this event are pre-SPEC-8). The
+ * engine emits it ONLY when the host passes `harnessShape` into
+ * `submitMessage` options; hosts that don't classify won't see this
+ * event.
+ */
+ | {
+    type: 'harness_shape';
+    shape: HarnessShape;
+    /**
+     * 1-line human-readable explanation of why this shape was picked.
+     * Examples: "matched recipe portfolio_rebalance → max",
+     * "session has prior writes + 'borrow' keyword → rich",
+     * "single-fact lookup → lean". Forwarded into telemetry verbatim.
+     */
+    rationale: string;
 };
+/**
+ * [SPEC 8 v0.5.1 B3.2] Adaptive harness shape — driven by `classifyEffort()`,
+ * pinned per-turn at turn start. Each shape implies a different
+ * `thinking.budget_tokens` cap, soft block limit, and `update_todo`
+ * permission. See SPEC 8 § "Adaptive thresholds: harness shape gate"
+ * for the canonical mapping.
+ */
+type HarnessShape = 'lean' | 'standard' | 'rich' | 'max';
+/**
+ * [SPEC 8 v0.5.1 B3.2] Maps the engine's `ThinkingEffort` to the host-facing
+ * harness shape. Single source of truth for the `low → lean`, `medium →
+ * standard`, `high → rich`, `max → max` mapping. Exported so hosts (and
+ * tests) get the mapping for free without re-implementing it.
+ */
+declare function harnessShapeForEffort(effort: ThinkingEffort): HarnessShape;
+/**
+ * [SPEC 8 v0.5.1] One row in an `update_todo` payload. Mirrored from
+ * `packages/engine/src/tools/update-todo.ts`. Kept here so hosts that
+ * consume `EngineEvent` don't need to depend on the tool module.
+ */
+interface TodoItem$1 {
+    id: string;
+    label: string;
+    status: 'pending' | 'in_progress' | 'completed';
+}
 type StopReason = 'end_turn' | 'tool_use' | 'max_tokens' | 'max_turns' | 'error';
 /**
  * [v1.4 Item 6] Describes a single input field on a `PendingAction` that
@@ -807,6 +993,23 @@ interface ToolContext {
      * primarily a fast-path optimisation rather than a correctness primitive.
      */
     portfolioCache?: Map<string, AddressPortfolio>;
+    /**
+     * [SPEC 8 v0.5.1 B3.2] Per-tool-invocation HTTP attempt counter. The
+     * engine's tool dispatcher attaches a fresh `{ attemptCount: 1 }` to
+     * the context before calling each tool; retry wrappers
+     * (`fetchBlockVisionWithRetry` and equivalents) bump
+     * `retryStats.attemptCount` on every retry beyond the first attempt;
+     * the dispatcher reads the final value back and surfaces it on the
+     * `tool_result` event (only when > 1). Tools that don't use a retry
+     * wrapper never observe a non-default value.
+     *
+     * The mutable-ref shape is deliberate — it lets retry wrappers deep
+     * in the call stack record state without changing every caller's
+     * return type.
+     */
+    retryStats?: {
+        attemptCount: number;
+    };
 }
 interface ServerPositionData {
     savings: number;
@@ -1057,10 +1260,14 @@ interface ToolDefinition {
 type ProviderEvent = {
     type: 'thinking_delta';
     text: string;
+    blockIndex: number;
 } | {
     type: 'thinking_done';
+    blockIndex: number;
     thinking: string;
     signature: string;
+    summaryMode?: boolean;
+    evaluationItems?: EvaluationItem[];
 } | {
     type: 'redacted_thinking';
     data: string;
@@ -1172,8 +1379,20 @@ declare class QueryEngine {
      * `pending_action` event and the stream ends — no persistent connection needed.
      * The caller should save messages + pendingAction to the session store, then
      * call `resumeWithToolResult()` after the user approves/denies and executes.
+     *
+     * [SPEC 8 v0.5.1 B3.2] Optional `options.harnessShape` + `options.harnessRationale`
+     * cause a one-shot `harness_shape` event to be yielded BEFORE the agent loop
+     * begins. The engine itself doesn't classify — the host calls
+     * `classifyEffort()` (host already does this for thinking-budget routing)
+     * and maps via `harnessShapeForEffort()` before calling `submitMessage`.
+     * Hosts that don't pass `harnessShape` won't see the event (existing
+     * pre-SPEC-8 hosts continue to work; their `TurnMetrics.harnessShape`
+     * defaults to `'legacy'`).
      */
-    submitMessage(prompt: string): AsyncGenerator<EngineEvent>;
+    submitMessage(prompt: string, options?: {
+        harnessShape?: HarnessShape;
+        harnessRationale?: string;
+    }): AsyncGenerator<EngineEvent>;
     /**
      * Resume the conversation after a pending action is resolved.
      * Called with the user's approval/denial and optional client-side execution result.
@@ -1276,9 +1495,13 @@ declare function findTool(tools: Tool[], name: string): Tool | undefined;
 type SSEEvent = {
     type: 'thinking_delta';
     text: string;
+    blockIndex: number;
 } | {
     type: 'thinking_done';
+    blockIndex: number;
     signature?: string;
+    summaryMode?: boolean;
+    evaluationItems?: EvaluationItem[];
 } | {
     type: 'text_delta';
     text: string;
@@ -1296,6 +1519,7 @@ type SSEEvent = {
     wasEarlyDispatched?: boolean;
     resultDeduped?: boolean;
     wasPostWriteRefresh?: boolean;
+    attemptCount?: number;
 } | {
     type: 'pending_action';
     action: PendingAction;
@@ -1317,6 +1541,25 @@ type SSEEvent = {
     data: unknown;
     title: string;
     toolUseId: string;
+} | {
+    type: 'todo_update';
+    items: TodoItem$1[];
+    toolUseId: string;
+} | {
+    type: 'tool_progress';
+    toolUseId: string;
+    toolName: string;
+    message: string;
+    pct?: number;
+} | {
+    type: 'pending_input';
+    schema: unknown;
+    inputId: string;
+    prompt?: string;
+} | {
+    type: 'harness_shape';
+    shape: HarnessShape;
+    rationale: string;
 };
 declare function serializeSSE(event: SSEEvent): string;
 declare function parseSSE(raw: string): SSEEvent | null;
@@ -1392,6 +1635,24 @@ declare function getToolFlags(name: string): ToolFlags;
  */
 declare function classifyEffort(model: string, userMessage: string, matchedRecipe: Recipe | null, sessionWriteCount: number): ThinkingEffort;
 
+declare const EFFORT_THINKING_BUDGET_CAPS: Record<ThinkingEffort, number | null>;
+/**
+ * Clamp a `ThinkingConfig` to the HARD cap for the given effort tier.
+ *
+ * - When `effort === 'low'`, returns `{ type: 'disabled' }` regardless of
+ *   input — LEAN tier is non-negotiable.
+ * - When `config.type === 'enabled'` and `config.budgetTokens` exceeds
+ *   the cap, returns a copy with `budgetTokens` clamped down.
+ * - When `config.type === 'adaptive'`, returns it unchanged — adaptive
+ *   mode is shape-agnostic by design (Anthropic decides per-turn).
+ * - When `effort` is undefined, returns `config` unchanged — caller
+ *   hasn't classified the turn yet (back-compat for hosts that don't
+ *   route on effort).
+ *
+ * This function is pure and side-effect-free; safe to call per-turn.
+ */
+declare function clampThinkingForEffort(config: ThinkingConfig | undefined, effort: ThinkingEffort | undefined): ThinkingConfig | undefined;
+
 /**
  * Build a cacheable system prompt array from static and dynamic parts.
  *
@@ -2435,6 +2696,63 @@ declare const resolveSuinsTool: Tool<{
     query: string;
 }, ResolveSuinsResult>;
 
+declare const todoItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    status: z.ZodEnum<["pending", "in_progress", "completed"]>;
+}, "strip", z.ZodTypeAny, {
+    label: string;
+    status: "pending" | "in_progress" | "completed";
+    id: string;
+}, {
+    label: string;
+    status: "pending" | "in_progress" | "completed";
+    id: string;
+}>;
+declare const inputSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        status: z.ZodEnum<["pending", "in_progress", "completed"]>;
+    }, "strip", z.ZodTypeAny, {
+        label: string;
+        status: "pending" | "in_progress" | "completed";
+        id: string;
+    }, {
+        label: string;
+        status: "pending" | "in_progress" | "completed";
+        id: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    items: {
+        label: string;
+        status: "pending" | "in_progress" | "completed";
+        id: string;
+    }[];
+}, {
+    items: {
+        label: string;
+        status: "pending" | "in_progress" | "completed";
+        id: string;
+    }[];
+}>;
+type TodoItem = z.infer<typeof todoItemSchema>;
+type UpdateTodoInput = z.infer<typeof inputSchema>;
+declare const updateTodoTool: Tool<{
+    items: {
+        label: string;
+        status: "pending" | "in_progress" | "completed";
+        id: string;
+    }[];
+}, {
+    __todoUpdate: boolean;
+    items: {
+        label: string;
+        status: "pending" | "in_progress" | "completed";
+        id: string;
+    }[];
+}>;
+
 declare const tokenPricesTool: Tool<{
     coinTypes: string[];
     include24hChange?: boolean | undefined;
@@ -3020,4 +3338,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, EarlyToolDispatcher, type EngineConfig, type EngineEvent, type FetchLock, type GuardCheckResult, type GuardConfig, type GuardEvent, type GuardInjection, type GuardResult, type GuardRunnerState, type GuardTier, type GuardVerdict, 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 Tool, type ToolChoice, type ToolContext, type ToolDefinition, type ToolFlags, type ToolJsonSchema, type ToolResult, TxMutex, 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, 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, hasNaviMcp, healthCheckTool, loadRecipes, looksLikeSuiNs, microcompact, mppServicesTool, naviKey, normalizeAddressInput, 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, 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, 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 };