teleton 0.2.5 → 0.3.0

package/dist/{chunk-KS7B2CVM.js → chunk-ILDG4OPK.js}

@@ -30,7 +30,7 @@ import {
   initializeMemory,
   migrateFromMainDb,
   openModuleDb
-} from "./chunk-DR6WM6B5.js";
+} from "./chunk-QQW6KE7Q.js";
 import {
   COINGECKO_API_URL,
   ELEVENLABS_TTS_URL,
@@ -65,7 +65,7 @@ import {
   TELEGRAM_CONNECTION_RETRIES,
   TELEGRAM_FLOOD_SLEEP_THRESHOLD,
   TELEGRAM_MAX_MESSAGE_LENGTH
-} from "./chunk-2X4PCE7V.js";
+} from "./chunk-UYF4TT44.js";
 import {
   ALLOWED_EXTENSIONS,
   MAX_FILE_SIZES,
@@ -1524,7 +1524,7 @@ var PROVIDER_REGISTRY = {
     keyHint: "sk-or-v1-...",
     consoleUrl: "https://openrouter.ai/keys",
     defaultModel: "anthropic/claude-opus-4.5",
-    utilityModel: "google/gemini-2.0-flash-001:free",
+    utilityModel: "google/gemini-2.5-flash-lite",
     toolLimit: 128,
     piAiProvider: "openrouter"
   }
@@ -2149,6 +2149,9 @@ function getProviderModel(provider, modelId) {
   const meta = getProviderMetadata(provider);
   try {
     const model = getModel(meta.piAiProvider, modelId);
+    if (!model) {
+      throw new Error(`getModel returned undefined for ${provider}/${modelId}`);
+    }
     modelCache.set(cacheKey, model);
     return model;
   } catch (e) {
@@ -2160,6 +2163,11 @@ function getProviderModel(provider, modelId) {
     if (fallbackCached) return fallbackCached;
     try {
       const model = getModel(meta.piAiProvider, meta.defaultModel);
+      if (!model) {
+        throw new Error(
+          `Fallback model ${meta.defaultModel} also returned undefined for ${provider}`
+        );
+      }
       modelCache.set(fallbackKey, model);
       return model;
     } catch {
@@ -3633,6 +3641,11 @@ ${statsContext}`;
    */
   clearHistory(chatId) {
     const db3 = getDatabase().getDb();
+    db3.prepare(
+      `DELETE FROM tg_messages_vec WHERE id IN (
+        SELECT id FROM tg_messages WHERE chat_id = ?
+      )`
+    ).run(chatId);
     db3.prepare(`DELETE FROM tg_messages WHERE chat_id = ?`).run(chatId);
     resetSession(chatId);
     console.log(`\u{1F5D1}\uFE0F  Cleared history for chat ${chatId}`);
@@ -4591,7 +4604,7 @@ var MessageHandler = class {
         reason: "Already processed"
       };
     }
-    if (message.isGroup && message.isBot) {
+    if (message.isBot) {
       return {
         message,
         isAdmin,
@@ -15593,6 +15606,223 @@ var tonMyTransactionsExecutor = async (params, context) => {
   }
 };
 
+// src/agent/tools/ton/chart.ts
+import { Type as Type78 } from "@sinclair/typebox";
+var tonChartTool = {
+  name: "ton_chart",
+  description: "Get price history chart for TON or any jetton. Returns price points over a time period with stats (min, max, change %). Use token param for jettons (master contract address).",
+  parameters: Type78.Object({
+    token: Type78.Optional(
+      Type78.String({
+        description: 'Token identifier: "ton" for TON, or a jetton master contract address. Defaults to "ton".'
+      })
+    ),
+    period: Type78.Optional(
+      Type78.String({
+        description: 'Time period: "1h", "24h", "7d", "30d", "90d", "1y". Defaults to "7d".'
+      })
+    )
+  }),
+  category: "data-bearing"
+};
+var PERIOD_CONFIG = {
+  "1h": { seconds: 3600, points: 60 },
+  "24h": { seconds: 86400, points: 96 },
+  "7d": { seconds: 604800, points: 168 },
+  "30d": { seconds: 2592e3, points: 120 },
+  "90d": { seconds: 7776e3, points: 180 },
+  "1y": { seconds: 31536e3, points: 200 }
+};
+var tonChartExecutor = async (params, context) => {
+  try {
+    const token = params.token || "ton";
+    const period = params.period || "7d";
+    const config = PERIOD_CONFIG[period];
+    if (!config) {
+      return {
+        success: false,
+        error: `Invalid period "${period}". Use one of: ${Object.keys(PERIOD_CONFIG).join(", ")}`
+      };
+    }
+    const endDate = Math.floor(Date.now() / 1e3);
+    const startDate = endDate - config.seconds;
+    const url = `/rates/chart?token=${encodeURIComponent(token)}&currency=usd&start_date=${startDate}&end_date=${endDate}&points_count=${config.points}`;
+    const res = await tonapiFetch(url);
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      return {
+        success: false,
+        error: `TonAPI returned ${res.status}: ${text || res.statusText}`
+      };
+    }
+    const data = await res.json();
+    if (!Array.isArray(data.points) || data.points.length === 0) {
+      return {
+        success: false,
+        error: `No price data available for token "${token}" over period "${period}".`
+      };
+    }
+    const rawPoints = data.points;
+    const sorted = [...rawPoints].sort((a, b) => a[0] - b[0]);
+    const points = sorted.map(([ts, price]) => ({
+      timestamp: ts,
+      date: new Date(ts * 1e3).toISOString(),
+      price
+    }));
+    const prices = points.map((p2) => p2.price);
+    const startPrice = prices[0];
+    const currentPrice = prices[prices.length - 1];
+    const minPrice = Math.min(...prices);
+    const maxPrice = Math.max(...prices);
+    const changeAbsolute = currentPrice - startPrice;
+    const changePercent = startPrice !== 0 ? changeAbsolute / startPrice * 100 : 0;
+    const minIdx = prices.indexOf(minPrice);
+    const maxIdx = prices.indexOf(maxPrice);
+    const stats = {
+      currentPrice,
+      startPrice,
+      minPrice,
+      maxPrice,
+      changePercent: Math.round(changePercent * 100) / 100,
+      changeAbsolute: Math.round(changeAbsolute * 1e6) / 1e6,
+      high: { price: maxPrice, date: points[maxIdx].date },
+      low: { price: minPrice, date: points[minIdx].date }
+    };
+    const direction = changePercent >= 0 ? "+" : "";
+    const tokenLabel = token === "ton" ? "TON" : token;
+    const message = `${tokenLabel} price over ${period}: $${currentPrice.toFixed(4)} (${direction}${stats.changePercent}%). Low: $${minPrice.toFixed(4)}, High: $${maxPrice.toFixed(4)}. ${points.length} data points.`;
+    return {
+      success: true,
+      data: {
+        token: tokenLabel,
+        period,
+        points,
+        stats,
+        message
+      }
+    };
+  } catch (error) {
+    console.error("Error in ton_chart:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+};
+
+// src/agent/tools/ton/nft-list.ts
+import { Type as Type79 } from "@sinclair/typebox";
+var nftListTool = {
+  name: "nft_list",
+  description: "List NFTs owned by a TON wallet. Defaults to the agent's own wallet. Can filter by collection address.",
+  parameters: Type79.Object({
+    address: Type79.Optional(
+      Type79.String({
+        description: "TON wallet address to query. Defaults to the agent's wallet."
+      })
+    ),
+    collection: Type79.Optional(
+      Type79.String({
+        description: "Filter by collection contract address."
+      })
+    ),
+    limit: Type79.Optional(
+      Type79.Number({
+        description: "Max NFTs to return (1-100). Defaults to 50.",
+        minimum: 1,
+        maximum: 100
+      })
+    )
+  }),
+  category: "data-bearing"
+};
+var nftListExecutor = async (params, context) => {
+  try {
+    const address4 = params.address || getWalletAddress();
+    if (!address4) {
+      return {
+        success: false,
+        error: "No address provided and agent wallet is not initialized."
+      };
+    }
+    const limit = params.limit || 50;
+    const queryParts = [`limit=${limit}`, "indirect_ownership=true"];
+    if (params.collection) {
+      queryParts.push(`collection=${encodeURIComponent(params.collection)}`);
+    }
+    const url = `/accounts/${encodeURIComponent(address4)}/nfts?${queryParts.join("&")}`;
+    const res = await tonapiFetch(url);
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      return {
+        success: false,
+        error: `TonAPI returned ${res.status}: ${text || res.statusText}`
+      };
+    }
+    const data = await res.json();
+    if (!Array.isArray(data.nft_items)) {
+      return {
+        success: false,
+        error: "Invalid API response: missing nft_items array"
+      };
+    }
+    const rawItems = data.nft_items;
+    const filtered = rawItems.filter((item) => item.trust !== "blacklist");
+    const nfts = filtered.map((item) => {
+      const meta = item.metadata || {};
+      const coll = item.collection || {};
+      const sale = item.sale;
+      const previews = item.previews || [];
+      const preview = previews.length > 1 && previews[1].url || previews.length > 0 && previews[0].url || null;
+      let salePrice = null;
+      if (sale?.price?.value) {
+        const raw = Number(sale.price.value);
+        if (!isNaN(raw) && raw > 0) {
+          const amount = raw / 1e9;
+          const currency = sale.price.token_name || "TON";
+          salePrice = `${amount} ${currency}`;
+        }
+      }
+      return {
+        address: item.address,
+        name: meta.name || "Unnamed NFT",
+        description: (meta.description || "").slice(0, 100),
+        collection: coll.name || null,
+        collectionAddress: coll.address || null,
+        preview,
+        onSale: !!sale,
+        salePrice,
+        marketplace: sale?.marketplace || null,
+        dns: item.dns || null,
+        trust: item.trust || "none",
+        explorer: `https://tonviewer.com/${item.address}`
+      };
+    });
+    const hasMore = rawItems.length >= limit;
+    const summary = `Found ${nfts.length} NFT(s) for ${address4}${params.collection ? ` in collection ${params.collection}` : ""}${hasMore ? ` (limit ${limit} reached, there may be more)` : ""}.`;
+    const onSaleCount = nfts.filter((n2) => n2.onSale).length;
+    const collections = [...new Set(nfts.map((n2) => n2.collection).filter(Boolean))];
+    const message = `${summary}${onSaleCount > 0 ? ` ${onSaleCount} on sale.` : ""} Collections: ${collections.length > 0 ? collections.join(", ") : "none"}.`;
+    return {
+      success: true,
+      data: {
+        address: address4,
+        totalNfts: nfts.length,
+        hasMore,
+        nfts,
+        message,
+        summary
+      }
+    };
+  } catch (error) {
+    console.error("Error in nft_list:", error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+};
+
 // src/agent/tools/ton/index.ts
 var tools16 = [
   { tool: tonSendTool, executor: tonSendExecutor, scope: "dm-only" },
@@ -15600,16 +15830,18 @@ var tools16 = [
   { tool: tonGetBalanceTool, executor: tonGetBalanceExecutor },
   { tool: tonPriceTool, executor: tonPriceExecutor },
   { tool: tonGetTransactionsTool, executor: tonGetTransactionsExecutor },
-  { tool: tonMyTransactionsTool, executor: tonMyTransactionsExecutor }
+  { tool: tonMyTransactionsTool, executor: tonMyTransactionsExecutor },
+  { tool: tonChartTool, executor: tonChartExecutor },
+  { tool: nftListTool, executor: nftListExecutor }
 ];
 
 // src/agent/tools/dns/check.ts
-import { Type as Type78 } from "@sinclair/typebox";
+import { Type as Type80 } from "@sinclair/typebox";
 var dnsCheckTool = {
   name: "dns_check",
   description: "Check if a .ton domain is available, in auction, or already owned. Returns status with relevant details (price estimates, current bids, owner info).",
-  parameters: Type78.Object({
-    domain: Type78.String({
+  parameters: Type80.Object({
+    domain: Type80.String({
       description: "Domain name to check (with or without .ton extension)"
     })
   })
@@ -15723,13 +15955,13 @@ var dnsCheckExecutor = async (params, context) => {
 };
 
 // src/agent/tools/dns/auctions.ts
-import { Type as Type79 } from "@sinclair/typebox";
+import { Type as Type81 } from "@sinclair/typebox";
 var dnsAuctionsTool = {
   name: "dns_auctions",
   description: "List all active .ton domain auctions. Returns domains currently in auction with current bid prices, number of bids, and end times.",
-  parameters: Type79.Object({
-    limit: Type79.Optional(
-      Type79.Number({
+  parameters: Type81.Object({
+    limit: Type81.Optional(
+      Type81.Number({
         description: "Maximum number of auctions to return (default: 20, max: 100)",
         minimum: 1,
         maximum: 100
@@ -15794,12 +16026,12 @@ ${summary}`
 };
 
 // src/agent/tools/dns/resolve.ts
-import { Type as Type80 } from "@sinclair/typebox";
+import { Type as Type82 } from "@sinclair/typebox";
 var dnsResolveTool = {
   name: "dns_resolve",
   description: "Resolve a .ton domain to its associated wallet address. Only works for domains that are already owned (not available or in auction).",
-  parameters: Type80.Object({
-    domain: Type80.String({
+  parameters: Type82.Object({
+    domain: Type82.String({
       description: "Domain name to resolve (with or without .ton extension)"
     })
   })
@@ -15855,7 +16087,7 @@ var dnsResolveExecutor = async (params, context) => {
 };
 
 // src/agent/tools/dns/start-auction.ts
-import { Type as Type81 } from "@sinclair/typebox";
+import { Type as Type83 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey4 } from "@ton/crypto";
 import { WalletContractV5R1 as WalletContractV5R14, TonClient as TonClient7, toNano as toNano3, internal as internal3, beginCell } from "@ton/ton";
 import { Address as Address6, SendMode as SendMode3 } from "@ton/core";
@@ -15863,11 +16095,11 @@ var DNS_COLLECTION = "EQC3dNlesgVD8YbAazcauIrXBPfiVhMMr5YYk2in0Mtsz0Bz";
 var dnsStartAuctionTool = {
   name: "dns_start_auction",
   description: "Start an auction for an unminted .ton domain. Sends TON to the DNS collection contract to mint a new domain NFT. Domain must be 4-126 characters, available (not minted), and amount must meet minimum price.",
-  parameters: Type81.Object({
-    domain: Type81.String({
+  parameters: Type83.Object({
+    domain: Type83.String({
       description: "Domain name to mint (without .ton extension, 4-126 chars)"
     }),
-    amount: Type81.Number({
+    amount: Type83.Number({
       description: "Bid amount in TON (must meet minimum: ~100 TON for 4 chars, ~1 TON for 11+ chars)",
       minimum: 1
     })
@@ -15942,18 +16174,18 @@ var dnsStartAuctionExecutor = async (params, context) => {
 };
 
 // src/agent/tools/dns/bid.ts
-import { Type as Type82 } from "@sinclair/typebox";
+import { Type as Type84 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey5 } from "@ton/crypto";
 import { WalletContractV5R1 as WalletContractV5R15, TonClient as TonClient8, toNano as toNano4, internal as internal4 } from "@ton/ton";
 import { Address as Address7, SendMode as SendMode4 } from "@ton/core";
 var dnsBidTool = {
   name: "dns_bid",
   description: "Place a bid on an existing .ton domain auction. Bid must be at least 5% higher than current bid. The domain must already be in auction (use dns_check first to verify status and get current bid).",
-  parameters: Type82.Object({
-    domain: Type82.String({
+  parameters: Type84.Object({
+    domain: Type84.String({
       description: "Domain name (with or without .ton extension)"
     }),
-    amount: Type82.Number({
+    amount: Type84.Number({
       description: "Bid amount in TON (must be >= 105% of current bid)",
       minimum: 1
     })
@@ -16059,7 +16291,7 @@ var dnsBidExecutor = async (params, context) => {
 };
 
 // src/agent/tools/dns/link.ts
-import { Type as Type83 } from "@sinclair/typebox";
+import { Type as Type85 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey6 } from "@ton/crypto";
 import { WalletContractV5R1 as WalletContractV5R16, TonClient as TonClient9, toNano as toNano5, internal as internal5, beginCell as beginCell2 } from "@ton/ton";
 import { Address as Address8, SendMode as SendMode5 } from "@ton/core";
@@ -16071,12 +16303,12 @@ var WALLET_RECORD_KEY = BigInt(
 var dnsLinkTool = {
   name: "dns_link",
   description: "Link a wallet address to a .ton domain you own. This sets the wallet record so the domain resolves to the specified address. If no wallet_address is provided, links to your own wallet.",
-  parameters: Type83.Object({
-    domain: Type83.String({
+  parameters: Type85.Object({
+    domain: Type85.String({
       description: "Domain name (with or without .ton extension)"
     }),
-    wallet_address: Type83.Optional(
-      Type83.String({
+    wallet_address: Type85.Optional(
+      Type85.String({
         description: "Wallet address to link (defaults to your wallet if not specified)"
       })
     )
@@ -16186,7 +16418,7 @@ var dnsLinkExecutor = async (params, context) => {
 };
 
 // src/agent/tools/dns/unlink.ts
-import { Type as Type84 } from "@sinclair/typebox";
+import { Type as Type86 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey7 } from "@ton/crypto";
 import { WalletContractV5R1 as WalletContractV5R17, TonClient as TonClient10, toNano as toNano6, internal as internal6, beginCell as beginCell3 } from "@ton/ton";
 import { Address as Address9, SendMode as SendMode6 } from "@ton/core";
@@ -16197,8 +16429,8 @@ var WALLET_RECORD_KEY2 = BigInt(
 var dnsUnlinkTool = {
   name: "dns_unlink",
   description: "Remove the wallet link from a .ton domain you own. This deletes the wallet record so the domain no longer resolves to any address.",
-  parameters: Type84.Object({
-    domain: Type84.String({
+  parameters: Type86.Object({
+    domain: Type86.String({
       description: "Domain name (with or without .ton extension)"
     })
   })
@@ -16307,11 +16539,11 @@ var tools17 = [
 ];
 
 // src/agent/tools/jetton/balances.ts
-import { Type as Type85 } from "@sinclair/typebox";
+import { Type as Type87 } from "@sinclair/typebox";
 var jettonBalancesTool = {
   name: "jetton_balances",
   description: "Get all Jetton (token) balances owned by the agent. Returns a list of all tokens with their balances, names, symbols, and verification status. Useful to check what tokens you currently hold.",
-  parameters: Type85.Object({}),
+  parameters: Type87.Object({}),
   category: "data-bearing"
 };
 var jettonBalancesExecutor = async (params, context) => {
@@ -16412,7 +16644,7 @@ var jettonBalancesExecutor = async (params, context) => {
 };
 
 // src/agent/tools/jetton/swap.ts
-import { Type as Type86 } from "@sinclair/typebox";
+import { Type as Type88 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey8 } from "@ton/crypto";
 import { WalletContractV5R1 as WalletContractV5R18, TonClient as TonClient11, toNano as toNano19, internal as internal7 } from "@ton/ton";
 import { SendMode as SendMode7 } from "@ton/core";
@@ -19741,19 +19973,19 @@ var NATIVE_TON_ADDRESS = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
 var jettonSwapTool = {
   name: "jetton_swap",
   description: "Swap tokens on STON.fi DEX. Supports TON\u2194Jetton and Jetton\u2194Jetton swaps. Use 'ton' as from_asset to buy jettons with TON, or provide jetton master address. Amount is in human-readable units (will be converted based on decimals). Example: swap 10 TON for USDT, or swap USDT for SCALE.",
-  parameters: Type86.Object({
-    from_asset: Type86.String({
+  parameters: Type88.Object({
+    from_asset: Type88.String({
       description: "Source asset: 'ton' for TON, or jetton master address (EQ... format)"
     }),
-    to_asset: Type86.String({
+    to_asset: Type88.String({
       description: "Destination jetton master address (EQ... format)"
     }),
-    amount: Type86.Number({
+    amount: Type88.Number({
       description: "Amount to swap in human-readable units (e.g., 10 for 10 TON or 10 tokens)",
       minimum: 1e-3
     }),
-    slippage: Type86.Optional(
-      Type86.Number({
+    slippage: Type88.Optional(
+      Type88.Number({
         description: "Slippage tolerance (0.01 = 1%, default: 0.01)",
         minimum: 1e-3,
         maximum: 0.5
@@ -19871,7 +20103,7 @@ var jettonSwapExecutor = async (params, context) => {
 };
 
 // src/agent/tools/jetton/send.ts
-import { Type as Type87 } from "@sinclair/typebox";
+import { Type as Type89 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey9 } from "@ton/crypto";
 import { WalletContractV5R1 as WalletContractV5R19, TonClient as TonClient12, toNano as toNano20, internal as internal8 } from "@ton/ton";
 import { Address as Address13, SendMode as SendMode8, beginCell as beginCell15 } from "@ton/core";
@@ -19879,19 +20111,19 @@ var JETTON_TRANSFER_OP = 260734629;
 var jettonSendTool = {
   name: "jetton_send",
   description: "Send Jettons (tokens) to another address. Requires the jetton master address, recipient address, and amount. Amount is in human-readable units (e.g., 10 for 10 USDT). Use jetton_balances first to see what tokens you own and their addresses.",
-  parameters: Type87.Object({
-    jetton_address: Type87.String({
+  parameters: Type89.Object({
+    jetton_address: Type89.String({
       description: "Jetton master contract address (EQ... or 0:... format)"
     }),
-    to: Type87.String({
+    to: Type89.String({
       description: "Recipient TON address (EQ... or UQ... format)"
     }),
-    amount: Type87.Number({
+    amount: Type89.Number({
       description: "Amount to send in human-readable units (e.g., 10 for 10 tokens)",
       minimum: 0
     }),
-    comment: Type87.Optional(
-      Type87.String({
+    comment: Type89.Optional(
+      Type89.String({
         description: "Optional comment/memo to include with the transfer"
       })
     )
@@ -19995,12 +20227,12 @@ var jettonSendExecutor = async (params, context) => {
 };
 
 // src/agent/tools/jetton/info.ts
-import { Type as Type88 } from "@sinclair/typebox";
+import { Type as Type90 } from "@sinclair/typebox";
 var jettonInfoTool = {
   name: "jetton_info",
   description: "Get detailed information about a Jetton (token) by its master contract address. Returns name, symbol, decimals, total supply, holders count, and verification status. Useful to research a token before buying or sending.",
-  parameters: Type88.Object({
-    jetton_address: Type88.String({
+  parameters: Type90.Object({
+    jetton_address: Type90.String({
       description: "Jetton master contract address (EQ... or 0:... format)"
     })
   })
@@ -20090,12 +20322,12 @@ function formatLargeNumber(num) {
 }
 
 // src/agent/tools/jetton/price.ts
-import { Type as Type89 } from "@sinclair/typebox";
+import { Type as Type91 } from "@sinclair/typebox";
 var jettonPriceTool = {
   name: "jetton_price",
   description: "Get the current price of a Jetton (token) in USD and TON, along with 24h, 7d, and 30d price changes. Useful to check token value before swapping or to monitor investments.",
-  parameters: Type89.Object({
-    jetton_address: Type89.String({
+  parameters: Type91.Object({
+    jetton_address: Type91.String({
       description: "Jetton master contract address (EQ... or 0:... format)"
     })
   })
@@ -20188,17 +20420,17 @@ var jettonPriceExecutor = async (params, context) => {
 };
 
 // src/agent/tools/jetton/search.ts
-import { Type as Type90 } from "@sinclair/typebox";
+import { Type as Type92 } from "@sinclair/typebox";
 var jettonSearchTool = {
   name: "jetton_search",
   description: "Search for Jettons (tokens) by name or symbol. Returns a list of matching tokens with their addresses, useful for finding a token's address before swapping or checking prices. Search is case-insensitive.",
-  parameters: Type90.Object({
-    query: Type90.String({
+  parameters: Type92.Object({
+    query: Type92.String({
       description: "Search query - token name or symbol (e.g., 'usdt', 'scale', 'not')",
       minLength: 1
     }),
-    limit: Type90.Optional(
-      Type90.Number({
+    limit: Type92.Optional(
+      Type92.Number({
         description: "Maximum number of results to return (default: 10, max: 50)",
         minimum: 1,
         maximum: 50
@@ -20307,25 +20539,25 @@ var jettonSearchExecutor = async (params, context) => {
 };
 
 // src/agent/tools/jetton/quote.ts
-import { Type as Type91 } from "@sinclair/typebox";
+import { Type as Type93 } from "@sinclair/typebox";
 import { toNano as toNano21 } from "@ton/ton";
 var NATIVE_TON_ADDRESS2 = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
 var jettonQuoteTool = {
   name: "jetton_quote",
   description: "Get a price quote for a token swap WITHOUT executing it. Shows expected output, minimum output, price impact, and fees. Use this to preview a swap before committing. Use 'ton' as from_asset for TON, or jetton master address.",
-  parameters: Type91.Object({
-    from_asset: Type91.String({
+  parameters: Type93.Object({
+    from_asset: Type93.String({
       description: "Source asset: 'ton' for TON, or jetton master address (EQ... format)"
     }),
-    to_asset: Type91.String({
+    to_asset: Type93.String({
       description: "Destination jetton master address (EQ... format)"
     }),
-    amount: Type91.Number({
+    amount: Type93.Number({
       description: "Amount to swap in human-readable units",
       minimum: 1e-3
     }),
-    slippage: Type91.Optional(
-      Type91.Number({
+    slippage: Type93.Optional(
+      Type93.Number({
         description: "Slippage tolerance (0.01 = 1%, default: 0.01)",
         minimum: 1e-3,
         maximum: 0.5
@@ -20411,16 +20643,16 @@ var jettonQuoteExecutor = async (params, context) => {
 };
 
 // src/agent/tools/jetton/holders.ts
-import { Type as Type92 } from "@sinclair/typebox";
+import { Type as Type94 } from "@sinclair/typebox";
 var jettonHoldersTool = {
   name: "jetton_holders",
   description: "Get the top holders of a Jetton (token). Shows wallet addresses and their balances. Useful to analyze token distribution and identify whale wallets.",
-  parameters: Type92.Object({
-    jetton_address: Type92.String({
+  parameters: Type94.Object({
+    jetton_address: Type94.String({
       description: "Jetton master contract address (EQ... or 0:... format)"
     }),
-    limit: Type92.Optional(
-      Type92.Number({
+    limit: Type94.Optional(
+      Type94.Number({
         description: "Number of top holders to return (default: 10, max: 100)",
         minimum: 1,
         maximum: 100
@@ -20505,12 +20737,12 @@ var jettonHoldersExecutor = async (params, context) => {
 };
 
 // src/agent/tools/jetton/history.ts
-import { Type as Type93 } from "@sinclair/typebox";
+import { Type as Type95 } from "@sinclair/typebox";
 var jettonHistoryTool = {
   name: "jetton_history",
   description: "Get price history and performance data for a Jetton. Shows price changes over 24h, 7d, 30d periods, along with volume and market data. Useful for analyzing token trends.",
-  parameters: Type93.Object({
-    jetton_address: Type93.String({
+  parameters: Type95.Object({
+    jetton_address: Type95.String({
       description: "Jetton master contract address (EQ... format)"
     })
   })
@@ -20630,13 +20862,13 @@ var jettonHistoryExecutor = async (params, context) => {
 };
 
 // src/agent/tools/jetton/trending.ts
-import { Type as Type94 } from "@sinclair/typebox";
+import { Type as Type96 } from "@sinclair/typebox";
 var jettonTrendingTool = {
   name: "jetton_trending",
   description: "Get trending/popular Jettons on the TON blockchain. Shows tokens ranked by trading volume and liquidity. Useful for discovering popular tokens.",
-  parameters: Type94.Object({
-    limit: Type94.Optional(
-      Type94.Number({
+  parameters: Type96.Object({
+    limit: Type96.Optional(
+      Type96.Number({
         description: "Number of trending tokens to return (default: 10, max: 50)",
         minimum: 1,
         maximum: 50
@@ -20703,18 +20935,18 @@ var jettonTrendingExecutor = async (params, context) => {
 };
 
 // src/agent/tools/jetton/pools.ts
-import { Type as Type95 } from "@sinclair/typebox";
+import { Type as Type97 } from "@sinclair/typebox";
 var jettonPoolsTool = {
   name: "jetton_pools",
   description: "Get liquidity pools for a Jetton or list top pools by volume. Shows pool addresses, liquidity, volume, APY, and trading pairs. Useful for finding where to trade a token or analyzing DeFi opportunities.",
-  parameters: Type95.Object({
-    jetton_address: Type95.Optional(
-      Type95.String({
+  parameters: Type97.Object({
+    jetton_address: Type97.Optional(
+      Type97.String({
         description: "Jetton address to filter pools (optional - if not provided, returns top pools)"
       })
     ),
-    limit: Type95.Optional(
-      Type95.Number({
+    limit: Type97.Optional(
+      Type97.Number({
         description: "Number of pools to return (default: 10, max: 50)",
         minimum: 1,
         maximum: 50
@@ -20830,7 +21062,7 @@ var tools18 = [
 ];
 
 // src/agent/tools/dedust/quote.ts
-import { Type as Type96 } from "@sinclair/typebox";
+import { Type as Type98 } from "@sinclair/typebox";
 import { TonClient as TonClient13, toNano as toNano22, fromNano as fromNano5 } from "@ton/ton";
 import { Address as Address14 } from "@ton/core";
 import { Factory, Asset, PoolType, ReadinessStatus } from "@dedust/sdk";
@@ -20854,24 +21086,24 @@ var NATIVE_TON_ADDRESS3 = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
 var dedustQuoteTool = {
   name: "dedust_quote",
   description: "Get a price quote for a token swap on DeDust DEX WITHOUT executing it. Shows expected output, minimum output, and pool info. Use 'ton' as from_asset for TON, or jetton master address. Pool types: 'volatile' (default) or 'stable' (for stablecoins).",
-  parameters: Type96.Object({
-    from_asset: Type96.String({
+  parameters: Type98.Object({
+    from_asset: Type98.String({
       description: "Source asset: 'ton' for TON, or jetton master address (EQ... format)"
     }),
-    to_asset: Type96.String({
+    to_asset: Type98.String({
       description: "Destination asset: 'ton' for TON, or jetton master address (EQ... format)"
     }),
-    amount: Type96.Number({
+    amount: Type98.Number({
       description: "Amount to swap in human-readable units",
       minimum: 1e-3
     }),
-    pool_type: Type96.Optional(
-      Type96.Union([Type96.Literal("volatile"), Type96.Literal("stable")], {
+    pool_type: Type98.Optional(
+      Type98.Union([Type98.Literal("volatile"), Type98.Literal("stable")], {
         description: "Pool type: 'volatile' (default) or 'stable' for stablecoin pairs"
       })
     ),
-    slippage: Type96.Optional(
-      Type96.Number({
+    slippage: Type98.Optional(
+      Type98.Number({
         description: "Slippage tolerance (0.01 = 1%, default: 0.01)",
         minimum: 1e-3,
         maximum: 0.5
@@ -20986,7 +21218,7 @@ var dedustQuoteExecutor = async (params, context) => {
 };
 
 // src/agent/tools/dedust/swap.ts
-import { Type as Type97 } from "@sinclair/typebox";
+import { Type as Type99 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey10 } from "@ton/crypto";
 import { WalletContractV5R1 as WalletContractV5R110, TonClient as TonClient14, toNano as toNano23, fromNano as fromNano6 } from "@ton/ton";
 import { Address as Address15 } from "@ton/core";
@@ -20994,24 +21226,24 @@ import { Factory as Factory2, Asset as Asset2, PoolType as PoolType2, ReadinessS
 var dedustSwapTool = {
   name: "dedust_swap",
   description: "Execute a token swap on DeDust DEX. Supports TON->Jetton and Jetton->TON/Jetton swaps. Use 'ton' as from_asset or to_asset for TON. Pool types: 'volatile' (default) or 'stable' (for stablecoins like USDT/USDC). Use dedust_quote first to preview the swap.",
-  parameters: Type97.Object({
-    from_asset: Type97.String({
+  parameters: Type99.Object({
+    from_asset: Type99.String({
       description: "Source asset: 'ton' for TON, or jetton master address (EQ... format)"
     }),
-    to_asset: Type97.String({
+    to_asset: Type99.String({
       description: "Destination asset: 'ton' for TON, or jetton master address (EQ... format)"
     }),
-    amount: Type97.Number({
+    amount: Type99.Number({
       description: "Amount to swap in human-readable units (e.g., 10 for 10 TON or 10 tokens)",
       minimum: 1e-3
     }),
-    pool_type: Type97.Optional(
-      Type97.Union([Type97.Literal("volatile"), Type97.Literal("stable")], {
+    pool_type: Type99.Optional(
+      Type99.Union([Type99.Literal("volatile"), Type99.Literal("stable")], {
         description: "Pool type: 'volatile' (default) or 'stable' for stablecoin pairs"
       })
     ),
-    slippage: Type97.Optional(
-      Type97.Number({
+    slippage: Type99.Optional(
+      Type99.Number({
         description: "Slippage tolerance (0.01 = 1%, default: 0.01)",
         minimum: 1e-3,
         maximum: 0.5
@@ -21157,23 +21389,23 @@ var dedustSwapExecutor = async (params, context) => {
 };
 
 // src/agent/tools/dedust/pools.ts
-import { Type as Type98 } from "@sinclair/typebox";
+import { Type as Type100 } from "@sinclair/typebox";
 var dedustPoolsTool = {
   name: "dedust_pools",
   description: "List liquidity pools on DeDust DEX. Can filter by jetton address or pool type. Shows reserves, fees, and trading volume.",
-  parameters: Type98.Object({
-    jetton_address: Type98.Optional(
-      Type98.String({
+  parameters: Type100.Object({
+    jetton_address: Type100.Optional(
+      Type100.String({
         description: "Filter by jetton master address (EQ... format) to find pools containing this token"
       })
     ),
-    pool_type: Type98.Optional(
-      Type98.Union([Type98.Literal("volatile"), Type98.Literal("stable")], {
+    pool_type: Type100.Optional(
+      Type100.Union([Type100.Literal("volatile"), Type100.Literal("stable")], {
         description: "Filter by pool type: 'volatile' or 'stable'"
       })
     ),
-    limit: Type98.Optional(
-      Type98.Number({
+    limit: Type100.Optional(
+      Type100.Number({
         description: "Maximum number of pools to return (default: 20)",
         minimum: 1,
         maximum: 100
@@ -21289,26 +21521,26 @@ var tools19 = [
 ];
 
 // src/agent/tools/dex/smart-quote.ts
-import { Type as Type99 } from "@sinclair/typebox";
+import { Type as Type101 } from "@sinclair/typebox";
 import { TonClient as TonClient15, toNano as toNano24, fromNano as fromNano7 } from "@ton/ton";
 import { Address as Address16 } from "@ton/core";
 import { Factory as Factory3, Asset as Asset3, PoolType as PoolType3, ReadinessStatus as ReadinessStatus3 } from "@dedust/sdk";
 var dexQuoteTool = {
   name: "dex_quote",
   description: "Smart router that compares quotes from STON.fi and DeDust DEX to find the best price. Returns comparison table with expected outputs, fees, and recommends the best DEX for your swap. Use 'ton' for TON or jetton master address.",
-  parameters: Type99.Object({
-    from_asset: Type99.String({
+  parameters: Type101.Object({
+    from_asset: Type101.String({
       description: "Source asset: 'ton' for TON, or jetton master address (EQ... format)"
     }),
-    to_asset: Type99.String({
+    to_asset: Type101.String({
       description: "Destination asset: 'ton' for TON, or jetton master address (EQ... format)"
     }),
-    amount: Type99.Number({
+    amount: Type101.Number({
       description: "Amount to swap in human-readable units",
       minimum: 1e-3
     }),
-    slippage: Type99.Optional(
-      Type99.Number({
+    slippage: Type101.Optional(
+      Type101.Number({
         description: "Slippage tolerance (0.01 = 1%, default: 0.01)",
         minimum: 1e-3,
         maximum: 0.5
@@ -21546,7 +21778,7 @@ Use dex_swap to execute on the best DEX, or jetton_swap/dedust_swap for specific
 };
 
 // src/agent/tools/dex/smart-swap.ts
-import { Type as Type100 } from "@sinclair/typebox";
+import { Type as Type102 } from "@sinclair/typebox";
 import { mnemonicToPrivateKey as mnemonicToPrivateKey11 } from "@ton/crypto";
 import { WalletContractV5R1 as WalletContractV5R111, TonClient as TonClient16, toNano as toNano25, fromNano as fromNano8 } from "@ton/ton";
 import { Address as Address17, SendMode as SendMode9, internal as internal9 } from "@ton/core";
@@ -21554,26 +21786,26 @@ import { Factory as Factory4, Asset as Asset4, PoolType as PoolType4, ReadinessS
 var dexSwapTool = {
   name: "dex_swap",
   description: "Smart router that executes swap on the best DEX (STON.fi or DeDust). Automatically compares prices and routes to the DEX with better output. Use preferred_dex to force a specific DEX. Use 'ton' for TON or jetton master address.",
-  parameters: Type100.Object({
-    from_asset: Type100.String({
+  parameters: Type102.Object({
+    from_asset: Type102.String({
       description: "Source asset: 'ton' for TON, or jetton master address (EQ... format)"
     }),
-    to_asset: Type100.String({
+    to_asset: Type102.String({
       description: "Destination asset: 'ton' for TON, or jetton master address (EQ... format)"
     }),
-    amount: Type100.Number({
+    amount: Type102.Number({
       description: "Amount to swap in human-readable units",
       minimum: 1e-3
     }),
-    slippage: Type100.Optional(
-      Type100.Number({
+    slippage: Type102.Optional(
+      Type102.Number({
         description: "Slippage tolerance (0.01 = 1%, default: 0.01)",
         minimum: 1e-3,
         maximum: 0.5
       })
     ),
-    preferred_dex: Type100.Optional(
-      Type100.Union([Type100.Literal("stonfi"), Type100.Literal("dedust"), Type100.Literal("auto")], {
+    preferred_dex: Type102.Optional(
+      Type102.Union([Type102.Literal("stonfi"), Type102.Literal("dedust"), Type102.Literal("auto")], {
         description: "Preferred DEX: 'auto' (default, best price), 'stonfi', or 'dedust'"
       })
     )
@@ -21890,7 +22122,7 @@ var tools20 = [
 ];
 
 // src/agent/tools/journal/log.ts
-import { Type as Type101 } from "@sinclair/typebox";
+import { Type as Type103 } from "@sinclair/typebox";
 var journalLogTool = {
   name: "journal_log",
   description: `Log a business operation to the trading journal.
@@ -21908,44 +22140,44 @@ Examples:
 - gift: "Sold Deluxe Heart at 120% floor - buyer was eager"
 - middleman: "Escrow for 150 TON gift trade - 3% fee"
 - kol: "Posted project review in channel - 75 TON fee"`,
-  parameters: Type101.Object({
-    type: Type101.Union(
-      [Type101.Literal("trade"), Type101.Literal("gift"), Type101.Literal("middleman"), Type101.Literal("kol")],
+  parameters: Type103.Object({
+    type: Type103.Union(
+      [Type103.Literal("trade"), Type103.Literal("gift"), Type103.Literal("middleman"), Type103.Literal("kol")],
       { description: "Type of operation" }
     ),
-    action: Type101.String({
+    action: Type103.String({
       description: "Brief action description (e.g., 'buy', 'sell', 'swap', 'escrow', 'post')"
     }),
-    asset_from: Type101.Optional(
-      Type101.String({ description: "Asset sent/sold (e.g., 'TON', 'USDT', 'Deluxe Heart')" })
+    asset_from: Type103.Optional(
+      Type103.String({ description: "Asset sent/sold (e.g., 'TON', 'USDT', 'Deluxe Heart')" })
     ),
-    asset_to: Type101.Optional(Type101.String({ description: "Asset received/bought" })),
-    amount_from: Type101.Optional(Type101.Number({ description: "Amount sent/sold" })),
-    amount_to: Type101.Optional(Type101.Number({ description: "Amount received/bought" })),
-    price_ton: Type101.Optional(Type101.Number({ description: "Price in TON (for gifts, services)" })),
-    counterparty: Type101.Optional(
-      Type101.String({ description: "Username or ID of the other party (if applicable)" })
+    asset_to: Type103.Optional(Type103.String({ description: "Asset received/bought" })),
+    amount_from: Type103.Optional(Type103.Number({ description: "Amount sent/sold" })),
+    amount_to: Type103.Optional(Type103.Number({ description: "Amount received/bought" })),
+    price_ton: Type103.Optional(Type103.Number({ description: "Price in TON (for gifts, services)" })),
+    counterparty: Type103.Optional(
+      Type103.String({ description: "Username or ID of the other party (if applicable)" })
     ),
-    platform: Type101.Optional(
-      Type101.String({ description: "Platform used (e.g., 'STON.fi', 'Telegram', 'DeDust')" })
+    platform: Type103.Optional(
+      Type103.String({ description: "Platform used (e.g., 'STON.fi', 'Telegram', 'DeDust')" })
     ),
-    reasoning: Type101.String({
+    reasoning: Type103.String({
       description: "WHY you took this action - explain your decision-making (this is CRITICAL for learning and auditing)"
     }),
-    outcome: Type101.Optional(
-      Type101.Union(
+    outcome: Type103.Optional(
+      Type103.Union(
         [
-          Type101.Literal("pending"),
-          Type101.Literal("profit"),
-          Type101.Literal("loss"),
-          Type101.Literal("neutral"),
-          Type101.Literal("cancelled")
+          Type103.Literal("pending"),
+          Type103.Literal("profit"),
+          Type103.Literal("loss"),
+          Type103.Literal("neutral"),
+          Type103.Literal("cancelled")
         ],
         { description: "Outcome status (default: 'pending')" }
       )
     ),
-    tx_hash: Type101.Optional(
-      Type101.String({ description: "Blockchain transaction hash (if applicable)" })
+    tx_hash: Type103.Optional(
+      Type103.String({ description: "Blockchain transaction hash (if applicable)" })
     )
   })
 };
@@ -22005,7 +22237,7 @@ var journalLogExecutor = async (params, context) => {
 };
 
 // src/agent/tools/journal/query.ts
-import { Type as Type102 } from "@sinclair/typebox";
+import { Type as Type104 } from "@sinclair/typebox";
 var journalQueryTool = {
   name: "journal_query",
   description: `Query the trading journal to analyze past operations.
@@ -22021,38 +22253,38 @@ Examples:
 - "What gifts did I sell this week?"
 - "Show all profitable TON trades"
 - "What's my win rate on crypto trades?"`,
-  parameters: Type102.Object({
-    type: Type102.Optional(
-      Type102.Union(
+  parameters: Type104.Object({
+    type: Type104.Optional(
+      Type104.Union(
         [
-          Type102.Literal("trade"),
-          Type102.Literal("gift"),
-          Type102.Literal("middleman"),
-          Type102.Literal("kol")
+          Type104.Literal("trade"),
+          Type104.Literal("gift"),
+          Type104.Literal("middleman"),
+          Type104.Literal("kol")
         ],
         { description: "Filter by operation type" }
       )
     ),
-    asset: Type102.Optional(
-      Type102.String({ description: "Filter by asset (e.g., 'TON', 'USDT', 'Deluxe Heart')" })
+    asset: Type104.Optional(
+      Type104.String({ description: "Filter by asset (e.g., 'TON', 'USDT', 'Deluxe Heart')" })
     ),
-    outcome: Type102.Optional(
-      Type102.Union(
+    outcome: Type104.Optional(
+      Type104.Union(
         [
-          Type102.Literal("pending"),
-          Type102.Literal("profit"),
-          Type102.Literal("loss"),
-          Type102.Literal("neutral"),
-          Type102.Literal("cancelled")
+          Type104.Literal("pending"),
+          Type104.Literal("profit"),
+          Type104.Literal("loss"),
+          Type104.Literal("neutral"),
+          Type104.Literal("cancelled")
         ],
         { description: "Filter by outcome status" }
       )
     ),
-    days: Type102.Optional(
-      Type102.Number({ description: "Limit to last N days (e.g., 7 for last week)", minimum: 1 })
+    days: Type104.Optional(
+      Type104.Number({ description: "Limit to last N days (e.g., 7 for last week)", minimum: 1 })
     ),
-    limit: Type102.Optional(
-      Type102.Number({ description: "Max number of results (default: 20)", minimum: 1 })
+    limit: Type104.Optional(
+      Type104.Number({ description: "Max number of results (default: 20)", minimum: 1 })
     )
   })
 };
@@ -22140,7 +22372,7 @@ var journalQueryExecutor = async (params) => {
 };
 
 // src/agent/tools/journal/update.ts
-import { Type as Type103 } from "@sinclair/typebox";
+import { Type as Type105 } from "@sinclair/typebox";
 var journalUpdateTool = {
   name: "journal_update",
   description: `Update a journal entry with outcome and P&L.
@@ -22159,25 +22391,25 @@ Examples:
 - "Close trade #42 - sold at profit"
 - "Mark gift sale #38 as complete"
 - "Update escrow #55 with tx hash"`,
-  parameters: Type103.Object({
-    id: Type103.Number({ description: "Journal entry ID to update" }),
-    outcome: Type103.Optional(
-      Type103.Union(
+  parameters: Type105.Object({
+    id: Type105.Number({ description: "Journal entry ID to update" }),
+    outcome: Type105.Optional(
+      Type105.Union(
         [
-          Type103.Literal("pending"),
-          Type103.Literal("profit"),
-          Type103.Literal("loss"),
-          Type103.Literal("neutral"),
-          Type103.Literal("cancelled")
+          Type105.Literal("pending"),
+          Type105.Literal("profit"),
+          Type105.Literal("loss"),
+          Type105.Literal("neutral"),
+          Type105.Literal("cancelled")
         ],
         { description: "Update outcome status" }
       )
     ),
-    pnl_ton: Type103.Optional(
-      Type103.Number({ description: "Profit/loss in TON (positive = profit, negative = loss)" })
+    pnl_ton: Type105.Optional(
+      Type105.Number({ description: "Profit/loss in TON (positive = profit, negative = loss)" })
     ),
-    pnl_pct: Type103.Optional(Type103.Number({ description: "Profit/loss percentage" })),
-    tx_hash: Type103.Optional(Type103.String({ description: "Add or update transaction hash" }))
+    pnl_pct: Type105.Optional(Type105.Number({ description: "Profit/loss percentage" })),
+    tx_hash: Type105.Optional(Type105.String({ description: "Add or update transaction hash" }))
   })
 };
 var journalUpdateExecutor = async (params) => {
@@ -22246,7 +22478,7 @@ var tools21 = [
 ];
 
 // src/agent/tools/workspace/list.ts
-import { Type as Type104 } from "@sinclair/typebox";
+import { Type as Type106 } from "@sinclair/typebox";
 import { readdirSync as readdirSync3, lstatSync as lstatSync2 } from "fs";
 import { join as join11 } from "path";
 var workspaceListTool = {
@@ -22261,19 +22493,19 @@ Your workspace is at ~/.teleton/workspace/ and contains:
 - temp/ (temporary files)
 
 You can ONLY access files within this workspace. Files outside (config.yaml, wallet.json, etc.) are protected.`,
-  parameters: Type104.Object({
-    path: Type104.Optional(
-      Type104.String({
+  parameters: Type106.Object({
+    path: Type106.Optional(
+      Type106.String({
         description: "Subdirectory to list (relative to workspace root). Leave empty for root."
       })
     ),
-    recursive: Type104.Optional(
-      Type104.Boolean({
+    recursive: Type106.Optional(
+      Type106.Boolean({
         description: "List files recursively (default: false)"
       })
     ),
-    filter: Type104.Optional(
-      Type104.String({
+    filter: Type106.Optional(
+      Type106.String({
         description: "Filter by type: 'all' (default), 'files', or 'directories'",
         enum: ["all", "files", "directories"]
       })
@@ -22345,7 +22577,7 @@ var workspaceListExecutor = async (params, _context) => {
 };
 
 // src/agent/tools/workspace/read.ts
-import { Type as Type105 } from "@sinclair/typebox";
+import { Type as Type107 } from "@sinclair/typebox";
 import { readFileSync as readFileSync13, lstatSync as lstatSync3 } from "fs";
 var workspaceReadTool = {
   name: "workspace_read",
@@ -22361,18 +22593,18 @@ Examples:
 - Read your memory: path="MEMORY.md"
 - Read today's log: path="memory/2024-01-15.md"
 - Read downloaded image info: path="downloads/image.jpg" (will return metadata only)`,
-  parameters: Type105.Object({
-    path: Type105.String({
+  parameters: Type107.Object({
+    path: Type107.String({
       description: "Path to file (relative to workspace root)"
     }),
-    encoding: Type105.Optional(
-      Type105.String({
+    encoding: Type107.Optional(
+      Type107.String({
         description: "File encoding: 'utf-8' (default) or 'base64'",
         enum: ["utf-8", "base64"]
       })
     ),
-    maxSize: Type105.Optional(
-      Type105.Number({
+    maxSize: Type107.Optional(
+      Type107.Number({
         description: "Max file size to read in bytes (default: 1MB)"
       })
     )
@@ -22447,7 +22679,7 @@ var workspaceReadExecutor = async (params, _context) => {
 };
 
 // src/agent/tools/workspace/write.ts
-import { Type as Type106 } from "@sinclair/typebox";
+import { Type as Type108 } from "@sinclair/typebox";
 import { writeFileSync as writeFileSync9, appendFileSync as appendFileSync3, mkdirSync as mkdirSync9, existsSync as existsSync13 } from "fs";
 import { dirname as dirname6 } from "path";
 var workspaceWriteTool = {
@@ -22464,26 +22696,26 @@ You CANNOT write to protected locations like config.yaml, wallet.json, etc.
 Examples:
 - Save a note: path="memory/note.md", content="..."
 - Prepare upload: path="uploads/message.txt", content="..."`,
-  parameters: Type106.Object({
-    path: Type106.String({
+  parameters: Type108.Object({
+    path: Type108.String({
       description: "Path to file (relative to workspace root)"
     }),
-    content: Type106.String({
+    content: Type108.String({
       description: "Content to write"
     }),
-    encoding: Type106.Optional(
-      Type106.String({
+    encoding: Type108.Optional(
+      Type108.String({
         description: "Content encoding: 'utf-8' (default) or 'base64'",
         enum: ["utf-8", "base64"]
       })
     ),
-    append: Type106.Optional(
-      Type106.Boolean({
+    append: Type108.Optional(
+      Type108.Boolean({
         description: "Append to file instead of overwriting (default: false)"
       })
     ),
-    createDirs: Type106.Optional(
-      Type106.Boolean({
+    createDirs: Type108.Optional(
+      Type108.Boolean({
         description: "Create parent directories if they don't exist (default: true)"
       })
     )
@@ -22540,7 +22772,7 @@ var workspaceWriteExecutor = async (params, _context) => {
 };
 
 // src/agent/tools/workspace/delete.ts
-import { Type as Type107 } from "@sinclair/typebox";
+import { Type as Type109 } from "@sinclair/typebox";
 import { unlinkSync as unlinkSync3, rmdirSync, readdirSync as readdirSync4, rmSync } from "fs";
 var PROTECTED_WORKSPACE_FILES = [
   "SOUL.md",
@@ -22562,12 +22794,12 @@ You CAN delete:
 - Custom files you've created
 
 Use recursive=true to delete non-empty directories.`,
-  parameters: Type107.Object({
-    path: Type107.String({
+  parameters: Type109.Object({
+    path: Type109.String({
       description: "Path to file or directory to delete"
     }),
-    recursive: Type107.Optional(
-      Type107.Boolean({
+    recursive: Type109.Optional(
+      Type109.Boolean({
         description: "Delete directory recursively (default: false)"
       })
     )
@@ -22622,7 +22854,7 @@ var workspaceDeleteExecutor = async (params, _context) => {
 };
 
 // src/agent/tools/workspace/info.ts
-import { Type as Type108 } from "@sinclair/typebox";
+import { Type as Type110 } from "@sinclair/typebox";
 import { lstatSync as lstatSync4, readdirSync as readdirSync5, existsSync as existsSync14 } from "fs";
 import { join as join12 } from "path";
 var MEMES_DIR = WORKSPACE_PATHS.MEMES_DIR;
@@ -22635,9 +22867,9 @@ Returns:
 - Directory structure
 - File counts and sizes
 - Usage limits`,
-  parameters: Type108.Object({
-    detailed: Type108.Optional(
-      Type108.Boolean({
+  parameters: Type110.Object({
+    detailed: Type110.Optional(
+      Type110.Boolean({
         description: "Include detailed file listing (default: false)"
       })
     )
@@ -22736,7 +22968,7 @@ var workspaceInfoExecutor = async (params, _context) => {
 };
 
 // src/agent/tools/workspace/rename.ts
-import { Type as Type109 } from "@sinclair/typebox";
+import { Type as Type111 } from "@sinclair/typebox";
 import { renameSync, existsSync as existsSync15 } from "fs";
 import { dirname as dirname7 } from "path";
 import { mkdirSync as mkdirSync10 } from "fs";
@@ -22755,15 +22987,15 @@ Examples:
 - Organize: from="downloads/doc.pdf", to="downloads/contracts/2026/lease.pdf"
 
 CANNOT move/rename files outside workspace or to protected locations.`,
-  parameters: Type109.Object({
-    from: Type109.String({
+  parameters: Type111.Object({
+    from: Type111.String({
       description: "Current path of the file (relative to workspace)"
     }),
-    to: Type109.String({
+    to: Type111.String({
       description: "New path for the file (relative to workspace)"
     }),
-    overwrite: Type109.Optional(
-      Type109.Boolean({
+    overwrite: Type111.Optional(
+      Type111.Boolean({
         description: "Overwrite if destination exists (default: false)"
       })
     )
@@ -22963,7 +23195,7 @@ function getCasinoDb() {
 }
 
 // src/agent/tools/casino/balance.ts
-import { Type as Type110 } from "@sinclair/typebox";
+import { Type as Type112 } from "@sinclair/typebox";
 var casinoBalanceTool = {
   name: "casino_balance",
   description: `Check Teleton Casino bankroll status and betting limits.
@@ -22980,7 +23212,7 @@ Teleton Casino needs sufficient balance to cover potential payouts (up to 5x the
 
 IMPORTANT: When a player wants to bet, tell them to send TON to Teleton Casino address with their username as memo.
 Example: "Send 2 TON to EQxxx with memo: john_doe"`,
-  parameters: Type110.Object({})
+  parameters: Type112.Object({})
 };
 var casinoBalanceExecutor = async (params, context) => {
   try {
@@ -23046,7 +23278,7 @@ var casinoBalanceExecutor = async (params, context) => {
 };
 
 // src/agent/tools/casino/spin.ts
-import { Type as Type111 } from "@sinclair/typebox";
+import { Type as Type113 } from "@sinclair/typebox";
 
 // src/casino/game-engine.ts
 import { Api as Api57 } from "telegram";
@@ -23424,19 +23656,19 @@ Process:
 6. AUTO-PAYOUT if player wins
 
 Tell the user: "Send X TON to [casino_address] with memo: your_username"`,
-  parameters: Type111.Object({
-    chat_id: Type111.String({
+  parameters: Type113.Object({
+    chat_id: Type113.String({
       description: "Telegram chat ID where to send the spin"
     }),
-    bet_amount: Type111.Number({
+    bet_amount: Type113.Number({
       description: "Bet amount in TON",
       minimum: 0.1
     }),
-    player_username: Type111.String({
+    player_username: Type113.String({
       description: "Player's Telegram username (without @)"
     }),
-    reply_to: Type111.Optional(
-      Type111.Number({
+    reply_to: Type113.Optional(
+      Type113.Number({
         description: "Message ID to reply to"
       })
     )
@@ -23460,7 +23692,7 @@ var casinoSpinExecutor = async (params, context) => {
 };
 
 // src/agent/tools/casino/dice.ts
-import { Type as Type112 } from "@sinclair/typebox";
+import { Type as Type114 } from "@sinclair/typebox";
 var casinoDiceTool = {
   name: "casino_dice",
   description: `Execute a Teleton Casino dice roll with full security checks.
@@ -23480,19 +23712,19 @@ Same security as slot:
 6. AUTO-PAYOUT if player wins
 
 Tell the user: "Send X TON to [casino_address] with memo: your_username"`,
-  parameters: Type112.Object({
-    chat_id: Type112.String({
+  parameters: Type114.Object({
+    chat_id: Type114.String({
       description: "Telegram chat ID where to send the dice"
     }),
-    bet_amount: Type112.Number({
+    bet_amount: Type114.Number({
       description: "Bet amount in TON",
       minimum: 0.1
     }),
-    player_username: Type112.String({
+    player_username: Type114.String({
       description: "Player's Telegram username (without @)"
     }),
-    reply_to: Type112.Optional(
-      Type112.Number({
+    reply_to: Type114.Optional(
+      Type114.Number({
         description: "Message ID to reply to"
       })
     )
@@ -23516,7 +23748,7 @@ var casinoDiceExecutor = async (params, context) => {
 };
 
 // src/agent/tools/casino/leaderboard.ts
-import { Type as Type113 } from "@sinclair/typebox";
+import { Type as Type115 } from "@sinclair/typebox";
 var casinoLeaderboardTool = {
   name: "casino_leaderboard",
   description: `Show Teleton Casino leaderboard with top players.
@@ -23531,16 +23763,16 @@ Shows:
 - Total amount wagered
 - Total wins/losses
 - Win rate percentage`,
-  parameters: Type113.Object({
-    limit: Type113.Optional(
-      Type113.Number({
+  parameters: Type115.Object({
+    limit: Type115.Optional(
+      Type115.Number({
         description: "Number of players to show (default: 10)",
         minimum: 1,
         maximum: 50
       })
     ),
-    type: Type113.Optional(
-      Type113.String({
+    type: Type115.Optional(
+      Type115.String({
         description: "Leaderboard type: winners, losers, or wagered",
         enum: ["winners", "losers", "wagered"]
       })
@@ -23645,7 +23877,7 @@ ${formattedPlayers}`
 };
 
 // src/agent/tools/casino/my-stats.ts
-import { Type as Type114 } from "@sinclair/typebox";
+import { Type as Type116 } from "@sinclair/typebox";
 var casinoMyStatsTool = {
   name: "casino_my_stats",
   description: `Show the current player's personal Teleton Casino statistics.
@@ -23658,7 +23890,7 @@ Returns:
 - Net profit/loss
 - Win rate percentage
 - Last bet timestamp`,
-  parameters: Type114.Object({})
+  parameters: Type116.Object({})
 };
 var casinoMyStatsExecutor = async (params, context) => {
   try {
@@ -23787,7 +24019,7 @@ var MarketScraperService = class {
     this.isScrapingInProgress = true;
     console.log("\u{1F504} Starting full market scrape...");
     try {
-      const { runScraper } = await import("./scraper-2O6Z3ZHT.js");
+      const { runScraper } = await import("./scraper-KXRBQMVQ.js");
       const result = await runScraper({
         workers: 4,
         limit: 0
@@ -24241,16 +24473,15 @@ var TonnetApp = class {
       autoReconnect: true,
       floodSleepThreshold: TELEGRAM_FLOOD_SLEEP_THRESHOLD
     });
-    const VECTOR_DIMENSIONS = 512;
+    const VECTOR_DIMENSIONS = 384;
     const memory = initializeMemory({
       database: {
         path: join16(TELETON_ROOT, "memory.db"),
-        enableVectorSearch: false,
+        enableVectorSearch: true,
         vectorDimensions: VECTOR_DIMENSIONS
       },
       embeddings: {
-        provider: "none",
-        apiKey: "",
+        provider: "local",
         model: ""
       },
       workspaceDir: join16(TELETON_ROOT)
@@ -24316,19 +24547,18 @@ ${blue}  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u250
         `\u26A0\uFE0F Tool count (${this.toolCount}) exceeds ${providerMeta.displayName} limit (${providerMeta.toolLimit})`
       );
     }
-    const { migrateSessionsToDb } = await import("./migrate-6BQZVOBN.js");
+    const { migrateSessionsToDb } = await import("./migrate-7OG67FXP.js");
     migrateSessionsToDb();
     const { cleanupOldTranscripts } = await import("./transcript-DF2Y6CFY.js");
     cleanupOldTranscripts(30);
     const memory = initializeMemory({
       database: {
         path: join16(TELETON_ROOT, "memory.db"),
-        enableVectorSearch: false,
-        vectorDimensions: 512
+        enableVectorSearch: true,
+        vectorDimensions: 384
       },
       embeddings: {
-        provider: "none",
-        apiKey: "",
+        provider: "local",
         model: ""
       },
       workspaceDir: join16(TELETON_ROOT)
@@ -24466,8 +24696,8 @@ ${blue}  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u250
       }
       const taskId = match[1];
       const { getTaskStore } = await import("./tasks-M3QDPTGY.js");
-      const { executeScheduledTask } = await import("./task-executor-4SVB72GR.js");
-      const { getDatabase: getDatabase2 } = await import("./memory-PDEJIPK6.js");
+      const { executeScheduledTask } = await import("./task-executor-AUTT3VAL.js");
+      const { getDatabase: getDatabase2 } = await import("./memory-ZXDAJBL6.js");
       const db3 = getDatabase2().getDb();
       const taskStore = getTaskStore(db3);
       const task = taskStore.getTask(taskId);
@@ -24533,7 +24763,7 @@ ${blue}  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u250
       taskStore.completeTask(taskId, response.content);
       console.log(`\u2705 Executed scheduled task ${taskId}: ${task.description}`);
       if (!this.dependencyResolver) {
-        const { TaskDependencyResolver } = await import("./task-dependency-resolver-WNYOTWWM.js");
+        const { TaskDependencyResolver } = await import("./task-dependency-resolver-S45DFI5C.js");
         this.dependencyResolver = new TaskDependencyResolver(taskStore, this.bridge);
       }
       await this.dependencyResolver.onTaskComplete(taskId);
@@ -24541,8 +24771,8 @@ ${blue}  \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u250
       console.error("Error handling scheduled task:", error);
       try {
         const { getTaskStore } = await import("./tasks-M3QDPTGY.js");
-        const { TaskDependencyResolver } = await import("./task-dependency-resolver-WNYOTWWM.js");
-        const { getDatabase: getDatabase2 } = await import("./memory-PDEJIPK6.js");
+        const { TaskDependencyResolver } = await import("./task-dependency-resolver-S45DFI5C.js");
+        const { getDatabase: getDatabase2 } = await import("./memory-ZXDAJBL6.js");
         const db3 = getDatabase2().getDb();
         const taskStore = getTaskStore(db3);
         const match = message.text.match(/^\[TASK:([^\]]+)\]/);