@t2000/engine 0.31.3 → 0.33.0

package/dist/index.js

@@ -1,5 +1,8 @@
 import { z } from 'zod';
 import { resolveSymbol, getDecimalsForCoinType, assertAllowedAsset, getSwapQuote, SUI_TYPE } from '@t2000/sdk';
+import { readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+import yaml from 'js-yaml';
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
@@ -7,15 +10,18 @@ import Anthropic from '@anthropic-ai/sdk';
 
 // src/tool.ts
 function buildTool(opts) {
+  const isReadOnly = opts.isReadOnly ?? true;
   return {
     name: opts.name,
     description: opts.description,
     inputSchema: opts.inputSchema,
     jsonSchema: opts.jsonSchema,
     call: opts.call,
-    isReadOnly: opts.isReadOnly ?? true,
-    isConcurrencySafe: opts.isReadOnly ?? true,
-    permissionLevel: opts.permissionLevel ?? (opts.isReadOnly === false ? "confirm" : "auto")
+    isReadOnly,
+    isConcurrencySafe: isReadOnly,
+    permissionLevel: opts.permissionLevel ?? (isReadOnly ? "auto" : "confirm"),
+    flags: opts.flags ?? {},
+    preflight: opts.preflight
   };
 }
 function toolsToDefinitions(tools) {
@@ -152,6 +158,45 @@ async function executeSingleTool(tool, call, context) {
   const result = await tool.call(parsed.data, context);
   return { data: result.data, isError: false };
 }
+
+// src/tool-flags.ts
+var TOOL_FLAGS = {
+  // Write tools — financial
+  save_deposit: { mutating: true, requiresBalance: true },
+  withdraw: { mutating: true, affectsHealth: true },
+  send_transfer: { mutating: true, requiresBalance: true, irreversible: true },
+  swap_execute: { mutating: true, requiresBalance: true },
+  borrow: { mutating: true, affectsHealth: true },
+  repay_debt: { mutating: true, requiresBalance: true },
+  claim_rewards: { mutating: true },
+  volo_stake: { mutating: true, requiresBalance: true },
+  volo_unstake: { mutating: true },
+  // Write tools — pay / services
+  pay_api: { mutating: true, requiresBalance: true, costAware: true, producesArtifact: true, maxRetries: 1 },
+  // Write tools — lightweight (no financial guards)
+  save_contact: {},
+  create_schedule: { mutating: true },
+  cancel_schedule: { mutating: true },
+  // Allowance tools — API mutations disguised as reads
+  toggle_allowance: { mutating: true },
+  update_daily_limit: { mutating: true },
+  update_permissions: { mutating: true },
+  // Receive tools — create/cancel mutate server state
+  create_payment_link: { mutating: true },
+  cancel_payment_link: { mutating: true },
+  create_invoice: { mutating: true },
+  cancel_invoice: { mutating: true }
+};
+function applyToolFlags(tools) {
+  return tools.map((tool) => {
+    const flags = TOOL_FLAGS[tool.name];
+    if (!flags) return tool;
+    return { ...tool, flags: { ...tool.flags, ...flags } };
+  });
+}
+function getToolFlags(name) {
+  return TOOL_FLAGS[name] ?? {};
+}
 var SUI_MAINNET_URL = "https://fullnode.mainnet.sui.io:443";
 var EXTRA_COINS = {
   "0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c::coin::COIN": { symbol: "USDT", decimals: 6 }
@@ -1119,6 +1164,13 @@ var saveDepositTool = buildTool({
   },
   isReadOnly: false,
   permissionLevel: "confirm",
+  flags: { mutating: true, requiresBalance: true },
+  preflight: (input) => {
+    if (input.asset && input.asset.toUpperCase() !== "USDC") {
+      return { valid: false, error: `Only USDC deposits are supported. Got: "${input.asset}"` };
+    }
+    return { valid: true };
+  },
   async call(input, context) {
     assertAllowedAsset("save", input.asset);
     const agent = requireAgent(context);
@@ -1160,6 +1212,7 @@ var withdrawTool = buildTool({
   },
   isReadOnly: false,
   permissionLevel: "confirm",
+  flags: { mutating: true, affectsHealth: true },
   async call(input, context) {
     const agent = requireAgent(context);
     const result = await agent.withdraw({
@@ -1207,6 +1260,16 @@ var sendTransferTool = buildTool({
   },
   isReadOnly: false,
   permissionLevel: "confirm",
+  flags: { mutating: true, requiresBalance: true, irreversible: true },
+  preflight: (input) => {
+    if (input.to.startsWith("0x") && !/^0x[a-fA-F0-9]{64}$/.test(input.to)) {
+      return { valid: false, error: `Invalid Sui address format: "${input.to}". Must be 0x followed by 64 hex characters.` };
+    }
+    if (input.amount <= 0) {
+      return { valid: false, error: "Amount must be positive." };
+    }
+    return { valid: true };
+  },
   async call(input, context) {
     const agent = requireAgent(context);
     const result = await agent.send({ to: input.to, amount: input.amount });
@@ -1249,6 +1312,13 @@ var borrowTool = buildTool({
   },
   isReadOnly: false,
   permissionLevel: "confirm",
+  flags: { mutating: true, affectsHealth: true },
+  preflight: (input) => {
+    if (input.asset && input.asset.toUpperCase() !== "USDC") {
+      return { valid: false, error: `Only USDC borrows are supported. Got: "${input.asset}"` };
+    }
+    return { valid: true };
+  },
   async call(input, context) {
     assertAllowedAsset("borrow", input.asset);
     const agent = requireAgent(context);
@@ -1283,6 +1353,7 @@ var repayDebtTool = buildTool({
   },
   isReadOnly: false,
   permissionLevel: "confirm",
+  flags: { mutating: true, requiresBalance: true },
   async call(input, context) {
     const agent = requireAgent(context);
     const result = await agent.repay({ amount: input.amount });
@@ -1305,6 +1376,7 @@ var claimRewardsTool = buildTool({
   jsonSchema: { type: "object", properties: {}, required: [] },
   isReadOnly: false,
   permissionLevel: "confirm",
+  flags: { mutating: true },
   async call(_input, context) {
     const agent = requireAgent(context);
     const result = await agent.claimRewards();
@@ -1379,6 +1451,28 @@ Always use ISO-3166 country codes (GB not UK, US not USA). A return address ("fr
   },
   isReadOnly: false,
   permissionLevel: "confirm",
+  flags: { mutating: true, requiresBalance: true, costAware: true, producesArtifact: true, maxRetries: 1 },
+  preflight: (input) => {
+    if (!input.url.startsWith(MPP_GATEWAY)) {
+      return { valid: false, error: `URL must start with ${MPP_GATEWAY}. Got: "${input.url}"` };
+    }
+    if (input.body) {
+      try {
+        JSON.parse(input.body);
+      } catch {
+        return { valid: false, error: "body must be valid JSON." };
+      }
+      if (input.url.includes("lob/")) {
+        const body = JSON.parse(input.body);
+        const to = body.to;
+        const country = to?.address_country;
+        if (typeof country === "string" && country.length !== 2) {
+          return { valid: false, error: `Country must be ISO-3166 2-letter code (got "${country}")` };
+        }
+      }
+    }
+    return { valid: true };
+  },
   async call(input, context) {
     const agent = requireAgent(context);
     const result = await agent.pay({
@@ -1480,6 +1574,13 @@ var swapExecuteTool = buildTool({
   },
   isReadOnly: false,
   permissionLevel: "confirm",
+  flags: { mutating: true, requiresBalance: true },
+  preflight: (input) => {
+    if (input.from.toLowerCase() === input.to.toLowerCase()) {
+      return { valid: false, error: `Cannot swap ${input.from} to itself.` };
+    }
+    return { valid: true };
+  },
   async call(input, context) {
     const agent = requireAgent(context);
     const result = await agent.swap({
@@ -1554,6 +1655,7 @@ var voloStakeTool = buildTool({
   },
   isReadOnly: false,
   permissionLevel: "confirm",
+  flags: { mutating: true, requiresBalance: true },
   async call(input, context) {
     const agent = requireAgent(context);
     const result = await agent.stakeVSui({ amount: input.amount });
@@ -1584,6 +1686,7 @@ var voloUnstakeTool = buildTool({
   },
   isReadOnly: false,
   permissionLevel: "confirm",
+  flags: { mutating: true },
   async call(input, context) {
     const agent = requireAgent(context);
     const result = await agent.unstakeVSui({ amount: input.amount });
@@ -3416,7 +3519,7 @@ var WRITE_TOOLS = [
   cancelScheduleTool
 ];
 function getDefaultTools() {
-  return [...READ_TOOLS, ...WRITE_TOOLS];
+  return applyToolFlags([...READ_TOOLS, ...WRITE_TOOLS]);
 }
 
 // src/prompt.ts
@@ -3517,6 +3620,511 @@ var CostTracker = class {
   }
 };
 
+// src/guards.ts
+var DEFAULT_GUARD_CONFIG = {
+  balanceValidation: true,
+  healthFactor: { warnBelow: 2, blockBelow: 1.5 },
+  largeTransfer: { warnAbove: 50, strongWarnAbove: 500 },
+  slippage: true,
+  staleData: true,
+  irreversibility: true,
+  artifactPreview: true,
+  costWarning: true,
+  retryProtection: true,
+  inputValidation: true
+};
+var BalanceTracker = class {
+  lastBalanceAt = 0;
+  lastWriteAt = 0;
+  recordRead() {
+    this.lastBalanceAt = Date.now();
+  }
+  recordWrite() {
+    this.lastWriteAt = Date.now();
+  }
+  isStale() {
+    return this.lastWriteAt > this.lastBalanceAt;
+  }
+  hasEverRead() {
+    return this.lastBalanceAt > 0;
+  }
+};
+var BALANCE_READ_TOOLS = /* @__PURE__ */ new Set([
+  "balance_check",
+  "savings_info",
+  "health_check"
+]);
+var RetryTracker = class {
+  executed = /* @__PURE__ */ new Map();
+  key(toolName, input) {
+    const url = input?.url ?? "";
+    return `${toolName}:${url}`;
+  }
+  record(toolName, input, result) {
+    const r = result;
+    if (r?.paymentConfirmed || r?.doNotRetry) {
+      this.executed.set(this.key(toolName, input), { result, paidAt: Date.now() });
+    }
+  }
+  isBlocked(toolName, input) {
+    const prev = this.executed.get(this.key(toolName, input));
+    if (!prev) return { blocked: false };
+    return { blocked: true, previousResult: prev.result };
+  }
+};
+function guardRetryProtection(tool, call, retryTracker) {
+  const check = retryTracker.isBlocked(tool.name, call.input);
+  if (check.blocked) {
+    return {
+      verdict: "block",
+      gate: "retry_blocked",
+      tier: "safety",
+      message: `Blocked: ${tool.name} was already called and payment was confirmed. Do not retry.`
+    };
+  }
+  return { verdict: "pass", gate: "retry_blocked", tier: "safety" };
+}
+function guardIrreversibility(tool, _call, conversationText) {
+  if (!tool.flags.irreversible) {
+    return { verdict: "pass", gate: "irreversibility", tier: "safety" };
+  }
+  const hasPreview = /preview|here.s what|confirm.*send|looks? good/i.test(conversationText);
+  if (hasPreview) {
+    return { verdict: "pass", gate: "irreversibility", tier: "safety" };
+  }
+  return {
+    verdict: "hint",
+    gate: "irreversibility",
+    tier: "safety",
+    message: "This action is irreversible. Show a preview and ask the user to confirm before proceeding."
+  };
+}
+function guardBalanceValidation(tool, _call, balanceTracker) {
+  if (!tool.flags.requiresBalance) {
+    return { verdict: "pass", gate: "balance_required", tier: "financial" };
+  }
+  if (!balanceTracker.hasEverRead()) {
+    return {
+      verdict: "hint",
+      gate: "balance_required",
+      tier: "financial",
+      message: "Balance has not been checked this session. Call balance_check first to verify sufficient funds."
+    };
+  }
+  if (balanceTracker.isStale()) {
+    return {
+      verdict: "hint",
+      gate: "balance_required",
+      tier: "financial",
+      message: "Balance data is stale (a write action occurred since last check). Call balance_check first to verify sufficient funds."
+    };
+  }
+  return { verdict: "pass", gate: "balance_required", tier: "financial" };
+}
+function guardHealthFactor(tool, _call, lastHealthFactor, config) {
+  if (!tool.flags.affectsHealth) {
+    return { verdict: "pass", gate: "health_factor", tier: "financial" };
+  }
+  if (lastHealthFactor === null) {
+    return {
+      verdict: "hint",
+      gate: "health_factor",
+      tier: "financial",
+      message: "Health factor has not been checked this session. Call health_check before this action."
+    };
+  }
+  if (lastHealthFactor < config.blockBelow) {
+    return {
+      verdict: "block",
+      gate: "health_factor",
+      tier: "financial",
+      message: `Health factor is ${lastHealthFactor.toFixed(2)} \u2014 this action risks liquidation. Refusing.`
+    };
+  }
+  if (lastHealthFactor < config.warnBelow) {
+    return {
+      verdict: "warn",
+      gate: "health_factor",
+      tier: "financial",
+      message: `Health factor is ${lastHealthFactor.toFixed(2)} \u2014 this action may reduce it further.`
+    };
+  }
+  return { verdict: "pass", gate: "health_factor", tier: "financial" };
+}
+function guardLargeTransfer(tool, call, config) {
+  if (tool.name !== "send_transfer") {
+    return { verdict: "pass", gate: "large_transfer", tier: "financial" };
+  }
+  const input = call.input;
+  const amount = Number(input.amount ?? 0);
+  if (!amount || amount <= 0) {
+    return { verdict: "pass", gate: "large_transfer", tier: "financial" };
+  }
+  const recipient = String(input.recipient ?? input.to ?? "");
+  const shortAddr = recipient.length > 10 ? `${recipient.slice(0, 6)}...${recipient.slice(-4)}` : recipient;
+  if (amount > config.strongWarnAbove) {
+    return {
+      verdict: "warn",
+      gate: "large_transfer",
+      tier: "financial",
+      message: `High-value transfer ($${amount}). Double-check the address: ${shortAddr}`
+    };
+  }
+  if (amount > config.warnAbove) {
+    return {
+      verdict: "hint",
+      gate: "large_transfer",
+      tier: "financial",
+      message: `This is a large transfer ($${amount}). Verify the recipient address.`
+    };
+  }
+  return { verdict: "pass", gate: "large_transfer", tier: "financial" };
+}
+function guardSlippage(tool, _call, lastAssistantText) {
+  if (tool.name !== "swap_execute") {
+    return { verdict: "pass", gate: "slippage_warning", tier: "financial" };
+  }
+  const hasEstimate = /~?\$?[\d,]+\.?\d*\s*(SUI|USDC|USDT|WETH)/i.test(lastAssistantText) || /approximately|≈|about|expect|receive/i.test(lastAssistantText);
+  if (hasEstimate) {
+    return { verdict: "pass", gate: "slippage_warning", tier: "financial" };
+  }
+  return {
+    verdict: "hint",
+    gate: "slippage_warning",
+    tier: "financial",
+    message: "State the expected output amount to the user before executing the swap."
+  };
+}
+function guardCostWarning(tool, _call, conversationText) {
+  if (!tool.flags.costAware) {
+    return { verdict: "pass", gate: "cost_warning", tier: "ux" };
+  }
+  const hasCostMention = /\$\d+\.?\d*|cost|fee|charge|price|pay/i.test(conversationText);
+  if (hasCostMention) {
+    return { verdict: "pass", gate: "cost_warning", tier: "ux" };
+  }
+  return {
+    verdict: "hint",
+    gate: "cost_warning",
+    tier: "ux",
+    message: "This action has a monetary cost. Confirm the user is aware before proceeding."
+  };
+}
+function guardArtifactPreview(result) {
+  if (!result || typeof result !== "object") return null;
+  const r = result;
+  const hasImage = typeof r.url === "string" && /\.(png|jpg|jpeg|webp|gif|svg)(\?|$)/i.test(r.url) || Array.isArray(r.images) && r.images.length > 0 || typeof r.image_url === "string";
+  const hasPdf = typeof r.url === "string" && /\.pdf(\?|$)/i.test(r.url);
+  if (hasImage || hasPdf) {
+    return {
+      _gate: "artifact_preview",
+      _hint: "Show this to the user before proceeding. Output as ![description](url)."
+    };
+  }
+  return null;
+}
+function guardStaleData(toolFlags) {
+  if (!toolFlags.mutating) return null;
+  return {
+    _gate: "stale_data",
+    _hint: "A write action just completed. The balance snapshot is outdated. Do NOT calculate new balances from old data \u2014 call balance_check for fresh numbers, or use only the data returned by the write tool."
+  };
+}
+function createGuardRunnerState() {
+  return {
+    balanceTracker: new BalanceTracker(),
+    retryTracker: new RetryTracker(),
+    lastHealthFactor: null
+  };
+}
+function runGuards(tool, call, state, config, conversationContext) {
+  const results = [];
+  const now = Date.now();
+  if (config.inputValidation !== false && tool.preflight) {
+    const check = tool.preflight(call.input);
+    if (!check.valid) {
+      const event = {
+        timestamp: now,
+        toolName: tool.name,
+        toolUseId: call.id,
+        gate: "input_validation",
+        verdict: "block",
+        tier: "safety",
+        message: check.error
+      };
+      return {
+        blocked: true,
+        blockReason: check.error,
+        blockGate: "input_validation",
+        injections: [],
+        events: [event]
+      };
+    }
+  }
+  if (config.retryProtection !== false) {
+    results.push(guardRetryProtection(tool, call, state.retryTracker));
+  }
+  if (config.irreversibility !== false) {
+    results.push(guardIrreversibility(tool, call, conversationContext.fullText));
+  }
+  if (config.balanceValidation !== false) {
+    results.push(guardBalanceValidation(tool, call, state.balanceTracker));
+  }
+  if (config.healthFactor) {
+    results.push(guardHealthFactor(tool, call, state.lastHealthFactor, config.healthFactor));
+  }
+  if (config.largeTransfer) {
+    results.push(guardLargeTransfer(tool, call, config.largeTransfer));
+  }
+  if (config.slippage !== false) {
+    results.push(guardSlippage(tool, call, conversationContext.lastAssistantText));
+  }
+  if (config.costWarning !== false) {
+    results.push(guardCostWarning(tool, call, conversationContext.fullText));
+  }
+  const events = results.filter((r) => r.verdict !== "pass").map((r) => ({
+    timestamp: now,
+    toolName: tool.name,
+    toolUseId: call.id,
+    gate: r.gate,
+    verdict: r.verdict,
+    tier: r.tier,
+    message: r.message
+  }));
+  const block = results.find((r) => r.verdict === "block");
+  if (block) {
+    return {
+      blocked: true,
+      blockReason: block.message ?? `Blocked by ${block.gate}`,
+      blockGate: block.gate,
+      injections: [],
+      events
+    };
+  }
+  const injections = results.filter((r) => r.verdict === "hint" || r.verdict === "warn").map((r) => ({
+    _gate: r.gate,
+    ...r.verdict === "hint" ? { _hint: r.message } : { _warning: r.message }
+  }));
+  return { blocked: false, injections, events };
+}
+function updateGuardStateAfterToolResult(toolName, tool, input, result, isError, state) {
+  if (isError) return;
+  if (BALANCE_READ_TOOLS.has(toolName)) {
+    state.balanceTracker.recordRead();
+  }
+  if (tool?.flags.mutating) {
+    state.balanceTracker.recordWrite();
+  }
+  if (toolName === "health_check" && result && typeof result === "object") {
+    const r = result;
+    const hf = Number(r.healthFactor ?? r.health_factor ?? r.hf);
+    if (!isNaN(hf) && hf > 0) {
+      state.lastHealthFactor = hf;
+    }
+  }
+  state.retryTracker.record(toolName, input, result);
+}
+function extractConversationText(messages) {
+  const textParts = [];
+  let lastAssistantText = "";
+  for (const msg of messages) {
+    if (!Array.isArray(msg.content)) continue;
+    for (const block of msg.content) {
+      if (block.type === "text" && typeof block.text === "string") {
+        textParts.push(block.text);
+        if (msg.role === "assistant") {
+          lastAssistantText = block.text;
+        }
+      }
+    }
+  }
+  return {
+    fullText: textParts.join("\n"),
+    lastAssistantText
+  };
+}
+
+// src/context.ts
+var CHARS_PER_TOKEN = 4;
+var DEFAULT_CONTEXT_LIMIT = 2e5;
+function estimateTokens(messages) {
+  let chars = 0;
+  for (const msg of messages) {
+    for (const block of msg.content) {
+      chars += blockCharCount(block);
+    }
+  }
+  return Math.ceil(chars / CHARS_PER_TOKEN);
+}
+function blockCharCount(block) {
+  switch (block.type) {
+    case "text":
+      return block.text.length;
+    case "thinking":
+      return block.thinking.length;
+    case "redacted_thinking":
+      return block.data.length;
+    case "tool_use":
+      return block.name.length + JSON.stringify(block.input).length;
+    case "tool_result":
+      return block.content.length;
+  }
+}
+var ContextBudget = class {
+  estimatedTokens = 0;
+  contextLimit;
+  compactThreshold;
+  warnThreshold;
+  constructor(config = {}) {
+    this.contextLimit = config.contextLimit ?? DEFAULT_CONTEXT_LIMIT;
+    this.compactThreshold = config.compactThreshold ?? 0.85;
+    this.warnThreshold = config.warnThreshold ?? 0.7;
+  }
+  /** Update with actual input_tokens from the API usage event. */
+  update(inputTokens) {
+    this.estimatedTokens = inputTokens;
+  }
+  /** True when the session should be compacted (at 85% of context limit). */
+  shouldCompact() {
+    return this.estimatedTokens >= this.contextLimit * this.compactThreshold;
+  }
+  /** True when nearing the limit (at 70% of context limit). */
+  shouldWarn() {
+    return this.estimatedTokens >= this.contextLimit * this.warnThreshold;
+  }
+  /** Current token count. */
+  get tokens() {
+    return this.estimatedTokens;
+  }
+  /** Remaining tokens before compaction triggers. */
+  get remaining() {
+    return Math.max(0, Math.floor(this.contextLimit * this.compactThreshold) - this.estimatedTokens);
+  }
+  /** Usage ratio (0..1). */
+  get usage() {
+    return this.estimatedTokens / this.contextLimit;
+  }
+  reset() {
+    this.estimatedTokens = 0;
+  }
+};
+async function compactMessages(messages, opts = {}) {
+  const maxTokens = opts.maxTokens ?? 1e5;
+  const keepRecent = opts.keepRecentCount ?? 8;
+  const systemTokens = opts.systemPromptTokens ?? 500;
+  const budget = maxTokens - systemTokens;
+  if (messages.length === 0) return [];
+  const mutable = messages.map((m) => ({
+    role: m.role,
+    content: m.content.map((b) => ({ ...b }))
+  }));
+  if (estimateTokens(mutable) <= budget) return mutable;
+  const splitIdx = Math.max(0, mutable.length - keepRecent);
+  const oldMessages = mutable.slice(0, splitIdx);
+  const recent = mutable.slice(splitIdx);
+  if (opts.summarizer && oldMessages.length > 0) {
+    const strippedOld = stripThinkingBlocks(oldMessages);
+    try {
+      const summary = await opts.summarizer(strippedOld);
+      const summaryMessages = [
+        { role: "user", content: [{ type: "text", text: `[Session summary: ${summary}]` }] },
+        { role: "assistant", content: [{ type: "text", text: "Understood. I have the context from our earlier conversation." }] }
+      ];
+      const withSummary = [...summaryMessages, ...recent];
+      if (estimateTokens(withSummary) <= budget) return sanitizeMessages(withSummary);
+    } catch {
+    }
+  }
+  for (let i = 0; i < splitIdx; i++) {
+    mutable[i].content = mutable[i].content.map((block) => {
+      if (block.type === "tool_result" && block.content.length > 200) {
+        return {
+          ...block,
+          content: truncateToolResult(block.content)
+        };
+      }
+      return block;
+    });
+  }
+  for (let i = 0; i < splitIdx; i++) {
+    mutable[i].content = mutable[i].content.filter(
+      (b) => b.type !== "thinking" && b.type !== "redacted_thinking"
+    );
+  }
+  if (estimateTokens(mutable) <= budget) return mutable;
+  const first = mutable[0];
+  const recentFromMutable = mutable.slice(splitIdx);
+  const oldSection = mutable.slice(1, splitIdx);
+  while (oldSection.length > 0 && estimateTokens([first, ...oldSection, ...recentFromMutable]) > budget) {
+    oldSection.shift();
+  }
+  const compacted = [first, ...oldSection, ...recentFromMutable];
+  if (estimateTokens(compacted) > budget) {
+    for (const msg of compacted) {
+      msg.content = msg.content.map((block) => {
+        if (block.type === "tool_result" && block.content.length > 100) {
+          return { ...block, content: truncateToolResult(block.content) };
+        }
+        return block;
+      });
+    }
+  }
+  return sanitizeMessages(compacted);
+}
+function stripThinkingBlocks(messages) {
+  return messages.map((m) => ({
+    ...m,
+    content: m.content.filter(
+      (b) => b.type !== "thinking" && b.type !== "redacted_thinking"
+    )
+  })).filter((m) => m.content.length > 0);
+}
+function sanitizeMessages(messages) {
+  const toolUseIds = /* @__PURE__ */ new Set();
+  const toolResultIds = /* @__PURE__ */ new Set();
+  for (const msg of messages) {
+    for (const block of msg.content) {
+      if (block.type === "tool_use") toolUseIds.add(block.id);
+      if (block.type === "tool_result") toolResultIds.add(block.toolUseId);
+    }
+  }
+  return messages.map((msg) => {
+    const filtered = msg.content.filter((block) => {
+      if (block.type === "tool_result") return toolUseIds.has(block.toolUseId);
+      if (block.type === "tool_use") return toolResultIds.has(block.id);
+      return true;
+    });
+    if (filtered.length === 0) return null;
+    return { ...msg, content: filtered };
+  }).filter((m) => m !== null);
+}
+function truncateToolResult(content) {
+  try {
+    const parsed = JSON.parse(content);
+    if (parsed.error) {
+      return JSON.stringify({ error: parsed.error });
+    }
+    if (typeof parsed === "object" && parsed !== null) {
+      const summary = {};
+      for (const [key, value] of Object.entries(parsed)) {
+        if (typeof value === "number" || typeof value === "boolean") {
+          summary[key] = value;
+        } else if (typeof value === "string") {
+          summary[key] = value.length > 50 ? value.slice(0, 50) + "\u2026" : value;
+        } else if (Array.isArray(value)) {
+          summary[key] = `[${value.length} items]`;
+        } else {
+          summary[key] = "{\u2026}";
+        }
+      }
+      return JSON.stringify(summary);
+    }
+    return content.slice(0, 100);
+  } catch {
+    return content.slice(0, 100);
+  }
+}
+
 // src/engine.ts
 var DEFAULT_MAX_TURNS = 10;
 var DEFAULT_MAX_TOKENS = 4096;
@@ -3529,6 +4137,8 @@ var QueryEngine = class {
   maxTokens;
   temperature;
   toolChoice;
+  thinking;
+  outputConfig;
   agent;
   mcpManager;
   walletAddress;
@@ -3538,8 +4148,15 @@ var QueryEngine = class {
   env;
   txMutex = new TxMutex();
   costTracker;
+  guardConfig;
+  guardState;
+  recipes;
+  contextBudget;
+  contextSummarizer;
+  matchedRecipe = null;
   messages = [];
   abortController = null;
+  guardEvents = [];
   constructor(config) {
     this.provider = config.provider;
     this.agent = config.agent;
@@ -3554,8 +4171,15 @@ var QueryEngine = class {
     this.maxTokens = config.maxTokens ?? DEFAULT_MAX_TOKENS;
     this.temperature = config.temperature;
     this.toolChoice = config.toolChoice;
+    this.thinking = config.thinking;
+    this.outputConfig = config.outputConfig;
     this.systemPrompt = config.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
     this.costTracker = new CostTracker(config.costTracker);
+    this.guardConfig = config.guards;
+    this.guardState = createGuardRunnerState();
+    this.recipes = config.recipes;
+    this.contextBudget = new ContextBudget(config.contextBudget);
+    this.contextSummarizer = config.contextSummarizer;
     this.tools = config.tools ?? (config.agent ? getDefaultTools() : []);
   }
   /**
@@ -3573,6 +4197,7 @@ var QueryEngine = class {
     }
     this.abortController = new AbortController();
     const signal = this.abortController.signal;
+    this.matchedRecipe = this.recipes?.match(prompt) ?? null;
     this.messages.push({
       role: "user",
       content: [{ type: "text", text: prompt }]
@@ -3631,9 +4256,21 @@ var QueryEngine = class {
   getMessages() {
     return this.messages;
   }
+  getMatchedRecipe() {
+    return this.matchedRecipe;
+  }
+  getContextBudget() {
+    return this.contextBudget;
+  }
   reset() {
     this.messages = [];
     this.costTracker.reset();
+    this.contextBudget.reset();
+    this.guardEvents = [];
+    this.matchedRecipe = null;
+  }
+  getGuardEvents() {
+    return this.guardEvents;
   }
   loadMessages(messages) {
     this.messages = [...messages];
@@ -3680,11 +4317,20 @@ var QueryEngine = class {
         pendingToolCalls: []
       };
       try {
+        if (this.contextBudget.shouldCompact()) {
+          this.messages = await compactMessages(this.messages, {
+            maxTokens: 1e5,
+            keepRecentCount: 8,
+            summarizer: this.contextSummarizer
+          });
+        }
         this.messages = validateHistory(this.messages);
         if (process.env.NODE_ENV !== "test") {
           const summary = this.messages.map((m, idx) => {
             const blocks = m.content.map((b) => {
               if (b.type === "text") return `text(${b.text.slice(0, 40)}\u2026)`;
+              if (b.type === "thinking") return `thinking(${b.thinking.length}ch)`;
+              if (b.type === "redacted_thinking") return `redacted_thinking`;
               if (b.type === "tool_use") return `tool_use:${b.id.slice(-8)}/${b.name}`;
               return `tool_result:${b.toolUseId.slice(-8)}`;
             });
@@ -3693,14 +4339,32 @@ var QueryEngine = class {
           console.log(`[engine] provider.chat turn=${turns} msgs=${this.messages.length}
 ${summary.join("\n")}`);
         }
+        const thinkingEnabled = this.thinking && this.thinking.type !== "disabled";
+        const effectiveToolChoice = thinkingEnabled ? applyToolChoice && turns === 1 ? "auto" : void 0 : applyToolChoice && turns === 1 ? this.toolChoice : void 0;
+        let effectivePrompt = this.systemPrompt;
+        if (this.matchedRecipe && this.recipes) {
+          const recipeCtx = this.recipes.toPromptContext(this.matchedRecipe);
+          if (typeof effectivePrompt === "string") {
+            effectivePrompt = `${effectivePrompt}
+
+${recipeCtx}`;
+          } else if (Array.isArray(effectivePrompt)) {
+            effectivePrompt = [
+              ...effectivePrompt,
+              { type: "text", text: recipeCtx }
+            ];
+          }
+        }
         const stream = this.provider.chat({
           messages: this.messages,
-          systemPrompt: this.systemPrompt,
+          systemPrompt: effectivePrompt,
           tools: toolDefs,
           model: this.model,
           maxTokens: this.maxTokens,
           temperature: this.temperature,
-          toolChoice: applyToolChoice && turns === 1 ? this.toolChoice : void 0,
+          toolChoice: effectiveToolChoice,
+          thinking: this.thinking,
+          outputConfig: this.outputConfig,
           signal
         });
         for await (const event of stream) {
@@ -3746,7 +4410,42 @@ ${summary.join("\n")}`);
         pendingWrite = { call, tool };
         break;
       }
-      for await (const toolEvent of runTools(approved, this.tools, context, this.txMutex)) {
+      const guardedApproved = [];
+      if (this.guardConfig) {
+        const convCtx = extractConversationText(this.messages);
+        for (const call of approved) {
+          const tool = findTool(this.tools, call.name);
+          if (!tool) {
+            guardedApproved.push(call);
+            continue;
+          }
+          const check = runGuards(tool, call, this.guardState, this.guardConfig, convCtx);
+          this.guardEvents.push(...check.events);
+          if (check.blocked) {
+            yield {
+              type: "tool_result",
+              toolName: call.name,
+              toolUseId: call.id,
+              result: { error: check.blockReason, _gate: check.blockGate },
+              isError: true
+            };
+            toolResultBlocks.push({
+              type: "tool_result",
+              toolUseId: call.id,
+              content: JSON.stringify({ error: check.blockReason, _gate: check.blockGate }),
+              isError: true
+            });
+            continue;
+          }
+          if (check.injections.length > 0) {
+            call._guardInjections = check.injections;
+          }
+          guardedApproved.push(call);
+        }
+      } else {
+        guardedApproved.push(...approved);
+      }
+      for await (const toolEvent of runTools(guardedApproved, this.tools, context, this.txMutex)) {
         if (toolEvent.type === "tool_result" && !toolEvent.isError) {
           const warning = flagSuspiciousResult(toolEvent.toolName, toolEvent.result);
           if (warning) {
@@ -3764,29 +4463,89 @@ ${summary.join("\n")}`);
             continue;
           }
         }
-        yield toolEvent;
-        if (toolEvent.type === "tool_result" && !toolEvent.isError) {
-          const r = toolEvent.result;
-          if (r && r.__canvas === true) {
-            yield {
-              type: "canvas",
-              template: String(r.template ?? ""),
-              title: String(r.title ?? ""),
-              data: r.templateData ?? null,
-              toolUseId: toolEvent.toolUseId
-            };
+        if (toolEvent.type === "tool_result") {
+          const tool = findTool(this.tools, toolEvent.toolName);
+          const originalCall = guardedApproved.find((c) => c.id === toolEvent.toolUseId);
+          updateGuardStateAfterToolResult(
+            toolEvent.toolName,
+            tool,
+            originalCall?.input ?? null,
+            toolEvent.result,
+            toolEvent.isError,
+            this.guardState
+          );
+          let enrichedResult = toolEvent.result;
+          if (this.guardConfig && !toolEvent.isError && tool) {
+            const artifactInj = this.guardConfig.artifactPreview !== false ? guardArtifactPreview(toolEvent.result) : null;
+            const staleInj = this.guardConfig.staleData !== false ? guardStaleData(tool.flags) : null;
+            const preInjections = guardedApproved.find((c) => c.id === toolEvent.toolUseId)?._guardInjections ?? [];
+            const allInjections = [
+              ...preInjections,
+              ...artifactInj ? [artifactInj] : [],
+              ...staleInj ? [staleInj] : []
+            ];
+            if (allInjections.length > 0 && typeof enrichedResult === "object" && enrichedResult) {
+              enrichedResult = { ...enrichedResult, _guards: allInjections };
+            }
+          }
+          const finalEvent = enrichedResult !== toolEvent.result ? { ...toolEvent, result: enrichedResult } : toolEvent;
+          yield finalEvent;
+          if (finalEvent.type === "tool_result" && !finalEvent.isError) {
+            const r = finalEvent.result;
+            if (r && r.__canvas === true) {
+              yield {
+                type: "canvas",
+                template: String(r.template ?? ""),
+                title: String(r.title ?? ""),
+                data: r.templateData ?? null,
+                toolUseId: finalEvent.toolUseId
+              };
+            }
           }
+          toolResultBlocks.push({
+            type: "tool_result",
+            toolUseId: finalEvent.toolUseId,
+            content: JSON.stringify(finalEvent.result),
+            isError: finalEvent.isError
+          });
+          continue;
         }
-        if (toolEvent.type === "tool_result") {
+        yield toolEvent;
+      }
+      if (pendingWrite && this.guardConfig) {
+        const convCtx = extractConversationText(this.messages);
+        const check = runGuards(
+          pendingWrite.tool,
+          pendingWrite.call,
+          this.guardState,
+          this.guardConfig,
+          convCtx
+        );
+        this.guardEvents.push(...check.events);
+        if (check.blocked) {
+          yield {
+            type: "tool_result",
+            toolName: pendingWrite.call.name,
+            toolUseId: pendingWrite.call.id,
+            result: { error: check.blockReason, _gate: check.blockGate },
+            isError: true
+          };
           toolResultBlocks.push({
             type: "tool_result",
-            toolUseId: toolEvent.toolUseId,
-            content: JSON.stringify(toolEvent.result),
-            isError: toolEvent.isError
+            toolUseId: pendingWrite.call.id,
+            content: JSON.stringify({ error: check.blockReason, _gate: check.blockGate }),
+            isError: true
           });
+          this.messages.push({ role: "assistant", content: acc.assistantBlocks });
+          this.messages.push({ role: "user", content: toolResultBlocks });
+          continue;
+        }
+        if (check.injections.length > 0) {
+          pendingWrite.call._guardInjections = check.injections;
         }
       }
       if (pendingWrite) {
+        const writeGuardInjections = pendingWrite.call._guardInjections;
         yield {
           type: "pending_action",
           action: {
@@ -3799,7 +4558,8 @@ ${summary.join("\n")}`);
               toolUseId: b.toolUseId,
               content: b.content,
               isError: b.isError ?? false
-            }))
+            })),
+            ...writeGuardInjections?.length ? { guardInjections: writeGuardInjections } : {}
           }
         };
         return;
@@ -3829,6 +4589,26 @@ ${summary.join("\n")}`);
   }
   *handleProviderEvent(event, acc) {
     switch (event.type) {
+      case "thinking_delta": {
+        yield { type: "thinking_delta", text: event.text };
+        break;
+      }
+      case "thinking_done": {
+        acc.assistantBlocks.push({
+          type: "thinking",
+          thinking: event.thinking,
+          signature: event.signature
+        });
+        yield { type: "thinking_done", signature: event.signature };
+        break;
+      }
+      case "redacted_thinking": {
+        acc.assistantBlocks.push({
+          type: "redacted_thinking",
+          data: event.data
+        });
+        break;
+      }
       case "text_delta": {
         acc.text += event.text;
         yield { type: "text_delta", text: event.text };
@@ -3859,6 +4639,7 @@ ${summary.join("\n")}`);
           event.cacheReadTokens,
           event.cacheWriteTokens
         );
+        this.contextBudget.update(event.inputTokens);
         yield {
           type: "usage",
           inputTokens: event.inputTokens,
@@ -4075,114 +4856,305 @@ var MemorySessionStore = class {
     }
   }
 };
+var StepRequirementSchema = z.object({
+  step: z.string().optional(),
+  field: z.string().optional(),
+  confirmation: z.boolean().optional()
+});
+var OnErrorSchema = z.object({
+  action: z.enum(["abort", "refuse", "report", "retry"]),
+  message: z.string(),
+  suggest: z.string().optional()
+});
+var StepSchema = z.object({
+  name: z.string().min(1),
+  tool: z.string().optional(),
+  service: z.string().optional(),
+  purpose: z.string().min(1),
+  cost: z.string().optional(),
+  output: z.object({ type: z.string(), key: z.string() }).optional(),
+  gate: z.enum(["none", "preview", "review", "estimate"]).optional(),
+  gate_prompt: z.string().optional(),
+  requires: z.array(StepRequirementSchema).optional(),
+  rules: z.array(z.string()).optional(),
+  condition: z.string().optional(),
+  notes: z.string().optional(),
+  flags: z.record(z.unknown()).optional(),
+  on_error: OnErrorSchema.optional(),
+  input_template: z.record(z.string()).optional(),
+  cost_per_unit: z.string().optional()
+});
+var RecipeSchema = z.object({
+  name: z.string().min(1),
+  description: z.string().min(1),
+  triggers: z.array(z.string().min(1)).min(1),
+  services: z.array(z.string()).optional(),
+  prerequisites: z.array(z.object({ field: z.string(), prompt: z.string() })).optional(),
+  steps: z.array(StepSchema).min(1)
+}).refine(
+  (r) => {
+    const names = r.steps.map((s) => s.name);
+    return new Set(names).size === names.length;
+  },
+  { message: "Step names must be unique within a recipe" }
+);
+function loadRecipes(yamlDir) {
+  const files = readdirSync(yamlDir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+  const recipes = [];
+  for (const file of files) {
+    const content = readFileSync(join(yamlDir, file), "utf-8");
+    const raw = yaml.load(content);
+    const parsed = RecipeSchema.parse(raw);
+    recipes.push(parsed);
+  }
+  return recipes;
+}
+function parseRecipe(yamlContent) {
+  const raw = yaml.load(yamlContent);
+  return RecipeSchema.parse(raw);
+}
 
-// src/context.ts
-var CHARS_PER_TOKEN = 4;
-function estimateTokens(messages) {
-  let chars = 0;
-  for (const msg of messages) {
-    for (const block of msg.content) {
-      chars += blockCharCount(block);
-    }
+// src/recipes/registry.ts
+var RecipeRegistry = class {
+  recipes = [];
+  /** Load all recipes from a directory of YAML files. */
+  loadDir(yamlDir) {
+    this.recipes.push(...loadRecipes(yamlDir));
   }
-  return Math.ceil(chars / CHARS_PER_TOKEN);
-}
-function blockCharCount(block) {
-  switch (block.type) {
-    case "text":
-      return block.text.length;
-    case "tool_use":
-      return block.name.length + JSON.stringify(block.input).length;
-    case "tool_result":
-      return block.content.length;
+  /** Register a single recipe from a YAML string. */
+  loadYaml(yamlContent) {
+    this.recipes.push(parseRecipe(yamlContent));
   }
-}
-function compactMessages(messages, opts = {}) {
-  const maxTokens = opts.maxTokens ?? 1e5;
-  const keepRecent = opts.keepRecentCount ?? 6;
-  const systemTokens = opts.systemPromptTokens ?? 500;
-  const budget = maxTokens - systemTokens;
-  if (messages.length === 0) return [];
-  const mutable = messages.map((m) => ({
-    role: m.role,
-    content: m.content.map((b) => ({ ...b }))
-  }));
-  if (estimateTokens(mutable) <= budget) return mutable;
-  const splitIdx = Math.max(0, mutable.length - keepRecent);
-  for (let i = 0; i < splitIdx; i++) {
-    mutable[i].content = mutable[i].content.map((block) => {
-      if (block.type === "tool_result" && block.content.length > 200) {
-        return {
-          ...block,
-          content: truncateToolResult(block.content)
-        };
-      }
-      return block;
-    });
+  /** Register a pre-parsed Recipe object. */
+  register(recipe) {
+    this.recipes.push(recipe);
   }
-  if (estimateTokens(mutable) <= budget) return mutable;
-  const first = mutable[0];
-  const recent = mutable.slice(splitIdx);
-  const oldSection = mutable.slice(1, splitIdx);
-  while (oldSection.length > 0 && estimateTokens([first, ...oldSection, ...recent]) > budget) {
-    oldSection.shift();
+  /** All loaded recipes. */
+  all() {
+    return this.recipes;
   }
-  const compacted = [first, ...oldSection, ...recent];
-  if (estimateTokens(compacted) > budget) {
-    for (const msg of compacted) {
-      msg.content = msg.content.map((block) => {
-        if (block.type === "tool_result" && block.content.length > 100) {
-          return { ...block, content: truncateToolResult(block.content) };
+  /**
+   * Match a user message to the most specific recipe.
+   * Longest trigger phrase match wins. Returns null if no match.
+   */
+  match(userMessage) {
+    const normalized = userMessage.toLowerCase().trim();
+    let best = null;
+    let bestLength = 0;
+    for (const recipe of this.recipes) {
+      for (const trigger of recipe.triggers) {
+        const triggerLower = trigger.toLowerCase();
+        if (normalized.includes(triggerLower) && triggerLower.length > bestLength) {
+          best = recipe;
+          bestLength = triggerLower.length;
         }
-        return block;
-      });
+      }
     }
+    return best;
   }
-  return sanitizeMessages(compacted);
-}
-function sanitizeMessages(messages) {
-  const toolUseIds = /* @__PURE__ */ new Set();
-  const toolResultIds = /* @__PURE__ */ new Set();
-  for (const msg of messages) {
-    for (const block of msg.content) {
-      if (block.type === "tool_use") toolUseIds.add(block.id);
-      if (block.type === "tool_result") toolResultIds.add(block.toolUseId);
+  /**
+   * Format a matched recipe as a compact context block for the system prompt.
+   * Injected dynamically — only when the recipe matches.
+   */
+  toPromptContext(recipe) {
+    const lines = [
+      `## Active Recipe: ${recipe.name}`,
+      recipe.description,
+      "Follow these steps:"
+    ];
+    for (let i = 0; i < recipe.steps.length; i++) {
+      const step = recipe.steps[i];
+      const num = i + 1;
+      const toolNote = step.tool ? ` \u2192 ${step.tool}` : "";
+      const serviceNote = step.service ? ` (${step.service})` : "";
+      const costNote = step.cost ? ` \u2014 ${step.cost}` : "";
+      const gateNote = step.gate && step.gate !== "none" ? ` [GATE: ${step.gate}]` : "";
+      let line = `${num}. ${step.name}${toolNote}${serviceNote}${costNote}${gateNote}`;
+      if (step.gate_prompt) {
+        line += ` \u2014 "${step.gate_prompt}"`;
+      }
+      lines.push(line);
+      if (step.rules?.length) {
+        for (const rule of step.rules) {
+          lines.push(`   - ${rule}`);
+        }
+      }
+      if (step.notes) {
+        lines.push(`   Note: ${step.notes}`);
+      }
+      if (step.on_error) {
+        lines.push(`   On error: ${step.on_error.action} \u2014 ${step.on_error.message}`);
+      }
+      if (step.condition) {
+        lines.push(`   Condition: ${step.condition}`);
+      }
     }
+    if (recipe.prerequisites?.length) {
+      lines.push("Prerequisites (ask before starting):");
+      for (const pre of recipe.prerequisites) {
+        lines.push(`- ${pre.field}: "${pre.prompt}"`);
+      }
+    }
+    return lines.join("\n");
   }
-  return messages.map((msg) => {
-    const filtered = msg.content.filter((block) => {
-      if (block.type === "tool_result") return toolUseIds.has(block.toolUseId);
-      if (block.type === "tool_use") return toolResultIds.has(block.id);
-      return true;
-    });
-    if (filtered.length === 0) return null;
-    return { ...msg, content: filtered };
-  }).filter((m) => m !== null);
+};
+
+// src/classify-effort.ts
+function classifyEffort(model, userMessage, matchedRecipe, sessionWriteCount) {
+  const supportsMax = model.includes("opus-4-6");
+  const msg = userMessage.toLowerCase();
+  if (supportsMax) {
+    if (matchedRecipe?.name === "portfolio_rebalance") return "max";
+    if (matchedRecipe?.name === "emergency_withdraw") return "max";
+    if (/rebalance|reallocate|dca setup|close.*position/i.test(msg)) return "max";
+  }
+  if (matchedRecipe && matchedRecipe.steps.length >= 3) return "high";
+  if (matchedRecipe?.name === "safe_borrow" || matchedRecipe?.name === "bulk_mail") return "high";
+  if (sessionWriteCount > 0 && /borrow|withdraw|send|swap/i.test(msg)) return "high";
+  if (/balance|rate|how much|what is|check|history|show|price/i.test(msg)) return "low";
+  if (!matchedRecipe && !/deposit|send|swap|borrow|withdraw|save|pay/i.test(msg)) return "low";
+  return "medium";
 }
-function truncateToolResult(content) {
-  try {
-    const parsed = JSON.parse(content);
-    if (parsed.error) {
-      return JSON.stringify({ error: parsed.error });
+
+// src/prompt-cache.ts
+function buildCachedSystemPrompt(staticParts, dynamicPart) {
+  const blocks = staticParts.map((text, i) => ({
+    type: "text",
+    text,
+    ...i === staticParts.length - 1 && { cache_control: { type: "ephemeral" } }
+  }));
+  if (dynamicPart) {
+    blocks.push({ type: "text", text: dynamicPart });
+  }
+  return blocks;
+}
+
+// src/intelligence.ts
+function buildProfileContext(profile) {
+  if (!profile || profile.riskConfidence < 0.3) return "";
+  const lines = ["User financial profile (inferred from conversation history):"];
+  if (profile.riskConfidence >= 0.5) {
+    lines.push(`- Risk appetite: ${profile.riskAppetite}`);
+  }
+  if (profile.literacyConfidence >= 0.5) {
+    lines.push(`- Financial literacy: ${profile.financialLiteracy}`);
+    if (profile.financialLiteracy === "advanced") {
+      lines.push("  \u2192 Skip basic DeFi explanations (health factor, APY, etc). User knows these.");
     }
-    if (typeof parsed === "object" && parsed !== null) {
-      const summary = {};
-      for (const [key, value] of Object.entries(parsed)) {
-        if (typeof value === "number" || typeof value === "boolean") {
-          summary[key] = value;
-        } else if (typeof value === "string") {
-          summary[key] = value.length > 50 ? value.slice(0, 50) + "\u2026" : value;
-        } else if (Array.isArray(value)) {
-          summary[key] = `[${value.length} items]`;
-        } else {
-          summary[key] = "{\u2026}";
-        }
-      }
-      return JSON.stringify(summary);
+    if (profile.financialLiteracy === "novice") {
+      lines.push("  \u2192 Always explain DeFi concepts in plain language.");
     }
-    return content.slice(0, 100);
-  } catch {
-    return content.slice(0, 100);
+  }
+  if (profile.currencyFraming === "fiat") {
+    lines.push('- Frame amounts as dollars (e.g. "$50" not "50 USDC")');
+  }
+  if (profile.prefersBriefResponses) {
+    lines.push("- Prefers brief responses \u2014 be concise");
+  }
+  if (profile.primaryGoals.length > 0) {
+    lines.push(`- Stated goals: ${profile.primaryGoals.join(", ")}`);
+  }
+  if (profile.knownPatterns.length > 0) {
+    lines.push(`- Behavioural patterns: ${profile.knownPatterns.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+function buildProactivenessInstructions(profile) {
+  const brevityGuidance = profile?.prefersBriefResponses ? "This user prefers brevity \u2014 only surface context if urgent or directly actionable." : "Surface relevant context when criteria are met.";
+  const styleGuidance = profile?.financialLiteracy === "novice" ? "Frame observations in plain English, no DeFi jargon." : "Technical framing is fine.";
+  return `Proactive awareness:
+After completing the user's request, consider whether ONE additional piece of financial
+context is worth mentioning. ${brevityGuidance}
+
+\u2713 Mention if:
+- Their savings goal is materially off-track (>20% behind pace)
+- Yield rate changed significantly since last session (>0.5%)
+- They have idle USDC >$50 sitting for >48h
+- An action they just took interacts with an active goal or debt position
+- A pattern would materially benefit from their attention
+
+\u2717 Do NOT mention if:
+- Tangentially related but not actionable
+- Already surfaced this session
+- Requires more explanation than the original answer
+- Would seem pushy or sales-y
+
+${styleGuidance}
+Format: One sentence maximum, after main response, separated by a line break.
+Frame as observation, not advice: "Your Tokyo goal is $80 behind pace." \u2014 not "You should deposit more."`;
+}
+function buildSelfEvaluationInstruction() {
+  return `Self-evaluation (apply silently before composing your response):
+
+1. ACCURACY \u2014 Quote exact values from tool results, not estimates or rounded figures.
+   Never combine post-action tool results with pre-action snapshot numbers.
+   If the tool returned an error, label it as an error \u2014 do not paraphrase it as success.
+
+2. STATE CONSISTENCY \u2014 Describe the actual outcome of all steps.
+   Partial success (swap ok, deposit failed): describe both clearly.
+   Never describe a failed action as if it succeeded.
+
+3. COMPLETENESS \u2014 If the user asked multiple things, answer all of them.
+   If you couldn't complete something, explain why and what the current state is.
+
+4. TONE \u2014 Match tone to outcome.
+   Success: confirming and forward-looking.
+   Failure: clear about what failed, unchanged, and what to do next.
+   Warning: specific risk, not generic caution.
+
+If any check fails, rewrite before outputting.`;
+}
+
+// src/state/conversation-state.ts
+function buildStateContext(state) {
+  switch (state.type) {
+    case "idle":
+      return "";
+    case "mid_recipe": {
+      const elapsed = Math.round((Date.now() - state.startedAt) / 6e4);
+      const outputs = JSON.stringify(state.completedStepOutputs);
+      return [
+        `Conversation state: MID-RECIPE`,
+        `Active recipe: ${state.recipeName} (step ${state.currentStep + 1} of ${state.totalSteps})`,
+        `Started: ${elapsed} minutes ago`,
+        `Completed step key outputs: ${outputs}`,
+        `If the user asks an unrelated question: answer briefly, then offer to continue the ${state.recipeName} flow.`,
+        `If the user says "cancel" or "stop": confirm you have abandoned the recipe and return to idle.`
+      ].join("\n");
+    }
+    case "awaiting_confirmation": {
+      const expiryMins = Math.max(0, Math.round((state.expiresAt - Date.now()) / 6e4));
+      const expired = state.expiresAt < Date.now();
+      return [
+        `Conversation state: AWAITING CONFIRMATION`,
+        `Proposed action: ${state.action}${state.amount ? ` for $${state.amount}` : ""}${state.recipient ? ` to ${state.recipient}` : ""}`,
+        expired ? `Status: EXPIRED \u2014 ask if user still wants to proceed` : `Expires in: ${expiryMins} minutes`,
+        `"yes/confirm/do it" \u2192 execute. "no/cancel/wait" \u2192 abort, reset to idle.`
+      ].join("\n");
+    }
+    case "post_error":
+      return [
+        `Conversation state: POST-ERROR`,
+        `Failed action: ${state.failedAction}`,
+        `Error: ${state.errorMessage}`,
+        state.partialState ? `Partial state: ${state.partialState}` : "",
+        `Acknowledge failure clearly. Offer a specific recovery path if one exists.`,
+        `This state clears automatically on the next successful action.`
+      ].filter(Boolean).join("\n");
+    case "post_liquidation_warning":
+      return [
+        `Conversation state: LIQUIDATION WARNING ACTIVE`,
+        `Health factor: ${state.healthFactor.toFixed(2)} \u2014 below safe threshold`,
+        `Prioritise debt repayment or collateral deposit.`,
+        `Do not proceed with any action that would further reduce health factor.`
+      ].join("\n");
+    case "onboarding":
+      return [
+        `Conversation state: ONBOARDING (session ${state.sessionNumber})`,
+        state.sessionNumber === 1 ? "First session \u2014 introduce capabilities through context, not a feature list." : `Returning user \u2014 ${state.hasSavedBefore ? "has saved before" : "has not saved yet"}.`
+      ].join("\n");
+    default:
+      return "";
   }
 }
 
@@ -4419,6 +5391,7 @@ function adaptMcpTool(mcpTool, config) {
     isReadOnly,
     isConcurrencySafe: isReadOnly,
     permissionLevel,
+    flags: {},
     async call(input, _context) {
       const result = await config.manager.callTool(
         config.serverName,
@@ -4484,17 +5457,26 @@ var AnthropicProvider = class {
         toolChoice = { type: "tool", name: params.toolChoice.name };
       }
     }
-    const streamParams = {
+    const thinkingParam = toAnthropicThinking(params.thinking);
+    const systemParam = toAnthropicSystem(params.systemPrompt);
+    const baseParams = {
       model: params.model ?? this.defaultModel,
       max_tokens: params.maxTokens ?? this.defaultMaxTokens,
-      system: params.systemPrompt,
+      system: systemParam,
       messages,
+      stream: true,
       tools: tools.length > 0 ? tools : void 0,
-      ...params.temperature !== void 0 && { temperature: params.temperature },
+      ...!thinkingParam && params.temperature !== void 0 && { temperature: params.temperature },
       ...toolChoice && { tool_choice: toolChoice }
     };
+    const streamParams = {
+      ...baseParams,
+      ...thinkingParam && { thinking: thinkingParam },
+      ...params.outputConfig?.effort && { output_config: { effort: params.outputConfig.effort } }
+    };
     const stream = params.signal ? this.client.messages.stream(streamParams, { signal: params.signal }) : this.client.messages.stream(streamParams);
     const toolInputBuffers = /* @__PURE__ */ new Map();
+    const thinkingBuffers = /* @__PURE__ */ new Map();
     let outputTokensFromStart = 0;
     try {
       for await (const event of stream) {
@@ -4532,6 +5514,10 @@ var AnthropicProvider = class {
                 id: block.id,
                 name: block.name
               };
+            } else if (block.type === "thinking") {
+              thinkingBuffers.set(event.index, { type: "thinking", text: "", signature: "" });
+            } else if (block.type === "redacted_thinking") {
+              thinkingBuffers.set(event.index, { type: "redacted_thinking", data: block.data ?? "" });
             }
             break;
           }
@@ -4549,26 +5535,41 @@ var AnthropicProvider = class {
                   partialJson: delta.partial_json
                 };
               }
+            } else if (delta.type === "thinking_delta") {
+              const buf = thinkingBuffers.get(event.index);
+              if (buf?.type === "thinking") buf.text += delta.thinking ?? "";
+              yield { type: "thinking_delta", text: delta.thinking ?? "" };
+            } else if (delta.type === "signature_delta") {
+              const buf = thinkingBuffers.get(event.index);
+              if (buf?.type === "thinking") buf.signature = delta.signature ?? "";
             }
             break;
           }
           case "content_block_stop": {
-            const buf = toolInputBuffers.get(event.index);
-            if (buf) {
+            const toolBuf = toolInputBuffers.get(event.index);
+            if (toolBuf) {
               let input = {};
               try {
-                input = JSON.parse(buf.json || "{}");
+                input = JSON.parse(toolBuf.json || "{}");
               } catch {
                 input = {};
               }
               yield {
                 type: "tool_use_done",
-                id: buf.id,
-                name: buf.name,
+                id: toolBuf.id,
+                name: toolBuf.name,
                 input
               };
               toolInputBuffers.delete(event.index);
             }
+            const thinkBuf = thinkingBuffers.get(event.index);
+            if (thinkBuf?.type === "thinking") {
+              yield { type: "thinking_done", thinking: thinkBuf.text, signature: thinkBuf.signature };
+              thinkingBuffers.delete(event.index);
+            } else if (thinkBuf?.type === "redacted_thinking") {
+              yield { type: "redacted_thinking", data: thinkBuf.data };
+              thinkingBuffers.delete(event.index);
+            }
             break;
           }
           case "message_delta": {
@@ -4598,11 +5599,28 @@ var AnthropicProvider = class {
     }
   }
 };
+function toAnthropicSystem(prompt) {
+  if (typeof prompt === "string") return prompt;
+  return prompt.map((block) => ({
+    type: "text",
+    text: block.text,
+    ...block.cache_control && { cache_control: block.cache_control }
+  }));
+}
+function toAnthropicThinking(config) {
+  if (!config || config.type === "disabled") return void 0;
+  if (config.type === "adaptive") return { type: "adaptive" };
+  return { type: "enabled", budget_tokens: config.budgetTokens };
+}
 function toAnthropicMessage(msg) {
   const content = msg.content.map((block) => {
     switch (block.type) {
       case "text":
         return { type: "text", text: block.text };
+      case "thinking":
+        return { type: "thinking", thinking: block.thinking, signature: block.signature };
+      case "redacted_thinking":
+        return { type: "redacted_thinking", data: block.data };
       case "tool_use":
         return {
           type: "tool_use",
@@ -4618,7 +5636,7 @@ function toAnthropicMessage(msg) {
           is_error: block.isError
         };
     }
-  });
+  }).filter((b) => b !== null);
   return { role: msg.role, content };
 }
 function toAnthropicTool(def) {
@@ -4707,6 +5725,6 @@ function sanitizeAnthropicMessages(messages) {
   return merged;
 }
 
-export { AnthropicProvider, CANVAS_TEMPLATES, CostTracker, DEFAULT_SYSTEM_PROMPT, McpClientManager, McpResponseCache, MemorySessionStore, NAVI_MCP_CONFIG, NAVI_MCP_URL, NAVI_SERVER_NAME, NaviTools, QueryEngine, READ_TOOLS, TxMutex, WRITE_TOOLS, 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, BalanceTracker, CANVAS_TEMPLATES, ContextBudget, CostTracker, DEFAULT_GUARD_CONFIG, DEFAULT_SYSTEM_PROMPT, McpClientManager, McpResponseCache, MemorySessionStore, NAVI_MCP_CONFIG, NAVI_MCP_URL, NAVI_SERVER_NAME, NaviTools, QueryEngine, READ_TOOLS, RecipeRegistry, RetryTracker, TOOL_FLAGS, TxMutex, WRITE_TOOLS, 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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map