diff --git a/agent/agent.go b/agent/agent.go new file mode 100644 index 00000000..93f6351c --- /dev/null +++ b/agent/agent.go @@ -0,0 +1,806 @@ +// Package agent implements the NOFXi Agent Core. +// +// Architecture: ALL user messages go to the LLM. The LLM understands intent +// and calls tools to execute actions. No regex routing, no pattern matching. +// The LLM IS the brain — just like how OpenClaw works. +package agent + +import ( + "context" + "encoding/json" + "fmt" + "log/slog" + "net/http" + "sort" + "strconv" + "strings" + "time" + + "nofx/manager" + "nofx/market" + "nofx/mcp" + "nofx/store" +) + +type Agent struct { + traderManager *manager.TraderManager + store *store.Store + aiClient mcp.AIClient + config *Config + sentinel *Sentinel + brain *Brain + scheduler *Scheduler + logger *slog.Logger + history *chatHistory + pending *pendingTrades + stopCh chan struct{} // signals background goroutines to stop + NotifyFunc func(userID int64, text string) error +} + +type Config struct { + Language string `json:"language"` + WatchSymbols []string `json:"watch_symbols"` + EnableBriefs bool `json:"enable_briefs"` + EnableNews bool `json:"enable_news"` + EnableSentinel bool `json:"enable_sentinel"` + BriefTimes []int `json:"brief_times"` +} + +func DefaultConfig() *Config { + return &Config{ + Language: "zh", WatchSymbols: []string{"BTCUSDT", "ETHUSDT", "SOLUSDT"}, + EnableBriefs: true, EnableNews: true, EnableSentinel: true, BriefTimes: []int{8, 20}, + } +} + +func New(tm *manager.TraderManager, st *store.Store, cfg *Config, logger *slog.Logger) *Agent { + if cfg == nil { + cfg = DefaultConfig() + } + return &Agent{traderManager: tm, store: st, config: cfg, logger: logger, history: newChatHistory(100), pending: newPendingTrades(), stopCh: make(chan struct{})} +} + +func (a *Agent) SetAIClient(c mcp.AIClient) { a.aiClient = c } + +func (a *Agent) log() *slog.Logger { + if a != nil && a.logger != nil { + return a.logger + } + return slog.Default() +} + +func (a *Agent) EnsureAIClient() { + a.ensureAIClientForStoreUser("default") +} + +func (a *Agent) ensureAIClientForStoreUser(storeUserID string) { + if storeUserID == "" { + storeUserID = "default" + } + if a.store != nil { + if client, modelName, ok := a.loadAIClientFromStoreUser(storeUserID); ok { + a.aiClient = client + a.log().Info("agent AI client ready", "store_user_id", storeUserID, "model", modelName) + return + } + } + if a.aiClient != nil { + a.log().Warn("clearing stale AI client for store user", "store_user_id", storeUserID) + a.aiClient = nil + } + a.log().Warn("no AI client — agent will have limited capabilities", "store_user_id", storeUserID) +} + +func (a *Agent) loadAIClientFromStoreUser(storeUserID string) (mcp.AIClient, string, bool) { + if a.store == nil { + a.log().Warn("cannot load AI client: store unavailable", "store_user_id", storeUserID) + return nil, "", false + } + + if storeUserID == "" { + storeUserID = "default" + } + + model, err := a.store.AIModel().GetDefault(storeUserID) + if err != nil || model == nil { + a.log().Warn("no enabled AI model found for store user", "store_user_id", storeUserID, "error", err) + return nil, "", false + } + + a.log().Info( + "agent selected AI model config", + "store_user_id", storeUserID, + "model_id", model.ID, + "provider", model.Provider, + "enabled", model.Enabled, + "has_api_key", len(model.APIKey) > 0, + "custom_api_url", strings.TrimSpace(model.CustomAPIURL), + "custom_model_name", strings.TrimSpace(model.CustomModelName), + ) + + apiKey := string(model.APIKey) + customAPIURL := strings.TrimSpace(model.CustomAPIURL) + modelName := strings.TrimSpace(model.CustomModelName) + customAPIURL, modelName = resolveModelRuntimeConfig(model.Provider, customAPIURL, modelName, model.ID) + if apiKey == "" || customAPIURL == "" { + a.log().Warn( + "enabled AI model is incomplete", + "store_user_id", storeUserID, + "model_id", model.ID, + "provider", model.Provider, + "has_api_key", apiKey != "", + "has_custom_api_url", customAPIURL != "", + ) + return nil, "", false + } + + httpClient := &http.Client{Timeout: 60 * time.Second} + client := mcp.NewClient(mcp.WithHTTPClient(httpClient)) + name := modelName + client.SetAPIKey(apiKey, customAPIURL, name) + return client, name, true +} + +func resolveModelRuntimeConfig(provider, customAPIURL, customModelName, fallbackModelID string) (string, string) { + provider = strings.ToLower(strings.TrimSpace(provider)) + customAPIURL = strings.TrimSpace(customAPIURL) + customModelName = strings.TrimSpace(customModelName) + fallbackModelID = strings.TrimSpace(fallbackModelID) + + type providerDefaults struct { + url string + model string + } + defaults := map[string]providerDefaults{ + "deepseek": {url: "https://api.deepseek.com/v1", model: "deepseek-chat"}, + "qwen": {url: "https://dashscope.aliyuncs.com/compatible-mode/v1", model: "qwen3-max"}, + "openai": {url: "https://api.openai.com/v1", model: "gpt-5.2"}, + "claude": {url: "https://api.anthropic.com/v1", model: "claude-opus-4-6"}, + "gemini": {url: "https://generativelanguage.googleapis.com/v1beta/openai", model: "gemini-3-pro-preview"}, + "grok": {url: "https://api.x.ai/v1", model: "grok-3-latest"}, + "kimi": {url: "https://api.moonshot.ai/v1", model: "moonshot-v1-auto"}, + "minimax": {url: "https://api.minimax.chat/v1", model: "MiniMax-M2.5"}, + } + + if customAPIURL == "" { + if cfg, ok := defaults[provider]; ok { + customAPIURL = cfg.url + } + } + if customModelName == "" { + if cfg, ok := defaults[provider]; ok { + customModelName = cfg.model + } + } + if customModelName == "" { + customModelName = fallbackModelID + } + return customAPIURL, customModelName +} + +func (a *Agent) Start() { + a.logger.Info("starting NOFXi agent...") + a.EnsureAIClient() + + if a.config.EnableSentinel { + a.sentinel = NewSentinel(a.config.WatchSymbols, a.handleSignal, a.logger) + a.sentinel.Start() + } + a.brain = NewBrain(a, a.logger) + if a.config.EnableNews { + a.brain.StartNewsScan(5 * time.Minute) + } + if a.config.EnableBriefs { + a.brain.StartMarketBriefs(a.config.BriefTimes) + } + a.scheduler = NewScheduler(a, a.logger) + a.scheduler.Start(context.Background()) + + a.logger.Info("NOFXi agent is online 🚀") +} + +func (a *Agent) Stop() { + // Signal all background goroutines (e.g. chat-history-cleanup) to exit. + select { + case <-a.stopCh: + // Already closed + default: + close(a.stopCh) + } + if a.sentinel != nil { + a.sentinel.Stop() + } + if a.brain != nil { + a.brain.Stop() + } + if a.scheduler != nil { + a.scheduler.Stop() + } +} + +// HandleMessage — the core. Everything goes through the LLM. +func (a *Agent) HandleMessage(ctx context.Context, userID int64, text string) (string, error) { + a.EnsureAIClient() + return a.handleMessageForStoreUser(ctx, "default", userID, text) +} + +// HandleMessageForStoreUser is like HandleMessage but stores setup artifacts +// (exchange/model) under the provided authenticated store user ID. +func (a *Agent) HandleMessageForStoreUser(ctx context.Context, storeUserID string, userID int64, text string) (string, error) { + return a.handleMessageForStoreUser(ctx, storeUserID, userID, text) +} + +func (a *Agent) handleMessageForStoreUser(ctx context.Context, storeUserID string, userID int64, text string) (string, error) { + a.ensureAIClientForStoreUser(storeUserID) + + lang := a.config.Language + if strings.HasPrefix(text, "[lang:") { + if end := strings.Index(text, "] "); end > 0 { + lang = text[6:end] + text = text[end+2:] + } + } + + a.logger.Info("message", "user_id", userID, "text", text) + + // Only keep a tiny command surface outside the planner. + if text == "/status" { + return a.handleStatus(lang), nil + } + if text == "/clear" { + a.history.Clear(userID) + a.clearTaskState(userID) + a.clearExecutionState(userID) + if lang == "zh" { + return "🧹 对话记忆已清除。", nil + } + return "🧹 Conversation history cleared.", nil + } + if reply, handled := a.handleTradeConfirmation(ctx, userID, text, lang); handled { + return reply, nil + } + + // Everything else goes through the planner and tool system. + return a.thinkAndAct(ctx, storeUserID, userID, lang, text) +} + +// HandleMessageStream is like HandleMessage but streams the final LLM response via SSE. +// onEvent is called with (eventType, data) — see StreamEvent* constants. +// Non-streamable responses (commands, trade confirmations) return immediately without events. +func (a *Agent) HandleMessageStream(ctx context.Context, userID int64, text string, onEvent func(event, data string)) (string, error) { + a.EnsureAIClient() + return a.handleMessageStreamForStoreUser(ctx, "default", userID, text, onEvent) +} + +// HandleMessageStreamForStoreUser mirrors HandleMessageForStoreUser for SSE responses. +func (a *Agent) HandleMessageStreamForStoreUser(ctx context.Context, storeUserID string, userID int64, text string, onEvent func(event, data string)) (string, error) { + return a.handleMessageStreamForStoreUser(ctx, storeUserID, userID, text, onEvent) +} + +func (a *Agent) handleMessageStreamForStoreUser(ctx context.Context, storeUserID string, userID int64, text string, onEvent func(event, data string)) (string, error) { + a.ensureAIClientForStoreUser(storeUserID) + + lang := a.config.Language + if strings.HasPrefix(text, "[lang:") { + if end := strings.Index(text, "] "); end > 0 { + lang = text[6:end] + text = text[end+2:] + } + } + + a.logger.Info("message (stream)", "user_id", userID, "text", text) + + if text == "/status" { + return a.handleStatus(lang), nil + } + if text == "/clear" { + a.history.Clear(userID) + a.clearTaskState(userID) + a.clearExecutionState(userID) + if lang == "zh" { + return "🧹 对话记忆已清除。", nil + } + return "🧹 Conversation history cleared.", nil + } + if reply, handled := a.handleTradeConfirmation(ctx, userID, text, lang); handled { + if onEvent != nil { + onEvent(StreamEventDelta, reply) + } + return reply, nil + } + return a.thinkAndActStream(ctx, storeUserID, userID, lang, text, onEvent) +} + +// StreamEvent types sent via SSE to the frontend. +const ( + StreamEventPlanning = "planning" + StreamEventPlan = "plan" + StreamEventStepStart = "step_start" + StreamEventStepComplete = "step_complete" + StreamEventReplan = "replan" + StreamEventTool = "tool" // Tool is being called (shows status to user) + StreamEventDelta = "delta" // Text chunk from LLM streaming + StreamEventDone = "done" // Stream complete + StreamEventError = "error" // Error occurred +) + +// buildSystemPrompt creates the system prompt that makes NOFXi behave like a real agent. +func (a *Agent) buildSystemPrompt(lang string) string { + // Gather live system state + traderInfo := a.getTradersSummary() + watchlist := "" + if a.sentinel != nil { + watchlist = a.sentinel.FormatWatchlist(lang) + } + skillCatalog := skillCatalogPrompt(lang) + + if lang == "zh" { + return fmt.Sprintf(`你是 NOFXi，一个专业的 AI 交易 Agent。你不是一个简单的聊天机器人——你是用户的交易伙伴。 + +## 你的核心能力 +1. **市场分析** — 加密货币（BTC/ETH/SOL等）有实时数据，A股/港股/美股/外汇你可以基于知识分析 +2. **交易管理** — 查看持仓、余额、交易历史、Trader 状态 +3. **策略建议** — 根据用户需求制定交易策略 +4. **策略模板管理** — 创建、查看、修改、删除、激活策略模板 +5. **风险管理** — 评估风险、建议止损止盈 +6. **配置引导** — 用户说"开始配置"时引导配置交易所和AI模型 + +## 当前系统状态 +%s +%s + +## 数据说明（极其重要，违反即失职！） +- 加密货币（BTC/ETH等）：交易所实时数据，标注 [Real-time] +- A股/港股/美股：**必须调用 search_stock 工具**获取实时行情。不调工具就没有数据。 +- 美股盘前盘后：search_stock 返回的 quote 中 ext_price/ext_change_pct/ext_time +- 外汇/指数期货：当前没有数据源，如实告知 + +### 铁律：禁止编造任何价格！ +- **你的训练数据中的价格全部过时，不可使用** +- **没有通过工具获取的价格 = 你不知道 = 不能说** +- 用户问多只股票的盘前数据？→ 对每只股票调用 search_stock 工具 +- 用户问"盘前概览"？→ 调用 search_stock 查主要股票（AAPL、TSLA、NVDA、MSFT、GOOGL、AMZN、META等），用真实数据回答 +- **绝对不允许**不调工具就给出具体价格数字（如 $421.85） +- 如果某只股票 search_stock 查不到数据，就说"暂时无法获取该股票数据" +- 指数期货（纳指、标普、道琼斯期货）我们目前没有数据源，直接说"暂不支持指数期货数据" + +## 工具使用 +你可以调用以下工具来执行操作： +- **search_stock** — 搜索股票（支持中文名、英文名、代码）。当用户提到你不认识的股票时，先用这个工具搜索。 +- **execute_trade** — 下单交易（加密货币或美股）。美股：open_long=买入，close_long=卖出。调用后创建待确认订单，用户需回复"确认 trade_xxx"。 +- **get_positions** — 查看当前所有持仓（加密货币 + 股票） +- **get_balance** — 查看账户余额 +- **get_market_price** — 获取实时价格（加密货币或股票代码） +- **get_exchange_configs / manage_exchange_config** — 查看、新增、修改、删除交易所绑定配置 +- **get_model_configs / manage_model_config** — 查看、新增、修改、删除 AI 模型配置 +- **get_strategies / manage_strategy** — 查看、新增、修改、删除、激活、复制策略模板 +- **manage_trader** — 查看、新增、修改、删除、启动、停止交易员 + +### 配置、策略与交易员管理规则 +- 当用户要求创建、修改、删除、激活、复制策略模板时，优先使用 get_strategies / manage_strategy +- **策略模板本身是独立资源，不默认依赖交易所或 AI 模型** +- 只有当用户要求“运行策略 / 创建交易员 / 把策略部署到账户”时，才需要进一步关联交易所、模型或 trader +- 当用户要求配置交易所、绑定 API Key、修改交易所账户时，优先使用 manage_exchange_config +- 当用户要求配置大模型、设置 API Key、切换模型、修改模型地址时，优先使用 manage_model_config +- 当用户要求创建、修改、删除、启动、停止交易员时，优先使用 manage_trader +- 如果缺少必要字段，先追问缺失信息，再调用工具 +- **在这些工具存在时，不要说“系统没有这个能力”** +- 对敏感信息（API Key、Secret、Private Key）只保存，不要在最终回复中完整回显 + +%s + +### 交易安全规则 +- 用户明确要求交易时才调用 execute_trade +- 分析和建议不需要调用工具，直接回复即可 +- 交易确认信息要清晰展示：品种、方向、数量、杠杆 +- 提醒用户确认命令格式 + +### 数据真实性规则（极其重要！） +- **持仓信息必须且只能通过 get_positions 工具获取**，绝对禁止编造持仓 +- **余额信息必须且只能通过 get_balance 工具获取**，绝对禁止编造余额 +- 如果用户问持仓但 get_positions 返回空，就说"当前没有持仓"，不要编造 +- 如果工具返回 error（如未配置交易所），如实告知用户 +- **你不知道用户持有什么股票/币种，除非工具返回了数据** +- 查股票行情 ≠ 用户持有该股票。不要混淆"查价格"和"有持仓" + +## 行为准则 +- 简洁、专业、有观点。不说废话。 +- 用户问什么答什么，不要推销配置。 +- 有实时数据时给具体价位，没有时给策略框架和思路。 +- **诚实是第一原则** — 不确定就说不确定，没数据就说没数据。绝不编造。 +- 用交易相关的 emoji 让回复更直观。 +- 用中文回复。 + +当前时间: %s`, traderInfo, watchlist, skillCatalog, time.Now().Format("2006-01-02 15:04:05")) + } + + return fmt.Sprintf(`You are NOFXi, a professional AI trading agent. Not a chatbot — a trading partner. + +## Capabilities +1. Market analysis — crypto with real-time data, stocks/forex with knowledge +2. Trade management — positions, balance, history, trader status +3. Strategy — build trading strategies based on user needs +4. Strategy template management — create, inspect, update, delete, and activate strategy templates +5. Risk management — assess risk, suggest stop-loss/take-profit +6. Setup — guide exchange/AI configuration when user asks + +## Current System State +%s +%s + +## Data Notice (CRITICAL — violating this is unacceptable!) +- Crypto (BTC/ETH): Exchange real-time data, marked [Real-time] +- Stocks: You MUST call search_stock tool to get real-time quotes. No tool call = no data. +- US stocks pre/after-hours: ext_price/ext_change_pct/ext_time in search_stock results +- Forex/Index futures: No data source currently — tell user honestly + +### ABSOLUTE RULE: NEVER fabricate any price! +- Your training data prices are ALL outdated and MUST NOT be used +- No tool result = you don't know = you cannot state a price +- User asks multiple stocks? → Call search_stock for EACH one +- User asks "pre-market overview"? → Call search_stock for major stocks (AAPL, TSLA, NVDA, MSFT, GOOGL, AMZN, META etc.) and use real data +- NEVER output a specific price number (like $421.85) without a tool having returned it +- If search_stock fails for a stock, say "unable to fetch data for this stock" +- Index futures (NDX, SPX, DJI futures) — we have no data source, say "index futures not supported yet" + +## Tools +You can call these tools to take action: +- **search_stock** — Search for stocks by name, ticker, or code. Covers A-share, HK, and US markets. Use when the user mentions an unknown stock. +- **execute_trade** — Place a trade order (crypto or US stocks). For stocks: open_long=buy, close_long=sell. Creates a pending order that requires user confirmation. +- **get_positions** — View all current open positions (crypto + stocks) +- **get_balance** — View account balance and equity +- **get_market_price** — Get real-time price from the exchange (crypto or stock symbol) +- **get_exchange_configs / manage_exchange_config** — View, create, update, and delete exchange bindings +- **get_model_configs / manage_model_config** — View, create, update, and delete AI model bindings +- **get_strategies / manage_strategy** — View, create, update, delete, activate, and duplicate strategy templates +- **manage_trader** — List, create, update, delete, start, and stop traders + +### Configuration, Strategy, and Trader Rules +- When the user wants to create, edit, delete, activate, or duplicate a strategy template, prefer get_strategies / manage_strategy +- **A strategy template is an independent asset and does not require exchange or model bindings by default** +- Only ask for exchange/model/trader details when the user wants to run, deploy, or attach a strategy to a trader +- When the user wants to bind or edit an exchange account, prefer manage_exchange_config +- When the user wants to bind or edit an AI model, prefer manage_model_config +- When the user wants to create, edit, delete, start, or stop a trader, prefer manage_trader +- If required fields are missing, ask a focused follow-up question first, then call the tool +- **Do not claim the system lacks these capabilities when the tools exist** +- For secrets such as API keys, secrets, and private keys: store them, but never echo them back in full + +%s + +### Trade Safety Rules +- Only call execute_trade when user explicitly requests a trade +- Analysis and advice don't need tools — just reply directly +- Show trade details clearly: symbol, direction, quantity, leverage +- Remind user of the confirmation command format + +### Data Truthfulness Rules (CRITICAL!) +- **Position data MUST come from get_positions tool only** — NEVER fabricate positions +- **Balance data MUST come from get_balance tool only** — NEVER fabricate balances +- If get_positions returns empty, say "no open positions" — do NOT make up holdings +- If a tool returns an error (e.g. no exchange configured), tell the user honestly +- **You do NOT know what the user holds unless a tool tells you** +- Checking a stock price ≠ user owns that stock. Never confuse "quote lookup" with "holding" + +## Behavior +- Concise, professional, opinionated. No fluff. +- Answer what's asked. Don't push setup. +- With real-time data: give specific levels. Without: give strategy frameworks. +- **Honesty is rule #1** — uncertain = say uncertain, no data = say no data. +- Use trading emojis. + +Current time: %s`, traderInfo, watchlist, skillCatalog, time.Now().Format("2006-01-02 15:04:05")) +} + +// gatherContext collects real-time market data relevant to the user's message. +func (a *Agent) gatherContext(text string) string { + var parts []string + upper := strings.ToUpper(text) + + // Crypto — detect symbols dynamically + // 1. Check known popular symbols (fast path) + // 2. Extract any "XXXUSDT" pattern from text (catches arbitrary pairs) + knownSymbols := []string{ + "BTC", "ETH", "SOL", "BNB", "XRP", "DOGE", "ADA", "AVAX", "DOT", "LINK", + "PEPE", "SHIB", "ARB", "OP", "SUI", "APT", "SEI", "TIA", "JUP", "WIF", + "NEAR", "ATOM", "FTM", "MATIC", "INJ", "RENDER", "FET", "TAO", "WLD", + "AAVE", "UNI", "LDO", "MKR", "CRV", "PENDLE", "ENA", "ONDO", "TRUMP", + } + matched := make(map[string]bool) + for _, sym := range knownSymbols { + if strings.Contains(upper, sym) { + matched[sym] = true + } + } + // Also extract "XXXUSDT" patterns for coins not in the known list + for _, word := range strings.Fields(upper) { + word = strings.Trim(word, ".,!?;:()[]{}\"'") + if strings.HasSuffix(word, "USDT") && len(word) > 4 && len(word) <= 15 { + sym := strings.TrimSuffix(word, "USDT") + if len(sym) >= 2 && len(sym) <= 10 { + matched[sym] = true + } + } + } + // Collect and sort matched symbols for deterministic selection + sortedSymbols := make([]string, 0, len(matched)) + for sym := range matched { + sortedSymbols = append(sortedSymbols, sym) + } + sort.Strings(sortedSymbols) + + // Cap at 5 symbols to avoid slow context gathering + count := 0 + for _, sym := range sortedSymbols { + if count >= 5 { + break + } + md, err := market.Get(sym + "USDT") + if err == nil && md.CurrentPrice > 0 { + parts = append(parts, fmt.Sprintf("[%s/USDT Real-time]\nPrice: $%.4f | 1h: %+.2f%% | 4h: %+.2f%% | RSI7: %.1f | EMA20: %.4f | MACD: %.6f | Funding: %.4f%%", + sym, md.CurrentPrice, md.PriceChange1h, md.PriceChange4h, md.CurrentRSI7, md.CurrentEMA20, md.CurrentMACD, md.FundingRate*100)) + count++ + } + } + + // A-share / stocks — only call Sina API when text likely references stocks. + // Skip for purely crypto conversations to avoid unnecessary external API calls. + if looksLikeStockQuery(text) { + stockCode, stockName := resolveStockCodeDynamic(text) + if stockCode != "" { + quote, err := fetchStockQuote(stockCode) + if err == nil && quote.Price > 0 { + parts = append(parts, fmt.Sprintf("[%s(%s) Real-time A-share Data]\n%s", quote.Name, quote.Code, formatStockQuote(quote))) + } else if err != nil { + a.logger.Error("fetch stock quote", "code", stockCode, "name", stockName, "error", err) + } + } + } + + // Trader positions + if a.traderManager != nil { + for _, t := range a.traderManager.GetAllTraders() { + positions, err := t.GetPositions() + if err != nil { + continue + } + for _, p := range positions { + size := toFloat(p["size"]) + if size == 0 { + continue + } + parts = append(parts, fmt.Sprintf("[Position] %s %s: size=%.4f entry=$%.4f mark=$%.4f pnl=$%.2f", + p["symbol"], p["side"], size, toFloat(p["entryPrice"]), toFloat(p["markPrice"]), toFloat(p["unrealizedPnl"]))) + } + } + } + + return strings.Join(parts, "\n") +} + +func (a *Agent) getTradersSummary() string { + if a.traderManager == nil { + return "Traders: none configured" + } + traders := a.traderManager.GetAllTraders() + if len(traders) == 0 { + return "Traders: none configured" + } + + var lines []string + for id, t := range traders { + s := t.GetStatus() + running, _ := s["is_running"].(bool) + status := "stopped" + if running { + status = "running" + } + tid := id + if len(tid) > 8 { + tid = tid[:8] + } + lines = append(lines, fmt.Sprintf("• %s [%s] %s | %s", t.GetName(), tid, status, t.GetExchange())) + } + return "Traders:\n" + strings.Join(lines, "\n") +} + +func (a *Agent) handleStatus(L string) string { + tc, rc := 0, 0 + if a.traderManager != nil { + all := a.traderManager.GetAllTraders() + tc = len(all) + for _, t := range all { + if s := t.GetStatus(); s["is_running"] == true { + rc++ + } + } + } + wc := 0 + if a.sentinel != nil { + wc = a.sentinel.SymbolCount() + } + ai := "❌" + if a.aiClient != nil { + ai = "✅" + } + return fmt.Sprintf(a.msg(L, "status"), rc, tc, wc, ai, time.Now().Format("2006-01-02 15:04:05")) +} + +// noAIFallback — when no AI is available, still try to be useful. +func (a *Agent) noAIFallback(lang, text string) (string, error) { + upper := strings.ToUpper(text) + + // Try to provide market data directly + for _, sym := range []string{"BTC", "ETH", "SOL", "BNB", "XRP", "DOGE"} { + if strings.Contains(upper, sym) { + md, err := market.Get(sym + "USDT") + if err == nil { + return fmt.Sprintf("📊 *%s/USDT*\n\n%s\n\n💡 配置 AI 模型后我能给你更深度的分析。发送 *开始配置* 开始。", sym, market.Format(md)), nil + } + } + } + + // Check if asking about positions/balance + if strings.Contains(text, "持仓") || strings.Contains(upper, "POSITION") { + return a.queryPositionsDirect(lang) + } + if strings.Contains(text, "余额") || strings.Contains(upper, "BALANCE") { + return a.queryBalancesDirect(lang) + } + + if lang == "zh" { + return "🤖 我是 NOFXi。配置 AI 模型后我就能理解你的任何问题——分析股票、制定策略、管理交易。\n\n现在可用：\n• 加密货币实时行情（试试「BTC」）\n• `/status` 系统状态\n\n发送 *开始配置* 配置 AI 模型。", nil + } + return "🤖 I'm NOFXi. Configure an AI model and I can understand anything — analyze stocks, build strategies, manage trades.\n\nAvailable now:\n• Crypto real-time data (try 'BTC')\n• `/status` system status\n\nSend *setup* to configure AI.", nil +} + +func (a *Agent) aiServiceFailure(lang string, err error) (string, error) { + reason := "unknown error" + if err != nil { + reason = summarizeObservation(err.Error()) + } + a.logger.Error("AI service call failed", "error", reason) + if lang == "zh" { + return fmt.Sprintf("当前 AI 服务调用失败：%s\n\n这不是“未配置模型”。更可能是模型服务余额不足、接口报错或超时。请检查当前启用模型的 API 状态后再试。", reason), nil + } + return fmt.Sprintf("The AI service call failed: %s\n\nThis is not a missing-model issue. The active model provider likely returned an error, timed out, or has insufficient balance. Please check the active model API and try again.", reason), nil +} + +func (a *Agent) queryPositionsDirect(L string) (string, error) { + if a.traderManager == nil { + return a.msg(L, "no_traders"), nil + } + var sb strings.Builder + sb.WriteString("📊 *Positions*\n\n") + hasAny := false + for id, t := range a.traderManager.GetAllTraders() { + positions, err := t.GetPositions() + if err != nil { + continue + } + for _, p := range positions { + size := toFloat(p["size"]) + if size == 0 { + continue + } + hasAny = true + pnl := toFloat(p["unrealizedPnl"]) + e := "🟢" + if pnl < 0 { + e = "🔴" + } + sb.WriteString(fmt.Sprintf("%s *%s* %s — $%.2f | Trader: %s\n", e, p["symbol"], p["side"], pnl, id[:8])) + } + } + if !hasAny { + return a.msg(L, "no_positions"), nil + } + return sb.String(), nil +} + +func (a *Agent) queryBalancesDirect(L string) (string, error) { + if a.traderManager == nil { + return a.msg(L, "no_traders"), nil + } + var sb strings.Builder + sb.WriteString("💰 *Balance*\n\n") + for id, t := range a.traderManager.GetAllTraders() { + info, err := t.GetAccountInfo() + if err != nil { + continue + } + tid := id + if len(tid) > 8 { + tid = tid[:8] + } + sb.WriteString(fmt.Sprintf("*%s* (%s): $%.2f\n", t.GetName(), tid, toFloat(info["total_equity"]))) + } + return sb.String(), nil +} + +func (a *Agent) handleSignal(sig Signal) { + if a.brain != nil { + a.brain.HandleSignal(sig) + } +} + +func (a *Agent) notifyAll(text string) { + if a.NotifyFunc != nil { + a.NotifyFunc(0, text) + } +} + +// looksLikeStockQuery returns true if the text likely references stocks rather +// than being a pure crypto/general query. This avoids hitting the Sina search +// API on every single message (saves ~200ms latency + external API call). +func looksLikeStockQuery(text string) bool { + upper := strings.ToUpper(text) + + // Check for known stock-related Chinese keywords + stockKeywords := []string{ + "股", "A股", "港股", "美股", "股票", "涨停", "跌停", "大盘", + "沪指", "深指", "恒指", "纳指", "标普", "道琼斯", + "茅台", "比亚迪", "宁德", "腾讯", "阿里", "美团", "小米", + "京东", "百度", "苹果", "特斯拉", "英伟达", "微软", "谷歌", + "盘前", "盘后", "开盘", "收盘", "涨幅", "跌幅", + } + for _, kw := range stockKeywords { + if strings.Contains(text, kw) { + return true + } + } + + // Check for US stock ticker patterns (1-5 uppercase letters not matching crypto) + for _, word := range strings.Fields(upper) { + word = strings.Trim(word, ".,!?;:()[]{}\"'") + if len(word) >= 1 && len(word) <= 5 { + allLetter := true + for _, c := range word { + if c < 'A' || c > 'Z' { + allLetter = false + break + } + } + if allLetter { + // Check if it's in the known US ticker map + if _, ok := usTickerMap[word]; ok { + return true + } + } + } + } + + // Check for 6-digit A-share codes or 5-digit HK codes + for _, w := range strings.Fields(text) { + w = strings.TrimSpace(w) + if len(w) == 5 || len(w) == 6 { + if _, err := strconv.Atoi(w); err == nil { + return true + } + } + } + + return false +} + +func toFloat(v interface{}) float64 { + switch x := v.(type) { + case float64: + return x + case float32: + return float64(x) + case int: + return float64(x) + case int64: + return float64(x) + case int32: + return float64(x) + case string: + f, _ := strconv.ParseFloat(x, 64) + return f + case json.Number: + f, _ := x.Float64() + return f + } + return 0 +} diff --git a/agent/backend_logs_test.go b/agent/backend_logs_test.go new file mode 100644 index 00000000..16f37a64 --- /dev/null +++ b/agent/backend_logs_test.go @@ -0,0 +1,127 @@ +package agent + +import ( + "encoding/json" + "os" + "path/filepath" + "strings" + "testing" + + "nofx/store" +) + +func TestReadBackendLogEntriesReturnsRecentErrorLines(t *testing.T) { + wd, err := os.Getwd() + if err != nil { + t.Fatalf("Getwd() error = %v", err) + } + tmp := t.TempDir() + if err := os.Chdir(tmp); err != nil { + t.Fatalf("Chdir(tmp) error = %v", err) + } + t.Cleanup(func() { + _ = os.Chdir(wd) + }) + + if err := os.MkdirAll("data", 0o755); err != nil { + t.Fatalf("MkdirAll(data) error = %v", err) + } + logPath := filepath.Join("data", "nofx_2099-01-01.log") + content := strings.Join([]string{ + "04-19 13:00:00 [INFO] api/server.go:590 API server starting", + "04-19 13:00:01 [ERRO] api/server.go:600 invalid signature for okx account", + "04-19 13:00:02 [ERRO] agent/tools.go:123 model update failed: missing api key", + }, "\n") + "\n" + if err := os.WriteFile(logPath, []byte(content), 0o644); err != nil { + t.Fatalf("WriteFile() error = %v", err) + } + + path, entries, err := readBackendLogEntries(10, "model", true) + if err != nil { + t.Fatalf("readBackendLogEntries() error = %v", err) + } + if !strings.Contains(path, "nofx_2099-01-01.log") { + t.Fatalf("unexpected log path: %s", path) + } + if len(entries) != 1 || !strings.Contains(entries[0], "missing api key") { + t.Fatalf("unexpected filtered entries: %#v", entries) + } +} + +func TestToolGetBackendLogsRequiresOwnedTrader(t *testing.T) { + wd, err := os.Getwd() + if err != nil { + t.Fatalf("Getwd() error = %v", err) + } + tmp := t.TempDir() + if err := os.Chdir(tmp); err != nil { + t.Fatalf("Chdir(tmp) error = %v", err) + } + t.Cleanup(func() { + _ = os.Chdir(wd) + }) + + if err := os.MkdirAll("data", 0o755); err != nil { + t.Fatalf("MkdirAll(data) error = %v", err) + } + logPath := filepath.Join("data", "nofx_2099-01-01.log") + content := strings.Join([]string{ + "04-19 13:00:00 [INFO] api/server.go:590 API server starting", + "04-19 13:00:01 [ERRO] trader/runtime.go:88 trader_id=trader-owned strategy execution failed", + "04-19 13:00:02 [ERRO] trader/runtime.go:89 trader_id=trader-other strategy execution failed", + }, "\n") + "\n" + if err := os.WriteFile(logPath, []byte(content), 0o644); err != nil { + t.Fatalf("WriteFile() error = %v", err) + } + + a := newTestAgentWithStore(t) + if err := a.store.Trader().Create(&store.Trader{ + ID: "trader-owned", + UserID: "user-1", + Name: "Owned Trader", + AIModelID: "model-1", + ExchangeID: "exchange-1", + StrategyID: "strategy-1", + InitialBalance: 1000, + }); err != nil { + t.Fatalf("create owned trader: %v", err) + } + if err := a.store.Trader().Create(&store.Trader{ + ID: "trader-other", + UserID: "user-2", + Name: "Other Trader", + AIModelID: "model-2", + ExchangeID: "exchange-2", + StrategyID: "strategy-2", + InitialBalance: 1000, + }); err != nil { + t.Fatalf("create other trader: %v", err) + } + + resp := a.toolGetBackendLogs("user-1", `{"trader_id":"trader-owned","limit":5}`) + var okResult struct { + TraderID string `json:"trader_id"` + Entries []string `json:"entries"` + Count int `json:"count"` + } + if err := json.Unmarshal([]byte(resp), &okResult); err != nil { + t.Fatalf("unmarshal owned response: %v\nraw=%s", err, resp) + } + if okResult.TraderID != "trader-owned" || okResult.Count != 1 { + t.Fatalf("unexpected owned response: %+v", okResult) + } + if len(okResult.Entries) != 1 || !strings.Contains(okResult.Entries[0], "trader-owned") { + t.Fatalf("unexpected owned entries: %#v", okResult.Entries) + } + + resp = a.toolGetBackendLogs("user-1", `{"trader_id":"trader-other","limit":5}`) + var denied struct { + Error string `json:"error"` + } + if err := json.Unmarshal([]byte(resp), &denied); err != nil { + t.Fatalf("unmarshal denied response: %v\nraw=%s", err, resp) + } + if denied.Error != "trader not found for current user" { + t.Fatalf("unexpected denied response: %+v", denied) + } +} diff --git a/agent/brain.go b/agent/brain.go new file mode 100644 index 00000000..c3c267c9 --- /dev/null +++ b/agent/brain.go @@ -0,0 +1,183 @@ +package agent + +import ( + "encoding/json" + "fmt" + "log/slog" + "net/http" + "nofx/safe" + "strings" + "sync" + "time" +) + +// Brain handles proactive intelligence: signals, news, market briefs. +type Brain struct { + agent *Agent + logger *slog.Logger + http *http.Client + stopCh chan struct{} + recentSignals sync.Map // debounce +} + +func NewBrain(agent *Agent, logger *slog.Logger) *Brain { + return &Brain{ + agent: agent, + logger: logger, + http: &http.Client{Timeout: 15 * time.Second}, + stopCh: make(chan struct{}), + } +} + +func (b *Brain) Stop() { close(b.stopCh) } + +// cleanStaleSignals removes debounce entries older than 30 minutes. +func (b *Brain) cleanStaleSignals() { + cutoff := time.Now().Add(-30 * time.Minute) + b.recentSignals.Range(func(key, value any) bool { + if t, ok := value.(time.Time); ok && t.Before(cutoff) { + b.recentSignals.Delete(key) + } + return true + }) +} + +func (b *Brain) HandleSignal(sig Signal) { + key := fmt.Sprintf("%s:%s", sig.Type, sig.Symbol) + if v, ok := b.recentSignals.Load(key); ok { + if time.Since(v.(time.Time)) < 10*time.Minute { + return + } + } + b.recentSignals.Store(key, time.Now()) + + emoji := map[string]string{"info": "ℹ️", "warning": "⚠️", "critical": "🚨"} + e := emoji[sig.Severity] + if e == "" { e = "📊" } + + b.agent.notifyAll(fmt.Sprintf("%s *%s*\n\n%s", e, sig.Title, sig.Detail)) +} + +func (b *Brain) StartNewsScan(interval time.Duration) { + seen := make(map[string]bool) + safe.GoNamed("brain-news-scan", func() { + ticker := time.NewTicker(interval) + defer ticker.Stop() + cleanTick := 0 + for { + select { + case <-b.stopCh: return + case <-ticker.C: + b.scanNews(seen) + cleanTick++ + if cleanTick%6 == 0 { // every ~30 min + b.cleanStaleSignals() + } + } + } + }) +} + +func (b *Brain) scanNews(seen map[string]bool) { + resp, err := b.http.Get("https://min-api.cryptocompare.com/data/v2/news/?lang=EN&sortOrder=latest") + if err != nil { return } + defer resp.Body.Close() + if resp.StatusCode != http.StatusOK { + b.logger.Debug("news API non-200", "status", resp.StatusCode) + return + } + body, err := safe.ReadAllLimited(resp.Body, 1024*1024) // 1MB limit + if err != nil { return } + + var result struct { + Data []struct { + Title string `json:"title"` + Source string `json:"source"` + URL string `json:"url"` + Body string `json:"body"` + Categories string `json:"categories"` + PublishedOn int64 `json:"published_on"` + } `json:"Data"` + } + if err := json.Unmarshal(body, &result); err != nil { return } + + bullish := []string{"surge", "rally", "bullish", "breakout", "ath", "pump", "adoption"} + bearish := []string{"crash", "dump", "bearish", "sell-off", "plunge", "hack", "ban", "fraud"} + + for _, d := range result.Data { + if seen[d.URL] { continue } + seen[d.URL] = true + if time.Since(time.Unix(d.PublishedOn, 0)) > 10*time.Minute { continue } + + lower := strings.ToLower(d.Title + " " + d.Body) + bc, brc := 0, 0 + for _, w := range bullish { if strings.Contains(lower, w) { bc++ } } + for _, w := range bearish { if strings.Contains(lower, w) { brc++ } } + + if bc == 0 && brc == 0 { continue } + + emoji := "📰" + sentiment := "NEUTRAL" + if bc > brc { emoji = "🟢"; sentiment = "BULLISH" } + if brc > bc { emoji = "🔴"; sentiment = "BEARISH" } + + b.agent.notifyAll(fmt.Sprintf("%s *News*\n\n%s\n\n• Source: %s\n• Sentiment: %s", + emoji, d.Title, d.Source, sentiment)) + } + + // Evict ~half when seen map gets large (keep recent half to avoid re-notifying) + if len(seen) > 1000 { + i, half := 0, len(seen)/2 + for k := range seen { + if i >= half { break } + delete(seen, k) + i++ + } + } +} + +func (b *Brain) StartMarketBriefs(hours []int) { + safe.GoNamed("brain-market-briefs", func() { + ticker := time.NewTicker(1 * time.Minute) + defer ticker.Stop() + sent := make(map[string]bool) + for { + select { + case <-b.stopCh: return + case now := <-ticker.C: + key := now.Format("2006-01-02-15") + for _, h := range hours { + if now.Hour() == h && now.Minute() == 30 && !sent[key] { + sent[key] = true + b.sendBrief(h) + } + } + } + } + }) +} + +func (b *Brain) sendBrief(hour int) { + title := "☀️ *早间市场简报*" + if hour >= 18 { title = "🌙 *晚间市场简报*" } + + // Fetch BTC/ETH prices for the brief + var btcPrice, ethPrice, btcChg, ethChg string + for _, sym := range []string{"BTCUSDT", "ETHUSDT"} { + resp, err := b.http.Get(fmt.Sprintf("https://fapi.binance.com/fapi/v1/ticker/24hr?symbol=%s", sym)) + if err != nil { continue } + body, readErr := safe.ReadAllLimited(resp.Body, 64*1024) // 64KB limit + statusOK := resp.StatusCode == http.StatusOK + resp.Body.Close() + if readErr != nil || !statusOK { continue } + var t map[string]string + if err := json.Unmarshal(body, &t); err != nil { continue } + if sym == "BTCUSDT" { btcPrice = t["lastPrice"]; btcChg = t["priceChangePercent"] } + if sym == "ETHUSDT" { ethPrice = t["lastPrice"]; ethChg = t["priceChangePercent"] } + } + + brief := fmt.Sprintf("%s\n\n• BTC: $%s (%s%%)\n• ETH: $%s (%s%%)\n\n_%s_", + title, btcPrice, btcChg, ethPrice, ethChg, time.Now().Format("2006-01-02 15:04")) + + b.agent.notifyAll(brief) +} diff --git a/agent/config_tools_test.go b/agent/config_tools_test.go new file mode 100644 index 00000000..4cf717d7 --- /dev/null +++ b/agent/config_tools_test.go @@ -0,0 +1,386 @@ +package agent + +import ( + "encoding/json" + "path/filepath" + "strings" + "testing" + + "nofx/mcp" + "nofx/store" +) + +func newTestAgentWithStore(t *testing.T) *Agent { + t.Helper() + st, err := store.New(filepath.Join(t.TempDir(), "test.db")) + if err != nil { + t.Fatalf("create test store: %v", err) + } + t.Cleanup(func() { + _ = st.Close() + }) + return &Agent{store: st} +} + +func TestToolManageExchangeConfigLifecycle(t *testing.T) { + a := newTestAgentWithStore(t) + + createResp := a.toolManageExchangeConfig("user-1", `{ + "action":"create", + "exchange_type":"binance", + "account_name":"Main", + "enabled":true, + "testnet":true + }`) + + var created struct { + Status string `json:"status"` + Action string `json:"action"` + Exchange safeExchangeToolConfig `json:"exchange"` + } + if err := json.Unmarshal([]byte(createResp), &created); err != nil { + t.Fatalf("unmarshal create response: %v\nraw=%s", err, createResp) + } + if created.Status != "ok" || created.Action != "create" { + t.Fatalf("unexpected create response: %+v", created) + } + if created.Exchange.AccountName != "Main" || created.Exchange.ExchangeType != "binance" { + t.Fatalf("unexpected exchange payload: %+v", created.Exchange) + } + + updateResp := a.toolManageExchangeConfig("user-1", `{ + "action":"update", + "exchange_id":"`+created.Exchange.ID+`", + "account_name":"Renamed", + "enabled":false + }`) + var updated struct { + Status string `json:"status"` + Action string `json:"action"` + Exchange safeExchangeToolConfig `json:"exchange"` + } + if err := json.Unmarshal([]byte(updateResp), &updated); err != nil { + t.Fatalf("unmarshal update response: %v\nraw=%s", err, updateResp) + } + if updated.Exchange.AccountName != "Renamed" || updated.Exchange.Enabled { + t.Fatalf("unexpected updated exchange payload: %+v", updated.Exchange) + } + + deleteResp := a.toolManageExchangeConfig("user-1", `{ + "action":"delete", + "exchange_id":"`+created.Exchange.ID+`" + }`) + var deleted map[string]any + if err := json.Unmarshal([]byte(deleteResp), &deleted); err != nil { + t.Fatalf("unmarshal delete response: %v\nraw=%s", err, deleteResp) + } + if deleted["status"] != "ok" || deleted["action"] != "delete" { + t.Fatalf("unexpected delete response: %+v", deleted) + } +} + +func TestToolManageModelConfigLifecycle(t *testing.T) { + a := newTestAgentWithStore(t) + + createResp := a.toolManageModelConfig("user-1", `{ + "action":"create", + "provider":"openai", + "enabled":true, + "api_key":"sk-test", + "custom_api_url":"https://api.openai.com/v1", + "custom_model_name":"gpt-5-mini" + }`) + + var created struct { + Status string `json:"status"` + Action string `json:"action"` + Model safeModelToolConfig `json:"model"` + } + if err := json.Unmarshal([]byte(createResp), &created); err != nil { + t.Fatalf("unmarshal create response: %v\nraw=%s", err, createResp) + } + if created.Status != "ok" || created.Action != "create" { + t.Fatalf("unexpected create response: %+v", created) + } + if created.Model.Provider != "openai" || created.Model.CustomModelName != "gpt-5-mini" { + t.Fatalf("unexpected model payload: %+v", created.Model) + } + + updateResp := a.toolManageModelConfig("user-1", `{ + "action":"update", + "model_id":"`+created.Model.ID+`", + "enabled":false, + "custom_model_name":"gpt-5" + }`) + var updated struct { + Status string `json:"status"` + Action string `json:"action"` + Model safeModelToolConfig `json:"model"` + } + if err := json.Unmarshal([]byte(updateResp), &updated); err != nil { + t.Fatalf("unmarshal update response: %v\nraw=%s", err, updateResp) + } + if updated.Model.Enabled || updated.Model.CustomModelName != "gpt-5" { + t.Fatalf("unexpected updated model payload: %+v", updated.Model) + } + + deleteResp := a.toolManageModelConfig("user-1", `{ + "action":"delete", + "model_id":"`+created.Model.ID+`" + }`) + var deleted map[string]any + if err := json.Unmarshal([]byte(deleteResp), &deleted); err != nil { + t.Fatalf("unmarshal delete response: %v\nraw=%s", err, deleteResp) + } + if deleted["status"] != "ok" || deleted["action"] != "delete" { + t.Fatalf("unexpected delete response: %+v", deleted) + } +} + +func TestToolManageModelConfigRejectsEnableWithoutAPIKey(t *testing.T) { + a := newTestAgentWithStore(t) + + createResp := a.toolManageModelConfig("user-1", `{ + "action":"create", + "provider":"openai", + "enabled":false, + "custom_model_name":"gpt-4o" + }`) + var created struct { + Model safeModelToolConfig `json:"model"` + } + if err := json.Unmarshal([]byte(createResp), &created); err != nil { + t.Fatalf("unmarshal create response: %v\nraw=%s", err, createResp) + } + + updateResp := a.toolManageModelConfig("user-1", `{ + "action":"update", + "model_id":"`+created.Model.ID+`", + "enabled":true + }`) + if !strings.Contains(updateResp, "cannot enable model config before API key is configured") { + t.Fatalf("expected enabling incomplete model to fail, got %s", updateResp) + } +} + +func TestGetDefaultSkipsEnabledModelWithoutAPIKey(t *testing.T) { + a := newTestAgentWithStore(t) + + incompleteCreate := a.toolManageModelConfig("user-1", `{ + "action":"create", + "provider":"openai", + "enabled":true, + "custom_model_name":"gpt-4o" + }`) + var incomplete struct { + Model safeModelToolConfig `json:"model"` + } + if err := json.Unmarshal([]byte(incompleteCreate), &incomplete); err != nil { + t.Fatalf("unmarshal incomplete create response: %v\nraw=%s", err, incompleteCreate) + } + + completeCreate := a.toolManageModelConfig("user-1", `{ + "action":"create", + "provider":"deepseek", + "enabled":true, + "api_key":"sk-test", + "custom_model_name":"deepseek-chat" + }`) + var complete struct { + Model safeModelToolConfig `json:"model"` + } + if err := json.Unmarshal([]byte(completeCreate), &complete); err != nil { + t.Fatalf("unmarshal complete create response: %v\nraw=%s", err, completeCreate) + } + + model, err := a.store.AIModel().GetDefault("user-1") + if err != nil { + t.Fatalf("GetDefault() error = %v", err) + } + if model.ID != complete.Model.ID { + t.Fatalf("expected GetDefault to skip incomplete enabled model and return %s, got %s", complete.Model.ID, model.ID) + } +} + +func TestToolManageTraderLifecycle(t *testing.T) { + a := newTestAgentWithStore(t) + + modelResp := a.toolManageModelConfig("user-1", `{ + "action":"create", + "provider":"openai", + "enabled":true, + "api_key":"sk-test", + "custom_api_url":"https://api.openai.com/v1", + "custom_model_name":"gpt-5-mini" + }`) + var modelCreated struct { + Model safeModelToolConfig `json:"model"` + } + if err := json.Unmarshal([]byte(modelResp), &modelCreated); err != nil { + t.Fatalf("unmarshal model response: %v", err) + } + + exchangeResp := a.toolManageExchangeConfig("user-1", `{ + "action":"create", + "exchange_type":"binance", + "account_name":"Main", + "enabled":true + }`) + var exchangeCreated struct { + Exchange safeExchangeToolConfig `json:"exchange"` + } + if err := json.Unmarshal([]byte(exchangeResp), &exchangeCreated); err != nil { + t.Fatalf("unmarshal exchange response: %v", err) + } + + createResp := a.toolManageTrader("user-1", `{ + "action":"create", + "name":"Momentum Trader", + "ai_model_id":"`+modelCreated.Model.ID+`", + "exchange_id":"`+exchangeCreated.Exchange.ID+`", + "scan_interval_minutes":5 + }`) + var created struct { + Status string `json:"status"` + Action string `json:"action"` + Trader safeTraderToolConfig `json:"trader"` + } + if err := json.Unmarshal([]byte(createResp), &created); err != nil { + t.Fatalf("unmarshal create trader response: %v\nraw=%s", err, createResp) + } + if created.Status != "ok" || created.Action != "create" { + t.Fatalf("unexpected create trader response: %+v", created) + } + if created.Trader.Name != "Momentum Trader" || created.Trader.ScanIntervalMinutes != 5 { + t.Fatalf("unexpected created trader: %+v", created.Trader) + } + + listResp := a.toolManageTrader("user-1", `{"action":"list"}`) + var listed struct { + Count int `json:"count"` + Traders []safeTraderToolConfig `json:"traders"` + } + if err := json.Unmarshal([]byte(listResp), &listed); err != nil { + t.Fatalf("unmarshal list response: %v\nraw=%s", err, listResp) + } + if listed.Count != 1 || len(listed.Traders) != 1 { + t.Fatalf("unexpected trader list: %+v", listed) + } + + updateResp := a.toolManageTrader("user-1", `{ + "action":"update", + "trader_id":"`+created.Trader.ID+`", + "name":"Renamed Trader", + "scan_interval_minutes":8 + }`) + var updated struct { + Status string `json:"status"` + Action string `json:"action"` + Trader safeTraderToolConfig `json:"trader"` + } + if err := json.Unmarshal([]byte(updateResp), &updated); err != nil { + t.Fatalf("unmarshal update trader response: %v\nraw=%s", err, updateResp) + } + if updated.Trader.Name != "Renamed Trader" || updated.Trader.ScanIntervalMinutes != 8 { + t.Fatalf("unexpected updated trader: %+v", updated.Trader) + } + + deleteResp := a.toolManageTrader("user-1", `{ + "action":"delete", + "trader_id":"`+created.Trader.ID+`" + }`) + var deleted map[string]any + if err := json.Unmarshal([]byte(deleteResp), &deleted); err != nil { + t.Fatalf("unmarshal delete trader response: %v\nraw=%s", err, deleteResp) + } + if deleted["status"] != "ok" || deleted["action"] != "delete" { + t.Fatalf("unexpected delete trader response: %+v", deleted) + } +} + +func TestToolManageStrategyLifecycle(t *testing.T) { + a := newTestAgentWithStore(t) + + createResp := a.toolManageStrategy("user-1", `{ + "action":"create", + "name":"激进", + "description":"激进策略模板", + "lang":"zh" + }`) + + var created struct { + Status string `json:"status"` + Action string `json:"action"` + Strategy safeStrategyToolConfig `json:"strategy"` + } + if err := json.Unmarshal([]byte(createResp), &created); err != nil { + t.Fatalf("unmarshal create response: %v\nraw=%s", err, createResp) + } + if created.Status != "ok" || created.Action != "create" { + t.Fatalf("unexpected create response: %+v", created) + } + if created.Strategy.Name != "激进" { + t.Fatalf("unexpected strategy payload: %+v", created.Strategy) + } + + listResp := a.toolGetStrategies("user-1") + if !strings.Contains(listResp, "激进") { + t.Fatalf("expected created strategy in list, got %s", listResp) + } + + updateResp := a.toolManageStrategy("user-1", `{ + "action":"update", + "strategy_id":"`+created.Strategy.ID+`", + "description":"更新后的描述" + }`) + var updated struct { + Status string `json:"status"` + Action string `json:"action"` + Strategy safeStrategyToolConfig `json:"strategy"` + } + if err := json.Unmarshal([]byte(updateResp), &updated); err != nil { + t.Fatalf("unmarshal update response: %v\nraw=%s", err, updateResp) + } + if updated.Strategy.Description != "更新后的描述" { + t.Fatalf("unexpected updated strategy payload: %+v", updated.Strategy) + } + + activateResp := a.toolManageStrategy("user-1", `{ + "action":"activate", + "strategy_id":"`+created.Strategy.ID+`" + }`) + if !strings.Contains(activateResp, `"action":"activate"`) { + t.Fatalf("unexpected activate response: %s", activateResp) + } + + deleteResp := a.toolManageStrategy("user-1", `{ + "action":"delete", + "strategy_id":"`+created.Strategy.ID+`" + }`) + if !strings.Contains(deleteResp, `"action":"delete"`) { + t.Fatalf("unexpected delete response: %s", deleteResp) + } +} + +func TestLoadAIClientFromStoreUserUsesUserSpecificEnabledModel(t *testing.T) { + a := newTestAgentWithStore(t) + + if err := a.store.AIModel().Update("user-42", "openai", true, "sk-test", "https://api.openai.com/v1", "gpt-5-mini"); err != nil { + t.Fatalf("seed model: %v", err) + } + + client, modelName, ok := a.loadAIClientFromStoreUser("user-42") + if !ok { + t.Fatal("expected AI client to load from user-specific model") + } + if client == nil { + t.Fatal("expected non-nil AI client") + } + if modelName != "gpt-5-mini" { + t.Fatalf("unexpected model name: %s", modelName) + } + + if _, ok := client.(*mcp.Client); !ok { + t.Fatalf("expected *mcp.Client, got %T", client) + } +} diff --git a/agent/execution_state.go b/agent/execution_state.go new file mode 100644 index 00000000..fe6e7540 --- /dev/null +++ b/agent/execution_state.go @@ -0,0 +1,339 @@ +package agent + +import ( + "encoding/json" + "fmt" + "strings" + "time" +) + +const ( + executionStatusPlanning = "planning" + executionStatusRunning = "running" + executionStatusWaitingUser = "waiting_user" + executionStatusCompleted = "completed" + executionStatusFailed = "failed" +) + +const ( + planStepTypeTool = "tool" + planStepTypeReason = "reason" + planStepTypeAskUser = "ask_user" + planStepTypeRespond = "respond" +) + +const ( + planStepStatusPending = "pending" + planStepStatusRunning = "running" + planStepStatusCompleted = "completed" + planStepStatusFailed = "failed" +) + +type ExecutionState struct { + SessionID string `json:"session_id"` + UserID int64 `json:"user_id"` + Goal string `json:"goal"` + Status string `json:"status"` + PlanID string `json:"plan_id"` + Steps []PlanStep `json:"steps,omitempty"` + CurrentStepID string `json:"current_step_id,omitempty"` + CurrentReferences *CurrentReferences `json:"current_references,omitempty"` + DynamicSnapshots []Observation `json:"dynamic_snapshots,omitempty"` + ExecutionLog []Observation `json:"execution_log,omitempty"` + SummaryNotes []Observation `json:"summary_notes,omitempty"` + Waiting *WaitingState `json:"waiting,omitempty"` + Observations []Observation `json:"observations,omitempty"` + FinalAnswer string `json:"final_answer,omitempty"` + LastError string `json:"last_error,omitempty"` + UpdatedAt string `json:"updated_at"` +} + +type PlanStep struct { + ID string `json:"id"` + Type string `json:"type"` + Title string `json:"title,omitempty"` + Status string `json:"status,omitempty"` + ToolName string `json:"tool_name,omitempty"` + ToolArgs map[string]any `json:"tool_args,omitempty"` + Instruction string `json:"instruction,omitempty"` + RequiresConfirmation bool `json:"requires_confirmation,omitempty"` + OutputSummary string `json:"output_summary,omitempty"` + Error string `json:"error,omitempty"` +} + +type Observation struct { + StepID string `json:"step_id,omitempty"` + Kind string `json:"kind"` + Summary string `json:"summary"` + RawJSON string `json:"raw_json,omitempty"` + CreatedAt string `json:"created_at"` +} + +type WaitingState struct { + Question string `json:"question,omitempty"` + Intent string `json:"intent,omitempty"` + PendingFields []string `json:"pending_fields,omitempty"` + ConfirmationTarget string `json:"confirmation_target,omitempty"` + CreatedAt string `json:"created_at,omitempty"` +} + +type EntityReference struct { + ID string `json:"id,omitempty"` + Name string `json:"name,omitempty"` +} + +type CurrentReferences struct { + Strategy *EntityReference `json:"strategy,omitempty"` + Trader *EntityReference `json:"trader,omitempty"` + Model *EntityReference `json:"model,omitempty"` + Exchange *EntityReference `json:"exchange,omitempty"` +} + +type executionPlan struct { + Goal string `json:"goal"` + Steps []PlanStep `json:"steps"` +} + +const ( + executionLogMaxEntries = 8 + summaryNotesMaxEntries = 4 +) + +func ExecutionStateConfigKey(userID int64) string { + return fmt.Sprintf("agent_execution_state_%d", userID) +} + +func (a *Agent) getExecutionState(userID int64) ExecutionState { + if a.store == nil { + return ExecutionState{} + } + raw, err := a.store.GetSystemConfig(ExecutionStateConfigKey(userID)) + if err != nil { + a.logger.Warn("failed to load execution state", "error", err, "user_id", userID) + return ExecutionState{} + } + raw = strings.TrimSpace(raw) + if raw == "" { + return ExecutionState{} + } + + var state ExecutionState + if err := json.Unmarshal([]byte(raw), &state); err != nil { + a.logger.Warn("failed to parse execution state", "error", err, "user_id", userID) + return ExecutionState{} + } + return normalizeExecutionState(state) +} + +func (a *Agent) saveExecutionState(state ExecutionState) error { + if a.store == nil { + return fmt.Errorf("store unavailable") + } + state = normalizeExecutionState(state) + if state.SessionID == "" { + return a.store.SetSystemConfig(ExecutionStateConfigKey(state.UserID), "") + } + data, err := json.Marshal(state) + if err != nil { + return err + } + return a.store.SetSystemConfig(ExecutionStateConfigKey(state.UserID), string(data)) +} + +func (a *Agent) clearExecutionState(userID int64) { + if a.store == nil { + return + } + if err := a.store.SetSystemConfig(ExecutionStateConfigKey(userID), ""); err != nil { + a.logger.Warn("failed to clear execution state", "error", err, "user_id", userID) + } +} + +func newExecutionState(userID int64, goal string) ExecutionState { + now := time.Now().UTC().Format(time.RFC3339) + return normalizeExecutionState(ExecutionState{ + SessionID: fmt.Sprintf("sess_%d", time.Now().UTC().UnixNano()), + UserID: userID, + Goal: strings.TrimSpace(goal), + Status: executionStatusPlanning, + PlanID: fmt.Sprintf("plan_%d", time.Now().UTC().UnixNano()), + UpdatedAt: now, + }) +} + +func normalizeExecutionState(state ExecutionState) ExecutionState { + state.Goal = strings.TrimSpace(state.Goal) + state.Status = strings.TrimSpace(state.Status) + state.CurrentStepID = strings.TrimSpace(state.CurrentStepID) + state.FinalAnswer = strings.TrimSpace(state.FinalAnswer) + state.LastError = strings.TrimSpace(state.LastError) + state.CurrentReferences = normalizeCurrentReferences(state.CurrentReferences) + state.Waiting = normalizeWaitingState(state.Waiting) + if state.Status == "" && state.SessionID != "" { + state.Status = executionStatusPlanning + } + for i := range state.Steps { + state.Steps[i].ID = strings.TrimSpace(state.Steps[i].ID) + if state.Steps[i].ID == "" { + state.Steps[i].ID = fmt.Sprintf("step_%d", i+1) + } + state.Steps[i].Type = strings.TrimSpace(state.Steps[i].Type) + state.Steps[i].Title = strings.TrimSpace(state.Steps[i].Title) + state.Steps[i].ToolName = strings.TrimSpace(state.Steps[i].ToolName) + state.Steps[i].Instruction = strings.TrimSpace(state.Steps[i].Instruction) + state.Steps[i].OutputSummary = strings.TrimSpace(state.Steps[i].OutputSummary) + state.Steps[i].Error = strings.TrimSpace(state.Steps[i].Error) + if state.Steps[i].Status == "" { + state.Steps[i].Status = planStepStatusPending + } + } + if len(state.Observations) > 0 { + state.ExecutionLog = append(state.ExecutionLog, state.Observations...) + state.Observations = nil + } + state.DynamicSnapshots = normalizeObservationList(state.DynamicSnapshots) + state.ExecutionLog = normalizeObservationList(state.ExecutionLog) + state.SummaryNotes = normalizeObservationList(state.SummaryNotes) + state = compactExecutionLog(state) + if state.UpdatedAt == "" && state.SessionID != "" { + state.UpdatedAt = time.Now().UTC().Format(time.RFC3339) + } + return state +} + +func normalizeWaitingState(waiting *WaitingState) *WaitingState { + if waiting == nil { + return nil + } + waiting.Question = strings.TrimSpace(waiting.Question) + waiting.Intent = strings.TrimSpace(waiting.Intent) + waiting.PendingFields = cleanStringList(waiting.PendingFields) + waiting.ConfirmationTarget = strings.TrimSpace(waiting.ConfirmationTarget) + if waiting.CreatedAt == "" && (waiting.Question != "" || waiting.Intent != "" || len(waiting.PendingFields) > 0 || waiting.ConfirmationTarget != "") { + waiting.CreatedAt = time.Now().UTC().Format(time.RFC3339) + } + if waiting.Question == "" && waiting.Intent == "" && len(waiting.PendingFields) == 0 && waiting.ConfirmationTarget == "" { + return nil + } + return waiting +} + +func normalizeEntityReference(ref *EntityReference) *EntityReference { + if ref == nil { + return nil + } + ref.ID = strings.TrimSpace(ref.ID) + ref.Name = strings.TrimSpace(ref.Name) + if ref.ID == "" && ref.Name == "" { + return nil + } + return ref +} + +func normalizeCurrentReferences(refs *CurrentReferences) *CurrentReferences { + if refs == nil { + return nil + } + refs.Strategy = normalizeEntityReference(refs.Strategy) + refs.Trader = normalizeEntityReference(refs.Trader) + refs.Model = normalizeEntityReference(refs.Model) + refs.Exchange = normalizeEntityReference(refs.Exchange) + if refs.Strategy == nil && refs.Trader == nil && refs.Model == nil && refs.Exchange == nil { + return nil + } + return refs +} + +func normalizeObservationList(values []Observation) []Observation { + if len(values) == 0 { + return nil + } + out := make([]Observation, 0, len(values)) + for _, value := range values { + value.StepID = strings.TrimSpace(value.StepID) + value.Kind = strings.TrimSpace(value.Kind) + value.Summary = strings.TrimSpace(value.Summary) + value.RawJSON = strings.TrimSpace(value.RawJSON) + if value.Kind == "" && value.Summary == "" && value.RawJSON == "" { + continue + } + if value.CreatedAt == "" { + value.CreatedAt = time.Now().UTC().Format(time.RFC3339) + } + out = append(out, value) + } + if len(out) == 0 { + return nil + } + return out +} + +func compactExecutionLog(state ExecutionState) ExecutionState { + if len(state.ExecutionLog) <= executionLogMaxEntries { + if len(state.SummaryNotes) > summaryNotesMaxEntries { + state.SummaryNotes = state.SummaryNotes[len(state.SummaryNotes)-summaryNotesMaxEntries:] + } + return state + } + + overflow := state.ExecutionLog[:len(state.ExecutionLog)-executionLogMaxEntries] + state.ExecutionLog = state.ExecutionLog[len(state.ExecutionLog)-executionLogMaxEntries:] + summary := summarizeExecutionOverflow(overflow) + if summary != nil { + state.SummaryNotes = append(state.SummaryNotes, *summary) + if len(state.SummaryNotes) > summaryNotesMaxEntries { + state.SummaryNotes = state.SummaryNotes[len(state.SummaryNotes)-summaryNotesMaxEntries:] + } + } + return state +} + +func summarizeExecutionOverflow(values []Observation) *Observation { + if len(values) == 0 { + return nil + } + summaries := make([]string, 0, len(values)) + for _, value := range values { + label := value.Kind + if label == "" { + label = "observation" + } + if value.Summary != "" { + summaries = append(summaries, fmt.Sprintf("%s: %s", label, value.Summary)) + } else if value.RawJSON != "" { + summaries = append(summaries, fmt.Sprintf("%s: %s", label, value.RawJSON)) + } + } + if len(summaries) == 0 { + return nil + } + text := strings.Join(summaries, " | ") + if len(text) > 500 { + text = text[:500] + "..." + } + return &Observation{ + Kind: "execution_summary", + Summary: text, + CreatedAt: time.Now().UTC().Format(time.RFC3339), + } +} + +func appendDynamicSnapshot(state *ExecutionState, obs Observation) { + state.DynamicSnapshots = append(state.DynamicSnapshots, obs) + state.DynamicSnapshots = normalizeObservationList(state.DynamicSnapshots) +} + +func appendExecutionLog(state *ExecutionState, obs Observation) { + state.ExecutionLog = append(state.ExecutionLog, obs) + *state = normalizeExecutionState(*state) +} + +func buildObservationContext(state ExecutionState) map[string]any { + state = normalizeExecutionState(state) + return map[string]any{ + "current_references": state.CurrentReferences, + "dynamic_snapshots": state.DynamicSnapshots, + "execution_log": state.ExecutionLog, + "summary_notes": state.SummaryNotes, + } +} diff --git a/agent/history.go b/agent/history.go new file mode 100644 index 00000000..662bbd31 --- /dev/null +++ b/agent/history.go @@ -0,0 +1,103 @@ +package agent + +import ( + "sync" + "time" +) + +// chatMessage represents a single message in conversation history. +type chatMessage struct { + Role string `json:"role"` // "user" or "assistant" + Content string `json:"content"` + Timestamp time.Time `json:"timestamp"` +} + +// chatHistory stores conversation history per user. +type chatHistory struct { + mu sync.RWMutex + sessions map[int64][]chatMessage + maxTurns int // hard safety cap in messages per user +} + +func newChatHistory(maxTurns int) *chatHistory { + if maxTurns <= 0 { + maxTurns = 100 // default hard cap; recent-window trimming is handled separately + } + return &chatHistory{ + sessions: make(map[int64][]chatMessage), + maxTurns: maxTurns, + } +} + +// Add appends a message to the user's history. +func (h *chatHistory) Add(userID int64, role, content string) { + h.mu.Lock() + defer h.mu.Unlock() + + h.sessions[userID] = append(h.sessions[userID], chatMessage{ + Role: role, + Content: content, + Timestamp: time.Now(), + }) + + // Hard safety cap in case summarization is unavailable. + msgs := h.sessions[userID] + if len(msgs) > h.maxTurns { + h.sessions[userID] = msgs[len(msgs)-h.maxTurns:] + } +} + +// Get returns the conversation history for a user. +func (h *chatHistory) Get(userID int64) []chatMessage { + h.mu.RLock() + defer h.mu.RUnlock() + + msgs := h.sessions[userID] + if msgs == nil { + return nil + } + // Return a copy + result := make([]chatMessage, len(msgs)) + copy(result, msgs) + return result +} + +func (h *chatHistory) Replace(userID int64, msgs []chatMessage) { + h.mu.Lock() + defer h.mu.Unlock() + + if len(msgs) == 0 { + delete(h.sessions, userID) + return + } + + if len(msgs) > h.maxTurns { + msgs = msgs[len(msgs)-h.maxTurns:] + } + cloned := make([]chatMessage, len(msgs)) + copy(cloned, msgs) + h.sessions[userID] = cloned +} + +// Clear resets conversation history for a user. +func (h *chatHistory) Clear(userID int64) { + h.mu.Lock() + defer h.mu.Unlock() + delete(h.sessions, userID) +} + +// CleanOld removes sessions older than the given duration. +func (h *chatHistory) CleanOld(maxAge time.Duration) { + h.mu.Lock() + defer h.mu.Unlock() + + now := time.Now() + for uid, msgs := range h.sessions { + if len(msgs) > 0 { + lastMsg := msgs[len(msgs)-1] + if now.Sub(lastMsg.Timestamp) > maxAge { + delete(h.sessions, uid) + } + } + } +} diff --git a/agent/i18n.go b/agent/i18n.go new file mode 100644 index 00000000..47425cab --- /dev/null +++ b/agent/i18n.go @@ -0,0 +1,86 @@ +package agent + +var i18nMessages = map[string]map[string]string{ + "help": { + "zh": "🤖 *NOFXi — 你的 AI 交易 Agent*\n\n" + + "*交易:* /buy /sell /long /short + 交易对 数量 杠杆\n" + + "*查询:* /positions /balance /pnl /traders\n" + + "*分析:* /analyze BTC\n" + + "*监控:* /watch BTC · /unwatch BTC\n" + + "*策略:* /strategy\n" + + "*系统:* /status /help\n\n" + + "直接跟我说话就行，中英文都可以 💬", + "en": "🤖 *NOFXi — Your AI Trading Agent*\n\n" + + "*Trade:* /buy /sell /long /short + symbol qty leverage\n" + + "*Query:* /positions /balance /pnl /traders\n" + + "*Analyze:* /analyze BTC\n" + + "*Monitor:* /watch BTC · /unwatch BTC\n" + + "*Strategy:* /strategy\n" + + "*System:* /status /help\n\n" + + "Just talk to me in any language 💬", + }, + "status": { + "zh": "📊 *NOFXi 状态*\n\n• Traders: %d/%d 运行中\n• 监控: %d 个交易对\n• AI: %s\n• 时间: %s", + "en": "📊 *NOFXi Status*\n\n• Traders: %d/%d running\n• Watching: %d symbols\n• AI: %s\n• Time: %s", + }, + "no_traders": { + "zh": "📭 暂无 Trader。请在 Web UI 中创建和配置。", + "en": "📭 No traders configured. Create one in Web UI.", + }, + "no_running_trader": { + "zh": "⚠️ 没有运行中的 Trader。请在 Web UI 中启动。", + "en": "⚠️ No running trader. Start one in Web UI.", + }, + "no_positions": { + "zh": "📭 当前没有持仓。", + "en": "📭 No open positions.", + }, + "positions_header": { + "zh": "📊 *当前持仓*\n\n", + "en": "📊 *Open Positions*\n\n", + }, + "total_pnl": { + "zh": "💰 *总未实现盈亏: $%.2f*", + "en": "💰 *Total Unrealized P/L: $%.2f*", + }, + "balance_header": { + "zh": "💰 *账户余额*\n\n", + "en": "💰 *Account Balances*\n\n", + }, + "traders_header": { + "zh": "🤖 *Traders*\n\n", + "en": "🤖 *Traders*\n\n", + }, + "trade_usage": { + "zh": "用法: `/buy BTC 0.01` 或 `/sell ETH 0.5 3x`", + "en": "Usage: `/buy BTC 0.01` or `/sell ETH 0.5 3x`", + }, + "invalid_qty": { + "zh": "❓ 无效数量: %s", + "en": "❓ Invalid quantity: %s", + }, + "analysis_header": { + "zh": "🔍 *%s 市场分析*", + "en": "🔍 *%s Analysis*", + }, + "sentinel_off": { + "zh": "⚠️ Sentinel 未启用。", + "en": "⚠️ Sentinel not enabled.", + }, + "system_prompt": { + "zh": "你是 NOFXi，一个专业的 AI 交易 Agent。简洁、专业、用中文回复。使用交易相关 emoji。", + "en": "You are NOFXi, a professional AI trading agent. Be concise, professional. Use trading emojis.", + }, +} + +func (a *Agent) msg(lang, key string) string { + if m, ok := i18nMessages[key]; ok { + if s, ok := m[lang]; ok { + return s + } + if s, ok := m["en"]; ok { + return s + } + } + return key +} diff --git a/agent/llm_skill_router.go b/agent/llm_skill_router.go new file mode 100644 index 00000000..3e53a699 --- /dev/null +++ b/agent/llm_skill_router.go @@ -0,0 +1,344 @@ +package agent + +import ( + "context" + "encoding/json" + "fmt" + "strings" + + "nofx/mcp" +) + +type llmSkillRouteDecision struct { + Route string `json:"route"` + Skill string `json:"skill,omitempty"` + Action string `json:"action,omitempty"` + Filter string `json:"filter,omitempty"` +} + +func (a *Agent) tryLLMSkillRoute(ctx context.Context, storeUserID string, userID int64, lang, text string, onEvent func(event, data string)) (string, bool, error) { + if a.aiClient == nil { + return "", false, nil + } + + text = strings.TrimSpace(text) + if text == "" { + return "", false, nil + } + + recentConversationCtx := a.buildRecentConversationContext(userID, text) + taskStateCtx := buildTaskStateContext(a.getTaskState(userID)) + executionState := normalizeExecutionState(a.getExecutionState(userID)) + executionJSON, _ := json.Marshal(executionState) + systemPrompt := `You are the lightweight skill router for NOFXi. +Decide whether the user's message should go to a structured skill or continue to the planner. +Return JSON only. Do not return markdown. + +Use route "skill" only when the user intent is clear enough to send directly to one structured skill. +Use route "planner" for ambiguous, multi-step, open-ended, analytical, or diagnostic requests. + +Available skills: +- trader_management +- exchange_management +- model_management +- strategy_management +- trader_diagnosis +- exchange_diagnosis +- model_diagnosis +- strategy_diagnosis + +For management skills, choose one atomic action from: +- query_list +- query_detail +- query_running +- create +- update_name +- update_bindings +- update_status +- update_endpoint +- update_config +- update_prompt +- delete +- start +- stop +- activate +- duplicate + +Set filter only when it is clearly implied by the user. Use values like: +- running_only +- stopped_only +- enabled_only +- disabled_only +- active_only +- default_only + +Rules: +- Prefer route "planner" when uncertain. +- Prefer route "planner" for market analysis, broad advice, multi-step troubleshooting, or requests that need synthesis. +- Prefer route "skill" for straightforward management requests like listing, creating, starting, stopping, enabling, disabling, renaming, or deleting known entities. +- Questions like "当前有运行中的trader吗" and "有没有 trader 在跑" are trader_management with action "query_running". +- Questions about one entity's details, config, parameters, or prompt should prefer action "query_detail". +- Do not use route "skill" for casual chat. +- Consider Recent conversation, Task state, and Execution state JSON before deciding. + +Return JSON with this exact shape: +{"route":"skill|planner","skill":"","action":"","filter":""}` + userPrompt := fmt.Sprintf("Language: %s\nUser message: %s\n\nRecent conversation:\n%s\n\nTask state:\n%s\n\nExecution state JSON:\n%s", lang, text, recentConversationCtx, taskStateCtx, string(executionJSON)) + + stageCtx, cancel := withPlannerStageTimeout(ctx, directReplyTimeout) + defer cancel() + + raw, err := a.aiClient.CallWithRequest(&mcp.Request{ + Messages: []mcp.Message{ + mcp.NewSystemMessage(systemPrompt), + mcp.NewUserMessage(userPrompt), + }, + Ctx: stageCtx, + }) + if err != nil { + return "", false, nil + } + + decision, err := parseLLMSkillRouteDecision(raw) + if err != nil || decision.Route != "skill" { + return "", false, nil + } + + outcome, ok := a.executeLLMSkillRoute(storeUserID, userID, lang, text, decision) + if !ok { + return "", false, nil + } + + review, err := a.reviewTaskCompletion(ctx, userID, lang, text, outcome) + if err != nil { + if outcome.Status == skillOutcomeRecoverableError || outcome.Status == skillOutcomeFatalError || outcome.Status == skillOutcomeNotHandled { + return "", false, nil + } + review = taskReviewDecision{Route: "complete", Answer: outcome.UserMessage} + } + if review.Route == "replan" { + answer, planErr := a.runPlannedAgent(ctx, storeUserID, userID, lang, fmt.Sprintf("Original user request:\n%s\n\nPrevious skill outcome JSON:\n%s", text, mustMarshalJSON(outcome)), onEvent) + return answer, true, planErr + } + + answer := strings.TrimSpace(review.Answer) + if answer == "" { + answer = strings.TrimSpace(outcome.UserMessage) + } + if answer == "" { + return "", false, nil + } + + a.recordSkillInteraction(userID, text, answer) + if onEvent != nil { + label := "llm_skill_route" + if decision.Skill != "" { + label += ":" + decision.Skill + } + if decision.Action != "" { + label += ":" + decision.Action + } + onEvent(StreamEventTool, label) + onEvent(StreamEventDelta, answer) + } + return answer, true, nil +} + +func parseLLMSkillRouteDecision(raw string) (llmSkillRouteDecision, error) { + raw = strings.TrimSpace(raw) + raw = strings.TrimPrefix(raw, "```json") + raw = strings.TrimPrefix(raw, "```") + raw = strings.TrimSuffix(raw, "```") + raw = strings.TrimSpace(raw) + + var decision llmSkillRouteDecision + if err := json.Unmarshal([]byte(raw), &decision); err == nil { + return normalizeLLMSkillRouteDecision(decision), nil + } + start := strings.Index(raw, "{") + end := strings.LastIndex(raw, "}") + if start >= 0 && end > start { + if err := json.Unmarshal([]byte(raw[start:end+1]), &decision); err == nil { + return normalizeLLMSkillRouteDecision(decision), nil + } + } + return llmSkillRouteDecision{}, fmt.Errorf("invalid llm skill route json") +} + +func normalizeLLMSkillRouteDecision(decision llmSkillRouteDecision) llmSkillRouteDecision { + decision.Route = strings.TrimSpace(strings.ToLower(decision.Route)) + decision.Skill = strings.TrimSpace(strings.ToLower(decision.Skill)) + decision.Filter = strings.TrimSpace(strings.ToLower(decision.Filter)) + if decision.Action == "query" && decision.Filter == "running_only" && decision.Skill == "trader_management" { + decision.Action = "query_running" + } else { + decision.Action = normalizeAtomicSkillAction(decision.Skill, decision.Action) + } + return decision +} + +func (a *Agent) executeLLMSkillRoute(storeUserID string, userID int64, lang, text string, decision llmSkillRouteDecision) (skillOutcome, bool) { + session := skillSession{Name: decision.Skill, Action: decision.Action} + + switch decision.Skill { + case "trader_management": + if decision.Action == "create" { + answer, handled := a.handleCreateTraderSkill(storeUserID, userID, lang, text, session) + if !handled { + return skillOutcome{}, false + } + return inferSkillOutcome(decision.Skill, decision.Action, answer, a.getSkillSession(userID), skillDataForAction(storeUserID, decision.Skill, decision.Action, a)), true + } + answer, handled := a.handleTraderManagementSkill(storeUserID, userID, lang, text, session) + if handled && decision.Action == "query_running" { + answer = applyTraderQueryFilter(lang, answer, a.toolListTraders(storeUserID), "running_only") + } + if !handled { + return skillOutcome{}, false + } + return inferSkillOutcome(decision.Skill, decision.Action, answer, a.getSkillSession(userID), skillDataForAction(storeUserID, decision.Skill, decision.Action, a)), true + case "exchange_management": + answer, handled := a.handleExchangeManagementSkill(storeUserID, userID, lang, text, session) + if !handled { + return skillOutcome{}, false + } + return inferSkillOutcome(decision.Skill, decision.Action, answer, a.getSkillSession(userID), skillDataForAction(storeUserID, decision.Skill, decision.Action, a)), true + case "model_management": + answer, handled := a.handleModelManagementSkill(storeUserID, userID, lang, text, session) + if !handled { + return skillOutcome{}, false + } + return inferSkillOutcome(decision.Skill, decision.Action, answer, a.getSkillSession(userID), skillDataForAction(storeUserID, decision.Skill, decision.Action, a)), true + case "strategy_management": + answer, handled := a.handleStrategyManagementSkill(storeUserID, userID, lang, text, session) + if !handled { + return skillOutcome{}, false + } + return inferSkillOutcome(decision.Skill, decision.Action, answer, a.getSkillSession(userID), skillDataForAction(storeUserID, decision.Skill, decision.Action, a)), true + case "model_diagnosis": + return skillOutcome{ + Skill: decision.Skill, + Action: defaultIfEmpty(decision.Action, "diagnose"), + Status: skillOutcomeSuccess, + GoalAchieved: true, + UserMessage: a.handleModelDiagnosisSkill(storeUserID, lang, text), + }, true + case "exchange_diagnosis": + return skillOutcome{ + Skill: decision.Skill, + Action: defaultIfEmpty(decision.Action, "diagnose"), + Status: skillOutcomeSuccess, + GoalAchieved: true, + UserMessage: a.handleExchangeDiagnosisSkill(storeUserID, lang, text), + }, true + case "trader_diagnosis": + return skillOutcome{ + Skill: decision.Skill, + Action: defaultIfEmpty(decision.Action, "diagnose"), + Status: skillOutcomeSuccess, + GoalAchieved: true, + UserMessage: a.handleTraderDiagnosisSkill(storeUserID, lang, text), + }, true + case "strategy_diagnosis": + return skillOutcome{ + Skill: decision.Skill, + Action: defaultIfEmpty(decision.Action, "diagnose"), + Status: skillOutcomeSuccess, + GoalAchieved: true, + UserMessage: a.handleStrategyDiagnosisSkill(storeUserID, lang, text), + }, true + default: + return skillOutcome{}, false + } +} + +func skillDataForAction(storeUserID, skill, action string, a *Agent) map[string]any { + var raw string + switch skill { + case "trader_management": + if strings.HasPrefix(action, "query") { + raw = a.toolListTraders(storeUserID) + } + case "exchange_management": + if strings.HasPrefix(action, "query") { + raw = a.toolGetExchangeConfigs(storeUserID) + } + case "model_management": + if strings.HasPrefix(action, "query") { + raw = a.toolGetModelConfigs(storeUserID) + } + case "strategy_management": + if strings.HasPrefix(action, "query") { + raw = a.toolGetStrategies(storeUserID) + } + } + if strings.TrimSpace(raw) == "" { + return nil + } + var data map[string]any + if err := json.Unmarshal([]byte(raw), &data); err != nil { + return nil + } + return data +} + +func mustMarshalJSON(v any) string { + data, _ := json.Marshal(v) + return string(data) +} + +func applyTraderQueryFilter(lang, fallback, raw, filter string) string { + filter = strings.TrimSpace(strings.ToLower(filter)) + if filter == "" { + return fallback + } + + var payload struct { + Traders []struct { + Name string `json:"name"` + IsRunning bool `json:"is_running"` + } `json:"traders"` + } + if err := json.Unmarshal([]byte(raw), &payload); err != nil { + return fallback + } + + switch filter { + case "running_only": + names := make([]string, 0, len(payload.Traders)) + for _, trader := range payload.Traders { + if trader.IsRunning { + names = append(names, strings.TrimSpace(trader.Name)) + } + } + if lang == "zh" { + if len(names) == 0 { + return "当前没有运行中的交易员。" + } + return fmt.Sprintf("当前有 %d 个运行中的交易员：%s。", len(names), strings.Join(names, "、")) + } + if len(names) == 0 { + return "There are no running traders right now." + } + return fmt.Sprintf("There are %d running traders right now: %s.", len(names), strings.Join(names, ", ")) + case "stopped_only": + names := make([]string, 0, len(payload.Traders)) + for _, trader := range payload.Traders { + if !trader.IsRunning { + names = append(names, strings.TrimSpace(trader.Name)) + } + } + if lang == "zh" { + if len(names) == 0 { + return "当前没有已停止的交易员。" + } + return fmt.Sprintf("当前有 %d 个未运行的交易员：%s。", len(names), strings.Join(names, "、")) + } + if len(names) == 0 { + return "There are no stopped traders right now." + } + return fmt.Sprintf("There are %d stopped traders right now: %s.", len(names), strings.Join(names, ", ")) + default: + return fallback + } +} diff --git a/agent/memory.go b/agent/memory.go new file mode 100644 index 00000000..4b274648 --- /dev/null +++ b/agent/memory.go @@ -0,0 +1,467 @@ +package agent + +import ( + "context" + "encoding/json" + "fmt" + "strings" + "time" + + "nofx/mcp" +) + +const ( + recentConversationRounds = 3 + recentConversationMessages = recentConversationRounds * 2 + taskStateSummaryTokenLimit = 1200 + shortTermCompressThreshold = 900 + incrementalTaskStateMessages = 6 + incrementalTaskStateTokenLimit = 500 +) + +type DecisionMemory struct { + Action string `json:"action,omitempty"` + Reason string `json:"reason,omitempty"` + StillValid bool `json:"still_valid,omitempty"` + Timestamp string `json:"timestamp,omitempty"` +} + +type TaskState struct { + CurrentGoal string `json:"current_goal,omitempty"` + ActiveFlow string `json:"active_flow,omitempty"` + // OpenLoops stores only high-level unresolved issues that still matter across turns. + // Step-level pending work belongs in ExecutionState, not here. + OpenLoops []string `json:"open_loops,omitempty"` + ImportantFacts []string `json:"important_facts,omitempty"` + LastDecision *DecisionMemory `json:"last_decision,omitempty"` + UpdatedAt string `json:"updated_at,omitempty"` +} + +func TaskStateConfigKey(userID int64) string { + return fmt.Sprintf("agent_task_state_%d", userID) +} + +func (a *Agent) getTaskState(userID int64) TaskState { + if a.store == nil { + return TaskState{} + } + raw, err := a.store.GetSystemConfig(TaskStateConfigKey(userID)) + if err != nil { + a.logger.Warn("failed to load task state", "error", err, "user_id", userID) + return TaskState{} + } + raw = strings.TrimSpace(raw) + if raw == "" { + return TaskState{} + } + + var state TaskState + if err := json.Unmarshal([]byte(raw), &state); err != nil { + a.logger.Warn("failed to parse task state", "error", err, "user_id", userID) + return TaskState{} + } + return normalizeTaskState(state) +} + +func (a *Agent) saveTaskState(userID int64, state TaskState) error { + if a.store == nil { + return fmt.Errorf("store unavailable") + } + state = normalizeTaskState(state) + if isZeroTaskState(state) { + return a.store.SetSystemConfig(TaskStateConfigKey(userID), "") + } + data, err := json.Marshal(state) + if err != nil { + return err + } + return a.store.SetSystemConfig(TaskStateConfigKey(userID), string(data)) +} + +func (a *Agent) clearTaskState(userID int64) { + if a.store == nil { + return + } + if err := a.store.SetSystemConfig(TaskStateConfigKey(userID), ""); err != nil { + a.logger.Warn("failed to clear task state", "error", err, "user_id", userID) + } +} + +func normalizeTaskState(state TaskState) TaskState { + state.CurrentGoal = strings.TrimSpace(state.CurrentGoal) + state.ActiveFlow = strings.TrimSpace(state.ActiveFlow) + state.OpenLoops = filterTaskStateOpenLoops(cleanStringList(state.OpenLoops)) + state.ImportantFacts = cleanStringList(state.ImportantFacts) + if state.LastDecision != nil { + state.LastDecision.Action = strings.TrimSpace(state.LastDecision.Action) + state.LastDecision.Reason = strings.TrimSpace(state.LastDecision.Reason) + state.LastDecision.Timestamp = strings.TrimSpace(state.LastDecision.Timestamp) + if state.LastDecision.Timestamp == "" && (state.LastDecision.Action != "" || state.LastDecision.Reason != "") { + state.LastDecision.Timestamp = time.Now().UTC().Format(time.RFC3339) + } + if state.LastDecision.Action == "" && state.LastDecision.Reason == "" { + state.LastDecision = nil + } + } + if state.UpdatedAt == "" && !isZeroTaskState(state) { + state.UpdatedAt = time.Now().UTC().Format(time.RFC3339) + } + return state +} + +func isZeroTaskState(state TaskState) bool { + return state.CurrentGoal == "" && + state.ActiveFlow == "" && + len(state.OpenLoops) == 0 && + len(state.ImportantFacts) == 0 && + state.LastDecision == nil +} + +func cleanStringList(values []string) []string { + if len(values) == 0 { + return nil + } + out := make([]string, 0, len(values)) + seen := make(map[string]struct{}, len(values)) + for _, v := range values { + v = strings.TrimSpace(v) + if v == "" { + continue + } + key := strings.ToLower(v) + if _, ok := seen[key]; ok { + continue + } + seen[key] = struct{}{} + out = append(out, v) + } + if len(out) == 0 { + return nil + } + return out +} + +func filterTaskStateOpenLoops(values []string) []string { + if len(values) == 0 { + return nil + } + + rejectedPrefixes := []string{ + "wait for ", + "waiting for ", + "ask for ", + "call ", + "run ", + "execute ", + "invoke ", + "use tool", + "step ", + } + rejectedContains := []string{ + "current step", + "tool call", + "api key", + "api secret", + "secret key", + "passphrase", + "model id", + "exchange id", + } + + filtered := make([]string, 0, len(values)) + for _, value := range values { + lower := strings.ToLower(strings.TrimSpace(value)) + if lower == "" { + continue + } + if matchesAnyPrefix(lower, rejectedPrefixes) || matchesAnyContains(lower, rejectedContains) { + continue + } + filtered = append(filtered, value) + } + if len(filtered) == 0 { + return nil + } + return filtered +} + +func matchesAnyPrefix(value string, prefixes []string) bool { + for _, prefix := range prefixes { + if strings.HasPrefix(value, prefix) { + return true + } + } + return false +} + +func matchesAnyContains(value string, patterns []string) bool { + for _, pattern := range patterns { + if strings.Contains(value, pattern) { + return true + } + } + return false +} + +func buildTaskStateContext(state TaskState) string { + state = normalizeTaskState(state) + if isZeroTaskState(state) { + return "" + } + + var sb strings.Builder + sb.WriteString("[Structured Task State - durable, non-derivable context]\n") + if state.CurrentGoal != "" { + sb.WriteString("- Current goal: ") + sb.WriteString(state.CurrentGoal) + sb.WriteString("\n") + } + if state.ActiveFlow != "" { + sb.WriteString("- Active flow: ") + sb.WriteString(state.ActiveFlow) + sb.WriteString("\n") + } + for _, loop := range state.OpenLoops { + sb.WriteString("- High-level open loop: ") + sb.WriteString(loop) + sb.WriteString("\n") + } + for _, fact := range state.ImportantFacts { + sb.WriteString("- Important fact: ") + sb.WriteString(fact) + sb.WriteString("\n") + } + if state.LastDecision != nil { + sb.WriteString("- Last decision: ") + sb.WriteString(state.LastDecision.Action) + if state.LastDecision.Reason != "" { + sb.WriteString(" | reason: ") + sb.WriteString(state.LastDecision.Reason) + } + if state.LastDecision.StillValid { + sb.WriteString(" | still valid") + } + sb.WriteString("\n") + } + return strings.TrimSpace(sb.String()) +} + +func estimateChatMessagesTokens(msgs []chatMessage) int { + total := 0 + for _, msg := range msgs { + total += len([]rune(msg.Content))/3 + 10 + } + return total +} + +func formatChatMessagesForSummary(msgs []chatMessage) string { + var sb strings.Builder + for _, msg := range msgs { + if strings.TrimSpace(msg.Content) == "" { + continue + } + role := "User" + if msg.Role == "assistant" { + role = "Assistant" + } + sb.WriteString(role) + sb.WriteString(": ") + sb.WriteString(msg.Content) + sb.WriteString("\n") + } + return strings.TrimSpace(sb.String()) +} + +func (a *Agent) maybeCompressHistory(ctx context.Context, userID int64) { + if a.aiClient == nil || a.history == nil { + return + } + + msgs := a.history.Get(userID) + if len(msgs) <= recentConversationMessages { + return + } + if estimateChatMessagesTokens(msgs) <= shortTermCompressThreshold { + return + } + + splitAt := len(msgs) - recentConversationMessages + if splitAt <= 0 { + return + } + + oldPart := msgs[:splitAt] + recentPart := msgs[splitAt:] + existingState := a.getTaskState(userID) + updatedState, err := a.summarizeConversationToTaskState(ctx, userID, existingState, oldPart) + if err != nil { + a.logger.Warn("failed to compress chat history", "error", err, "user_id", userID) + return + } + if err := a.saveTaskState(userID, updatedState); err != nil { + a.log().Warn("failed to persist task state", "error", err, "user_id", userID) + return + } + a.history.Replace(userID, recentPart) +} + +func (a *Agent) maybeUpdateTaskStateIncrementally(ctx context.Context, userID int64) { + if a.aiClient == nil || a.history == nil { + return + } + + msgs := a.history.Get(userID) + if len(msgs) < 2 { + return + } + + window := msgs + if len(window) > incrementalTaskStateMessages { + window = window[len(window)-incrementalTaskStateMessages:] + } + + existingState := a.getTaskState(userID) + updatedState, err := a.summarizeRecentConversationToTaskState(ctx, userID, existingState, window) + if err != nil { + a.log().Warn("failed to incrementally update task state", "error", err, "user_id", userID) + return + } + if err := a.saveTaskState(userID, updatedState); err != nil { + a.log().Warn("failed to persist incremental task state", "error", err, "user_id", userID) + } +} + +func (a *Agent) summarizeConversationToTaskState(ctx context.Context, userID int64, existing TaskState, oldPart []chatMessage) (TaskState, error) { + transcript := formatChatMessagesForSummary(oldPart) + if transcript == "" { + return normalizeTaskState(existing), nil + } + + existingJSON, err := json.Marshal(normalizeTaskState(existing)) + if err != nil { + return TaskState{}, err + } + + systemPrompt := `You maintain structured task state for a trading assistant. +Update the task state using the existing state plus archived dialogue. +Return JSON only. Do not return markdown. + +Rules: +- Keep only durable, non-derivable context useful for future turns. +- Do not store market prices, balances, positions, or anything tools can fetch again. +- Do not store chit-chat or repeated wording. +- current_goal: the user's active objective, if any. +- active_flow: a named flow such as onboarding, trading_confirmation, market_analysis, or empty. +- open_loops: only high-level unresolved issues that still matter across turns. +- Do not put execution-step pending work into open_loops. +- Bad open_loops examples: "wait for API secret", "call get_exchange_configs", "run step 2", "ask user for exchange_id". +- Good open_loops examples: "finish trader setup after external configuration is ready", "user still wants to complete onboarding". +- important_facts: non-derivable facts worth remembering briefly. +- last_decision: keep only one current relevant decision; omit if none. +- Replace stale items instead of appending blindly. +- If a field is no longer relevant, return it empty or omit it. +- Never invent facts.` + + userPrompt := fmt.Sprintf("Existing task state JSON:\n%s\n\nArchived dialogue to compress:\n%s\n\nReturn the new task state JSON with this exact shape:\n{\"current_goal\":\"\",\"active_flow\":\"\",\"open_loops\":[],\"important_facts\":[],\"last_decision\":{\"action\":\"\",\"reason\":\"\",\"still_valid\":false,\"timestamp\":\"\"},\"updated_at\":\"\"}", string(existingJSON), transcript) + + req := &mcp.Request{ + Messages: []mcp.Message{ + mcp.NewSystemMessage(systemPrompt), + mcp.NewUserMessage(userPrompt), + }, + Ctx: ctx, + MaxTokens: intPtr(taskStateSummaryTokenLimit), + } + + resp, err := a.aiClient.CallWithRequest(req) + if err != nil { + return TaskState{}, err + } + + state, err := parseTaskStateJSON(resp) + if err != nil { + return TaskState{}, err + } + state = normalizeTaskState(state) + a.log().Info("compressed chat history into task state", "user_id", userID, "archived_messages", len(oldPart)) + return state, nil +} + +func (a *Agent) summarizeRecentConversationToTaskState(ctx context.Context, userID int64, existing TaskState, recentPart []chatMessage) (TaskState, error) { + transcript := formatChatMessagesForSummary(recentPart) + if transcript == "" { + return normalizeTaskState(existing), nil + } + + existingJSON, err := json.Marshal(normalizeTaskState(existing)) + if err != nil { + return TaskState{}, err + } + + systemPrompt := `You maintain structured task state for a trading assistant. +Update the task state incrementally using the existing state plus the latest conversation window. +Return JSON only. Do not return markdown. + +Rules: +- Capture newly confirmed facts from the latest few turns immediately. +- Preserve important existing facts that still matter; replace stale items when contradicted. +- Keep only durable, non-derivable context useful for the next turns. +- current_goal: the user's active objective right now. +- active_flow: a named flow such as onboarding, trading_confirmation, market_analysis, strategy_debugging, or empty. +- open_loops: only high-level unresolved issues that still matter across turns. +- important_facts: include recently confirmed concrete facts, such as the current trader under discussion, the reported runtime error, the user's claimed config value, or the environment where the issue occurs. +- Do not store execution-step pending work or tool instructions. +- Do not store market prices, balances, or anything tools can fetch again. +- Keep last_decision only if there is a current relevant decision; omit it otherwise. +- Never invent facts.` + + userPrompt := fmt.Sprintf("Existing task state JSON:\n%s\n\nLatest conversation window:\n%s\n\nReturn the updated task state JSON with this exact shape:\n{\"current_goal\":\"\",\"active_flow\":\"\",\"open_loops\":[],\"important_facts\":[],\"last_decision\":{\"action\":\"\",\"reason\":\"\",\"still_valid\":false,\"timestamp\":\"\"},\"updated_at\":\"\"}", string(existingJSON), transcript) + + req := &mcp.Request{ + Messages: []mcp.Message{ + mcp.NewSystemMessage(systemPrompt), + mcp.NewUserMessage(userPrompt), + }, + Ctx: ctx, + MaxTokens: intPtr(incrementalTaskStateTokenLimit), + } + + resp, err := a.aiClient.CallWithRequest(req) + if err != nil { + return TaskState{}, err + } + + state, err := parseTaskStateJSON(resp) + if err != nil { + return TaskState{}, err + } + state = normalizeTaskState(state) + a.log().Info("incrementally refreshed task state", "user_id", userID, "window_messages", len(recentPart)) + return state, nil +} + +func parseTaskStateJSON(raw string) (TaskState, error) { + raw = strings.TrimSpace(raw) + raw = strings.TrimPrefix(raw, "```json") + raw = strings.TrimPrefix(raw, "```") + raw = strings.TrimSuffix(raw, "```") + raw = strings.TrimSpace(raw) + + var state TaskState + if err := json.Unmarshal([]byte(raw), &state); err == nil { + return state, nil + } + + start := strings.Index(raw, "{") + end := strings.LastIndex(raw, "}") + if start >= 0 && end > start { + if err := json.Unmarshal([]byte(raw[start:end+1]), &state); err == nil { + return state, nil + } + } + return TaskState{}, fmt.Errorf("invalid task state json") +} + +func intPtr(v int) *int { + return &v +} diff --git a/agent/memory_test.go b/agent/memory_test.go new file mode 100644 index 00000000..ed772be9 --- /dev/null +++ b/agent/memory_test.go @@ -0,0 +1,132 @@ +package agent + +import ( + "context" + "log/slog" + "path/filepath" + "strings" + "testing" + "time" + + "nofx/mcp" + "nofx/store" +) + +type fakeAIClient struct { + callCount int +} + +func (f *fakeAIClient) SetAPIKey(string, string, string) {} +func (f *fakeAIClient) SetTimeout(time.Duration) {} +func (f *fakeAIClient) CallWithMessages(string, string) (string, error) { + return "", nil +} +func (f *fakeAIClient) CallWithRequest(req *mcp.Request) (string, error) { + f.callCount++ + return `{"current_goal":"continue setup","active_flow":"onboarding","open_loops":["finish trader setup after external exchange/model configuration is ready"],"important_facts":["user selected OKX"],"last_decision":{"action":"paused setup","reason":"user asked a market question","still_valid":true},"updated_at":"2026-04-01T00:00:00Z"}`, nil +} +func (f *fakeAIClient) CallWithRequestStream(req *mcp.Request, onChunk func(string)) (string, error) { + return "", nil +} +func (f *fakeAIClient) CallWithRequestFull(req *mcp.Request) (*mcp.LLMResponse, error) { + return nil, nil +} + +func TestMaybeCompressHistoryKeepsRecentThreeRounds(t *testing.T) { + st, err := store.New(filepath.Join(t.TempDir(), "nofxi-test.db")) + if err != nil { + t.Fatalf("store.New() error = %v", err) + } + + fakeClient := &fakeAIClient{} + a := &Agent{ + store: st, + logger: slog.Default(), + history: newChatHistory(100), + aiClient: fakeClient, + } + + userID := int64(42) + payload := strings.Repeat("BTC ETH market context ", 20) + for i := 0; i < 6; i++ { + a.history.Add(userID, "user", "user turn #"+string(rune('0'+i))+" "+payload) + a.history.Add(userID, "assistant", "assistant turn #"+string(rune('0'+i))+" "+payload) + } + + a.maybeCompressHistory(context.Background(), userID) + + msgs := a.history.Get(userID) + if len(msgs) != recentConversationMessages { + t.Fatalf("expected %d recent messages, got %d", recentConversationMessages, len(msgs)) + } + if fakeClient.callCount != 1 { + t.Fatalf("expected summarizer to be called once, got %d", fakeClient.callCount) + } + + state := a.getTaskState(userID) + if state.CurrentGoal != "continue setup" { + t.Fatalf("expected persisted task state goal, got %#v", state) + } + if state.LastDecision == nil || state.LastDecision.Action != "paused setup" { + t.Fatalf("expected persisted last_decision, got %#v", state.LastDecision) + } + if len(state.OpenLoops) != 1 || state.OpenLoops[0] != "finish trader setup after external exchange/model configuration is ready" { + t.Fatalf("expected high-level open loop, got %#v", state.OpenLoops) + } + if strings.Contains(msgs[0].Content, "#0") { + t.Fatalf("expected oldest round to be compressed away, first recent message = %q", msgs[0].Content) + } + if !strings.Contains(msgs[0].Content, "#3") { + t.Fatalf("expected recent window to start from round #3, got %q", msgs[0].Content) + } + if !strings.Contains(msgs[len(msgs)-1].Content, "#5") { + t.Fatalf("expected latest round to remain in short-term history, got %q", msgs[len(msgs)-1].Content) + } +} + +func TestNormalizeTaskStateDropsExecutionLevelOpenLoops(t *testing.T) { + state := normalizeTaskState(TaskState{ + OpenLoops: []string{ + "wait for API secret", + "call get_exchange_configs", + "finish trader setup after external configuration is ready", + }, + }) + + if len(state.OpenLoops) != 1 { + t.Fatalf("expected only one high-level open loop to remain, got %#v", state.OpenLoops) + } + if state.OpenLoops[0] != "finish trader setup after external configuration is ready" { + t.Fatalf("unexpected open loop after normalization: %#v", state.OpenLoops) + } +} + +func TestMaybeUpdateTaskStateIncrementallyPersistsShortConversationFacts(t *testing.T) { + st, err := store.New(filepath.Join(t.TempDir(), "nofxi-test.db")) + if err != nil { + t.Fatalf("store.New() error = %v", err) + } + + fakeClient := &fakeAIClient{} + a := &Agent{ + store: st, + logger: slog.Default(), + history: newChatHistory(100), + aiClient: fakeClient, + } + + userID := int64(7) + a.history.Add(userID, "user", "我是在运行测试1交易员时遇到的，错误是运行时出现的") + a.history.Add(userID, "assistant", "我会继续排查测试1交易员的运行时错误") + + a.maybeUpdateTaskStateIncrementally(context.Background(), userID) + + if fakeClient.callCount != 1 { + t.Fatalf("expected incremental summarizer to be called once, got %d", fakeClient.callCount) + } + + state := a.getTaskState(userID) + if state.CurrentGoal != "continue setup" { + t.Fatalf("expected incrementally persisted task state, got %#v", state) + } +} diff --git a/agent/onboard.go b/agent/onboard.go new file mode 100644 index 00000000..aa7fe436 --- /dev/null +++ b/agent/onboard.go @@ -0,0 +1,595 @@ +package agent + +import ( + "fmt" + "strings" + "time" + + "golang.org/x/text/cases" + "golang.org/x/text/language" + "nofx/store" +) + +var titleCaser = cases.Title(language.English) +const setupExchangeAccountName = "Default" + +// Onboard handles first-time setup through natural language. +// When there's no trader configured, the agent guides the user. + +// SetupState tracks where the user is in the setup flow. +type SetupState struct { + Step string // "", "await_exchange", "await_api_key", "await_api_secret", "await_passphrase", "await_ai_model", "await_ai_key" + Exchange string + ExchangeID string + APIKey string + APISecret string + Passphrase string + AIProvider string + AIModel string + AIModelID string + AIKey string + AIBaseURL string +} + +// needsSetup returns true if no traders are configured. +func (a *Agent) needsSetup() bool { + if a.traderManager == nil { + return true + } + return len(a.traderManager.GetAllTraders()) == 0 +} + +// getSetupState loads the current setup state from user preferences. +func (a *Agent) getSetupState(userID int64) *SetupState { + step, _ := a.store.GetSystemConfig(fmt.Sprintf("setup_step_%d", userID)) + if step == "" { + return &SetupState{} + } + return &SetupState{ + Step: step, + Exchange: getConfig(a.store, userID, "exchange"), + ExchangeID: getConfig(a.store, userID, "exchange_id"), + APIKey: getConfig(a.store, userID, "api_key"), + APISecret: getConfig(a.store, userID, "api_secret"), + Passphrase: getConfig(a.store, userID, "passphrase"), + AIProvider: getConfig(a.store, userID, "ai_provider"), + AIModel: getConfig(a.store, userID, "ai_model"), + AIModelID: getConfig(a.store, userID, "ai_model_id"), + AIKey: getConfig(a.store, userID, "ai_key"), + AIBaseURL: getConfig(a.store, userID, "ai_base_url"), + } +} + +func (a *Agent) saveSetupState(userID int64, s *SetupState) { + a.store.SetSystemConfig(fmt.Sprintf("setup_step_%d", userID), s.Step) + setConfig(a.store, userID, "exchange", s.Exchange) + setConfig(a.store, userID, "exchange_id", s.ExchangeID) + setConfig(a.store, userID, "api_key", s.APIKey) + setConfig(a.store, userID, "api_secret", s.APISecret) + setConfig(a.store, userID, "passphrase", s.Passphrase) + setConfig(a.store, userID, "ai_provider", s.AIProvider) + setConfig(a.store, userID, "ai_model", s.AIModel) + setConfig(a.store, userID, "ai_model_id", s.AIModelID) + setConfig(a.store, userID, "ai_key", s.AIKey) + setConfig(a.store, userID, "ai_base_url", s.AIBaseURL) +} + +func (a *Agent) clearSetupState(userID int64) { + for _, k := range []string{"step", "exchange", "exchange_id", "api_key", "api_secret", "passphrase", "ai_provider", "ai_model", "ai_model_id", "ai_key", "ai_base_url"} { + a.store.SetSystemConfig(fmt.Sprintf("setup_%s_%d", k, userID), "") + } +} + +func getConfig(st *store.Store, uid int64, key string) string { + v, _ := st.GetSystemConfig(fmt.Sprintf("setup_%s_%d", key, uid)) + return v +} + +func setConfig(st *store.Store, uid int64, key, val string) { + st.SetSystemConfig(fmt.Sprintf("setup_%s_%d", key, uid), val) +} + +// handleSetupFlow processes the setup conversation. +// Returns (response, handled). If handled=false, continue to normal routing. +func (a *Agent) handleSetupFlow(userID int64, text string, L string) (string, bool) { + return a.handleSetupFlowForStoreUser("default", userID, text, L) +} + +func (a *Agent) handleSetupFlowForStoreUser(storeUserID string, userID int64, text string, L string) (string, bool) { + state := a.getSetupState(userID) + + lower := strings.ToLower(text) + + // Cancel setup — explicit or implicit (user asking unrelated questions) + if lower == "cancel" || lower == "取消" || lower == "/cancel" { + a.clearSetupState(userID) + return a.setupMsg(L, "cancelled"), true + } + + // If in a step that expects a key/secret, check if user is NOT sending a key + // Keys are typically long strings without spaces and Chinese characters + if state.Step == "await_api_key" || state.Step == "await_api_secret" || state.Step == "await_passphrase" || state.Step == "await_ai_key" { + trimmed := strings.TrimSpace(text) + hasChinese := false + for _, r := range trimmed { + if r >= 0x4e00 && r <= 0x9fff { + hasChinese = true + break + } + } + hasSpaces := strings.Contains(trimmed, " ") && !strings.HasPrefix(trimmed, "sk-") + tooShort := len(trimmed) < 8 + + if hasChinese || hasSpaces || tooShort { + // User is probably asking a question, not providing a key + a.clearSetupState(userID) + if L == "zh" { + return "👌 配置已暂停。我先回答你的问题——\n\n随时发送 *开始配置* 继续配置。", false + } + return "👌 Setup paused. Let me answer your question first—\n\nSend *setup* anytime to continue.", false + } + } + + switch state.Step { + case "await_exchange": + return a.handleExchangeChoice(userID, text, state, L) + case "await_api_key": + state.APIKey = strings.TrimSpace(text) + state.Step = "await_api_secret" + a.saveSetupState(userID, state) + return a.setupMsg(L, "ask_secret"), true + case "await_api_secret": + state.APISecret = strings.TrimSpace(text) + // OKX/Bitget/KuCoin need passphrase + if needsPassphrase(state.Exchange) { + state.Step = "await_passphrase" + a.saveSetupState(userID, state) + return a.setupMsg(L, "ask_passphrase"), true + } + exchangeID, err := a.saveSetupExchange(storeUserID, state) + if err != nil { + a.logger.Error("save exchange from setup failed", "error", err, "exchange", state.Exchange, "store_user_id", storeUserID) + if L == "zh" { + return fmt.Sprintf("⚠️ 交易所配置保存失败: %v\n请再试一次，或稍后去 Web UI 继续。", err), true + } + return fmt.Sprintf("⚠️ Failed to save exchange config: %v\nPlease try again, or continue later in the Web UI.", err), true + } + state.ExchangeID = exchangeID + state.Step = "await_ai_model" + a.saveSetupState(userID, state) + if L == "zh" { + return "✅ 交易所配置已保存，在配置页里现在就能看到。\n\n" + a.setupMsg(L, "ask_ai"), true + } + return "✅ Exchange config saved. It should now be visible in the config page.\n\n" + a.setupMsg(L, "ask_ai"), true + case "await_passphrase": + state.Passphrase = strings.TrimSpace(text) + exchangeID, err := a.saveSetupExchange(storeUserID, state) + if err != nil { + a.logger.Error("save exchange from setup failed", "error", err, "exchange", state.Exchange, "store_user_id", storeUserID) + if L == "zh" { + return fmt.Sprintf("⚠️ 交易所配置保存失败: %v\n请再试一次，或稍后去 Web UI 继续。", err), true + } + return fmt.Sprintf("⚠️ Failed to save exchange config: %v\nPlease try again, or continue later in the Web UI.", err), true + } + state.ExchangeID = exchangeID + state.Step = "await_ai_model" + a.saveSetupState(userID, state) + if L == "zh" { + return "✅ 交易所配置已保存，在配置页里现在就能看到。\n\n" + a.setupMsg(L, "ask_ai"), true + } + return "✅ Exchange config saved. It should now be visible in the config page.\n\n" + a.setupMsg(L, "ask_ai"), true + case "await_ai_model": + return a.handleAIChoice(storeUserID, userID, text, state, L) + case "await_ai_key": + state.AIKey = strings.TrimSpace(text) + aiModelID, err := a.saveSetupAIModel(storeUserID, state) + if err != nil { + a.logger.Error("save AI model from setup failed", "error", err, "provider", state.AIProvider, "store_user_id", storeUserID) + if L == "zh" { + return fmt.Sprintf("⚠️ AI 模型配置保存失败: %v\n请再试一次，或稍后去 Web UI 继续。", err), true + } + return fmt.Sprintf("⚠️ Failed to save AI model config: %v\nPlease try again, or continue later in the Web UI.", err), true + } + state.AIModelID = aiModelID + return a.finishSetup(storeUserID, userID, state, L) + } + + // Not in setup flow — only enter setup for a tiny set of explicit commands. + // Natural-language configuration requests should go to the planner first, + // including phrases like "开始配置" or "帮我配置交易所". + if isDirectSetupCommand(lower) { + state.Step = "await_exchange" + a.saveSetupState(userID, state) + return a.setupMsg(L, "ask_exchange"), true + } + + // Everything else — let normal routing handle it + return "", false +} + +func isDirectSetupCommand(text string) bool { + text = strings.ToLower(strings.TrimSpace(text)) + if text == "" { + return false + } + switch text { + case "setup", "/setup": + return true + default: + return false + } +} + +func (a *Agent) handleExchangeChoice(userID int64, text string, state *SetupState, L string) (string, bool) { + lower := strings.ToLower(strings.TrimSpace(text)) + + exchanges := map[string]string{ + "binance": "binance", "币安": "binance", "1": "binance", + "okx": "okx", "欧易": "okx", "2": "okx", + "bybit": "bybit", "3": "bybit", + "bitget": "bitget", "4": "bitget", + "gate": "gate", "5": "gate", + "kucoin": "kucoin", "库币": "kucoin", "6": "kucoin", + "hyperliquid": "hyperliquid", "7": "hyperliquid", + } + + ex, ok := exchanges[lower] + if !ok { + return a.setupMsg(L, "invalid_exchange"), true + } + + state.Exchange = ex + state.Step = "await_api_key" + a.saveSetupState(userID, state) + + if L == "zh" { + return fmt.Sprintf("✅ 选择了 *%s*\n\n请发送你的 API Key：", titleCaser.String(ex)), true + } + return fmt.Sprintf("✅ Selected *%s*\n\nPlease send your API Key:", titleCaser.String(ex)), true +} + +func (a *Agent) handleAIChoice(storeUserID string, userID int64, text string, state *SetupState, L string) (string, bool) { + lower := strings.ToLower(strings.TrimSpace(text)) + + models := map[string]struct{ provider, model, url string }{ + "deepseek": {"deepseek", "deepseek-chat", "https://api.deepseek.com/v1"}, + "1": {"deepseek", "deepseek-chat", "https://api.deepseek.com/v1"}, + "qwen": {"qwen", "qwen-plus", "https://dashscope.aliyuncs.com/compatible-mode/v1"}, + "通义": {"qwen", "qwen-plus", "https://dashscope.aliyuncs.com/compatible-mode/v1"}, + "2": {"qwen", "qwen-plus", "https://dashscope.aliyuncs.com/compatible-mode/v1"}, + "openai": {"openai", "gpt-4o", "https://api.openai.com/v1"}, + "gpt": {"openai", "gpt-4o", "https://api.openai.com/v1"}, + "3": {"openai", "gpt-4o", "https://api.openai.com/v1"}, + "claude": {"claude", "claude-3-5-sonnet-20241022", "https://api.anthropic.com/v1"}, + "4": {"claude", "claude-3-5-sonnet-20241022", "https://api.anthropic.com/v1"}, + "skip": {"", "", ""}, + "跳过": {"", "", ""}, + "5": {"", "", ""}, + } + + choice, ok := models[lower] + if !ok { + return a.setupMsg(L, "invalid_ai"), true + } + + if choice.model == "" { + // Skip AI, just create trader with exchange + state.AIProvider = "" + state.AIModel = "" + state.AIModelID = "" + state.AIKey = "" + return a.finishSetup(storeUserID, userID, state, L) + } + + state.AIProvider = choice.provider + state.AIModel = choice.model + state.AIBaseURL = choice.url + state.Step = "await_ai_key" + a.saveSetupState(userID, state) + + if L == "zh" { + return fmt.Sprintf("✅ AI 模型: *%s*\n\n请发送你的 API Key：", choice.model), true + } + return fmt.Sprintf("✅ AI Model: *%s*\n\nPlease send your API Key:", choice.model), true +} + +func (a *Agent) finishSetup(storeUserID string, userID int64, state *SetupState, L string) (string, bool) { + // Create exchange in store + a.logger.Info("creating trader from setup", + "exchange", state.Exchange, + "ai_model", state.AIModel, + "store_user_id", storeUserID, + ) + + // TODO: Use store to create exchange + trader config + // For now, log the config and tell user + a.clearSetupState(userID) + + result := "" + maskedKey := maskKey(state.APIKey) + if L == "zh" { + result = fmt.Sprintf("🎉 *配置完成！*\n\n"+ + "• 交易所: %s\n"+ + "• API Key: %s\n", + titleCaser.String(state.Exchange), maskedKey) + if state.AIModel != "" { + result += fmt.Sprintf("• AI 模型: %s\n", state.AIModel) + } + result += "\n正在创建 Trader..." + } else { + result = fmt.Sprintf("🎉 *Setup Complete!*\n\n"+ + "• Exchange: %s\n"+ + "• API Key: %s\n", + titleCaser.String(state.Exchange), maskedKey) + if state.AIModel != "" { + result += fmt.Sprintf("• AI Model: %s\n", state.AIModel) + } + result += "\nCreating Trader..." + } + + // Actually create the trader via store + err := a.createTraderFromSetupForStoreUser(storeUserID, state) + if err != nil { + a.logger.Error("create trader failed", "error", err) + if L == "zh" { + result += fmt.Sprintf("\n\n⚠️ 创建失败: %v\n交易所配置已保存，下次配置时可直接复用。\n也可以在 Web UI 中继续完成。", err) + } else { + result += fmt.Sprintf("\n\n⚠️ Failed: %v\nYour exchange config was saved, so you can reuse it next time.\nYou can also finish setup in the Web UI.", err) + } + } else { + if L == "zh" { + result += "\n\n✅ Trader 已创建！现在你可以:\n• `/analyze BTC` — 分析市场\n• `/positions` — 查看持仓\n• 或者直接跟我聊天" + } else { + result += "\n\n✅ Trader created! Now you can:\n• `/analyze BTC` — analyze market\n• `/positions` — view positions\n• Or just chat with me" + } + } + + return result, true +} + +func (a *Agent) createTraderFromSetup(state *SetupState) error { + return a.createTraderFromSetupForStoreUser("default", state) +} + +func (a *Agent) createTraderFromSetupForStoreUser(storeUserID string, state *SetupState) error { + if a.store == nil { + return fmt.Errorf("store not available") + } + exchangeID := state.ExchangeID + if exchangeID == "" { + var err error + exchangeID, err = a.saveSetupExchange(storeUserID, state) + if err != nil { + return fmt.Errorf("save exchange: %w", err) + } + } + + aiModelID := state.AIModelID + if state.AIModel != "" && state.AIKey != "" && aiModelID == "" { + var err error + aiModelID, err = a.saveSetupAIModel(storeUserID, state) + if err != nil { + a.logger.Error("save AI model", "error", err) + } + } + + // Reuse an existing trader if the same exchange/model pair already exists. + existingTraders, err := a.store.Trader().List(storeUserID) + if err != nil { + return fmt.Errorf("list traders: %w", err) + } + for _, existing := range existingTraders { + if existing.ExchangeID == exchangeID && existing.AIModelID == aiModelID { + a.logger.Info("reusing existing trader created via chat setup", + "trader", existing.Name, + "exchange_id", exchangeID, + "ai_model_id", aiModelID, + ) + return nil + } + } + + // Create trader config + exchangeIDShort := exchangeID + if len(exchangeIDShort) > 8 { + exchangeIDShort = exchangeIDShort[:8] + } + modelPart := aiModelID + if modelPart == "" { + modelPart = "manual" + } + trader := &store.Trader{ + ID: fmt.Sprintf("%s_%s_%d", exchangeIDShort, modelPart, time.Now().UnixNano()), + Name: fmt.Sprintf("NOFXi-%s", titleCaser.String(state.Exchange)), + UserID: storeUserID, + ExchangeID: exchangeID, + AIModelID: aiModelID, + IsRunning: false, + } + if err := a.store.Trader().Create(trader); err != nil { + return fmt.Errorf("save trader: %w", err) + } + + a.logger.Info("trader created via chat", + "trader", trader.Name, + "exchange", state.Exchange, + "ai", aiModelID, + ) + + return nil +} + +func (a *Agent) saveSetupExchange(storeUserID string, state *SetupState) (string, error) { + if a.store == nil { + return "", fmt.Errorf("store not available") + } + + hlWallet := "" + hlUnified := false + passphrase := state.Passphrase + apiKey := state.APIKey + apiSecret := state.APISecret + + if state.Exchange == "hyperliquid" { + hlWallet = state.APISecret + apiKey = "" + apiSecret = state.APIKey + } + + exchanges, err := a.store.Exchange().List(storeUserID) + if err != nil { + return "", err + } + for _, ex := range exchanges { + if ex.ExchangeType == state.Exchange && ex.AccountName == setupExchangeAccountName { + if err := a.store.Exchange().Update( + storeUserID, ex.ID, true, + apiKey, apiSecret, passphrase, + false, + hlWallet, hlUnified, + "", "", "", + "", "", "", 0, + ); err != nil { + return "", err + } + return ex.ID, nil + } + } + + return a.store.Exchange().Create( + storeUserID, + state.Exchange, + setupExchangeAccountName, + true, + apiKey, apiSecret, passphrase, + false, + hlWallet, hlUnified, + "", "", "", + "", "", "", 0, + ) +} + +func (a *Agent) saveSetupAIModel(storeUserID string, state *SetupState) (string, error) { + if a.store == nil { + return "", fmt.Errorf("store not available") + } + if state.AIProvider == "" { + return "", nil + } + + modelID := state.AIProvider + if err := a.store.AIModel().Update( + storeUserID, + modelID, + true, + state.AIKey, + state.AIBaseURL, + state.AIModel, + ); err != nil { + return "", err + } + + if modelID == state.AIProvider { + modelID = fmt.Sprintf("%s_%s", storeUserID, state.AIProvider) + } + return modelID, nil +} + +func maskKey(key string) string { + if len(key) <= 8 { + return "****" + } + return key[:4] + "****" + key[len(key)-4:] +} + +func needsPassphrase(exchange string) bool { + return exchange == "okx" || exchange == "bitget" || exchange == "kucoin" +} + +func containsAny(s string, words []string) bool { + for _, w := range words { + if strings.Contains(s, w) { + return true + } + } + return false +} + +var setupMessages = map[string]map[string]string{ + "welcome": { + "zh": "👋 你好！我是 *NOFXi*，你的 AI 交易 Agent。\n\n" + + "我发现你还没有配置交易所，让我帮你搞定吧！\n\n" + + "发送 *开始配置* 或 *setup* 开始\n" + + "发送 *取消* 随时退出", + "en": "👋 Hi! I'm *NOFXi*, your AI trading agent.\n\n" + + "I see you haven't configured an exchange yet. Let me help!\n\n" + + "Send *setup* to begin\n" + + "Send *cancel* to exit anytime", + }, + "ask_exchange": { + "zh": "🏦 *选择你的交易所*\n\n" + + "1️⃣ Binance（币安）\n" + + "2️⃣ OKX（欧易）\n" + + "3️⃣ Bybit\n" + + "4️⃣ Bitget\n" + + "5️⃣ Gate\n" + + "6️⃣ KuCoin（库币）\n" + + "7️⃣ Hyperliquid\n\n" + + "发送数字或名称选择：", + "en": "🏦 *Choose your exchange*\n\n" + + "1️⃣ Binance\n" + + "2️⃣ OKX\n" + + "3️⃣ Bybit\n" + + "4️⃣ Bitget\n" + + "5️⃣ Gate\n" + + "6️⃣ KuCoin\n" + + "7️⃣ Hyperliquid\n\n" + + "Send number or name:", + }, + "invalid_exchange": { + "zh": "❓ 没有识别到交易所。请发送数字 1-7 或交易所名称。", + "en": "❓ Exchange not recognized. Send a number 1-7 or exchange name.", + }, + "ask_secret": { + "zh": "🔑 收到 API Key。\n\n现在请发送你的 *API Secret*：", + "en": "🔑 Got API Key.\n\nNow send your *API Secret*:", + }, + "ask_passphrase": { + "zh": "🔐 收到 API Secret。\n\n这个交易所还需要 *Passphrase*，请发送：", + "en": "🔐 Got API Secret.\n\nThis exchange also needs a *Passphrase*. Please send it:", + }, + "ask_ai": { + "zh": "🤖 *选择 AI 模型*\n\n" + + "1️⃣ DeepSeek（推荐，便宜好用）\n" + + "2️⃣ 通义千问 (Qwen)\n" + + "3️⃣ OpenAI (GPT-4o)\n" + + "4️⃣ Claude\n" + + "5️⃣ 跳过（不配置 AI）\n\n" + + "发送数字或名称选择：", + "en": "🤖 *Choose AI model*\n\n" + + "1️⃣ DeepSeek (recommended, affordable)\n" + + "2️⃣ Qwen\n" + + "3️⃣ OpenAI (GPT-4o)\n" + + "4️⃣ Claude\n" + + "5️⃣ Skip (no AI)\n\n" + + "Send number or name:", + }, + "invalid_ai": { + "zh": "❓ 没有识别到 AI 模型。请发送数字 1-5 或模型名称。", + "en": "❓ AI model not recognized. Send a number 1-5 or model name.", + }, + "cancelled": { + "zh": "👌 配置已取消。随时发送 *开始配置* 重新开始。", + "en": "👌 Setup cancelled. Send *setup* anytime to restart.", + }, +} + +func (a *Agent) setupMsg(L, key string) string { + if m, ok := setupMessages[key]; ok { + if s, ok := m[L]; ok { + return s + } + return m["en"] + } + return key +} diff --git a/agent/onboard_test.go b/agent/onboard_test.go new file mode 100644 index 00000000..0529650c --- /dev/null +++ b/agent/onboard_test.go @@ -0,0 +1,25 @@ +package agent + +import "testing" + +func TestIsDirectSetupCommand(t *testing.T) { + cases := []struct { + text string + want bool + }{ + {text: "setup", want: true}, + {text: "/setup", want: true}, + {text: "开始配置", want: false}, + {text: "/开始配置", want: false}, + {text: "创建全新的配置，杠杆你定", want: false}, + {text: "帮我配置一个 deepseek 模型", want: false}, + {text: "绑定交易所 okx", want: false}, + {text: "配置", want: false}, + } + + for _, tc := range cases { + if got := isDirectSetupCommand(tc.text); got != tc.want { + t.Fatalf("isDirectSetupCommand(%q) = %v, want %v", tc.text, got, tc.want) + } + } +} diff --git a/agent/planner_runtime.go b/agent/planner_runtime.go new file mode 100644 index 00000000..5db56a64 --- /dev/null +++ b/agent/planner_runtime.go @@ -0,0 +1,2466 @@ +package agent + +import ( + "context" + "encoding/json" + "errors" + "fmt" + "strings" + "time" + + "nofx/mcp" +) + +const ( + plannerMaxSteps = 8 + plannerMaxIterations = 12 + observationMaxLength = 400 +) + +var ( + plannerCreateTimeout = 36 * time.Second + plannerReplanTimeout = 24 * time.Second + plannerReasonTimeout = 30 * time.Second + plannerFinalTimeout = 36 * time.Second + directReplyTimeout = 8 * time.Second +) + +type replannerDecision struct { + Action string `json:"action"` + Goal string `json:"goal,omitempty"` + Steps []PlanStep `json:"steps,omitempty"` + Instruction string `json:"instruction,omitempty"` + Question string `json:"question,omitempty"` +} + +type readFastPathRequest struct { + Kind string + ArgsJSON string +} + +type directReplyDecision struct { + Action string `json:"action"` + Answer string `json:"answer,omitempty"` +} + +func latestAskedQuestion(state ExecutionState) string { + if state.Waiting != nil && strings.TrimSpace(state.Waiting.Question) != "" { + return strings.TrimSpace(state.Waiting.Question) + } + for i := len(state.Steps) - 1; i >= 0; i-- { + step := state.Steps[i] + if step.Type == planStepTypeAskUser { + if q := strings.TrimSpace(step.Instruction); q != "" { + return q + } + if q := strings.TrimSpace(step.OutputSummary); q != "" { + return q + } + } + } + if state.Status == executionStatusWaitingUser { + return strings.TrimSpace(state.FinalAnswer) + } + return "" +} + +func buildWaitingState(state ExecutionState, step PlanStep, question string) *WaitingState { + waiting := &WaitingState{ + Question: strings.TrimSpace(question), + Intent: inferWaitingIntent(state.Goal, step, question), + PendingFields: inferPendingFields(step, question), + ConfirmationTarget: inferConfirmationTarget(state.Goal, step, question), + CreatedAt: time.Now().UTC().Format(time.RFC3339), + } + return normalizeWaitingState(waiting) +} + +func inferWaitingIntent(goal string, step PlanStep, question string) string { + lowerGoal := strings.ToLower(strings.TrimSpace(goal)) + lowerQuestion := strings.ToLower(strings.TrimSpace(question)) + switch { + case step.RequiresConfirmation || strings.Contains(lowerQuestion, "需要我") || strings.Contains(lowerQuestion, "confirm") || strings.Contains(lowerQuestion, "确认"): + return "confirm_action" + case strings.Contains(lowerGoal, "交易员") || strings.Contains(lowerGoal, "trader"): + return "complete_trader_setup" + case strings.Contains(lowerGoal, "交易所") || strings.Contains(lowerGoal, "exchange"): + return "complete_exchange_config" + case strings.Contains(lowerGoal, "模型") || strings.Contains(lowerGoal, "model"): + return "complete_model_config" + default: + return "provide_missing_information" + } +} + +func inferPendingFields(step PlanStep, question string) []string { + source := strings.ToLower(strings.TrimSpace(question)) + if source == "" { + sourceBytes, _ := json.Marshal(step.ToolArgs) + source = strings.ToLower(string(sourceBytes)) + } + candidates := []struct { + key string + patterns []string + }{ + {key: "ai_model_id", patterns: []string{"ai_model_id", "model id", "模型id", "模型 id"}}, + {key: "exchange_id", patterns: []string{"exchange_id", "exchange id", "交易所id", "交易所 id"}}, + {key: "strategy_id", patterns: []string{"strategy_id", "strategy id", "策略id", "策略 id"}}, + {key: "name", patterns: []string{"trader name", "name", "名字", "名称"}}, + {key: "api_key", patterns: []string{"api key", "apikey", "api_key"}}, + {key: "secret_key", patterns: []string{"secret key", "secret_key", "密钥"}}, + {key: "passphrase", patterns: []string{"passphrase", "密码短语"}}, + } + fields := make([]string, 0, len(candidates)) + for _, candidate := range candidates { + for _, pattern := range candidate.patterns { + if strings.Contains(source, pattern) { + fields = append(fields, candidate.key) + break + } + } + } + return cleanStringList(fields) +} + +func inferConfirmationTarget(goal string, step PlanStep, question string) string { + if step.RequiresConfirmation { + if step.ToolName != "" { + return step.ToolName + } + } + lowerGoal := strings.ToLower(strings.TrimSpace(goal)) + lowerQuestion := strings.ToLower(strings.TrimSpace(question)) + switch { + case strings.Contains(lowerGoal, "交易员") || strings.Contains(lowerQuestion, "交易员") || strings.Contains(lowerGoal, "trader"): + return "trader" + case strings.Contains(lowerGoal, "交易所") || strings.Contains(lowerQuestion, "交易所") || strings.Contains(lowerGoal, "exchange"): + return "exchange_config" + case strings.Contains(lowerGoal, "模型") || strings.Contains(lowerQuestion, "模型") || strings.Contains(lowerGoal, "model"): + return "model_config" + default: + return "" + } +} + +func isConfigOrTraderIntent(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + keywords := []string{ + "交易员", "trader", "exchange", "交易所", "模型", "model", "api key", "apikey", + "绑定", "配置", "setup", "configure", "deepseek", "openai", "claude", "gemini", + "okx", "binance", "bybit", "gate", "kucoin", "hyperliquid", "aster", "lighter", + } + for _, kw := range keywords { + if strings.Contains(lower, kw) { + return true + } + } + return false +} + +func isStrategyIntent(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + keywords := []string{ + "策略", "strategy", "template", "模板", "激进", "趋势跟踪", "网格策略", + "量化策略", "策略模板", "strategy studio", + } + for _, kw := range keywords { + if strings.Contains(lower, kw) { + return true + } + } + return false +} + +func isRealtimeAccountIntent(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + keywords := []string{ + "余额", "balance", "equity", "净值", "available", "available balance", + "持仓", "position", "positions", "仓位", "unrealized pnl", "浮盈", "浮亏", + "交易历史", "trade history", "history", "closed trades", "recent trades", + "订单", "order", "orders", "成交", "pnl", "profit", "loss", + } + for _, kw := range keywords { + if strings.Contains(lower, kw) { + return true + } + } + return false +} + +func snapshotKindsForIntent(userText string) []string { + kinds := make([]string, 0, 6) + return uniqueStrings(kinds) +} + +func uniqueStrings(values []string) []string { + if len(values) == 0 { + return nil + } + out := make([]string, 0, len(values)) + seen := make(map[string]struct{}, len(values)) + for _, value := range values { + if _, ok := seen[value]; ok { + continue + } + seen[value] = struct{}{} + out = append(out, value) + } + return out +} + +func withPlannerStageTimeout(ctx context.Context, timeout time.Duration) (context.Context, context.CancelFunc) { + if timeout <= 0 { + return context.WithCancel(ctx) + } + if deadline, ok := ctx.Deadline(); ok { + remaining := time.Until(deadline) + if remaining <= timeout { + return context.WithCancel(ctx) + } + } + return context.WithTimeout(ctx, timeout) +} + +func isPlannerTimeoutError(err error) bool { + if err == nil { + return false + } + return errors.Is(err, context.DeadlineExceeded) +} + +func plannerTimeoutMessage(lang string) string { + if lang == "zh" { + return "⏱️ 当前请求处理超时，请重试一次。若持续出现，请把问题拆小一点。" + } + return "⏱️ This request timed out. Please try again, or break it into a smaller request." +} + +func shouldResetExecutionStateForNewAttempt(text string, state ExecutionState) bool { + if state.SessionID == "" { + return false + } + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + retrySignals := []string{ + "再试", "重试", "重新", "继续", "继续创建", "我已经配置好了", "已经配置好了", "我配好了", + "我已经弄好了", "已经弄好了", "好了", "retry", "try again", "continue", "resume", + "i configured it", "i've configured it", "i already configured", "configured already", + } + for _, signal := range retrySignals { + if strings.Contains(lower, signal) { + return true + } + } + if isConfigOrTraderIntent(lower) && (state.Status == executionStatusFailed || state.Status == executionStatusCompleted) { + return true + } + if isConfigOrTraderIntent(lower) && state.Status == executionStatusWaitingUser { + return true + } + return false +} + +func ensureCurrentReferences(state *ExecutionState) { + if state.CurrentReferences == nil { + state.CurrentReferences = &CurrentReferences{} + } +} + +func preferReference(current **EntityReference, id, name string) { + id = strings.TrimSpace(id) + name = strings.TrimSpace(name) + if id == "" && name == "" { + return + } + if *current == nil { + *current = &EntityReference{} + } + if id != "" { + (*current).ID = id + } + if name != "" { + (*current).Name = name + } +} + +func matchEntityReference(text string, candidates []EntityReference) *EntityReference { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return nil + } + var matched *EntityReference + for _, candidate := range candidates { + id := strings.ToLower(strings.TrimSpace(candidate.ID)) + name := strings.ToLower(strings.TrimSpace(candidate.Name)) + if id == "" && name == "" { + continue + } + if (id != "" && strings.Contains(lower, id)) || (name != "" && strings.Contains(lower, name)) { + if matched != nil { + return nil + } + copy := candidate + matched = © + } + } + return matched +} + +func (a *Agent) refreshCurrentReferencesForUserText(storeUserID, text string, state *ExecutionState) { + if a.store == nil || strings.TrimSpace(text) == "" { + return + } + ensureCurrentReferences(state) + + if strategies, err := a.store.Strategy().List(storeUserID); err == nil { + candidates := make([]EntityReference, 0, len(strategies)) + for _, strategy := range strategies { + candidates = append(candidates, EntityReference{ID: strategy.ID, Name: strategy.Name}) + } + if ref := matchEntityReference(text, candidates); ref != nil { + preferReference(&state.CurrentReferences.Strategy, ref.ID, ref.Name) + } + } + if traders, err := a.store.Trader().List(storeUserID); err == nil { + candidates := make([]EntityReference, 0, len(traders)) + for _, trader := range traders { + candidates = append(candidates, EntityReference{ID: trader.ID, Name: trader.Name}) + } + if ref := matchEntityReference(text, candidates); ref != nil { + preferReference(&state.CurrentReferences.Trader, ref.ID, ref.Name) + } + } + if models, err := a.store.AIModel().List(storeUserID); err == nil { + candidates := make([]EntityReference, 0, len(models)) + for _, model := range models { + name := model.Name + if name == "" { + name = model.CustomModelName + } + if name == "" { + name = model.Provider + } + candidates = append(candidates, EntityReference{ID: model.ID, Name: name}) + } + if ref := matchEntityReference(text, candidates); ref != nil { + preferReference(&state.CurrentReferences.Model, ref.ID, ref.Name) + } + } + if exchanges, err := a.store.Exchange().List(storeUserID); err == nil { + candidates := make([]EntityReference, 0, len(exchanges)) + for _, exchange := range exchanges { + name := exchange.AccountName + if name == "" { + name = exchange.ExchangeType + } + candidates = append(candidates, EntityReference{ID: exchange.ID, Name: name}) + } + if ref := matchEntityReference(text, candidates); ref != nil { + preferReference(&state.CurrentReferences.Exchange, ref.ID, ref.Name) + } + } +} + +func updateCurrentReferencesFromToolResult(state *ExecutionState, toolName, raw string) bool { + if strings.TrimSpace(raw) == "" { + return false + } + var payload map[string]any + if err := json.Unmarshal([]byte(raw), &payload); err != nil { + return false + } + ensureCurrentReferences(state) + before, _ := json.Marshal(state.CurrentReferences) + + switch toolName { + case "manage_strategy": + if item, ok := payload["strategy"].(map[string]any); ok { + preferReference(&state.CurrentReferences.Strategy, asString(item["id"]), asString(item["name"])) + } + case "manage_trader": + if item, ok := payload["trader"].(map[string]any); ok { + preferReference(&state.CurrentReferences.Trader, asString(item["id"]), asString(item["name"])) + preferReference(&state.CurrentReferences.Model, asString(item["ai_model_id"]), "") + preferReference(&state.CurrentReferences.Exchange, asString(item["exchange_id"]), "") + preferReference(&state.CurrentReferences.Strategy, asString(item["strategy_id"]), "") + } + case "manage_model_config": + if item, ok := payload["model"].(map[string]any); ok { + name := asString(item["name"]) + if name == "" { + name = asString(item["provider"]) + } + preferReference(&state.CurrentReferences.Model, asString(item["id"]), name) + } + case "manage_exchange_config": + if item, ok := payload["exchange"].(map[string]any); ok { + name := asString(item["account_name"]) + if name == "" { + name = asString(item["exchange_type"]) + } + preferReference(&state.CurrentReferences.Exchange, asString(item["id"]), name) + } + case "get_strategies": + if items, ok := payload["strategies"].([]any); ok && len(items) == 1 { + if item, ok := items[0].(map[string]any); ok { + preferReference(&state.CurrentReferences.Strategy, asString(item["id"]), asString(item["name"])) + } + } + } + state.CurrentReferences = normalizeCurrentReferences(state.CurrentReferences) + after, _ := json.Marshal(state.CurrentReferences) + return string(before) != string(after) +} + +func asString(v any) string { + s, _ := v.(string) + return strings.TrimSpace(s) +} + +func containsAnyKeyword(text string, keywords []string) bool { + for _, keyword := range keywords { + if strings.Contains(text, keyword) { + return true + } + } + return false +} + +func detectReadFastPath(text string) *readFastPathRequest { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return nil + } + + switch lower { + case "/traders": + return &readFastPathRequest{Kind: "list_traders"} + case "/strategies": + return &readFastPathRequest{Kind: "get_strategies"} + case "/models": + return &readFastPathRequest{Kind: "get_model_configs"} + case "/exchanges": + return &readFastPathRequest{Kind: "get_exchange_configs"} + case "/balance": + return &readFastPathRequest{Kind: "get_balance"} + case "/positions": + return &readFastPathRequest{Kind: "get_positions"} + case "/history", "/trades": + return &readFastPathRequest{Kind: "get_trade_history", ArgsJSON: `{"limit":10}`} + default: + return nil + } +} + +func (a *Agent) tryReadFastPath(storeUserID string, userID int64, lang, text string) (string, bool) { + req := detectReadFastPath(text) + if req == nil { + return "", false + } + if a.history == nil { + a.history = newChatHistory(100) + } + + a.history.Add(userID, "user", text) + raw := a.executeReadFastPath(storeUserID, userID, req) + answer := formatReadFastPathResponse(lang, req.Kind, raw) + a.history.Add(userID, "assistant", answer) + if !isEphemeralReadFastPathKind(req.Kind) { + a.maybeUpdateTaskStateIncrementally(context.Background(), userID) + a.maybeCompressHistory(context.Background(), userID) + } + return answer, true +} + +func isEphemeralReadFastPathKind(kind string) bool { + switch kind { + case "get_balance", "get_positions", "get_trade_history": + return true + default: + return false + } +} + +func (a *Agent) executeReadFastPath(storeUserID string, _ int64, req *readFastPathRequest) string { + switch req.Kind { + case "get_balance": + return a.toolGetBalance() + case "get_positions": + return a.toolGetPositions() + case "get_trade_history": + return a.toolGetTradeHistory(req.ArgsJSON) + case "get_strategies": + return a.toolGetStrategies(storeUserID) + case "list_traders": + return a.toolListTraders(storeUserID) + case "get_model_configs": + return a.toolGetModelConfigs(storeUserID) + case "get_exchange_configs": + return a.toolGetExchangeConfigs(storeUserID) + default: + return `{"error":"unsupported fast path"}` + } +} + +func formatReadFastPathResponse(lang, kind, raw string) string { + var payload map[string]any + if err := json.Unmarshal([]byte(raw), &payload); err != nil { + return summarizeObservation(raw) + } + if errMsg, _ := payload["error"].(string); strings.TrimSpace(errMsg) != "" { + return summarizeObservation(raw) + } + + switch kind { + case "get_strategies": + items, _ := payload["strategies"].([]any) + if len(items) == 0 { + if lang == "zh" { + return "当前还没有策略。" + } + return "There are no strategies yet." + } + lines := []string{"Current strategies:"} + if lang == "zh" { + lines[0] = "当前策略：" + } + for _, item := range items { + entry, ok := item.(map[string]any) + if !ok { + continue + } + name := asString(entry["name"]) + if name == "" { + name = asString(entry["id"]) + } + meta := make([]string, 0, 2) + if active, _ := entry["is_active"].(bool); active { + meta = append(meta, "active") + } + if isDefault, _ := entry["is_default"].(bool); isDefault { + meta = append(meta, "default") + } + if len(meta) > 0 { + lines = append(lines, fmt.Sprintf("- %s (%s)", name, strings.Join(meta, ", "))) + } else { + lines = append(lines, fmt.Sprintf("- %s", name)) + } + } + return strings.Join(lines, "\n") + case "list_traders": + items, _ := payload["traders"].([]any) + if len(items) == 0 { + if lang == "zh" { + return "当前还没有交易员。" + } + return "There are no traders yet." + } + lines := []string{"Current traders:"} + if lang == "zh" { + lines[0] = "当前交易员：" + } + for _, item := range items { + entry, ok := item.(map[string]any) + if !ok { + continue + } + name := asString(entry["name"]) + line := fmt.Sprintf("- %s", name) + meta := cleanStringList([]string{asString(entry["exchange_type"]), asString(entry["ai_model_id"])}) + if len(meta) > 0 { + line += fmt.Sprintf(" (%s)", strings.Join(meta, ", ")) + } + lines = append(lines, line) + } + return strings.Join(lines, "\n") + case "get_model_configs": + items, _ := payload["model_configs"].([]any) + if len(items) == 0 { + if lang == "zh" { + return "当前还没有模型配置。" + } + return "There are no model configs yet." + } + lines := []string{"Current model configs:"} + if lang == "zh" { + lines[0] = "当前模型配置：" + } + for _, item := range items { + entry, ok := item.(map[string]any) + if !ok { + continue + } + name := asString(entry["name"]) + if name == "" { + name = asString(entry["provider"]) + } + meta := make([]string, 0, 2) + if enabled, _ := entry["enabled"].(bool); enabled { + meta = append(meta, "enabled") + } + if model := asString(entry["custom_model_name"]); model != "" { + meta = append(meta, model) + } + if len(meta) > 0 { + lines = append(lines, fmt.Sprintf("- %s (%s)", name, strings.Join(meta, ", "))) + } else { + lines = append(lines, fmt.Sprintf("- %s", name)) + } + } + return strings.Join(lines, "\n") + case "get_exchange_configs": + items, _ := payload["exchange_configs"].([]any) + if len(items) == 0 { + if lang == "zh" { + return "当前还没有交易所配置。" + } + return "There are no exchange configs yet." + } + lines := []string{"Current exchange configs:"} + if lang == "zh" { + lines[0] = "当前交易所配置：" + } + for _, item := range items { + entry, ok := item.(map[string]any) + if !ok { + continue + } + name := asString(entry["account_name"]) + if name == "" { + name = asString(entry["exchange_type"]) + } + meta := cleanStringList([]string{asString(entry["exchange_type"])}) + if enabled, _ := entry["enabled"].(bool); enabled { + meta = append(meta, "enabled") + } + if len(meta) > 0 { + lines = append(lines, fmt.Sprintf("- %s (%s)", name, strings.Join(meta, ", "))) + } else { + lines = append(lines, fmt.Sprintf("- %s", name)) + } + } + return strings.Join(lines, "\n") + case "get_balance": + items, _ := payload["balances"].([]any) + if len(items) == 0 { + if lang == "zh" { + return "当前没有可用的余额数据。" + } + return "No balance data is available right now." + } + lines := []string{"Current balance overview:"} + if lang == "zh" { + lines[0] = "当前余额概览：" + } + var totalEquity float64 + var totalAvailable float64 + for _, item := range items { + entry, ok := item.(map[string]any) + if !ok { + continue + } + equity := toFloat(entry["total_equity"]) + available := toFloat(entry["available"]) + totalEquity += equity + totalAvailable += available + lines = append(lines, fmt.Sprintf("- %s (%s): equity %.4f, available %.4f", + asString(entry["name"]), asString(entry["exchange"]), + equity, available)) + } + if len(items) > 1 { + if lang == "zh" { + lines = append(lines, fmt.Sprintf("汇总：equity %.4f, available %.4f", totalEquity, totalAvailable)) + } else { + lines = append(lines, fmt.Sprintf("Total: equity %.4f, available %.4f", totalEquity, totalAvailable)) + } + } + return strings.Join(lines, "\n") + case "get_positions": + items, _ := payload["positions"].([]any) + if len(items) == 0 { + if lang == "zh" { + return "当前没有持仓。" + } + return "There are no open positions right now." + } + lines := []string{"Current positions:"} + if lang == "zh" { + lines[0] = "当前持仓：" + } + for _, item := range items { + entry, ok := item.(map[string]any) + if !ok { + continue + } + lines = append(lines, fmt.Sprintf("- %s %s size %.4f, entry %.4f, pnl %.4f", + asString(entry["symbol"]), asString(entry["side"]), + toFloat(entry["size"]), toFloat(entry["entry_price"]), toFloat(entry["unrealized_pnl"]))) + } + return strings.Join(lines, "\n") + case "get_trade_history": + items, _ := payload["trades"].([]any) + if len(items) == 0 { + if lang == "zh" { + return "当前没有已平仓交易历史。" + } + return "There is no closed trade history yet." + } + summary, _ := payload["summary"].(map[string]any) + head := fmt.Sprintf("Recent trades: %.0f total, win rate %s, total PnL %.4f", + toFloat(summary["total_trades"]), asString(summary["win_rate"]), toFloat(summary["total_pnl"])) + if lang == "zh" { + head = fmt.Sprintf("最近交易：共 %.0f 笔，胜率 %s，总 PnL %.4f", + toFloat(summary["total_trades"]), asString(summary["win_rate"]), toFloat(summary["total_pnl"])) + } + lines := []string{head} + for idx, item := range items { + if idx >= 5 { + break + } + entry, ok := item.(map[string]any) + if !ok { + continue + } + lines = append(lines, fmt.Sprintf("- %s %s pnl %.4f (%s -> %s)", + asString(entry["symbol"]), asString(entry["side"]), toFloat(entry["pnl"]), + asString(entry["entry_time"]), asString(entry["exit_time"]))) + } + return strings.Join(lines, "\n") + default: + return summarizeObservation(raw) + } +} + +func (a *Agent) thinkAndAct(ctx context.Context, storeUserID string, userID int64, lang, text string) (string, error) { + if answer, ok, err := a.tryStatePriorityPath(ctx, storeUserID, userID, lang, text, nil); ok || err != nil { + return answer, err + } + if answer, ok := tryInstantDirectReply(lang, text); ok { + return answer, nil + } + if answer, ok := a.tryReadFastPath(storeUserID, userID, lang, text); ok { + return answer, nil + } + if answer, ok, err := a.tryWorkflowIntent(ctx, storeUserID, userID, lang, text, nil); ok || err != nil { + return answer, err + } + if answer, ok := a.tryHardSkill(ctx, storeUserID, userID, lang, text, nil); ok { + return answer, nil + } + if a.aiClient == nil { + return a.noAIFallback(lang, text) + } + return a.runPlannedAgent(ctx, storeUserID, userID, lang, text, nil) +} + +func (a *Agent) thinkAndActStream(ctx context.Context, storeUserID string, userID int64, lang, text string, onEvent func(event, data string)) (string, error) { + if answer, ok, err := a.tryStatePriorityPath(ctx, storeUserID, userID, lang, text, onEvent); ok || err != nil { + return answer, err + } + if answer, ok := tryInstantDirectReply(lang, text); ok { + if onEvent != nil { + onEvent(StreamEventDelta, answer) + } + return answer, nil + } + if answer, ok := a.tryReadFastPath(storeUserID, userID, lang, text); ok { + if onEvent != nil { + onEvent(StreamEventTool, "read_fast_path") + onEvent(StreamEventDelta, answer) + } + return answer, nil + } + if answer, ok, err := a.tryWorkflowIntent(ctx, storeUserID, userID, lang, text, onEvent); ok || err != nil { + return answer, err + } + if answer, ok := a.tryHardSkill(ctx, storeUserID, userID, lang, text, onEvent); ok { + return answer, nil + } + if a.aiClient == nil { + return a.noAIFallback(lang, text) + } + return a.runPlannedAgent(ctx, storeUserID, userID, lang, text, onEvent) +} + +func tryInstantDirectReply(lang, text string) (string, bool) { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return "", false + } + + zhReplies := map[string]string{ + "hi": "在，有什么我帮你看的？", + "hello": "在，有什么我帮你看的？", + "hey": "在，有什么我帮你看的？", + "你好": "在，有什么我帮你看的？", + "嗨": "在，有什么我帮你看的？", + "在吗": "在，有什么我帮你看的？", + "谢谢": "不客气。", + "多谢": "不客气。", + "谢了": "不客气。", + "ok": "好。", + "好的": "好。", + "收到": "好。", + } + enReplies := map[string]string{ + "hi": "I'm here. What should we look at?", + "hello": "I'm here. What should we look at?", + "hey": "I'm here. What should we look at?", + "thanks": "You're welcome.", + "thank you": "You're welcome.", + "ok": "Okay.", + "okay": "Okay.", + "got it": "Got it.", + } + + if lang == "zh" { + if reply, ok := zhReplies[lower]; ok { + return reply, true + } + if reply, ok := enReplies[lower]; ok { + return reply, true + } + return "", false + } + + if reply, ok := enReplies[lower]; ok { + return reply, true + } + return "", false +} + +func (a *Agent) hasActiveSkillSession(userID int64) bool { + session := a.getSkillSession(userID) + return strings.TrimSpace(session.Name) != "" +} + +func hasActiveExecutionState(state ExecutionState) bool { + if strings.TrimSpace(state.SessionID) == "" { + return false + } + switch strings.TrimSpace(state.Status) { + case executionStatusPlanning, executionStatusRunning, executionStatusWaitingUser: + return true + default: + return false + } +} + +func (a *Agent) tryStatePriorityPath(ctx context.Context, storeUserID string, userID int64, lang, text string, onEvent func(event, data string)) (string, bool, error) { + if workflow := a.getWorkflowSession(userID); hasActiveWorkflowSession(workflow) { + answer, handled, err := a.handleWorkflowSession(ctx, storeUserID, userID, lang, text, workflow, onEvent) + if handled || err != nil { + return answer, true, err + } + } + if session := a.getSkillSession(userID); strings.TrimSpace(session.Name) != "" { + switch a.classifySkillSessionInput(ctx, userID, lang, session, text) { + case "cancel": + a.clearSkillSession(userID) + a.clearWorkflowSession(userID) + if lang == "zh" { + return "已取消当前流程。", true, nil + } + return "Cancelled the current flow.", true, nil + case "interrupt": + a.clearSkillSession(userID) + default: + if answer, ok := a.tryHardSkill(ctx, storeUserID, userID, lang, text, onEvent); ok { + return answer, true, nil + } + } + } + + state := a.getExecutionState(userID) + if hasActiveExecutionState(state) { + switch classifyExecutionStateInput(state, text) { + case "cancel": + a.clearExecutionState(userID) + if lang == "zh" { + return "已取消当前流程。", true, nil + } + return "Cancelled the current flow.", true, nil + case "interrupt": + a.clearExecutionState(userID) + default: + answer, err := a.runPlannedAgent(ctx, storeUserID, userID, lang, text, onEvent) + return answer, true, err + } + } + + return "", false, nil +} + +func (a *Agent) classifySkillSessionInput(ctx context.Context, userID int64, lang string, session skillSession, text string) string { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return "continue" + } + if isYesReply(text) || isNoReply(text) { + return "continue" + } + if isExplicitFlowAbort(text) { + return "cancel" + } + if shouldContinueSkillSessionByExpectedSlot(session, text) { + return "continue" + } + if decision := a.classifySkillSessionIntentWithLLM(ctx, userID, lang, session, text); decision != "" { + return decision + } + if isNewSkillRootIntent(session, text) { + return "interrupt" + } + if isSkillFlowDeflection(session, text) { + return "interrupt" + } + if belongsToSkillDomain(session.Name, text) || !looksLikeNewTopLevelIntent(text) { + return "continue" + } + return "interrupt" +} + +type skillSessionIntentDecision struct { + Decision string `json:"decision"` +} + +func shouldUseLLMSkillSessionClassifier(session skillSession, text string) bool { + if strings.TrimSpace(text) == "" { + return false + } + if isExplicitFlowAbort(text) || isYesReply(text) || isNoReply(text) { + return false + } + if shouldContinueSkillSessionByExpectedSlot(session, text) { + return false + } + return true +} + +func shouldContinueSkillSessionByExpectedSlot(session skillSession, text string) bool { + text = strings.TrimSpace(text) + if text == "" { + return false + } + currentStep, ok := currentSkillDAGStep(session) + if !ok { + return false + } + switch currentStep.ID { + case "await_start_confirmation", "await_confirmation": + return isYesReply(text) || isNoReply(text) + case "resolve_config_value": + if fieldValue(session, "config_field") == "selected_timeframes" { + return timeframeTokenRE.MatchString(strings.ToLower(text)) + } + return firstIntegerPattern.MatchString(text) + case "collect_enabled": + _, ok := parseEnabledValue(text) + return ok + case "collect_custom_api_url": + return extractURL(text) != "" + case "resolve_exchange_type": + return exchangeTypeFromText(text) != "" + case "resolve_provider": + return providerFromText(text) != "" + case "resolve_name", "collect_name", "collect_prompt", "collect_account_name", "collect_custom_model_name": + return !looksLikeNewTopLevelIntent(text) + } + for _, field := range currentStep.RequiredFields { + switch field { + case "config_value": + return firstIntegerPattern.MatchString(text) + case "enabled": + _, ok := parseEnabledValue(text) + return ok + case "custom_api_url": + return extractURL(text) != "" + } + } + return false +} + +func (a *Agent) classifySkillSessionIntentWithLLM(ctx context.Context, userID int64, lang string, session skillSession, text string) string { + if a == nil || a.aiClient == nil { + return "" + } + if !shouldUseLLMSkillSessionClassifier(session, text) { + return "" + } + currentStep, _ := currentSkillDAGStep(session) + recentConversationCtx := a.buildRecentConversationContext(userID, text) + systemPrompt := `You classify one user message while a NOFXi structured management flow is active. +Return JSON only. No markdown. + +Possible decisions: +- "continue": the user is still answering the current flow +- "cancel": the user wants to stop the current flow +- "interrupt": the user changed topic, wants diagnosis/query/new task, or should leave the current flow + +Be conservative: +- Prefer "continue" only when the message clearly answers the current slot/question. +- Use "cancel" for explicit abandonment like "算了", "不改了", "换话题", "别弄了". +- Use "interrupt" for diagnosis, query, new requests, or topic shifts.` + userPrompt := fmt.Sprintf( + "Language: %s\nActive skill: %s\nAction: %s\nCurrent DAG step: %s\nExpected required fields: %s\nUser message: %s\n\nRecent conversation:\n%s", + lang, + session.Name, + session.Action, + currentStep.ID, + strings.Join(currentStep.RequiredFields, ", "), + text, + recentConversationCtx, + ) + stageCtx, cancel := withPlannerStageTimeout(ctx, directReplyTimeout) + defer cancel() + raw, err := a.aiClient.CallWithRequest(&mcp.Request{ + Messages: []mcp.Message{ + mcp.NewSystemMessage(systemPrompt), + mcp.NewUserMessage(userPrompt), + }, + Ctx: stageCtx, + }) + if err != nil { + return "" + } + raw = strings.TrimSpace(raw) + raw = strings.TrimPrefix(raw, "```json") + raw = strings.TrimPrefix(raw, "```") + raw = strings.TrimSuffix(raw, "```") + raw = strings.TrimSpace(raw) + var decision skillSessionIntentDecision + if err := json.Unmarshal([]byte(raw), &decision); err != nil { + start := strings.Index(raw, "{") + end := strings.LastIndex(raw, "}") + if start < 0 || end <= start || json.Unmarshal([]byte(raw[start:end+1]), &decision) != nil { + return "" + } + } + switch strings.TrimSpace(decision.Decision) { + case "continue", "cancel", "interrupt": + return decision.Decision + default: + return "" + } +} + +func isSkillFlowDeflection(session skillSession, text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + if containsAny(lower, []string{ + "看下报错", "看看报错", "帮我看下报错", "帮我看看报错", "报错怎么回事", "错误怎么回事", + "换话题", "聊别的", "不是这个", "先说别的", "不聊这个", + }) { + return true + } + switch strings.TrimSpace(session.Name) { + case "exchange_management": + return detectModelDiagnosisSkill(text) || detectTraderDiagnosisSkill(text) || detectStrategyDiagnosisSkill(text) + case "model_management": + return detectExchangeDiagnosisSkill(text) || detectTraderDiagnosisSkill(text) || detectStrategyDiagnosisSkill(text) + case "strategy_management": + return detectExchangeDiagnosisSkill(text) || detectTraderDiagnosisSkill(text) || detectModelDiagnosisSkill(text) + case "trader_management": + return detectExchangeDiagnosisSkill(text) || detectModelDiagnosisSkill(text) || detectStrategyDiagnosisSkill(text) + default: + return false + } +} + +func isNewSkillRootIntent(session skillSession, text string) bool { + currentSkill := strings.TrimSpace(session.Name) + currentAction := strings.TrimSpace(session.Action) + if currentSkill == "" { + return false + } + switch currentSkill { + case "trader_management": + if detectCreateTraderSkill(text) && currentAction != "create" { + return true + } + if action := normalizeAtomicSkillAction("trader_management", detectManagementAction(text, "trader")); action == "create" && currentAction != "create" { + return true + } + case "strategy_management": + if action := normalizeAtomicSkillAction("strategy_management", detectManagementAction(text, "strategy")); action == "create" && currentAction != "create" { + return true + } + case "model_management": + if action := normalizeAtomicSkillAction("model_management", detectManagementAction(text, "model")); action == "create" && currentAction != "create" { + return true + } + case "exchange_management": + if action := normalizeAtomicSkillAction("exchange_management", detectManagementAction(text, "exchange")); action == "create" && currentAction != "create" { + return true + } + } + return false +} + +func classifyExecutionStateInput(state ExecutionState, text string) string { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return "continue" + } + if isExplicitFlowAbort(text) { + return "cancel" + } + if isYesReply(text) || isNoReply(text) || shouldResetExecutionStateForNewAttempt(text, state) { + return "continue" + } + if state.Waiting != nil && !looksLikeNewTopLevelIntent(text) { + return "continue" + } + if looksLikeNewTopLevelIntent(text) { + return "interrupt" + } + return "continue" +} + +func isExplicitFlowAbort(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + if isCancelSkillReply(text) { + return true + } + return containsAny(lower, []string{ + "算了", "先不", "不配了", "别弄了", "不搞了", "先停", "换个话题", "换话题", "聊点别的", "聊别的", + "stop this", "drop it", "never mind", "forget it", "skip this", + }) +} + +func belongsToSkillDomain(skillName, text string) bool { + switch strings.TrimSpace(skillName) { + case "trader_management": + return detectCreateTraderSkill(text) || detectTraderManagementIntent(text) || detectTraderDiagnosisSkill(text) + case "strategy_management": + return detectStrategyManagementIntent(text) || detectStrategyDiagnosisSkill(text) + case "model_management": + return detectModelManagementIntent(text) || detectModelDiagnosisSkill(text) + case "exchange_management": + return detectExchangeManagementIntent(text) || detectExchangeDiagnosisSkill(text) + default: + return false + } +} + +func looksLikeNewTopLevelIntent(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + if strings.HasPrefix(lower, "/") { + return true + } + if detectCreateTraderSkill(text) || + detectTraderManagementIntent(text) || + detectExchangeManagementIntent(text) || + detectModelManagementIntent(text) || + detectStrategyManagementIntent(text) || + detectTraderDiagnosisSkill(text) || + detectExchangeDiagnosisSkill(text) || + detectModelDiagnosisSkill(text) || + detectStrategyDiagnosisSkill(text) { + return true + } + if detectReadFastPath(text) != nil { + return true + } + return containsAny(lower, []string{ + "btc", "eth", "sol", "市场", "行情", "余额", "仓位", "持仓", "订单", "账户", + "price", "market", "balance", "position", "portfolio", "account", + }) +} + +func (a *Agent) tryDirectAnswer(ctx context.Context, userID int64, lang, text string, onEvent func(event, data string)) (string, bool) { + if a.aiClient == nil { + return "", false + } + + text = strings.TrimSpace(text) + if text == "" { + return "", false + } + + recentConversationCtx := a.buildRecentConversationContext(userID, text) + taskStateCtx := buildTaskStateContext(a.getTaskState(userID)) + executionState := normalizeExecutionState(a.getExecutionState(userID)) + executionJSON, _ := json.Marshal(executionState) + systemPrompt := `You are the first-pass router for NOFXi. +Decide whether the assistant can answer the user's message directly without using skills, tools, or planning. +Return JSON only. Do not return markdown. + +Use "direct_answer" only when a concise, self-contained answer is sufficient. +Examples that often fit direct_answer: +- greetings, thanks, small talk +- concept explanations +- open-ended advice that does not require current system state +- trading education or opinion questions that can be answered from general reasoning + +Use "defer" when the message likely needs: +- a management or diagnosis skill +- tool reads +- multi-step planning +- continuation of an active execution flow that needs stateful follow-up + +Rules: +- Consider Recent conversation, Task state, and Execution state JSON before deciding. +- Default to direct_answer for greetings, thanks, identity questions, and other lightweight conversational turns unless there is a clearly unfinished operational flow that the user is continuing. +- If the user is clearly continuing an unfinished operational flow, choose defer. +- If you choose direct_answer, provide the final user-facing answer in the same language as the user. +- Prefer defer when uncertain. + +Return JSON with this exact shape: +{"action":"direct_answer|defer","answer":""}` + userPrompt := fmt.Sprintf("Language: %s\nUser message: %s\n\nRecent conversation:\n%s\n\nTask state:\n%s\n\nExecution state JSON:\n%s", lang, text, recentConversationCtx, taskStateCtx, string(executionJSON)) + + stageCtx, cancel := withPlannerStageTimeout(ctx, directReplyTimeout) + defer cancel() + + raw, err := a.aiClient.CallWithRequest(&mcp.Request{ + Messages: []mcp.Message{ + mcp.NewSystemMessage(systemPrompt), + mcp.NewUserMessage(userPrompt), + }, + Ctx: stageCtx, + }) + if err != nil { + return "", false + } + + decision, err := parseDirectReplyDecision(raw) + if err != nil { + return "", false + } + if decision.Action != "direct_answer" { + return "", false + } + + answer := strings.TrimSpace(decision.Answer) + if answer == "" { + return "", false + } + + if a.history == nil { + a.history = newChatHistory(100) + } + a.history.Add(userID, "user", text) + a.history.Add(userID, "assistant", answer) + a.maybeUpdateTaskStateIncrementally(ctx, userID) + a.maybeCompressHistory(ctx, userID) + if onEvent != nil { + onEvent(StreamEventDelta, answer) + } + return answer, true +} + +func parseDirectReplyDecision(raw string) (directReplyDecision, error) { + raw = strings.TrimSpace(raw) + raw = strings.TrimPrefix(raw, "```json") + raw = strings.TrimPrefix(raw, "```") + raw = strings.TrimSuffix(raw, "```") + raw = strings.TrimSpace(raw) + + var decision directReplyDecision + if err := json.Unmarshal([]byte(raw), &decision); err == nil { + return normalizeDirectReplyDecision(decision), nil + } + start := strings.Index(raw, "{") + end := strings.LastIndex(raw, "}") + if start >= 0 && end > start { + if err := json.Unmarshal([]byte(raw[start:end+1]), &decision); err == nil { + return normalizeDirectReplyDecision(decision), nil + } + } + return directReplyDecision{}, fmt.Errorf("invalid direct reply decision json") +} + +func normalizeDirectReplyDecision(decision directReplyDecision) directReplyDecision { + decision.Action = strings.TrimSpace(strings.ToLower(decision.Action)) + decision.Answer = strings.TrimSpace(decision.Answer) + return decision +} + +func (a *Agent) runPlannedAgent(ctx context.Context, storeUserID string, userID int64, lang, text string, onEvent func(event, data string)) (string, error) { + a.history.Add(userID, "user", text) + if onEvent != nil { + onEvent(StreamEventPlanning, a.planningStatusText(lang)) + } + + requestStartedAt := time.Now() + state, err := a.prepareExecutionState(ctx, storeUserID, userID, lang, text) + if err != nil { + a.logPlannerTiming("", userID, "prepare_execution_state", requestStartedAt, err) + if isPlannerTimeoutError(err) { + msg := plannerTimeoutMessage(lang) + if onEvent != nil { + onEvent(StreamEventError, msg) + onEvent(StreamEventDelta, msg) + } + return msg, nil + } + a.logger.Warn("planner failed, falling back to legacy loop", "error", err, "user_id", userID) + return a.thinkAndActLegacy(ctx, userID, lang, text, onEvent) + } + a.logPlannerTiming(state.SessionID, userID, "prepare_execution_state", requestStartedAt, nil) + + executionStartedAt := time.Now() + answer, err := a.executePlan(ctx, storeUserID, userID, lang, &state, onEvent) + a.logPlannerTiming(state.SessionID, userID, "execute_plan", executionStartedAt, err) + if err != nil { + if isPlannerTimeoutError(err) { + msg := plannerTimeoutMessage(lang) + if onEvent != nil { + onEvent(StreamEventError, msg) + onEvent(StreamEventDelta, msg) + } + return msg, nil + } + a.logger.Warn("plan execution failed, falling back to legacy loop", "error", err, "user_id", userID) + return a.thinkAndActLegacy(ctx, userID, lang, text, onEvent) + } + + a.history.Add(userID, "assistant", answer) + a.maybeUpdateTaskStateIncrementally(ctx, userID) + a.maybeCompressHistory(ctx, userID) + a.logPlannerTiming(state.SessionID, userID, "run_planned_agent_total", requestStartedAt, nil) + return answer, nil +} + +func (a *Agent) prepareExecutionState(ctx context.Context, storeUserID string, userID int64, lang, text string) (ExecutionState, error) { + existing := a.getExecutionState(userID) + if shouldResetExecutionStateForNewAttempt(text, existing) { + a.clearExecutionState(userID) + existing = ExecutionState{} + } + if existing.Status == executionStatusWaitingUser && existing.SessionID != "" { + a.refreshCurrentReferencesForUserText(storeUserID, text, &existing) + askedQuestion := latestAskedQuestion(existing) + replySummary := strings.TrimSpace(text) + if askedQuestion != "" { + replySummary = fmt.Sprintf("Answer to previous question [%s]: %s", askedQuestion, replySummary) + } + appendExecutionLog(&existing, Observation{ + Kind: "user_reply", + Summary: replySummary, + CreatedAt: time.Now().UTC().Format(time.RFC3339), + }) + existing.Status = executionStatusPlanning + existing.Waiting = nil + existing.FinalAnswer = "" + existing.LastError = "" + existing = a.refreshStateForDynamicRequests(storeUserID, text, existing) + existing.Steps = completedSteps(existing.Steps) + existing.CurrentStepID = "" + existing.Status = executionStatusRunning + existing.UpdatedAt = time.Now().UTC().Format(time.RFC3339) + if err := a.saveExecutionState(existing); err != nil { + return ExecutionState{}, err + } + return existing, nil + } + + state := newExecutionState(userID, text) + a.refreshCurrentReferencesForUserText(storeUserID, text, &state) + state = a.refreshStateForDynamicRequests(storeUserID, text, state) + state.Status = executionStatusRunning + if err := a.saveExecutionState(state); err != nil { + return ExecutionState{}, err + } + return state, nil +} + +type nextStepDecision struct { + Goal string `json:"goal"` + Steps []PlanStep `json:"steps,omitempty"` + Step PlanStep `json:"step"` +} + +func (a *Agent) decideNextStep(ctx context.Context, userID int64, lang string, state ExecutionState) (nextStepDecision, error) { + toolDefs, _ := json.Marshal(agentTools()) + stateJSON, _ := json.Marshal(normalizeExecutionState(state)) + obsJSON, _ := json.Marshal(buildObservationContext(state)) + recentlyFetchedJSON, _ := json.Marshal(buildRecentlyFetchedData(state, time.Now().UTC())) + taskStateCtx := buildTaskStateContext(a.getTaskState(userID)) + recentConversationCtx := a.buildRecentConversationContext(userID, state.Goal) + + systemPrompt := `You are the step selector for NOFXi. +Return JSON only. Do not return markdown. + +You are operating in ReAct mode: Thought -> Action -> Observation. +Choose the immediate next action batch. Do not generate a long multi-step execution plan. + +Allowed step types: +- tool +- reason +- ask_user +- respond + +Rules: +- Use all available memory layers: Execution state JSON, Observations JSON, Recent conversation, and Task state. +- Use Recently fetched data JSON as the deduplication source of truth for fresh tool results. +- Prefer the freshest evidence in this order: execution state, observations, recent conversation, then task state. +- If fresh external or system data is needed, choose a tool step. +- If the user is blocked on a missing parameter, choose ask_user. +- If there is enough information to answer now, choose respond. +- Use reason only when a short intermediate synthesis is necessary before the next action. +- Prefer tool or respond over reason whenever possible. +- Never emit the same reason step twice in a row. +- After a reason step, the next batch should usually be tool, ask_user, or respond. Do not stay in analysis loops. +- Never invent tools. +- If the task needs multiple independent tool reads, emit ALL of them together in one response. +- Parallelism rule: when multiple tool reads are mutually independent, do not split them across turns. Return them together in steps. +- Never mix ask_user/respond with additional steps in the same batch. +- Only emit multiple steps when every emitted step is a tool step. +- Avoid repeated tool calls. If a matching tool call already exists in Recently fetched data and age_seconds <= 60, do not call it again unless the user explicitly asks to refresh. +- For tool steps, set tool_name exactly to one available tool and provide tool_args as a JSON object. +- For ask_user or respond steps, put the user-facing question/response instruction in instruction. +- If the latest observation already answers the goal, prefer respond over another tool call. +- Never place a trade unless the user intent is explicit. + +Return JSON with this exact shape: +{"goal":"","steps":[{"id":"step_1","type":"tool|reason|ask_user|respond","title":"","tool_name":"","tool_args":{},"instruction":"","requires_confirmation":false}]}` + + userPrompt := fmt.Sprintf("Language: %s\nGoal: %s\n\nRecent conversation:\n%s\n\nAvailable tools JSON:\n%s\n\nPersistent preferences:\n%s\n\nTask state:\n%s\n\nExecution state JSON:\n%s\n\nObservations JSON:\n%s\n\nRecently fetched data JSON:\n%s", lang, state.Goal, recentConversationCtx, string(toolDefs), a.buildPersistentPreferencesContext(userID), taskStateCtx, string(stateJSON), string(obsJSON), string(recentlyFetchedJSON)) + + stageCtx, cancel := withPlannerStageTimeout(ctx, plannerCreateTimeout) + defer cancel() + + startedAt := time.Now() + raw, err := a.aiClient.CallWithRequest(&mcp.Request{ + Messages: []mcp.Message{ + mcp.NewSystemMessage(systemPrompt), + mcp.NewUserMessage(userPrompt), + }, + Ctx: stageCtx, + }) + a.logPlannerTiming(state.SessionID, userID, "decide_next_step_llm", startedAt, err) + if err != nil { + return nextStepDecision{}, err + } + return parseNextStepDecisionJSON(raw) +} + +func parseNextStepDecisionJSON(raw string) (nextStepDecision, error) { + raw = strings.TrimSpace(raw) + raw = strings.TrimPrefix(raw, "```json") + raw = strings.TrimPrefix(raw, "```") + raw = strings.TrimSuffix(raw, "```") + raw = strings.TrimSpace(raw) + + var decision nextStepDecision + if err := json.Unmarshal([]byte(raw), &decision); err == nil { + return normalizeNextStepDecision(decision), nil + } + start := strings.Index(raw, "{") + end := strings.LastIndex(raw, "}") + if start >= 0 && end > start { + if err := json.Unmarshal([]byte(raw[start:end+1]), &decision); err == nil { + return normalizeNextStepDecision(decision), nil + } + } + return nextStepDecision{}, fmt.Errorf("invalid next step decision json") +} + +func normalizeNextStepDecision(decision nextStepDecision) nextStepDecision { + decision.Goal = strings.TrimSpace(decision.Goal) + steps := decision.Steps + if len(steps) == 0 && decision.Step.Type != "" { + steps = []PlanStep{decision.Step} + } + if len(steps) > 0 { + steps = normalizeExecutionState(ExecutionState{Steps: steps}).Steps + } + decision.Steps = steps + if len(steps) > 0 { + decision.Step = steps[0] + } + return decision +} + +func (a *Agent) refreshStateForDynamicRequests(storeUserID, userText string, state ExecutionState) ExecutionState { + kinds := snapshotKindsForIntent(userText) + if len(kinds) == 0 { + return state + } + kindsToRefresh := make(map[string]struct{}, len(kinds)) + for _, kind := range kinds { + kindsToRefresh[kind] = struct{}{} + } + + fresh := make([]Observation, 0, len(state.DynamicSnapshots)+3) + for _, obs := range state.DynamicSnapshots { + if _, ok := kindsToRefresh[obs.Kind]; ok { + continue + } + fresh = append(fresh, obs) + } + + appendSnapshot := func(kind, raw string) { + raw = strings.TrimSpace(raw) + if raw == "" { + return + } + fresh = append(fresh, Observation{ + Kind: kind, + Summary: summarizeObservation(raw), + RawJSON: raw, + CreatedAt: time.Now().UTC().Format(time.RFC3339), + }) + } + + for _, kind := range kinds { + switch kind { + case "current_model_configs": + appendSnapshot(kind, a.toolGetModelConfigs(storeUserID)) + case "current_exchange_configs": + appendSnapshot(kind, a.toolGetExchangeConfigs(storeUserID)) + case "current_traders": + appendSnapshot(kind, a.toolListTraders(storeUserID)) + case "current_strategies": + appendSnapshot(kind, a.toolGetStrategies(storeUserID)) + case "current_balances": + appendSnapshot(kind, a.toolGetBalance()) + case "current_positions": + appendSnapshot(kind, a.toolGetPositions()) + case "recent_trade_history": + appendSnapshot(kind, a.toolGetTradeHistory(`{"limit":10}`)) + } + } + state.DynamicSnapshots = fresh + return state +} + +func (a *Agent) buildRecentConversationContext(userID int64, currentUserText string) string { + if a.history == nil { + return "" + } + + msgs := a.history.Get(userID) + if len(msgs) == 0 { + return "" + } + + currentUserText = strings.TrimSpace(currentUserText) + if currentUserText != "" { + last := msgs[len(msgs)-1] + if last.Role == "user" && strings.TrimSpace(last.Content) == currentUserText { + msgs = msgs[:len(msgs)-1] + } + } + + if len(msgs) == 0 { + return "" + } + if len(msgs) > recentConversationMessages { + msgs = msgs[len(msgs)-recentConversationMessages:] + } + + transcript := formatChatMessagesForSummary(msgs) + if transcript == "" { + return "" + } + return transcript +} + +func (a *Agent) createExecutionPlan(ctx context.Context, userID int64, lang, userText string, state ExecutionState) (executionPlan, error) { + toolDefs, _ := json.Marshal(agentTools()) + stateJSON, _ := json.Marshal(normalizeExecutionState(state)) + taskStateCtx := buildTaskStateContext(a.getTaskState(userID)) + recentConversationCtx := a.buildRecentConversationContext(userID, userText) + if isConfigOrTraderIntent(userText) { + // Configuration and trader setup requests are especially sensitive to stale + // summaries like "this capability does not exist". Prefer fresh tool checks. + taskStateCtx = "" + } + + systemPrompt := `You are the planning module for NOFXi. +Return JSON only. Do not return markdown. + +Create a minimal safe execution plan using these step types only: +- tool +- reason +- ask_user +- respond + +Rules: +- Use all available memory layers when planning: Execution state JSON, Recent conversation, and Task state. +- Memory priority order: + 1. Execution state JSON = current operational truth for the active task. + 2. Recent conversation = the best source for what was said in the last few turns. + 3. Task state = compressed durable background only. +- If these memory layers conflict, prefer execution state first, then recent conversation. Do not let task state override fresher evidence. +- Do not ask the user to repeat a fact that is already explicit in execution state or recent conversation unless the inputs are contradictory. +- Use tool steps whenever fresh external data is required. +- Use ask_user if required parameters are missing. +- Never place a trade unless the user intent is explicit. +- For exchange binding or exchange credential requests, prefer get_exchange_configs/manage_exchange_config. +- For AI model binding or model credential requests, prefer get_model_configs/manage_model_config. +- For strategy template creation or editing requests, prefer get_strategies/manage_strategy. +- For trader creation or trader lifecycle requests, prefer manage_trader. +- A strategy template is independent and does not require exchange/model bindings unless the user explicitly asks to run or deploy it through a trader. +- If these tools exist, never answer that the system lacks exchange/model/trader management capability. +- When configuration, strategy, or trader creation is requested, gather missing required fields via ask_user, then call the appropriate tool. +- Before concluding that exchange/model/trader/strategy setup is impossible or missing, first inspect current state with the relevant tools. +- For high-volatility state such as balances, positions, recent trade history, or current config availability, prefer fresh tool reads over old observations. +- Keep the plan short and practical. +- End with either ask_user or respond. +- At most 8 steps. +- For tool steps, set tool_name exactly to one of the available tool names and provide tool_args as JSON object. +- For reason steps, put the reasoning task in instruction. +- For ask_user steps, put the exact follow-up question in instruction. +- For respond steps, put either a short instruction or leave instruction empty. +- If resuming after a waiting_user state, incorporate the new user reply and return a fresh full plan. +- Never invent tools.` + + resumeContext := "" + if state.SessionID != "" { + if askedQuestion := latestAskedQuestion(state); askedQuestion != "" { + resumeContext = fmt.Sprintf("\n\nResume context:\n- The assistant was waiting for the user's answer to this exact question: %s\n- Interpret the new user message as the answer to that question unless the message clearly starts a new topic.", askedQuestion) + if state.Waiting != nil { + waitingJSON, _ := json.Marshal(state.Waiting) + resumeContext += fmt.Sprintf("\n- Structured waiting state JSON: %s", string(waitingJSON)) + } + } + } + + userPrompt := fmt.Sprintf("Language: %s\nUser request: %s%s\n\nRecent conversation:\n%s\n\nAvailable tools JSON:\n%s\n\nPersistent preferences:\n%s\n\nTask state:\n%s\n\nExecution state JSON:\n%s\n\nReturn JSON with this exact shape:\n{\"goal\":\"\",\"steps\":[{\"id\":\"step_1\",\"type\":\"tool|reason|ask_user|respond\",\"title\":\"\",\"tool_name\":\"\",\"tool_args\":{},\"instruction\":\"\",\"requires_confirmation\":false}]}", lang, userText, resumeContext, recentConversationCtx, string(toolDefs), a.buildPersistentPreferencesContext(userID), taskStateCtx, string(stateJSON)) + + stageCtx, cancel := withPlannerStageTimeout(ctx, plannerCreateTimeout) + defer cancel() + + startedAt := time.Now() + resp, err := a.aiClient.CallWithRequest(&mcp.Request{ + Messages: []mcp.Message{ + mcp.NewSystemMessage(systemPrompt), + mcp.NewUserMessage(userPrompt), + }, + Ctx: stageCtx, + }) + a.logPlannerTiming(state.SessionID, userID, "create_execution_plan_llm", startedAt, err) + if err != nil { + return executionPlan{}, err + } + + plan, err := parseExecutionPlanJSON(resp) + if err != nil { + return executionPlan{}, err + } + if len(plan.Steps) == 0 { + return executionPlan{}, fmt.Errorf("empty execution plan") + } + if len(plan.Steps) > plannerMaxSteps { + plan.Steps = plan.Steps[:plannerMaxSteps] + } + for i := range plan.Steps { + if plan.Steps[i].ID == "" { + plan.Steps[i].ID = fmt.Sprintf("step_%d", i+1) + } + if plan.Steps[i].Status == "" { + plan.Steps[i].Status = planStepStatusPending + } + if plan.Steps[i].Title == "" { + plan.Steps[i].Title = strings.ReplaceAll(plan.Steps[i].ID, "_", " ") + } + } + if strings.TrimSpace(plan.Goal) == "" { + plan.Goal = strings.TrimSpace(userText) + } + return plan, nil +} + +func parseExecutionPlanJSON(raw string) (executionPlan, error) { + raw = strings.TrimSpace(raw) + raw = strings.TrimPrefix(raw, "```json") + raw = strings.TrimPrefix(raw, "```") + raw = strings.TrimSuffix(raw, "```") + raw = strings.TrimSpace(raw) + + var plan executionPlan + if err := json.Unmarshal([]byte(raw), &plan); err == nil { + return plan, nil + } + start := strings.Index(raw, "{") + end := strings.LastIndex(raw, "}") + if start >= 0 && end > start { + if err := json.Unmarshal([]byte(raw[start:end+1]), &plan); err == nil { + return plan, nil + } + } + return executionPlan{}, fmt.Errorf("invalid execution plan json") +} + +func (a *Agent) executePlan(ctx context.Context, storeUserID string, userID int64, lang string, state *ExecutionState, onEvent func(event, data string)) (string, error) { + if onEvent != nil && len(state.Steps) > 0 { + onEvent(StreamEventPlan, formatPlanStatus(*state, lang)) + } + + for i := 0; i < plannerMaxIterations; i++ { + stepIndex := nextPendingStepIndex(state.Steps) + if stepIndex < 0 { + decisionStartedAt := time.Now() + decision, err := a.decideNextStep(ctx, userID, lang, *state) + a.logPlannerTiming(state.SessionID, userID, "decide_next_step", decisionStartedAt, err) + if err != nil { + return "", err + } + steps := filterFreshDuplicateToolSteps(decision.Steps, *state, time.Now().UTC()) + if len(steps) == 0 { + appendExecutionLog(state, Observation{ + Kind: "decision_note", + Summary: "Skipped duplicate fresh tool calls from next-step decision", + CreatedAt: time.Now().UTC().Format(time.RFC3339), + }) + state.UpdatedAt = time.Now().UTC().Format(time.RFC3339) + if err := a.saveExecutionState(*state); err != nil { + return "", err + } + continue + } + if hasRepeatedReasonLoop(*state, steps) { + return "", fmt.Errorf("repeated reasoning loop detected") + } + if decision.Goal != "" { + state.Goal = decision.Goal + } + base := len(completedSteps(state.Steps)) + for idx := range steps { + if steps[idx].Type == "" { + return "", fmt.Errorf("next step decision missing step type") + } + if steps[idx].ID == "" { + steps[idx].ID = fmt.Sprintf("step_%d", base+idx+1) + } + if steps[idx].Title == "" { + steps[idx].Title = strings.ReplaceAll(steps[idx].ID, "_", " ") + } + if steps[idx].Status == "" { + steps[idx].Status = planStepStatusPending + } + } + state.Steps = append(completedSteps(state.Steps), steps...) + state.Status = executionStatusRunning + state.UpdatedAt = time.Now().UTC().Format(time.RFC3339) + if err := a.saveExecutionState(*state); err != nil { + return "", err + } + if onEvent != nil { + onEvent(StreamEventPlan, formatPlanStatus(*state, lang)) + } + continue + } + + step := &state.Steps[stepIndex] + step.Status = planStepStatusRunning + state.Status = executionStatusRunning + state.CurrentStepID = step.ID + state.UpdatedAt = time.Now().UTC().Format(time.RFC3339) + if onEvent != nil { + onEvent(StreamEventStepStart, formatStepStatus(*step, stepIndex, len(state.Steps), lang)) + } + if err := a.saveExecutionState(*state); err != nil { + return "", err + } + + switch step.Type { + case planStepTypeTool: + if onEvent != nil { + onEvent(StreamEventTool, step.ToolName) + } + stepStartedAt := time.Now() + result := a.executePlanTool(ctx, storeUserID, userID, lang, *step) + a.logPlannerTiming(state.SessionID, userID, "tool:"+step.ToolName, stepStartedAt, nil) + summary := summarizeObservation(result) + referencesChanged := false + step.Status = planStepStatusCompleted + step.OutputSummary = summary + appendExecutionLog(state, Observation{ + StepID: step.ID, + Kind: "tool_result", + Summary: summary, + RawJSON: result, + CreatedAt: time.Now().UTC().Format(time.RFC3339), + }) + referencesChanged = updateCurrentReferencesFromToolResult(state, step.ToolName, result) + _ = referencesChanged + case planStepTypeReason: + reasonStartedAt := time.Now() + reasoning, err := a.executeReasonStep(ctx, userID, lang, state.Goal, *state, *step) + a.logPlannerTiming(state.SessionID, userID, "reason_step", reasonStartedAt, err) + if err != nil { + step.Status = planStepStatusFailed + step.Error = err.Error() + state.Status = executionStatusFailed + state.LastError = err.Error() + _ = a.saveExecutionState(*state) + return "", err + } + step.Status = planStepStatusCompleted + step.OutputSummary = reasoning + appendExecutionLog(state, Observation{ + StepID: step.ID, + Kind: "reasoning", + Summary: reasoning, + CreatedAt: time.Now().UTC().Format(time.RFC3339), + }) + case planStepTypeAskUser: + question := strings.TrimSpace(step.Instruction) + if question == "" { + if lang == "zh" { + question = "我还缺少一些信息，麻烦你补充一下。" + } else { + question = "I need a bit more information before I continue." + } + } + step.Status = planStepStatusCompleted + step.OutputSummary = question + state.Status = executionStatusWaitingUser + state.Waiting = buildWaitingState(*state, *step, question) + state.FinalAnswer = question + state.UpdatedAt = time.Now().UTC().Format(time.RFC3339) + if err := a.saveExecutionState(*state); err != nil { + return "", err + } + if onEvent != nil { + onEvent(StreamEventStepComplete, formatStepCompleteStatus(*step, lang)) + onEvent(StreamEventDelta, question) + } + return question, nil + case planStepTypeRespond: + respondStartedAt := time.Now() + finalText, err := a.generateFinalPlanResponse(ctx, userID, lang, *state, step.Instruction) + a.logPlannerTiming(state.SessionID, userID, "respond_step", respondStartedAt, err) + if err != nil { + return "", err + } + step.Status = planStepStatusCompleted + step.OutputSummary = finalText + state.Status = executionStatusCompleted + state.Waiting = nil + state.FinalAnswer = finalText + state.CurrentStepID = "" + state.UpdatedAt = time.Now().UTC().Format(time.RFC3339) + if err := a.saveExecutionState(*state); err != nil { + return "", err + } + if onEvent != nil { + onEvent(StreamEventStepComplete, formatStepCompleteStatus(*step, lang)) + onEvent(StreamEventDelta, finalText) + } + return finalText, nil + default: + return "", fmt.Errorf("unsupported step type: %s", step.Type) + } + + state.UpdatedAt = time.Now().UTC().Format(time.RFC3339) + if err := a.saveExecutionState(*state); err != nil { + return "", err + } + if onEvent != nil { + onEvent(StreamEventStepComplete, formatStepCompleteStatus(*step, lang)) + } + } + + return "", fmt.Errorf("plan execution exceeded iteration limit") +} + +type fetchedToolRecord struct { + ToolName string `json:"tool_name"` + ToolArgsJSON string `json:"tool_args_json"` + FetchedAt string `json:"fetched_at"` + AgeSeconds int64 `json:"age_seconds"` +} + +func buildRecentlyFetchedData(state ExecutionState, now time.Time) []fetchedToolRecord { + state = normalizeExecutionState(state) + stepByID := make(map[string]PlanStep, len(state.Steps)) + for _, step := range state.Steps { + stepByID[step.ID] = step + } + latest := map[string]fetchedToolRecord{} + for _, obs := range state.ExecutionLog { + if obs.Kind != "tool_result" { + continue + } + step, ok := stepByID[obs.StepID] + if !ok || step.ToolName == "" { + continue + } + sig := toolCallSignature(step.ToolName, step.ToolArgs) + createdAt := parseRFC3339(obs.CreatedAt) + record := fetchedToolRecord{ + ToolName: step.ToolName, + ToolArgsJSON: toolArgsJSONString(step.ToolArgs), + FetchedAt: obs.CreatedAt, + AgeSeconds: int64(now.Sub(createdAt).Seconds()), + } + prev, exists := latest[sig] + if !exists || prev.FetchedAt < record.FetchedAt { + latest[sig] = record + } + } + out := make([]fetchedToolRecord, 0, len(latest)) + for _, record := range latest { + if record.AgeSeconds < 0 { + record.AgeSeconds = 0 + } + out = append(out, record) + } + return out +} + +func filterFreshDuplicateToolSteps(steps []PlanStep, state ExecutionState, now time.Time) []PlanStep { + if len(steps) == 0 { + return nil + } + fresh := make(map[string]struct{}) + for _, item := range buildRecentlyFetchedData(state, now) { + if item.AgeSeconds <= 60 { + fresh[item.ToolName+"|"+item.ToolArgsJSON] = struct{}{} + } + } + out := make([]PlanStep, 0, len(steps)) + for _, step := range steps { + if step.Type != planStepTypeTool { + out = append(out, step) + continue + } + sig := toolCallSignature(step.ToolName, step.ToolArgs) + if _, ok := fresh[sig]; ok { + continue + } + fresh[sig] = struct{}{} + out = append(out, step) + } + return out +} + +func hasRepeatedReasonLoop(state ExecutionState, steps []PlanStep) bool { + if len(steps) == 0 { + return false + } + last := lastCompletedStep(state.Steps) + if last == nil || last.Type != planStepTypeReason { + return false + } + for _, step := range steps { + if step.Type != planStepTypeReason { + return false + } + if stepSemanticKey(*last) != stepSemanticKey(step) { + return false + } + } + return true +} + +func lastCompletedStep(steps []PlanStep) *PlanStep { + for i := len(steps) - 1; i >= 0; i-- { + if steps[i].Status == planStepStatusCompleted { + return &steps[i] + } + } + return nil +} + +func stepSemanticKey(step PlanStep) string { + return strings.ToLower(strings.TrimSpace( + step.Type + "|" + step.ToolName + "|" + step.Title + "|" + step.Instruction, + )) +} + +func toolCallSignature(toolName string, args map[string]any) string { + return strings.TrimSpace(toolName) + "|" + toolArgsJSONString(args) +} + +func toolArgsJSONString(args map[string]any) string { + if len(args) == 0 { + return "{}" + } + data, err := json.Marshal(args) + if err != nil { + return "{}" + } + return string(data) +} + +func parseRFC3339(value string) time.Time { + t, err := time.Parse(time.RFC3339, strings.TrimSpace(value)) + if err != nil { + return time.Time{} + } + return t +} + +func (a *Agent) replanAfterStep(ctx context.Context, userID int64, lang string, state ExecutionState, completedStep PlanStep) (replannerDecision, error) { + obsJSON, _ := json.Marshal(buildObservationContext(state)) + stepsJSON, _ := json.Marshal(state.Steps) + systemPrompt := `You are the replanning module for NOFXi. +Return JSON only. + +Decide what to do after a plan step completed. +Allowed actions: +- continue +- replace_remaining +- ask_user +- finish + +Rules: +- Use continue when the current remaining steps still make sense. +- Use replace_remaining when the observations materially change the remaining plan. +- Use ask_user when execution is blocked on missing user input. +- Use finish when there is enough information to answer and remaining steps are unnecessary. +- If action=replace_remaining, return a fresh list of remaining steps only. +- Keep plans short and safe. +- Never invent tools.` + + userPrompt := fmt.Sprintf("Language: %s\nGoal: %s\nCompleted step: %s (%s)\nCompleted summary: %s\n\nCurrent steps JSON:\n%s\n\nObservations JSON:\n%s\n\nPersistent preferences:\n%s\n\nTask state:\n%s\n\nReturn JSON with this exact shape:\n{\"action\":\"continue|replace_remaining|ask_user|finish\",\"goal\":\"\",\"instruction\":\"\",\"question\":\"\",\"steps\":[{\"id\":\"step_x\",\"type\":\"tool|reason|ask_user|respond\",\"title\":\"\",\"tool_name\":\"\",\"tool_args\":{},\"instruction\":\"\",\"requires_confirmation\":false}]}", lang, state.Goal, completedStep.ID, completedStep.Type, completedStep.OutputSummary, string(stepsJSON), string(obsJSON), a.buildPersistentPreferencesContext(userID), buildTaskStateContext(a.getTaskState(userID))) + + stageCtx, cancel := withPlannerStageTimeout(ctx, plannerReplanTimeout) + defer cancel() + + startedAt := time.Now() + raw, err := a.aiClient.CallWithRequest(&mcp.Request{ + Messages: []mcp.Message{ + mcp.NewSystemMessage(systemPrompt), + mcp.NewUserMessage(userPrompt), + }, + Ctx: stageCtx, + MaxTokens: intPtr(500), + }) + a.logPlannerTiming(state.SessionID, userID, "replan_after_step_llm", startedAt, err) + if err != nil { + return replannerDecision{}, err + } + return parseReplannerDecisionJSON(raw) +} + +func parseReplannerDecisionJSON(raw string) (replannerDecision, error) { + raw = strings.TrimSpace(raw) + raw = strings.TrimPrefix(raw, "```json") + raw = strings.TrimPrefix(raw, "```") + raw = strings.TrimSuffix(raw, "```") + raw = strings.TrimSpace(raw) + + var decision replannerDecision + if err := json.Unmarshal([]byte(raw), &decision); err == nil { + return normalizeReplannerDecision(decision), nil + } + start := strings.Index(raw, "{") + end := strings.LastIndex(raw, "}") + if start >= 0 && end > start { + if err := json.Unmarshal([]byte(raw[start:end+1]), &decision); err == nil { + return normalizeReplannerDecision(decision), nil + } + } + return replannerDecision{}, fmt.Errorf("invalid replanner decision json") +} + +func normalizeReplannerDecision(decision replannerDecision) replannerDecision { + decision.Action = strings.TrimSpace(decision.Action) + decision.Goal = strings.TrimSpace(decision.Goal) + decision.Instruction = strings.TrimSpace(decision.Instruction) + decision.Question = strings.TrimSpace(decision.Question) + for i := range decision.Steps { + if decision.Steps[i].ID == "" { + decision.Steps[i].ID = fmt.Sprintf("step_%d", i+1) + } + if decision.Steps[i].Status == "" { + decision.Steps[i].Status = planStepStatusPending + } + decision.Steps[i].Type = strings.TrimSpace(decision.Steps[i].Type) + decision.Steps[i].Title = strings.TrimSpace(decision.Steps[i].Title) + decision.Steps[i].ToolName = strings.TrimSpace(decision.Steps[i].ToolName) + decision.Steps[i].Instruction = strings.TrimSpace(decision.Steps[i].Instruction) + } + return decision +} + +func applyReplannerDecision(state *ExecutionState, decision replannerDecision) bool { + switch decision.Action { + case "", "continue": + return false + case "finish": + state.Steps = append(completedSteps(state.Steps), PlanStep{ + ID: fmt.Sprintf("step_finish_%d", time.Now().UTC().UnixNano()), + Type: planStepTypeRespond, + Title: "final response", + Status: planStepStatusPending, + Instruction: decision.Instruction, + }) + state.CurrentStepID = "" + if decision.Goal != "" { + state.Goal = decision.Goal + } + state.Waiting = nil + return true + case "ask_user": + question := decision.Question + if question == "" { + question = decision.Instruction + } + state.Steps = append(completedSteps(state.Steps), PlanStep{ + ID: fmt.Sprintf("step_ask_%d", time.Now().UTC().UnixNano()), + Type: planStepTypeAskUser, + Title: "need user input", + Status: planStepStatusPending, + Instruction: question, + }) + state.CurrentStepID = "" + if decision.Goal != "" { + state.Goal = decision.Goal + } + state.Waiting = buildWaitingState(*state, state.Steps[len(state.Steps)-1], question) + return true + case "replace_remaining": + if len(decision.Steps) == 0 { + return false + } + state.Steps = append(completedSteps(state.Steps), decision.Steps...) + state.CurrentStepID = "" + if decision.Goal != "" { + state.Goal = decision.Goal + } + state.Waiting = nil + return true + default: + return false + } +} + +func shouldAttemptReplan(state ExecutionState, step PlanStep, referencesChanged bool) bool { + if step.Type != planStepTypeTool { + return false + } + if toolResultIndicatesError(step.OutputSummary) || toolResultSignalsDependencyGap(step.OutputSummary) { + return true + } + if referencesChanged { + return true + } + if !hasPendingWorkAfterStep(state.Steps) { + return false + } + switch step.ToolName { + case "manage_trader", "manage_strategy", "manage_model_config", "manage_exchange_config", "execute_trade": + return toolActionMayChangePlan(step.ToolArgs) + default: + return false + } +} + +func hasPendingWorkAfterStep(steps []PlanStep) bool { + for _, step := range steps { + if step.Status == planStepStatusPending { + return true + } + } + return false +} + +func toolActionMayChangePlan(args map[string]any) bool { + action, _ := args["action"].(string) + switch strings.TrimSpace(action) { + case "create", "update", "delete", "start", "stop", "activate", "duplicate": + return true + default: + return false + } +} + +func toolResultIndicatesError(summary string) bool { + lower := strings.ToLower(strings.TrimSpace(summary)) + return strings.Contains(lower, `"error"`) || strings.Contains(lower, `"status":"error"`) || strings.Contains(lower, "failed to ") +} + +func toolResultSignalsDependencyGap(summary string) bool { + lower := strings.ToLower(strings.TrimSpace(summary)) + patterns := []string{ + "is required", "invalid ai_model_id", "invalid exchange_id", "invalid strategy_id", + "ai model is disabled", "exchange is disabled", "not found", "missing", + } + return containsAnyKeyword(lower, patterns) +} + +func completedSteps(steps []PlanStep) []PlanStep { + out := make([]PlanStep, 0, len(steps)) + for _, step := range steps { + if step.Status == planStepStatusCompleted { + out = append(out, step) + } + } + return out +} + +func (a *Agent) planningStatusText(lang string) string { + if lang == "zh" { + return "🧭 正在规划执行步骤..." + } + return "🧭 Planning the next execution steps..." +} + +func formatPlanStatus(state ExecutionState, lang string) string { + parts := make([]string, 0, len(state.Steps)) + for i, step := range state.Steps { + label := step.Title + if label == "" { + label = step.Type + } + parts = append(parts, fmt.Sprintf("%d.%s", i+1, label)) + } + if lang == "zh" { + return fmt.Sprintf("🗺️ 计划: %s", strings.Join(parts, " -> ")) + } + return fmt.Sprintf("🗺️ Plan: %s", strings.Join(parts, " -> ")) +} + +func formatStepStatus(step PlanStep, idx, total int, lang string) string { + label := step.Title + if label == "" { + label = step.Type + } + if lang == "zh" { + return fmt.Sprintf("▶️ 步骤 %d/%d: %s", idx+1, total, label) + } + return fmt.Sprintf("▶️ Step %d/%d: %s", idx+1, total, label) +} + +func formatStepCompleteStatus(step PlanStep, lang string) string { + label := step.Title + if label == "" { + label = step.Type + } + if lang == "zh" { + return fmt.Sprintf("✅ 已完成: %s", label) + } + return fmt.Sprintf("✅ Completed: %s", label) +} + +func formatReplanStatus(decision replannerDecision, lang string) string { + switch decision.Action { + case "replace_remaining": + if lang == "zh" { + return "🔄 已根据新结果更新后续步骤" + } + return "🔄 Updated the remaining steps based on new results" + case "ask_user": + if lang == "zh" { + return "📝 当前流程需要用户补充信息" + } + return "📝 This flow needs more user input" + case "finish": + if lang == "zh" { + return "🏁 已提前收敛到最终回复" + } + return "🏁 Converged early to the final response" + default: + if lang == "zh" { + return "🔄 已重新评估计划" + } + return "🔄 Re-evaluated the plan" + } +} + +func (a *Agent) executePlanTool(ctx context.Context, storeUserID string, userID int64, lang string, step PlanStep) string { + argsJSON := "{}" + if len(step.ToolArgs) > 0 { + if data, err := json.Marshal(step.ToolArgs); err == nil { + argsJSON = string(data) + } + } + return a.handleToolCall(ctx, storeUserID, userID, lang, mcp.ToolCall{ + ID: step.ID, + Type: "function", + Function: mcp.ToolCallFunction{ + Name: step.ToolName, + Arguments: argsJSON, + }, + }) +} + +func (a *Agent) executeReasonStep(ctx context.Context, userID int64, lang, goal string, state ExecutionState, step PlanStep) (string, error) { + obsJSON, _ := json.Marshal(buildObservationContext(state)) + stageCtx, cancel := withPlannerStageTimeout(ctx, plannerReasonTimeout) + defer cancel() + + startedAt := time.Now() + resp, err := a.aiClient.CallWithRequest(&mcp.Request{ + Messages: []mcp.Message{ + mcp.NewSystemMessage("You are the reasoning module for NOFXi. Return one short paragraph only. No markdown, no bullet list."), + mcp.NewUserMessage(fmt.Sprintf("Language: %s\nGoal: %s\nReasoning task: %s\nObservations JSON: %s\nPersistent preferences: %s\nTask state: %s", lang, goal, step.Instruction, string(obsJSON), a.buildPersistentPreferencesContext(userID), buildTaskStateContext(a.getTaskState(userID)))), + }, + Ctx: stageCtx, + }) + a.logPlannerTiming(state.SessionID, userID, "reason_step_llm", startedAt, err) + if err != nil { + return "", err + } + return summarizeObservation(resp), nil +} + +func (a *Agent) generateFinalPlanResponse(ctx context.Context, userID int64, lang string, state ExecutionState, instruction string) (string, error) { + obsJSON, _ := json.Marshal(buildObservationContext(state)) + systemPrompt := a.buildSystemPrompt(lang) + if instruction == "" { + instruction = "Provide the best possible final response to the user based on the finished execution." + } + stageCtx, cancel := withPlannerStageTimeout(ctx, plannerFinalTimeout) + defer cancel() + startedAt := time.Now() + resp, err := a.aiClient.CallWithRequest(&mcp.Request{ + Messages: []mcp.Message{ + mcp.NewSystemMessage(systemPrompt), + mcp.NewSystemMessage("You are responding after a completed execution plan. Use the observations as the source of truth. Be concise and actionable."), + mcp.NewUserMessage(fmt.Sprintf("Goal: %s\nResponse instruction: %s\nObservations JSON: %s\nPersistent preferences: %s\nTask state: %s", state.Goal, instruction, string(obsJSON), a.buildPersistentPreferencesContext(userID), buildTaskStateContext(a.getTaskState(userID)))), + }, + Ctx: stageCtx, + }) + a.logPlannerTiming(state.SessionID, userID, "generate_final_response_llm", startedAt, err) + return resp, err +} + +func (a *Agent) logPlannerTiming(sessionID string, userID int64, stage string, startedAt time.Time, err error) { + if stage == "" || startedAt.IsZero() { + return + } + attrs := []any{ + "session_id", sessionID, + "user_id", userID, + "stage", stage, + "elapsed_ms", time.Since(startedAt).Milliseconds(), + } + if err != nil { + attrs = append(attrs, "error", err.Error()) + } + a.log().Info("planner timing", attrs...) +} + +func nextPendingStepIndex(steps []PlanStep) int { + for i := range steps { + if steps[i].Status == "" || steps[i].Status == planStepStatusPending { + return i + } + } + return -1 +} + +func summarizeObservation(value string) string { + value = strings.TrimSpace(value) + if len(value) <= observationMaxLength { + return value + } + return strings.TrimSpace(value[:observationMaxLength]) + "..." +} + +func (a *Agent) thinkAndActLegacy(ctx context.Context, userID int64, lang, text string, onEvent func(event, data string)) (string, error) { + systemPrompt := a.buildSystemPrompt(lang) + enrichment := a.gatherContext(text) + preferencesCtx := a.buildPersistentPreferencesContext(userID) + + userPrompt := text + if preferencesCtx != "" { + userPrompt = preferencesCtx + "\n\n---\n" + userPrompt + } + if enrichment != "" { + userPrompt = text + "\n\n---\n[NOFXi System Context - real-time data for reference]\n" + enrichment + if preferencesCtx != "" { + userPrompt = preferencesCtx + "\n\n---\n" + userPrompt + } + } + + messages := []mcp.Message{mcp.NewSystemMessage(systemPrompt)} + taskStateCtx := buildTaskStateContext(a.getTaskState(userID)) + if isConfigOrTraderIntent(text) { + taskStateCtx = "" + } + if taskStateCtx != "" { + messages = append(messages, mcp.NewSystemMessage(taskStateCtx)) + } + history := a.history.Get(userID) + if len(history) > 0 { + history = history[:len(history)-1] + } + for _, msg := range history { + messages = append(messages, mcp.NewMessage(msg.Role, msg.Content)) + } + messages = append(messages, mcp.NewUserMessage(userPrompt)) + + tools := agentTools() + + const maxToolRounds = 5 + for round := 0; round < maxToolRounds; round++ { + req := &mcp.Request{ + Messages: messages, + Tools: tools, + ToolChoice: "auto", + Ctx: ctx, + } + + resp, err := a.aiClient.CallWithRequestFull(req) + if err != nil { + if round == 0 { + plainResp, plainErr := a.aiClient.CallWithRequest(&mcp.Request{Messages: messages, Ctx: ctx}) + if plainErr != nil { + a.logger.Warn("legacy AI plain fallback failed", "error", plainErr, "user_id", userID) + return a.aiServiceFailure(lang, plainErr) + } + if onEvent != nil { + onEvent(StreamEventDelta, plainResp) + } + return plainResp, nil + } + a.logger.Warn("legacy AI tool round failed", "error", err, "user_id", userID, "round", round) + return a.aiServiceFailure(lang, err) + } + + if len(resp.ToolCalls) == 0 { + if onEvent != nil { + onEvent(StreamEventDelta, resp.Content) + } + return resp.Content, nil + } + + assistantMsg := mcp.Message{Role: "assistant", ToolCalls: resp.ToolCalls} + if resp.Content != "" { + assistantMsg.Content = resp.Content + } + messages = append(messages, assistantMsg) + + for _, tc := range resp.ToolCalls { + if onEvent != nil { + onEvent(StreamEventTool, tc.Function.Name) + } + result := a.handleToolCall(ctx, storeUserIDFromContext(ctx), userID, lang, tc) + messages = append(messages, mcp.Message{ + Role: "tool", + Content: result, + ToolCallID: tc.ID, + }) + } + } + + finalResp, err := a.aiClient.CallWithRequest(&mcp.Request{Messages: messages, Ctx: ctx}) + if err != nil { + a.logger.Warn("legacy AI final response failed", "error", err, "user_id", userID) + return a.aiServiceFailure(lang, err) + } + if onEvent != nil { + onEvent(StreamEventDelta, finalResp) + } + return finalResp, nil +} diff --git a/agent/planner_runtime_state_test.go b/agent/planner_runtime_state_test.go new file mode 100644 index 00000000..ed1b08da --- /dev/null +++ b/agent/planner_runtime_state_test.go @@ -0,0 +1,807 @@ +package agent + +import ( + "context" + "encoding/json" + "errors" + "log/slog" + "strings" + "testing" + "time" + + "nofx/mcp" +) + +func TestIsConfigOrTraderIntent(t *testing.T) { + cases := []struct { + text string + want bool + }{ + {text: "帮我创建一个交易员", want: true}, + {text: "我已经配置好了 OKX 和 DeepSeek", want: true}, + {text: "List my traders", want: true}, + {text: "BTC 接下来怎么看", want: false}, + } + for _, tc := range cases { + if got := isConfigOrTraderIntent(tc.text); got != tc.want { + t.Fatalf("isConfigOrTraderIntent(%q) = %v, want %v", tc.text, got, tc.want) + } + } +} + +func TestIsRealtimeAccountIntent(t *testing.T) { + cases := []struct { + text string + want bool + }{ + {text: "现在余额多少", want: true}, + {text: "我的仓位还在吗", want: true}, + {text: "show recent trade history", want: true}, + {text: "帮我创建交易员", want: false}, + } + for _, tc := range cases { + if got := isRealtimeAccountIntent(tc.text); got != tc.want { + t.Fatalf("isRealtimeAccountIntent(%q) = %v, want %v", tc.text, got, tc.want) + } + } +} + +func TestDetectReadFastPath(t *testing.T) { + cases := []struct { + text string + want string + }{ + {text: "/traders", want: "list_traders"}, + {text: "/strategies", want: "get_strategies"}, + {text: "/models", want: "get_model_configs"}, + {text: "/exchanges", want: "get_exchange_configs"}, + {text: "/balance", want: "get_balance"}, + {text: "/positions", want: "get_positions"}, + {text: "/history", want: "get_trade_history"}, + {text: "/trades", want: "get_trade_history"}, + {text: "列出我当前的策略", want: ""}, + {text: "查看当前交易员", want: ""}, + {text: "现在余额多少", want: ""}, + {text: "我的仓位还在吗", want: ""}, + {text: "我现在有哪些账户", want: ""}, + {text: "我的余额", want: ""}, + {text: "根据我的余额帮我分析我应该买什么", want: ""}, + {text: "我的策略是AI100，但是No candidate coins available, cycle skipped", want: ""}, + {text: "帮我创建一个 trader", want: ""}, + } + for _, tc := range cases { + req := detectReadFastPath(tc.text) + got := "" + if req != nil { + got = req.Kind + } + if got != tc.want { + t.Fatalf("detectReadFastPath(%q) = %q, want %q", tc.text, got, tc.want) + } + } +} + +func TestShouldResetExecutionStateForNewAttempt(t *testing.T) { + state := ExecutionState{ + SessionID: "sess_1", + Status: executionStatusWaitingUser, + } + if !shouldResetExecutionStateForNewAttempt("我已经配置好了，继续创建交易员", state) { + t.Fatalf("expected retry-style config request to reset execution state") + } + if shouldResetExecutionStateForNewAttempt("BTC 价格多少", state) { + t.Fatalf("did not expect generic market query to reset execution state") + } +} + +func TestLatestAskedQuestion(t *testing.T) { + state := ExecutionState{ + Status: executionStatusWaitingUser, + Steps: []PlanStep{ + {ID: "step_1", Type: planStepTypeTool, Status: planStepStatusCompleted}, + {ID: "step_2", Type: planStepTypeAskUser, Status: planStepStatusCompleted, Instruction: "需要我用正确的参数重试创建交易员 lky 吗？"}, + }, + } + got := latestAskedQuestion(state) + want := "需要我用正确的参数重试创建交易员 lky 吗？" + if got != want { + t.Fatalf("latestAskedQuestion() = %q, want %q", got, want) + } +} + +func TestLatestAskedQuestionPrefersStructuredWaitingState(t *testing.T) { + state := ExecutionState{ + Status: executionStatusWaitingUser, + Waiting: &WaitingState{ + Question: "请确认是否继续创建交易员 lky", + Intent: "confirm_action", + }, + Steps: []PlanStep{ + {ID: "step_2", Type: planStepTypeAskUser, Status: planStepStatusCompleted, Instruction: "旧问题"}, + }, + } + if got := latestAskedQuestion(state); got != "请确认是否继续创建交易员 lky" { + t.Fatalf("latestAskedQuestion() = %q, want structured waiting question", got) + } +} + +func TestRefreshStateForDynamicRequestsAddsFreshSnapshots(t *testing.T) { + a := newTestAgentWithStore(t) + + _ = a.toolManageModelConfig("user-1", `{ + "action":"create", + "provider":"openai", + "enabled":true, + "custom_api_url":"https://api.openai.com/v1", + "custom_model_name":"gpt-5-mini" + }`) + _ = a.toolManageExchangeConfig("user-1", `{ + "action":"create", + "exchange_type":"okx", + "account_name":"Main", + "enabled":true + }`) + + state := ExecutionState{ + SessionID: "sess_1", + UserID: 1, + DynamicSnapshots: []Observation{ + {Kind: "current_model_configs", Summary: "stale"}, + }, + ExecutionLog: []Observation{{Kind: "user_reply", Summary: "continue"}}, + } + + refreshed := a.refreshStateForDynamicRequests("user-1", "帮我创建交易员", state) + + if len(refreshed.DynamicSnapshots) < 3 { + t.Fatalf("expected refreshed observations to include snapshots, got %+v", refreshed.DynamicSnapshots) + } + + var foundModel, foundExchange, foundTraders bool + for _, obs := range refreshed.DynamicSnapshots { + switch obs.Kind { + case "current_model_configs": + foundModel = strings.Contains(obs.RawJSON, "openai") + case "current_exchange_configs": + foundExchange = strings.Contains(obs.RawJSON, "okx") + case "current_traders": + foundTraders = strings.Contains(obs.RawJSON, `"traders"`) + } + } + + if !foundModel || !foundExchange || !foundTraders { + t.Fatalf("missing fresh snapshots: %+v", refreshed.DynamicSnapshots) + } +} + +func TestRefreshStateForRealtimeAccountRequestsAddsFreshSnapshots(t *testing.T) { + a := newTestAgentWithStore(t) + + state := ExecutionState{ + SessionID: "sess_2", + UserID: 1, + DynamicSnapshots: []Observation{ + {Kind: "current_balances", Summary: "stale balances"}, + {Kind: "current_positions", Summary: "stale positions"}, + }, + ExecutionLog: []Observation{{Kind: "user_reply", Summary: "现在余额多少"}}, + } + + refreshed := a.refreshStateForDynamicRequests("user-1", "现在余额多少，我的仓位还在吗", state) + + var keptBalances, keptPositions, foundHistory bool + for _, obs := range refreshed.DynamicSnapshots { + switch obs.Kind { + case "current_balances": + keptBalances = strings.Contains(obs.Summary, "stale balances") + case "current_positions": + keptPositions = strings.Contains(obs.Summary, "stale positions") + case "recent_trade_history": + foundHistory = obs.RawJSON != "" + } + } + + if !keptBalances || !keptPositions || foundHistory { + t.Fatalf("expected realtime snapshots to stay untouched, got %+v", refreshed.DynamicSnapshots) + } +} + +func TestThinkAndActNaturalLanguageReadCanBeHandledByHighLevelSkill(t *testing.T) { + a := newTestAgentWithStore(t) + _ = a.toolManageStrategy("user-1", `{ + "action":"create", + "name":"激进", + "description":"激进策略模板", + "lang":"zh" + }`) + + resp, err := a.thinkAndAct(context.Background(), "user-1", 1, "zh", "列出我当前的策略") + if err != nil { + t.Fatalf("thinkAndAct() error = %v", err) + } + if !strings.Contains(resp, "当前策略") || !strings.Contains(resp, "激进") { + t.Fatalf("expected natural-language read to be handled by high-level skill, got %q", resp) + } +} + +func TestNormalizeExecutionStateMigratesLegacyObservations(t *testing.T) { + state := normalizeExecutionState(ExecutionState{ + SessionID: "sess_legacy", + UserID: 1, + Observations: []Observation{ + {Kind: "tool_result", Summary: "legacy tool result"}, + }, + }) + + if len(state.Observations) != 0 { + t.Fatalf("expected legacy observations field to be cleared, got %+v", state.Observations) + } + if len(state.ExecutionLog) != 1 || state.ExecutionLog[0].Summary != "legacy tool result" { + t.Fatalf("expected legacy observations to migrate into execution log, got %+v", state.ExecutionLog) + } +} + +func TestBuildWaitingStateForTraderConfirmation(t *testing.T) { + state := ExecutionState{Goal: "创建交易员 lky"} + step := PlanStep{ + ID: "step_ask_1", + Type: planStepTypeAskUser, + Instruction: "需要我用正确的参数重试创建交易员 lky 吗？", + RequiresConfirmation: true, + } + + waiting := buildWaitingState(state, step, step.Instruction) + if waiting == nil { + t.Fatal("expected waiting state") + } + if waiting.Intent != "confirm_action" { + t.Fatalf("unexpected waiting intent: %+v", waiting) + } + if waiting.ConfirmationTarget != "trader" { + t.Fatalf("unexpected confirmation target: %+v", waiting) + } +} + +func TestNormalizeWaitingStateCleansFields(t *testing.T) { + state := normalizeExecutionState(ExecutionState{ + SessionID: "sess_waiting", + UserID: 1, + Waiting: &WaitingState{ + Question: " 请提供 strategy_id ", + Intent: " complete_trader_setup ", + PendingFields: []string{" strategy_id ", "strategy_id"}, + ConfirmationTarget: " trader ", + }, + }) + + if state.Waiting == nil { + t.Fatal("expected normalized waiting state") + } + if state.Waiting.Question != "请提供 strategy_id" { + t.Fatalf("unexpected normalized question: %+v", state.Waiting) + } + if len(state.Waiting.PendingFields) != 1 || state.Waiting.PendingFields[0] != "strategy_id" { + t.Fatalf("unexpected pending fields: %+v", state.Waiting) + } + if state.Waiting.ConfirmationTarget != "trader" { + t.Fatalf("unexpected confirmation target: %+v", state.Waiting) + } +} + +func TestRefreshCurrentReferencesForUserTextMatchesStrategyName(t *testing.T) { + a := newTestAgentWithStore(t) + _ = a.toolManageStrategy("user-1", `{ + "action":"create", + "name":"激进", + "description":"激进策略模板", + "lang":"zh" + }`) + + state := newExecutionState(1, "帮我改一下激进这个策略") + a.refreshCurrentReferencesForUserText("user-1", "帮我改一下激进这个策略", &state) + + if state.CurrentReferences == nil || state.CurrentReferences.Strategy == nil { + t.Fatalf("expected strategy reference, got %+v", state.CurrentReferences) + } + if state.CurrentReferences.Strategy.Name != "激进" { + t.Fatalf("unexpected strategy reference: %+v", state.CurrentReferences.Strategy) + } +} + +func TestUpdateCurrentReferencesFromToolResultTracksCreatedStrategy(t *testing.T) { + state := newExecutionState(1, "创建策略") + changed := updateCurrentReferencesFromToolResult(&state, "manage_strategy", `{ + "status":"ok", + "action":"create", + "strategy":{"id":"strategy_1","name":"激进"} + }`) + + if !changed { + t.Fatalf("expected reference update to report changed") + } + if state.CurrentReferences == nil || state.CurrentReferences.Strategy == nil { + t.Fatalf("expected strategy reference after tool result, got %+v", state.CurrentReferences) + } + if state.CurrentReferences.Strategy.ID != "strategy_1" { + t.Fatalf("unexpected strategy reference: %+v", state.CurrentReferences.Strategy) + } +} + +func TestShouldAttemptReplan(t *testing.T) { + state := ExecutionState{ + Steps: []PlanStep{ + {ID: "step_1", Type: planStepTypeTool, Status: planStepStatusCompleted}, + {ID: "step_2", Type: planStepTypeRespond, Status: planStepStatusPending}, + }, + } + + if !shouldAttemptReplan(state, PlanStep{ + Type: planStepTypeTool, + ToolName: "manage_trader", + ToolArgs: map[string]any{"action": "create"}, + OutputSummary: `{"status":"ok","action":"create"}`, + }, false) { + t.Fatalf("expected create trader step to trigger replan") + } + + if shouldAttemptReplan(state, PlanStep{ + Type: planStepTypeTool, + ToolName: "get_balance", + OutputSummary: `{"balances":[]}`, + }, false) { + t.Fatalf("did not expect read-only balance step to trigger replan") + } + + if !shouldAttemptReplan(state, PlanStep{ + Type: planStepTypeTool, + ToolName: "get_balance", + OutputSummary: `{"error":"ai_model_id is required"}`, + }, false) { + t.Fatalf("expected dependency/error result to trigger replan") + } +} + +type failingAIClient struct{} + +func (f *failingAIClient) SetAPIKey(string, string, string) {} +func (f *failingAIClient) SetTimeout(_ time.Duration) {} +func (f *failingAIClient) CallWithMessages(string, string) (string, error) { + return "", errors.New("unexpected CallWithMessages") +} +func (f *failingAIClient) CallWithRequest(*mcp.Request) (string, error) { + return "", errors.New("API returned error (status 402): insufficient balance") +} +func (f *failingAIClient) CallWithRequestStream(*mcp.Request, func(string)) (string, error) { + return "", errors.New("unexpected CallWithRequestStream") +} +func (f *failingAIClient) CallWithRequestFull(*mcp.Request) (*mcp.LLMResponse, error) { + return nil, errors.New("API returned error (status 402): insufficient balance") +} + +type capturePlannerAIClient struct { + systemPrompt string + userPrompt string +} + +func (c *capturePlannerAIClient) SetAPIKey(string, string, string) {} +func (c *capturePlannerAIClient) SetTimeout(time.Duration) {} +func (c *capturePlannerAIClient) CallWithMessages(string, string) (string, error) { + return "", errors.New("unexpected CallWithMessages") +} +func (c *capturePlannerAIClient) CallWithRequest(req *mcp.Request) (string, error) { + if len(req.Messages) > 0 { + c.systemPrompt = req.Messages[0].Content + } + if len(req.Messages) > 1 { + c.userPrompt = req.Messages[1].Content + } + return `{"goal":"test goal","steps":[{"id":"step_1","type":"respond","instruction":"ok"}]}`, nil +} +func (c *capturePlannerAIClient) CallWithRequestStream(*mcp.Request, func(string)) (string, error) { + return "", errors.New("unexpected CallWithRequestStream") +} +func (c *capturePlannerAIClient) CallWithRequestFull(*mcp.Request) (*mcp.LLMResponse, error) { + return nil, errors.New("unexpected CallWithRequestFull") +} + +type blockingAIClient struct{} + +func (b *blockingAIClient) SetAPIKey(string, string, string) {} +func (b *blockingAIClient) SetTimeout(time.Duration) {} +func (b *blockingAIClient) CallWithMessages(string, string) (string, error) { + return "", errors.New("unexpected CallWithMessages") +} +func (b *blockingAIClient) CallWithRequest(req *mcp.Request) (string, error) { + <-req.Ctx.Done() + return "", req.Ctx.Err() +} +func (b *blockingAIClient) CallWithRequestStream(*mcp.Request, func(string)) (string, error) { + return "", errors.New("unexpected CallWithRequestStream") +} +func (b *blockingAIClient) CallWithRequestFull(*mcp.Request) (*mcp.LLMResponse, error) { + return nil, errors.New("unexpected CallWithRequestFull") +} + +type directReplyAIClient struct { + lastSystemPrompt string + lastUserPrompt string + routerPrompt string + skillRouterPrompt string + plannerPrompt string +} + +func (d *directReplyAIClient) SetAPIKey(string, string, string) {} +func (d *directReplyAIClient) SetTimeout(time.Duration) {} +func (d *directReplyAIClient) CallWithMessages(string, string) (string, error) { + return "", errors.New("unexpected CallWithMessages") +} +func (d *directReplyAIClient) CallWithRequest(req *mcp.Request) (string, error) { + if len(req.Messages) > 0 { + d.lastSystemPrompt = req.Messages[0].Content + } + if len(req.Messages) > 1 { + d.lastUserPrompt = req.Messages[1].Content + } + if strings.Contains(d.lastSystemPrompt, "first-pass router for NOFXi") { + d.routerPrompt = d.lastSystemPrompt + if strings.Contains(d.lastUserPrompt, "你好") { + return `{"action":"direct_answer","answer":"你好，我在。想聊策略、配置还是排障？"}`, nil + } + return `{"action":"defer","answer":""}`, nil + } + if strings.Contains(d.lastSystemPrompt, "lightweight skill router for NOFXi") { + d.skillRouterPrompt = d.lastSystemPrompt + if strings.Contains(d.lastUserPrompt, "运行中的trader") || strings.Contains(d.lastUserPrompt, "有没有 trader 在跑") { + return `{"route":"skill","skill":"trader_management","action":"query","filter":"running_only"}`, nil + } + return `{"route":"planner","skill":"","action":"","filter":""}`, nil + } + if strings.Contains(d.lastSystemPrompt, "planning module for NOFXi") { + d.plannerPrompt = d.lastSystemPrompt + } + return `{"goal":"test goal","steps":[{"id":"step_1","type":"respond","instruction":"ok"}]}`, nil +} +func (d *directReplyAIClient) CallWithRequestStream(*mcp.Request, func(string)) (string, error) { + return "", errors.New("unexpected CallWithRequestStream") +} +func (d *directReplyAIClient) CallWithRequestFull(*mcp.Request) (*mcp.LLMResponse, error) { + return nil, errors.New("unexpected CallWithRequestFull") +} + +func TestThinkAndActLegacyReturnsProviderFailureInsteadOfNoAIFallback(t *testing.T) { + a := &Agent{ + aiClient: &failingAIClient{}, + config: DefaultConfig(), + logger: slog.Default(), + history: newChatHistory(10), + } + + resp, err := a.thinkAndActLegacy(context.Background(), 42, "zh", "你好", nil) + if err != nil { + t.Fatalf("thinkAndActLegacy() error = %v", err) + } + if strings.Contains(resp, "发送 *开始配置* 配置 AI 模型") { + t.Fatalf("expected provider failure message, got fallback: %q", resp) + } + if !strings.Contains(resp, "AI 服务调用失败") { + t.Fatalf("expected provider failure message, got %q", resp) + } +} + +func TestThinkAndActUsesDirectReplyGateForConversationalQuestion(t *testing.T) { + client := &directReplyAIClient{} + a := &Agent{ + aiClient: client, + config: DefaultConfig(), + logger: slog.Default(), + history: newChatHistory(10), + } + + resp, err := a.thinkAndAct(context.Background(), "user-1", 88, "zh", "你好") + if err != nil { + t.Fatalf("thinkAndAct() error = %v", err) + } + if !strings.Contains(resp, "你好，我在") { + t.Fatalf("expected direct reply response, got %q", resp) + } + if !strings.Contains(client.routerPrompt, "first-pass router for NOFXi") { + t.Fatalf("expected direct reply router prompt, got %q", client.routerPrompt) + } +} + +func TestThinkAndActDefersFromDirectReplyGateToHardSkill(t *testing.T) { + a := newTestAgentWithStore(t) + a.aiClient = &directReplyAIClient{} + + resp, err := a.thinkAndAct(context.Background(), "user-1", 89, "zh", "帮我创建一个 DeepSeek 模型配置") + if err != nil { + t.Fatalf("thinkAndAct() error = %v", err) + } + if !strings.Contains(resp, "已创建模型配置") { + t.Fatalf("expected direct reply gate to defer to hard skill, got %q", resp) + } +} + +func TestThinkAndActUsesLLMSkillRouterForNaturalLanguageTraderQuery(t *testing.T) { + client := &directReplyAIClient{} + a := newTestAgentWithStore(t) + a.aiClient = client + a.history = newChatHistory(10) + + modelResp := a.toolManageModelConfig("user-1", `{ + "action":"create", + "provider":"openai", + "enabled":true, + "custom_api_url":"https://api.openai.com/v1", + "custom_model_name":"gpt-5-mini" + }`) + var modelCreated struct { + Model safeModelToolConfig `json:"model"` + } + if err := json.Unmarshal([]byte(modelResp), &modelCreated); err != nil { + t.Fatalf("unmarshal model response: %v", err) + } + + exchangeResp := a.toolManageExchangeConfig("user-1", `{ + "action":"create", + "exchange_type":"binance", + "account_name":"Main", + "enabled":true + }`) + var exchangeCreated struct { + Exchange safeExchangeToolConfig `json:"exchange"` + } + if err := json.Unmarshal([]byte(exchangeResp), &exchangeCreated); err != nil { + t.Fatalf("unmarshal exchange response: %v", err) + } + + createResp := a.toolManageTrader("user-1", `{ + "action":"create", + "name":"Momentum Trader", + "ai_model_id":"`+modelCreated.Model.ID+`", + "exchange_id":"`+exchangeCreated.Exchange.ID+`", + "scan_interval_minutes":5 + }`) + var created struct { + Trader safeTraderToolConfig `json:"trader"` + } + if err := json.Unmarshal([]byte(createResp), &created); err != nil { + t.Fatalf("unmarshal create trader response: %v\nraw=%s", err, createResp) + } + if err := a.store.Trader().UpdateStatus("user-1", created.Trader.ID, true); err != nil { + t.Fatalf("update trader status: %v", err) + } + + resp, err := a.thinkAndAct(context.Background(), "user-1", 90, "zh", "当前有运行中的trader吗") + if err != nil { + t.Fatalf("thinkAndAct() error = %v", err) + } + if !strings.Contains(resp, "运行中的交易员") || !strings.Contains(resp, "Momentum Trader") { + t.Fatalf("expected routed running-trader answer, got %q", resp) + } + if client.skillRouterPrompt == "" { + t.Fatal("expected lightweight skill router prompt to be used") + } + if client.plannerPrompt != "" { + t.Fatalf("expected planner to be skipped, got prompt %q", client.plannerPrompt) + } +} + +func TestThinkAndActPrioritizesActiveExecutionStateOverDirectReply(t *testing.T) { + client := &directReplyAIClient{} + a := newTestAgentWithStore(t) + a.aiClient = client + a.history = newChatHistory(10) + a.logger = slog.Default() + + userID := int64(90) + state := newExecutionState(userID, "继续完成当前任务") + state.Status = executionStatusWaitingUser + state.Waiting = &WaitingState{ + Question: "请确认是否继续", + Intent: "confirm_action", + } + if err := a.saveExecutionState(state); err != nil { + t.Fatalf("saveExecutionState() error = %v", err) + } + + resp, err := a.thinkAndAct(context.Background(), "user-1", userID, "zh", "你好") + if err != nil { + t.Fatalf("thinkAndAct() error = %v", err) + } + if strings.Contains(resp, "你好，我在") { + t.Fatalf("expected active execution state to bypass direct reply gate, got %q", resp) + } + if !strings.Contains(client.plannerPrompt, "planning module for NOFXi") { + t.Fatalf("expected planner prompt when execution state is active, got %q", client.plannerPrompt) + } +} + +func TestThinkAndActInterruptsWaitingExecutionStateForNewTopic(t *testing.T) { + a := newTestAgentWithStore(t) + a.history = newChatHistory(10) + + _ = a.toolManageStrategy("user-1", `{ + "action":"create", + "name":"激进", + "lang":"zh" + }`) + + userID := int64(91) + state := newExecutionState(userID, "创建交易员") + state.Status = executionStatusWaitingUser + state.Waiting = &WaitingState{ + Question: "请告诉我交易员名称", + PendingFields: []string{"name"}, + } + if err := a.saveExecutionState(state); err != nil { + t.Fatalf("saveExecutionState() error = %v", err) + } + + resp, err := a.thinkAndAct(context.Background(), "user-1", userID, "zh", "列出我当前的策略") + if err != nil { + t.Fatalf("thinkAndAct() error = %v", err) + } + if !strings.Contains(resp, "当前策略") || !strings.Contains(resp, "激进") { + t.Fatalf("expected new topic to be handled, got %q", resp) + } + if got := a.getExecutionState(userID); got.SessionID != "" { + t.Fatalf("expected execution state to be cleared, got %+v", got) + } +} + +func TestCreateExecutionPlanIncludesRecentConversation(t *testing.T) { + client := &capturePlannerAIClient{} + a := &Agent{ + aiClient: client, + config: DefaultConfig(), + logger: slog.Default(), + history: newChatHistory(10), + } + + userID := int64(42) + a.history.Add(userID, "user", "先帮我看一下当前trader") + a.history.Add(userID, "assistant", "当前只有测试1这个trader。") + a.history.Add(userID, "user", "好的，那就按当前trader来") + + _, err := a.createExecutionPlan(context.Background(), userID, "zh", "好的，那就按当前trader来", newExecutionState(userID, "好的，那就按当前trader来")) + if err != nil { + t.Fatalf("createExecutionPlan() error = %v", err) + } + if !strings.Contains(client.userPrompt, "Recent conversation:") { + t.Fatalf("expected planner prompt to include recent conversation, got %q", client.userPrompt) + } + if !strings.Contains(client.userPrompt, "先帮我看一下当前trader") { + t.Fatalf("expected previous user turn in recent conversation, got %q", client.userPrompt) + } + if !strings.Contains(client.userPrompt, "当前只有测试1这个trader") { + t.Fatalf("expected previous assistant turn in recent conversation, got %q", client.userPrompt) + } + recentIdx := strings.Index(client.userPrompt, "Recent conversation:\n") + toolsIdx := strings.Index(client.userPrompt, "\n\nAvailable tools JSON:") + if recentIdx == -1 || toolsIdx == -1 || toolsIdx <= recentIdx { + t.Fatalf("expected recent conversation block boundaries, got %q", client.userPrompt) + } + recentBlock := client.userPrompt[recentIdx:toolsIdx] + if strings.Contains(recentBlock, "好的，那就按当前trader来") { + t.Fatalf("expected current user text to stay out of recent conversation block, got %q", recentBlock) + } + if !strings.Contains(client.systemPrompt, "Memory priority order:") { + t.Fatalf("expected planner system prompt to include memory priority guidance, got %q", client.systemPrompt) + } + if !strings.Contains(client.systemPrompt, "Execution state JSON = current operational truth") { + t.Fatalf("expected planner system prompt to prioritize execution state, got %q", client.systemPrompt) + } + if !strings.Contains(client.systemPrompt, "Do not ask the user to repeat a fact") { + t.Fatalf("expected planner system prompt to forbid unnecessary repeated questions, got %q", client.systemPrompt) + } +} + +func TestCreateExecutionPlanIncludesRecentConversationForFreshRequest(t *testing.T) { + client := &capturePlannerAIClient{} + a := &Agent{ + aiClient: client, + config: DefaultConfig(), + logger: slog.Default(), + history: newChatHistory(10), + } + + userID := int64(99) + a.history.Add(userID, "user", "先帮我看一下当前trader") + a.history.Add(userID, "assistant", "当前只有测试1这个trader。") + + _, err := a.createExecutionPlan(context.Background(), userID, "zh", "帮我分析一下比特币", ExecutionState{}) + if err != nil { + t.Fatalf("createExecutionPlan() error = %v", err) + } + if !strings.Contains(client.userPrompt, "Recent conversation:") { + t.Fatalf("expected fresh request to still include recent conversation block, got %q", client.userPrompt) + } + if !strings.Contains(client.userPrompt, "先帮我看一下当前trader") { + t.Fatalf("expected previous user turn in recent conversation, got %q", client.userPrompt) + } + if !strings.Contains(client.userPrompt, "当前只有测试1这个trader") { + t.Fatalf("expected previous assistant turn in recent conversation, got %q", client.userPrompt) + } +} + +func TestCreateExecutionPlanIncludesQuotedEarlierAssistantClaim(t *testing.T) { + client := &capturePlannerAIClient{} + a := &Agent{ + aiClient: client, + config: DefaultConfig(), + logger: slog.Default(), + history: newChatHistory(10), + } + + userID := int64(100) + a.history.Add(userID, "user", "配置页怎么只有三个交易所") + a.history.Add(userID, "assistant", "目前你看到的是三个交易所。") + + _, err := a.createExecutionPlan(context.Background(), userID, "zh", "你前面也跟我说只有三个交易所", ExecutionState{}) + if err != nil { + t.Fatalf("createExecutionPlan() error = %v", err) + } + if !strings.Contains(client.userPrompt, "目前你看到的是三个交易所") { + t.Fatalf("expected planner prompt to include earlier assistant claim, got %q", client.userPrompt) + } + if !strings.Contains(client.userPrompt, "配置页怎么只有三个交易所") { + t.Fatalf("expected planner prompt to include earlier user complaint, got %q", client.userPrompt) + } +} + +func TestRunPlannedAgentReturnsTimeoutMessageOnPlannerTimeout(t *testing.T) { + oldTimeout := plannerCreateTimeout + plannerCreateTimeout = 10 * time.Millisecond + defer func() { plannerCreateTimeout = oldTimeout }() + + a := &Agent{ + aiClient: &blockingAIClient{}, + config: DefaultConfig(), + logger: slog.Default(), + history: newChatHistory(10), + } + + resp, err := a.runPlannedAgent(context.Background(), "default", 7, "zh", "帮我分析一下当前市场", nil) + if err != nil { + t.Fatalf("runPlannedAgent() error = %v", err) + } + if !strings.Contains(resp, "处理超时") { + t.Fatalf("expected timeout message, got %q", resp) + } +} + +func TestHandleMessageForStoreUserBypassesPlannerForTradeConfirmation(t *testing.T) { + a := &Agent{ + config: DefaultConfig(), + logger: slog.Default(), + history: newChatHistory(10), + pending: newPendingTrades(), + } + + resp, err := a.handleMessageForStoreUser(context.Background(), "default", 1, "确认 trade_missing") + if err != nil { + t.Fatalf("handleMessageForStoreUser() error = %v", err) + } + if !strings.Contains(resp, "交易已过期或不存在") { + t.Fatalf("expected direct trade confirmation handling, got %q", resp) + } +} + +func TestResolveModelRuntimeConfigUsesProviderDefaults(t *testing.T) { + url, model := resolveModelRuntimeConfig("deepseek", "", "", "user_deepseek") + if url != "https://api.deepseek.com/v1" { + t.Fatalf("unexpected deepseek default url: %q", url) + } + if model != "deepseek-chat" { + t.Fatalf("unexpected deepseek default model: %q", model) + } + + url, model = resolveModelRuntimeConfig("deepseek", "", "deepseek1", "user_deepseek") + if url != "https://api.deepseek.com/v1" { + t.Fatalf("unexpected resolved url: %q", url) + } + if model != "deepseek1" { + t.Fatalf("expected existing custom model name to win, got %q", model) + } +} diff --git a/agent/preferences.go b/agent/preferences.go new file mode 100644 index 00000000..af43c9e8 --- /dev/null +++ b/agent/preferences.go @@ -0,0 +1,161 @@ +package agent + +import ( + "encoding/json" + "fmt" + "hash/fnv" + "strings" + "time" +) + +// PersistentPreference is a durable user instruction shown in the UI and +// injected into the agent context for future conversations. +type PersistentPreference struct { + ID string `json:"id"` + Text string `json:"text"` + CreatedAt string `json:"created_at,omitempty"` +} + +func NewPersistentPreference(text string) (PersistentPreference, error) { + text = strings.TrimSpace(text) + if text == "" { + return PersistentPreference{}, fmt.Errorf("text required") + } + + now := time.Now().UTC() + return PersistentPreference{ + ID: now.Format("20060102150405.000000000"), + Text: text, + CreatedAt: now.Format(time.RFC3339), + }, nil +} + +// SessionUserIDFromKey maps a stable user key (for example a UUID string from +// auth) to the int64 session id expected by the current agent implementation. +func SessionUserIDFromKey(userKey string) int64 { + if strings.TrimSpace(userKey) == "" { + return 1 + } + h := fnv.New64a() + _, _ = h.Write([]byte(userKey)) + sum := h.Sum64() & 0x7fffffffffffffff + if sum == 0 { + return 1 + } + return int64(sum) +} + +func PreferencesConfigKey(userID int64) string { + return fmt.Sprintf("agent_preferences_%d", userID) +} + +func (a *Agent) getPersistentPreferences(userID int64) []PersistentPreference { + if a.store == nil { + return nil + } + + raw, err := a.store.GetSystemConfig(PreferencesConfigKey(userID)) + if err != nil || strings.TrimSpace(raw) == "" { + return nil + } + + var prefs []PersistentPreference + if err := json.Unmarshal([]byte(raw), &prefs); err != nil { + a.logger.Warn("failed to parse persistent preferences", "error", err, "user_id", userID) + return nil + } + return prefs +} + +func (a *Agent) savePersistentPreferences(userID int64, prefs []PersistentPreference) error { + if a.store == nil { + return fmt.Errorf("store unavailable") + } + data, err := json.Marshal(prefs) + if err != nil { + return err + } + return a.store.SetSystemConfig(PreferencesConfigKey(userID), string(data)) +} + +func (a *Agent) addPersistentPreference(userID int64, text string) ([]PersistentPreference, PersistentPreference, error) { + created, err := NewPersistentPreference(text) + if err != nil { + return nil, PersistentPreference{}, err + } + prefs := a.getPersistentPreferences(userID) + prefs = append([]PersistentPreference{created}, prefs...) + if len(prefs) > 20 { + prefs = prefs[:20] + } + if err := a.savePersistentPreferences(userID, prefs); err != nil { + return nil, PersistentPreference{}, err + } + return prefs, created, nil +} + +func (a *Agent) updatePersistentPreference(userID int64, match, replacement string) ([]PersistentPreference, *PersistentPreference, error) { + match = strings.TrimSpace(match) + replacement = strings.TrimSpace(replacement) + if match == "" || replacement == "" { + return nil, nil, fmt.Errorf("match and replacement are required") + } + + prefs := a.getPersistentPreferences(userID) + for i := range prefs { + if prefs[i].ID == match || strings.Contains(strings.ToLower(prefs[i].Text), strings.ToLower(match)) { + prefs[i].Text = replacement + if err := a.savePersistentPreferences(userID, prefs); err != nil { + return nil, nil, err + } + return prefs, &prefs[i], nil + } + } + return prefs, nil, fmt.Errorf("preference not found") +} + +func (a *Agent) deletePersistentPreference(userID int64, match string) ([]PersistentPreference, *PersistentPreference, error) { + match = strings.TrimSpace(match) + if match == "" { + return nil, nil, fmt.Errorf("match required") + } + + prefs := a.getPersistentPreferences(userID) + filtered := make([]PersistentPreference, 0, len(prefs)) + var removed *PersistentPreference + for i := range prefs { + p := prefs[i] + if removed == nil && (p.ID == match || strings.Contains(strings.ToLower(p.Text), strings.ToLower(match))) { + cp := p + removed = &cp + continue + } + filtered = append(filtered, p) + } + if removed == nil { + return prefs, nil, fmt.Errorf("preference not found") + } + if err := a.savePersistentPreferences(userID, filtered); err != nil { + return nil, nil, err + } + return filtered, removed, nil +} + +func (a *Agent) buildPersistentPreferencesContext(userID int64) string { + prefs := a.getPersistentPreferences(userID) + if len(prefs) == 0 { + return "" + } + + var sb strings.Builder + sb.WriteString("[Persistent User Preferences - follow unless the user explicitly overrides them]\n") + for _, pref := range prefs { + if strings.TrimSpace(pref.Text) == "" { + continue + } + sb.WriteString("- ") + sb.WriteString(pref.Text) + sb.WriteString("\n") + } + return strings.TrimSpace(sb.String()) +} diff --git a/agent/preferences_test.go b/agent/preferences_test.go new file mode 100644 index 00000000..5c45e2c5 --- /dev/null +++ b/agent/preferences_test.go @@ -0,0 +1,31 @@ +package agent + +import ( + "strings" + "testing" +) + +func TestNewPersistentPreference(t *testing.T) { + pref, err := NewPersistentPreference(" Always answer in Chinese. ") + if err != nil { + t.Fatalf("expected preference to be created, got error: %v", err) + } + if pref.ID == "" { + t.Fatal("expected non-empty preference id") + } + if pref.Text != "Always answer in Chinese." { + t.Fatalf("expected trimmed text, got %q", pref.Text) + } + if pref.CreatedAt == "" { + t.Fatal("expected created_at to be set") + } + if strings.Contains(pref.ID, "Always") { + t.Fatalf("expected generated id, got %q", pref.ID) + } +} + +func TestNewPersistentPreferenceRejectsEmptyText(t *testing.T) { + if _, err := NewPersistentPreference(" "); err == nil { + t.Fatal("expected empty text to be rejected") + } +} diff --git a/agent/scheduler.go b/agent/scheduler.go new file mode 100644 index 00000000..41021c7a --- /dev/null +++ b/agent/scheduler.go @@ -0,0 +1,105 @@ +package agent + +import ( + "context" + "fmt" + "log/slog" + "nofx/safe" + "strings" + "time" +) + +type Scheduler struct { + agent *Agent + logger *slog.Logger + stopCh chan struct{} +} + +func NewScheduler(a *Agent, l *slog.Logger) *Scheduler { + return &Scheduler{agent: a, logger: l, stopCh: make(chan struct{})} +} + +func (s *Scheduler) Start(ctx context.Context) { + safe.GoNamed("agent-scheduler", func() { + ticker := time.NewTicker(1 * time.Minute) + defer ticker.Stop() + lastReport := time.Time{} + lastCheck := time.Time{} + for { + select { + case <-ctx.Done(): return + case <-s.stopCh: return + case now := <-ticker.C: + // Daily report at 21:00 + if now.Hour() == 21 && now.Sub(lastReport) > 12*time.Hour { + s.dailyReport() + lastReport = now + } + // Position risk check every 4h + if now.Sub(lastCheck) > 4*time.Hour { + s.riskCheck() + lastCheck = now + } + // Clean expired pending trades every hour. + if now.Minute() == 0 { + if s.agent.pending != nil { + s.agent.pending.CleanExpired() + } + } + } + } + }) +} + +func (s *Scheduler) Stop() { close(s.stopCh) } + +func (s *Scheduler) dailyReport() { + if s.agent.traderManager == nil { return } + + traders := s.agent.traderManager.GetAllTraders() + if len(traders) == 0 { return } + + var sb strings.Builder + sb.WriteString(fmt.Sprintf("📊 *NOFXi 每日报告 — %s*\n\n", time.Now().Format("2006-01-02"))) + + totalPnL := 0.0 + for _, t := range traders { + info, err := t.GetAccountInfo() + if err != nil { continue } + equity := toFloat(info["total_equity"]) + pnl := toFloat(info["unrealized_pnl"]) + sb.WriteString(fmt.Sprintf("• %s: $%.2f (P/L: $%.2f)\n", t.GetName(), equity, pnl)) + totalPnL += pnl + } + e := "📈" + if totalPnL < 0 { e = "📉" } + sb.WriteString(fmt.Sprintf("\n%s Total P/L: $%.2f", e, totalPnL)) + + s.agent.notifyAll(sb.String()) +} + +func (s *Scheduler) riskCheck() { + if s.agent.traderManager == nil { return } + + var alerts []string + for _, t := range s.agent.traderManager.GetAllTraders() { + positions, err := t.GetPositions() + if err != nil { continue } + for _, p := range positions { + pnl := toFloat(p["unrealizedPnl"]) + size := toFloat(p["size"]) + if size == 0 { continue } + entry := toFloat(p["entryPrice"]) + if entry > 0 { + pnlPct := (pnl / (entry * size)) * 100 + if pnlPct < -5 { + alerts = append(alerts, fmt.Sprintf("⚠️ *%s* %s: %.1f%% ($%.2f)", + p["symbol"], p["side"], pnlPct, pnl)) + } + } + } + } + if len(alerts) > 0 { + s.agent.notifyAll("🚨 *持仓风险提醒*\n\n" + strings.Join(alerts, "\n")) + } +} diff --git a/agent/sentinel.go b/agent/sentinel.go new file mode 100644 index 00000000..3c5f0f22 --- /dev/null +++ b/agent/sentinel.go @@ -0,0 +1,172 @@ +package agent + +import ( + "encoding/json" + "fmt" + "log/slog" + "math" + "net/http" + "nofx/safe" + "strconv" + "strings" + "sync" + "time" +) + +type SignalType string + +const ( + SignalPriceBreakout SignalType = "price_breakout" + SignalVolumeSpike SignalType = "volume_spike" + SignalFundingRate SignalType = "funding_rate" +) + +type Signal struct { + Type SignalType + Symbol string + Severity string + Title string + Detail string + Price float64 + Change float64 +} + +type SignalCallback func(Signal) + +type Sentinel struct { + mu sync.RWMutex + symbols []string + history map[string][]pricePt + onSignal SignalCallback + http *http.Client + logger *slog.Logger + stopCh chan struct{} +} + +type pricePt struct { + Price float64 + Volume float64 + Time time.Time +} + +func NewSentinel(symbols []string, cb SignalCallback, logger *slog.Logger) *Sentinel { + return &Sentinel{ + symbols: symbols, + history: make(map[string][]pricePt), + onSignal: cb, + http: &http.Client{Timeout: 10 * time.Second}, + logger: logger, + stopCh: make(chan struct{}), + } +} + +func (s *Sentinel) Start() { + safe.GoNamed("sentinel", func() { + ticker := time.NewTicker(60 * time.Second) + defer ticker.Stop() + s.scan() + for { + select { + case <-s.stopCh: + return + case <-ticker.C: + s.scan() + } + } + }) +} + +func (s *Sentinel) Stop() { close(s.stopCh) } +func (s *Sentinel) SymbolCount() int { s.mu.RLock(); defer s.mu.RUnlock(); return len(s.symbols) } +func (s *Sentinel) AddSymbol(sym string) { s.mu.Lock(); defer s.mu.Unlock(); for _, x := range s.symbols { if x == sym { return } }; s.symbols = append(s.symbols, sym) } +func (s *Sentinel) RemoveSymbol(sym string) { s.mu.Lock(); defer s.mu.Unlock(); for i, x := range s.symbols { if x == sym { s.symbols = append(s.symbols[:i], s.symbols[i+1:]...); return } } } + +func (s *Sentinel) FormatWatchlist(L string) string { + s.mu.RLock() + defer s.mu.RUnlock() + if len(s.symbols) == 0 { + if L == "zh" { return "📭 监控列表为空。用 `/watch BTC` 添加。" } + return "📭 Watchlist empty. Use `/watch BTC` to add." + } + var sb strings.Builder + if L == "zh" { sb.WriteString("👁️ *监控列表*\n\n") } else { sb.WriteString("👁️ *Watchlist*\n\n") } + for _, sym := range s.symbols { + if pts, ok := s.history[sym]; ok && len(pts) > 0 { + last := pts[len(pts)-1] + sb.WriteString(fmt.Sprintf("• *%s*: $%.4f (%s)\n", sym, last.Price, last.Time.Format("15:04"))) + } else { + sb.WriteString(fmt.Sprintf("• *%s*: waiting...\n", sym)) + } + } + return sb.String() +} + +func (s *Sentinel) scan() { + s.mu.RLock() + syms := make([]string, len(s.symbols)) + copy(syms, s.symbols) + s.mu.RUnlock() + for _, sym := range syms { + s.check(sym) + } +} + +func (s *Sentinel) check(symbol string) { + resp, err := s.http.Get(fmt.Sprintf("https://fapi.binance.com/fapi/v1/ticker/24hr?symbol=%s", symbol)) + if err != nil { return } + defer resp.Body.Close() + if resp.StatusCode != http.StatusOK { + s.logger.Debug("sentinel ticker non-200", "symbol", symbol, "status", resp.StatusCode) + return + } + body, err := safe.ReadAllLimited(resp.Body, 256*1024) // 256KB limit + if err != nil { return } + var t map[string]interface{} + if err := json.Unmarshal(body, &t); err != nil { return } + + price, _ := strconv.ParseFloat(fmt.Sprint(t["lastPrice"]), 64) + vol, _ := strconv.ParseFloat(fmt.Sprint(t["quoteVolume"]), 64) + chg, _ := strconv.ParseFloat(fmt.Sprint(t["priceChangePercent"]), 64) + + pt := pricePt{Price: price, Volume: vol, Time: time.Now()} + s.mu.Lock() + h := s.history[symbol] + h = append(h, pt) + if len(h) > 60 { h = h[len(h)-60:] } + s.history[symbol] = h + s.mu.Unlock() + + if len(h) < 5 { return } + + // Price breakout (>3% in 5 min) + old := h[len(h)-5] + pct := ((price - old.Price) / old.Price) * 100 + if math.Abs(pct) >= 3.0 { + sev := "warning" + if math.Abs(pct) >= 6.0 { sev = "critical" } + dir := "📈 拉升" + if pct < 0 { dir = "📉 下跌" } + s.emit(Signal{Type: SignalPriceBreakout, Symbol: symbol, Severity: sev, + Title: fmt.Sprintf("%s %s %.1f%%", symbol, dir, math.Abs(pct)), + Detail: fmt.Sprintf("5min: $%.2f → $%.2f (24h: %.1f%%)", old.Price, price, chg), + Price: price, Change: pct}) + } + + // Volume spike (>3x avg) + if len(h) >= 10 { + var avg float64 + for i := 0; i < len(h)-1; i++ { avg += h[i].Volume } + avg /= float64(len(h) - 1) + if avg > 0 && vol > avg*3 { + s.emit(Signal{Type: SignalVolumeSpike, Symbol: symbol, Severity: "warning", + Title: fmt.Sprintf("%s 成交量异常 %.1fx", symbol, vol/avg), + Detail: fmt.Sprintf("Price: $%.2f (24h: %.1f%%)", price, chg), + Price: price, Change: chg}) + } + } +} + +func (s *Sentinel) emit(sig Signal) { + s.logger.Info("signal", "type", sig.Type, "symbol", sig.Symbol, "title", sig.Title) + if s.onSignal != nil { s.onSignal(sig) } +} diff --git a/agent/skill_catalog.go b/agent/skill_catalog.go new file mode 100644 index 00000000..069c4f85 --- /dev/null +++ b/agent/skill_catalog.go @@ -0,0 +1,97 @@ +package agent + +func skillCatalogPrompt(lang string) string { + if lang == "zh" { + return `## 多轮与 Skill-First 工作模式 +- 对于高频已知任务，优先按 skill 执行，不要每次从零规划 +- 如果用户仍在同一任务里，继续当前 flow，不要重新路由 +- 只追问继续执行所需的最少必要字段，不要让用户重复已确认信息 +- 高风险动作（删除、启动实盘、停止运行中 trader、覆盖关键配置）必须单独确认 +- 对诊断类问题，优先做“问题归类 -> 可能原因 -> 核查项 -> 下一步建议” + +## 当前重点技能 +### 1. 模型配置与诊断 +- ` + "`skill_model_api_setup`" + `：用户问某个大模型的 API key 去哪申请、base URL 怎么填、model name 怎么填时，给步骤化指导 +- ` + "`skill_model_config_diagnosis`" + `：当用户遇到模型配置失败、调用失败、保存后不可用时，优先检查： + 1. 是否已启用模型 + 2. API Key 是否为空 + 3. custom_api_url 是否为合法 HTTPS 地址 + 4. custom_model_name 是否为空或填错 + 5. 保存后是否需要重新加载 trader +- 已知事实： + - 系统会拒绝非 HTTPS 的 custom_api_url + - 已启用模型如果缺少 API Key 或 custom_api_url，会导致 agent 不可用 + +### 2. 交易所配置与诊断 +- ` + "`skill_exchange_api_setup`" + `：指导用户创建交易所 API，明确需要哪些权限、哪些权限不要开、哪些交易所需要额外字段 +- ` + "`skill_exchange_api_diagnosis`" + `：用户遇到 invalid signature、timestamp、permission denied、IP not allowed 时，优先排查： + 1. 系统时间是否同步 + 2. API Key / Secret 是否填反或过期 + 3. IP 白名单是否包含服务器 IP + 4. 是否启用了合约/交易权限 + 5. OKX 是否遗漏 passphrase +- 已知事实： + - OKX 除 API Key 和 Secret 外还需要 passphrase + - invalid signature / timestamp 常见根因是时间不同步或密钥不匹配 + +### 3. Trader 启动与运行诊断 +- ` + "`skill_trader_start_diagnosis`" + `：当用户说 trader 启动不了、启动后不交易、没有持仓、没有决策时，优先排查： + 1. 是否存在可用且启用的模型配置 + 2. 是否存在可用且启用的交易所配置 + 3. trader 绑定的 strategy / exchange / model 是否齐全 + 4. 账户余额和权限是否满足下单要求 + 5. AI 是否一直返回 wait / hold +- 如果用户问“为什么没有开仓”，要明确区分： + - 系统没启动 + - 启动了但 AI 决策为 wait + - 有信号但下单失败 + +### 4. 交易行为异常诊断 +- ` + "`skill_order_execution_diagnosis`" + `：当用户问仓位开不出来、只开单边、杠杆报错时，优先排查： + 1. 是否为交易所模式问题（例如 Binance One-way / Hedge Mode） + 2. 是否为子账户杠杆限制 + 3. 是否为合约权限或 symbol 不可交易 + 4. 是否为余额不足或保证金占用过高 +- 已知事实： + - Binance 若不是 Hedge Mode，可能出现 position side mismatch 或只开单边 + - 某些子账户杠杆受限，超过限制会直接报错 + +### 5. 策略与提示词诊断 +- ` + "`skill_strategy_diagnosis`" + `：当用户说策略没生效、提示词不对、预览和实际不一致时，优先建议： + 1. 查看当前 strategy 配置 + 2. 区分策略模板本身和 trader 上的 custom prompt + 3. 必要时预览 prompt 或读取当前保存值后再判断 + +## 回答格式要求 +- 诊断类问题尽量按“现象 / 原因 / 先检查什么 / 怎么修复”回答 +- 配置指导类问题尽量按步骤回答 +- 如果已有工具能验证当前状态，先查再下结论 +- 如果结论是推测，必须明确说是“更可能”或“优先怀疑”` + } + + return `## Multi-turn and Skill-First Operating Mode +- For high-frequency known tasks, prefer stable skills instead of replanning from scratch +- If the user is still in the same task, continue the active flow +- Ask only for the minimum missing fields required to proceed +- Require explicit confirmation for destructive or financially sensitive actions +- For diagnostic requests, use: issue class -> likely causes -> checks -> next steps + +## Priority Skills +- skill_model_api_setup / skill_model_config_diagnosis +- skill_exchange_api_setup / skill_exchange_api_diagnosis +- skill_trader_start_diagnosis +- skill_order_execution_diagnosis +- skill_strategy_diagnosis + +Known facts: +- custom_api_url must be a valid HTTPS URL +- OKX requires passphrase in addition to API key and secret +- invalid signature / timestamp often means clock skew or mismatched credentials +- missing enabled model or exchange config can block trader startup +- Binance position-side issues are often caused by One-way Mode vs Hedge Mode + +Response style: +- Diagnostics: symptom -> cause -> checks -> fix +- Setup guidance: step-by-step +- Verify with tools when possible before concluding` +} diff --git a/agent/skill_catalog_test.go b/agent/skill_catalog_test.go new file mode 100644 index 00000000..36d96fbe --- /dev/null +++ b/agent/skill_catalog_test.go @@ -0,0 +1,35 @@ +package agent + +import ( + "log/slog" + "strings" + "testing" +) + +func TestSkillCatalogPromptZHIncludesDiagnosisSkills(t *testing.T) { + got := skillCatalogPrompt("zh") + for _, want := range []string{ + "多轮与 Skill-First 工作模式", + "skill_model_config_diagnosis", + "skill_exchange_api_diagnosis", + "skill_trader_start_diagnosis", + } { + if !strings.Contains(got, want) { + t.Fatalf("skillCatalogPrompt(zh) missing %q\n%s", want, got) + } + } +} + +func TestBuildSystemPromptIncludesSkillCatalog(t *testing.T) { + a := New(nil, nil, DefaultConfig(), slog.Default()) + got := a.buildSystemPrompt("zh") + for _, want := range []string{ + "多轮与 Skill-First 工作模式", + "skill_exchange_api_setup", + "skill_order_execution_diagnosis", + } { + if !strings.Contains(got, want) { + t.Fatalf("buildSystemPrompt(zh) missing %q", want) + } + } +} diff --git a/agent/skill_dag.go b/agent/skill_dag.go new file mode 100644 index 00000000..ad026115 --- /dev/null +++ b/agent/skill_dag.go @@ -0,0 +1,277 @@ +package agent + +import "strings" + +type SkillDAG struct { + SkillName string + Action string + Steps []SkillDAGStep +} + +type SkillDAGStep struct { + ID string + Kind string + RequiredFields []string + OptionalFields []string + Next []string + Terminal bool +} + +var skillDAGRegistry = buildSkillDAGRegistry() + +func buildSkillDAGRegistry() map[string]SkillDAG { + dags := []SkillDAG{ + { + SkillName: "trader_management", + Action: "create", + Steps: []SkillDAGStep{ + {ID: "resolve_name", Kind: "collect_slot", RequiredFields: []string{"name"}, Next: []string{"resolve_exchange"}}, + {ID: "resolve_exchange", Kind: "collect_slot", RequiredFields: []string{"exchange_id"}, OptionalFields: []string{"exchange_name"}, Next: []string{"resolve_model"}}, + {ID: "resolve_model", Kind: "collect_slot", RequiredFields: []string{"model_id"}, OptionalFields: []string{"model_name"}, Next: []string{"resolve_strategy"}}, + {ID: "resolve_strategy", Kind: "collect_slot", RequiredFields: []string{"strategy_id"}, OptionalFields: []string{"strategy_name"}, Next: []string{"maybe_confirm_start"}}, + {ID: "maybe_confirm_start", Kind: "branch", OptionalFields: []string{"auto_start"}, Next: []string{"await_start_confirmation", "execute_create_only"}}, + {ID: "await_start_confirmation", Kind: "confirm", RequiredFields: []string{"auto_start"}, Next: []string{"execute_create_and_start", "execute_create_only"}}, + {ID: "execute_create_only", Kind: "execute", RequiredFields: []string{"name", "exchange_id", "model_id", "strategy_id"}, Terminal: true}, + {ID: "execute_create_and_start", Kind: "execute", RequiredFields: []string{"name", "exchange_id", "model_id", "strategy_id"}, OptionalFields: []string{"auto_start"}, Terminal: true}, + }, + }, + { + SkillName: "trader_management", + Action: "update_name", + Steps: []SkillDAGStep{ + {ID: "resolve_target", Kind: "resolve_target", RequiredFields: []string{"target_ref"}, Next: []string{"collect_name"}}, + {ID: "collect_name", Kind: "collect_slot", RequiredFields: []string{"name"}, Next: []string{"execute_update"}}, + {ID: "execute_update", Kind: "execute", RequiredFields: []string{"target_ref", "name"}, Terminal: true}, + }, + }, + { + SkillName: "trader_management", + Action: "update_bindings", + Steps: []SkillDAGStep{ + {ID: "resolve_target", Kind: "resolve_target", RequiredFields: []string{"target_ref"}, Next: []string{"collect_bindings"}}, + {ID: "collect_bindings", Kind: "collect_slot", RequiredFields: []string{"binding_update"}, OptionalFields: []string{"ai_model_id", "exchange_id", "strategy_id"}, Next: []string{"execute_update"}}, + {ID: "execute_update", Kind: "execute", RequiredFields: []string{"target_ref", "binding_update"}, OptionalFields: []string{"ai_model_id", "exchange_id", "strategy_id"}, Terminal: true}, + }, + }, + { + SkillName: "trader_management", + Action: "start", + Steps: []SkillDAGStep{ + {ID: "resolve_target", Kind: "resolve_target", RequiredFields: []string{"target_ref"}, Next: []string{"await_confirmation"}}, + {ID: "await_confirmation", Kind: "confirm", RequiredFields: []string{"target_ref"}, Next: []string{"execute_start"}}, + {ID: "execute_start", Kind: "execute", RequiredFields: []string{"target_ref"}, Terminal: true}, + }, + }, + { + SkillName: "trader_management", + Action: "stop", + Steps: []SkillDAGStep{ + {ID: "resolve_target", Kind: "resolve_target", RequiredFields: []string{"target_ref"}, Next: []string{"await_confirmation"}}, + {ID: "await_confirmation", Kind: "confirm", RequiredFields: []string{"target_ref"}, Next: []string{"execute_stop"}}, + {ID: "execute_stop", Kind: "execute", RequiredFields: []string{"target_ref"}, Terminal: true}, + }, + }, + { + SkillName: "trader_management", + Action: "delete", + Steps: []SkillDAGStep{ + {ID: "resolve_target", Kind: "resolve_target", RequiredFields: []string{"target_ref"}, Next: []string{"await_confirmation"}}, + {ID: "await_confirmation", Kind: "confirm", RequiredFields: []string{"target_ref"}, Next: []string{"execute_delete"}}, + {ID: "execute_delete", Kind: "execute", RequiredFields: []string{"target_ref"}, Terminal: true}, + }, + }, + { + SkillName: "strategy_management", + Action: "create", + Steps: []SkillDAGStep{ + {ID: "resolve_name", Kind: "collect_slot", RequiredFields: []string{"name"}, OptionalFields: []string{"lang", "description", "config"}, Next: []string{"execute_create"}}, + {ID: "execute_create", Kind: "execute", RequiredFields: []string{"name"}, OptionalFields: []string{"lang", "description", "config"}, Terminal: true}, + }, + }, + { + SkillName: "strategy_management", + Action: "update_name", + Steps: []SkillDAGStep{ + {ID: "resolve_target", Kind: "resolve_target", RequiredFields: []string{"target_ref"}, Next: []string{"collect_name"}}, + {ID: "collect_name", Kind: "collect_slot", RequiredFields: []string{"name"}, Next: []string{"execute_update"}}, + {ID: "execute_update", Kind: "execute", RequiredFields: []string{"target_ref", "name"}, Terminal: true}, + }, + }, + { + SkillName: "strategy_management", + Action: "update_prompt", + Steps: []SkillDAGStep{ + {ID: "resolve_target", Kind: "resolve_target", RequiredFields: []string{"target_ref"}, Next: []string{"collect_prompt"}}, + {ID: "collect_prompt", Kind: "collect_slot", RequiredFields: []string{"prompt"}, Next: []string{"load_config"}}, + {ID: "load_config", Kind: "load_state", RequiredFields: []string{"target_ref"}, Next: []string{"execute_update"}}, + {ID: "execute_update", Kind: "execute", RequiredFields: []string{"target_ref", "prompt"}, Terminal: true}, + }, + }, + { + SkillName: "strategy_management", + Action: "update_config", + Steps: []SkillDAGStep{ + {ID: "resolve_target", Kind: "resolve_target", RequiredFields: []string{"target_ref"}, Next: []string{"resolve_config_field"}}, + {ID: "resolve_config_field", Kind: "collect_slot", RequiredFields: []string{"config_field"}, Next: []string{"resolve_config_value"}}, + {ID: "resolve_config_value", Kind: "collect_slot", RequiredFields: []string{"config_value"}, Next: []string{"load_config"}}, + {ID: "load_config", Kind: "load_state", RequiredFields: []string{"target_ref"}, Next: []string{"apply_field_update"}}, + {ID: "apply_field_update", Kind: "transform", RequiredFields: []string{"config_field", "config_value"}, Next: []string{"execute_update"}}, + {ID: "execute_update", Kind: "execute", RequiredFields: []string{"target_ref", "config_field", "config_value"}, Terminal: true}, + }, + }, + { + SkillName: "strategy_management", + Action: "duplicate", + Steps: []SkillDAGStep{ + {ID: "resolve_target", Kind: "resolve_target", RequiredFields: []string{"target_ref"}, Next: []string{"collect_name"}}, + {ID: "collect_name", Kind: "collect_slot", RequiredFields: []string{"name"}, Next: []string{"execute_duplicate"}}, + {ID: "execute_duplicate", Kind: "execute", RequiredFields: []string{"target_ref", "name"}, Terminal: true}, + }, + }, + { + SkillName: "strategy_management", + Action: "activate", + Steps: []SkillDAGStep{ + {ID: "resolve_target", Kind: "resolve_target", RequiredFields: []string{"target_ref"}, Next: []string{"execute_activate"}}, + {ID: "execute_activate", Kind: "execute", RequiredFields: []string{"target_ref"}, Terminal: true}, + }, + }, + { + SkillName: "strategy_management", + Action: "delete", + Steps: []SkillDAGStep{ + {ID: "resolve_target", Kind: "resolve_target", RequiredFields: []string{"target_ref"}, Next: []string{"await_confirmation"}}, + {ID: "await_confirmation", Kind: "confirm", RequiredFields: []string{"target_ref"}, Next: []string{"execute_delete"}}, + {ID: "execute_delete", Kind: "execute", RequiredFields: []string{"target_ref"}, Terminal: true}, + }, + }, + { + SkillName: "model_management", + Action: "create", + Steps: []SkillDAGStep{ + {ID: "resolve_provider", Kind: "collect_slot", RequiredFields: []string{"provider"}, Next: []string{"collect_optional_fields"}}, + {ID: "collect_optional_fields", Kind: "collect_slot", OptionalFields: []string{"name", "custom_api_url", "custom_model_name"}, Next: []string{"execute_create"}}, + {ID: "execute_create", Kind: "execute", RequiredFields: []string{"provider"}, OptionalFields: []string{"name", "custom_api_url", "custom_model_name"}, Terminal: true}, + }, + }, + { + SkillName: "model_management", + Action: "update_status", + Steps: []SkillDAGStep{ + {ID: "resolve_target", Kind: "resolve_target", RequiredFields: []string{"target_ref"}, Next: []string{"collect_enabled"}}, + {ID: "collect_enabled", Kind: "collect_slot", RequiredFields: []string{"enabled"}, Next: []string{"execute_update"}}, + {ID: "execute_update", Kind: "execute", RequiredFields: []string{"target_ref", "enabled"}, Terminal: true}, + }, + }, + { + SkillName: "model_management", + Action: "update_endpoint", + Steps: []SkillDAGStep{ + {ID: "resolve_target", Kind: "resolve_target", RequiredFields: []string{"target_ref"}, Next: []string{"collect_custom_api_url"}}, + {ID: "collect_custom_api_url", Kind: "collect_slot", RequiredFields: []string{"custom_api_url"}, Next: []string{"execute_update"}}, + {ID: "execute_update", Kind: "execute", RequiredFields: []string{"target_ref", "custom_api_url"}, Terminal: true}, + }, + }, + { + SkillName: "model_management", + Action: "update_name", + Steps: []SkillDAGStep{ + {ID: "resolve_target", Kind: "resolve_target", RequiredFields: []string{"target_ref"}, Next: []string{"collect_custom_model_name"}}, + {ID: "collect_custom_model_name", Kind: "collect_slot", RequiredFields: []string{"custom_model_name"}, Next: []string{"execute_update"}}, + {ID: "execute_update", Kind: "execute", RequiredFields: []string{"target_ref", "custom_model_name"}, Terminal: true}, + }, + }, + { + SkillName: "model_management", + Action: "delete", + Steps: []SkillDAGStep{ + {ID: "resolve_target", Kind: "resolve_target", RequiredFields: []string{"target_ref"}, Next: []string{"await_confirmation"}}, + {ID: "await_confirmation", Kind: "confirm", RequiredFields: []string{"target_ref"}, Next: []string{"execute_delete"}}, + {ID: "execute_delete", Kind: "execute", RequiredFields: []string{"target_ref"}, Terminal: true}, + }, + }, + { + SkillName: "exchange_management", + Action: "create", + Steps: []SkillDAGStep{ + {ID: "resolve_exchange_type", Kind: "collect_slot", RequiredFields: []string{"exchange_type"}, Next: []string{"collect_account_name"}}, + {ID: "collect_account_name", Kind: "collect_slot", OptionalFields: []string{"account_name"}, Next: []string{"execute_create"}}, + {ID: "execute_create", Kind: "execute", RequiredFields: []string{"exchange_type"}, OptionalFields: []string{"account_name"}, Terminal: true}, + }, + }, + { + SkillName: "exchange_management", + Action: "update_name", + Steps: []SkillDAGStep{ + {ID: "resolve_target", Kind: "resolve_target", RequiredFields: []string{"target_ref"}, Next: []string{"collect_account_name"}}, + {ID: "collect_account_name", Kind: "collect_slot", RequiredFields: []string{"account_name"}, Next: []string{"execute_update"}}, + {ID: "execute_update", Kind: "execute", RequiredFields: []string{"target_ref", "account_name"}, Terminal: true}, + }, + }, + { + SkillName: "exchange_management", + Action: "update_status", + Steps: []SkillDAGStep{ + {ID: "resolve_target", Kind: "resolve_target", RequiredFields: []string{"target_ref"}, Next: []string{"collect_enabled"}}, + {ID: "collect_enabled", Kind: "collect_slot", RequiredFields: []string{"enabled"}, Next: []string{"execute_update"}}, + {ID: "execute_update", Kind: "execute", RequiredFields: []string{"target_ref", "enabled"}, Terminal: true}, + }, + }, + { + SkillName: "exchange_management", + Action: "delete", + Steps: []SkillDAGStep{ + {ID: "resolve_target", Kind: "resolve_target", RequiredFields: []string{"target_ref"}, Next: []string{"await_confirmation"}}, + {ID: "await_confirmation", Kind: "confirm", RequiredFields: []string{"target_ref"}, Next: []string{"execute_delete"}}, + {ID: "execute_delete", Kind: "execute", RequiredFields: []string{"target_ref"}, Terminal: true}, + }, + }, + } + + registry := make(map[string]SkillDAG, len(dags)) + for _, dag := range dags { + dag = normalizeSkillDAG(dag) + if dag.SkillName == "" || dag.Action == "" { + continue + } + registry[skillDAGKey(dag.SkillName, dag.Action)] = dag + } + return registry +} + +func normalizeSkillDAG(dag SkillDAG) SkillDAG { + dag.SkillName = strings.TrimSpace(dag.SkillName) + dag.Action = strings.TrimSpace(dag.Action) + steps := make([]SkillDAGStep, 0, len(dag.Steps)) + for _, step := range dag.Steps { + step.ID = strings.TrimSpace(step.ID) + step.Kind = strings.TrimSpace(step.Kind) + step.RequiredFields = cleanStringList(step.RequiredFields) + step.OptionalFields = cleanStringList(step.OptionalFields) + step.Next = cleanStringList(step.Next) + if step.ID == "" { + continue + } + steps = append(steps, step) + } + dag.Steps = steps + return dag +} + +func skillDAGKey(skillName, action string) string { + return strings.TrimSpace(skillName) + ":" + strings.TrimSpace(action) +} + +func getSkillDAG(skillName, action string) (SkillDAG, bool) { + dag, ok := skillDAGRegistry[skillDAGKey(skillName, action)] + return dag, ok +} + +func listSkillDAGs() []SkillDAG { + out := make([]SkillDAG, 0, len(skillDAGRegistry)) + for _, dag := range skillDAGRegistry { + out = append(out, dag) + } + return out +} + diff --git a/agent/skill_dag_runtime.go b/agent/skill_dag_runtime.go new file mode 100644 index 00000000..8178536c --- /dev/null +++ b/agent/skill_dag_runtime.go @@ -0,0 +1,51 @@ +package agent + +const skillDAGStepField = "_dag_step" + +func currentSkillDAGStep(session skillSession) (SkillDAGStep, bool) { + dag, ok := getSkillDAG(session.Name, session.Action) + if !ok || len(dag.Steps) == 0 { + return SkillDAGStep{}, false + } + stepID := fieldValue(session, skillDAGStepField) + if stepID == "" { + return dag.Steps[0], true + } + for _, step := range dag.Steps { + if step.ID == stepID { + return step, true + } + } + return dag.Steps[0], true +} + +func setSkillDAGStep(session *skillSession, stepID string) { + ensureSkillFields(session) + if stepID == "" { + delete(session.Fields, skillDAGStepField) + return + } + session.Fields[skillDAGStepField] = stepID +} + +func clearSkillDAGStep(session *skillSession) { + if session == nil || session.Fields == nil { + return + } + delete(session.Fields, skillDAGStepField) +} + +func advanceSkillDAGStep(session *skillSession, currentStepID string) { + dag, ok := getSkillDAG(session.Name, session.Action) + if !ok { + return + } + for _, step := range dag.Steps { + if step.ID != currentStepID || len(step.Next) == 0 { + continue + } + setSkillDAGStep(session, step.Next[0]) + return + } +} + diff --git a/agent/skill_dag_runtime_test.go b/agent/skill_dag_runtime_test.go new file mode 100644 index 00000000..8085ceee --- /dev/null +++ b/agent/skill_dag_runtime_test.go @@ -0,0 +1,27 @@ +package agent + +import "testing" + +func TestCurrentSkillDAGStepDefaultsToFirstStep(t *testing.T) { + session := skillSession{Name: "strategy_management", Action: "update_config"} + step, ok := currentSkillDAGStep(session) + if !ok { + t.Fatal("expected dag step") + } + if step.ID != "resolve_target" { + t.Fatalf("expected first step resolve_target, got %s", step.ID) + } +} + +func TestAdvanceSkillDAGStepMovesToNextStep(t *testing.T) { + session := skillSession{Name: "strategy_management", Action: "update_config"} + setSkillDAGStep(&session, "resolve_config_field") + advanceSkillDAGStep(&session, "resolve_config_field") + step, ok := currentSkillDAGStep(session) + if !ok { + t.Fatal("expected dag step") + } + if step.ID != "resolve_config_value" { + t.Fatalf("expected resolve_config_value, got %s", step.ID) + } +} diff --git a/agent/skill_dag_test.go b/agent/skill_dag_test.go new file mode 100644 index 00000000..73707474 --- /dev/null +++ b/agent/skill_dag_test.go @@ -0,0 +1,67 @@ +package agent + +import "testing" + +func TestGetSkillDAGForStructuredActions(t *testing.T) { + tests := []struct { + skill string + action string + }{ + {skill: "trader_management", action: "create"}, + {skill: "trader_management", action: "update_bindings"}, + {skill: "strategy_management", action: "update_config"}, + {skill: "strategy_management", action: "update_prompt"}, + {skill: "model_management", action: "update_status"}, + {skill: "exchange_management", action: "update_name"}, + } + + for _, tt := range tests { + dag, ok := getSkillDAG(tt.skill, tt.action) + if !ok { + t.Fatalf("expected DAG for %s/%s", tt.skill, tt.action) + } + if dag.SkillName != tt.skill || dag.Action != tt.action { + t.Fatalf("unexpected dag identity: %+v", dag) + } + if len(dag.Steps) == 0 { + t.Fatalf("expected DAG steps for %s/%s", tt.skill, tt.action) + } + } +} + +func TestStructuredDAGsHaveTerminalStep(t *testing.T) { + for _, dag := range listSkillDAGs() { + hasTerminal := false + for _, step := range dag.Steps { + if step.Terminal { + hasTerminal = true + break + } + } + if !hasTerminal { + t.Fatalf("expected terminal step for %s/%s", dag.SkillName, dag.Action) + } + } +} + +func TestStrategyUpdateConfigDAGMatchesCurrentAtomicFlow(t *testing.T) { + dag, ok := getSkillDAG("strategy_management", "update_config") + if !ok { + t.Fatal("missing strategy update_config dag") + } + if len(dag.Steps) != 6 { + t.Fatalf("expected 6 steps, got %d", len(dag.Steps)) + } + if dag.Steps[0].ID != "resolve_target" { + t.Fatalf("expected first step resolve_target, got %s", dag.Steps[0].ID) + } + if dag.Steps[1].ID != "resolve_config_field" { + t.Fatalf("expected second step resolve_config_field, got %s", dag.Steps[1].ID) + } + if dag.Steps[2].ID != "resolve_config_value" { + t.Fatalf("expected third step resolve_config_value, got %s", dag.Steps[2].ID) + } + if dag.Steps[5].ID != "execute_update" || !dag.Steps[5].Terminal { + t.Fatalf("expected final terminal execute step, got %+v", dag.Steps[5]) + } +} diff --git a/agent/skill_dispatcher.go b/agent/skill_dispatcher.go new file mode 100644 index 00000000..96c2a71f --- /dev/null +++ b/agent/skill_dispatcher.go @@ -0,0 +1,1127 @@ +package agent + +import ( + "context" + "encoding/json" + "fmt" + "regexp" + "strings" + "time" +) + +type skillSession struct { + Name string `json:"name,omitempty"` + Action string `json:"action,omitempty"` + Phase string `json:"phase,omitempty"` + TargetRef *EntityReference `json:"target_ref,omitempty"` + Fields map[string]string `json:"fields,omitempty"` + Slots *createTraderSkillSlots `json:"slots,omitempty"` + UpdatedAt string `json:"updated_at,omitempty"` +} + +type createTraderSkillSlots struct { + Name string `json:"name,omitempty"` + ExchangeID string `json:"exchange_id,omitempty"` + ExchangeName string `json:"exchange_name,omitempty"` + ModelID string `json:"model_id,omitempty"` + ModelName string `json:"model_name,omitempty"` + StrategyID string `json:"strategy_id,omitempty"` + StrategyName string `json:"strategy_name,omitempty"` + AutoStart *bool `json:"auto_start,omitempty"` +} + +type traderSkillOption struct { + ID string + Name string + Enabled bool +} + +var ( + quotedNamePattern = regexp.MustCompile(`[“"]([^“”"]{1,40})[”"]`) + traderNamedPattern = regexp.MustCompile(`(?:叫|名为|名字是)\s*([A-Za-z0-9_\-\p{Han}]{2,40})`) +) + +func skillSessionConfigKey(userID int64) string { + return fmt.Sprintf("agent_skill_session_%d", userID) +} + +func normalizeSkillSession(session skillSession) skillSession { + session.Name = strings.TrimSpace(session.Name) + session.Action = strings.TrimSpace(session.Action) + session.Phase = strings.TrimSpace(session.Phase) + session.TargetRef = normalizeEntityReference(session.TargetRef) + if len(session.Fields) > 0 { + normalized := make(map[string]string, len(session.Fields)) + for key, value := range session.Fields { + key = strings.TrimSpace(key) + value = strings.TrimSpace(value) + if key == "" || value == "" { + continue + } + normalized[key] = value + } + if len(normalized) > 0 { + session.Fields = normalized + } else { + session.Fields = nil + } + } + if session.Slots != nil { + session.Slots.Name = strings.TrimSpace(session.Slots.Name) + session.Slots.ExchangeID = strings.TrimSpace(session.Slots.ExchangeID) + session.Slots.ExchangeName = strings.TrimSpace(session.Slots.ExchangeName) + session.Slots.ModelID = strings.TrimSpace(session.Slots.ModelID) + session.Slots.ModelName = strings.TrimSpace(session.Slots.ModelName) + session.Slots.StrategyID = strings.TrimSpace(session.Slots.StrategyID) + session.Slots.StrategyName = strings.TrimSpace(session.Slots.StrategyName) + if session.Slots.Name == "" && + session.Slots.ExchangeID == "" && + session.Slots.ModelID == "" && + session.Slots.StrategyID == "" && + session.Slots.AutoStart == nil { + session.Slots = nil + } + } + if session.Name == "" { + return skillSession{} + } + if session.UpdatedAt == "" { + session.UpdatedAt = time.Now().UTC().Format(time.RFC3339) + } + return session +} + +func (a *Agent) getSkillSession(userID int64) skillSession { + if a.store == nil { + return skillSession{} + } + raw, err := a.store.GetSystemConfig(skillSessionConfigKey(userID)) + if err != nil || strings.TrimSpace(raw) == "" { + return skillSession{} + } + var session skillSession + if err := json.Unmarshal([]byte(raw), &session); err != nil { + return skillSession{} + } + return normalizeSkillSession(session) +} + +func (a *Agent) saveSkillSession(userID int64, session skillSession) { + if a.store == nil { + return + } + session = normalizeSkillSession(session) + if session.Name == "" { + _ = a.store.SetSystemConfig(skillSessionConfigKey(userID), "") + return + } + data, err := json.Marshal(session) + if err != nil { + return + } + _ = a.store.SetSystemConfig(skillSessionConfigKey(userID), string(data)) +} + +func (a *Agent) clearSkillSession(userID int64) { + if a.store == nil { + return + } + _ = a.store.SetSystemConfig(skillSessionConfigKey(userID), "") +} + +func isYesReply(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + for _, candidate := range []string{"是", "好", "好的", "确认", "确认启动", "确认创建", "要", "启动", "开始", "yes", "y", "ok", "confirm", "go ahead"} { + if lower == candidate { + return true + } + } + return false +} + +func isNoReply(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + for _, candidate := range []string{"不", "不用", "先不用", "取消", "不要", "no", "n", "cancel", "stop"} { + if lower == candidate { + return true + } + } + return false +} + +func isCancelSkillReply(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + switch lower { + case "取消", "/cancel", "cancel", "不改", "先不改", "算了", "先不用", "不用了", "不弄了", "不搞了", "换话题", "换话题了", "聊别的", "先聊别的": + return true + default: + return false + } +} + +func detectCreateTraderSkill(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + hasCreate := containsAny(lower, []string{"创建", "新建", "建一个", "create", "new"}) + hasTrader := containsAny(lower, []string{"交易员", "trader", "agent"}) + return hasCreate && hasTrader +} + +func detectModelDiagnosisSkill(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + if containsAny(lower, []string{"custom_api_url", "invalid custom_api_url", "ai assistant unavailable", "模型配置失败", "模型不可用", "ai unavailable"}) { + return true + } + return containsAny(lower, []string{"模型", "model", "api key", "base url", "custom_api_url"}) && + containsAny(lower, []string{"报错", "错误", "失败", "不可用", "不生效", "invalid", "error", "failed"}) +} + +func detectExchangeDiagnosisSkill(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + return containsAny(lower, []string{ + "invalid signature", "timestamp", "ip not allowed", "permission denied", + "签名错误", "签名失败", "时间戳", "白名单", "权限不足", "交易所 api 报错", "交易所连接不上", + }) +} + +func detectStartIntent(text string) bool { + lower := strings.ToLower(text) + return containsAny(lower, []string{"启动", "跑起来", "run", "start", "立即运行", "并启动"}) +} + +func looksLikeStandaloneValueReply(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + if firstIntegerPattern.MatchString(lower) && len(strings.Fields(lower)) <= 4 { + return true + } + return containsAny(lower, []string{"启用", "禁用", "enable", "disable", "打开", "关闭"}) +} + +func detectImplicitStrategyAction(text string) string { + lower := strings.ToLower(strings.TrimSpace(text)) + switch { + case containsAny(lower, []string{"prompt", "提示词"}): + return "update_prompt" + case containsAny(lower, []string{"参数", "配置", "置信度", "持仓", "周期", "timeframe", "调到", "改到", "改成", "调整"}): + return "update_config" + default: + return "" + } +} + +func detectImplicitTraderAction(text string) string { + lower := strings.ToLower(strings.TrimSpace(text)) + switch { + case containsAny(lower, []string{"启动", "开始", "run", "start"}): + return "start" + case containsAny(lower, []string{"停止", "停掉", "stop", "pause"}): + return "stop" + case containsAny(lower, []string{"换模型", "换交易所", "换策略", "绑定", "切换模型", "切换交易所", "切换策略"}): + return "update_bindings" + case containsAny(lower, []string{"改名", "重命名", "rename"}): + return "update_name" + default: + return "" + } +} + +func detectImplicitModelAction(text string) string { + lower := strings.ToLower(strings.TrimSpace(text)) + switch { + case containsAny(lower, []string{"启用", "禁用", "enable", "disable"}): + return "update_status" + case containsAny(lower, []string{"url", "endpoint", "地址", "接口"}): + return "update_endpoint" + case containsAny(lower, []string{"模型名", "模型名称", "model name", "改名", "重命名", "rename"}): + return "update_name" + default: + return "" + } +} + +func detectImplicitExchangeAction(text string) string { + lower := strings.ToLower(strings.TrimSpace(text)) + switch { + case containsAny(lower, []string{"启用", "禁用", "enable", "disable"}): + return "update_status" + case containsAny(lower, []string{"账户名", "改名", "重命名", "rename"}): + return "update_name" + default: + return "" + } +} + +func (a *Agent) inferContextualSkillSession(storeUserID string, userID int64, text string, session skillSession) skillSession { + if session.Name != "" || strings.TrimSpace(text) == "" { + return session + } + state := a.getExecutionState(userID) + lower := strings.ToLower(strings.TrimSpace(text)) + if state.CurrentReferences != nil { + if ref := state.CurrentReferences.Strategy; ref != nil { + if action := detectImplicitStrategyAction(text); action != "" || looksLikeStandaloneValueReply(text) { + return skillSession{Name: "strategy_management", Action: defaultIfEmpty(action, "update_config"), Phase: "collecting", TargetRef: ref} + } + } + if ref := state.CurrentReferences.Trader; ref != nil { + if action := detectImplicitTraderAction(text); action != "" { + return skillSession{Name: "trader_management", Action: action, Phase: "collecting", TargetRef: ref} + } + } + if ref := state.CurrentReferences.Model; ref != nil { + if action := detectImplicitModelAction(text); action != "" { + return skillSession{Name: "model_management", Action: action, Phase: "collecting", TargetRef: ref} + } + } + if ref := state.CurrentReferences.Exchange; ref != nil { + if action := detectImplicitExchangeAction(text); action != "" { + return skillSession{Name: "exchange_management", Action: action, Phase: "collecting", TargetRef: ref} + } + } + } + if containsAny(lower, []string{"调整参数", "改参数", "改配置"}) { + options := a.loadStrategyOptions(storeUserID) + if len(options) == 1 { + return skillSession{ + Name: "strategy_management", + Action: "update_config", + Phase: "collecting", + TargetRef: &EntityReference{ + ID: options[0].ID, + Name: options[0].Name, + }, + } + } + } + return session +} + +func extractTraderName(text string) string { + text = strings.TrimSpace(text) + if text == "" { + return "" + } + if matches := quotedNamePattern.FindStringSubmatch(text); len(matches) == 2 { + return strings.TrimSpace(matches[1]) + } + if matches := traderNamedPattern.FindStringSubmatch(text); len(matches) == 2 { + return strings.TrimSpace(matches[1]) + } + return "" +} + +func extractSegmentAfterKeywords(text string, keywords []string) string { + trimmed := strings.TrimSpace(text) + if trimmed == "" { + return "" + } + lower := strings.ToLower(trimmed) + for _, keyword := range keywords { + idx := strings.Index(lower, strings.ToLower(keyword)) + if idx < 0 { + continue + } + segment := strings.TrimSpace(trimmed[idx+len(keyword):]) + if segment == "" { + continue + } + cut := len(segment) + for i, r := range segment { + switch r { + case '，', ',', '。', '；', ';', '\n', '、': + cut = i + goto done + } + } + done: + segment = strings.TrimSpace(segment[:cut]) + segment = strings.Trim(segment, "“”\"'：: ") + if segment != "" { + return segment + } + } + return "" +} + +func pickMentionedOption(text string, options []traderSkillOption) *traderSkillOption { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return nil + } + bestScore := 0 + var matched *traderSkillOption + for _, option := range options { + id := strings.ToLower(strings.TrimSpace(option.ID)) + name := strings.ToLower(strings.TrimSpace(option.Name)) + if id == "" && name == "" { + continue + } + score := optionMatchScore(lower, id, name) + if score == 0 { + continue + } + if score == bestScore { + matched = nil + continue + } + if score > bestScore { + bestScore = score + copy := option + matched = © + } + } + return matched +} + +func pickOptionFromSegment(text string, keywords []string, options []traderSkillOption) *traderSkillOption { + segment := extractSegmentAfterKeywords(text, keywords) + if strings.TrimSpace(segment) == "" { + return nil + } + return pickMentionedOption(segment, options) +} + +func optionMatchScore(text, id, name string) int { + if id != "" && strings.Contains(text, id) { + return 4 + } + return optionNameMatchScore(text, name) +} + +func optionNameMatchScore(text, name string) int { + name = strings.TrimSpace(strings.ToLower(name)) + if name == "" { + return 0 + } + if strings.Contains(text, name) { + return 3 + } + fields := strings.FieldsFunc(name, func(r rune) bool { + switch r { + case ' ', ',', '，', '/', '|', '、', '(', ')', '（', '）': + return true + default: + return false + } + }) + best := 0 + for _, field := range fields { + field = strings.TrimSpace(field) + if field == "" { + continue + } + if len([]rune(field)) <= 2 && !containsHan(field) { + continue + } + if strings.Contains(text, field) { + if containsHan(field) && len([]rune(field)) >= 3 { + best = max(best, 2) + } else { + best = max(best, 1) + } + } + } + return best +} + +func containsHan(s string) bool { + for _, r := range s { + if r >= 0x4E00 && r <= 0x9FFF { + return true + } + } + return false +} + +func max(a, b int) int { + if a > b { + return a + } + return b +} + +func choosePreferredOption(options []traderSkillOption) *traderSkillOption { + if len(options) == 1 { + copy := options[0] + return © + } + enabled := make([]traderSkillOption, 0, len(options)) + for _, option := range options { + if option.Enabled { + enabled = append(enabled, option) + } + } + if len(enabled) == 1 { + copy := enabled[0] + return © + } + return nil +} + +func formatOptionList(prefix string, options []traderSkillOption) string { + parts := make([]string, 0, len(options)) + for _, option := range options { + label := option.Name + if label == "" { + label = option.ID + } + if option.Enabled { + label += "（已启用）" + } else { + label += "（已禁用）" + } + parts = append(parts, label) + } + if len(parts) == 0 { + return "" + } + return prefix + strings.Join(parts, "、") +} + +func parseSkillError(raw string) string { + var payload map[string]any + if err := json.Unmarshal([]byte(raw), &payload); err == nil { + if msg, _ := payload["error"].(string); strings.TrimSpace(msg) != "" { + return strings.TrimSpace(msg) + } + } + return strings.TrimSpace(raw) +} + +func (a *Agent) loadEnabledModelOptions(storeUserID string) []traderSkillOption { + if a.store == nil { + return nil + } + models, err := a.store.AIModel().List(storeUserID) + if err != nil { + return nil + } + out := make([]traderSkillOption, 0, len(models)) + for _, model := range models { + parts := cleanStringList([]string{ + strings.TrimSpace(model.Name), + strings.TrimSpace(model.CustomModelName), + strings.TrimSpace(model.Provider), + }) + name := strings.Join(parts, " ") + out = append(out, traderSkillOption{ID: model.ID, Name: name, Enabled: model.Enabled}) + } + return out +} + +func (a *Agent) loadExchangeOptions(storeUserID string) []traderSkillOption { + if a.store == nil { + return nil + } + exchanges, err := a.store.Exchange().List(storeUserID) + if err != nil { + return nil + } + out := make([]traderSkillOption, 0, len(exchanges)) + for _, exchange := range exchanges { + name := strings.TrimSpace(exchange.AccountName) + if name == "" { + name = strings.TrimSpace(exchange.ExchangeType) + } + out = append(out, traderSkillOption{ID: exchange.ID, Name: name, Enabled: exchange.Enabled}) + } + return out +} + +func (a *Agent) loadStrategyOptions(storeUserID string) []traderSkillOption { + if a.store == nil { + return nil + } + strategies, err := a.store.Strategy().List(storeUserID) + if err != nil { + return nil + } + out := make([]traderSkillOption, 0, len(strategies)) + for _, strategy := range strategies { + out = append(out, traderSkillOption{ID: strategy.ID, Name: strategy.Name, Enabled: true}) + } + return out +} + +func (a *Agent) tryHardSkill(ctx context.Context, storeUserID string, userID int64, lang, text string, onEvent func(event, data string)) (string, bool) { + if ctx != nil && ctx.Err() != nil { + return "", false + } + session := a.getSkillSession(userID) + session = a.inferContextualSkillSession(storeUserID, userID, text, session) + if (session.Name == "trader_management" && session.Action == "create") || detectCreateTraderSkill(text) { + answer, handled := a.handleCreateTraderSkill(storeUserID, userID, lang, text, session) + if handled { + a.recordSkillInteraction(userID, text, answer) + if onEvent != nil { + onEvent(StreamEventTool, "hard_skill:trader_management:create") + onEvent(StreamEventDelta, answer) + } + } + return answer, handled + } + if (session.Name == "trader_management" && session.Action != "create") || detectTraderManagementIntent(text) { + answer, handled := a.handleTraderManagementSkill(storeUserID, userID, lang, text, session) + if handled { + a.recordSkillInteraction(userID, text, answer) + if onEvent != nil { + onEvent(StreamEventTool, "hard_skill:trader_management") + onEvent(StreamEventDelta, answer) + } + } + return answer, handled + } + if session.Name == "exchange_management" || detectExchangeManagementIntent(text) { + answer, handled := a.handleExchangeManagementSkill(storeUserID, userID, lang, text, session) + if handled { + a.recordSkillInteraction(userID, text, answer) + if onEvent != nil { + onEvent(StreamEventTool, "hard_skill:exchange_management") + onEvent(StreamEventDelta, answer) + } + } + return answer, handled + } + if session.Name == "model_management" || detectModelManagementIntent(text) { + answer, handled := a.handleModelManagementSkill(storeUserID, userID, lang, text, session) + if handled { + a.recordSkillInteraction(userID, text, answer) + if onEvent != nil { + onEvent(StreamEventTool, "hard_skill:model_management") + onEvent(StreamEventDelta, answer) + } + } + return answer, handled + } + if session.Name == "strategy_management" || detectStrategyManagementIntent(text) { + answer, handled := a.handleStrategyManagementSkill(storeUserID, userID, lang, text, session) + if handled { + a.recordSkillInteraction(userID, text, answer) + if onEvent != nil { + onEvent(StreamEventTool, "hard_skill:strategy_management") + onEvent(StreamEventDelta, answer) + } + } + return answer, handled + } + if detectModelDiagnosisSkill(text) { + answer := a.handleModelDiagnosisSkill(storeUserID, lang, text) + a.recordSkillInteraction(userID, text, answer) + if onEvent != nil { + onEvent(StreamEventTool, "hard_skill:model_diagnosis") + onEvent(StreamEventDelta, answer) + } + return answer, true + } + if detectExchangeDiagnosisSkill(text) { + answer := a.handleExchangeDiagnosisSkill(storeUserID, lang, text) + a.recordSkillInteraction(userID, text, answer) + if onEvent != nil { + onEvent(StreamEventTool, "hard_skill:exchange_diagnosis") + onEvent(StreamEventDelta, answer) + } + return answer, true + } + if detectTraderDiagnosisSkill(text) { + answer := a.handleTraderDiagnosisSkill(storeUserID, lang, text) + a.recordSkillInteraction(userID, text, answer) + if onEvent != nil { + onEvent(StreamEventTool, "hard_skill:trader_diagnosis") + onEvent(StreamEventDelta, answer) + } + return answer, true + } + if detectStrategyDiagnosisSkill(text) { + answer := a.handleStrategyDiagnosisSkill(storeUserID, lang, text) + a.recordSkillInteraction(userID, text, answer) + if onEvent != nil { + onEvent(StreamEventTool, "hard_skill:strategy_diagnosis") + onEvent(StreamEventDelta, answer) + } + return answer, true + } + return "", false +} + +func (a *Agent) recordSkillInteraction(userID int64, userText, answer string) { + if a.history == nil { + a.history = newChatHistory(100) + } + a.history.Add(userID, "user", userText) + a.history.Add(userID, "assistant", answer) +} + +func ensureSkillFields(session *skillSession) { + if session.Fields == nil { + session.Fields = make(map[string]string) + } +} + +func (a *Agent) handleCreateTraderSkill(storeUserID string, userID int64, lang, text string, session skillSession) (string, bool) { + if isCancelSkillReply(text) { + a.clearSkillSession(userID) + if lang == "zh" { + return "已取消当前创建交易员流程。", true + } + return "Cancelled the current trader creation flow.", true + } + + if session.Name == "" { + session = skillSession{ + Name: "trader_management", + Action: "create", + Phase: "collecting", + Slots: &createTraderSkillSlots{}, + } + if detectStartIntent(text) { + autoStart := true + session.Slots.AutoStart = &autoStart + } + } + if session.Slots == nil { + session.Slots = &createTraderSkillSlots{} + } + if fieldValue(session, skillDAGStepField) == "" { + setSkillDAGStep(&session, "resolve_name") + } + + if session.Phase == "await_start_confirmation" { + setSkillDAGStep(&session, "await_start_confirmation") + switch { + case isYesReply(text): + answer := a.executeCreateTraderSkill(storeUserID, userID, lang, session, true) + return answer, true + case isNoReply(text): + answer := a.executeCreateTraderSkill(storeUserID, userID, lang, session, false) + return answer, true + default: + a.saveSkillSession(userID, session) + if lang == "zh" { + return "当前流程在等待你确认是否立即启动交易员。回复“确认”继续启动，回复“先不用”则只创建不启动。", true + } + return "This flow is waiting for your confirmation to start the trader. Reply 'confirm' to start it now, or 'no' to create without starting.", true + } + } + + slots := session.Slots + if slots.Name == "" { + slots.Name = extractTraderName(text) + } + if slots.Name != "" { + setSkillDAGStep(&session, "resolve_exchange") + } + + models := a.loadEnabledModelOptions(storeUserID) + exchanges := a.loadExchangeOptions(storeUserID) + strategies := a.loadStrategyOptions(storeUserID) + + if slots.ModelID == "" { + if match := pickOptionFromSegment(text, []string{"模型用", "模型", "model"}, models); match != nil { + slots.ModelID = match.ID + slots.ModelName = match.Name + } else if match := pickMentionedOption(text, models); match != nil { + slots.ModelID = match.ID + slots.ModelName = match.Name + } else if choice := choosePreferredOption(models); choice != nil { + slots.ModelID = choice.ID + slots.ModelName = choice.Name + } + } + if slots.ExchangeID != "" { + setSkillDAGStep(&session, "resolve_model") + } + if slots.ExchangeID == "" { + if match := pickOptionFromSegment(text, []string{"交易所用", "交易所", "exchange"}, exchanges); match != nil { + if match.Enabled { + slots.ExchangeID = match.ID + slots.ExchangeName = match.Name + } else { + if lang == "zh" { + extra := "你刚才提到的交易所“" + defaultIfEmpty(match.Name, match.ID) + "”当前已禁用，请换一个已启用的交易所。" + a.saveSkillSession(userID, session) + return extra + "\n" + formatOptionList("可用交易所：", exchanges), true + } + a.saveSkillSession(userID, session) + return "The exchange you mentioned is currently disabled. Please choose an enabled exchange.\n" + formatOptionList("Available exchanges:", exchanges), true + } + } else if match := pickMentionedOption(text, exchanges); match != nil { + if match.Enabled { + slots.ExchangeID = match.ID + slots.ExchangeName = match.Name + } else { + if lang == "zh" { + extra := "你刚才提到的交易所“" + defaultIfEmpty(match.Name, match.ID) + "”当前已禁用，请换一个已启用的交易所。" + a.saveSkillSession(userID, session) + return extra + "\n" + formatOptionList("可用交易所：", exchanges), true + } + a.saveSkillSession(userID, session) + return "The exchange you mentioned is currently disabled. Please choose an enabled exchange.\n" + formatOptionList("Available exchanges:", exchanges), true + } + } else if choice := choosePreferredOption(exchanges); choice != nil { + slots.ExchangeID = choice.ID + slots.ExchangeName = choice.Name + } + } + if slots.StrategyID == "" { + if match := pickOptionFromSegment(text, []string{"策略用", "策略", "strategy"}, strategies); match != nil { + slots.StrategyID = match.ID + slots.StrategyName = match.Name + } else if match := pickMentionedOption(text, strategies); match != nil { + slots.StrategyID = match.ID + slots.StrategyName = match.Name + } else if choice := choosePreferredOption(strategies); choice != nil { + slots.StrategyID = choice.ID + slots.StrategyName = choice.Name + } + } + if slots.ModelID != "" { + setSkillDAGStep(&session, "resolve_strategy") + } + if slots.StrategyID != "" { + setSkillDAGStep(&session, "maybe_confirm_start") + } + + if slots.AutoStart == nil && detectStartIntent(text) { + autoStart := true + slots.AutoStart = &autoStart + } + + missing := make([]string, 0, 3) + extraLines := make([]string, 0, 3) + if actionRequiresSlot("trader_management", "create", "name") && slots.Name == "" { + missing = append(missing, slotDisplayName("name", lang)) + } + if actionRequiresSlot("trader_management", "create", "exchange") && slots.ExchangeID == "" { + missing = append(missing, slotDisplayName("exchange", lang)) + if len(exchanges) == 0 { + if lang == "zh" { + extraLines = append(extraLines, "当前还没有可用交易所配置，请先配置并启用一个交易所账户。") + } else { + extraLines = append(extraLines, "There is no enabled exchange config yet. Please create and enable one first.") + } + } else { + label := "Available exchanges:" + if lang == "zh" { + label = "可用交易所：" + } + extraLines = append(extraLines, formatOptionList(label, exchanges)) + } + } + if actionRequiresSlot("trader_management", "create", "model") && slots.ModelID == "" { + missing = append(missing, slotDisplayName("model", lang)) + if len(models) == 0 { + if lang == "zh" { + extraLines = append(extraLines, "当前还没有可用模型配置，请先配置并启用一个模型。") + } else { + extraLines = append(extraLines, "There is no enabled model config yet. Please create and enable one first.") + } + } else { + label := "Available models:" + if lang == "zh" { + label = "可用模型：" + } + extraLines = append(extraLines, formatOptionList(label, models)) + } + } + if slots.StrategyID == "" && (actionRequiresSlot("trader_management", "create", "strategy") || len(strategies) == 0) { + missing = append(missing, slotDisplayName("strategy", lang)) + } + if slots.StrategyID == "" { + if len(strategies) == 0 { + if lang == "zh" { + extraLines = append(extraLines, "当前还没有可用策略，请先创建一个策略。") + } else { + extraLines = append(extraLines, "There is no strategy available yet. Please create one first.") + } + } else { + label := "Available strategies:" + if lang == "zh" { + label = "可用策略：" + } + extraLines = append(extraLines, formatOptionList(label, strategies)) + } + } + + if len(missing) > 0 { + session.Phase = "collecting" + a.saveSkillSession(userID, session) + if lang == "zh" { + reply := "要继续创建交易员，还缺这些信息：" + strings.Join(missing, "、") + "。" + if len(extraLines) > 0 { + reply += "\n" + strings.Join(cleanStringList(extraLines), "\n") + } + reply += "\n你可以直接一次性告诉我，例如：名称、用哪个交易所、哪个模型、哪个策略。" + return reply, true + } + reply := "To continue creating the trader, I still need: " + strings.Join(missing, ", ") + "." + if len(extraLines) > 0 { + reply += "\n" + strings.Join(cleanStringList(extraLines), "\n") + } + reply += "\nYou can reply with all missing fields in one message." + return reply, true + } + + if slots.AutoStart != nil && *slots.AutoStart { + session.Phase = "await_start_confirmation" + setSkillDAGStep(&session, "await_start_confirmation") + a.saveSkillSession(userID, session) + if lang == "zh" { + return fmt.Sprintf("我已经准备好创建交易员“%s”，并在创建后立即启动它。\n使用的交易所：%s\n使用的模型：%s\n使用的策略：%s\n\n这是高风险动作。回复“确认”继续，回复“先不用”则只创建不启动。", + slots.Name, slots.ExchangeNameOrID(), slots.ModelNameOrID(), slots.StrategyNameOrID()), true + } + return fmt.Sprintf("I'm ready to create trader %q and start it immediately.\nExchange: %s\nModel: %s\nStrategy: %s\n\nThis is a high-risk action. Reply 'confirm' to continue, or 'no' to create it without starting.", + slots.Name, slots.ExchangeNameOrID(), slots.ModelNameOrID(), slots.StrategyNameOrID()), true + } + + answer := a.executeCreateTraderSkill(storeUserID, userID, lang, session, false) + return answer, true +} + +func (s *createTraderSkillSlots) ExchangeNameOrID() string { + if strings.TrimSpace(s.ExchangeName) != "" { + return s.ExchangeName + } + return s.ExchangeID +} + +func (s *createTraderSkillSlots) ModelNameOrID() string { + if strings.TrimSpace(s.ModelName) != "" { + return s.ModelName + } + return s.ModelID +} + +func (s *createTraderSkillSlots) StrategyNameOrID() string { + if strings.TrimSpace(s.StrategyName) != "" { + return s.StrategyName + } + return s.StrategyID +} + +func (a *Agent) executeCreateTraderSkill(storeUserID string, userID int64, lang string, session skillSession, startAfterCreate bool) string { + args := manageTraderArgs{ + Action: "create", + Name: session.Slots.Name, + AIModelID: session.Slots.ModelID, + ExchangeID: session.Slots.ExchangeID, + StrategyID: session.Slots.StrategyID, + } + createRaw := a.toolCreateTrader(storeUserID, args) + if errMsg := parseSkillError(createRaw); errMsg != "" && strings.Contains(createRaw, `"error"`) { + session.Phase = "collecting" + a.saveSkillSession(userID, session) + if strings.Contains(strings.ToLower(errMsg), "exchange is disabled") { + exchanges := a.loadExchangeOptions(storeUserID) + if lang == "zh" { + reply := fmt.Sprintf("创建交易员失败：你选的交易所“%s”当前已禁用，请换一个已启用的交易所。", session.Slots.ExchangeNameOrID()) + if list := formatOptionList("可用交易所：", exchanges); list != "" { + reply += "\n" + list + } + return reply + } + reply := fmt.Sprintf("Failed to create trader: the selected exchange %q is disabled. Please choose an enabled exchange.", session.Slots.ExchangeNameOrID()) + if list := formatOptionList("Available exchanges:", exchanges); list != "" { + reply += "\n" + list + } + return reply + } + if lang == "zh" { + return "创建交易员失败：" + errMsg + } + return "Failed to create trader: " + errMsg + } + var created struct { + Trader safeTraderToolConfig `json:"trader"` + } + if err := json.Unmarshal([]byte(createRaw), &created); err != nil || created.Trader.ID == "" { + a.clearSkillSession(userID) + if lang == "zh" { + return "交易员创建后返回结果异常，请稍后到列表里确认。" + } + return "The trader was created but the response could not be verified. Please check the trader list." + } + + if !startAfterCreate { + setSkillDAGStep(&session, "execute_create_only") + a.clearSkillSession(userID) + if lang == "zh" { + return fmt.Sprintf("已创建交易员“%s”。\n交易所：%s\n模型：%s\n策略：%s\n当前状态：未启动。", + created.Trader.Name, session.Slots.ExchangeNameOrID(), session.Slots.ModelNameOrID(), session.Slots.StrategyNameOrID()) + } + return fmt.Sprintf("Created trader %q.\nExchange: %s\nModel: %s\nStrategy: %s\nCurrent status: not started.", + created.Trader.Name, session.Slots.ExchangeNameOrID(), session.Slots.ModelNameOrID(), session.Slots.StrategyNameOrID()) + } + + setSkillDAGStep(&session, "execute_create_and_start") + startRaw := a.toolStartTrader(storeUserID, created.Trader.ID) + if errMsg := parseSkillError(startRaw); errMsg != "" && strings.Contains(startRaw, `"error"`) { + a.clearSkillSession(userID) + if lang == "zh" { + return fmt.Sprintf("交易员“%s”已创建，但启动失败：%s", created.Trader.Name, errMsg) + } + return fmt.Sprintf("Trader %q was created, but starting it failed: %s", created.Trader.Name, errMsg) + } + + a.clearSkillSession(userID) + if lang == "zh" { + return fmt.Sprintf("已创建并启动交易员“%s”。\n交易所：%s\n模型：%s\n策略：%s", + created.Trader.Name, session.Slots.ExchangeNameOrID(), session.Slots.ModelNameOrID(), session.Slots.StrategyNameOrID()) + } + return fmt.Sprintf("Created and started trader %q.\nExchange: %s\nModel: %s\nStrategy: %s", + created.Trader.Name, session.Slots.ExchangeNameOrID(), session.Slots.ModelNameOrID(), session.Slots.StrategyNameOrID()) +} + +func (a *Agent) handleModelDiagnosisSkill(storeUserID, lang, text string) string { + raw := a.toolGetModelConfigs(storeUserID) + errMsg := parseSkillError(raw) + if errMsg != "" && strings.Contains(raw, `"error"`) { + if lang == "zh" { + return "现象：模型配置读取失败。\n更可能原因：当前存储不可用或配置列表读取失败。\n下一步：请稍后重试，或先检查后端日志。" + } + return "Symptom: failed to read model configs.\nLikely cause: the store is unavailable or loading configs failed.\nNext step: retry later or check backend logs." + } + + var payload struct { + ModelConfigs []safeModelToolConfig `json:"model_configs"` + } + _ = json.Unmarshal([]byte(raw), &payload) + + if len(payload.ModelConfigs) == 0 { + if lang == "zh" { + return "现象：当前没有任何模型配置。\n更可能原因：还没创建模型绑定。\n先检查什么：先确认你要使用哪个 provider。\n下一步：先新增并启用一个模型配置，再继续排查。" + } + return "Symptom: there are no model configs yet.\nLikely cause: no model binding has been created.\nNext step: create and enable a model config first." + } + + enabledCount := 0 + var incomplete []string + for _, model := range payload.ModelConfigs { + if model.Enabled { + enabledCount++ + } + if model.Enabled && (!model.HasAPIKey || strings.TrimSpace(model.CustomAPIURL) == "") { + incomplete = append(incomplete, model.Name) + } + } + + lines := make([]string, 0, 6) + if lang == "zh" { + lines = append(lines, "现象：这是模型配置/调用失败类问题。") + switch { + case enabledCount == 0: + lines = append(lines, "更可能原因：当前没有已启用模型。") + case len(incomplete) > 0: + lines = append(lines, "更可能原因：已启用模型里至少有一项缺少 API Key 或 custom_api_url，例如："+strings.Join(incomplete, "、")+"。") + case containsAny(strings.ToLower(text), []string{"custom_api_url", "url", "https"}): + lines = append(lines, "更可能原因：custom_api_url 不是合法 HTTPS 地址，后端会直接拒绝保存。") + default: + lines = append(lines, "更可能原因：模型已保存，但 custom_model_name、API Key 或 provider 运行配置不匹配。") + } + lines = append(lines, "先检查什么：") + lines = append(lines, fmt.Sprintf("1. 当前共 %d 个模型配置，已启用 %d 个。", len(payload.ModelConfigs), enabledCount)) + lines = append(lines, "2. 检查目标模型是否同时具备 enabled、API Key、custom_api_url。") + lines = append(lines, "3. 如果是 OpenAI / Claude / DeepSeek 等 provider，确认 model name 填的是该 provider 实际可用的模型名。") + if excerpt := backendLogDiagnosisExcerpt(lang, text, "model"); excerpt != "" { + lines = append(lines, excerpt) + } + lines = append(lines, "下一步：如果你愿意，我下一步可以继续帮你逐项检查你当前配置里的具体模型。") + return strings.Join(lines, "\n") + } + + lines = append(lines, "Symptom: this looks like a model configuration or model runtime issue.") + switch { + case enabledCount == 0: + lines = append(lines, "Likely cause: there is no enabled model.") + case len(incomplete) > 0: + lines = append(lines, "Likely cause: at least one enabled model is missing an API key or custom_api_url, for example: "+strings.Join(incomplete, ", ")+".") + default: + lines = append(lines, "Likely cause: the model was saved, but the API key, custom_api_url, or custom_model_name does not match the provider runtime config.") + } + lines = append(lines, fmt.Sprintf("Check first: %d model configs exist, %d are enabled.", len(payload.ModelConfigs), enabledCount)) + if excerpt := backendLogDiagnosisExcerpt(lang, text, "model"); excerpt != "" { + lines = append(lines, excerpt) + } + lines = append(lines, "Next step: verify the target model has enabled=true, a non-empty API key, a valid HTTPS custom_api_url, and a correct model name.") + return strings.Join(lines, "\n") +} + +func (a *Agent) handleExchangeDiagnosisSkill(storeUserID, lang, text string) string { + exchanges := a.loadExchangeOptions(storeUserID) + lower := strings.ToLower(text) + lines := make([]string, 0, 8) + if lang == "zh" { + lines = append(lines, "现象：这是交易所 API 连接或签名类问题。") + switch { + case containsAny(lower, []string{"invalid signature", "签名"}): + lines = append(lines, "更可能原因：API Secret / passphrase 不匹配，或者系统时间不同步。") + case containsAny(lower, []string{"timestamp", "时间戳"}): + lines = append(lines, "更可能原因：服务器时间偏差过大。") + case containsAny(lower, []string{"ip not allowed", "白名单"}): + lines = append(lines, "更可能原因：API 白名单没有包含当前服务器 IP。") + case containsAny(lower, []string{"permission denied", "权限"}): + lines = append(lines, "更可能原因：交易或合约权限没有打开。") + default: + lines = append(lines, "更可能原因：密钥配置、时间同步、白名单或权限设置存在问题。") + } + lines = append(lines, "先检查什么：") + lines = append(lines, "1. 先同步系统时间，尤其是出现 invalid signature / timestamp 时。") + lines = append(lines, "2. 确认 API Key 和 Secret 没有填反、没有过期。") + if containsAny(lower, []string{"okx", "欧易"}) || containsAny(strings.ToLower(formatOptionList("", exchanges)), []string{"okx"}) { + lines = append(lines, "3. 如果是 OKX，再确认 passphrase 没漏填。") + } + lines = append(lines, "4. 检查 API 白名单是否包含当前服务器 IP。") + lines = append(lines, "5. 检查是否已经开启交易/合约权限。") + if excerpt := backendLogDiagnosisExcerpt(lang, text, "exchange"); excerpt != "" { + lines = append(lines, excerpt) + } + lines = append(lines, "下一步：如果你把具体报错原文贴给我，我可以按报错类型继续缩小范围。") + return strings.Join(lines, "\n") + } + + lines = append(lines, "Symptom: this looks like an exchange API connectivity or signature issue.") + lines = append(lines, "Check first: system time sync, API key/secret correctness, IP whitelist, trading permissions, and passphrase for OKX.") + if len(exchanges) > 0 { + lines = append(lines, "Current exchange bindings exist, so the next step is to match the exact error text to the most likely cause.") + } + if excerpt := backendLogDiagnosisExcerpt(lang, text, "exchange"); excerpt != "" { + lines = append(lines, excerpt) + } + return strings.Join(lines, "\n") +} + +func backendLogDiagnosisExcerpt(lang, text, fallbackFilter string) string { + filter := strings.TrimSpace(text) + if strings.TrimSpace(filter) == "" { + filter = fallbackFilter + } + _, entries, err := readBackendLogEntries(8, filter, true) + if err != nil || len(entries) == 0 { + if filter != fallbackFilter { + _, entries, err = readBackendLogEntries(8, fallbackFilter, true) + } + } + if err != nil || len(entries) == 0 { + return "" + } + if lang == "zh" { + return "最近命中的后端错误日志：\n- " + strings.Join(entries, "\n- ") + } + return "Recent matching backend error logs:\n- " + strings.Join(entries, "\n- ") +} diff --git a/agent/skill_dispatcher_test.go b/agent/skill_dispatcher_test.go new file mode 100644 index 00000000..bb292156 --- /dev/null +++ b/agent/skill_dispatcher_test.go @@ -0,0 +1,828 @@ +package agent + +import ( + "context" + "encoding/json" + "errors" + "strings" + "testing" + "time" + + "nofx/mcp" +) + +func TestCreateTraderSkillCollectsMissingFieldsAndCreatesTrader(t *testing.T) { + a := newTestAgentWithStore(t) + + modelResp := a.toolManageModelConfig("user-1", `{ + "action":"create", + "provider":"deepseek", + "enabled":true, + "api_key":"sk-test", + "custom_api_url":"https://api.deepseek.com/v1", + "custom_model_name":"deepseek-chat" + }`) + if strings.Contains(modelResp, `"error"`) { + t.Fatalf("failed to create model: %s", modelResp) + } + exchangeResp := a.toolManageExchangeConfig("user-1", `{ + "action":"create", + "exchange_type":"okx", + "account_name":"主账户", + "enabled":true + }`) + if strings.Contains(exchangeResp, `"error"`) { + t.Fatalf("failed to create exchange: %s", exchangeResp) + } + strategyResp := a.toolManageStrategy("user-1", `{ + "action":"create", + "name":"趋势策略", + "lang":"zh" + }`) + if strings.Contains(strategyResp, `"error"`) { + t.Fatalf("failed to create strategy: %s", strategyResp) + } + + resp, err := a.thinkAndAct(context.Background(), "user-1", 1, "zh", "帮我创建一个交易员") + if err != nil { + t.Fatalf("thinkAndAct() error = %v", err) + } + if !strings.Contains(resp, "还缺这些信息") || !strings.Contains(resp, "名称") { + t.Fatalf("expected missing-field prompt, got %q", resp) + } + + resp, err = a.thinkAndAct(context.Background(), "user-1", 1, "zh", "叫 波段一号") + if err != nil { + t.Fatalf("thinkAndAct() second turn error = %v", err) + } + if !strings.Contains(resp, "已创建交易员") || !strings.Contains(resp, "波段一号") { + t.Fatalf("expected trader creation confirmation, got %q", resp) + } + + listResp := a.toolListTraders("user-1") + if !strings.Contains(listResp, "波段一号") { + t.Fatalf("expected created trader in list, got %s", listResp) + } +} + +func TestCreateTraderSkillReportsAllMissingPrerequisitesAtOnce(t *testing.T) { + a := newTestAgentWithStore(t) + + resp, err := a.thinkAndAct(context.Background(), "user-1", 11, "zh", "帮我创建一个交易员") + if err != nil { + t.Fatalf("thinkAndAct() error = %v", err) + } + for _, want := range []string{"名称", "交易所", "模型", "策略"} { + if !strings.Contains(resp, want) { + t.Fatalf("expected response to mention %q, got %q", want, resp) + } + } + for _, want := range []string{"当前还没有可用交易所配置", "当前还没有可用模型配置", "当前还没有可用策略"} { + if !strings.Contains(resp, want) { + t.Fatalf("expected response to mention prerequisite %q, got %q", want, resp) + } + } +} + +func TestActiveSkillSessionYieldsToNewTopic(t *testing.T) { + a := newTestAgentWithStore(t) + + _ = a.toolManageStrategy("user-1", `{ + "action":"create", + "name":"测试策略", + "lang":"zh" + }`) + + resp, err := a.thinkAndAct(context.Background(), "user-1", 13, "zh", "帮我创建一个交易员") + if err != nil { + t.Fatalf("thinkAndAct() error = %v", err) + } + if !strings.Contains(resp, "还缺这些信息") { + t.Fatalf("expected trader creation flow prompt, got %q", resp) + } + + resp, err = a.thinkAndAct(context.Background(), "user-1", 13, "zh", "列出我当前的策略") + if err != nil { + t.Fatalf("thinkAndAct() interrupt error = %v", err) + } + if !strings.Contains(resp, "当前策略") || !strings.Contains(resp, "测试策略") { + t.Fatalf("expected new topic to be handled, got %q", resp) + } + if a.hasActiveSkillSession(13) { + t.Fatal("expected skill session to be cleared after interruption") + } +} + +func TestCreateTraderSkillRequestsStartConfirmation(t *testing.T) { + a := newTestAgentWithStore(t) + + _ = a.toolManageModelConfig("user-1", `{ + "action":"create", + "provider":"openai", + "enabled":true, + "api_key":"sk-test", + "custom_api_url":"https://api.openai.com/v1", + "custom_model_name":"gpt-5" + }`) + _ = a.toolManageExchangeConfig("user-1", `{ + "action":"create", + "exchange_type":"binance", + "account_name":"Main", + "enabled":true + }`) + _ = a.toolManageStrategy("user-1", `{ + "action":"create", + "name":"保守策略", + "lang":"zh" + }`) + + resp, err := a.thinkAndAct(context.Background(), "user-1", 2, "zh", "创建一个叫“实盘一号”的交易员并启动") + if err != nil { + t.Fatalf("thinkAndAct() error = %v", err) + } + if !strings.Contains(resp, "高风险动作") || !strings.Contains(resp, "确认") { + t.Fatalf("expected start confirmation prompt, got %q", resp) + } + + resp, err = a.thinkAndAct(context.Background(), "user-1", 2, "zh", "先不用") + if err != nil { + t.Fatalf("thinkAndAct() confirmation error = %v", err) + } + if !strings.Contains(resp, "已创建交易员") || strings.Contains(resp, "已创建并启动") { + t.Fatalf("expected create-without-start response, got %q", resp) + } +} + +func TestModelDiagnosisSkillHandledWithoutAIClient(t *testing.T) { + a := newTestAgentWithStore(t) + resp, err := a.thinkAndAct(context.Background(), "user-1", 3, "zh", "为什么我的模型配置失败了") + if err != nil { + t.Fatalf("thinkAndAct() error = %v", err) + } + if !strings.Contains(resp, "模型配置") { + t.Fatalf("expected model diagnosis response, got %q", resp) + } +} + +func TestExchangeDiagnosisSkillHandledWithoutAIClient(t *testing.T) { + a := newTestAgentWithStore(t) + resp, err := a.thinkAndAct(context.Background(), "user-1", 4, "zh", "交易所 API 报 invalid signature 怎么办") + if err != nil { + t.Fatalf("thinkAndAct() error = %v", err) + } + if !strings.Contains(resp, "invalid signature") && !strings.Contains(resp, "签名") { + t.Fatalf("expected exchange diagnosis response, got %q", resp) + } +} + +func TestExchangeManagementCreateAndQuerySkill(t *testing.T) { + a := newTestAgentWithStore(t) + + resp, err := a.thinkAndAct(context.Background(), "user-1", 5, "zh", "帮我创建一个 OKX 交易所配置") + if err != nil { + t.Fatalf("thinkAndAct() error = %v", err) + } + if !strings.Contains(resp, "已创建交易所配置") { + t.Fatalf("expected exchange create response, got %q", resp) + } + + resp, err = a.thinkAndAct(context.Background(), "user-1", 5, "zh", "列出我的交易所配置") + if err != nil { + t.Fatalf("thinkAndAct() query error = %v", err) + } + if !strings.Contains(resp, "当前交易所配置") && !strings.Contains(resp, "Default") { + t.Fatalf("expected exchange query response, got %q", resp) + } +} + +func TestModelManagementCreateSkill(t *testing.T) { + a := newTestAgentWithStore(t) + + resp, err := a.thinkAndAct(context.Background(), "user-1", 6, "zh", "帮我创建一个 DeepSeek 模型配置") + if err != nil { + t.Fatalf("thinkAndAct() error = %v", err) + } + if !strings.Contains(resp, "已创建模型配置") { + t.Fatalf("expected model create response, got %q", resp) + } +} + +func TestStrategyManagementCreateAndActivateSkill(t *testing.T) { + a := newTestAgentWithStore(t) + + resp, err := a.thinkAndAct(context.Background(), "user-1", 7, "zh", "创建一个叫“趋势策略B”的策略") + if err != nil { + t.Fatalf("thinkAndAct() create error = %v", err) + } + if !strings.Contains(resp, "已创建策略") { + t.Fatalf("expected strategy create response, got %q", resp) + } + + resp, err = a.thinkAndAct(context.Background(), "user-1", 7, "zh", "激活趋势策略B") + if err != nil { + t.Fatalf("thinkAndAct() activate error = %v", err) + } + if !strings.Contains(resp, "已激活策略") { + t.Fatalf("expected strategy activate response, got %q", resp) + } +} + +func TestStrategyManagementQueryCanExplainStrategyDetails(t *testing.T) { + a := newTestAgentWithStore(t) + + resp, err := a.thinkAndAct(context.Background(), "user-1", 12, "zh", "创建一个叫“激进的”的策略") + if err != nil { + t.Fatalf("thinkAndAct() create error = %v", err) + } + if !strings.Contains(resp, "已创建策略") { + t.Fatalf("expected strategy create response, got %q", resp) + } + + resp, err = a.thinkAndAct(context.Background(), "user-1", 12, "zh", "这个策略里面的参数和prompt分别是什么样的") + if err != nil { + t.Fatalf("thinkAndAct() detail query error = %v", err) + } + for _, want := range []string{"策略“激进的”概览", "K线周期", "仓位风险", "Prompt"} { + if !strings.Contains(resp, want) { + t.Fatalf("expected response to mention %q, got %q", want, resp) + } + } +} + +func TestTraderManagementQueryAndDiagnosisSkill(t *testing.T) { + a := newTestAgentWithStore(t) + + modelResp := a.toolManageModelConfig("user-1", `{ + "action":"create", + "provider":"openai", + "enabled":true, + "api_key":"sk-test", + "custom_api_url":"https://api.openai.com/v1", + "custom_model_name":"gpt-5" + }`) + var modelCreated struct { + Model safeModelToolConfig `json:"model"` + } + if err := json.Unmarshal([]byte(modelResp), &modelCreated); err != nil { + t.Fatalf("unmarshal model response: %v", err) + } + + exchangeResp := a.toolManageExchangeConfig("user-1", `{ + "action":"create", + "exchange_type":"binance", + "account_name":"Main", + "enabled":true + }`) + var exchangeCreated struct { + Exchange safeExchangeToolConfig `json:"exchange"` + } + if err := json.Unmarshal([]byte(exchangeResp), &exchangeCreated); err != nil { + t.Fatalf("unmarshal exchange response: %v", err) + } + _ = a.toolManageStrategy("user-1", `{ + "action":"create", + "name":"测试策略", + "lang":"zh" + }`) + _ = a.toolManageTrader("user-1", `{ + "action":"create", + "name":"测试交易员", + "ai_model_id":"`+modelCreated.Model.ID+`", + "exchange_id":"`+exchangeCreated.Exchange.ID+`", + "strategy_id":"" + }`) + + resp, err := a.thinkAndAct(context.Background(), "user-1", 8, "zh", "查看我的交易员") + if err != nil { + t.Fatalf("thinkAndAct() query error = %v", err) + } + if !strings.Contains(resp, "当前交易员") && !strings.Contains(resp, "测试交易员") { + t.Fatalf("expected trader query response, got %q", resp) + } + + resp, err = a.thinkAndAct(context.Background(), "user-1", 8, "zh", "为什么我的交易员不交易") + if err != nil { + t.Fatalf("thinkAndAct() diagnosis error = %v", err) + } + if !strings.Contains(resp, "交易员运行诊断") { + t.Fatalf("expected trader diagnosis response, got %q", resp) + } +} + +func TestExchangeManagementAtomicUpdates(t *testing.T) { + a := newTestAgentWithStore(t) + + createResp := a.toolManageExchangeConfig("user-1", `{ + "action":"create", + "exchange_type":"okx", + "account_name":"主账户", + "enabled":true + }`) + var created struct { + Exchange safeExchangeToolConfig `json:"exchange"` + } + if err := json.Unmarshal([]byte(createResp), &created); err != nil { + t.Fatalf("unmarshal exchange response: %v", err) + } + + resp, err := a.thinkAndAct(context.Background(), "user-1", 14, "zh", "更新交易所，把主账户改名为备用账户") + if err != nil { + t.Fatalf("rename exchange error = %v", err) + } + if !strings.Contains(resp, "已更新交易所配置") { + t.Fatalf("expected exchange update response, got %q", resp) + } + + raw := a.toolGetExchangeConfigs("user-1") + if !strings.Contains(raw, "备用账户") { + t.Fatalf("expected renamed exchange in list, got %s", raw) + } + + resp, err = a.thinkAndAct(context.Background(), "user-1", 14, "zh", "禁用这个交易所配置") + if err != nil { + t.Fatalf("disable exchange error = %v", err) + } + if !strings.Contains(resp, "已更新交易所配置") { + t.Fatalf("expected exchange status update response, got %q", resp) + } + + raw = a.toolGetExchangeConfigs("user-1") + if strings.Contains(raw, `"enabled":true`) && strings.Contains(raw, "备用账户") { + t.Fatalf("expected exchange to be disabled, got %s", raw) + } +} + +func TestModelManagementAtomicUpdates(t *testing.T) { + a := newTestAgentWithStore(t) + + createResp := a.toolManageModelConfig("user-1", `{ + "action":"create", + "provider":"deepseek", + "enabled":true, + "custom_api_url":"https://api.deepseek.com/v1", + "custom_model_name":"deepseek-chat" + }`) + var created struct { + Model safeModelToolConfig `json:"model"` + } + if err := json.Unmarshal([]byte(createResp), &created); err != nil { + t.Fatalf("unmarshal model response: %v", err) + } + + resp, err := a.thinkAndAct(context.Background(), "user-1", 15, "zh", "更新模型，把模型名称改成 deepseek-reasoner") + if err != nil { + t.Fatalf("rename model error = %v", err) + } + if !strings.Contains(resp, "已更新模型配置") { + t.Fatalf("expected model update response, got %q", resp) + } + + resp, err = a.thinkAndAct(context.Background(), "user-1", 15, "zh", "更新模型，把接口地址改成 https://api.deepseek.com/beta") + if err != nil { + t.Fatalf("update model endpoint error = %v", err) + } + if !strings.Contains(resp, "已更新模型配置") { + t.Fatalf("expected model endpoint update response, got %q", resp) + } + + resp, err = a.thinkAndAct(context.Background(), "user-1", 15, "zh", "禁用这个模型配置") + if err != nil { + t.Fatalf("disable model error = %v", err) + } + if !strings.Contains(resp, "已更新模型配置") { + t.Fatalf("expected model status update response, got %q", resp) + } + + raw := a.toolGetModelConfigs("user-1") + if !strings.Contains(raw, "deepseek-reasoner") || !strings.Contains(raw, "https://api.deepseek.com/beta") { + t.Fatalf("expected updated model fields, got %s", raw) + } + if strings.Contains(raw, `"enabled":true`) && strings.Contains(raw, created.Model.ID) { + t.Fatalf("expected model to be disabled, got %s", raw) + } +} + +func TestStrategyManagementAtomicUpdates(t *testing.T) { + a := newTestAgentWithStore(t) + + resp, err := a.thinkAndAct(context.Background(), "user-1", 16, "zh", "创建一个叫“激进策略C”的策略") + if err != nil { + t.Fatalf("create strategy error = %v", err) + } + if !strings.Contains(resp, "已创建策略") { + t.Fatalf("expected strategy create response, got %q", resp) + } + + resp, err = a.thinkAndAct(context.Background(), "user-1", 16, "zh", "更新这个策略的prompt，把提示词改成“优先观察BTC和ETH，信号不一致时不要开仓”") + if err != nil { + t.Fatalf("update strategy prompt error = %v", err) + } + if !strings.Contains(resp, "已更新策略 prompt") { + t.Fatalf("expected strategy prompt update response, got %q", resp) + } + + resp, err = a.thinkAndAct(context.Background(), "user-1", 16, "zh", "更新这个策略参数，把最大持仓改成2，最低置信度改成80，主周期改成15m，并使用15m 1h 4h") + if err != nil { + t.Fatalf("update strategy config error = %v", err) + } + if !strings.Contains(resp, "已更新策略参数") { + t.Fatalf("expected strategy config update response, got %q", resp) + } + + listRaw := a.toolGetStrategies("user-1") + if !strings.Contains(listRaw, "优先观察BTC和ETH") || !strings.Contains(listRaw, `"max_positions":2`) || !strings.Contains(listRaw, `"min_confidence":80`) || !strings.Contains(listRaw, `"primary_timeframe":"15m"`) { + t.Fatalf("expected updated strategy config, got %s", listRaw) + } +} + +func TestTraderManagementAtomicBindingUpdate(t *testing.T) { + a := newTestAgentWithStore(t) + + modelOpenAI := a.toolManageModelConfig("user-1", `{ + "action":"create", + "provider":"openai", + "enabled":true, + "custom_api_url":"https://api.openai.com/v1", + "custom_model_name":"gpt-5-mini" + }`) + var openAI struct { + Model safeModelToolConfig `json:"model"` + } + if err := json.Unmarshal([]byte(modelOpenAI), &openAI); err != nil { + t.Fatalf("unmarshal openai model: %v", err) + } + modelDeepSeek := a.toolManageModelConfig("user-1", `{ + "action":"create", + "provider":"deepseek", + "enabled":true, + "custom_api_url":"https://api.deepseek.com/v1", + "custom_model_name":"deepseek-chat" + }`) + var deepSeek struct { + Model safeModelToolConfig `json:"model"` + } + if err := json.Unmarshal([]byte(modelDeepSeek), &deepSeek); err != nil { + t.Fatalf("unmarshal deepseek model: %v", err) + } + + exchangeBinance := a.toolManageExchangeConfig("user-1", `{ + "action":"create", + "exchange_type":"binance", + "account_name":"Binance 主账户", + "enabled":true + }`) + var binance struct { + Exchange safeExchangeToolConfig `json:"exchange"` + } + if err := json.Unmarshal([]byte(exchangeBinance), &binance); err != nil { + t.Fatalf("unmarshal binance exchange: %v", err) + } + exchangeOKX := a.toolManageExchangeConfig("user-1", `{ + "action":"create", + "exchange_type":"okx", + "account_name":"OKX 主账户", + "enabled":true + }`) + var okx struct { + Exchange safeExchangeToolConfig `json:"exchange"` + } + if err := json.Unmarshal([]byte(exchangeOKX), &okx); err != nil { + t.Fatalf("unmarshal okx exchange: %v", err) + } + + strategyA := a.toolManageStrategy("user-1", `{"action":"create","name":"策略A","lang":"zh"}`) + var stA struct { + Strategy safeStrategyToolConfig `json:"strategy"` + } + if err := json.Unmarshal([]byte(strategyA), &stA); err != nil { + t.Fatalf("unmarshal strategy A: %v", err) + } + strategyB := a.toolManageStrategy("user-1", `{"action":"create","name":"策略B","lang":"zh"}`) + var stB struct { + Strategy safeStrategyToolConfig `json:"strategy"` + } + if err := json.Unmarshal([]byte(strategyB), &stB); err != nil { + t.Fatalf("unmarshal strategy B: %v", err) + } + + createTrader := a.toolManageTrader("user-1", `{ + "action":"create", + "name":"实盘一号", + "ai_model_id":"`+openAI.Model.ID+`", + "exchange_id":"`+binance.Exchange.ID+`", + "strategy_id":"`+stA.Strategy.ID+`" + }`) + var trader struct { + Trader safeTraderToolConfig `json:"trader"` + } + if err := json.Unmarshal([]byte(createTrader), &trader); err != nil { + t.Fatalf("unmarshal trader: %v", err) + } + + resp, err := a.thinkAndAct(context.Background(), "user-1", 17, "zh", "更新交易员绑定，把实盘一号换成 deepseek-chat、OKX 主账户 和 策略B") + if err != nil { + t.Fatalf("update trader bindings error = %v", err) + } + if !strings.Contains(resp, "已更新交易员绑定") { + t.Fatalf("expected trader binding update response, got %q", resp) + } + + listRaw := a.toolListTraders("user-1") + if !strings.Contains(listRaw, deepSeek.Model.ID) || !strings.Contains(listRaw, okx.Exchange.ID) || !strings.Contains(listRaw, stB.Strategy.ID) { + t.Fatalf("expected trader bindings to change, got %s", listRaw) + } +} + +func TestStrategyManagementDeleteAllUserStrategies(t *testing.T) { + a := newTestAgentWithStore(t) + + for _, name := range []string{"趋势策略A", "趋势策略B"} { + resp := a.toolManageStrategy("user-1", `{ + "action":"create", + "name":"`+name+`", + "lang":"zh" + }`) + if strings.Contains(resp, `"error"`) { + t.Fatalf("failed to create strategy %q: %s", name, resp) + } + } + + resp, err := a.thinkAndAct(context.Background(), "user-1", 21, "zh", "现在把所有的策略全部删除") + if err != nil { + t.Fatalf("thinkAndAct() bulk delete start error = %v", err) + } + if !strings.Contains(resp, "确认") || !strings.Contains(resp, "全部自定义策略") { + t.Fatalf("expected bulk delete confirmation, got %q", resp) + } + + resp, err = a.thinkAndAct(context.Background(), "user-1", 21, "zh", "确认") + if err != nil { + t.Fatalf("thinkAndAct() bulk delete confirm error = %v", err) + } + if !strings.Contains(resp, "成功删除 2 个") { + t.Fatalf("expected bulk delete success summary, got %q", resp) + } + + listResp := a.toolGetStrategies("user-1") + if strings.Contains(listResp, "趋势策略A") || strings.Contains(listResp, "趋势策略B") { + t.Fatalf("expected created strategies to be deleted, got %s", listResp) + } +} + +func TestCreateTraderSkillRejectsDisabledExchangeWithClearPrompt(t *testing.T) { + a := newTestAgentWithStore(t) + + _ = a.toolManageModelConfig("user-1", `{ + "action":"create", + "provider":"deepseek", + "enabled":true, + "api_key":"sk-test", + "custom_api_url":"https://api.deepseek.com/v1", + "custom_model_name":"deepseek-chat" + }`) + enabledExchange := a.toolManageExchangeConfig("user-1", `{ + "action":"create", + "exchange_type":"okx", + "account_name":"test", + "enabled":true + }`) + if strings.Contains(enabledExchange, `"error"`) { + t.Fatalf("failed to create enabled exchange: %s", enabledExchange) + } + anotherEnabledExchange := a.toolManageExchangeConfig("user-1", `{ + "action":"create", + "exchange_type":"okx", + "account_name":"lky", + "enabled":true + }`) + if strings.Contains(anotherEnabledExchange, `"error"`) { + t.Fatalf("failed to create second enabled exchange: %s", anotherEnabledExchange) + } + disabledExchange := a.toolManageExchangeConfig("user-1", `{ + "action":"create", + "exchange_type":"okx", + "account_name":"new", + "enabled":false + }`) + if strings.Contains(disabledExchange, `"error"`) { + t.Fatalf("failed to create disabled exchange: %s", disabledExchange) + } + _ = a.toolManageStrategy("user-1", `{"action":"create","name":"激进","lang":"zh"}`) + + resp, err := a.thinkAndAct(context.Background(), "user-1", 24, "zh", "给我创建一个trader") + if err != nil { + t.Fatalf("create trader start error = %v", err) + } + if !strings.Contains(resp, "new（已禁用）") { + t.Fatalf("expected disabled exchange to be labelled, got %q", resp) + } + + resp, err = a.thinkAndAct(context.Background(), "user-1", 24, "zh", "名称叫test，交易所用new、策略用激进") + if err != nil { + t.Fatalf("disabled exchange selection error = %v", err) + } + if !strings.Contains(resp, "当前已禁用") { + t.Fatalf("expected disabled exchange warning, got %q", resp) + } +} + +func TestCancelReplyExitsExchangeUpdateFlow(t *testing.T) { + a := newTestAgentWithStore(t) + _ = a.toolManageModelConfig("user-1", `{ + "action":"create", + "provider":"deepseek", + "enabled":true, + "api_key":"sk-test", + "custom_api_url":"https://api.deepseek.com/v1", + "custom_model_name":"deepseek-chat" + }`) + + exchangeResp := a.toolManageExchangeConfig("user-1", `{ + "action":"create", + "exchange_type":"okx", + "account_name":"test", + "enabled":true + }`) + if strings.Contains(exchangeResp, `"error"`) { + t.Fatalf("failed to create exchange: %s", exchangeResp) + } + + resp, err := a.thinkAndAct(context.Background(), "user-1", 25, "zh", "把test这个交易所改一下") + if err != nil { + t.Fatalf("enter exchange update flow error = %v", err) + } + if !strings.Contains(resp, "请告诉我你要改什么") { + t.Fatalf("expected exchange update prompt, got %q", resp) + } + + resp, err = a.thinkAndAct(context.Background(), "user-1", 25, "zh", "不改") + if err != nil { + t.Fatalf("cancel exchange flow error = %v", err) + } + if !strings.Contains(resp, "已取消当前流程") { + t.Fatalf("expected flow cancellation, got %q", resp) + } +} + +func TestClassifySkillSessionInputInterruptsOnDeflection(t *testing.T) { + session := skillSession{Name: "exchange_management", Action: "update"} + a := &Agent{} + + if got := a.classifySkillSessionInput(context.Background(), 0, "zh", session, "你能帮我看下报错吗"); got != "interrupt" { + t.Fatalf("expected diagnosis deflection to interrupt current skill flow, got %q", got) + } + if got := a.classifySkillSessionInput(context.Background(), 0, "zh", session, "换话题了大哥"); got != "cancel" { + t.Fatalf("expected topic shift to cancel current skill flow, got %q", got) + } +} + +type skillSessionClassifierAIClient struct { + lastSystemPrompt string + lastUserPrompt string + response string +} + +func (c *skillSessionClassifierAIClient) SetAPIKey(string, string, string) {} +func (c *skillSessionClassifierAIClient) SetTimeout(time.Duration) {} +func (c *skillSessionClassifierAIClient) CallWithMessages(string, string) (string, error) { + return "", errors.New("unexpected CallWithMessages") +} +func (c *skillSessionClassifierAIClient) CallWithRequest(req *mcp.Request) (string, error) { + if len(req.Messages) > 0 { + c.lastSystemPrompt = req.Messages[0].Content + } + if len(req.Messages) > 1 { + c.lastUserPrompt = req.Messages[1].Content + } + return c.response, nil +} +func (c *skillSessionClassifierAIClient) CallWithRequestStream(*mcp.Request, func(string)) (string, error) { + return "", errors.New("unexpected CallWithRequestStream") +} +func (c *skillSessionClassifierAIClient) CallWithRequestFull(*mcp.Request) (*mcp.LLMResponse, error) { + return nil, errors.New("unexpected CallWithRequestFull") +} + +func TestClassifySkillSessionInputUsesSlotExpectationWithoutLLM(t *testing.T) { + client := &skillSessionClassifierAIClient{response: `{"decision":"interrupt"}`} + a := &Agent{aiClient: client} + session := skillSession{ + Name: "strategy_management", + Action: "update_config", + Fields: map[string]string{ + skillDAGStepField: "resolve_config_value", + "config_field": "min_confidence", + }, + } + + if got := a.classifySkillSessionInput(context.Background(), 0, "zh", session, "70"); got != "continue" { + t.Fatalf("expected numeric slot fill to continue, got %q", got) + } + if client.lastSystemPrompt != "" { + t.Fatalf("expected no LLM call for direct slot expectation, got prompt %q", client.lastSystemPrompt) + } +} + +func TestClassifySkillSessionInputUsesLLMOnlyForAmbiguousDeflection(t *testing.T) { + client := &skillSessionClassifierAIClient{response: `{"decision":"interrupt"}`} + a := &Agent{ + aiClient: client, + history: newChatHistory(10), + } + session := skillSession{ + Name: "exchange_management", + Action: "update", + Fields: map[string]string{ + skillDAGStepField: "collect_account_name", + }, + } + + if got := a.classifySkillSessionInput(context.Background(), 0, "zh", session, "你能帮我看下报错吗"); got != "interrupt" { + t.Fatalf("expected ambiguous deflection to interrupt, got %q", got) + } + if !strings.Contains(client.lastSystemPrompt, "classify one user message while a NOFXi structured management flow is active") { + t.Fatalf("expected LLM classifier prompt, got %q", client.lastSystemPrompt) + } +} + +func TestClassifySkillSessionInputUsesLLMForUnmatchedActiveSessionInput(t *testing.T) { + client := &skillSessionClassifierAIClient{response: `{"decision":"continue"}`} + a := &Agent{ + aiClient: client, + history: newChatHistory(10), + } + session := skillSession{ + Name: "model_management", + Action: "create", + Fields: map[string]string{ + skillDAGStepField: "collect_optional_fields", + "provider": "openai", + }, + } + + if got := a.classifySkillSessionInput(context.Background(), 0, "zh", session, "新增一个"); got != "continue" { + t.Fatalf("expected unmatched active-session input to follow LLM decision, got %q", got) + } + if !strings.Contains(client.lastSystemPrompt, "classify one user message while a NOFXi structured management flow is active") { + t.Fatalf("expected LLM classifier prompt, got %q", client.lastSystemPrompt) + } +} + +func TestStrategyManagementCanDescribeDefaultConfig(t *testing.T) { + a := newTestAgentWithStore(t) + _ = a.toolManageModelConfig("user-1", `{ + "action":"create", + "provider":"deepseek", + "enabled":true, + "api_key":"sk-test", + "custom_api_url":"https://api.deepseek.com/v1", + "custom_model_name":"deepseek-chat" + }`) + + resp, err := a.thinkAndAct(context.Background(), "user-1", 22, "zh", "看一下默认配置") + if err != nil { + t.Fatalf("thinkAndAct() default config error = %v", err) + } + if !strings.Contains(resp, "默认策略模板") || !strings.Contains(resp, "最低置信度") { + t.Fatalf("expected default strategy config response, got %q", resp) + } +} + +func TestStrategyManagementSupportsMultiFieldConfigUpdate(t *testing.T) { + a := newTestAgentWithStore(t) + _ = a.toolManageModelConfig("user-1", `{ + "action":"create", + "provider":"deepseek", + "enabled":true, + "api_key":"sk-test", + "custom_api_url":"https://api.deepseek.com/v1", + "custom_model_name":"deepseek-chat" + }`) + + createResp := a.toolManageStrategy("user-1", `{ + "action":"create", + "name":"趋势策略A", + "lang":"zh" + }`) + if strings.Contains(createResp, `"error"`) { + t.Fatalf("failed to create strategy: %s", createResp) + } + + resp, err := a.thinkAndAct(context.Background(), "user-1", 23, "zh", "把趋势策略A的最小置信度改成70，核心指标都全选") + if err != nil { + t.Fatalf("thinkAndAct() multi-field update error = %v", err) + } + if !strings.Contains(resp, "最小置信度") || !strings.Contains(resp, "EMA") { + t.Fatalf("expected multi-field update confirmation, got %q", resp) + } + + strategiesRaw := a.toolGetStrategies("user-1") + if !strings.Contains(strategiesRaw, `"min_confidence":70`) || + !strings.Contains(strategiesRaw, `"enable_ema":true`) || + !strings.Contains(strategiesRaw, `"enable_macd":true`) || + !strings.Contains(strategiesRaw, `"enable_rsi":true`) || + !strings.Contains(strategiesRaw, `"enable_atr":true`) || + !strings.Contains(strategiesRaw, `"enable_boll":true`) { + t.Fatalf("expected strategy config to include updated confidence and indicators, got %s", strategiesRaw) + } +} diff --git a/agent/skill_execution_handlers.go b/agent/skill_execution_handlers.go new file mode 100644 index 00000000..98db45cd --- /dev/null +++ b/agent/skill_execution_handlers.go @@ -0,0 +1,1222 @@ +package agent + +import ( + "encoding/json" + "fmt" + "regexp" + "sort" + "strconv" + "strings" + + "nofx/store" +) + +var ( + firstIntegerPattern = regexp.MustCompile(`\d+`) + timeframeTokenRE = regexp.MustCompile(`(?i)\b\d{1,2}[mhdw]\b`) +) + +func parseStandaloneInteger(text string) (int, bool) { + match := firstIntegerPattern.FindString(strings.TrimSpace(text)) + if match == "" { + return 0, false + } + value, err := strconv.Atoi(match) + if err != nil { + return 0, false + } + return value, true +} + +func parseEnabledValue(text string) (bool, bool) { + lower := strings.ToLower(strings.TrimSpace(text)) + switch { + case containsAny(lower, []string{"启用", "打开", "开启", "enable", "enabled", "on"}): + return true, true + case containsAny(lower, []string{"禁用", "关闭", "停用", "disable", "disabled", "off"}): + return false, true + default: + return false, false + } +} + +func parseFlagValue(text string, keywords []string) (bool, bool) { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" || !containsAny(lower, keywords) { + return false, false + } + switch { + case containsAny(lower, []string{"启用", "打开", "开启", "使用", "用", "是", "true", "enable", "enabled", "on", "use"}): + return true, true + case containsAny(lower, []string{"禁用", "关闭", "停用", "不用", "不要", "否", "false", "disable", "disabled", "off", "don't use", "do not use"}): + return false, true + default: + return false, false + } +} + +func extractCredentialValue(text string, keywords []string) string { + if value := extractQuotedContent(text); value != "" && containsAny(strings.ToLower(text), keywords) { + return value + } + return extractPostKeywordName(text, keywords) +} + +func parseScanIntervalMinutes(text string) (int, bool) { + if value, ok := extractLabeledInt(text, []string{"扫描间隔", "扫描频率", "scan interval", "scan frequency"}); ok { + return value, true + } + lower := strings.ToLower(strings.TrimSpace(text)) + if !containsAny(lower, []string{"扫描间隔", "扫描频率", "scan interval", "scan frequency"}) { + return 0, false + } + return parseStandaloneInteger(text) +} + +func detectStrategyConfigField(text string) string { + lower := strings.ToLower(strings.TrimSpace(text)) + switch { + case containsAny(lower, []string{"最大持仓", "最多持仓", "max positions"}): + return "max_positions" + case containsAny(lower, []string{"最低置信度", "最小置信度", "min confidence"}): + return "min_confidence" + case containsAny(lower, []string{"btc/eth杠杆", "btc eth杠杆", "btc eth leverage", "btc/eth leverage", "主流币杠杆"}): + return "btceth_max_leverage" + case containsAny(lower, []string{"山寨币杠杆", "altcoin leverage", "alts leverage"}): + return "altcoin_max_leverage" + case containsAny(lower, []string{"ema"}): + return "enable_ema" + case containsAny(lower, []string{"macd"}): + return "enable_macd" + case containsAny(lower, []string{"rsi"}): + return "enable_rsi" + case containsAny(lower, []string{"atr"}): + return "enable_atr" + case containsAny(lower, []string{"boll", "bollinger", "布林"}): + return "enable_boll" + case containsAny(lower, []string{"核心指标"}) && containsAny(lower, []string{"全选", "全部", "全开", "都开", "都启用", "全部启用"}): + return "enable_all_core_indicators" + case containsAny(lower, []string{"主周期", "主时间周期", "primary timeframe"}): + return "primary_timeframe" + case containsAny(lower, []string{"多周期", "时间框架", "timeframes", "selected timeframes"}): + return "selected_timeframes" + default: + return "" + } +} + +func strategyConfigFieldDisplayName(field, lang string) string { + switch field { + case "max_positions": + if lang == "zh" { + return "最大持仓" + } + return "max positions" + case "min_confidence": + if lang == "zh" { + return "最小置信度" + } + return "min confidence" + case "btceth_max_leverage": + if lang == "zh" { + return "BTC/ETH 最大杠杆" + } + return "BTC/ETH max leverage" + case "altcoin_max_leverage": + if lang == "zh" { + return "山寨币最大杠杆" + } + return "altcoin max leverage" + case "enable_ema": + if lang == "zh" { + return "EMA" + } + return "EMA" + case "enable_macd": + if lang == "zh" { + return "MACD" + } + return "MACD" + case "enable_rsi": + if lang == "zh" { + return "RSI" + } + return "RSI" + case "enable_atr": + if lang == "zh" { + return "ATR" + } + return "ATR" + case "enable_boll": + if lang == "zh" { + return "Bollinger" + } + return "Bollinger" + case "enable_all_core_indicators": + if lang == "zh" { + return "全部核心指标" + } + return "all core indicators" + case "primary_timeframe": + if lang == "zh" { + return "主周期" + } + return "primary timeframe" + case "selected_timeframes": + if lang == "zh" { + return "多周期时间框架" + } + return "selected timeframes" + default: + return field + } +} + +func extractStrategyConfigValue(text, field string) (string, bool) { + switch field { + case "max_positions": + if value, ok := extractLabeledInt(text, []string{"最大持仓", "最多持仓", "max positions"}); ok { + return strconv.Itoa(value), true + } + if value, ok := parseStandaloneInteger(text); ok { + return strconv.Itoa(value), true + } + case "min_confidence": + if value, ok := extractLabeledInt(text, []string{"最低置信度", "最小置信度", "min confidence"}); ok { + return strconv.Itoa(value), true + } + if value, ok := parseStandaloneInteger(text); ok { + return strconv.Itoa(value), true + } + case "btceth_max_leverage": + if value, ok := extractLabeledInt(text, []string{"btc/eth杠杆", "btc eth杠杆", "btc/eth leverage", "btc eth leverage", "主流币杠杆"}); ok { + return strconv.Itoa(value), true + } + if value, ok := parseStandaloneInteger(text); ok { + return strconv.Itoa(value), true + } + case "altcoin_max_leverage": + if value, ok := extractLabeledInt(text, []string{"山寨币杠杆", "altcoin leverage", "alts leverage"}); ok { + return strconv.Itoa(value), true + } + if value, ok := parseStandaloneInteger(text); ok { + return strconv.Itoa(value), true + } + case "enable_ema", "enable_macd", "enable_rsi", "enable_atr", "enable_boll": + if enabled, ok := parseEnabledValue(text); ok { + return strconv.FormatBool(enabled), true + } + case "enable_all_core_indicators": + lower := strings.ToLower(strings.TrimSpace(text)) + switch { + case containsAny(lower, []string{"全选", "全部", "全开", "都开", "都启用", "全部启用"}): + return "true", true + case containsAny(lower, []string{"关闭", "停用", "禁用", "全部关闭", "全部禁用"}): + return "false", true + } + case "primary_timeframe": + if tf := extractTimeframeAfterKeywords(text, []string{"主周期", "主时间周期", "primary timeframe", "timeframe"}); tf != "" { + return tf, true + } + case "selected_timeframes": + if tfs := extractTimeframes(text); len(tfs) > 0 { + return strings.Join(tfs, ","), true + } + } + return "", false +} + +type strategyConfigPatch struct { + Field string + Value string +} + +func detectStrategyConfigPatches(text string) []strategyConfigPatch { + seen := map[string]string{} + addPatch := func(field, value string) { + field = strings.TrimSpace(field) + value = strings.TrimSpace(value) + if field == "" || value == "" { + return + } + seen[field] = value + } + + for _, field := range []string{ + "max_positions", + "min_confidence", + "btceth_max_leverage", + "altcoin_max_leverage", + "primary_timeframe", + "selected_timeframes", + "enable_ema", + "enable_macd", + "enable_rsi", + "enable_atr", + "enable_boll", + "enable_all_core_indicators", + } { + if value, ok := extractStrategyConfigValue(text, field); ok { + if field == "enable_all_core_indicators" { + addPatch("enable_ema", value) + addPatch("enable_macd", value) + addPatch("enable_rsi", value) + addPatch("enable_atr", value) + addPatch("enable_boll", value) + continue + } + addPatch(field, value) + } + } + + fields := make([]string, 0, len(seen)) + for field := range seen { + fields = append(fields, field) + } + sort.Strings(fields) + + patches := make([]strategyConfigPatch, 0, len(fields)) + for _, field := range fields { + patches = append(patches, strategyConfigPatch{Field: field, Value: seen[field]}) + } + return patches +} + +func applyStrategyConfigPatch(cfg *store.StrategyConfig, field, value string) error { + switch field { + case "max_positions": + parsed, err := strconv.Atoi(value) + if err != nil { + return fmt.Errorf("最大持仓需要是整数") + } + cfg.RiskControl.MaxPositions = parsed + case "min_confidence": + parsed, err := strconv.Atoi(value) + if err != nil { + return fmt.Errorf("最小置信度需要是整数") + } + cfg.RiskControl.MinConfidence = parsed + case "btceth_max_leverage": + parsed, err := strconv.Atoi(value) + if err != nil { + return fmt.Errorf("BTC/ETH 最大杠杆需要是整数") + } + cfg.RiskControl.BTCETHMaxLeverage = parsed + case "altcoin_max_leverage": + parsed, err := strconv.Atoi(value) + if err != nil { + return fmt.Errorf("山寨币最大杠杆需要是整数") + } + cfg.RiskControl.AltcoinMaxLeverage = parsed + case "primary_timeframe": + cfg.Indicators.Klines.PrimaryTimeframe = value + case "selected_timeframes": + tfs := strings.Split(value, ",") + cfg.Indicators.Klines.SelectedTimeframes = tfs + cfg.Indicators.Klines.EnableMultiTimeframe = len(tfs) > 1 + case "enable_ema": + cfg.Indicators.EnableEMA = value == "true" + case "enable_macd": + cfg.Indicators.EnableMACD = value == "true" + case "enable_rsi": + cfg.Indicators.EnableRSI = value == "true" + case "enable_atr": + cfg.Indicators.EnableATR = value == "true" + case "enable_boll": + cfg.Indicators.EnableBOLL = value == "true" + default: + return fmt.Errorf("unsupported strategy config field: %s", field) + } + return nil +} + +func (a *Agent) executeTraderManagementAction(storeUserID string, userID int64, lang, text string, session skillSession) string { + switch session.Action { + case "query", "query_list": + return formatReadFastPathResponse(lang, "list_traders", a.toolListTraders(storeUserID)) + case "query_detail": + if detail, ok := a.describeTrader(storeUserID, lang, session.TargetRef); ok { + return detail + } + return formatReadFastPathResponse(lang, "list_traders", a.toolListTraders(storeUserID)) + case "start", "stop", "delete": + if fieldValue(session, skillDAGStepField) == "" { + setSkillDAGStep(&session, "await_confirmation") + } + if msg, waiting := beginConfirmationIfNeeded(userID, lang, &session, defaultIfEmpty(session.TargetRef.Name, session.TargetRef.ID)); waiting { + a.saveSkillSession(userID, session) + return msg + } + if msg, waiting := awaitingConfirmationButNotApproved(lang, session, text); waiting { + a.saveSkillSession(userID, session) + return msg + } + var resp string + switch session.Action { + case "start": + setSkillDAGStep(&session, "execute_start") + resp = a.toolStartTrader(storeUserID, session.TargetRef.ID) + case "stop": + setSkillDAGStep(&session, "execute_stop") + resp = a.toolStopTrader(storeUserID, session.TargetRef.ID) + case "delete": + setSkillDAGStep(&session, "execute_delete") + resp = a.toolDeleteTrader(storeUserID, session.TargetRef.ID) + } + a.clearSkillSession(userID) + if errMsg := parseSkillError(resp); strings.Contains(resp, `"error"`) { + if lang == "zh" { + return "执行失败：" + errMsg + } + return "Action failed: " + errMsg + } + if lang == "zh" { + return fmt.Sprintf("已完成交易员操作：%s。", session.Action) + } + return fmt.Sprintf("Completed trader action: %s.", session.Action) + case "update", "update_name", "update_bindings": + if session.Action == "update_bindings" { + if fieldValue(session, skillDAGStepField) == "" { + setSkillDAGStep(&session, "collect_bindings") + } + args := manageTraderArgs{Action: "update", TraderID: session.TargetRef.ID} + if match := pickMentionedOption(text, a.loadEnabledModelOptions(storeUserID)); match != nil { + args.AIModelID = match.ID + } + if match := pickMentionedOption(text, a.loadExchangeOptions(storeUserID)); match != nil { + args.ExchangeID = match.ID + } + if match := pickMentionedOption(text, a.loadStrategyOptions(storeUserID)); match != nil { + args.StrategyID = match.ID + } + if args.AIModelID != "" { + setField(&session, "ai_model_id", args.AIModelID) + } + if args.ExchangeID != "" { + setField(&session, "exchange_id", args.ExchangeID) + } + if args.StrategyID != "" { + setField(&session, "strategy_id", args.StrategyID) + } + if value := fieldValue(session, "ai_model_id"); value != "" { + args.AIModelID = value + } + if value := fieldValue(session, "exchange_id"); value != "" { + args.ExchangeID = value + } + if value := fieldValue(session, "strategy_id"); value != "" { + args.StrategyID = value + } + if args.AIModelID == "" && args.ExchangeID == "" && args.StrategyID == "" { + setSkillDAGStep(&session, "collect_bindings") + a.saveSkillSession(userID, session) + if lang == "zh" { + return "这次是更新交易员绑定，请直接说要换成哪个模型、交易所或策略。" + } + return "This action updates trader bindings. Tell me which model, exchange, or strategy to switch to." + } + setSkillDAGStep(&session, "execute_update") + resp := a.toolUpdateTrader(storeUserID, args) + a.clearSkillSession(userID) + if errMsg := parseSkillError(resp); strings.Contains(resp, `"error"`) { + if lang == "zh" { + return "更新交易员绑定失败：" + errMsg + } + return "Failed to update trader bindings: " + errMsg + } + if lang == "zh" { + return "已更新交易员绑定。" + } + return "Updated trader bindings." + } + if fieldValue(session, skillDAGStepField) == "" { + setSkillDAGStep(&session, "collect_name") + } + args := manageTraderArgs{Action: "update", TraderID: session.TargetRef.ID} + if minutes, ok := parseScanIntervalMinutes(text); ok && minutes > 0 { + args.ScanIntervalMinutes = &minutes + } + if value, ok := extractStrategyConfigValue(text, "btceth_max_leverage"); ok { + if parsed, err := strconv.Atoi(value); err == nil { + args.BTCETHLeverage = &parsed + } + } + if value, ok := extractStrategyConfigValue(text, "altcoin_max_leverage"); ok { + if parsed, err := strconv.Atoi(value); err == nil { + args.AltcoinLeverage = &parsed + } + } + if prompt := extractCredentialValue(text, []string{"自定义提示词", "提示词", "custom prompt", "prompt"}); prompt != "" && + containsAny(strings.ToLower(text), []string{"提示词", "prompt"}) { + args.CustomPrompt = prompt + } + if enabled, ok := parseFlagValue(text, []string{"ai500"}); ok { + args.UseAI500 = &enabled + } + if enabled, ok := parseFlagValue(text, []string{"oi top", "oitop", "持仓量排名"}); ok { + args.UseOITop = &enabled + } + if args.ScanIntervalMinutes != nil || args.BTCETHLeverage != nil || args.AltcoinLeverage != nil || args.CustomPrompt != "" || args.UseAI500 != nil || args.UseOITop != nil { + setSkillDAGStep(&session, "execute_update") + resp := a.toolUpdateTrader(storeUserID, args) + a.clearSkillSession(userID) + if errMsg := parseSkillError(resp); strings.Contains(resp, `"error"`) { + if lang == "zh" { + return "更新交易员失败：" + errMsg + } + return "Failed to update trader: " + errMsg + } + if lang == "zh" { + return "已更新交易员配置。" + } + return "Updated trader config." + } + newName := extractTraderName(text) + if newName == "" { + newName = extractPostKeywordName(text, []string{"改成", "改为", "rename to"}) + } + if newName != "" { + setField(&session, "name", newName) + } + newName = fieldValue(session, "name") + if newName == "" { + setSkillDAGStep(&session, "collect_name") + a.saveSkillSession(userID, session) + if lang == "zh" { + return "目前更新交易员这条 skill 先支持改名。请直接告诉我新的名字。" + } + return "This trader update skill currently supports renaming first. Tell me the new name." + } + args = manageTraderArgs{Action: "update", TraderID: session.TargetRef.ID, Name: newName} + setSkillDAGStep(&session, "execute_update") + resp := a.toolUpdateTrader(storeUserID, args) + a.clearSkillSession(userID) + if errMsg := parseSkillError(resp); strings.Contains(resp, `"error"`) { + if lang == "zh" { + return "更新交易员失败：" + errMsg + } + return "Failed to update trader: " + errMsg + } + if lang == "zh" { + return fmt.Sprintf("已将交易员改名为“%s”。", newName) + } + return fmt.Sprintf("Renamed trader to %q.", newName) + default: + return "" + } +} + +func (a *Agent) executeExchangeManagementAction(storeUserID string, userID int64, lang, text string, session skillSession) string { + switch session.Action { + case "query_detail": + if detail, ok := a.describeExchange(storeUserID, lang, session.TargetRef); ok { + return detail + } + return formatReadFastPathResponse(lang, "get_exchange_configs", a.toolGetExchangeConfigs(storeUserID)) + case "delete": + if fieldValue(session, skillDAGStepField) == "" { + setSkillDAGStep(&session, "await_confirmation") + } + if msg, waiting := beginConfirmationIfNeeded(userID, lang, &session, defaultIfEmpty(session.TargetRef.Name, session.TargetRef.ID)); waiting { + a.saveSkillSession(userID, session) + return msg + } + if msg, waiting := awaitingConfirmationButNotApproved(lang, session, text); waiting { + a.saveSkillSession(userID, session) + return msg + } + setSkillDAGStep(&session, "execute_delete") + args, _ := json.Marshal(map[string]any{"action": "delete", "exchange_id": session.TargetRef.ID}) + resp := a.toolManageExchangeConfig(storeUserID, string(args)) + a.clearSkillSession(userID) + if errMsg := parseSkillError(resp); strings.Contains(resp, `"error"`) { + if lang == "zh" { + return "删除交易所配置失败：" + errMsg + } + return "Failed to delete exchange config: " + errMsg + } + if lang == "zh" { + return "已删除交易所配置。" + } + return "Deleted exchange config." + case "update", "update_name", "update_status": + if fieldValue(session, skillDAGStepField) == "" { + if session.Action == "update_status" { + setSkillDAGStep(&session, "collect_enabled") + } else { + setSkillDAGStep(&session, "collect_account_name") + } + } + accountName := extractTraderName(text) + if accountName == "" { + accountName = extractPostKeywordName(text, []string{"改成", "改为", "账户名改成", "rename to"}) + } + if accountName != "" { + setField(&session, "account_name", accountName) + } + if enabled, ok := parseEnabledValue(text); ok { + setField(&session, "enabled", strconv.FormatBool(enabled)) + } + if value := extractCredentialValue(text, []string{"api key", "apikey", "api_key"}); value != "" { + setField(&session, "api_key", value) + } + if value := extractCredentialValue(text, []string{"secret key", "secret", "secret_key"}); value != "" { + setField(&session, "secret_key", value) + } + if value := extractCredentialValue(text, []string{"passphrase", "密码短语"}); value != "" { + setField(&session, "passphrase", value) + } + if testnet, ok := parseFlagValue(text, []string{"testnet", "测试网"}); ok { + setField(&session, "testnet", strconv.FormatBool(testnet)) + } + payload := map[string]any{"action": "update", "exchange_id": session.TargetRef.ID} + accountName = fieldValue(session, "account_name") + if accountName != "" && session.Action != "update_status" { + payload["account_name"] = accountName + } + if enabledRaw := fieldValue(session, "enabled"); enabledRaw != "" { + payload["enabled"] = enabledRaw == "true" + } + if value := fieldValue(session, "api_key"); value != "" { + payload["api_key"] = value + } + if value := fieldValue(session, "secret_key"); value != "" { + payload["secret_key"] = value + } + if value := fieldValue(session, "passphrase"); value != "" { + payload["passphrase"] = value + } + if value := fieldValue(session, "testnet"); value != "" { + payload["testnet"] = value == "true" + } + if session.Action == "update_status" { + delete(payload, "account_name") + } + if len(payload) == 2 { + if session.Action == "update_status" { + setSkillDAGStep(&session, "collect_enabled") + } else { + setSkillDAGStep(&session, "collect_account_name") + } + a.saveSkillSession(userID, session) + if lang == "zh" { + return "目前更新交易所 skill 支持改账户名、启用状态、API Key、Secret、Passphrase 和 testnet。请告诉我你要改什么。" + } + return "This exchange update skill supports account name, enabled state, API key, secret, passphrase, and testnet." + } + setSkillDAGStep(&session, "execute_update") + raw, _ := json.Marshal(payload) + resp := a.toolManageExchangeConfig(storeUserID, string(raw)) + a.clearSkillSession(userID) + if errMsg := parseSkillError(resp); strings.Contains(resp, `"error"`) { + if lang == "zh" { + return "更新交易所配置失败：" + errMsg + } + return "Failed to update exchange config: " + errMsg + } + if lang == "zh" { + return "已更新交易所配置。" + } + return "Updated exchange config." + default: + return "" + } +} + +func (a *Agent) executeModelManagementAction(storeUserID string, userID int64, lang, text string, session skillSession) string { + switch session.Action { + case "query_detail": + if detail, ok := a.describeModel(storeUserID, lang, session.TargetRef); ok { + return detail + } + return formatReadFastPathResponse(lang, "get_model_configs", a.toolGetModelConfigs(storeUserID)) + case "delete": + if fieldValue(session, skillDAGStepField) == "" { + setSkillDAGStep(&session, "await_confirmation") + } + if msg, waiting := beginConfirmationIfNeeded(userID, lang, &session, defaultIfEmpty(session.TargetRef.Name, session.TargetRef.ID)); waiting { + a.saveSkillSession(userID, session) + return msg + } + if msg, waiting := awaitingConfirmationButNotApproved(lang, session, text); waiting { + a.saveSkillSession(userID, session) + return msg + } + setSkillDAGStep(&session, "execute_delete") + raw, _ := json.Marshal(map[string]any{"action": "delete", "model_id": session.TargetRef.ID}) + resp := a.toolManageModelConfig(storeUserID, string(raw)) + a.clearSkillSession(userID) + if errMsg := parseSkillError(resp); strings.Contains(resp, `"error"`) { + if lang == "zh" { + return "删除模型配置失败：" + errMsg + } + return "Failed to delete model config: " + errMsg + } + if lang == "zh" { + return "已删除模型配置。" + } + return "Deleted model config." + case "update", "update_name", "update_endpoint", "update_status": + if fieldValue(session, skillDAGStepField) == "" { + switch session.Action { + case "update_status": + setSkillDAGStep(&session, "collect_enabled") + case "update_endpoint": + setSkillDAGStep(&session, "collect_custom_api_url") + default: + setSkillDAGStep(&session, "collect_custom_model_name") + } + } + payload := map[string]any{"action": "update", "model_id": session.TargetRef.ID} + if url := extractURL(text); url != "" { + setField(&session, "custom_api_url", url) + } + if enabled, ok := parseEnabledValue(text); ok { + setField(&session, "enabled", strconv.FormatBool(enabled)) + } + if apiKey := extractCredentialValue(text, []string{"api key", "apikey", "api_key"}); apiKey != "" { + setField(&session, "api_key", apiKey) + } + if modelName := extractPostKeywordName(text, []string{"model name", "模型名", "模型名称", "改成"}); modelName != "" { + setField(&session, "custom_model_name", modelName) + } + if value := fieldValue(session, "custom_api_url"); value != "" { + payload["custom_api_url"] = value + } + if value := fieldValue(session, "enabled"); value != "" { + payload["enabled"] = value == "true" + } + if value := fieldValue(session, "api_key"); value != "" { + payload["api_key"] = value + } + if value := fieldValue(session, "custom_model_name"); value != "" { + payload["custom_model_name"] = value + } + if session.Action == "update_name" { + delete(payload, "custom_api_url") + delete(payload, "enabled") + delete(payload, "api_key") + } + if session.Action == "update_status" { + delete(payload, "custom_api_url") + delete(payload, "custom_model_name") + delete(payload, "api_key") + } + if session.Action == "update_endpoint" { + delete(payload, "custom_model_name") + delete(payload, "enabled") + delete(payload, "api_key") + } + if len(payload) == 2 { + switch session.Action { + case "update_status": + setSkillDAGStep(&session, "collect_enabled") + case "update_endpoint": + setSkillDAGStep(&session, "collect_custom_api_url") + default: + setSkillDAGStep(&session, "collect_custom_model_name") + } + a.saveSkillSession(userID, session) + if lang == "zh" { + return "目前更新模型 skill 支持改 API Key、URL、模型名和启用状态。请告诉我你要改什么。" + } + return "This model update skill supports API key, URL, model name, and enabled state." + } + setSkillDAGStep(&session, "execute_update") + raw, _ := json.Marshal(payload) + resp := a.toolManageModelConfig(storeUserID, string(raw)) + if errMsg := parseSkillError(resp); strings.Contains(resp, `"error"`) { + a.saveSkillSession(userID, session) + if lang == "zh" { + if strings.Contains(errMsg, "cannot enable model config before API key is configured") { + return "更新模型配置失败：这个模型还没有配置 API Key，暂时不能启用。你可以直接把 API Key 发给我，我帮你继续配置。" + } + return "更新模型配置失败：" + errMsg + } + a.saveSkillSession(userID, session) + return "Failed to update model config: " + errMsg + } + a.clearSkillSession(userID) + if lang == "zh" { + if session.Action == "update_status" { + return "已更新模型配置启用状态。" + } + return "已更新模型配置。" + } + return "Updated model config." + default: + return "" + } +} + +func (a *Agent) executeStrategyManagementAction(storeUserID string, userID int64, lang, text string, session skillSession) string { + switch session.Action { + case "query", "query_list": + return formatReadFastPathResponse(lang, "get_strategies", a.toolGetStrategies(storeUserID)) + case "query_detail": + if detail, ok := a.describeStrategy(storeUserID, lang, session.TargetRef); ok { + return detail + } + return formatReadFastPathResponse(lang, "get_strategies", a.toolGetStrategies(storeUserID)) + case "activate": + raw, _ := json.Marshal(map[string]any{"action": "activate", "strategy_id": session.TargetRef.ID}) + resp := a.toolManageStrategy(storeUserID, string(raw)) + a.clearSkillSession(userID) + if errMsg := parseSkillError(resp); strings.Contains(resp, `"error"`) { + if lang == "zh" { + return "激活策略失败：" + errMsg + } + return "Failed to activate strategy: " + errMsg + } + if lang == "zh" { + return "已激活策略。" + } + return "Activated strategy." + case "duplicate": + if fieldValue(session, skillDAGStepField) == "" { + setSkillDAGStep(&session, "collect_name") + } + newName := extractTraderName(text) + if newName == "" { + newName = extractPostKeywordName(text, []string{"叫", "名为", "改成", "rename to"}) + } + if newName != "" { + setField(&session, "name", newName) + } + newName = fieldValue(session, "name") + if newName == "" { + setSkillDAGStep(&session, "collect_name") + a.saveSkillSession(userID, session) + if lang == "zh" { + return "复制策略时，我还需要一个新名称。" + } + return "I still need a new name for the duplicated strategy." + } + setSkillDAGStep(&session, "execute_duplicate") + raw, _ := json.Marshal(map[string]any{"action": "duplicate", "strategy_id": session.TargetRef.ID, "name": newName}) + resp := a.toolManageStrategy(storeUserID, string(raw)) + a.clearSkillSession(userID) + if errMsg := parseSkillError(resp); strings.Contains(resp, `"error"`) { + if lang == "zh" { + return "复制策略失败：" + errMsg + } + return "Failed to duplicate strategy: " + errMsg + } + if lang == "zh" { + return fmt.Sprintf("已复制策略，新名称为“%s”。", newName) + } + return fmt.Sprintf("Duplicated strategy as %q.", newName) + case "delete": + if fieldValue(session, skillDAGStepField) == "" { + setSkillDAGStep(&session, "await_confirmation") + } + if fieldValue(session, "bulk_scope") == "all" { + strategies, err := a.store.Strategy().List(storeUserID) + if err != nil { + if lang == "zh" { + return "读取策略列表失败：" + err.Error() + } + return "Failed to load strategies: " + err.Error() + } + + deletable := make([]*store.Strategy, 0, len(strategies)) + skippedDefault := 0 + for _, strategy := range strategies { + if strategy == nil { + continue + } + if strategy.IsDefault { + skippedDefault++ + continue + } + deletable = append(deletable, strategy) + } + if len(deletable) == 0 { + a.clearSkillSession(userID) + if lang == "zh" { + return "当前没有可删除的自定义策略。" + } + return "There are no user-created strategies to delete." + } + + targetLabel := fmt.Sprintf("全部自定义策略（共 %d 个）", len(deletable)) + if msg, waiting := beginConfirmationIfNeeded(userID, lang, &session, targetLabel); waiting { + a.saveSkillSession(userID, session) + return msg + } + if msg, waiting := awaitingConfirmationButNotApproved(lang, session, text); waiting { + a.saveSkillSession(userID, session) + return msg + } + + setSkillDAGStep(&session, "execute_delete") + deletedNames := make([]string, 0, len(deletable)) + failedNames := make([]string, 0) + for _, strategy := range deletable { + raw, _ := json.Marshal(map[string]any{"action": "delete", "strategy_id": strategy.ID}) + resp := a.toolManageStrategy(storeUserID, string(raw)) + if errMsg := parseSkillError(resp); strings.Contains(resp, `"error"`) { + failedNames = append(failedNames, fmt.Sprintf("%s（%s）", strategy.Name, errMsg)) + continue + } + deletedNames = append(deletedNames, strategy.Name) + } + a.clearSkillSession(userID) + + if lang == "zh" { + parts := []string{fmt.Sprintf("批量删除策略已完成：成功删除 %d 个。", len(deletedNames))} + if skippedDefault > 0 { + parts = append(parts, fmt.Sprintf("已跳过系统默认策略 %d 个。", skippedDefault)) + } + if len(failedNames) > 0 { + parts = append(parts, "删除失败："+strings.Join(failedNames, "；")) + } + if len(deletedNames) > 0 { + parts = append(parts, "已删除："+strings.Join(deletedNames, "、")) + } + return strings.Join(parts, "\n") + } + + parts := []string{fmt.Sprintf("Bulk strategy deletion finished: deleted %d strategy(s).", len(deletedNames))} + if skippedDefault > 0 { + parts = append(parts, fmt.Sprintf("Skipped %d default strategy(ies).", skippedDefault)) + } + if len(failedNames) > 0 { + parts = append(parts, "Failed: "+strings.Join(failedNames, "; ")) + } + if len(deletedNames) > 0 { + parts = append(parts, "Deleted: "+strings.Join(deletedNames, ", ")) + } + return strings.Join(parts, "\n") + } + if msg, waiting := beginConfirmationIfNeeded(userID, lang, &session, defaultIfEmpty(session.TargetRef.Name, session.TargetRef.ID)); waiting { + a.saveSkillSession(userID, session) + return msg + } + if msg, waiting := awaitingConfirmationButNotApproved(lang, session, text); waiting { + a.saveSkillSession(userID, session) + return msg + } + setSkillDAGStep(&session, "execute_delete") + raw, _ := json.Marshal(map[string]any{"action": "delete", "strategy_id": session.TargetRef.ID}) + resp := a.toolManageStrategy(storeUserID, string(raw)) + a.clearSkillSession(userID) + if errMsg := parseSkillError(resp); strings.Contains(resp, `"error"`) { + if lang == "zh" { + return "删除策略失败：" + errMsg + } + return "Failed to delete strategy: " + errMsg + } + if lang == "zh" { + return "已删除策略。" + } + return "Deleted strategy." + case "update", "update_name", "update_config", "update_prompt": + if session.Action == "update_prompt" { + return a.executeStrategyPromptUpdate(storeUserID, userID, lang, text, session) + } + if session.Action == "update_config" { + return a.executeStrategyConfigUpdate(storeUserID, userID, lang, text, session) + } + if fieldValue(session, skillDAGStepField) == "" { + setSkillDAGStep(&session, "collect_name") + } + newName := extractTraderName(text) + if newName == "" { + newName = extractPostKeywordName(text, []string{"改成", "改为", "rename to"}) + } + if newName != "" { + setField(&session, "name", newName) + } + newName = fieldValue(session, "name") + if newName == "" { + setSkillDAGStep(&session, "collect_name") + a.saveSkillSession(userID, session) + if lang == "zh" { + return "目前更新策略 skill 先支持改名。请告诉我新的策略名称。" + } + return "This strategy update skill currently supports renaming first." + } + setSkillDAGStep(&session, "execute_update") + raw, _ := json.Marshal(map[string]any{"action": "update", "strategy_id": session.TargetRef.ID, "name": newName}) + resp := a.toolManageStrategy(storeUserID, string(raw)) + a.clearSkillSession(userID) + if errMsg := parseSkillError(resp); strings.Contains(resp, `"error"`) { + if lang == "zh" { + return "更新策略失败：" + errMsg + } + return "Failed to update strategy: " + errMsg + } + if lang == "zh" { + return fmt.Sprintf("已将策略改名为“%s”。", newName) + } + return fmt.Sprintf("Renamed strategy to %q.", newName) + default: + return "" + } +} + +func (a *Agent) executeStrategyPromptUpdate(storeUserID string, userID int64, lang, text string, session skillSession) string { + if fieldValue(session, skillDAGStepField) == "" { + setSkillDAGStep(&session, "collect_prompt") + } + strategy, cfg, err := a.loadStrategyConfigForUpdate(storeUserID, session.TargetRef.ID) + if err != nil { + if lang == "zh" { + return "读取策略失败：" + err.Error() + } + return "Failed to load strategy: " + err.Error() + } + + prompt := extractQuotedContent(text) + if prompt == "" { + prompt = extractPostKeywordName(text, []string{"prompt改成", "prompt 改成", "提示词改成", "提示词改为", "custom prompt 改成"}) + } + if prompt != "" { + setField(&session, "prompt", prompt) + } + prompt = fieldValue(session, "prompt") + if prompt == "" { + setSkillDAGStep(&session, "collect_prompt") + a.saveSkillSession(userID, session) + if lang == "zh" { + return "这次是更新策略 prompt，请直接把新的 prompt 内容发给我，最好放在引号里。" + } + return "This action updates the strategy prompt. Send me the new prompt text, ideally inside quotes." + } + + cfg.CustomPrompt = prompt + setSkillDAGStep(&session, "execute_update") + return a.persistStrategyConfigUpdate(storeUserID, userID, lang, strategy, cfg, "已更新策略 prompt。", "Updated strategy prompt.") +} + +func (a *Agent) executeStrategyConfigUpdate(storeUserID string, userID int64, lang, text string, session skillSession) string { + if _, ok := getSkillDAG("strategy_management", "update_config"); ok { + if fieldValue(session, skillDAGStepField) == "" { + setSkillDAGStep(&session, "resolve_config_field") + } + } + + currentStep, _ := currentSkillDAGStep(session) + strategy, cfg, err := a.loadStrategyConfigForUpdate(storeUserID, session.TargetRef.ID) + if err != nil { + if lang == "zh" { + return "读取策略失败：" + err.Error() + } + return "Failed to load strategy: " + err.Error() + } + + if fieldValue(session, "config_field") == "" && fieldValue(session, "config_value") == "" { + patches := detectStrategyConfigPatches(text) + if len(patches) > 1 { + changed := make([]string, 0, len(patches)) + for _, patch := range patches { + if err := applyStrategyConfigPatch(&cfg, patch.Field, patch.Value); err != nil { + a.saveSkillSession(userID, session) + if lang == "zh" { + return "更新策略参数失败：" + err.Error() + } + return "Failed to update strategy config: " + err.Error() + } + changed = append(changed, strategyConfigFieldDisplayName(patch.Field, lang)) + } + cfg.ClampLimits() + setSkillDAGStep(&session, "apply_field_update") + setSkillDAGStep(&session, "execute_update") + msgZH := "已更新策略参数：" + strings.Join(changed, "、") + "。" + msgEN := "Updated strategy config fields: " + strings.Join(changed, ", ") + "." + return a.persistStrategyConfigUpdate(storeUserID, userID, lang, strategy, cfg, msgZH, msgEN) + } + } + + field := fieldValue(session, "config_field") + if field == "" { + field = detectStrategyConfigField(text) + if field != "" { + setField(&session, "config_field", field) + if currentStep.ID == "resolve_config_field" { + advanceSkillDAGStep(&session, currentStep.ID) + currentStep, _ = currentSkillDAGStep(session) + } + } + } + if field == "" { + setSkillDAGStep(&session, "resolve_config_field") + a.saveSkillSession(userID, session) + if lang == "zh" { + return "这次是更新策略参数。我当前先支持这些字段：最大持仓、最低置信度、主周期、多周期时间框架。请先告诉我要改哪个字段。" + } + return "This action updates strategy config. I currently support max positions, min confidence, primary timeframe, and selected timeframes. Tell me which field to change first." + } + + if value, ok := extractStrategyConfigValue(text, field); ok { + setField(&session, "config_value", value) + if currentStep.ID == "resolve_config_value" { + advanceSkillDAGStep(&session, currentStep.ID) + currentStep, _ = currentSkillDAGStep(session) + } + } + value := fieldValue(session, "config_value") + if value == "" { + setSkillDAGStep(&session, "resolve_config_value") + a.saveSkillSession(userID, session) + if lang == "zh" { + return fmt.Sprintf("要更新策略参数，我还需要 %s 的目标值。", strategyConfigFieldDisplayName(field, lang)) + } + return fmt.Sprintf("I still need the target value for %s.", strategyConfigFieldDisplayName(field, lang)) + } + + if err := applyStrategyConfigPatch(&cfg, field, value); err != nil { + setSkillDAGStep(&session, "resolve_config_value") + a.saveSkillSession(userID, session) + if lang == "zh" { + return err.Error() + } + return err.Error() + } + + cfg.ClampLimits() + changed := []string{field} + displayChanged := make([]string, 0, len(changed)) + for _, item := range changed { + displayChanged = append(displayChanged, strategyConfigFieldDisplayName(item, lang)) + } + msgZH := "已更新策略参数：" + strings.Join(displayChanged, "、") + "。" + msgEN := "Updated strategy config fields: " + strings.Join(displayChanged, ", ") + "." + setSkillDAGStep(&session, "apply_field_update") + setSkillDAGStep(&session, "execute_update") + return a.persistStrategyConfigUpdate(storeUserID, userID, lang, strategy, cfg, msgZH, msgEN) +} + +func (a *Agent) loadStrategyConfigForUpdate(storeUserID, strategyID string) (*store.Strategy, store.StrategyConfig, error) { + strategy, err := a.store.Strategy().Get(storeUserID, strategyID) + if err != nil { + return nil, store.StrategyConfig{}, err + } + cfg := store.GetDefaultStrategyConfig("zh") + if strings.TrimSpace(strategy.Config) != "" { + _ = json.Unmarshal([]byte(strategy.Config), &cfg) + } + return strategy, cfg, nil +} + +func (a *Agent) persistStrategyConfigUpdate(storeUserID string, userID int64, lang string, strategy *store.Strategy, cfg store.StrategyConfig, zhMsg, enMsg string) string { + rawConfig, err := json.Marshal(cfg) + if err != nil { + if lang == "zh" { + return "序列化策略配置失败：" + err.Error() + } + return "Failed to serialize strategy config: " + err.Error() + } + raw, _ := json.Marshal(map[string]any{ + "action": "update", + "strategy_id": strategy.ID, + "config": json.RawMessage(rawConfig), + }) + resp := a.toolManageStrategy(storeUserID, string(raw)) + a.clearSkillSession(userID) + if errMsg := parseSkillError(resp); strings.Contains(resp, `"error"`) { + if lang == "zh" { + return "更新策略失败：" + errMsg + } + return "Failed to update strategy: " + errMsg + } + if lang == "zh" { + return zhMsg + } + return enMsg +} + +func extractQuotedContent(text string) string { + if matches := quotedNamePattern.FindStringSubmatch(text); len(matches) == 2 { + return strings.TrimSpace(matches[1]) + } + return "" +} + +func extractLabeledInt(text string, labels []string) (int, bool) { + lower := strings.ToLower(text) + for _, label := range labels { + idx := strings.Index(lower, strings.ToLower(label)) + if idx < 0 { + continue + } + segment := text[idx:] + if match := firstIntegerPattern.FindString(segment); match != "" { + if value, err := strconv.Atoi(match); err == nil { + return value, true + } + } + } + return 0, false +} + +func extractTimeframeAfterKeywords(text string, labels []string) string { + lower := strings.ToLower(text) + for _, label := range labels { + idx := strings.Index(lower, strings.ToLower(label)) + if idx < 0 { + continue + } + segment := text[idx:] + if match := timeframeTokenRE.FindString(segment); match != "" { + return strings.ToLower(match) + } + } + return "" +} + +func extractTimeframes(text string) []string { + matches := timeframeTokenRE.FindAllString(text, -1) + if len(matches) == 0 { + return nil + } + seen := make(map[string]struct{}, len(matches)) + out := make([]string, 0, len(matches)) + for _, match := range matches { + tf := strings.ToLower(strings.TrimSpace(match)) + if tf == "" { + continue + } + if _, ok := seen[tf]; ok { + continue + } + seen[tf] = struct{}{} + out = append(out, tf) + } + return out +} + +func (a *Agent) handleTraderDiagnosisSkill(storeUserID, lang, text string) string { + raw := a.toolListTraders(storeUserID) + list := formatReadFastPathResponse(lang, "list_traders", raw) + if lang == "zh" { + reply := "现象：这是交易员运行诊断问题。\n优先排查：\n1. 交易员是否已创建并处于运行状态。\n2. 绑定的模型、交易所、策略是否齐全。\n3. 是“没有启动”、还是“启动了但 AI 没有下单”、还是“下单失败”。\n当前交易员概览：\n" + list + if excerpt := backendLogDiagnosisExcerpt(lang, text, "trader"); excerpt != "" { + reply += "\n" + excerpt + } + return reply + } + reply := "This looks like a trader diagnosis issue.\nCheck whether the trader exists, is running, and has model/exchange/strategy bindings.\nCurrent trader overview:\n" + list + if excerpt := backendLogDiagnosisExcerpt(lang, text, "trader"); excerpt != "" { + reply += "\n" + excerpt + } + return reply +} + +func (a *Agent) handleStrategyDiagnosisSkill(storeUserID, lang, text string) string { + raw := a.toolGetStrategies(storeUserID) + list := formatReadFastPathResponse(lang, "get_strategies", raw) + if lang == "zh" { + reply := "现象：这是策略或提示词生效问题。\n优先排查：\n1. 你改的是策略模板，还是 trader 上的 custom prompt。\n2. 策略是否真的保存成功。\n3. 运行结果不符合预期，是配置问题还是市场条件问题。\n当前策略概览：\n" + list + if excerpt := backendLogDiagnosisExcerpt(lang, text, "strategy"); excerpt != "" { + reply += "\n" + excerpt + } + return reply + } + reply := "This looks like a strategy or prompt diagnosis issue.\nCheck whether you changed the strategy template or a trader-specific prompt override.\nCurrent strategy overview:\n" + list + if excerpt := backendLogDiagnosisExcerpt(lang, text, "strategy"); excerpt != "" { + reply += "\n" + excerpt + } + return reply +} diff --git a/agent/skill_management_handlers.go b/agent/skill_management_handlers.go new file mode 100644 index 00000000..ce7bba2b --- /dev/null +++ b/agent/skill_management_handlers.go @@ -0,0 +1,931 @@ +package agent + +import ( + "encoding/json" + "fmt" + "regexp" + "sort" + "strings" + + "nofx/store" +) + +var urlPattern = regexp.MustCompile(`https://[^\s"'<>]+`) + +func detectTraderManagementIntent(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + return containsAny(lower, []string{"交易员", "trader", "agent"}) && + containsAny(lower, []string{"修改", "编辑", "更新", "改", "改一下", "删除", "删了", "启动", "停止", "查看", "查询", "列出", "rename", "update", "delete", "start", "stop", "list", "show"}) +} + +func detectExchangeManagementIntent(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + return containsAny(lower, []string{"交易所", "exchange", "okx", "binance", "bybit", "gate", "kucoin", "hyperliquid"}) && + containsAny(lower, []string{"创建", "新建", "修改", "编辑", "更新", "改", "改一下", "删除", "删了", "查询", "查看", "列出", "启用", "禁用", "改名", "rename", "create", "update", "delete", "list", "show", "enable", "disable"}) +} + +func detectModelManagementIntent(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + return containsAny(lower, []string{"模型", "model", "provider", "deepseek", "openai", "claude", "gemini", "qwen", "kimi", "grok", "minimax"}) && + containsAny(lower, []string{"创建", "新建", "修改", "编辑", "更新", "改", "改一下", "删除", "删了", "查询", "查看", "列出", "启用", "禁用", "改名", "rename", "create", "update", "delete", "list", "show", "enable", "disable"}) +} + +func detectStrategyManagementIntent(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + if wantsDefaultStrategyConfig(text) { + return true + } + return containsAny(lower, []string{"策略", "strategy"}) && + containsAny(lower, []string{"创建", "新建", "修改", "编辑", "更新", "改", "改一下", "改成", "改为", "删除", "删了", "查询", "查看", "列出", "激活", "复制", "参数", "配置", "详情", "详细", "prompt", "提示词", "什么样", "怎么样", "create", "update", "delete", "list", "show", "activate", "duplicate", "detail", "details", "config", "configuration", "parameter", "prompt", "what kind"}) +} + +func detectTraderDiagnosisSkill(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + return containsAny(lower, []string{"交易员", "trader"}) && + containsAny(lower, []string{"启动失败", "不交易", "没开仓", "无法启动", "异常", "失败", "diagnose", "error", "not trading"}) +} + +func detectStrategyDiagnosisSkill(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + return containsAny(lower, []string{"策略", "strategy", "prompt"}) && + containsAny(lower, []string{"不生效", "没生效", "异常", "失败", "不一致", "失效", "diagnose", "error"}) +} + +func detectManagementAction(text string, domain string) string { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return "" + } + hasUpdateVerb := containsAny(lower, []string{"修改", "编辑", "更新", "改", "rename", "update", "切换", "换成", "换到"}) + switch { + case containsAny(lower, []string{"删除", "删掉", "删了", "remove", "delete"}): + return "delete" + case containsAny(lower, []string{"启动", "开始", "run", "start"}) && domain == "trader": + return "start" + case containsAny(lower, []string{"停止", "停掉", "stop", "pause"}) && domain == "trader": + return "stop" + case containsAny(lower, []string{"激活", "activate"}) && domain == "strategy": + return "activate" + case containsAny(lower, []string{"复制", "duplicate"}) && domain == "strategy": + return "duplicate" + case containsAny(lower, []string{"改名", "重命名", "rename"}): + return "update_name" + case domain == "trader" && containsAny(lower, []string{"换模型", "换交易所", "换策略", "绑定", "切换模型", "切换交易所", "切换策略"}): + return "update_bindings" + case (domain == "exchange" || domain == "model") && containsAny(lower, []string{"启用", "禁用", "enable", "disable"}): + return "update_status" + case domain == "model" && hasUpdateVerb && containsAny(lower, []string{"url", "endpoint", "地址", "接口"}): + return "update_endpoint" + case domain == "strategy" && hasUpdateVerb && containsAny(lower, []string{"prompt", "提示词"}): + return "update_prompt" + case domain == "strategy" && hasUpdateVerb && containsAny(lower, []string{ + "参数", "配置", "config", "configuration", "parameter", + "最大持仓", "最小置信度", "最低置信度", "主周期", "多周期", "时间框架", + "btc/eth杠杆", "btc eth杠杆", "山寨币杠杆", + "核心指标", "ema", "macd", "rsi", "atr", "boll", "bollinger", "布林", + }): + return "update_config" + case containsAny(lower, []string{"修改", "编辑", "更新", "改", "rename", "update"}): + return "update" + case domain == "trader" && containsAny(lower, []string{"运行中的", "在跑", "running"}): + return "query_running" + case !containsAny(lower, []string{"创建", "新建", "create", "new"}) && + containsAny(lower, []string{"详情", "详细", "prompt", "提示词", "什么样", "怎么样", "detail", "details", "what kind"}): + return "query_detail" + case containsAny(lower, []string{"查询", "查看", "列出", "list", "show", "有哪些"}): + return "query_list" + case containsAny(lower, []string{"创建", "新建", "加一个", "create", "new"}): + return "create" + default: + return "" + } +} + +func exchangeTypeFromText(text string) string { + lower := strings.ToLower(text) + candidates := []string{"binance", "okx", "bybit", "gate", "kucoin", "hyperliquid", "aster", "lighter"} + for _, candidate := range candidates { + if strings.Contains(lower, candidate) { + return candidate + } + } + switch { + case strings.Contains(text, "币安"): + return "binance" + case strings.Contains(text, "欧易"): + return "okx" + case strings.Contains(text, "库币"): + return "kucoin" + default: + return "" + } +} + +func providerFromText(text string) string { + lower := strings.ToLower(text) + candidates := []string{"openai", "deepseek", "claude", "gemini", "qwen", "kimi", "grok", "minimax"} + for _, candidate := range candidates { + if strings.Contains(lower, candidate) { + return candidate + } + } + if strings.Contains(text, "通义") { + return "qwen" + } + return "" +} + +func extractURL(text string) string { + return strings.TrimSpace(urlPattern.FindString(text)) +} + +func extractPostKeywordName(text string, keywords []string) string { + trimmed := strings.TrimSpace(text) + for _, keyword := range keywords { + if idx := strings.Index(trimmed, keyword); idx >= 0 { + name := strings.TrimSpace(trimmed[idx+len(keyword):]) + name = strings.Trim(name, "“”\"'：: ") + if name != "" && len([]rune(name)) <= 50 { + return name + } + } + } + return "" +} + +func setField(session *skillSession, key, value string) { + ensureSkillFields(session) + value = strings.TrimSpace(value) + if value == "" { + return + } + session.Fields[key] = value +} + +func fieldValue(session skillSession, key string) string { + if session.Fields == nil { + return "" + } + return strings.TrimSpace(session.Fields[key]) +} + +func textMeansAllTargets(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + return containsAny(lower, []string{ + "全部", "所有", "全都", "全部策略", "所有策略", + "all", "all strategies", "every strategy", + }) +} + +func supportsBulkTargetSelection(skillName, action string) bool { + return skillName == "strategy_management" && action == "delete" +} + +func resolveTargetFromText(text string, options []traderSkillOption, existing *EntityReference) *EntityReference { + if existing != nil && (existing.ID != "" || existing.Name != "") { + return existing + } + if match := pickMentionedOption(text, options); match != nil { + return &EntityReference{ID: match.ID, Name: match.Name} + } + if choice := choosePreferredOption(options); choice != nil { + return &EntityReference{ID: choice.ID, Name: choice.Name} + } + return nil +} + +func (a *Agent) handleTraderManagementSkill(storeUserID string, userID int64, lang, text string, session skillSession) (string, bool) { + action := detectManagementAction(text, "trader") + if session.Name == "trader_management" && session.Action != "" { + action = session.Action + } + if action == "" || action == "create" { + return "", false + } + if action == "query_running" { + answer := formatReadFastPathResponse(lang, "list_traders", a.toolListTraders(storeUserID)) + return applyTraderQueryFilter(lang, answer, a.toolListTraders(storeUserID), "running_only"), true + } + if action == "query_detail" { + options := a.loadTraderOptions(storeUserID) + target := resolveTargetFromText(text, options, session.TargetRef) + if detail, ok := a.describeTrader(storeUserID, lang, target); ok { + return detail, true + } + return formatReadFastPathResponse(lang, "list_traders", a.toolListTraders(storeUserID)), true + } + return a.handleSimpleEntitySkill(storeUserID, userID, lang, text, session, "trader_management", action, a.loadTraderOptions(storeUserID)) +} + +func (a *Agent) handleExchangeManagementSkill(storeUserID string, userID int64, lang, text string, session skillSession) (string, bool) { + action := detectManagementAction(text, "exchange") + if session.Name == "exchange_management" && session.Action != "" { + action = session.Action + } + if action == "" { + return "", false + } + options := a.loadExchangeOptions(storeUserID) + switch action { + case "query_list": + return formatReadFastPathResponse(lang, "get_exchange_configs", a.toolGetExchangeConfigs(storeUserID)), true + case "query_detail": + target := resolveTargetFromText(text, options, session.TargetRef) + if detail, ok := a.describeExchange(storeUserID, lang, target); ok { + return detail, true + } + return formatReadFastPathResponse(lang, "get_exchange_configs", a.toolGetExchangeConfigs(storeUserID)), true + case "create": + return a.handleExchangeCreateSkill(storeUserID, userID, lang, text, session), true + default: + return a.handleSimpleEntitySkill(storeUserID, userID, lang, text, session, "exchange_management", action, options) + } +} + +func (a *Agent) handleModelManagementSkill(storeUserID string, userID int64, lang, text string, session skillSession) (string, bool) { + action := detectManagementAction(text, "model") + if session.Name == "model_management" && session.Action != "" { + action = session.Action + } + if action == "" { + return "", false + } + options := a.loadEnabledModelOptions(storeUserID) + switch action { + case "query_list": + return formatReadFastPathResponse(lang, "get_model_configs", a.toolGetModelConfigs(storeUserID)), true + case "query_detail": + target := resolveTargetFromText(text, options, session.TargetRef) + if detail, ok := a.describeModel(storeUserID, lang, target); ok { + return detail, true + } + return formatReadFastPathResponse(lang, "get_model_configs", a.toolGetModelConfigs(storeUserID)), true + case "create": + return a.handleModelCreateSkill(storeUserID, userID, lang, text, session), true + default: + return a.handleSimpleEntitySkill(storeUserID, userID, lang, text, session, "model_management", action, options) + } +} + +func (a *Agent) handleStrategyManagementSkill(storeUserID string, userID int64, lang, text string, session skillSession) (string, bool) { + action := detectManagementAction(text, "strategy") + if session.Name == "strategy_management" && session.Action != "" { + action = session.Action + } + if action == "" && wantsStrategyDetails(text) { + action = "query_detail" + } + if action == "" { + return "", false + } + options := a.loadStrategyOptions(storeUserID) + switch action { + case "query_detail": + if wantsDefaultStrategyConfig(text) { + return a.describeDefaultStrategyConfig(lang), true + } + target := resolveTargetFromText(text, options, session.TargetRef) + if detail, ok := a.describeStrategy(storeUserID, lang, target); ok { + return detail, true + } + return formatReadFastPathResponse(lang, "get_strategies", a.toolGetStrategies(storeUserID)), true + case "query_list": + return formatReadFastPathResponse(lang, "get_strategies", a.toolGetStrategies(storeUserID)), true + case "create": + return a.handleStrategyCreateSkill(storeUserID, userID, lang, text, session), true + default: + return a.handleSimpleEntitySkill(storeUserID, userID, lang, text, session, "strategy_management", action, options) + } +} + +func wantsStrategyDetails(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + return containsAny(lower, []string{ + "什么样", "怎么样", "详情", "详细", "参数", "配置", "prompt", "提示词", + "what kind", "details", "detail", "config", "configuration", "parameter", "prompt", + }) +} + +func wantsDefaultStrategyConfig(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + return containsAny(lower, []string{ + "默认配置", "默认策略", "默认模板", "模板配置", + "default config", "default strategy", "default template", + }) +} + +func (a *Agent) describeStrategy(storeUserID, lang string, target *EntityReference) (string, bool) { + if a.store == nil { + return "", false + } + + var strategy *store.Strategy + var err error + if target != nil && strings.TrimSpace(target.ID) != "" { + strategy, err = a.store.Strategy().Get(storeUserID, strings.TrimSpace(target.ID)) + } else if target != nil && strings.TrimSpace(target.Name) != "" { + strategies, listErr := a.store.Strategy().List(storeUserID) + if listErr != nil { + return "", false + } + for _, item := range strategies { + if item != nil && strings.EqualFold(strings.TrimSpace(item.Name), strings.TrimSpace(target.Name)) { + strategy = item + break + } + } + } else { + strategies, listErr := a.store.Strategy().List(storeUserID) + if listErr != nil || len(strategies) != 1 { + return "", false + } + strategy = strategies[0] + } + if err != nil || strategy == nil { + return "", false + } + + var cfg store.StrategyConfig + if strings.TrimSpace(strategy.Config) != "" { + _ = json.Unmarshal([]byte(strategy.Config), &cfg) + } + + return formatStrategyDetailResponse(lang, strategy, cfg), true +} + +func formatStrategyDetailResponse(lang string, strategy *store.Strategy, cfg store.StrategyConfig) string { + name := strings.TrimSpace(strategy.Name) + if name == "" { + name = strings.TrimSpace(strategy.ID) + } + + sourceBits := make([]string, 0, 4) + if strings.TrimSpace(cfg.CoinSource.SourceType) != "" { + sourceBits = append(sourceBits, cfg.CoinSource.SourceType) + } + if cfg.CoinSource.UseAI500 { + sourceBits = append(sourceBits, fmt.Sprintf("AI500=%d", cfg.CoinSource.AI500Limit)) + } + if cfg.CoinSource.UseOITop { + sourceBits = append(sourceBits, fmt.Sprintf("OITop=%d", cfg.CoinSource.OITopLimit)) + } + if cfg.CoinSource.UseOILow { + sourceBits = append(sourceBits, fmt.Sprintf("OILow=%d", cfg.CoinSource.OILowLimit)) + } + if len(cfg.CoinSource.StaticCoins) > 0 { + sourceBits = append(sourceBits, "static="+strings.Join(cfg.CoinSource.StaticCoins, ",")) + } + + timeframes := append([]string(nil), cfg.Indicators.Klines.SelectedTimeframes...) + if len(timeframes) == 0 { + timeframes = cleanStringList([]string{cfg.Indicators.Klines.PrimaryTimeframe, cfg.Indicators.Klines.LongerTimeframe}) + } + + indicatorBits := make([]string, 0, 8) + if cfg.Indicators.EnableRawKlines { + indicatorBits = append(indicatorBits, "raw_klines") + } + if cfg.Indicators.EnableVolume { + indicatorBits = append(indicatorBits, "volume") + } + if cfg.Indicators.EnableOI { + indicatorBits = append(indicatorBits, "oi") + } + if cfg.Indicators.EnableFundingRate { + indicatorBits = append(indicatorBits, "funding_rate") + } + if cfg.Indicators.EnableEMA { + indicatorBits = append(indicatorBits, "ema") + } + if cfg.Indicators.EnableMACD { + indicatorBits = append(indicatorBits, "macd") + } + if cfg.Indicators.EnableRSI { + indicatorBits = append(indicatorBits, "rsi") + } + if cfg.Indicators.EnableATR { + indicatorBits = append(indicatorBits, "atr") + } + if cfg.Indicators.EnableBOLL { + indicatorBits = append(indicatorBits, "boll") + } + sort.Strings(indicatorBits) + + promptBits := make([]string, 0, 5) + if strings.TrimSpace(cfg.PromptSections.RoleDefinition) != "" { + promptBits = append(promptBits, "role_definition") + } + if strings.TrimSpace(cfg.PromptSections.TradingFrequency) != "" { + promptBits = append(promptBits, "trading_frequency") + } + if strings.TrimSpace(cfg.PromptSections.EntryStandards) != "" { + promptBits = append(promptBits, "entry_standards") + } + if strings.TrimSpace(cfg.PromptSections.DecisionProcess) != "" { + promptBits = append(promptBits, "decision_process") + } + + customPrompt := strings.TrimSpace(cfg.CustomPrompt) + customPromptPreview := customPrompt + if len([]rune(customPromptPreview)) > 120 { + runes := []rune(customPromptPreview) + customPromptPreview = string(runes[:120]) + "..." + } + + if lang == "zh" { + lines := []string{ + fmt.Sprintf("策略“%s”概览：", name), + fmt.Sprintf("- 类型：%s", defaultIfEmpty(strings.TrimSpace(cfg.StrategyType), "ai_trading")), + fmt.Sprintf("- 语言：%s", defaultIfEmpty(strings.TrimSpace(cfg.Language), "zh")), + } + if strings.TrimSpace(strategy.Description) != "" { + lines = append(lines, fmt.Sprintf("- 描述：%s", strings.TrimSpace(strategy.Description))) + } + if len(sourceBits) > 0 { + lines = append(lines, "- 标的来源："+strings.Join(sourceBits, " | ")) + } + if len(timeframes) > 0 { + lines = append(lines, "- K线周期："+strings.Join(timeframes, " / ")) + } + lines = append(lines, fmt.Sprintf("- 仓位风险：最多持仓 %d，BTC/ETH 最大杠杆 %d，山寨最大杠杆 %d，最低置信度 %d", + cfg.RiskControl.MaxPositions, cfg.RiskControl.BTCETHMaxLeverage, cfg.RiskControl.AltcoinMaxLeverage, cfg.RiskControl.MinConfidence)) + if len(indicatorBits) > 0 { + lines = append(lines, "- 已启用指标："+strings.Join(indicatorBits, "、")) + } + if len(promptBits) > 0 { + lines = append(lines, "- Prompt 模块："+strings.Join(promptBits, "、")) + } + if customPromptPreview != "" { + lines = append(lines, "- 自定义 Prompt："+customPromptPreview) + } else { + lines = append(lines, "- 自定义 Prompt：当前为空，主要使用策略模板内置 prompt sections。") + } + lines = append(lines, "- 如果你要，我还可以继续展开这条策略的完整参数 JSON，或者逐段解释它的 prompt。") + return strings.Join(lines, "\n") + } + + lines := []string{ + fmt.Sprintf("Strategy %q overview:", name), + fmt.Sprintf("- Type: %s", defaultIfEmpty(strings.TrimSpace(cfg.StrategyType), "ai_trading")), + fmt.Sprintf("- Language: %s", defaultIfEmpty(strings.TrimSpace(cfg.Language), "en")), + } + if strings.TrimSpace(strategy.Description) != "" { + lines = append(lines, fmt.Sprintf("- Description: %s", strings.TrimSpace(strategy.Description))) + } + if len(sourceBits) > 0 { + lines = append(lines, "- Coin source: "+strings.Join(sourceBits, " | ")) + } + if len(timeframes) > 0 { + lines = append(lines, "- Timeframes: "+strings.Join(timeframes, " / ")) + } + lines = append(lines, fmt.Sprintf("- Risk: max positions %d, BTC/ETH max leverage %d, alt max leverage %d, min confidence %d", + cfg.RiskControl.MaxPositions, cfg.RiskControl.BTCETHMaxLeverage, cfg.RiskControl.AltcoinMaxLeverage, cfg.RiskControl.MinConfidence)) + if len(indicatorBits) > 0 { + lines = append(lines, "- Enabled indicators: "+strings.Join(indicatorBits, ", ")) + } + if len(promptBits) > 0 { + lines = append(lines, "- Prompt modules: "+strings.Join(promptBits, ", ")) + } + if customPromptPreview != "" { + lines = append(lines, "- Custom prompt: "+customPromptPreview) + } else { + lines = append(lines, "- Custom prompt: empty right now; it mainly uses the built-in prompt sections from the strategy template.") + } + lines = append(lines, "- I can also expand the full strategy config JSON or walk through the prompt section by section.") + return strings.Join(lines, "\n") +} + +func (a *Agent) describeDefaultStrategyConfig(lang string) string { + if lang != "zh" { + lang = "en" + } + cfg := store.GetDefaultStrategyConfig(lang) + name := "Default Strategy Template" + description := "System default strategy configuration template" + if lang == "zh" { + name = "默认策略模板" + description = "系统默认策略配置模板" + } + return formatStrategyDetailResponse(lang, &store.Strategy{ + ID: "default_strategy_template", + Name: name, + Description: description, + }, cfg) +} + +func (a *Agent) describeTrader(storeUserID, lang string, target *EntityReference) (string, bool) { + raw := a.toolListTraders(storeUserID) + var payload struct { + Traders []safeTraderToolConfig `json:"traders"` + } + if err := json.Unmarshal([]byte(raw), &payload); err != nil { + return "", false + } + trader := findTraderByReference(payload.Traders, target) + if trader == nil { + if len(payload.Traders) != 1 { + return "", false + } + trader = &payload.Traders[0] + } + if lang == "zh" { + status := "未运行" + if trader.IsRunning { + status = "运行中" + } + return fmt.Sprintf("交易员“%s”详情：\n- 状态：%s\n- 模型：%s\n- 交易所：%s\n- 策略：%s\n- 扫描间隔：%d 分钟\n- 初始余额：%.2f", + trader.Name, status, trader.AIModelID, trader.ExchangeID, defaultIfEmpty(trader.StrategyID, "未绑定"), trader.ScanIntervalMinutes, trader.InitialBalance), true + } + status := "stopped" + if trader.IsRunning { + status = "running" + } + return fmt.Sprintf("Trader %q details:\n- Status: %s\n- Model: %s\n- Exchange: %s\n- Strategy: %s\n- Scan interval: %d minutes\n- Initial balance: %.2f", + trader.Name, status, trader.AIModelID, trader.ExchangeID, defaultIfEmpty(trader.StrategyID, "none"), trader.ScanIntervalMinutes, trader.InitialBalance), true +} + +func (a *Agent) describeExchange(storeUserID, lang string, target *EntityReference) (string, bool) { + raw := a.toolGetExchangeConfigs(storeUserID) + var payload struct { + ExchangeConfigs []safeExchangeToolConfig `json:"exchange_configs"` + } + if err := json.Unmarshal([]byte(raw), &payload); err != nil { + return "", false + } + exchange := findExchangeByReference(payload.ExchangeConfigs, target) + if exchange == nil { + if len(payload.ExchangeConfigs) != 1 { + return "", false + } + exchange = &payload.ExchangeConfigs[0] + } + if lang == "zh" { + return fmt.Sprintf("交易所配置“%s”详情：\n- 交易所：%s\n- 已启用：%t\n- API Key：%t\n- Secret：%t\n- Passphrase：%t\n- Testnet：%t", + defaultIfEmpty(exchange.AccountName, exchange.ID), exchange.ExchangeType, exchange.Enabled, exchange.HasAPIKey, exchange.HasSecretKey, exchange.HasPassphrase, exchange.Testnet), true + } + return fmt.Sprintf("Exchange config %q details:\n- Exchange: %s\n- Enabled: %t\n- API key present: %t\n- Secret present: %t\n- Passphrase present: %t\n- Testnet: %t", + defaultIfEmpty(exchange.AccountName, exchange.ID), exchange.ExchangeType, exchange.Enabled, exchange.HasAPIKey, exchange.HasSecretKey, exchange.HasPassphrase, exchange.Testnet), true +} + +func (a *Agent) describeModel(storeUserID, lang string, target *EntityReference) (string, bool) { + raw := a.toolGetModelConfigs(storeUserID) + var payload struct { + ModelConfigs []safeModelToolConfig `json:"model_configs"` + } + if err := json.Unmarshal([]byte(raw), &payload); err != nil { + return "", false + } + model := findModelByReference(payload.ModelConfigs, target) + if model == nil { + if len(payload.ModelConfigs) != 1 { + return "", false + } + model = &payload.ModelConfigs[0] + } + if lang == "zh" { + return fmt.Sprintf("模型配置“%s”详情：\n- Provider：%s\n- 已启用：%t\n- API Key：%t\n- URL：%s\n- Model Name：%s", + defaultIfEmpty(model.Name, model.ID), model.Provider, model.Enabled, model.HasAPIKey, defaultIfEmpty(model.CustomAPIURL, "未设置"), defaultIfEmpty(model.CustomModelName, "未设置")), true + } + return fmt.Sprintf("Model config %q details:\n- Provider: %s\n- Enabled: %t\n- API key present: %t\n- URL: %s\n- Model name: %s", + defaultIfEmpty(model.Name, model.ID), model.Provider, model.Enabled, model.HasAPIKey, defaultIfEmpty(model.CustomAPIURL, "not set"), defaultIfEmpty(model.CustomModelName, "not set")), true +} + +func findTraderByReference(items []safeTraderToolConfig, target *EntityReference) *safeTraderToolConfig { + if target == nil { + return nil + } + for i := range items { + if strings.TrimSpace(target.ID) != "" && items[i].ID == strings.TrimSpace(target.ID) { + return &items[i] + } + if strings.TrimSpace(target.Name) != "" && strings.EqualFold(strings.TrimSpace(items[i].Name), strings.TrimSpace(target.Name)) { + return &items[i] + } + } + return nil +} + +func findExchangeByReference(items []safeExchangeToolConfig, target *EntityReference) *safeExchangeToolConfig { + if target == nil { + return nil + } + for i := range items { + name := defaultIfEmpty(items[i].AccountName, items[i].Name) + if strings.TrimSpace(target.ID) != "" && items[i].ID == strings.TrimSpace(target.ID) { + return &items[i] + } + if strings.TrimSpace(target.Name) != "" && strings.EqualFold(strings.TrimSpace(name), strings.TrimSpace(target.Name)) { + return &items[i] + } + } + return nil +} + +func findModelByReference(items []safeModelToolConfig, target *EntityReference) *safeModelToolConfig { + if target == nil { + return nil + } + for i := range items { + if strings.TrimSpace(target.ID) != "" && items[i].ID == strings.TrimSpace(target.ID) { + return &items[i] + } + if strings.TrimSpace(target.Name) != "" && strings.EqualFold(strings.TrimSpace(items[i].Name), strings.TrimSpace(target.Name)) { + return &items[i] + } + } + return nil +} + +func (a *Agent) loadTraderOptions(storeUserID string) []traderSkillOption { + if a.store == nil { + return nil + } + traders, err := a.store.Trader().List(storeUserID) + if err != nil { + return nil + } + out := make([]traderSkillOption, 0, len(traders)) + for _, trader := range traders { + out = append(out, traderSkillOption{ID: trader.ID, Name: trader.Name, Enabled: trader.IsRunning}) + } + return out +} + +func (a *Agent) handleExchangeCreateSkill(storeUserID string, userID int64, lang, text string, session skillSession) string { + if session.Name == "" { + session = skillSession{Name: "exchange_management", Action: "create", Phase: "collecting"} + } + if fieldValue(session, skillDAGStepField) == "" { + setSkillDAGStep(&session, "resolve_exchange_type") + } + if isCancelSkillReply(text) { + a.clearSkillSession(userID) + if lang == "zh" { + return "已取消当前创建交易所配置流程。" + } + return "Cancelled the current exchange creation flow." + } + if v := exchangeTypeFromText(text); fieldValue(session, "exchange_type") == "" && v != "" { + setField(&session, "exchange_type", v) + } + if v := extractTraderName(text); fieldValue(session, "account_name") == "" && v != "" { + setField(&session, "account_name", v) + } + exType := fieldValue(session, "exchange_type") + if actionRequiresSlot("exchange_management", "create", "exchange_type") && exType == "" { + setSkillDAGStep(&session, "resolve_exchange_type") + a.saveSkillSession(userID, session) + if lang == "zh" { + return "要创建交易所配置，我还需要：" + slotDisplayName("exchange_type", lang) + "。例如：OKX、Binance、Bybit。" + } + return "To create an exchange config, tell me which exchange to use, for example OKX, Binance, or Bybit." + } + accountName := fieldValue(session, "account_name") + if accountName == "" { + accountName = "Default" + } + setSkillDAGStep(&session, "execute_create") + args := map[string]any{ + "action": "create", + "exchange_type": exType, + "account_name": accountName, + } + raw, _ := json.Marshal(args) + resp := a.toolManageExchangeConfig(storeUserID, string(raw)) + if errMsg := parseSkillError(resp); strings.Contains(resp, `"error"`) { + a.saveSkillSession(userID, session) + if lang == "zh" { + return "创建交易所配置失败：" + errMsg + } + return "Failed to create exchange config: " + errMsg + } + a.clearSkillSession(userID) + if lang == "zh" { + return fmt.Sprintf("已创建交易所配置：%s（%s）。如需继续补 API Key、Secret 或 Passphrase，可以直接继续说。", accountName, exType) + } + return fmt.Sprintf("Created exchange config %s (%s). You can continue by adding API key, secret, or passphrase.", accountName, exType) +} + +func (a *Agent) handleModelCreateSkill(storeUserID string, userID int64, lang, text string, session skillSession) string { + if session.Name == "" { + session = skillSession{Name: "model_management", Action: "create", Phase: "collecting"} + } + if fieldValue(session, skillDAGStepField) == "" { + setSkillDAGStep(&session, "resolve_provider") + } + if isCancelSkillReply(text) { + a.clearSkillSession(userID) + if lang == "zh" { + return "已取消当前创建模型配置流程。" + } + return "Cancelled the current model creation flow." + } + if v := providerFromText(text); fieldValue(session, "provider") == "" && v != "" { + setField(&session, "provider", v) + } + if v := extractTraderName(text); fieldValue(session, "name") == "" && v != "" { + setField(&session, "name", v) + } + if v := extractURL(text); fieldValue(session, "custom_api_url") == "" && v != "" { + setField(&session, "custom_api_url", v) + } + provider := fieldValue(session, "provider") + if actionRequiresSlot("model_management", "create", "provider") && provider == "" { + setSkillDAGStep(&session, "resolve_provider") + a.saveSkillSession(userID, session) + if lang == "zh" { + return "要创建模型配置，我还需要：" + slotDisplayName("provider", lang) + "，例如：OpenAI、DeepSeek、Claude、Gemini。" + } + return "To create a model config, I need the provider first, for example OpenAI, DeepSeek, Claude, or Gemini." + } + setSkillDAGStep(&session, "execute_create") + args := map[string]any{ + "action": "create", + "provider": provider, + "name": defaultIfEmpty(fieldValue(session, "name"), provider), + "custom_api_url": fieldValue(session, "custom_api_url"), + "custom_model_name": fieldValue(session, "custom_model_name"), + } + raw, _ := json.Marshal(args) + resp := a.toolManageModelConfig(storeUserID, string(raw)) + if errMsg := parseSkillError(resp); strings.Contains(resp, `"error"`) { + a.saveSkillSession(userID, session) + if lang == "zh" { + return "创建模型配置失败：" + errMsg + } + return "Failed to create model config: " + errMsg + } + a.clearSkillSession(userID) + if lang == "zh" { + return fmt.Sprintf("已创建模型配置：%s。你后续还可以继续补 API Key、URL 或模型名。", provider) + } + return fmt.Sprintf("Created model config for %s. You can continue by adding API key, URL, or model name.", provider) +} + +func (a *Agent) handleStrategyCreateSkill(storeUserID string, userID int64, lang, text string, session skillSession) string { + if session.Name == "" { + session = skillSession{Name: "strategy_management", Action: "create", Phase: "collecting"} + } + if fieldValue(session, skillDAGStepField) == "" { + setSkillDAGStep(&session, "resolve_name") + } + if isCancelSkillReply(text) { + a.clearSkillSession(userID) + if lang == "zh" { + return "已取消当前创建策略流程。" + } + return "Cancelled the current strategy creation flow." + } + name := fieldValue(session, "name") + if name == "" { + name = extractTraderName(text) + if name == "" { + name = extractPostKeywordName(text, []string{"叫", "名为", "策略叫", "strategy called"}) + } + if name != "" { + setField(&session, "name", name) + } + } + if actionRequiresSlot("strategy_management", "create", "name") && name == "" { + setSkillDAGStep(&session, "resolve_name") + a.saveSkillSession(userID, session) + if lang == "zh" { + return "要创建策略，我还需要：" + slotDisplayName("name", lang) + "。你可以直接说：创建一个叫“趋势策略A”的策略。" + } + return "To create a strategy, I need a strategy name. You can say: create a strategy called 'Trend A'." + } + setSkillDAGStep(&session, "execute_create") + args := map[string]any{"action": "create", "name": name, "lang": "zh"} + raw, _ := json.Marshal(args) + resp := a.toolManageStrategy(storeUserID, string(raw)) + if errMsg := parseSkillError(resp); strings.Contains(resp, `"error"`) { + a.saveSkillSession(userID, session) + if lang == "zh" { + return "创建策略失败：" + errMsg + } + return "Failed to create strategy: " + errMsg + } + a.clearSkillSession(userID) + if lang == "zh" { + return fmt.Sprintf("已创建策略“%s”。默认配置已就绪，你后续可以继续让我帮你改细节。", name) + } + return fmt.Sprintf("Created strategy %q with the default configuration.", name) +} + +func (a *Agent) handleSimpleEntitySkill(storeUserID string, userID int64, lang, text string, session skillSession, skillName, action string, options []traderSkillOption) (string, bool) { + if isCancelSkillReply(text) { + a.clearSkillSession(userID) + if lang == "zh" { + return "已取消当前流程。", true + } + return "Cancelled the current flow.", true + } + if session.Name == "" { + session = skillSession{Name: skillName, Action: action, Phase: "collecting"} + } + if session.Name != skillName || session.Action != action { + return "", false + } + + if dag, ok := getSkillDAG(skillName, action); ok && len(dag.Steps) > 0 { + currentStep, _ := currentSkillDAGStep(session) + if currentStep.ID == "resolve_target" { + if supportsBulkTargetSelection(skillName, action) && textMeansAllTargets(text) { + setField(&session, "bulk_scope", "all") + advanceSkillDAGStep(&session, currentStep.ID) + } else { + session.TargetRef = resolveTargetFromText(text, options, session.TargetRef) + } + if session.TargetRef == nil { + if !(supportsBulkTargetSelection(skillName, action) && fieldValue(session, "bulk_scope") == "all") { + setSkillDAGStep(&session, "resolve_target") + a.saveSkillSession(userID, session) + label := "可选对象：" + if lang != "zh" { + label = "Available targets:" + } + optionList := formatOptionList(label, options) + if lang == "zh" { + reply := "当前这一步需要先确定目标对象。请告诉我你要操作哪一个。" + if optionList != "" { + reply += "\n" + optionList + } + return reply, true + } + reply := "This step needs a target object first. Tell me which one to operate on." + if optionList != "" { + reply += "\n" + optionList + } + return reply, true + } + } + if fieldValue(session, skillDAGStepField) == currentStep.ID { + advanceSkillDAGStep(&session, currentStep.ID) + } + } + } else { + if supportsBulkTargetSelection(skillName, action) && textMeansAllTargets(text) { + setField(&session, "bulk_scope", "all") + } else { + session.TargetRef = resolveTargetFromText(text, options, session.TargetRef) + } + if session.TargetRef == nil && fieldValue(session, "bulk_scope") != "all" && action != "query" && action != "query_list" && action != "query_detail" && action != "query_running" { + a.saveSkillSession(userID, session) + label := formatOptionList("可选对象：", options) + if lang == "zh" { + reply := "我还需要你明确要操作的是哪一个对象。" + if label != "" { + reply += "\n" + label + } + return reply, true + } + reply := "I still need you to specify which object to operate on." + if label != "" { + reply += "\n" + label + } + return reply, true + } + } + + switch skillName { + case "trader_management": + return a.executeTraderManagementAction(storeUserID, userID, lang, text, session), true + case "exchange_management": + return a.executeExchangeManagementAction(storeUserID, userID, lang, text, session), true + case "model_management": + return a.executeModelManagementAction(storeUserID, userID, lang, text, session), true + case "strategy_management": + return a.executeStrategyManagementAction(storeUserID, userID, lang, text, session), true + default: + return "", false + } +} + +func defaultIfEmpty(value, fallback string) string { + value = strings.TrimSpace(value) + if value == "" { + return strings.TrimSpace(fallback) + } + return value +} diff --git a/agent/skill_outcome.go b/agent/skill_outcome.go new file mode 100644 index 00000000..1075a434 --- /dev/null +++ b/agent/skill_outcome.go @@ -0,0 +1,180 @@ +package agent + +import ( + "context" + "encoding/json" + "fmt" + "strings" + + "nofx/mcp" +) + +const ( + skillOutcomeSuccess = "success" + skillOutcomeNeedMoreInfo = "need_more_info" + skillOutcomeRecoverableError = "recoverable_error" + skillOutcomeFatalError = "fatal_error" + skillOutcomeNotHandled = "not_handled" +) + +type skillOutcome struct { + Skill string `json:"skill"` + Action string `json:"action"` + Status string `json:"status"` + GoalAchieved bool `json:"goal_achieved"` + UserMessage string `json:"user_message,omitempty"` + ErrorCode string `json:"error_code,omitempty"` + Error string `json:"error,omitempty"` + Data map[string]any `json:"data,omitempty"` +} + +type taskReviewDecision struct { + Route string `json:"route"` + Answer string `json:"answer,omitempty"` +} + +func normalizeAtomicSkillAction(skill, action string) string { + action = strings.TrimSpace(strings.ToLower(action)) + switch skill { + case "trader_management": + switch action { + case "query", "query_list": + return "query_list" + case "query_running": + return "query_running" + case "query_detail": + return "query_detail" + case "update": + return "update_name" + case "update_name", "update_bindings": + return action + } + case "exchange_management": + switch action { + case "query", "query_list": + return "query_list" + case "query_detail": + return "query_detail" + case "update": + return "update_name" + case "update_name", "update_status": + return action + } + case "model_management": + switch action { + case "query", "query_list": + return "query_list" + case "query_detail": + return "query_detail" + case "update": + return "update_name" + case "update_name", "update_endpoint", "update_status": + return action + } + case "strategy_management": + switch action { + case "query", "query_list": + return "query_list" + case "query_detail": + return "query_detail" + case "update": + return "update_name" + case "update_name", "update_config", "update_prompt": + return action + } + } + return action +} + +func inferSkillOutcome(skill, action, answer string, activeSession skillSession, data map[string]any) skillOutcome { + outcome := skillOutcome{ + Skill: skill, + Action: action, + Status: skillOutcomeSuccess, + UserMessage: strings.TrimSpace(answer), + Data: data, + } + if activeSession.Name != "" { + outcome.Status = skillOutcomeNeedMoreInfo + outcome.GoalAchieved = false + return outcome + } + + lower := strings.ToLower(strings.TrimSpace(answer)) + switch { + case lower == "": + outcome.Status = skillOutcomeNotHandled + case strings.Contains(lower, "失败") || strings.Contains(lower, "failed") || strings.Contains(lower, "error"): + outcome.Status = skillOutcomeRecoverableError + outcome.Error = strings.TrimSpace(answer) + default: + outcome.GoalAchieved = true + } + return outcome +} + +func parseTaskReviewDecision(raw string) (taskReviewDecision, error) { + raw = strings.TrimSpace(raw) + raw = strings.TrimPrefix(raw, "```json") + raw = strings.TrimPrefix(raw, "```") + raw = strings.TrimSuffix(raw, "```") + raw = strings.TrimSpace(raw) + + var decision taskReviewDecision + if err := json.Unmarshal([]byte(raw), &decision); err == nil { + decision.Route = strings.TrimSpace(strings.ToLower(decision.Route)) + decision.Answer = strings.TrimSpace(decision.Answer) + return decision, nil + } + start := strings.Index(raw, "{") + end := strings.LastIndex(raw, "}") + if start >= 0 && end > start { + if err := json.Unmarshal([]byte(raw[start:end+1]), &decision); err == nil { + decision.Route = strings.TrimSpace(strings.ToLower(decision.Route)) + decision.Answer = strings.TrimSpace(decision.Answer) + return decision, nil + } + } + return taskReviewDecision{}, fmt.Errorf("invalid task review json") +} + +func (a *Agent) reviewTaskCompletion(ctx context.Context, userID int64, lang, text string, outcome skillOutcome) (taskReviewDecision, error) { + if a.aiClient == nil { + if outcome.Status == skillOutcomeRecoverableError || outcome.Status == skillOutcomeFatalError || outcome.Status == skillOutcomeNotHandled { + return taskReviewDecision{Route: "replan"}, nil + } + return taskReviewDecision{Route: "complete", Answer: outcome.UserMessage}, nil + } + + recentConversationCtx := a.buildRecentConversationContext(userID, text) + outcomeJSON, _ := json.Marshal(outcome) + systemPrompt := `You are the task-level Plan-Execute-Review supervisor for NOFXi. +You are reviewing the JSON result returned by one structured skill execution. +Return JSON only. Do not return markdown. + +Rules: +- Decide whether the OVERALL user task is finished, not whether the skill itself ran successfully. +- Use route "complete" only when the user's task is now complete or the best next message is a final user-facing reply. +- Use route "replan" when the user's task is not complete yet and the planner should continue from the new skill outcome. +- Prefer route "replan" for recoverable errors, unmet goals, missing prerequisites, or cases where another skill/tool sequence may help. +- If you choose "complete", produce the final user-facing answer in the user's language. + +Return JSON with this exact shape: +{"route":"complete|replan","answer":""}` + userPrompt := fmt.Sprintf("Language: %s\nUser message: %s\n\nRecent conversation:\n%s\n\nSkill outcome JSON:\n%s", lang, text, recentConversationCtx, string(outcomeJSON)) + + stageCtx, cancel := withPlannerStageTimeout(ctx, directReplyTimeout) + defer cancel() + + raw, err := a.aiClient.CallWithRequest(&mcp.Request{ + Messages: []mcp.Message{ + mcp.NewSystemMessage(systemPrompt), + mcp.NewUserMessage(userPrompt), + }, + Ctx: stageCtx, + }) + if err != nil { + return taskReviewDecision{}, err + } + return parseTaskReviewDecision(raw) +} diff --git a/agent/skill_registry.go b/agent/skill_registry.go new file mode 100644 index 00000000..a74b3cbf --- /dev/null +++ b/agent/skill_registry.go @@ -0,0 +1,119 @@ +package agent + +import ( + "embed" + "encoding/json" + "fmt" + "sort" + "strings" +) + +//go:embed skills/*.json +var embeddedSkillDefinitions embed.FS + +type SkillDefinition struct { + Name string `json:"name"` + Kind string `json:"kind"` + Domain string `json:"domain"` + Description string `json:"description"` + Intents []string `json:"intents,omitempty"` + Actions map[string]SkillActionDefinition `json:"actions,omitempty"` + ToolMapping map[string]string `json:"tool_mapping,omitempty"` +} + +type SkillActionDefinition struct { + Description string `json:"description,omitempty"` + RequiredSlots []string `json:"required_slots,omitempty"` + OptionalSlots []string `json:"optional_slots,omitempty"` + NeedsConfirmation bool `json:"needs_confirmation,omitempty"` +} + +var skillRegistry = mustLoadSkillRegistry() + +func mustLoadSkillRegistry() map[string]SkillDefinition { + registry, err := loadSkillRegistry() + if err != nil { + panic(err) + } + return registry +} + +func loadSkillRegistry() (map[string]SkillDefinition, error) { + entries, err := embeddedSkillDefinitions.ReadDir("skills") + if err != nil { + return nil, err + } + + registry := make(map[string]SkillDefinition, len(entries)) + for _, entry := range entries { + if entry.IsDir() || !strings.HasSuffix(entry.Name(), ".json") { + continue + } + raw, err := embeddedSkillDefinitions.ReadFile("skills/" + entry.Name()) + if err != nil { + return nil, err + } + var def SkillDefinition + if err := json.Unmarshal(raw, &def); err != nil { + return nil, fmt.Errorf("parse skill definition %s: %w", entry.Name(), err) + } + def = normalizeSkillDefinition(def) + if def.Name == "" { + return nil, fmt.Errorf("skill definition %s has empty name", entry.Name()) + } + registry[def.Name] = def + } + return registry, nil +} + +func normalizeSkillDefinition(def SkillDefinition) SkillDefinition { + def.Name = strings.TrimSpace(def.Name) + def.Kind = strings.TrimSpace(def.Kind) + def.Domain = strings.TrimSpace(def.Domain) + def.Description = strings.TrimSpace(def.Description) + def.Intents = cleanStringList(def.Intents) + + if len(def.Actions) > 0 { + normalized := make(map[string]SkillActionDefinition, len(def.Actions)) + for key, action := range def.Actions { + key = strings.TrimSpace(key) + if key == "" { + continue + } + action.Description = strings.TrimSpace(action.Description) + action.RequiredSlots = cleanStringList(action.RequiredSlots) + action.OptionalSlots = cleanStringList(action.OptionalSlots) + normalized[key] = action + } + def.Actions = normalized + } + + if len(def.ToolMapping) > 0 { + normalized := make(map[string]string, len(def.ToolMapping)) + for key, value := range def.ToolMapping { + key = strings.TrimSpace(key) + value = strings.TrimSpace(value) + if key == "" || value == "" { + continue + } + normalized[key] = value + } + def.ToolMapping = normalized + } + + return def +} + +func getSkillDefinition(name string) (SkillDefinition, bool) { + def, ok := skillRegistry[strings.TrimSpace(name)] + return def, ok +} + +func listSkillNames() []string { + names := make([]string, 0, len(skillRegistry)) + for name := range skillRegistry { + names = append(names, name) + } + sort.Strings(names) + return names +} diff --git a/agent/skill_registry_test.go b/agent/skill_registry_test.go new file mode 100644 index 00000000..99a14987 --- /dev/null +++ b/agent/skill_registry_test.go @@ -0,0 +1,55 @@ +package agent + +import "testing" + +func TestSkillRegistryLoadsDefinitions(t *testing.T) { + names := listSkillNames() + if len(names) < 4 { + t.Fatalf("expected skill registry to load definitions, got %v", names) + } + + for _, name := range []string{ + "trader_management", + "exchange_management", + "model_management", + "strategy_management", + "exchange_diagnosis", + "model_diagnosis", + } { + if _, ok := getSkillDefinition(name); !ok { + t.Fatalf("missing skill definition %q", name) + } + } +} + +func TestTraderManagementDefinitionHasCreateAction(t *testing.T) { + def, ok := getSkillDefinition("trader_management") + if !ok { + t.Fatalf("missing trader_management definition") + } + action, ok := def.Actions["create"] + if !ok { + t.Fatalf("missing create action in trader_management") + } + if len(action.RequiredSlots) == 0 { + t.Fatalf("expected required slots for trader_management create action") + } +} + +func TestActionNeedsConfirmationUsesSkillDefinition(t *testing.T) { + if !actionNeedsConfirmation("exchange_management", "delete") { + t.Fatalf("expected exchange_management delete to require confirmation") + } + if actionNeedsConfirmation("exchange_management", "query") { + t.Fatalf("did not expect exchange_management query to require confirmation") + } +} + +func TestActionRequiresSlotUsesSkillDefinition(t *testing.T) { + if !actionRequiresSlot("model_management", "create", "provider") { + t.Fatalf("expected model_management create to require provider") + } + if actionRequiresSlot("model_management", "create", "target_ref") { + t.Fatalf("did not expect model_management create to require target_ref") + } +} diff --git a/agent/skill_runner.go b/agent/skill_runner.go new file mode 100644 index 00000000..a2b7fdbf --- /dev/null +++ b/agent/skill_runner.go @@ -0,0 +1,144 @@ +package agent + +import ( + "fmt" + "strings" +) + +type skillActionRuntime struct { + Skill SkillDefinition + Name string + Action SkillActionDefinition +} + +func getSkillActionRuntime(skillName, action string) (skillActionRuntime, bool) { + def, ok := getSkillDefinition(skillName) + if !ok { + return skillActionRuntime{}, false + } + action = strings.TrimSpace(action) + if action == "" { + return skillActionRuntime{Skill: def}, true + } + actionDef, ok := def.Actions[action] + if !ok { + return skillActionRuntime{}, false + } + return skillActionRuntime{ + Skill: def, + Name: action, + Action: actionDef, + }, true +} + +func actionNeedsConfirmation(skillName, action string) bool { + runtime, ok := getSkillActionRuntime(skillName, action) + if !ok { + return false + } + return runtime.Action.NeedsConfirmation +} + +func actionRequiresSlot(skillName, action, slot string) bool { + runtime, ok := getSkillActionRuntime(skillName, action) + if !ok { + return false + } + slot = strings.TrimSpace(slot) + for _, candidate := range runtime.Action.RequiredSlots { + if candidate == slot { + return true + } + } + return false +} + +func slotDisplayName(slot, lang string) string { + slot = strings.TrimSpace(slot) + if lang != "zh" { + switch slot { + case "target_ref": + return "target" + case "name": + return "name" + case "exchange": + return "exchange" + case "model": + return "model" + case "strategy": + return "strategy" + case "exchange_type": + return "exchange type" + case "provider": + return "provider" + default: + return slot + } + } + switch slot { + case "target_ref": + return "目标对象" + case "name": + return "名称" + case "exchange": + return "交易所" + case "model": + return "模型" + case "strategy": + return "策略" + case "exchange_type": + return "交易所类型" + case "provider": + return "provider" + default: + return slot + } +} + +func formatAwaitConfirmationMessage(lang, action, targetLabel string) string { + actionLabel := action + if lang == "zh" { + switch action { + case "start": + actionLabel = "启动" + case "stop": + actionLabel = "停止" + case "delete": + actionLabel = "删除" + case "activate": + actionLabel = "激活" + default: + actionLabel = action + } + return fmt.Sprintf("即将%s“%s”。这是需要确认的操作，请回复“确认”继续，回复“取消”终止。", actionLabel, targetLabel) + } + return fmt.Sprintf("You are about to %s %q. Please reply 'confirm' to continue or 'cancel' to stop.", actionLabel, targetLabel) +} + +func formatStillWaitingConfirmationMessage(lang string) string { + if lang == "zh" { + return "当前流程仍在等待你确认。回复“确认”继续，或“取消”终止。" + } + return "This flow is still waiting for your confirmation." +} + +func beginConfirmationIfNeeded(userID int64, lang string, session *skillSession, targetLabel string) (string, bool) { + if session == nil || !actionNeedsConfirmation(session.Name, session.Action) { + return "", false + } + if session.Phase != "await_confirmation" { + session.Phase = "await_confirmation" + return formatAwaitConfirmationMessage(lang, session.Action, targetLabel), true + } + return "", false +} + +func awaitingConfirmationButNotApproved(lang string, session skillSession, text string) (string, bool) { + if !actionNeedsConfirmation(session.Name, session.Action) || session.Phase != "await_confirmation" { + return "", false + } + if isYesReply(text) { + return "", false + } + return formatStillWaitingConfirmationMessage(lang), true +} diff --git a/agent/skills/exchange_diagnosis.json b/agent/skills/exchange_diagnosis.json new file mode 100644 index 00000000..c8d9b0ba --- /dev/null +++ b/agent/skills/exchange_diagnosis.json @@ -0,0 +1,6 @@ +{ + "name": "exchange_diagnosis", + "kind": "diagnosis", + "domain": "exchange", + "description": "当用户反馈交易所 API 连接失败、签名错误、timestamp 异常、权限不足、IP 白名单限制、账户不可用等问题时调用。适用于用户在手动配置或运行交易员时遇到的交易所接入故障。不用于创建、修改、删除或查询交易所配置这类管理操作。" +} diff --git a/agent/skills/exchange_management.json b/agent/skills/exchange_management.json new file mode 100644 index 00000000..1baf26ce --- /dev/null +++ b/agent/skills/exchange_management.json @@ -0,0 +1,32 @@ +{ + "name": "exchange_management", + "kind": "management", + "domain": "exchange", + "description": "当用户想创建、查看、修改或删除交易所账户配置时调用。适用于用户提到交易所账户、API Key、Secret、Passphrase、测试网开关、启用状态等配置管理需求。不用于排查 invalid signature、timestamp、权限不足、白名单限制等连接或鉴权诊断问题。", + "actions": { + "create": { + "description": "创建新的交易所配置。", + "required_slots": ["exchange_type"], + "optional_slots": ["account_name", "api_key", "secret_key", "passphrase", "testnet"] + }, + "update": { + "description": "更新已有交易所配置。", + "required_slots": ["target_ref"], + "optional_slots": ["account_name", "api_key", "secret_key", "passphrase", "enabled", "testnet"] + }, + "delete": { + "description": "删除交易所配置。", + "required_slots": ["target_ref"], + "needs_confirmation": true + }, + "query": { + "description": "查询交易所配置。" + } + }, + "tool_mapping": { + "create": "manage_exchange_config:create", + "update": "manage_exchange_config:update", + "delete": "manage_exchange_config:delete", + "query": "get_exchange_configs" + } +} diff --git a/agent/skills/model_diagnosis.json b/agent/skills/model_diagnosis.json new file mode 100644 index 00000000..d47e0d77 --- /dev/null +++ b/agent/skills/model_diagnosis.json @@ -0,0 +1,6 @@ +{ + "name": "model_diagnosis", + "kind": "diagnosis", + "domain": "model", + "description": "当用户反馈模型配置失败、API Key 无效、Base URL 非法、模型名不匹配、调用返回错误、模型不可用等问题时调用。适用于用户在接入或测试大模型时遇到的配置与兼容性故障。不用于创建、修改、删除或查询模型配置这类管理操作。" +} diff --git a/agent/skills/model_management.json b/agent/skills/model_management.json new file mode 100644 index 00000000..98b159ee --- /dev/null +++ b/agent/skills/model_management.json @@ -0,0 +1,32 @@ +{ + "name": "model_management", + "kind": "management", + "domain": "model", + "description": "当用户想创建、查看、修改或删除 AI 模型配置时调用。适用于用户提到 provider、API Key、Base URL、模型名称、启用状态等配置管理需求。不用于排查模型调用失败、接口不兼容、鉴权错误、模型不存在等诊断问题。", + "actions": { + "create": { + "description": "创建新的模型配置。", + "required_slots": ["provider"], + "optional_slots": ["name", "api_key", "custom_api_url", "custom_model_name", "enabled"] + }, + "update": { + "description": "更新已有模型配置。", + "required_slots": ["target_ref"], + "optional_slots": ["api_key", "custom_api_url", "custom_model_name", "enabled"] + }, + "delete": { + "description": "删除模型配置。", + "required_slots": ["target_ref"], + "needs_confirmation": true + }, + "query": { + "description": "查询模型配置。" + } + }, + "tool_mapping": { + "create": "manage_model_config:create", + "update": "manage_model_config:update", + "delete": "manage_model_config:delete", + "query": "get_model_configs" + } +} diff --git a/agent/skills/strategy_diagnosis.json b/agent/skills/strategy_diagnosis.json new file mode 100644 index 00000000..827185c6 --- /dev/null +++ b/agent/skills/strategy_diagnosis.json @@ -0,0 +1,6 @@ +{ + "name": "strategy_diagnosis", + "kind": "diagnosis", + "domain": "strategy", + "description": "当用户反馈策略未生效、策略输出异常、提示词或配置结果与预期不一致、策略执行表现异常时调用。适用于策略内容和执行效果相关的排障与解释。不用于创建、修改、删除、激活、复制或查询策略模板这类管理操作。" +} diff --git a/agent/skills/strategy_management.json b/agent/skills/strategy_management.json new file mode 100644 index 00000000..a6ce0465 --- /dev/null +++ b/agent/skills/strategy_management.json @@ -0,0 +1,42 @@ +{ + "name": "strategy_management", + "kind": "management", + "domain": "strategy", + "description": "当用户想创建、查看、修改、删除、激活或复制策略模板时调用。适用于用户提到策略名称、策略配置、描述、语言、激活状态、复制新版本等管理需求。不用于排查策略未生效、策略输出异常、执行结果异常等诊断问题。", + "actions": { + "create": { + "description": "创建策略模板。", + "required_slots": ["name"], + "optional_slots": ["config", "description", "lang"] + }, + "update": { + "description": "更新策略模板。", + "required_slots": ["target_ref"], + "optional_slots": ["name", "config", "description"] + }, + "delete": { + "description": "删除策略模板。", + "required_slots": ["target_ref"], + "needs_confirmation": true + }, + "activate": { + "description": "激活策略模板。", + "required_slots": ["target_ref"] + }, + "duplicate": { + "description": "复制策略模板。", + "required_slots": ["target_ref", "name"] + }, + "query": { + "description": "查询策略模板。" + } + }, + "tool_mapping": { + "create": "manage_strategy:create", + "update": "manage_strategy:update", + "delete": "manage_strategy:delete", + "activate": "manage_strategy:activate", + "duplicate": "manage_strategy:duplicate", + "query": "get_strategies" + } +} diff --git a/agent/skills/trader_diagnosis.json b/agent/skills/trader_diagnosis.json new file mode 100644 index 00000000..ae263145 --- /dev/null +++ b/agent/skills/trader_diagnosis.json @@ -0,0 +1,6 @@ +{ + "name": "trader_diagnosis", + "kind": "diagnosis", + "domain": "trader", + "description": "当用户反馈交易员无法启动、启动后不交易、绑定模型或交易所缺失、运行状态异常、收益或仓位表现异常时调用。适用于交易员运行过程中的排障与原因定位。不用于创建、修改、删除、启动、停止或查询交易员这类管理操作。" +} diff --git a/agent/skills/trader_management.json b/agent/skills/trader_management.json new file mode 100644 index 00000000..babd251d --- /dev/null +++ b/agent/skills/trader_management.json @@ -0,0 +1,52 @@ +{ + "name": "trader_management", + "kind": "management", + "domain": "trader", + "description": "当用户想创建、查看、修改、删除、启动或停止交易员时调用。适用于用户提到交易员名称、绑定交易所、绑定模型、绑定策略、扫描频率、自定义提示词、运行状态等管理需求。不用于排查交易员启动失败、未下单、收益异常、仓位异常等诊断问题。", + "intents": [ + "创建交易员", + "修改交易员", + "删除交易员", + "启动交易员", + "停止交易员", + "查询交易员" + ], + "actions": { + "create": { + "description": "创建新的交易员。", + "required_slots": ["name", "exchange", "model"], + "optional_slots": ["strategy", "auto_start"] + }, + "update": { + "description": "更新已有交易员。", + "required_slots": ["target_ref"], + "optional_slots": ["name", "exchange", "model", "strategy", "scan_interval_minutes", "custom_prompt"] + }, + "delete": { + "description": "删除交易员。", + "required_slots": ["target_ref"], + "needs_confirmation": true + }, + "start": { + "description": "启动交易员。", + "required_slots": ["target_ref"], + "needs_confirmation": true + }, + "stop": { + "description": "停止交易员。", + "required_slots": ["target_ref"], + "needs_confirmation": true + }, + "query": { + "description": "查询交易员列表或状态。" + } + }, + "tool_mapping": { + "create": "manage_trader:create", + "update": "manage_trader:update", + "delete": "manage_trader:delete", + "start": "manage_trader:start", + "stop": "manage_trader:stop", + "query": "manage_trader:list" + } +} diff --git a/agent/stock.go b/agent/stock.go new file mode 100644 index 00000000..250e7d8c --- /dev/null +++ b/agent/stock.go @@ -0,0 +1,444 @@ +package agent + +import ( + "nofx/safe" + "fmt" + "io" + "net/http" + "net/url" + "strconv" + "strings" + "time" + + "golang.org/x/text/encoding/simplifiedchinese" + "golang.org/x/text/transform" +) + +// stockHTTPClient is a shared HTTP client for stock API requests. +// Reused across calls for connection pooling. +var stockHTTPClient = &http.Client{ + Timeout: 10 * time.Second, + Transport: &http.Transport{ + MaxIdleConns: 10, + MaxIdleConnsPerHost: 5, + IdleConnTimeout: 90 * time.Second, + }, +} + +// StockQuote holds real-time stock data. +type StockQuote struct { + Name string + Code string + Market string // "A股", "港股", "美股" + Currency string // "CNY", "HKD", "USD" + Open float64 + PrevClose float64 + Price float64 + High float64 + Low float64 + Volume float64 + Turnover float64 + Date string + Time string + Change float64 + ChangePct float64 + // 盘前盘后 (美股) + ExtPrice float64 // 盘前/盘后价格 + ExtChangePct float64 // 盘前/盘后涨跌幅% + ExtChange float64 // 盘前/盘后涨跌额 + ExtTime string // 盘前/盘后时间 + IsExtHours bool // 是否在盘前盘后时段 +} + +// knownStocks maps Chinese names to stock codes. +var knownStocks = map[string]string{ + // A股 + "拓维信息": "sz002261", "比亚迪": "sz002594", "宁德时代": "sz300750", + "贵州茅台": "sh600519", "中国平安": "sh601318", "招商银行": "sh600036", + "中芯国际": "sh688981", "工商银行": "sh601398", "建设银行": "sh601939", + "中国银行": "sh601988", "农业银行": "sh601288", "中信证券": "sh600030", + "海康威视": "sz002415", "立讯精密": "sz002475", "东方财富": "sz300059", + "隆基绿能": "sh601012", "长城汽车": "sh601633", "科大讯飞": "sz002230", + "三六零": "sh601360", "中兴通讯": "sz000063", + // 港股 + "腾讯": "hk00700", "阿里巴巴": "hk09988", "美团": "hk03690", + "小米": "hk01810", "京东": "hk09618", "网易": "hk09999", + "百度": "hk09888", "快手": "hk01024", "哔哩哔哩": "hk09626", + "理想汽车": "hk02015", "蔚来": "hk09866", "小鹏汽车": "hk09868", + // 华为 is not publicly listed — removed incorrect Tencent fallback + // 美股 + "苹果": "gb_aapl", "特斯拉": "gb_tsla", "英伟达": "gb_nvda", + "微软": "gb_msft", "谷歌": "gb_googl", "亚马逊": "gb_amzn", + "meta": "gb_meta", "奈飞": "gb_nflx", "台积电": "gb_tsm", + "拼多多": "gb_pdd", "蔚来汽车": "gb_nio", +} + +// US stock ticker mapping +var usTickerMap = map[string]string{ + "AAPL": "gb_aapl", "TSLA": "gb_tsla", "NVDA": "gb_nvda", "MSFT": "gb_msft", + "GOOGL": "gb_googl", "AMZN": "gb_amzn", "META": "gb_meta", "NFLX": "gb_nflx", + "TSM": "gb_tsm", "PDD": "gb_pdd", "NIO": "gb_nio", "BABA": "gb_baba", + "JD": "gb_jd", "BIDU": "gb_bidu", "AMD": "gb_amd", "INTC": "gb_intc", + "COIN": "gb_coin", "MARA": "gb_mara", "RIOT": "gb_riot", +} + +func resolveStockCode(text string) (string, string) { + // Known Chinese names + for name, code := range knownStocks { + if strings.Contains(text, name) { + return code, name + } + } + + // US ticker symbols (uppercase) + upper := strings.ToUpper(text) + for ticker, code := range usTickerMap { + if strings.Contains(upper, ticker) { + return code, ticker + } + } + + // 6-digit A-share code + for _, w := range strings.Fields(text) { + w = strings.TrimSpace(w) + if len(w) == 6 { + if _, err := strconv.Atoi(w); err == nil { + prefix := "sz" + if w[0] == '6' || w[0] == '9' { prefix = "sh" } + return prefix + w, w + } + } + // 5-digit HK code + if len(w) == 5 { + if _, err := strconv.Atoi(w); err == nil { + return "hk" + w, w + } + } + } + + return "", "" +} + +// SearchResult represents a stock search result from Sina suggest API. +type SearchResult struct { + Name string // Display name + Code string // Sina-style code (e.g. sz300750, hk00700, gb_tsla) + Ticker string // Raw ticker (e.g. 300750, 00700, tsla) + Type string // Market type code: 11=A股, 31=港股, 41=美股 + Market string // "A股", "港股", "美股" +} + +// searchStock queries Sina's suggest API for dynamic stock search. +// Returns matching stocks across A-share, HK, and US markets. +func searchStock(keyword string) ([]SearchResult, error) { + // type=11 (A股), 31 (港股), 41 (美股) + u := fmt.Sprintf("https://suggest3.sinajs.cn/suggest/type=11,31,41&key=%s&name=suggestdata", + url.QueryEscape(keyword)) + + req, _ := http.NewRequest("GET", u, nil) + req.Header.Set("Referer", "https://finance.sina.com.cn") + + resp, err := stockHTTPClient.Do(req) + if err != nil { + return nil, err + } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("stock search API returned status %d", resp.StatusCode) + } + + reader := transform.NewReader(io.LimitReader(resp.Body, 256*1024), simplifiedchinese.GBK.NewDecoder()) + body, err := safe.ReadAllLimited(reader) + if err != nil { + return nil, err + } + + line := string(body) + // Parse: var suggestdata="item1;item2;..." + start := strings.Index(line, "\"") + end := strings.LastIndex(line, "\"") + if start == -1 || end <= start { + return nil, fmt.Errorf("invalid suggest response") + } + data := line[start+1 : end] + if data == "" { + return nil, nil // no results + } + + var results []SearchResult + items := strings.Split(data, ";") + for _, item := range items { + item = strings.TrimSpace(item) + if item == "" { + continue + } + fields := strings.Split(item, ",") + if len(fields) < 5 { + continue + } + // fields: [0]=name, [1]=type, [2]=ticker, [3]=sinaCode, [4]=displayName + typeCode := fields[1] + ticker := fields[2] + sinaCode := fields[3] + displayName := fields[4] + if displayName == "" { + displayName = fields[0] + } + + var mkt, code string + switch typeCode { + case "11": // A股 + mkt = "A股" + code = sinaCode // already like sz300750, sh600519 + if code == "" { + // Build from ticker + prefix := "sz" + if len(ticker) == 6 && (ticker[0] == '6' || ticker[0] == '9') { + prefix = "sh" + } + code = prefix + ticker + } + case "31": // 港股 + mkt = "港股" + code = "hk" + ticker + case "41": // 美股 + mkt = "美股" + code = "gb_" + ticker + default: + continue // skip funds (201), indices, etc. + } + + results = append(results, SearchResult{ + Name: displayName, + Code: code, + Ticker: ticker, + Type: typeCode, + Market: mkt, + }) + } + + return results, nil +} + +// resolveStockCodeDynamic tries local map first, then falls back to Sina search API. +func resolveStockCodeDynamic(text string) (string, string) { + // First try the static map + code, name := resolveStockCode(text) + if code != "" { + return code, name + } + + // Fall back to Sina search API + // Extract a meaningful search keyword from the text + keyword := extractStockKeyword(text) + if keyword == "" { + return "", "" + } + + results, err := searchStock(keyword) + if err != nil || len(results) == 0 { + return "", "" + } + + // Return the first (best) result + return results[0].Code, results[0].Name +} + +// extractStockKeyword extracts a likely stock name/ticker from user text. +func extractStockKeyword(text string) string { + // Remove common prefixes/suffixes that aren't stock names + text = strings.TrimSpace(text) + + // If the text itself is short enough, use it directly + // (e.g. "中远海控" or "AAPL") + if len([]rune(text)) <= 10 { + return text + } + + // Try to extract quoted terms first: 「xxx」 or "xxx" + quotePairs := [][2]string{ + {"「", "」"}, + {"\u201c", "\u201d"}, + {"\u2018", "\u2019"}, + {"\"", "\""}, + } + for _, pair := range quotePairs { + if s := strings.Index(text, pair[0]); s >= 0 { + if e := strings.Index(text[s+len(pair[0]):], pair[1]); e >= 0 { + return text[s+len(pair[0]) : s+len(pair[0])+e] + } + } + } + + // Look for patterns like "查 XXX", "搜索 XXX", "查一下 XXX" + for _, prefix := range []string{"查一下", "搜索", "查询", "看看", "搜一下", "查", "看", "search ", "find "} { + if idx := strings.Index(text, prefix); idx >= 0 { + rest := strings.TrimSpace(text[idx+len(prefix):]) + // Take the first "word" (either Chinese characters or English word) + words := strings.Fields(rest) + if len(words) > 0 { + return words[0] + } + } + } + + // Last resort: use first few words + words := strings.Fields(text) + if len(words) > 0 { + return words[0] + } + + return "" +} + +func fetchStockQuote(code string) (*StockQuote, error) { + url := fmt.Sprintf("https://hq.sinajs.cn/list=%s", code) + req, _ := http.NewRequest("GET", url, nil) + req.Header.Set("Referer", "https://finance.sina.com.cn") + + resp, err := stockHTTPClient.Do(req) + if err != nil { return nil, err } + defer resp.Body.Close() + + if resp.StatusCode != http.StatusOK { + return nil, fmt.Errorf("stock quote API returned status %d", resp.StatusCode) + } + + reader := transform.NewReader(io.LimitReader(resp.Body, 256*1024), simplifiedchinese.GBK.NewDecoder()) + body, err := safe.ReadAllLimited(reader) + if err != nil { return nil, err } + + line := string(body) + start := strings.Index(line, "\"") + end := strings.LastIndex(line, "\"") + if start == -1 || end <= start { return nil, fmt.Errorf("invalid response") } + + data := line[start+1 : end] + if data == "" { return nil, fmt.Errorf("empty data for %s", code) } + + if strings.HasPrefix(code, "sh") || strings.HasPrefix(code, "sz") { + return parseAShare(code, data) + } else if strings.HasPrefix(code, "hk") { + return parseHKShare(code, data) + } else if strings.HasPrefix(code, "gb_") { + return parseUSShare(code, data) + } + + return nil, fmt.Errorf("unsupported market: %s", code) +} + +func parseAShare(code, data string) (*StockQuote, error) { + f := strings.Split(data, ",") + if len(f) < 32 { return nil, fmt.Errorf("too few fields") } + + q := &StockQuote{Name: f[0], Code: code, Market: "A股", Currency: "CNY"} + q.Open, _ = strconv.ParseFloat(f[1], 64) + q.PrevClose, _ = strconv.ParseFloat(f[2], 64) + q.Price, _ = strconv.ParseFloat(f[3], 64) + q.High, _ = strconv.ParseFloat(f[4], 64) + q.Low, _ = strconv.ParseFloat(f[5], 64) + q.Volume, _ = strconv.ParseFloat(f[8], 64) + q.Turnover, _ = strconv.ParseFloat(f[9], 64) + q.Date = f[30]; q.Time = f[31] + if q.PrevClose > 0 { q.Change = q.Price - q.PrevClose; q.ChangePct = (q.Change / q.PrevClose) * 100 } + return q, nil +} + +func parseHKShare(code, data string) (*StockQuote, error) { + f := strings.Split(data, ",") + if len(f) < 18 { return nil, fmt.Errorf("too few fields") } + + q := &StockQuote{Name: f[1], Code: code, Market: "港股", Currency: "HKD"} + q.PrevClose, _ = strconv.ParseFloat(f[3], 64) + q.Open, _ = strconv.ParseFloat(f[2], 64) + q.High, _ = strconv.ParseFloat(f[4], 64) + q.Low, _ = strconv.ParseFloat(f[5], 64) + q.Price, _ = strconv.ParseFloat(f[6], 64) + q.Change, _ = strconv.ParseFloat(f[7], 64) + q.ChangePct, _ = strconv.ParseFloat(f[8], 64) + q.Turnover, _ = strconv.ParseFloat(f[10], 64) + q.Volume, _ = strconv.ParseFloat(f[11], 64) + if len(f) > 17 { q.Date = f[17]; q.Time = f[17] } + return q, nil +} + +func parseUSShare(code, data string) (*StockQuote, error) { + f := strings.Split(data, ",") + if len(f) < 30 { return nil, fmt.Errorf("too few fields") } + + q := &StockQuote{Name: f[0], Code: code, Market: "美股", Currency: "USD"} + q.Price, _ = strconv.ParseFloat(f[1], 64) + q.ChangePct, _ = strconv.ParseFloat(f[2], 64) + q.Change, _ = strconv.ParseFloat(f[4], 64) + q.Open, _ = strconv.ParseFloat(f[5], 64) + q.High, _ = strconv.ParseFloat(f[6], 64) + q.Low, _ = strconv.ParseFloat(f[7], 64) + // 52wk high/low + high52, _ := strconv.ParseFloat(f[8], 64) + low52, _ := strconv.ParseFloat(f[9], 64) + q.Volume, _ = strconv.ParseFloat(f[10], 64) + q.Turnover, _ = strconv.ParseFloat(f[11], 64) + if len(f) > 25 { q.Date = f[25]; q.Time = f[26] } + q.PrevClose = q.Price - q.Change + _ = high52; _ = low52 + + // 盘前盘后数据 (字段21=价格, 22=涨跌幅%, 23=涨跌额, 24=时间) + if len(f) > 24 { + extPrice, _ := strconv.ParseFloat(f[21], 64) + extPct, _ := strconv.ParseFloat(f[22], 64) + extChg, _ := strconv.ParseFloat(f[23], 64) + if extPrice > 0 { + q.ExtPrice = extPrice + q.ExtChangePct = extPct + q.ExtChange = extChg + q.ExtTime = strings.TrimSpace(f[24]) + q.IsExtHours = true + } + } + + return q, nil +} + +func formatStockQuote(q *StockQuote) string { + emoji := "🟢" + if q.ChangePct < 0 { emoji = "🔴" } + + sym := "¥" + if q.Currency == "USD" { sym = "$" } + if q.Currency == "HKD" { sym = "HK$" } + + volStr := fmt.Sprintf("%.0f", q.Volume) + if q.Volume > 1000000 { volStr = fmt.Sprintf("%.1f万", q.Volume/10000) } + if q.Volume > 100000000 { volStr = fmt.Sprintf("%.2f亿", q.Volume/100000000) } + + turnStr := fmt.Sprintf("%.0f", q.Turnover) + if q.Turnover > 100000000 { turnStr = fmt.Sprintf("%.2f亿", q.Turnover/100000000) } + + result := fmt.Sprintf(`%s *%s* (%s · %s) +💰 现价: %s%.2f (%+.2f%%) +📊 开盘: %s%.2f | 昨收: %s%.2f +📈 最高: %s%.2f | 最低: %s%.2f +📦 成交: %s | 额: %s +🕐 %s`, + emoji, q.Name, q.Code, q.Market, + sym, q.Price, q.ChangePct, + sym, q.Open, sym, q.PrevClose, + sym, q.High, sym, q.Low, + volStr, turnStr, + q.Date) + + // 盘前盘后数据 + if q.IsExtHours && q.ExtPrice > 0 { + extEmoji := "🟢" + if q.ExtChangePct < 0 { extEmoji = "🔴" } + extLabel := "🌙 盘后" + if strings.Contains(strings.ToLower(q.ExtTime), "am") { + extLabel = "🌅 盘前" + } + result += fmt.Sprintf("\n%s %s: %s%.2f (%+.2f%%) %s", + extLabel, extEmoji, sym, q.ExtPrice, q.ExtChangePct, q.ExtTime) + } + + return result +} diff --git a/agent/tools.go b/agent/tools.go new file mode 100644 index 00000000..be7e1f24 --- /dev/null +++ b/agent/tools.go @@ -0,0 +1,2242 @@ +package agent + +import ( + "bufio" + "context" + "encoding/json" + "fmt" + "os" + "path/filepath" + "sort" + "strings" + "time" + + "nofx/kernel" + "nofx/mcp" + "nofx/safe" + "nofx/security" + "nofx/store" +) + +// cachedTools holds the static tool definitions (built once, reused per message). +var cachedTools = buildAgentTools() + +// agentTools returns the tools available to the LLM for autonomous action. +func agentTools() []mcp.Tool { return cachedTools } + +func buildAgentTools() []mcp.Tool { + return []mcp.Tool{ + { + Type: "function", + Function: mcp.FunctionDef{ + Name: "get_preferences", + Description: "Get all persistent user preferences that the agent should remember long-term.", + Parameters: map[string]any{"type": "object", "properties": map[string]any{}}, + }, + }, + { + Type: "function", + Function: mcp.FunctionDef{ + Name: "manage_preferences", + Description: "Add, update, or delete a persistent user preference. Use this when the user asks to remember something long-term, change an existing long-term preference, or remove one.", + Parameters: map[string]any{ + "type": "object", + "properties": map[string]any{ + "action": map[string]any{ + "type": "string", + "enum": []string{"add", "update", "delete"}, + "description": "What to do with the persistent preference.", + }, + "text": map[string]any{ + "type": "string", + "description": "The new preference text. Required for add and update.", + }, + "match": map[string]any{ + "type": "string", + "description": "How to find the existing preference to update or delete. Can be an id or distinctive text like '每天8点'.", + }, + }, + "required": []string{"action"}, + }, + }, + }, + { + Type: "function", + Function: mcp.FunctionDef{ + Name: "get_backend_logs", + Description: "Get recent backend log lines for a trader diagnosis. Prefer this when the user asks why a specific trader failed, stopped, or behaved unexpectedly. Returns recent matching log lines for the authenticated user's trader.", + Parameters: map[string]any{ + "type": "object", + "properties": map[string]any{ + "trader_id": map[string]any{ + "type": "string", + "description": "Trader id to diagnose. The backend verifies that this trader belongs to the authenticated user before returning logs.", + }, + "limit": map[string]any{"type": "number", "description": "Maximum number of recent log lines to return. Default 30."}, + "errors_only": map[string]any{"type": "boolean", "description": "When true, only return error-like log lines. Default true."}, + }, + }, + }, + }, + { + Type: "function", + Function: mcp.FunctionDef{ + Name: "get_exchange_configs", + Description: "Get the user's current exchange account bindings. Returns safe metadata only and whether credentials are already stored.", + Parameters: map[string]any{"type": "object", "properties": map[string]any{}}, + }, + }, + { + Type: "function", + Function: mcp.FunctionDef{ + Name: "manage_exchange_config", + Description: "Create, update, or delete an exchange account binding. Use this when the user asks to add/edit/remove an exchange account, API key, secret, passphrase, wallet address, or account name. Sensitive fields are stored securely and are never returned in full.", + Parameters: map[string]any{ + "type": "object", + "properties": map[string]any{ + "action": map[string]any{ + "type": "string", + "enum": []string{"create", "update", "delete"}, + }, + "exchange_id": map[string]any{ + "type": "string", + "description": "Existing exchange account id. Required for update and delete.", + }, + "exchange_type": map[string]any{ + "type": "string", + "description": "Exchange type for a new binding, such as binance, bybit, okx, hyperliquid, aster, lighter, gate, kucoin, alpaca, forex, or metals.", + }, + "account_name": map[string]any{ + "type": "string", + "description": "User-visible account name like Main, Testnet, or Mom Account.", + }, + "enabled": map[string]any{ + "type": "boolean", + "description": "Whether this exchange binding should be enabled.", + }, + "api_key": map[string]any{"type": "string"}, + "secret_key": map[string]any{"type": "string"}, + "passphrase": map[string]any{"type": "string"}, + "testnet": map[string]any{"type": "boolean"}, + "hyperliquid_wallet_addr": map[string]any{"type": "string"}, + "hyperliquid_unified_account": map[string]any{"type": "boolean"}, + "aster_user": map[string]any{"type": "string"}, + "aster_signer": map[string]any{"type": "string"}, + "aster_private_key": map[string]any{"type": "string"}, + "lighter_wallet_addr": map[string]any{"type": "string"}, + "lighter_private_key": map[string]any{"type": "string"}, + "lighter_api_key_private_key": map[string]any{"type": "string"}, + "lighter_api_key_index": map[string]any{"type": "number"}, + }, + "required": []string{"action"}, + }, + }, + }, + { + Type: "function", + Function: mcp.FunctionDef{ + Name: "get_model_configs", + Description: "Get the user's current AI model bindings. Returns safe metadata only and whether an API key is already stored.", + Parameters: map[string]any{"type": "object", "properties": map[string]any{}}, + }, + }, + { + Type: "function", + Function: mcp.FunctionDef{ + Name: "manage_model_config", + Description: "Create, update, or delete an AI model binding. Use this when the user asks to add/edit/remove a model provider, API key, custom API URL, or custom model name. Sensitive fields are stored securely and are never returned in full.", + Parameters: map[string]any{ + "type": "object", + "properties": map[string]any{ + "action": map[string]any{ + "type": "string", + "enum": []string{"create", "update", "delete"}, + }, + "model_id": map[string]any{ + "type": "string", + "description": "Existing model id for update/delete, or the desired id for create.", + }, + "provider": map[string]any{ + "type": "string", + "description": "Provider slug such as openai, claude, gemini, deepseek, qwen, kimi, grok, minimax, claw402, or blockrun-base.", + }, + "name": map[string]any{ + "type": "string", + "description": "Display name for a newly created model binding.", + }, + "enabled": map[string]any{"type": "boolean"}, + "api_key": map[string]any{"type": "string"}, + "custom_api_url": map[string]any{"type": "string"}, + "custom_model_name": map[string]any{"type": "string"}, + }, + "required": []string{"action"}, + }, + }, + }, + { + Type: "function", + Function: mcp.FunctionDef{ + Name: "get_strategies", + Description: "Get the user's current strategy templates, including system default strategies available to that user.", + Parameters: map[string]any{"type": "object", "properties": map[string]any{}}, + }, + }, + { + Type: "function", + Function: mcp.FunctionDef{ + Name: "manage_strategy", + Description: "List, create, update, delete, activate, duplicate strategies, or get the default strategy config template. Use this when the user asks to create or edit a strategy template. Strategy templates are independent assets and do not require exchange/model bindings unless the user asks to run them via a trader.", + Parameters: map[string]any{ + "type": "object", + "properties": map[string]any{ + "action": map[string]any{ + "type": "string", + "enum": []string{"list", "create", "update", "delete", "activate", "duplicate", "get_default_config"}, + }, + "strategy_id": map[string]any{"type": "string"}, + "name": map[string]any{"type": "string"}, + "description": map[string]any{"type": "string"}, + "lang": map[string]any{"type": "string", "enum": []string{"zh", "en"}}, + "is_public": map[string]any{"type": "boolean"}, + "config_visible": map[string]any{"type": "boolean"}, + "config": map[string]any{"type": "object", "description": "Full or partial strategy config JSON object, depending on action."}, + }, + "required": []string{"action"}, + }, + }, + }, + { + Type: "function", + Function: mcp.FunctionDef{ + Name: "manage_trader", + Description: "List, create, update, delete, start, or stop traders. Use this when the user asks to create a trader, rename one, switch its exchange/model/strategy, delete it, or control its running state.", + Parameters: map[string]any{ + "type": "object", + "properties": map[string]any{ + "action": map[string]any{ + "type": "string", + "enum": []string{"list", "create", "update", "delete", "start", "stop"}, + }, + "trader_id": map[string]any{ + "type": "string", + "description": "Required for update, delete, start, and stop.", + }, + "name": map[string]any{"type": "string"}, + "ai_model_id": map[string]any{"type": "string"}, + "exchange_id": map[string]any{"type": "string"}, + "strategy_id": map[string]any{"type": "string"}, + "initial_balance": map[string]any{"type": "number"}, + "scan_interval_minutes": map[string]any{"type": "number"}, + "is_cross_margin": map[string]any{"type": "boolean"}, + "show_in_competition": map[string]any{"type": "boolean"}, + "btc_eth_leverage": map[string]any{"type": "number"}, + "altcoin_leverage": map[string]any{"type": "number"}, + "trading_symbols": map[string]any{"type": "string"}, + "custom_prompt": map[string]any{"type": "string"}, + "override_base_prompt": map[string]any{"type": "boolean"}, + "system_prompt_template": map[string]any{"type": "string"}, + "use_ai500": map[string]any{"type": "boolean"}, + "use_oi_top": map[string]any{"type": "boolean"}, + }, + "required": []string{"action"}, + }, + }, + }, + { + Type: "function", + Function: mcp.FunctionDef{ + Name: "search_stock", + Description: "Search for a stock by name, ticker symbol, or keyword. Searches across A-share (沪深), Hong Kong, and US markets. Returns a list of matching stocks with their codes. Use this when the user asks about a stock not in your known list, or when you need to find the exact code for a stock.", + Parameters: map[string]any{ + "type": "object", + "properties": map[string]any{ + "keyword": map[string]any{ + "type": "string", + "description": "Search keyword: stock name (e.g. '宁德时代', '腾讯'), ticker (e.g. 'TSLA', 'AAPL'), or stock code (e.g. '300750')", + }, + }, + "required": []string{"keyword"}, + }, + }, + }, + { + Type: "function", + Function: mcp.FunctionDef{ + Name: "execute_trade", + Description: "Execute a trade order (crypto or US stocks). Use this when the user explicitly asks to open/close a position. For stocks (e.g. AAPL, TSLA), use open_long to buy and close_long to sell. This creates a pending trade that requires user confirmation.", + Parameters: map[string]any{ + "type": "object", + "properties": map[string]any{ + "action": map[string]any{ + "type": "string", + "enum": []string{"open_long", "open_short", "close_long", "close_short"}, + "description": "Trade action: open_long (做多/buy), open_short (做空/sell), close_long (平多), close_short (平空)", + }, + "symbol": map[string]any{ + "type": "string", + "description": "Trading symbol. For crypto: BTCUSDT, ETHUSDT. For US stocks: AAPL, TSLA, NVDA (no suffix needed).", + }, + "quantity": map[string]any{ + "type": "number", + "description": "Trade quantity/amount. Required for opening positions. Use 0 to close entire position.", + }, + "leverage": map[string]any{ + "type": "number", + "description": "Leverage multiplier (e.g. 5, 10, 20). Optional, defaults to trader's current setting.", + }, + }, + "required": []string{"action", "symbol", "quantity"}, + }, + }, + }, + { + Type: "function", + Function: mcp.FunctionDef{ + Name: "get_positions", + Description: "Get all current open positions across all traders. Returns symbol, side, size, entry price, mark price, and unrealized PnL.", + Parameters: map[string]any{"type": "object", "properties": map[string]any{}}, + }, + }, + { + Type: "function", + Function: mcp.FunctionDef{ + Name: "get_balance", + Description: "Get account balance and equity across all traders.", + Parameters: map[string]any{"type": "object", "properties": map[string]any{}}, + }, + }, + { + Type: "function", + Function: mcp.FunctionDef{ + Name: "get_market_price", + Description: "Get the current market price for a crypto or stock symbol.", + Parameters: map[string]any{ + "type": "object", + "properties": map[string]any{ + "symbol": map[string]any{ + "type": "string", + "description": "Trading symbol, e.g. BTCUSDT for crypto, AAPL for stocks", + }, + }, + "required": []string{"symbol"}, + }, + }, + }, + { + Type: "function", + Function: mcp.FunctionDef{ + Name: "get_trade_history", + Description: "Get recent closed trade history with PnL. Use when user asks about past trades, performance, or trade results. Returns the most recent closed positions.", + Parameters: map[string]any{ + "type": "object", + "properties": map[string]any{ + "limit": map[string]any{ + "type": "number", + "description": "Number of recent trades to return (default 10, max 50)", + }, + }, + }, + }, + }, + { + Type: "function", + Function: mcp.FunctionDef{ + Name: "get_candidate_coins", + Description: "Get the current candidate coin list for a trader or strategy, including AI500 coin-source settings and the selected symbols.", + Parameters: map[string]any{ + "type": "object", + "properties": map[string]any{ + "trader_id": map[string]any{ + "type": "string", + "description": "Optional trader id. Prefer this when asking about a running trader.", + }, + "strategy_id": map[string]any{ + "type": "string", + "description": "Optional strategy id. Use this when asking about a strategy template directly.", + }, + }, + }, + }, + }, + } +} + +// handleToolCall processes a single tool call from the LLM and returns the result. +func (a *Agent) handleToolCall(ctx context.Context, storeUserID string, userID int64, lang string, tc mcp.ToolCall) string { + switch tc.Function.Name { + case "get_preferences": + return a.toolGetPreferences(userID) + case "manage_preferences": + return a.toolManagePreferences(userID, tc.Function.Arguments) + case "get_backend_logs": + return a.toolGetBackendLogs(storeUserID, tc.Function.Arguments) + case "get_exchange_configs": + return a.toolGetExchangeConfigs(storeUserID) + case "manage_exchange_config": + return a.toolManageExchangeConfig(storeUserID, tc.Function.Arguments) + case "get_model_configs": + return a.toolGetModelConfigs(storeUserID) + case "manage_model_config": + return a.toolManageModelConfig(storeUserID, tc.Function.Arguments) + case "get_strategies": + return a.toolGetStrategies(storeUserID) + case "manage_strategy": + return a.toolManageStrategy(storeUserID, tc.Function.Arguments) + case "manage_trader": + return a.toolManageTrader(storeUserID, tc.Function.Arguments) + case "search_stock": + return a.toolSearchStock(tc.Function.Arguments) + case "execute_trade": + return a.toolExecuteTrade(ctx, userID, lang, tc.Function.Arguments) + case "get_positions": + return a.toolGetPositions() + case "get_balance": + return a.toolGetBalance() + case "get_market_price": + return a.toolGetMarketPrice(tc.Function.Arguments) + case "get_trade_history": + return a.toolGetTradeHistory(tc.Function.Arguments) + case "get_candidate_coins": + return a.toolGetCandidateCoins(storeUserID, userID, tc.Function.Arguments) + default: + return fmt.Sprintf(`{"error": "unknown tool: %s"}`, tc.Function.Name) + } +} + +type safeExchangeToolConfig struct { + ID string `json:"id"` + ExchangeType string `json:"exchange_type"` + AccountName string `json:"account_name"` + Name string `json:"name"` + Type string `json:"type"` + Enabled bool `json:"enabled"` + HasAPIKey bool `json:"has_api_key"` + HasSecretKey bool `json:"has_secret_key"` + HasPassphrase bool `json:"has_passphrase"` + Testnet bool `json:"testnet"` + HyperliquidWalletAddr string `json:"hyperliquid_wallet_addr,omitempty"` + HasAsterPrivateKey bool `json:"has_aster_private_key"` + AsterUser string `json:"aster_user,omitempty"` + AsterSigner string `json:"aster_signer,omitempty"` + LighterWalletAddr string `json:"lighter_wallet_addr,omitempty"` + HasLighterPrivateKey bool `json:"has_lighter_private_key"` + HasLighterAPIKey bool `json:"has_lighter_api_key_private_key"` +} + +type safeModelToolConfig struct { + ID string `json:"id"` + Name string `json:"name"` + Provider string `json:"provider"` + Enabled bool `json:"enabled"` + HasAPIKey bool `json:"has_api_key"` + CustomAPIURL string `json:"custom_api_url,omitempty"` + CustomModelName string `json:"custom_model_name,omitempty"` +} + +type safeTraderToolConfig struct { + ID string `json:"id"` + Name string `json:"name"` + AIModelID string `json:"ai_model_id"` + ExchangeID string `json:"exchange_id"` + StrategyID string `json:"strategy_id,omitempty"` + InitialBalance float64 `json:"initial_balance"` + ScanIntervalMinutes int `json:"scan_interval_minutes"` + IsRunning bool `json:"is_running"` + IsCrossMargin bool `json:"is_cross_margin"` + ShowInCompetition bool `json:"show_in_competition"` + BTCETHLeverage int `json:"btc_eth_leverage,omitempty"` + AltcoinLeverage int `json:"altcoin_leverage,omitempty"` + TradingSymbols string `json:"trading_symbols,omitempty"` + CustomPrompt string `json:"custom_prompt,omitempty"` + SystemPromptTemplate string `json:"system_prompt_template,omitempty"` +} + +type safeStrategyToolConfig struct { + ID string `json:"id"` + Name string `json:"name"` + Description string `json:"description"` + IsActive bool `json:"is_active"` + IsDefault bool `json:"is_default"` + IsPublic bool `json:"is_public"` + ConfigVisible bool `json:"config_visible"` + Config map[string]any `json:"config,omitempty"` + HasConfig bool `json:"has_config"` +} + +type manageTraderArgs struct { + Action string `json:"action"` + TraderID string `json:"trader_id"` + Name string `json:"name"` + AIModelID string `json:"ai_model_id"` + ExchangeID string `json:"exchange_id"` + StrategyID string `json:"strategy_id"` + InitialBalance *float64 `json:"initial_balance"` + ScanIntervalMinutes *int `json:"scan_interval_minutes"` + IsCrossMargin *bool `json:"is_cross_margin"` + ShowInCompetition *bool `json:"show_in_competition"` + BTCETHLeverage *int `json:"btc_eth_leverage"` + AltcoinLeverage *int `json:"altcoin_leverage"` + TradingSymbols string `json:"trading_symbols"` + CustomPrompt string `json:"custom_prompt"` + OverrideBasePrompt *bool `json:"override_base_prompt"` + SystemPromptTemplate string `json:"system_prompt_template"` + UseAI500 *bool `json:"use_ai500"` + UseOITop *bool `json:"use_oi_top"` +} + +func safeExchangeForTool(ex *store.Exchange) safeExchangeToolConfig { + return safeExchangeToolConfig{ + ID: ex.ID, + ExchangeType: ex.ExchangeType, + AccountName: ex.AccountName, + Name: ex.Name, + Type: ex.Type, + Enabled: ex.Enabled, + HasAPIKey: ex.APIKey != "", + HasSecretKey: ex.SecretKey != "", + HasPassphrase: ex.Passphrase != "", + Testnet: ex.Testnet, + HyperliquidWalletAddr: ex.HyperliquidWalletAddr, + HasAsterPrivateKey: ex.AsterPrivateKey != "", + AsterUser: ex.AsterUser, + AsterSigner: ex.AsterSigner, + LighterWalletAddr: ex.LighterWalletAddr, + HasLighterPrivateKey: ex.LighterPrivateKey != "", + HasLighterAPIKey: ex.LighterAPIKeyPrivateKey != "", + } +} + +func safeModelForTool(model *store.AIModel) safeModelToolConfig { + return safeModelToolConfig{ + ID: model.ID, + Name: model.Name, + Provider: model.Provider, + Enabled: model.Enabled, + HasAPIKey: model.APIKey != "", + CustomAPIURL: model.CustomAPIURL, + CustomModelName: model.CustomModelName, + } +} + +func modelConfigUsable(provider, modelID, apiKey, customAPIURL, customModelName string) bool { + if strings.TrimSpace(apiKey) == "" { + return false + } + resolvedURL, resolvedModel := resolveModelRuntimeConfig(provider, customAPIURL, customModelName, modelID) + return strings.TrimSpace(resolvedURL) != "" && strings.TrimSpace(resolvedModel) != "" +} + +func safeTraderForTool(trader *store.Trader, isRunning bool) safeTraderToolConfig { + return safeTraderToolConfig{ + ID: trader.ID, + Name: trader.Name, + AIModelID: trader.AIModelID, + ExchangeID: trader.ExchangeID, + StrategyID: trader.StrategyID, + InitialBalance: trader.InitialBalance, + ScanIntervalMinutes: trader.ScanIntervalMinutes, + IsRunning: isRunning, + IsCrossMargin: trader.IsCrossMargin, + ShowInCompetition: trader.ShowInCompetition, + BTCETHLeverage: trader.BTCETHLeverage, + AltcoinLeverage: trader.AltcoinLeverage, + TradingSymbols: trader.TradingSymbols, + CustomPrompt: trader.CustomPrompt, + SystemPromptTemplate: trader.SystemPromptTemplate, + } +} + +func safeStrategyForTool(strategy *store.Strategy) safeStrategyToolConfig { + out := safeStrategyToolConfig{ + ID: strategy.ID, + Name: strategy.Name, + Description: strategy.Description, + IsActive: strategy.IsActive, + IsDefault: strategy.IsDefault, + IsPublic: strategy.IsPublic, + ConfigVisible: strategy.ConfigVisible, + HasConfig: strings.TrimSpace(strategy.Config) != "", + } + if out.HasConfig { + var cfg map[string]any + if err := json.Unmarshal([]byte(strategy.Config), &cfg); err == nil { + out.Config = cfg + } + } + return out +} + +func (a *Agent) toolGetExchangeConfigs(storeUserID string) string { + if a.store == nil { + return `{"error":"store unavailable"}` + } + exchanges, err := a.store.Exchange().List(storeUserID) + if err != nil { + return fmt.Sprintf(`{"error":"failed to load exchange configs: %s"}`, err) + } + safe := make([]safeExchangeToolConfig, 0, len(exchanges)) + for _, ex := range exchanges { + safe = append(safe, safeExchangeForTool(ex)) + } + result, _ := json.Marshal(map[string]any{ + "exchange_configs": safe, + "count": len(safe), + }) + return string(result) +} + +func latestBackendLogFilePath() string { + matches, err := filepath.Glob(filepath.Join("data", "nofx_*.log")) + if err != nil || len(matches) == 0 { + return "" + } + sort.Strings(matches) + return matches[len(matches)-1] +} + +func isBackendErrorLikeLogLine(line string) bool { + lower := strings.ToLower(strings.TrimSpace(line)) + if lower == "" { + return false + } + return strings.Contains(lower, "[erro]") || + strings.Contains(lower, " panic") || + strings.Contains(lower, "🔥") || + strings.Contains(lower, "❌") || + strings.Contains(lower, " failed") || + strings.Contains(lower, " error") || + strings.Contains(lower, "invalid ") +} + +func readBackendLogEntries(limit int, contains string, errorsOnly bool) (string, []string, error) { + path := latestBackendLogFilePath() + if path == "" { + return "", nil, fmt.Errorf("backend log file not found") + } + file, err := os.Open(path) + if err != nil { + return path, nil, err + } + defer file.Close() + + filter := strings.ToLower(strings.TrimSpace(contains)) + matches := make([]string, 0, max(limit, 1)) + scanner := bufio.NewScanner(file) + for scanner.Scan() { + line := scanner.Text() + if errorsOnly && !isBackendErrorLikeLogLine(line) { + continue + } + if filter != "" && !strings.Contains(strings.ToLower(line), filter) { + continue + } + matches = append(matches, line) + } + if err := scanner.Err(); err != nil { + return path, nil, err + } + if limit <= 0 { + limit = 30 + } + if len(matches) > limit { + matches = matches[len(matches)-limit:] + } + return path, matches, nil +} + +func (a *Agent) toolGetBackendLogs(storeUserID, argsJSON string) string { + var args struct { + TraderID string `json:"trader_id"` + Limit int `json:"limit"` + ErrorsOnly *bool `json:"errors_only"` + } + if strings.TrimSpace(argsJSON) != "" { + if err := json.Unmarshal([]byte(argsJSON), &args); err != nil { + return fmt.Sprintf(`{"error":"invalid arguments: %s"}`, err) + } + } + errorsOnly := true + if args.ErrorsOnly != nil { + errorsOnly = *args.ErrorsOnly + } + traderID := strings.TrimSpace(args.TraderID) + if traderID == "" { + return `{"error":"trader_id is required"}` + } + if a.store == nil { + return `{"error":"store unavailable"}` + } + trader, err := a.store.Trader().GetByID(traderID) + if err != nil { + return fmt.Sprintf(`{"error":"failed to load trader: %s"}`, err) + } + if trader.UserID != storeUserID { + return `{"error":"trader not found for current user"}` + } + path, entries, err := readBackendLogEntries(args.Limit, traderID, errorsOnly) + if err != nil { + return fmt.Sprintf(`{"error":"failed to read backend logs: %s"}`, err) + } + result, _ := json.Marshal(map[string]any{ + "trader_id": traderID, + "log_file": path, + "entries": entries, + "count": len(entries), + "errors_only": errorsOnly, + }) + return string(result) +} + +func (a *Agent) toolManageExchangeConfig(storeUserID, argsJSON string) string { + if a.store == nil { + return `{"error":"store unavailable"}` + } + var args struct { + Action string `json:"action"` + ExchangeID string `json:"exchange_id"` + ExchangeType string `json:"exchange_type"` + AccountName string `json:"account_name"` + Enabled *bool `json:"enabled"` + APIKey string `json:"api_key"` + SecretKey string `json:"secret_key"` + Passphrase string `json:"passphrase"` + Testnet *bool `json:"testnet"` + HyperliquidWalletAddr string `json:"hyperliquid_wallet_addr"` + HyperliquidUnifiedAccount *bool `json:"hyperliquid_unified_account"` + AsterUser string `json:"aster_user"` + AsterSigner string `json:"aster_signer"` + AsterPrivateKey string `json:"aster_private_key"` + LighterWalletAddr string `json:"lighter_wallet_addr"` + LighterPrivateKey string `json:"lighter_private_key"` + LighterAPIKeyPrivateKey string `json:"lighter_api_key_private_key"` + LighterAPIKeyIndex *int `json:"lighter_api_key_index"` + } + if err := json.Unmarshal([]byte(argsJSON), &args); err != nil { + return fmt.Sprintf(`{"error":"invalid arguments: %s"}`, err) + } + action := strings.TrimSpace(args.Action) + switch action { + case "create": + if strings.TrimSpace(args.ExchangeType) == "" { + return `{"error":"exchange_type is required for create"}` + } + enabled := false + if args.Enabled != nil { + enabled = *args.Enabled + } + testnet := false + if args.Testnet != nil { + testnet = *args.Testnet + } + unified := true + if args.HyperliquidUnifiedAccount != nil { + unified = *args.HyperliquidUnifiedAccount + } + lighterIndex := 0 + if args.LighterAPIKeyIndex != nil { + lighterIndex = *args.LighterAPIKeyIndex + } + id, err := a.store.Exchange().Create( + storeUserID, + strings.TrimSpace(args.ExchangeType), + strings.TrimSpace(args.AccountName), + enabled, + strings.TrimSpace(args.APIKey), + strings.TrimSpace(args.SecretKey), + strings.TrimSpace(args.Passphrase), + testnet, + strings.TrimSpace(args.HyperliquidWalletAddr), + unified, + strings.TrimSpace(args.AsterUser), + strings.TrimSpace(args.AsterSigner), + strings.TrimSpace(args.AsterPrivateKey), + strings.TrimSpace(args.LighterWalletAddr), + strings.TrimSpace(args.LighterPrivateKey), + strings.TrimSpace(args.LighterAPIKeyPrivateKey), + lighterIndex, + ) + if err != nil { + return fmt.Sprintf(`{"error":"failed to create exchange config: %s"}`, err) + } + created, err := a.store.Exchange().GetByID(storeUserID, id) + if err != nil { + return fmt.Sprintf(`{"error":"exchange created but failed to reload: %s"}`, err) + } + result, _ := json.Marshal(map[string]any{ + "status": "ok", + "action": "create", + "exchange": safeExchangeForTool(created), + }) + return string(result) + case "update": + if strings.TrimSpace(args.ExchangeID) == "" { + return `{"error":"exchange_id is required for update"}` + } + existing, err := a.store.Exchange().GetByID(storeUserID, strings.TrimSpace(args.ExchangeID)) + if err != nil { + return fmt.Sprintf(`{"error":"failed to load exchange config: %s"}`, err) + } + enabled := existing.Enabled + if args.Enabled != nil { + enabled = *args.Enabled + } + testnet := existing.Testnet + if args.Testnet != nil { + testnet = *args.Testnet + } + unified := existing.HyperliquidUnifiedAcct + if args.HyperliquidUnifiedAccount != nil { + unified = *args.HyperliquidUnifiedAccount + } + lighterIndex := existing.LighterAPIKeyIndex + if args.LighterAPIKeyIndex != nil { + lighterIndex = *args.LighterAPIKeyIndex + } + hyperWallet := existing.HyperliquidWalletAddr + if strings.TrimSpace(args.HyperliquidWalletAddr) != "" { + hyperWallet = strings.TrimSpace(args.HyperliquidWalletAddr) + } + asterUser := existing.AsterUser + if strings.TrimSpace(args.AsterUser) != "" { + asterUser = strings.TrimSpace(args.AsterUser) + } + asterSigner := existing.AsterSigner + if strings.TrimSpace(args.AsterSigner) != "" { + asterSigner = strings.TrimSpace(args.AsterSigner) + } + lighterWallet := existing.LighterWalletAddr + if strings.TrimSpace(args.LighterWalletAddr) != "" { + lighterWallet = strings.TrimSpace(args.LighterWalletAddr) + } + if err := a.store.Exchange().Update( + storeUserID, + existing.ID, + enabled, + strings.TrimSpace(args.APIKey), + strings.TrimSpace(args.SecretKey), + strings.TrimSpace(args.Passphrase), + testnet, + hyperWallet, + unified, + asterUser, + asterSigner, + strings.TrimSpace(args.AsterPrivateKey), + lighterWallet, + strings.TrimSpace(args.LighterPrivateKey), + strings.TrimSpace(args.LighterAPIKeyPrivateKey), + lighterIndex, + ); err != nil { + return fmt.Sprintf(`{"error":"failed to update exchange config: %s"}`, err) + } + if trimmed := strings.TrimSpace(args.AccountName); trimmed != "" && trimmed != existing.AccountName { + if err := a.store.Exchange().UpdateAccountName(storeUserID, existing.ID, trimmed); err != nil { + return fmt.Sprintf(`{"error":"exchange updated but failed to rename account: %s"}`, err) + } + } + updated, err := a.store.Exchange().GetByID(storeUserID, existing.ID) + if err != nil { + return fmt.Sprintf(`{"error":"exchange updated but failed to reload: %s"}`, err) + } + result, _ := json.Marshal(map[string]any{ + "status": "ok", + "action": "update", + "exchange": safeExchangeForTool(updated), + }) + return string(result) + case "delete": + if strings.TrimSpace(args.ExchangeID) == "" { + return `{"error":"exchange_id is required for delete"}` + } + if err := a.store.Exchange().Delete(storeUserID, strings.TrimSpace(args.ExchangeID)); err != nil { + return fmt.Sprintf(`{"error":"failed to delete exchange config: %s"}`, err) + } + result, _ := json.Marshal(map[string]any{ + "status": "ok", + "action": "delete", + "exchange_id": strings.TrimSpace(args.ExchangeID), + }) + return string(result) + default: + return `{"error":"invalid action"}` + } +} + +func (a *Agent) toolGetModelConfigs(storeUserID string) string { + if a.store == nil { + return `{"error":"store unavailable"}` + } + models, err := a.store.AIModel().List(storeUserID) + if err != nil { + return fmt.Sprintf(`{"error":"failed to load model configs: %s"}`, err) + } + safe := make([]safeModelToolConfig, 0, len(models)) + for _, model := range models { + safe = append(safe, safeModelForTool(model)) + } + result, _ := json.Marshal(map[string]any{ + "model_configs": safe, + "count": len(safe), + }) + return string(result) +} + +func (a *Agent) toolManageModelConfig(storeUserID, argsJSON string) string { + if a.store == nil { + return `{"error":"store unavailable"}` + } + var args struct { + Action string `json:"action"` + ModelID string `json:"model_id"` + Provider string `json:"provider"` + Name string `json:"name"` + Enabled *bool `json:"enabled"` + APIKey string `json:"api_key"` + CustomAPIURL string `json:"custom_api_url"` + CustomModelName string `json:"custom_model_name"` + } + if err := json.Unmarshal([]byte(argsJSON), &args); err != nil { + return fmt.Sprintf(`{"error":"invalid arguments: %s"}`, err) + } + if trimmed := strings.TrimSpace(args.CustomAPIURL); trimmed != "" { + if err := security.ValidateURL(strings.TrimSuffix(trimmed, "#")); err != nil { + return fmt.Sprintf(`{"error":"invalid custom_api_url: %s"}`, err) + } + } + action := strings.TrimSpace(args.Action) + switch action { + case "create": + provider := strings.TrimSpace(args.Provider) + if provider == "" { + return `{"error":"provider is required for create"}` + } + modelID := strings.TrimSpace(args.ModelID) + if modelID == "" { + modelID = provider + } + enabled := false + if args.Enabled != nil { + enabled = *args.Enabled + } + if err := a.store.AIModel().Update(storeUserID, modelID, enabled, strings.TrimSpace(args.APIKey), strings.TrimSpace(args.CustomAPIURL), strings.TrimSpace(args.CustomModelName)); err != nil { + return fmt.Sprintf(`{"error":"failed to create model config: %s"}`, err) + } + createdID := modelID + if modelID == provider { + createdID = fmt.Sprintf("%s_%s", storeUserID, provider) + } + model, err := a.store.AIModel().Get(storeUserID, createdID) + if err != nil { + model, err = a.store.AIModel().Get(storeUserID, modelID) + } + if err != nil { + return fmt.Sprintf(`{"error":"model created but failed to reload: %s"}`, err) + } + result, _ := json.Marshal(map[string]any{ + "status": "ok", + "action": "create", + "model": safeModelForTool(model), + }) + return string(result) + case "update": + modelID := strings.TrimSpace(args.ModelID) + if modelID == "" { + return `{"error":"model_id is required for update"}` + } + existing, err := a.store.AIModel().Get(storeUserID, modelID) + if err != nil { + return fmt.Sprintf(`{"error":"failed to load model config: %s"}`, err) + } + enabled := existing.Enabled + if args.Enabled != nil { + enabled = *args.Enabled + } + customAPIURL := existing.CustomAPIURL + if strings.TrimSpace(args.CustomAPIURL) != "" { + customAPIURL = strings.TrimSpace(args.CustomAPIURL) + } + customModelName := existing.CustomModelName + if strings.TrimSpace(args.CustomModelName) != "" { + customModelName = strings.TrimSpace(args.CustomModelName) + } + apiKey := strings.TrimSpace(args.APIKey) + effectiveAPIKey := string(existing.APIKey) + if apiKey != "" { + effectiveAPIKey = apiKey + } + if enabled && !modelConfigUsable(existing.Provider, existing.ID, effectiveAPIKey, customAPIURL, customModelName) { + return `{"error":"cannot enable model config before API key is configured"}` + } + if err := a.store.AIModel().Update(storeUserID, existing.ID, enabled, apiKey, customAPIURL, customModelName); err != nil { + return fmt.Sprintf(`{"error":"failed to update model config: %s"}`, err) + } + updated, err := a.store.AIModel().Get(storeUserID, existing.ID) + if err != nil { + return fmt.Sprintf(`{"error":"model updated but failed to reload: %s"}`, err) + } + result, _ := json.Marshal(map[string]any{ + "status": "ok", + "action": "update", + "model": safeModelForTool(updated), + }) + return string(result) + case "delete": + modelID := strings.TrimSpace(args.ModelID) + if modelID == "" { + return `{"error":"model_id is required for delete"}` + } + if err := a.store.AIModel().Delete(storeUserID, modelID); err != nil { + return fmt.Sprintf(`{"error":"failed to delete model config: %s"}`, err) + } + result, _ := json.Marshal(map[string]any{ + "status": "ok", + "action": "delete", + "model_id": modelID, + }) + return string(result) + default: + return `{"error":"invalid action"}` + } +} + +func (a *Agent) toolGetStrategies(storeUserID string) string { + if a.store == nil { + return `{"error":"store unavailable"}` + } + strategies, err := a.store.Strategy().List(storeUserID) + if err != nil { + return fmt.Sprintf(`{"error":"failed to load strategies: %s"}`, err) + } + safeStrategies := make([]safeStrategyToolConfig, 0, len(strategies)) + for _, strategy := range strategies { + safeStrategies = append(safeStrategies, safeStrategyForTool(strategy)) + } + result, _ := json.Marshal(map[string]any{ + "strategies": safeStrategies, + "count": len(safeStrategies), + }) + return string(result) +} + +func (a *Agent) toolManageStrategy(storeUserID, argsJSON string) string { + if a.store == nil { + return `{"error":"store unavailable"}` + } + var args struct { + Action string `json:"action"` + StrategyID string `json:"strategy_id"` + Name string `json:"name"` + Description string `json:"description"` + Lang string `json:"lang"` + IsPublic *bool `json:"is_public"` + ConfigVisible *bool `json:"config_visible"` + Config map[string]any `json:"config"` + } + if err := json.Unmarshal([]byte(argsJSON), &args); err != nil { + return fmt.Sprintf(`{"error":"invalid arguments: %s"}`, err) + } + + switch strings.TrimSpace(args.Action) { + case "list": + return a.toolGetStrategies(storeUserID) + case "get_default_config": + lang := strings.TrimSpace(args.Lang) + if lang != "zh" { + lang = "en" + } + cfg := store.GetDefaultStrategyConfig(lang) + payload, _ := json.Marshal(map[string]any{ + "status": "ok", + "action": "get_default_config", + "config": cfg, + }) + return string(payload) + case "create": + name := strings.TrimSpace(args.Name) + if name == "" { + return `{"error":"name is required for create"}` + } + var cfg any = store.GetDefaultStrategyConfig(strings.TrimSpace(args.Lang)) + if len(args.Config) > 0 { + cfg = args.Config + } + configJSON, err := json.Marshal(cfg) + if err != nil { + return fmt.Sprintf(`{"error":"failed to serialize strategy config: %s"}`, err) + } + record := &store.Strategy{ + ID: fmt.Sprintf("strategy_%d", time.Now().UnixNano()), + UserID: storeUserID, + Name: name, + Description: strings.TrimSpace(args.Description), + IsActive: false, + IsDefault: false, + IsPublic: args.IsPublic != nil && *args.IsPublic, + ConfigVisible: args.ConfigVisible == nil || *args.ConfigVisible, + Config: string(configJSON), + } + if err := a.store.Strategy().Create(record); err != nil { + return fmt.Sprintf(`{"error":"failed to create strategy: %s"}`, err) + } + payload, _ := json.Marshal(map[string]any{ + "status": "ok", + "action": "create", + "strategy": safeStrategyForTool(record), + }) + return string(payload) + case "update": + strategyID := strings.TrimSpace(args.StrategyID) + if strategyID == "" { + return `{"error":"strategy_id is required for update"}` + } + existing, err := a.store.Strategy().Get(storeUserID, strategyID) + if err != nil { + return fmt.Sprintf(`{"error":"failed to load strategy: %s"}`, err) + } + if existing.IsDefault { + return `{"error":"cannot modify system default strategy"}` + } + name := existing.Name + if trimmed := strings.TrimSpace(args.Name); trimmed != "" { + name = trimmed + } + description := existing.Description + if trimmed := strings.TrimSpace(args.Description); trimmed != "" { + description = trimmed + } + isPublic := existing.IsPublic + if args.IsPublic != nil { + isPublic = *args.IsPublic + } + configVisible := existing.ConfigVisible + if args.ConfigVisible != nil { + configVisible = *args.ConfigVisible + } + configJSON := existing.Config + if len(args.Config) > 0 { + raw, err := json.Marshal(args.Config) + if err != nil { + return fmt.Sprintf(`{"error":"failed to serialize strategy config: %s"}`, err) + } + configJSON = string(raw) + } + record := &store.Strategy{ + ID: existing.ID, + UserID: storeUserID, + Name: name, + Description: description, + IsPublic: isPublic, + ConfigVisible: configVisible, + Config: configJSON, + } + if err := a.store.Strategy().Update(record); err != nil { + return fmt.Sprintf(`{"error":"failed to update strategy: %s"}`, err) + } + updated, err := a.store.Strategy().Get(storeUserID, existing.ID) + if err != nil { + return fmt.Sprintf(`{"error":"strategy updated but failed to reload: %s"}`, err) + } + payload, _ := json.Marshal(map[string]any{ + "status": "ok", + "action": "update", + "strategy": safeStrategyForTool(updated), + }) + return string(payload) + case "delete": + strategyID := strings.TrimSpace(args.StrategyID) + if strategyID == "" { + return `{"error":"strategy_id is required for delete"}` + } + if err := a.store.Strategy().Delete(storeUserID, strategyID); err != nil { + if strings.Contains(err.Error(), "cannot delete active strategy") { + strategies, listErr := a.store.Strategy().List(storeUserID) + if listErr != nil { + return fmt.Sprintf(`{"error":"failed to prepare active strategy deletion: %s"}`, listErr) + } + + var fallbackID string + for _, strategy := range strategies { + if strategy == nil || strategy.ID == strategyID { + continue + } + if strategy.IsDefault { + fallbackID = strategy.ID + break + } + if fallbackID == "" { + fallbackID = strategy.ID + } + } + if fallbackID == "" { + defaultConfig := store.GetDefaultStrategyConfig("zh") + defaultConfig.ClampLimits() + configJSON, marshalErr := json.Marshal(defaultConfig) + if marshalErr != nil { + return fmt.Sprintf(`{"error":"failed to create fallback strategy config: %s"}`, marshalErr) + } + + fallbackID = fmt.Sprintf("strategy_%d", time.Now().UnixNano()) + fallbackStrategy := &store.Strategy{ + ID: fallbackID, + UserID: storeUserID, + Name: "默认策略", + Description: "Agent-generated fallback strategy", + Config: string(configJSON), + } + if createErr := a.store.Strategy().Create(fallbackStrategy); createErr != nil { + return fmt.Sprintf(`{"error":"failed to create fallback strategy before deletion: %s"}`, createErr) + } + } + if activateErr := a.store.Strategy().SetActive(storeUserID, fallbackID); activateErr != nil { + return fmt.Sprintf(`{"error":"failed to switch active strategy before deletion: %s"}`, activateErr) + } + if retryErr := a.store.Strategy().Delete(storeUserID, strategyID); retryErr != nil { + return fmt.Sprintf(`{"error":"failed to delete strategy: %s"}`, retryErr) + } + } else { + return fmt.Sprintf(`{"error":"failed to delete strategy: %s"}`, err) + } + } + payload, _ := json.Marshal(map[string]any{ + "status": "ok", + "action": "delete", + "strategy_id": strategyID, + }) + return string(payload) + case "activate": + strategyID := strings.TrimSpace(args.StrategyID) + if strategyID == "" { + return `{"error":"strategy_id is required for activate"}` + } + if err := a.store.Strategy().SetActive(storeUserID, strategyID); err != nil { + return fmt.Sprintf(`{"error":"failed to activate strategy: %s"}`, err) + } + updated, err := a.store.Strategy().Get(storeUserID, strategyID) + if err != nil { + return fmt.Sprintf(`{"error":"strategy activated but failed to reload: %s"}`, err) + } + payload, _ := json.Marshal(map[string]any{ + "status": "ok", + "action": "activate", + "strategy": safeStrategyForTool(updated), + }) + return string(payload) + case "duplicate": + sourceID := strings.TrimSpace(args.StrategyID) + name := strings.TrimSpace(args.Name) + if sourceID == "" { + return `{"error":"strategy_id is required for duplicate"}` + } + if name == "" { + return `{"error":"name is required for duplicate"}` + } + newID := fmt.Sprintf("strategy_%d", time.Now().UnixNano()) + if err := a.store.Strategy().Duplicate(storeUserID, sourceID, newID, name); err != nil { + return fmt.Sprintf(`{"error":"failed to duplicate strategy: %s"}`, err) + } + created, err := a.store.Strategy().Get(storeUserID, newID) + if err != nil { + return fmt.Sprintf(`{"error":"strategy duplicated but failed to reload: %s"}`, err) + } + payload, _ := json.Marshal(map[string]any{ + "status": "ok", + "action": "duplicate", + "strategy": safeStrategyForTool(created), + }) + return string(payload) + default: + return `{"error":"invalid action"}` + } +} + +func (a *Agent) toolManageTrader(storeUserID, argsJSON string) string { + if a.store == nil { + return `{"error":"store unavailable"}` + } + var args manageTraderArgs + if err := json.Unmarshal([]byte(argsJSON), &args); err != nil { + return fmt.Sprintf(`{"error":"invalid arguments: %s"}`, err) + } + + switch strings.TrimSpace(args.Action) { + case "list": + return a.toolListTraders(storeUserID) + case "create": + return a.toolCreateTrader(storeUserID, args) + case "update": + return a.toolUpdateTrader(storeUserID, args) + case "delete": + return a.toolDeleteTrader(storeUserID, strings.TrimSpace(args.TraderID)) + case "start": + return a.toolStartTrader(storeUserID, strings.TrimSpace(args.TraderID)) + case "stop": + return a.toolStopTrader(storeUserID, strings.TrimSpace(args.TraderID)) + default: + return `{"error":"invalid action"}` + } +} + +func (a *Agent) toolListTraders(storeUserID string) string { + traders, err := a.store.Trader().List(storeUserID) + if err != nil { + return fmt.Sprintf(`{"error":"failed to list traders: %s"}`, err) + } + safeTraders := make([]safeTraderToolConfig, 0, len(traders)) + for _, traderCfg := range traders { + isRunning := traderCfg.IsRunning + if a.traderManager != nil { + if memTrader, err := a.traderManager.GetTrader(traderCfg.ID); err == nil { + if running, ok := memTrader.GetStatus()["is_running"].(bool); ok { + isRunning = running + } + } + } + safeTraders = append(safeTraders, safeTraderForTool(traderCfg, isRunning)) + } + result, _ := json.Marshal(map[string]any{ + "traders": safeTraders, + "count": len(safeTraders), + }) + return string(result) +} + +func (a *Agent) validateTraderReferences(storeUserID, aiModelID, exchangeID, strategyID string) error { + if strings.TrimSpace(aiModelID) == "" { + return fmt.Errorf("ai_model_id is required") + } + if strings.TrimSpace(exchangeID) == "" { + return fmt.Errorf("exchange_id is required") + } + model, err := a.store.AIModel().Get(storeUserID, strings.TrimSpace(aiModelID)) + if err != nil { + return fmt.Errorf("invalid ai_model_id: %w", err) + } + if !model.Enabled { + return fmt.Errorf("ai model is disabled") + } + exchange, err := a.store.Exchange().GetByID(storeUserID, strings.TrimSpace(exchangeID)) + if err != nil { + return fmt.Errorf("invalid exchange_id: %w", err) + } + if !exchange.Enabled { + return fmt.Errorf("exchange is disabled") + } + if trimmed := strings.TrimSpace(strategyID); trimmed != "" { + if _, err := a.store.Strategy().Get(storeUserID, trimmed); err != nil { + return fmt.Errorf("invalid strategy_id: %w", err) + } + } + return nil +} + +func (a *Agent) toolCreateTrader(storeUserID string, args manageTraderArgs) string { + name := strings.TrimSpace(args.Name) + if name == "" { + return `{"error":"name is required for create"}` + } + if err := a.validateTraderReferences(storeUserID, args.AIModelID, args.ExchangeID, args.StrategyID); err != nil { + return fmt.Sprintf(`{"error":"%s"}`, err) + } + scanInterval := 3 + if args.ScanIntervalMinutes != nil && *args.ScanIntervalMinutes > 0 { + scanInterval = *args.ScanIntervalMinutes + if scanInterval < 3 { + scanInterval = 3 + } + } + initialBalance := 0.0 + if args.InitialBalance != nil && *args.InitialBalance > 0 { + initialBalance = *args.InitialBalance + } + isCrossMargin := true + if args.IsCrossMargin != nil { + isCrossMargin = *args.IsCrossMargin + } + showInCompetition := true + if args.ShowInCompetition != nil { + showInCompetition = *args.ShowInCompetition + } + btcEthLeverage := 10 + if args.BTCETHLeverage != nil && *args.BTCETHLeverage > 0 { + btcEthLeverage = *args.BTCETHLeverage + } + altcoinLeverage := 5 + if args.AltcoinLeverage != nil && *args.AltcoinLeverage > 0 { + altcoinLeverage = *args.AltcoinLeverage + } + overrideBasePrompt := false + if args.OverrideBasePrompt != nil { + overrideBasePrompt = *args.OverrideBasePrompt + } + useAI500 := false + if args.UseAI500 != nil { + useAI500 = *args.UseAI500 + } + useOITop := false + if args.UseOITop != nil { + useOITop = *args.UseOITop + } + systemPromptTemplate := strings.TrimSpace(args.SystemPromptTemplate) + if systemPromptTemplate == "" { + systemPromptTemplate = "default" + } + exchangeIDShort := strings.TrimSpace(args.ExchangeID) + if len(exchangeIDShort) > 8 { + exchangeIDShort = exchangeIDShort[:8] + } + traderID := fmt.Sprintf("%s_%s_%d", exchangeIDShort, strings.TrimSpace(args.AIModelID), time.Now().Unix()) + record := &store.Trader{ + ID: traderID, + UserID: storeUserID, + Name: name, + AIModelID: strings.TrimSpace(args.AIModelID), + ExchangeID: strings.TrimSpace(args.ExchangeID), + StrategyID: strings.TrimSpace(args.StrategyID), + InitialBalance: initialBalance, + ScanIntervalMinutes: scanInterval, + IsRunning: false, + IsCrossMargin: isCrossMargin, + ShowInCompetition: showInCompetition, + BTCETHLeverage: btcEthLeverage, + AltcoinLeverage: altcoinLeverage, + TradingSymbols: strings.TrimSpace(args.TradingSymbols), + UseAI500: useAI500, + UseOITop: useOITop, + CustomPrompt: strings.TrimSpace(args.CustomPrompt), + OverrideBasePrompt: overrideBasePrompt, + SystemPromptTemplate: systemPromptTemplate, + } + if err := a.store.Trader().Create(record); err != nil { + return fmt.Sprintf(`{"error":"failed to create trader: %s"}`, err) + } + if a.traderManager != nil { + _ = a.traderManager.LoadUserTradersFromStore(a.store, storeUserID) + } + result, _ := json.Marshal(map[string]any{ + "status": "ok", + "action": "create", + "trader": safeTraderForTool(record, false), + }) + return string(result) +} + +func (a *Agent) toolUpdateTrader(storeUserID string, args manageTraderArgs) string { + traderID := strings.TrimSpace(args.TraderID) + if traderID == "" { + return `{"error":"trader_id is required for update"}` + } + traders, err := a.store.Trader().List(storeUserID) + if err != nil { + return fmt.Sprintf(`{"error":"failed to load traders: %s"}`, err) + } + var existing *store.Trader + for _, item := range traders { + if item.ID == traderID { + existing = item + break + } + } + if existing == nil { + return `{"error":"trader not found"}` + } + name := existing.Name + if trimmed := strings.TrimSpace(args.Name); trimmed != "" { + name = trimmed + } + aiModelID := existing.AIModelID + if trimmed := strings.TrimSpace(args.AIModelID); trimmed != "" { + aiModelID = trimmed + } + exchangeID := existing.ExchangeID + if trimmed := strings.TrimSpace(args.ExchangeID); trimmed != "" { + exchangeID = trimmed + } + strategyID := existing.StrategyID + if trimmed := strings.TrimSpace(args.StrategyID); trimmed != "" { + strategyID = trimmed + } + if err := a.validateTraderReferences(storeUserID, aiModelID, exchangeID, strategyID); err != nil { + return fmt.Sprintf(`{"error":"%s"}`, err) + } + record := &store.Trader{ + ID: existing.ID, + UserID: storeUserID, + Name: name, + AIModelID: aiModelID, + ExchangeID: exchangeID, + StrategyID: strategyID, + InitialBalance: existing.InitialBalance, + ScanIntervalMinutes: existing.ScanIntervalMinutes, + IsRunning: existing.IsRunning, + IsCrossMargin: existing.IsCrossMargin, + ShowInCompetition: existing.ShowInCompetition, + BTCETHLeverage: existing.BTCETHLeverage, + AltcoinLeverage: existing.AltcoinLeverage, + TradingSymbols: existing.TradingSymbols, + UseAI500: existing.UseAI500, + UseOITop: existing.UseOITop, + CustomPrompt: existing.CustomPrompt, + OverrideBasePrompt: existing.OverrideBasePrompt, + SystemPromptTemplate: existing.SystemPromptTemplate, + } + if args.InitialBalance != nil && *args.InitialBalance > 0 { + record.InitialBalance = *args.InitialBalance + } + if args.ScanIntervalMinutes != nil && *args.ScanIntervalMinutes > 0 { + record.ScanIntervalMinutes = *args.ScanIntervalMinutes + if record.ScanIntervalMinutes < 3 { + record.ScanIntervalMinutes = 3 + } + } + if args.IsCrossMargin != nil { + record.IsCrossMargin = *args.IsCrossMargin + } + if args.ShowInCompetition != nil { + record.ShowInCompetition = *args.ShowInCompetition + } + if args.BTCETHLeverage != nil && *args.BTCETHLeverage > 0 { + record.BTCETHLeverage = *args.BTCETHLeverage + } + if args.AltcoinLeverage != nil && *args.AltcoinLeverage > 0 { + record.AltcoinLeverage = *args.AltcoinLeverage + } + if trimmed := strings.TrimSpace(args.TradingSymbols); trimmed != "" { + record.TradingSymbols = trimmed + } + if trimmed := strings.TrimSpace(args.CustomPrompt); trimmed != "" { + record.CustomPrompt = trimmed + } + if args.OverrideBasePrompt != nil { + record.OverrideBasePrompt = *args.OverrideBasePrompt + } + if trimmed := strings.TrimSpace(args.SystemPromptTemplate); trimmed != "" { + record.SystemPromptTemplate = trimmed + } + if args.UseAI500 != nil { + record.UseAI500 = *args.UseAI500 + } + if args.UseOITop != nil { + record.UseOITop = *args.UseOITop + } + if err := a.store.Trader().Update(record); err != nil { + return fmt.Sprintf(`{"error":"failed to update trader: %s"}`, err) + } + if a.traderManager != nil { + a.traderManager.RemoveTrader(record.ID) + _ = a.traderManager.LoadUserTradersFromStore(a.store, storeUserID) + } + result, _ := json.Marshal(map[string]any{ + "status": "ok", + "action": "update", + "trader": safeTraderForTool(record, record.IsRunning), + }) + return string(result) +} + +func (a *Agent) toolDeleteTrader(storeUserID, traderID string) string { + if traderID == "" { + return `{"error":"trader_id is required for delete"}` + } + if err := a.store.Trader().Delete(storeUserID, traderID); err != nil { + return fmt.Sprintf(`{"error":"failed to delete trader: %s"}`, err) + } + if a.traderManager != nil { + if trader, err := a.traderManager.GetTrader(traderID); err == nil { + trader.Stop() + } + a.traderManager.RemoveTrader(traderID) + } + result, _ := json.Marshal(map[string]any{ + "status": "ok", + "action": "delete", + "trader_id": traderID, + }) + return string(result) +} + +func (a *Agent) toolStartTrader(storeUserID, traderID string) string { + if traderID == "" { + return `{"error":"trader_id is required for start"}` + } + if a.traderManager == nil { + return `{"error":"trader manager unavailable"}` + } + if _, err := a.store.Trader().GetFullConfig(storeUserID, traderID); err != nil { + return fmt.Sprintf(`{"error":"trader not found or inaccessible: %s"}`, err) + } + if existing, err := a.traderManager.GetTrader(traderID); err == nil { + if running, ok := existing.GetStatus()["is_running"].(bool); ok && running { + return `{"error":"trader is already running"}` + } + a.traderManager.RemoveTrader(traderID) + } + if err := a.traderManager.LoadUserTradersFromStore(a.store, storeUserID); err != nil { + return fmt.Sprintf(`{"error":"failed to load trader config: %s"}`, err) + } + trader, err := a.traderManager.GetTrader(traderID) + if err != nil { + if loadErr := a.traderManager.GetLoadError(traderID); loadErr != nil { + return fmt.Sprintf(`{"error":"failed to load trader: %s"}`, loadErr) + } + return fmt.Sprintf(`{"error":"failed to get trader: %s"}`, err) + } + safe.GoNamed("agent-trader-start-"+traderID, func() { + if runErr := trader.Run(); runErr != nil { + a.logger.Error("agent tool trader runtime error", "trader_id", traderID, "error", runErr) + } + }) + _ = a.store.Trader().UpdateStatus(storeUserID, traderID, true) + result, _ := json.Marshal(map[string]any{ + "status": "ok", + "action": "start", + "trader_id": traderID, + "message": "Trader started", + }) + return string(result) +} + +func (a *Agent) toolStopTrader(storeUserID, traderID string) string { + if traderID == "" { + return `{"error":"trader_id is required for stop"}` + } + if a.traderManager == nil { + return `{"error":"trader manager unavailable"}` + } + if _, err := a.store.Trader().GetFullConfig(storeUserID, traderID); err != nil { + return fmt.Sprintf(`{"error":"trader not found or inaccessible: %s"}`, err) + } + trader, err := a.traderManager.GetTrader(traderID) + if err != nil { + return fmt.Sprintf(`{"error":"trader not loaded: %s"}`, err) + } + if running, ok := trader.GetStatus()["is_running"].(bool); ok && !running { + return `{"error":"trader is already stopped"}` + } + trader.Stop() + _ = a.store.Trader().UpdateStatus(storeUserID, traderID, false) + result, _ := json.Marshal(map[string]any{ + "status": "ok", + "action": "stop", + "trader_id": traderID, + "message": "Trader stopped", + }) + return string(result) +} + +func (a *Agent) toolGetPreferences(userID int64) string { + prefs := a.getPersistentPreferences(userID) + result, _ := json.Marshal(map[string]any{ + "preferences": prefs, + "count": len(prefs), + }) + return string(result) +} + +func (a *Agent) toolManagePreferences(userID int64, argsJSON string) string { + var args struct { + Action string `json:"action"` + Text string `json:"text"` + Match string `json:"match"` + } + if err := json.Unmarshal([]byte(argsJSON), &args); err != nil { + return fmt.Sprintf(`{"error": "invalid arguments: %s"}`, err) + } + + switch args.Action { + case "add": + prefs, created, err := a.addPersistentPreference(userID, args.Text) + if err != nil { + return fmt.Sprintf(`{"error": "%s"}`, err) + } + result, _ := json.Marshal(map[string]any{ + "status": "ok", + "action": "add", + "preference": created, + "preferences": prefs, + }) + return string(result) + case "update": + prefs, updated, err := a.updatePersistentPreference(userID, args.Match, args.Text) + if err != nil { + return fmt.Sprintf(`{"error": "%s"}`, err) + } + result, _ := json.Marshal(map[string]any{ + "status": "ok", + "action": "update", + "preference": updated, + "preferences": prefs, + }) + return string(result) + case "delete": + prefs, removed, err := a.deletePersistentPreference(userID, args.Match) + if err != nil { + return fmt.Sprintf(`{"error": "%s"}`, err) + } + result, _ := json.Marshal(map[string]any{ + "status": "ok", + "action": "delete", + "preference": removed, + "preferences": prefs, + }) + return string(result) + default: + return `{"error": "invalid action"}` + } +} + +func (a *Agent) toolSearchStock(argsJSON string) string { + var args struct { + Keyword string `json:"keyword"` + } + if err := json.Unmarshal([]byte(argsJSON), &args); err != nil { + return fmt.Sprintf(`{"error": "invalid arguments: %s"}`, err) + } + + if args.Keyword == "" { + return `{"error": "keyword is required"}` + } + + results, err := searchStock(args.Keyword) + if err != nil { + return fmt.Sprintf(`{"error": "search failed: %s"}`, err) + } + + if len(results) == 0 { + return fmt.Sprintf(`{"results": [], "message": "no stocks found for '%s'"}`, args.Keyword) + } + + // Limit to top 10 results + if len(results) > 10 { + results = results[:10] + } + + // Also fetch real-time quotes for the top results (up to 3) + type enrichedResult struct { + Name string `json:"name"` + Code string `json:"code"` + Market string `json:"market"` + Quote *StockQuote `json:"quote,omitempty"` + } + + var enriched []enrichedResult + for i, r := range results { + er := enrichedResult{Name: r.Name, Code: r.Code, Market: r.Market} + if i < 3 { + q, qErr := fetchStockQuote(r.Code) + if qErr == nil && q.Price > 0 { + er.Quote = q + } + } + enriched = append(enriched, er) + } + + result, _ := json.Marshal(map[string]any{ + "keyword": args.Keyword, + "count": len(enriched), + "results": enriched, + }) + return string(result) +} + +func (a *Agent) toolExecuteTrade(_ context.Context, userID int64, lang, argsJSON string) string { + var args struct { + Action string `json:"action"` + Symbol string `json:"symbol"` + Quantity float64 `json:"quantity"` + Leverage int `json:"leverage"` + } + if err := json.Unmarshal([]byte(argsJSON), &args); err != nil { + return fmt.Sprintf(`{"error": "invalid arguments: %s"}`, err) + } + + // Normalize symbol + sym := strings.ToUpper(args.Symbol) + // Only append USDT for crypto symbols; stock tickers (e.g. AAPL, TSLA) stay as-is + if !isStockSymbol(sym) && !strings.HasSuffix(sym, "USDT") { + sym += "USDT" + } + + // Validate action + validActions := map[string]bool{ + "open_long": true, "open_short": true, + "close_long": true, "close_short": true, + } + if !validActions[args.Action] { + return fmt.Sprintf(`{"error": "invalid action: %s"}`, args.Action) + } + + // For open actions, quantity must be > 0 + if (args.Action == "open_long" || args.Action == "open_short") && args.Quantity <= 0 { + return `{"error": "quantity must be > 0 for opening positions"}` + } + + // For stock symbols, check market hours and warn if closed + var marketWarning string + if isStockSymbol(sym) && a.traderManager != nil { + for _, t := range a.traderManager.GetAllTraders() { + if t.GetExchange() == "alpaca" { + ut := t.GetUnderlyingTrader() + if ut == nil { + continue + } + type marketChecker interface { + IsMarketOpen() (bool, string, error) + } + if mc, ok := ut.(marketChecker); ok { + isOpen, status, err := mc.IsMarketOpen() + if err == nil && !isOpen { + marketWarning = fmt.Sprintf("⚠️ US market is currently %s. Order will be queued for next market open.", status) + } + } + break + } + } + } + + // Create pending trade — requires user confirmation + trade := &TradeAction{ + ID: fmt.Sprintf("trade_%d", time.Now().UnixNano()), + Action: args.Action, + Symbol: sym, + Quantity: args.Quantity, + Leverage: args.Leverage, + Status: "pending_confirmation", + CreatedAt: time.Now().Unix(), + } + + a.pending.Add(trade) + a.pending.CleanExpired() + + // Return confirmation info to LLM so it can present it to the user + resultMap := map[string]any{ + "status": "pending_confirmation", + "trade_id": trade.ID, + "action": trade.Action, + "symbol": trade.Symbol, + "quantity": trade.Quantity, + "leverage": trade.Leverage, + "message": fmt.Sprintf("Trade created. User must confirm with: 确认 %s (or: confirm %s)", trade.ID, trade.ID), + "expires": "5 minutes", + } + if marketWarning != "" { + resultMap["market_warning"] = marketWarning + } + result, _ := json.Marshal(resultMap) + return string(result) +} + +func (a *Agent) toolGetPositions() string { + if a.traderManager == nil { + return `{"error": "no trader manager configured"}` + } + + var positions []map[string]any + for id, t := range a.traderManager.GetAllTraders() { + pos, err := t.GetPositions() + if err != nil { + continue + } + for _, p := range pos { + size := toFloat(p["size"]) + if size == 0 { + continue + } + tid := id + if len(tid) > 8 { + tid = tid[:8] + } + positions = append(positions, map[string]any{ + "trader": tid, + "exchange": t.GetExchange(), + "symbol": p["symbol"], + "side": p["side"], + "size": size, + "entry_price": toFloat(p["entryPrice"]), + "mark_price": toFloat(p["markPrice"]), + "unrealized_pnl": toFloat(p["unrealizedPnl"]), + "leverage": p["leverage"], + }) + } + } + + if len(positions) == 0 { + return `{"positions": [], "message": "no open positions"}` + } + + result, _ := json.Marshal(map[string]any{"positions": positions}) + return string(result) +} + +func (a *Agent) toolGetBalance() string { + if a.traderManager == nil { + return `{"error": "no trader manager configured"}` + } + + var balances []map[string]any + for id, t := range a.traderManager.GetAllTraders() { + info, err := t.GetAccountInfo() + if err != nil { + continue + } + tid := id + if len(tid) > 8 { + tid = tid[:8] + } + balances = append(balances, map[string]any{ + "trader": tid, + "name": t.GetName(), + "exchange": t.GetExchange(), + "total_equity": toFloat(info["total_equity"]), + "available": toFloat(info["available_balance"]), + "used_margin": toFloat(info["used_margin"]), + }) + } + + result, _ := json.Marshal(map[string]any{"balances": balances}) + return string(result) +} + +func (a *Agent) toolGetMarketPrice(argsJSON string) string { + var args struct { + Symbol string `json:"symbol"` + } + if err := json.Unmarshal([]byte(argsJSON), &args); err != nil { + return fmt.Sprintf(`{"error": "invalid arguments: %s"}`, err) + } + + sym := strings.ToUpper(args.Symbol) + if !isStockSymbol(sym) && !strings.HasSuffix(sym, "USDT") { + sym += "USDT" + } + + if a.traderManager == nil { + return `{"error": "no trader manager configured"}` + } + + wantStock := isStockSymbol(sym) + for _, t := range a.traderManager.GetAllTraders() { + underlying := t.GetUnderlyingTrader() + if underlying == nil { + continue + } + // Route to correct exchange type (stock vs crypto) + isAlpaca := t.GetExchange() == "alpaca" + if wantStock && !isAlpaca { + continue + } + if !wantStock && isAlpaca { + continue + } + price, err := underlying.GetMarketPrice(sym) + if err == nil && price > 0 { + priceResult := map[string]any{ + "symbol": sym, + "price": price, + } + // For stocks, include market status + if wantStock && isAlpaca { + type marketChecker interface { + IsMarketOpen() (bool, string, error) + } + if mc, ok := underlying.(marketChecker); ok { + isOpen, status, mErr := mc.IsMarketOpen() + if mErr == nil { + priceResult["market_open"] = isOpen + priceResult["market_status"] = status + } + } + } + result, _ := json.Marshal(priceResult) + return string(result) + } + } + + return fmt.Sprintf(`{"error": "could not get price for %s"}`, sym) +} + +func (a *Agent) toolGetTradeHistory(argsJSON string) string { + if a.store == nil { + return `{"error": "store not available"}` + } + + var args struct { + Limit int `json:"limit"` + } + if argsJSON != "" { + _ = json.Unmarshal([]byte(argsJSON), &args) + } + if args.Limit <= 0 { + args.Limit = 10 + } + if args.Limit > 50 { + args.Limit = 50 + } + + if a.traderManager == nil { + return `{"error": "no trader manager configured"}` + } + + var trades []map[string]any + var totalPnL float64 + var wins, losses int + + for id, t := range a.traderManager.GetAllTraders() { + positions, err := a.store.Position().GetClosedPositions(id, args.Limit) + if err != nil { + continue + } + tid := id + if len(tid) > 8 { + tid = tid[:8] + } + for _, pos := range positions { + pnl := pos.RealizedPnL + totalPnL += pnl + if pnl >= 0 { + wins++ + } else { + losses++ + } + + entryTime := "" + if pos.EntryTime > 0 { + entryTime = time.Unix(pos.EntryTime/1000, 0).Format("2006-01-02 15:04") + } + exitTime := "" + if pos.ExitTime > 0 { + exitTime = time.Unix(pos.ExitTime/1000, 0).Format("2006-01-02 15:04") + } + + trades = append(trades, map[string]any{ + "trader": t.GetName(), + "trader_id": tid, + "symbol": pos.Symbol, + "side": pos.Side, + "entry_price": pos.EntryPrice, + "exit_price": pos.ExitPrice, + "quantity": pos.Quantity, + "leverage": pos.Leverage, + "pnl": pnl, + "entry_time": entryTime, + "exit_time": exitTime, + }) + } + } + + if len(trades) == 0 { + return `{"trades": [], "message": "no closed trades found"}` + } + + // Sort trades by exit time (most recent first) for consistent ordering across traders + sort.Slice(trades, func(i, j int) bool { + ti, _ := trades[i]["exit_time"].(string) + tj, _ := trades[j]["exit_time"].(string) + return ti > tj // reverse chronological + }) + + // Only return up to the limit + if len(trades) > args.Limit { + trades = trades[:args.Limit] + } + + winRate := 0.0 + total := wins + losses + if total > 0 { + winRate = float64(wins) / float64(total) * 100 + } + + result, _ := json.Marshal(map[string]any{ + "trades": trades, + "summary": map[string]any{ + "total_trades": total, + "wins": wins, + "losses": losses, + "win_rate": fmt.Sprintf("%.1f%%", winRate), + "total_pnl": totalPnL, + }, + }) + return string(result) +} + +func (a *Agent) toolGetCandidateCoins(storeUserID string, userID int64, argsJSON string) string { + if a.store == nil { + return `{"error":"store unavailable"}` + } + + var args struct { + TraderID string `json:"trader_id"` + StrategyID string `json:"strategy_id"` + } + if strings.TrimSpace(argsJSON) != "" { + if err := json.Unmarshal([]byte(argsJSON), &args); err != nil { + return fmt.Sprintf(`{"error":"invalid arguments: %s"}`, err) + } + } + + traderID := strings.TrimSpace(args.TraderID) + strategyID := strings.TrimSpace(args.StrategyID) + state := a.getExecutionState(userID) + if traderID == "" && state.CurrentReferences != nil && state.CurrentReferences.Trader != nil { + traderID = strings.TrimSpace(state.CurrentReferences.Trader.ID) + } + if strategyID == "" && state.CurrentReferences != nil && state.CurrentReferences.Strategy != nil { + strategyID = strings.TrimSpace(state.CurrentReferences.Strategy.ID) + } + + if traderID != "" { + return a.toolGetCandidateCoinsForTrader(storeUserID, traderID) + } + if strategyID != "" { + return a.toolGetCandidateCoinsForStrategy(storeUserID, strategyID) + } + return `{"error":"trader_id or strategy_id is required"}` +} + +func (a *Agent) toolGetCandidateCoinsForTrader(storeUserID, traderID string) string { + if a.traderManager == nil { + return `{"error":"no trader manager configured"}` + } + record, err := a.store.Trader().GetFullConfig(storeUserID, traderID) + if err != nil { + return fmt.Sprintf(`{"error":"failed to load trader: %s"}`, err) + } + memTrader, err := a.traderManager.GetTrader(traderID) + if err != nil { + return fmt.Sprintf(`{"error":"trader is not loaded in memory: %s"}`, err) + } + + coins, coinErr := memTrader.GetCandidateCoins() + cfg := memTrader.GetStrategyConfig() + status := memTrader.GetStatus() + isRunning, _ := status["is_running"].(bool) + payload := map[string]any{ + "trader": safeTraderForTool(record.Trader, isRunning), + "coin_source": candidateCoinSourceSummary(cfg), + "candidate_count": len(coins), + "candidate_symbols": candidateCoinSymbols(coins), + "candidates": candidateCoinDetails(coins), + } + if coinErr != nil { + payload["error"] = coinErr.Error() + } + result, _ := json.Marshal(payload) + return string(result) +} + +func (a *Agent) toolGetCandidateCoinsForStrategy(storeUserID, strategyID string) string { + record, err := a.store.Strategy().Get(storeUserID, strategyID) + if err != nil { + return fmt.Sprintf(`{"error":"failed to load strategy: %s"}`, err) + } + cfg, err := record.ParseConfig() + if err != nil { + return fmt.Sprintf(`{"error":"failed to parse strategy config: %s"}`, err) + } + + engine := kernel.NewStrategyEngine(cfg) + coins, coinErr := engine.GetCandidateCoins() + payload := map[string]any{ + "strategy": safeStrategyForTool(record), + "coin_source": candidateCoinSourceSummary(cfg), + "candidate_count": len(coins), + "candidate_symbols": candidateCoinSymbols(coins), + "candidates": candidateCoinDetails(coins), + } + if coinErr != nil { + payload["error"] = coinErr.Error() + } + result, _ := json.Marshal(payload) + return string(result) +} + +func candidateCoinSourceSummary(cfg *store.StrategyConfig) map[string]any { + if cfg == nil { + return nil + } + return map[string]any{ + "source_type": cfg.CoinSource.SourceType, + "use_ai500": cfg.CoinSource.UseAI500, + "ai500_limit": cfg.CoinSource.AI500Limit, + "use_oi_top": cfg.CoinSource.UseOITop, + "oi_top_limit": cfg.CoinSource.OITopLimit, + "use_oi_low": cfg.CoinSource.UseOILow, + "oi_low_limit": cfg.CoinSource.OILowLimit, + "use_hyper_all": cfg.CoinSource.UseHyperAll, + "use_hyper_main": cfg.CoinSource.UseHyperMain, + "hyper_main_limit": cfg.CoinSource.HyperMainLimit, + "static_coins": cfg.CoinSource.StaticCoins, + "excluded_coins": cfg.CoinSource.ExcludedCoins, + } +} + +func candidateCoinSymbols(coins []kernel.CandidateCoin) []string { + out := make([]string, 0, len(coins)) + for _, coin := range coins { + out = append(out, coin.Symbol) + } + return out +} + +func candidateCoinDetails(coins []kernel.CandidateCoin) []map[string]any { + out := make([]map[string]any, 0, len(coins)) + for _, coin := range coins { + out = append(out, map[string]any{ + "symbol": coin.Symbol, + "sources": coin.Sources, + }) + } + return out +} + +// knownCryptoSymbols is a set of well-known cryptocurrency base symbols. +// Without this, isStockSymbol("BTC") would incorrectly return true because +// "BTC" is 3 uppercase letters and the suffix check only catches "BTCUSDT"-style pairs. +var knownCryptoSymbols = map[string]bool{ + "BTC": true, "ETH": true, "SOL": true, "BNB": true, "XRP": true, + "DOGE": true, "ADA": true, "AVAX": true, "DOT": true, "LINK": true, + "PEPE": true, "SHIB": true, "ARB": true, "OP": true, "SUI": true, + "APT": true, "SEI": true, "TIA": true, "JUP": true, "WIF": true, + "NEAR": true, "ATOM": true, "FTM": true, "MATIC": true, "INJ": true, + "RENDER": true, "FET": true, "TAO": true, "WLD": true, "USDT": true, + "USDC": true, "BUSD": true, "DAI": true, "UNI": true, "AAVE": true, + "LDO": true, "MKR": true, "CRV": true, "PENDLE": true, "ENA": true, + "ONDO": true, "TRUMP": true, "TON": true, "TRX": true, "LTC": true, + "BCH": true, "ETC": true, "FIL": true, "ICP": true, "HBAR": true, + "VET": true, "ALGO": true, "SAND": true, "MANA": true, "AXS": true, + "GMT": true, "APE": true, "GALA": true, "IMX": true, "BLUR": true, + "STRK": true, "ZK": true, "W": true, "IO": true, "ZRO": true, + "BONK": true, "FLOKI": true, "ORDI": true, "STX": true, "RUNE": true, +} + +// isStockSymbol heuristically determines if a symbol is a stock ticker (not crypto). +// Stock tickers are 1-5 uppercase letters without numeric suffixes like "USDT". +// Known crypto base symbols (BTC, ETH, SOL etc.) are excluded. +func isStockSymbol(sym string) bool { + sym = strings.ToUpper(sym) + + // Check known crypto base symbols first (critical: "BTC", "ETH" etc. are NOT stocks) + if knownCryptoSymbols[sym] { + return false + } + + // If it already has a crypto quote suffix, it's crypto + cryptoSuffixes := []string{"USDT", "BUSD", "USDC", "BTC", "ETH", "BNB"} + for _, suffix := range cryptoSuffixes { + if strings.HasSuffix(sym, suffix) && len(sym) > len(suffix) { + return false + } + } + // Pure uppercase letters, 1-5 chars = likely a stock ticker + if len(sym) >= 1 && len(sym) <= 5 { + allLetters := true + for _, c := range sym { + if c < 'A' || c > 'Z' { + allLetters = false + break + } + } + if allLetters { + return true + } + } + return false +} diff --git a/agent/tools_test.go b/agent/tools_test.go new file mode 100644 index 00000000..d7ea4918 --- /dev/null +++ b/agent/tools_test.go @@ -0,0 +1,65 @@ +package agent + +import "testing" + +func TestIsStockSymbol(t *testing.T) { + tests := []struct { + sym string + want bool + }{ + // Known crypto base symbols — must NOT be detected as stock + {"BTC", false}, + {"ETH", false}, + {"SOL", false}, + {"BNB", false}, + {"XRP", false}, + {"DOGE", false}, + {"ADA", false}, + {"AVAX", false}, + {"DOT", false}, + {"LINK", false}, + {"PEPE", false}, + {"SHIB", false}, + {"TRUMP", false}, + {"USDT", false}, + {"USDC", false}, + {"W", false}, // single letter crypto + + // Crypto pairs — must NOT be stock + {"BTCUSDT", false}, + {"ETHUSDT", false}, + {"SOLUSDT", false}, + {"DOGEUSDT", false}, + + // Real stock tickers — must be detected as stock + {"AAPL", true}, + {"TSLA", true}, + {"NVDA", true}, + {"MSFT", true}, + {"GOOGL", true}, + {"AMZN", true}, + {"META", true}, + {"AMD", true}, + {"PLTR", true}, + {"BA", true}, + {"F", true}, // Ford — 1 letter + {"GM", true}, // 2 letters + {"JPM", true}, // 3 letters + + // Mixed / edge cases + {"btc", false}, // lowercase crypto + {"aapl", true}, // lowercase stock (uppercased internally) + {"BTC123", false}, // not pure letters + {"123456", false}, // digits + {"", false}, + } + + for _, tt := range tests { + t.Run(tt.sym, func(t *testing.T) { + got := isStockSymbol(tt.sym) + if got != tt.want { + t.Errorf("isStockSymbol(%q) = %v, want %v", tt.sym, got, tt.want) + } + }) + } +} diff --git a/agent/trade.go b/agent/trade.go new file mode 100644 index 00000000..6a987a7d --- /dev/null +++ b/agent/trade.go @@ -0,0 +1,342 @@ +package agent + +import ( + "context" + "encoding/json" + "fmt" + "log/slog" + "strings" + "sync" + "time" +) + +// TradeAction represents a parsed trade intent from the LLM or user. +type TradeAction struct { + ID string `json:"id"` + Action string `json:"action"` // "open_long", "open_short", "close_long", "close_short" + Symbol string `json:"symbol"` // e.g. "BTCUSDT" + Quantity float64 `json:"quantity"` // amount + Leverage int `json:"leverage"` // leverage multiplier + TraderID string `json:"trader_id"` // which trader to use + Status string `json:"status"` // "pending", "confirmed", "executed", "failed", "expired" + CreatedAt int64 `json:"created_at"` + Error string `json:"error,omitempty"` +} + +// pendingTrades stores pending trade confirmations. +type pendingTrades struct { + mu sync.RWMutex + trades map[string]*TradeAction // id -> trade +} + +func newPendingTrades() *pendingTrades { + return &pendingTrades{trades: make(map[string]*TradeAction)} +} + +func (p *pendingTrades) Add(t *TradeAction) { + p.mu.Lock() + defer p.mu.Unlock() + p.trades[t.ID] = t +} + +func (p *pendingTrades) Get(id string) *TradeAction { + p.mu.RLock() + defer p.mu.RUnlock() + return p.trades[id] +} + +func (p *pendingTrades) Remove(id string) { + p.mu.Lock() + defer p.mu.Unlock() + delete(p.trades, id) +} + +// CleanExpired removes trades older than 5 minutes. +func (p *pendingTrades) CleanExpired() { + p.mu.Lock() + defer p.mu.Unlock() + cutoff := time.Now().Add(-5 * time.Minute).Unix() + for id, t := range p.trades { + if t.CreatedAt < cutoff { + delete(p.trades, id) + } + } +} + +// parseTradeCommand parses natural language trade commands. +// Returns nil if the message is not a trade command. +func parseTradeCommand(text string) *TradeAction { + upper := strings.ToUpper(strings.TrimSpace(text)) + + // Pattern: "做多 BTC 0.01" / "做空 ETH 0.1" / "long BTC 0.01" / "short ETH 0.1" + // Also: "平多 BTC" / "平空 ETH" / "close long BTC" / "close short ETH" + + var action, symbol string + var quantity float64 + var leverage int + + words := strings.Fields(upper) + if len(words) < 2 { + return nil + } + + switch words[0] { + case "做多", "LONG", "BUY": + action = "open_long" + case "做空", "SHORT", "SELL": + action = "open_short" + case "平多": + action = "close_long" + case "平空": + action = "close_short" + case "CLOSE": + if len(words) >= 3 { + switch words[1] { + case "LONG": + action = "close_long" + words = append(words[:1], words[2:]...) // remove "LONG" + case "SHORT": + action = "close_short" + words = append(words[:1], words[2:]...) // remove "SHORT" + } + } + if action == "" { + return nil + } + default: + return nil + } + + // Parse symbol + if len(words) < 2 { + return nil + } + symbol = words[1] + // Only append USDT for crypto symbols, not stock tickers + if !isStockSymbol(symbol) && !strings.HasSuffix(symbol, "USDT") { + symbol += "USDT" + } + + // Parse quantity (optional) + if len(words) >= 3 { + fmt.Sscanf(words[2], "%f", &quantity) + } + + // Parse leverage (optional, "x10" or "10x") + if len(words) >= 4 { + lev := strings.TrimSuffix(strings.TrimPrefix(words[3], "X"), "X") + fmt.Sscanf(lev, "%d", &leverage) + } + + if action == "" || symbol == "" { + return nil + } + + return &TradeAction{ + ID: fmt.Sprintf("trade_%d", time.Now().UnixNano()), + Action: action, + Symbol: symbol, + Quantity: quantity, + Leverage: leverage, + Status: "pending", + CreatedAt: time.Now().Unix(), + } +} + +// executeTrade performs the actual trade execution via TraderManager. +func (a *Agent) executeTrade(ctx context.Context, trade *TradeAction) error { + if a.traderManager == nil { + return fmt.Errorf("no trader manager available") + } + + traders := a.traderManager.GetAllTraders() + if len(traders) == 0 { + return fmt.Errorf("no traders configured") + } + + // Determine if this is a stock trade to route to the right exchange + wantStock := isStockSymbol(trade.Symbol) + + // Find a running trader's underlying exchange interface + var underlyingTrader interface { + OpenLong(symbol string, quantity float64, leverage int) (map[string]interface{}, error) + OpenShort(symbol string, quantity float64, leverage int) (map[string]interface{}, error) + CloseLong(symbol string, quantity float64) (map[string]interface{}, error) + CloseShort(symbol string, quantity float64) (map[string]interface{}, error) + } + + for _, t := range traders { + s := t.GetStatus() + running, _ := s["is_running"].(bool) + if running { + ut := t.GetUnderlyingTrader() + if ut == nil { + continue + } + // Route stock symbols to alpaca traders, crypto to others + exchange := t.GetExchange() + isAlpaca := exchange == "alpaca" + if wantStock && !isAlpaca { + continue // Skip non-stock traders for stock symbols + } + if !wantStock && isAlpaca { + continue // Skip stock traders for crypto symbols + } + underlyingTrader = ut + break + } + } + + if underlyingTrader == nil { + if wantStock { + return fmt.Errorf("no running stock trader (Alpaca) found — configure one to trade stocks") + } + return fmt.Errorf("no running trader supports trade execution") + } + + switch trade.Action { + case "open_long": + if trade.Quantity <= 0 { + return fmt.Errorf("quantity must be > 0") + } + _, err := underlyingTrader.OpenLong(trade.Symbol, trade.Quantity, trade.Leverage) + return err + case "open_short": + if trade.Quantity <= 0 { + return fmt.Errorf("quantity must be > 0") + } + _, err := underlyingTrader.OpenShort(trade.Symbol, trade.Quantity, trade.Leverage) + return err + case "close_long": + _, err := underlyingTrader.CloseLong(trade.Symbol, trade.Quantity) + return err + case "close_short": + _, err := underlyingTrader.CloseShort(trade.Symbol, trade.Quantity) + return err + default: + return fmt.Errorf("unknown action: %s", trade.Action) + } +} + +// formatTradeConfirmation creates a confirmation message for a pending trade. +func formatTradeConfirmation(trade *TradeAction, lang string) string { + actionNames := map[string]string{ + "open_long": "做多 (Long)", + "open_short": "做空 (Short)", + "close_long": "平多 (Close Long)", + "close_short": "平空 (Close Short)", + } + + symbol := trade.Symbol + if strings.HasSuffix(symbol, "USDT") { + symbol = strings.TrimSuffix(symbol, "USDT") + } + actionName := actionNames[trade.Action] + if actionName == "" { + actionName = trade.Action + } + + if lang == "zh" { + msg := fmt.Sprintf("⚠️ **交易确认**\n\n"+ + "操作: %s\n"+ + "品种: %s\n", actionName, symbol) + if trade.Quantity > 0 { + msg += fmt.Sprintf("数量: %.4f\n", trade.Quantity) + } + if trade.Leverage > 0 { + msg += fmt.Sprintf("杠杆: %dx\n", trade.Leverage) + } + msg += fmt.Sprintf("\n发送 `确认 %s` 执行交易，或忽略取消。", trade.ID) + return msg + } + + msg := fmt.Sprintf("⚠️ **Trade Confirmation**\n\n"+ + "Action: %s\n"+ + "Symbol: %s\n", actionName, symbol) + if trade.Quantity > 0 { + msg += fmt.Sprintf("Quantity: %.4f\n", trade.Quantity) + } + if trade.Leverage > 0 { + msg += fmt.Sprintf("Leverage: %dx\n", trade.Leverage) + } + msg += fmt.Sprintf("\nSend `confirm %s` to execute, or ignore to cancel.", trade.ID) + return msg +} + +// handleTradeConfirmation processes a trade confirmation message. +func (a *Agent) handleTradeConfirmation(ctx context.Context, userID int64, text, lang string) (string, bool) { + upper := strings.ToUpper(strings.TrimSpace(text)) + + var tradeID string + if strings.HasPrefix(upper, "确认 ") || strings.HasPrefix(upper, "CONFIRM ") { + parts := strings.Fields(text) + if len(parts) >= 2 { + tradeID = parts[1] + } + } + + if tradeID == "" { + return "", false + } + + if a.pending == nil { + return "", false + } + + trade := a.pending.Get(tradeID) + if trade == nil { + if lang == "zh" { + return "❌ 交易已过期或不存在。", true + } + return "❌ Trade expired or not found.", true + } + + a.pending.Remove(tradeID) + trade.Status = "confirmed" + + a.logger.Info("executing trade", + slog.String("id", trade.ID), + slog.String("action", trade.Action), + slog.String("symbol", trade.Symbol), + slog.Float64("quantity", trade.Quantity), + ) + + err := a.executeTrade(ctx, trade) + if err != nil { + trade.Status = "failed" + trade.Error = err.Error() + if lang == "zh" { + return fmt.Sprintf("❌ 交易执行失败: %s", err.Error()), true + } + return fmt.Sprintf("❌ Trade execution failed: %s", err.Error()), true + } + + trade.Status = "executed" + symbol := trade.Symbol + if strings.HasSuffix(symbol, "USDT") { + symbol = strings.TrimSuffix(symbol, "USDT") + } + actionEmoji := "📈" + if strings.Contains(trade.Action, "short") { + actionEmoji = "📉" + } + if strings.Contains(trade.Action, "close") { + actionEmoji = "✅" + } + + qtyStr := "" + if trade.Quantity > 0 { + qtyStr = fmt.Sprintf(" %.4f", trade.Quantity) + } + + if lang == "zh" { + return fmt.Sprintf("%s 交易已执行！\n%s %s%s", actionEmoji, trade.Action, symbol, qtyStr), true + } + return fmt.Sprintf("%s Trade executed!\n%s %s%s", actionEmoji, trade.Action, symbol, qtyStr), true +} + +// marshals trade action to JSON for embedding in responses +func marshalTradeAction(trade *TradeAction) string { + b, _ := json.Marshal(trade) + return string(b) +} diff --git a/agent/web.go b/agent/web.go new file mode 100644 index 00000000..12865d84 --- /dev/null +++ b/agent/web.go @@ -0,0 +1,343 @@ +package agent + +import ( + "context" + "encoding/json" + "fmt" + "io" + "log/slog" + "net/http" + "nofx/safe" + "regexp" + "time" +) + +type storeUserIDContextKey struct{} + +// WithStoreUserID annotates an HTTP request context with the authenticated store user ID. +func WithStoreUserID(ctx context.Context, storeUserID string) context.Context { + return context.WithValue(ctx, storeUserIDContextKey{}, storeUserID) +} + +func storeUserIDFromContext(ctx context.Context) string { + if v, ok := ctx.Value(storeUserIDContextKey{}).(string); ok && v != "" { + return v + } + return "default" +} + +// validSymbolRe matches only alphanumeric trading symbols (e.g. BTCUSDT, ETH-USD). +var validSymbolRe = regexp.MustCompile(`^[A-Za-z0-9\-_]{1,20}$`) + +// validIntervalRe matches only valid kline intervals (e.g. 1m, 5m, 1h, 4h, 1d, 1w). +var validIntervalRe = regexp.MustCompile(`^[0-9]{1,2}[mhHdDwWM]$`) + +// binanceClient is a shared HTTP client for proxying Binance API requests. +// Reused across requests to benefit from connection pooling. +var binanceClient = &http.Client{ + Timeout: 10 * time.Second, + Transport: &http.Transport{ + MaxIdleConns: 20, + MaxIdleConnsPerHost: 10, + IdleConnTimeout: 90 * time.Second, + }, +} + +// WebHandler provides HTTP endpoints for the NOFXi agent. +type WebHandler struct { + agent *Agent + logger *slog.Logger +} + +func NewWebHandler(agent *Agent, logger *slog.Logger) *WebHandler { + return &WebHandler{agent: agent, logger: logger} +} + +// HandleHealth handles GET /api/agent/health. +func (w *WebHandler) HandleHealth(rw http.ResponseWriter, r *http.Request) { + writeJSON(rw, 200, map[string]string{"status": "ok", "agent": "NOFXi", "time": time.Now().Format(time.RFC3339)}) +} + +// HandleChat handles POST /api/agent/chat. +func (w *WebHandler) HandleChat(rw http.ResponseWriter, r *http.Request) { + if r.Method != http.MethodPost { + http.Error(rw, "method not allowed", 405) + return + } + var req struct { + Message string `json:"message"` + UserID int64 `json:"user_id"` + UserKey string `json:"user_key"` + Lang string `json:"lang"` + } + // Limit request body to 64KB to prevent abuse + if err := json.NewDecoder(io.LimitReader(r.Body, 64*1024)).Decode(&req); err != nil { + writeJSON(rw, 400, map[string]string{"error": "invalid request"}) + return + } + if req.Message == "" { + writeJSON(rw, 400, map[string]string{"error": "message required"}) + return + } + if req.UserID == 0 { + req.UserID = SessionUserIDFromKey(req.UserKey) + } + msg := req.Message + if req.Lang != "" { + msg = "[lang:" + req.Lang + "] " + msg + } + + ctx, cancel := context.WithTimeout(r.Context(), 55*time.Second) + defer cancel() + + resp, err := w.agent.HandleMessageForStoreUser(ctx, storeUserIDFromContext(r.Context()), req.UserID, msg) + if err != nil { + w.logger.Error("agent HandleMessage failed", "error", err, "user_id", req.UserID) + writeJSON(rw, 500, map[string]string{"error": "Failed to process message. Please try again."}) + return + } + writeJSON(rw, 200, map[string]string{"response": resp}) +} + +// HandleChatStream handles POST /api/agent/chat/stream — SSE streaming chat. +// Sends server-sent events with types including planning, plan, step_start, +// step_complete, replan, tool, delta, done, error. +func (w *WebHandler) HandleChatStream(rw http.ResponseWriter, r *http.Request) { + if r.Method != http.MethodPost { + http.Error(rw, "method not allowed", 405) + return + } + var req struct { + Message string `json:"message"` + UserID int64 `json:"user_id"` + UserKey string `json:"user_key"` + Lang string `json:"lang"` + } + if err := json.NewDecoder(io.LimitReader(r.Body, 64*1024)).Decode(&req); err != nil { + writeJSON(rw, 400, map[string]string{"error": "invalid request"}) + return + } + if req.Message == "" { + writeJSON(rw, 400, map[string]string{"error": "message required"}) + return + } + if req.UserID == 0 { + req.UserID = SessionUserIDFromKey(req.UserKey) + } + msg := req.Message + if req.Lang != "" { + msg = "[lang:" + req.Lang + "] " + msg + } + + // Set SSE headers + rw.Header().Set("Content-Type", "text/event-stream") + rw.Header().Set("Cache-Control", "no-cache") + rw.Header().Set("Connection", "keep-alive") + rw.Header().Set("X-Accel-Buffering", "no") // Disable nginx buffering + rw.WriteHeader(200) + + flusher, ok := rw.(http.Flusher) + if !ok { + writeSSE(rw, nil, "error", "streaming not supported") + return + } + + ctx, cancel := context.WithTimeout(r.Context(), 120*time.Second) + defer cancel() + + resp, err := w.agent.HandleMessageStreamForStoreUser(ctx, storeUserIDFromContext(r.Context()), req.UserID, msg, func(event, data string) { + writeSSE(rw, flusher, event, data) + }) + if err != nil { + w.logger.Error("agent HandleMessageStream failed", "error", err, "user_id", req.UserID) + writeSSE(rw, flusher, "error", "Failed to process message. Please try again.") + return + } + // Send final done event with complete response + writeSSE(rw, flusher, "done", resp) +} + +// writeSSE writes a single SSE event. +func writeSSE(w http.ResponseWriter, flusher http.Flusher, event, data string) { + fmt.Fprintf(w, "event: %s\ndata: %s\n\n", event, sseEscape(data)) + if flusher != nil { + flusher.Flush() + } +} + +// sseEscape escapes newlines in SSE data (each line needs a "data: " prefix). +func sseEscape(s string) string { + // SSE spec: multi-line data uses multiple "data:" lines + // But we use JSON encoding to avoid this complexity + b, _ := json.Marshal(s) + return string(b) +} + +// HandleKlines proxies kline data from Binance. +func (w *WebHandler) HandleKlines(rw http.ResponseWriter, r *http.Request) { + symbol := r.URL.Query().Get("symbol") + if symbol == "" { + symbol = "BTCUSDT" + } + interval := r.URL.Query().Get("interval") + if interval == "" { + interval = "1h" + } + + if !validSymbolRe.MatchString(symbol) { + writeJSON(rw, 400, map[string]string{"error": "invalid symbol"}) + return + } + if !validIntervalRe.MatchString(interval) { + writeJSON(rw, 400, map[string]string{"error": "invalid interval"}) + return + } + + proxyBinance(rw, r.Context(), fmt.Sprintf("https://fapi.binance.com/fapi/v1/klines?symbol=%s&interval=%s&limit=300", symbol, interval)) +} + +// HandleTicker proxies ticker data from Binance. +func (w *WebHandler) HandleTicker(rw http.ResponseWriter, r *http.Request) { + symbol := r.URL.Query().Get("symbol") + if symbol == "" { + symbol = "BTCUSDT" + } + + if !validSymbolRe.MatchString(symbol) { + writeJSON(rw, 400, map[string]string{"error": "invalid symbol"}) + return + } + + proxyBinance(rw, r.Context(), fmt.Sprintf("https://fapi.binance.com/fapi/v1/ticker/24hr?symbol=%s", symbol)) +} + +// HandleTickers handles GET /api/agent/tickers?symbols=BTCUSDT,ETHUSDT,SOLUSDT +// Batch endpoint: fetches multiple tickers concurrently, returns array. +func (w *WebHandler) HandleTickers(rw http.ResponseWriter, r *http.Request) { + symbolsParam := r.URL.Query().Get("symbols") + if symbolsParam == "" { + symbolsParam = "BTCUSDT,ETHUSDT,SOLUSDT" + } + + // Validate symbols + var symbols []string + for _, s := range splitComma(symbolsParam) { + if validSymbolRe.MatchString(s) { + symbols = append(symbols, s) + } + } + if len(symbols) == 0 { + writeJSON(rw, 400, map[string]string{"error": "no valid symbols"}) + return + } + if len(symbols) > 20 { + writeJSON(rw, 400, map[string]string{"error": "max 20 symbols"}) + return + } + + // Fetch all tickers concurrently with context propagation + ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second) + defer cancel() + + type result struct { + idx int + data json.RawMessage + } + results := make(chan result, len(symbols)) + for i, sym := range symbols { + idx, s := i, sym + safe.GoNamed("ticker-fetch-"+s, func() { + req, err := http.NewRequestWithContext(ctx, "GET", + fmt.Sprintf("https://fapi.binance.com/fapi/v1/ticker/24hr?symbol=%s", s), nil) + if err != nil { + results <- result{idx: idx} + return + } + resp, err := binanceClient.Do(req) + if err != nil { + results <- result{idx: idx} + return + } + defer resp.Body.Close() + if resp.StatusCode != 200 { + results <- result{idx: idx} + return + } + body, err := safe.ReadAllLimited(resp.Body, 16*1024) + if err != nil { + results <- result{idx: idx} + return + } + results <- result{idx: idx, data: body} + }) + } + + // Collect results in order + ordered := make([]json.RawMessage, len(symbols)) + for range symbols { + r := <-results + if r.data != nil { + ordered[r.idx] = r.data + } + } + + // Filter out nil entries and write response + out := make([]json.RawMessage, 0, len(ordered)) + for _, d := range ordered { + if d != nil { + out = append(out, d) + } + } + rw.Header().Set("Content-Type", "application/json") + json.NewEncoder(rw).Encode(out) +} + +// commaRe is pre-compiled for splitComma — avoids recompiling on every call. +var commaRe = regexp.MustCompile(`\s*,\s*`) + +// splitComma splits a comma-separated string, trims whitespace, skips empty. +func splitComma(s string) []string { + var parts []string + for _, p := range commaRe.Split(s, -1) { + if p != "" { + parts = append(parts, p) + } + } + return parts +} + +func proxyBinance(rw http.ResponseWriter, ctx context.Context, url string) { + req, err := http.NewRequestWithContext(ctx, "GET", url, nil) + if err != nil { + writeJSON(rw, 500, map[string]string{"error": "failed to create request"}) + return + } + resp, err := binanceClient.Do(req) + if err != nil { + // Distinguish client cancellation from upstream failures + if ctx.Err() != nil { + return // Client disconnected, no point writing response + } + writeJSON(rw, 502, map[string]string{"error": "upstream request failed"}) + return + } + defer resp.Body.Close() + + // Forward upstream error status codes instead of silently proxying bad data + if resp.StatusCode != http.StatusOK { + writeJSON(rw, 502, map[string]string{"error": fmt.Sprintf("upstream returned status %d", resp.StatusCode)}) + return + } + + rw.Header().Set("Content-Type", "application/json") + // CORS is handled by the gin middleware — no need to set it here + // Limit response body to 2MB to prevent memory exhaustion + io.Copy(rw, io.LimitReader(resp.Body, 2*1024*1024)) +} + +func writeJSON(w http.ResponseWriter, status int, v interface{}) { + w.Header().Set("Content-Type", "application/json") + // CORS is handled by the gin middleware — no need to set it here + w.WriteHeader(status) + json.NewEncoder(w).Encode(v) +} diff --git a/agent/workflow.go b/agent/workflow.go new file mode 100644 index 00000000..fa704c3f --- /dev/null +++ b/agent/workflow.go @@ -0,0 +1,521 @@ +package agent + +import ( + "context" + "encoding/json" + "fmt" + "strings" + "time" + + "nofx/mcp" +) + +const ( + workflowTaskPending = "pending" + workflowTaskRunning = "running" + workflowTaskCompleted = "completed" + workflowTaskFailed = "failed" +) + +type WorkflowTask struct { + ID string `json:"id,omitempty"` + Skill string `json:"skill,omitempty"` + Action string `json:"action,omitempty"` + Request string `json:"request,omitempty"` + DependsOn []string `json:"depends_on,omitempty"` + Status string `json:"status,omitempty"` + Error string `json:"error,omitempty"` +} + +type WorkflowSession struct { + UserID int64 `json:"user_id"` + OriginalRequest string `json:"original_request,omitempty"` + Tasks []WorkflowTask `json:"tasks,omitempty"` + UpdatedAt string `json:"updated_at,omitempty"` +} + +type workflowDecomposition struct { + Tasks []WorkflowTask `json:"tasks"` +} + +func workflowSessionConfigKey(userID int64) string { + return fmt.Sprintf("agent_workflow_session_%d", userID) +} + +func normalizeWorkflowSession(session WorkflowSession) WorkflowSession { + session.OriginalRequest = strings.TrimSpace(session.OriginalRequest) + normalized := make([]WorkflowTask, 0, len(session.Tasks)) + for i, task := range session.Tasks { + task.ID = strings.TrimSpace(task.ID) + if task.ID == "" { + task.ID = fmt.Sprintf("task_%d", i+1) + } + task.Skill = strings.TrimSpace(task.Skill) + task.Action = normalizeAtomicSkillAction(task.Skill, task.Action) + task.Request = strings.TrimSpace(task.Request) + task.DependsOn = cleanStringList(task.DependsOn) + task.Status = strings.TrimSpace(task.Status) + if task.Status == "" { + task.Status = workflowTaskPending + } + task.Error = strings.TrimSpace(task.Error) + if task.Skill == "" || task.Action == "" || task.Request == "" { + continue + } + normalized = append(normalized, task) + } + session.Tasks = normalized + if len(session.Tasks) == 0 { + return WorkflowSession{} + } + if session.UpdatedAt == "" { + session.UpdatedAt = time.Now().UTC().Format(time.RFC3339) + } + return session +} + +func (a *Agent) getWorkflowSession(userID int64) WorkflowSession { + if a.store == nil { + return WorkflowSession{} + } + raw, err := a.store.GetSystemConfig(workflowSessionConfigKey(userID)) + if err != nil || strings.TrimSpace(raw) == "" { + return WorkflowSession{} + } + var session WorkflowSession + if err := json.Unmarshal([]byte(raw), &session); err != nil { + return WorkflowSession{} + } + return normalizeWorkflowSession(session) +} + +func (a *Agent) saveWorkflowSession(userID int64, session WorkflowSession) { + if a.store == nil { + return + } + session = normalizeWorkflowSession(session) + if len(session.Tasks) == 0 { + _ = a.store.SetSystemConfig(workflowSessionConfigKey(userID), "") + return + } + session.UserID = userID + session.UpdatedAt = time.Now().UTC().Format(time.RFC3339) + data, err := json.Marshal(session) + if err != nil { + return + } + _ = a.store.SetSystemConfig(workflowSessionConfigKey(userID), string(data)) +} + +func (a *Agent) clearWorkflowSession(userID int64) { + if a.store == nil { + return + } + _ = a.store.SetSystemConfig(workflowSessionConfigKey(userID), "") +} + +func hasActiveWorkflowSession(session WorkflowSession) bool { + if len(session.Tasks) == 0 { + return false + } + for _, task := range session.Tasks { + if task.Status == workflowTaskPending || task.Status == workflowTaskRunning { + return true + } + } + return false +} + +func nextRunnableWorkflowTask(session WorkflowSession) (WorkflowTask, int, bool) { + for i, task := range session.Tasks { + if task.Status != workflowTaskPending && task.Status != workflowTaskRunning { + continue + } + depsReady := true + for _, dep := range task.DependsOn { + ok := false + for _, candidate := range session.Tasks { + if candidate.ID == dep && candidate.Status == workflowTaskCompleted { + ok = true + break + } + } + if !ok { + depsReady = false + break + } + } + if depsReady { + return task, i, true + } + } + return WorkflowTask{}, -1, false +} + +func supportedWorkflowSkill(skill, action string) bool { + skill = strings.TrimSpace(skill) + action = normalizeAtomicSkillAction(skill, action) + if skill == "" || action == "" { + return false + } + if _, ok := getSkillDAG(skill, action); ok { + return true + } + switch skill { + case "trader_management", "strategy_management", "model_management", "exchange_management": + switch action { + case "create", "query_list", "query_detail", "query_running", "activate": + return true + } + } + return false +} + +func (a *Agent) tryWorkflowIntent(ctx context.Context, storeUserID string, userID int64, lang, text string, onEvent func(event, data string)) (string, bool, error) { + if session := a.getWorkflowSession(userID); hasActiveWorkflowSession(session) { + return a.handleWorkflowSession(ctx, storeUserID, userID, lang, text, session, onEvent) + } + + decomposition, err := a.decomposeWorkflowIntent(ctx, userID, lang, text) + if err != nil || len(decomposition.Tasks) <= 1 { + return "", false, err + } + session := WorkflowSession{ + UserID: userID, + OriginalRequest: text, + Tasks: decomposition.Tasks, + } + a.saveWorkflowSession(userID, session) + return a.handleWorkflowSession(ctx, storeUserID, userID, lang, text, session, onEvent) +} + +func (a *Agent) handleWorkflowSession(ctx context.Context, storeUserID string, userID int64, lang, text string, session WorkflowSession, onEvent func(event, data string)) (string, bool, error) { + if isExplicitFlowAbort(text) { + a.clearSkillSession(userID) + a.clearWorkflowSession(userID) + if lang == "zh" { + return "已取消当前任务流。", true, nil + } + return "Cancelled the current workflow.", true, nil + } + + if activeSkill := a.getSkillSession(userID); strings.TrimSpace(activeSkill.Name) != "" { + answer, handled := a.tryHardSkill(ctx, storeUserID, userID, lang, text, onEvent) + if !handled { + return "", false, nil + } + session = a.getWorkflowSession(userID) + if hasActiveWorkflowSession(session) && strings.TrimSpace(a.getSkillSession(userID).Name) == "" { + session = markCurrentWorkflowTask(session, workflowTaskCompleted, "") + a.saveWorkflowSession(userID, session) + if final, done, err := a.maybeAdvanceWorkflow(ctx, storeUserID, userID, lang, session, onEvent); done || err != nil { + if final != "" && answer != "" { + return answer + "\n\n" + final, true, err + } + if answer != "" { + return answer, true, err + } + return final, true, err + } + } + return answer, true, nil + } + + return a.maybeAdvanceWorkflow(ctx, storeUserID, userID, lang, session, onEvent) +} + +func (a *Agent) maybeAdvanceWorkflow(ctx context.Context, storeUserID string, userID int64, lang string, session WorkflowSession, onEvent func(event, data string)) (string, bool, error) { + task, index, ok := nextRunnableWorkflowTask(session) + if !ok { + summary := a.generateWorkflowSummary(ctx, userID, lang, session) + a.clearWorkflowSession(userID) + if summary == "" { + if lang == "zh" { + summary = "已完成当前任务流。" + } else { + summary = "Completed the current workflow." + } + } + if onEvent != nil { + onEvent(StreamEventPlan, summary) + onEvent(StreamEventDelta, summary) + } + return summary, true, nil + } + + session.Tasks[index].Status = workflowTaskRunning + a.saveWorkflowSession(userID, session) + taskSession := skillSession{Name: task.Skill, Action: task.Action, Phase: "collecting"} + a.saveSkillSession(userID, taskSession) + + if onEvent != nil { + onEvent(StreamEventPlan, a.formatWorkflowStatus(lang, session)) + onEvent(StreamEventTool, "workflow:"+task.Skill+":"+task.Action) + } + + answer, handled := a.tryHardSkill(ctx, storeUserID, userID, lang, task.Request, onEvent) + if !handled { + session.Tasks[index].Status = workflowTaskFailed + session.Tasks[index].Error = "task_not_handled" + a.saveWorkflowSession(userID, session) + return "", false, nil + } + + if strings.TrimSpace(a.getSkillSession(userID).Name) == "" { + session = a.getWorkflowSession(userID) + session = markCurrentWorkflowTask(session, workflowTaskCompleted, "") + a.saveWorkflowSession(userID, session) + if more, ok, err := a.maybeAdvanceWorkflow(ctx, storeUserID, userID, lang, session, onEvent); ok || err != nil { + if answer != "" && more != "" { + return answer + "\n\n" + more, true, err + } + if answer != "" { + return answer, true, err + } + return more, true, err + } + } + return answer, true, nil +} + +func markCurrentWorkflowTask(session WorkflowSession, status, errMsg string) WorkflowSession { + for i := range session.Tasks { + if session.Tasks[i].Status == workflowTaskRunning { + session.Tasks[i].Status = status + session.Tasks[i].Error = strings.TrimSpace(errMsg) + return session + } + } + return session +} + +func (a *Agent) formatWorkflowStatus(lang string, session WorkflowSession) string { + parts := make([]string, 0, len(session.Tasks)) + for _, task := range session.Tasks { + label := task.Request + if label == "" { + label = task.Skill + ":" + task.Action + } + switch task.Status { + case workflowTaskCompleted: + label = "✓ " + label + case workflowTaskRunning: + label = "→ " + label + default: + label = "· " + label + } + parts = append(parts, label) + } + if lang == "zh" { + return "任务流：" + strings.Join(parts, " | ") + } + return "Workflow: " + strings.Join(parts, " | ") +} + +func (a *Agent) generateWorkflowSummary(ctx context.Context, userID int64, lang string, session WorkflowSession) string { + completed := make([]string, 0, len(session.Tasks)) + for _, task := range session.Tasks { + if task.Status == workflowTaskCompleted { + completed = append(completed, task.Request) + } + } + if len(completed) == 0 { + return "" + } + if a.aiClient == nil { + if lang == "zh" { + return "已完成这些任务：" + strings.Join(completed, "；") + } + return "Completed these tasks: " + strings.Join(completed, "; ") + } + stageCtx, cancel := withPlannerStageTimeout(ctx, directReplyTimeout) + defer cancel() + systemPrompt := `You are summarizing a finished workflow for NOFXi. +Return one short user-facing summary in the user's language. +Do not mention internal DAG, scheduler, or JSON.` + userPrompt := fmt.Sprintf("Language: %s\nOriginal request: %s\nCompleted tasks:\n- %s", lang, session.OriginalRequest, strings.Join(completed, "\n- ")) + raw, err := a.aiClient.CallWithRequest(&mcp.Request{ + Messages: []mcp.Message{ + mcp.NewSystemMessage(systemPrompt), + mcp.NewUserMessage(userPrompt), + }, + Ctx: stageCtx, + }) + if err != nil { + if lang == "zh" { + return "已完成这些任务：" + strings.Join(completed, "；") + } + return "Completed these tasks: " + strings.Join(completed, "; ") + } + return strings.TrimSpace(raw) +} + +func (a *Agent) decomposeWorkflowIntent(ctx context.Context, userID int64, lang, text string) (workflowDecomposition, error) { + if !looksLikeMultiTaskIntent(text) { + return workflowDecomposition{}, nil + } + if a.aiClient != nil { + if dec, err := a.decomposeWorkflowIntentWithLLM(ctx, userID, lang, text); err == nil && len(dec.Tasks) > 1 { + return dec, nil + } + } + return a.decomposeWorkflowIntentFallback(text), nil +} + +func looksLikeMultiTaskIntent(text string) bool { + lower := strings.ToLower(strings.TrimSpace(text)) + if lower == "" { + return false + } + connectors := []string{"，", ",", "然后", "再", "并且", "并", "同时", "and", "then"} + count := 0 + for _, c := range connectors { + if strings.Contains(lower, c) { + count++ + } + } + return count > 0 +} + +func (a *Agent) decomposeWorkflowIntentWithLLM(ctx context.Context, userID int64, lang, text string) (workflowDecomposition, error) { + stageCtx, cancel := withPlannerStageTimeout(ctx, directReplyTimeout) + defer cancel() + systemPrompt := `You decompose one NOFXi user request into a small task graph. +Return JSON only. No markdown. +Only use these skills: trader_management, strategy_management, model_management, exchange_management. +Only use one atomic action per task. +Each task must include: +- id +- skill +- action +- request +- depends_on (array, may be empty) +If the request is effectively a single task, return one task only.` + userPrompt := fmt.Sprintf("Language: %s\nUser request: %s", lang, text) + raw, err := a.aiClient.CallWithRequest(&mcp.Request{ + Messages: []mcp.Message{ + mcp.NewSystemMessage(systemPrompt), + mcp.NewUserMessage(userPrompt), + }, + Ctx: stageCtx, + }) + if err != nil { + return workflowDecomposition{}, err + } + return parseWorkflowDecomposition(raw) +} + +func parseWorkflowDecomposition(raw string) (workflowDecomposition, error) { + raw = strings.TrimSpace(raw) + raw = strings.TrimPrefix(raw, "```json") + raw = strings.TrimPrefix(raw, "```") + raw = strings.TrimSuffix(raw, "```") + raw = strings.TrimSpace(raw) + var out workflowDecomposition + if err := json.Unmarshal([]byte(raw), &out); err == nil { + out = normalizeWorkflowDecomposition(out) + return out, nil + } + start := strings.Index(raw, "{") + end := strings.LastIndex(raw, "}") + if start >= 0 && end > start { + if err := json.Unmarshal([]byte(raw[start:end+1]), &out); err == nil { + out = normalizeWorkflowDecomposition(out) + return out, nil + } + } + return workflowDecomposition{}, fmt.Errorf("invalid workflow json") +} + +func normalizeWorkflowDecomposition(out workflowDecomposition) workflowDecomposition { + normalized := make([]WorkflowTask, 0, len(out.Tasks)) + for i, task := range out.Tasks { + task.ID = strings.TrimSpace(task.ID) + if task.ID == "" { + task.ID = fmt.Sprintf("task_%d", i+1) + } + task.Skill = strings.TrimSpace(task.Skill) + task.Action = normalizeAtomicSkillAction(task.Skill, task.Action) + task.Request = strings.TrimSpace(task.Request) + task.DependsOn = cleanStringList(task.DependsOn) + if !supportedWorkflowSkill(task.Skill, task.Action) || task.Request == "" { + continue + } + task.Status = workflowTaskPending + normalized = append(normalized, task) + } + out.Tasks = normalized + return out +} + +func (a *Agent) decomposeWorkflowIntentFallback(text string) workflowDecomposition { + segments := splitWorkflowSegments(text) + tasks := make([]WorkflowTask, 0, len(segments)) + for i, segment := range segments { + task, ok := classifyWorkflowTask(segment) + if !ok { + continue + } + task.ID = fmt.Sprintf("task_%d", i+1) + task.Status = workflowTaskPending + if len(tasks) > 0 { + task.DependsOn = []string{tasks[len(tasks)-1].ID} + } + tasks = append(tasks, task) + } + return workflowDecomposition{Tasks: tasks} +} + +func splitWorkflowSegments(text string) []string { + parts := []string{strings.TrimSpace(text)} + separators := []string{"，", ",", "然后", "再", "并且", "同时", " and then ", " then ", " and "} + for _, sep := range separators { + next := make([]string, 0, len(parts)) + for _, part := range parts { + split := strings.Split(part, sep) + for _, candidate := range split { + candidate = strings.TrimSpace(candidate) + if candidate != "" { + next = append(next, candidate) + } + } + } + parts = next + } + return parts +} + +func classifyWorkflowTask(text string) (WorkflowTask, bool) { + segment := strings.TrimSpace(text) + if segment == "" { + return WorkflowTask{}, false + } + switch { + case detectCreateTraderSkill(segment): + return WorkflowTask{Skill: "trader_management", Action: "create", Request: segment}, true + case detectTraderManagementIntent(segment): + action := normalizeAtomicSkillAction("trader_management", detectManagementAction(segment, "trader")) + if supportedWorkflowSkill("trader_management", action) { + return WorkflowTask{Skill: "trader_management", Action: action, Request: segment}, true + } + case detectExchangeManagementIntent(segment): + action := normalizeAtomicSkillAction("exchange_management", detectManagementAction(segment, "exchange")) + if supportedWorkflowSkill("exchange_management", action) { + return WorkflowTask{Skill: "exchange_management", Action: action, Request: segment}, true + } + case detectModelManagementIntent(segment): + action := normalizeAtomicSkillAction("model_management", detectManagementAction(segment, "model")) + if supportedWorkflowSkill("model_management", action) { + return WorkflowTask{Skill: "model_management", Action: action, Request: segment}, true + } + case detectStrategyManagementIntent(segment): + action := normalizeAtomicSkillAction("strategy_management", detectManagementAction(segment, "strategy")) + if action == "" && wantsStrategyDetails(segment) { + action = "query_detail" + } + if supportedWorkflowSkill("strategy_management", action) { + return WorkflowTask{Skill: "strategy_management", Action: action, Request: segment}, true + } + } + return WorkflowTask{}, false +} diff --git a/agent/workflow_test.go b/agent/workflow_test.go new file mode 100644 index 00000000..bffed9bb --- /dev/null +++ b/agent/workflow_test.go @@ -0,0 +1,37 @@ +package agent + +import "testing" + +func TestSplitWorkflowSegments(t *testing.T) { + got := splitWorkflowSegments("把策略删了，再把交易所改名") + if len(got) != 2 { + t.Fatalf("expected 2 segments, got %d: %#v", len(got), got) + } +} + +func TestClassifyWorkflowTask(t *testing.T) { + task, ok := classifyWorkflowTask("把策略删了") + if !ok { + t.Fatal("expected task") + } + if task.Skill != "strategy_management" || task.Action != "delete" { + t.Fatalf("unexpected task: %+v", task) + } +} + +func TestFallbackWorkflowDecompositionBuildsTwoTasks(t *testing.T) { + a := &Agent{} + out := a.decomposeWorkflowIntentFallback("把策略删了，再把交易所改名") + if len(out.Tasks) != 2 { + t.Fatalf("expected 2 tasks, got %d", len(out.Tasks)) + } + if out.Tasks[0].Skill != "strategy_management" { + t.Fatalf("unexpected first task: %+v", out.Tasks[0]) + } + if out.Tasks[1].Skill != "exchange_management" { + t.Fatalf("unexpected second task: %+v", out.Tasks[1]) + } + if len(out.Tasks[1].DependsOn) != 1 || out.Tasks[1].DependsOn[0] != out.Tasks[0].ID { + t.Fatalf("expected dependency on first task, got %+v", out.Tasks[1].DependsOn) + } +} diff --git a/agents.md b/agents.md new file mode 100644 index 00000000..684def9f --- /dev/null +++ b/agents.md @@ -0,0 +1,922 @@ +# NOFXi 交易智能助手规范 + +## 使命 + +NOFXi 交易智能助手不是通用闲聊机器人，而是一个面向交易场景的操作与决策辅助助手。 + +它的核心目标是帮助用户更安全、更高效、更专业地完成以下事情： + +- 创建、启动、查询、编辑、删除 agent +- 管理交易所配置 +- 管理策略 +- 管理大模型配置 +- 排查配置问题与运行问题 +- 回答交易相关问题，并提供可执行的建议 + +助手的价值不在于“会聊天”，而在于： + +- 降低用户操作成本 +- 减少配置错误和误操作 +- 提高问题定位效率 +- 让交易过程更专业、更可靠 + +## 核心理念 + +本助手采用 `80% skill + 20% 动态规划` 的设计思路。 + +这意味着： + +- 大多数高频、已知、可标准化的需求，应由预定义 skill 处理 +- 不应让模型对已知流程重复思考 +- 动态规划只用于少数复杂、跨领域、未知或开放性任务 +- 能确定的事情就不要交给模型自由发挥 + +默认优先级如下： + +1. 优先匹配 skill +2. 如果用户仍在当前任务中，则继续当前 skill +3. 只有当没有合适 skill 时，才进入动态规划 + +## 设计原则 + +### 1. 以 Skill 为主，不以自由推理为主 + +对于高频任务和高风险任务，必须优先使用 skill，而不是通用 agent 自行规划。 + +尤其是以下场景： + +- 创建 agent +- 启动或停止 agent +- 新增或修改交易所配置 +- 新增或修改策略 +- 新增或修改模型配置 +- 常见报错排查 +- API 配置指导 + +这些任务都应有稳定、明确、可重复执行的处理路径。 + +### 2. 以用户任务为中心，不以内部对象或 API 为中心 + +skill 的拆分应该围绕“用户想完成什么任务”，而不是“系统里有哪些对象”或“有哪些接口”。 + +好的拆分方式： + +- 创建一个 agent +- 启动或停止一个 agent +- 排查交易所 API 连接失败 +- 指导用户配置某个模型的 API +- 解释某条报错并给出下一步 + +不好的拆分方式： + +- exchange skill +- strategy 对象 skill +- 通用 REST 调用 skill +- 纯接口包装型 skill + +用户关注的是任务结果，不是内部实现。 + +### 3. 多轮对话的目标是推进任务，不是维持聊天感 + +多轮对话的本质，不是“让助手显得更像人”，而是让任务从模糊走向完成。 + +每一轮都应围绕以下问题展开： + +- 当前正在处理什么任务 +- 当前任务已经确认了哪些信息 +- 还缺什么关键信息 +- 下一步最合理的推进动作是什么 + +### 4. 只追问必要信息 + +当任务可以继续推进时，不要提出宽泛、发散、无助于执行的问题。 + +助手只应追问： + +- 当前任务必需但缺失的字段 +- 影响结果的重要选择项 +- 涉及风险、删除、替换、启动、停止等动作时的确认信息 + +不要要求用户重复已经确认过的信息。 + +### 5. 尽量减少不必要的思考 + +对于已有稳定处理路径的任务，直接按既定流程执行，不进行自由规划。 + +不要把模型能力浪费在这些事情上： + +- 猜测标准流程 +- 重新设计高频任务执行顺序 +- 对常见配置问题进行开放式发散分析 +- 对结构化任务做不必要的“创造性理解” + +### 6. 高风险动作优先保证安全 + +任何可能造成损失、误操作、难以回滚或影响实盘的动作，都必须谨慎处理。 + +以下动作通常需要明确确认： + +- 删除 agent +- 删除交易所配置 +- 删除策略 +- 覆盖已有配置 +- 启动实盘 agent +- 停止正在运行的 agent +- 修改可能影响下单行为的关键参数 + +当用户意图不够明确时，宁可先确认，不要直接执行。 + +### 7. 回答要以可执行为目标 + +当用户提问、排障、求指导时，回答应优先提供清晰的下一步，而不是停留在抽象概念。 + +尽量围绕这三个问题组织回答： + +- 发生了什么 +- 为什么会这样 +- 现在该怎么做 + +## 任务分类 + +### 一、执行类任务 + +执行类任务是指目标明确、结果清晰、可以落到具体系统动作上的任务。 + +例如： + +- 创建 agent +- 编辑 agent +- 启动 agent +- 停止 agent +- 删除 agent +- 创建交易所配置 +- 修改交易所配置 +- 删除交易所配置 +- 创建策略 +- 编辑策略 +- 激活策略 +- 复制策略 +- 删除策略 +- 创建模型配置 +- 修改模型配置 +- 删除模型配置 + +这类任务应优先通过 skill 实现，避免自由规划。 + +### 二、诊断类任务 + +诊断类任务是指用户遇到了问题，需要助手帮助识别原因、缩小范围、给出修复步骤。 + +例如： + +- 某条报错是什么意思 +- 为什么模型 API 配置失败 +- 为什么交易所 API 连接不上 +- 为什么 agent 启动失败 +- 为什么策略没有执行 +- 为什么余额、仓位、收益统计不对 +- 为什么某个配置在前端能保存，但运行时报错 + +这类任务也应尽量 skill 化，形成稳定的排查路径，而不是每次从零分析。 + +### 三、指导类任务 + +指导类任务是指用户需要完成某项配置、接入、理解或选择，但不一定立刻触发系统动作。 + +例如： + +- 某个模型的 API key 去哪里申请 +- 某个模型的 base URL 和 model name 怎么填 +- 某个交易所 API key 怎么创建 +- 某个交易所权限应该怎么勾选 +- 某种策略适合什么市场环境 +- 某些交易指标怎么理解 + +这类任务应提供步骤化、实操型指导。 + +### 四、动态规划类任务 + +动态规划不是默认模式，而是兜底模式。 + +只有在以下情况下，才允许进入动态规划： + +- 用户请求跨越多个 skill +- 用户描述模糊，需要先探索再判断 +- 用户提出的是开放式交易问题 +- 用户的问题不属于已有 skill 覆盖范围 +- 需要组合查询、分析、判断和建议 + +动态规划可以存在，但必须受控，不能覆盖主路径。 + +## 多轮对话策略 + +### 一、优先延续当前任务 + +如果用户仍然在处理同一个任务，就继续当前任务，不要重新规划或重新路由。 + +例如： + +- 用户：帮我创建一个新的 BTC agent +- 助手：请提供交易所和模型配置 +- 用户：用我刚配的 DeepSeek + +这时应继续“创建 agent”这个任务，而不是重新理解成一个新的需求。 + +### 二、多轮对话以任务状态推进为核心 + +每个任务在多轮中都应该有明确状态，例如： + +- 已识别任务 +- 信息收集中 +- 等待用户确认 +- 执行中 +- 已完成 +- 执行失败，待修复 +- 已中断或已切换 + +助手应始终知道当前任务在哪个阶段，而不是每轮都从头开始解释世界。 + +### 三、只补齐缺失参数，不重复收集已有信息 + +如果一个 skill 已经定义了所需字段，那么多轮中的追问应只围绕缺失字段展开。 + +例如创建 agent 时，可能需要： + +- 名称 +- 交易所 +- 策略 +- 模型 +- 是否立即启动 + +如果其中三个字段已经确认，就不要重新追问这三个字段。 + +### 四、允许用户中途切换任务 + +如果用户明显改变了目标，助手应允许当前任务中断，并切换到新任务。 + +例如： + +- 当前任务：创建 agent +- 用户突然说：为什么我的交易所 API 报 invalid signature + +这时应切换到诊断类任务，而不是强行把用户拉回创建流程。 + +### 五、允许短暂插问，但尽量回到主任务 + +如果用户在当前任务中插入一个简短问题，助手可以先简要回答，再视情况回到主任务。 + +例如： + +- 用户正在创建策略 +- 中途问：逐仓和全仓有什么区别 + +助手可以先给简洁解释，再继续原任务。 + +### 六、对高风险动作单独确认 + +即使任务流程已经基本完成，只要最后一步属于高风险动作，也要在执行前单独确认。 + +例如： + +- 删除策略前确认 +- 启动实盘前确认 +- 覆盖已有配置前确认 + +## 记忆策略 + +### 一、记住对当前任务有用的信息 + +当前会话中，应保留以下内容： + +- 当前活跃任务 +- 已确认的参数 +- 用户明确表达过的选择 +- 仍然缺失的关键字段 +- 当前排障上下文 +- 最近一次确认结果 + +### 二、不把猜测当成记忆 + +以下内容不应被高强度依赖： + +- 助手自行推断但用户未确认的偏好 +- 早前对话中的过时信息 +- 与当前任务无关的旧上下文 +- 仅基于模糊表达做出的假设 + +如果有不确定性，应明确标注为“推测”或重新确认。 + +### 三、敏感信息只在必要范围内使用 + +对于 API key、密钥、凭证、账户等敏感信息： + +- 不要在回答中完整复述 +- 不要在无关任务中再次提起 +- 仅在当前任务确有需要时使用 +- 默认进行脱敏展示 + +## Skill 设计规范 + +每个 skill 都应服务于一个真实、完整、可交付的用户任务。 + +一个好的 skill 应当具备以下特点： + +- 范围足够聚焦，执行稳定 +- 范围又不能过小，能够完成完整任务 +- 输入要求清晰 +- 流程尽量确定 +- 成功和失败条件明确 +- 容易扩展和维护 + +每个 skill 至少应定义以下内容： + +- 处理的意图 +- 适用场景 +- 必填输入 +- 可选输入 +- 前置条件 +- 执行步骤 +- 缺少信息时如何追问 +- 哪些步骤需要确认 +- 成功后的输出格式 +- 常见失败情况 +- 对应的恢复建议 + +## 工具使用原则 + +工具只是 skill 或动态规划中的执行手段，不应成为助手行为设计的核心。 + +助手不应表现为： + +- 一个通用 API 调用器 +- 一个只会函数路由的壳 +- 一个对常规任务也反复规划的自治代理 + +默认顺序应为： + +1. 先判断是否有合适 skill +2. 在 skill 内部调用所需工具 +3. 如果没有 skill，再进入受限动态规划 +4. 最后才考虑通用探索式工具调用 + +## Skill 与 Tool 的分层原则 + +Skill 和 tool 不是同一层概念。 + +tool 是底层执行能力，skill 是面向用户任务的稳定流程。 + +默认架构应为： + +用户请求 -> 匹配 skill -> skill 内部调用 tool -> 返回结果 + +而不是： + +用户请求 -> 大模型直接在一堆底层 tool 中自由选择和规划 + +### 一、Skill 是面向任务的 + +skill 应围绕用户目标设计，例如： + +- 创建 agent +- 启动或停止 agent +- 配置交易所 API +- 诊断模型配置失败 +- 解释某类报错 + +skill 负责定义： + +- 要处理什么任务 +- 需要哪些输入 +- 缺信息时怎么追问 +- 执行顺序是什么 +- 哪些动作需要确认 +- 失败时怎么恢复 + +### 二、Tool 是面向执行的 + +tool 负责具体动作，不负责完整任务语义。 + +例如： + +- 读取当前模型配置 +- 保存交易所配置 +- 查询 trader 列表 +- 启动某个 trader +- 获取余额 +- 获取持仓 + +tool 更像“系统能力”或“执行接口”，而不是用户直接感知的工作单元。 + +### 三、优先把底层 tool 收敛到 skill 内部 + +在 skill-first 架构下，不应默认把大量底层 tool 直接暴露给大模型。 + +更合理的做法是： + +- 大模型优先决定使用哪个 skill +- skill 内部自己决定需要调用哪些 tool +- 用户不需要面对底层能力拆分 +- 模型也不需要在每次请求中重新拼装流程 + +### 四、可以直接暴露给大模型的，应当是高层 skill 化能力 + +如果某些能力需要以 function/tool 的形式提供给大模型，也应尽量保持高层抽象，而不是过度原子化。 + +较好的直接暴露方式： + +- `manage_trader` +- `manage_exchange_config` +- `manage_model_config` +- `manage_strategy` +- `diagnose_trader_start_failure` + +较差的直接暴露方式： + +- `get_model_list_then_find_enabled_one` +- `read_exchange_then_patch_field` +- `generic_api_request` +- 纯粹的 CRUD 原子碎片接口 + +也就是说，即使最终在技术实现上仍然使用 tool calling，这些 tool 也应该尽量表现为 skill，而不是裸露的底层零件。 + +### 五、只有在以下情况，才允许直接使用底层 tool + +- 当前请求没有匹配 skill +- 请求属于探索式、一次性、低频问题 +- 需要动态组合多个能力处理未知问题 +- 当前是在做诊断型探索，而不是执行标准流程 + +即使如此，也应优先限制范围，避免进入无边界的自由调用。 + +### 六、设计目标 + +引入 skill 的目的，不是让系统层次变复杂，而是让大模型少思考那些不需要思考的事情。 + +因此分层目标应是： + +- 高频任务由 skill 固化 +- 低层动作沉到 skill 内部 +- 大模型少接触原子化 tool +- 只有少数未知问题才进入动态规划 + +## 交易场景下的行为要求 + +交易助手必须让整体体验显得专业、谨慎、清晰。 + +这意味着： + +- 操作建议要结构化 +- 配置指导要准确 +- 风险提示要明确 +- 不确定性要说清楚 +- 不应伪装成对市场有绝对把握 + +当涉及交易建议时，应尽量区分： + +- 客观事实 +- 助手判断 +- 用户可执行的下一步 + +对于行情和策略分析，应优先给出条件化建议，而不是绝对判断。 + +例如应更倾向于： + +- 如果你是震荡思路，可以考虑…… +- 如果当前目标是降低回撤，优先检查…… +- 这个现象更像是配置问题，不一定是策略本身失效 + +而不是： + +- 这个市场一定会涨 +- 你应该马上开多 +- 这个策略就是最优解 + +## 默认处理流程 + +当用户发来请求时，助手默认按以下顺序处理： + +1. 先判断这是不是一个已知高频任务 +2. 如果是，直接进入对应 skill +3. 如果任务信息不完整，只追问继续执行所需的最少字段 +4. 如果属于诊断问题，先判断问题类型，再进入对应排查路径 +5. 如果属于开放式问题或跨 skill 问题，才进入动态规划 +6. 如果涉及高风险动作，在执行前单独确认 +7. 完成后给出简洁、明确、可执行的结果反馈 + +## 总结原则 + +本助手的核心不是“尽可能多地思考”，而是“在正确的地方思考”。 + +应当 skill 化的事情，就不要交给模型自由发挥。 +应当标准化的流程，就不要每次重新规划。 +应当确认的风险动作，就不要直接执行。 + +多轮对话的价值，在于持续推进任务、减少用户负担、提升交易操作质量。 + +## 当前落地状态 + +第一批诊断与配置类 skill 已开始沉淀，见： + +- `docs/agent-skills/diagnostic-skills.zh-CN.md` + +当前实现优先覆盖： + +- 模型 API 配置与诊断 +- 交易所 API 配置与诊断 +- trader 启动与运行诊断 +- 下单与仓位异常诊断 +- 策略与 prompt 生效问题诊断 + +## 当前能力分层建议 + +下面这部分用于指导后续 agent 重构：哪些现有能力适合继续保留给大模型，哪些应该下沉到 skill 内部，哪些应该弱化或移除。 + +### 一、建议保留为高层 skill 的能力 + +这些能力已经接近“用户任务”粒度，适合继续保留为高层入口。 + +- `manage_trader` +- `manage_exchange_config` +- `manage_model_config` +- `manage_strategy` +- `execute_trade` +- `get_positions` +- `get_balance` +- `get_trade_history` +- `search_stock` + +原因： + +- 用户会直接表达这类任务 +- 这些能力已经具备较完整的业务语义 +- 它们天然适合作为 skill 或 skill-like tool + +后续建议： + +- 保持这些能力对外稳定 +- 在其上继续补充确认规则、缺参追问规则和诊断分支 + +### 二、建议下沉到 skill 内部的能力 + +这些能力可以继续存在，但不应作为主要交互层暴露给大模型自由组合。 + +- 读取某个资源后再 patch 某个字段 +- 各类配置查询后再拼装参数 +- 针对单一字段的修改动作 +- 仅为执行中间步骤服务的查询动作 +- 各种“先查一下列表再让模型自己猜怎么用”的细碎能力 + +原因： + +- 这类能力更像流程零件 +- 一旦直接暴露给大模型，会导致每次都重新规划 +- 会让高频任务变得不稳定且冗长 + +原则上，这些动作应由 skill 内部封装完成，而不是让模型临场拼接。 + +### 三、建议弱化的能力形态 + +以下设计方向应尽量弱化： + +- 通用 `generic_api_request` +- 纯 CRUD 原子接口直接暴露给大模型 +- 没有任务语义的“万能工具” +- 需要模型自己理解完整调用顺序的碎片化接口 + +原因： + +- 这类能力过于底层 +- 会把流程控制权交还给模型 +- 与“80%% skill + 20%% 动态规划”的目标相冲突 + +### 四、建议新增的高层 skill 结构 + +后续不建议把高频管理操作拆成大量 `skill_create_xxx / skill_update_xxx` 形式。 + +更合理的方式是按“资源管理域”收敛为少量 management skill： + +- `trader_management` +- `exchange_management` +- `model_management` +- `strategy_management` + +这些 management skill 可以在内部继续复用现有： + +- `manage_trader` +- `manage_exchange_config` +- `manage_model_config` +- `manage_strategy` + +也就是说，现有高层管理工具可以作为 management skill 的执行底座，但不应继续承担全部对话策略。 + +#### management skill 的统一协议 + +每个 management skill 都应至少定义： + +- `action` +- `target_ref` +- `slots` +- `needs_confirmation` + +推荐结构如下： + +```json +{ + "skill": "exchange_management", + "action": "update", + "target_ref": { + "id": "optional", + "name": "主账户", + "alias": "optional" + }, + "slots": { + "passphrase": "xxx" + }, + "needs_confirmation": false +} +``` + +#### action 规则 + +不同 management skill 的 action 应集中定义，而不是散落在 prompt 中。 + +- `trader_management` + - `create` + - `update` + - `delete` + - `start` + - `stop` + - `query` +- `exchange_management` + - `create` + - `update` + - `delete` + - `query` +- `model_management` + - `create` + - `update` + - `delete` + - `query` +- `strategy_management` + - `create` + - `update` + - `delete` + - `activate` + - `duplicate` + - `query` + +#### reference 规则 + +management skill 不应要求用户总是提供精确 id，而应支持分层定位目标： + +1. 优先使用 `id` +2. 其次使用 `name` +3. 再其次使用 alias / 最近上下文引用 +4. 若命中多个对象，则要求用户明确选择 +5. 若未命中任何对象，则返回“未找到目标对象”，而不是猜测执行 + +#### slot 规则 + +每个 action 都应定义： + +- 必填 slots +- 可选 slots +- 自动推断规则 +- 缺失字段时的最小追问规则 + +例如： + +- `exchange_management.create` + - 必填：`exchange_type` + - 常见必填：`account_name`、凭证字段 +- `exchange_management.update` + - 必填：`target_ref` + - 其余只需要用户明确要改的字段 +- `trader_management.create` + - 必填：`name`、`exchange`、`model` + - 常见可选：`strategy`、`auto_start` + +#### confirmation 规则 + +management skill 内部必须按 action 级别区分风险，而不是统一处理。 + +- `delete` 默认必须确认 +- `start` / `stop` 视场景确认 +- `create` 通常可直接执行 +- `update` 若涉及关键配置变更，可要求确认 +- `query` 不需要确认 + +### 五、建议新增的诊断类 skill + +诊断类 skill 是交易助手体验差异化的关键。 + +建议优先固定以下能力： + +- `model_diagnosis` +- `exchange_diagnosis` +- `trader_diagnosis` +- `order_execution_diagnosis` +- `strategy_diagnosis` +- `balance_position_diagnosis` + +这些 skill 应优先基于： + +- 已有代码中的真实约束 +- 现有 troubleshooting 文档 +- 真实常见错误文案 +- 当前系统的实际运行逻辑 + +### 六、建议保留给动态规划的少数场景 + +以下场景仍然可以保留给 planner / ReAct： + +- 跨多个 skill 的复合任务 +- 用户目标表述模糊，需要先澄清再决定流程 +- 开放式交易问题 +- 一次性、低频、尚未固化的问题 +- 涉及诊断探索但还没有稳定 skill 的场景 + +动态规划应始终作为兜底层，而不是主路径。 + +### 七、最终目标分层 + +理想结构如下： + +1. 用户表达需求 +2. 系统先判断是否命中高频 skill +3. 若命中，则进入对应 skill 流程 +4. skill 内部调用现有管理类能力或查询能力 +5. 只有未命中 skill 时，才进入 planner + +长期目标不是“让 planner 更聪明”，而是“让 planner 更少出场”。 + +## `agent/tools.go` 重构清单 + +当前 `agent/tools.go` 中主要暴露了以下工具： + +- `get_preferences` +- `manage_preferences` +- `get_exchange_configs` +- `manage_exchange_config` +- `get_model_configs` +- `manage_model_config` +- `get_strategies` +- `manage_strategy` +- `manage_trader` +- `search_stock` +- `execute_trade` +- `get_positions` +- `get_balance` +- `get_market_price` +- `get_trade_history` + +下面给出按当前设计目标的建议分类。 + +### 一、建议继续保留为高层入口的工具 + +这些工具已经具备较完整的任务语义，短期内可以继续作为高层 skill-like tool 保留。 + +- `manage_exchange_config` +- `manage_model_config` +- `manage_strategy` +- `manage_trader` +- `execute_trade` + +原因： + +- 它们都对应明确的用户任务 +- 内部已经承载了一定业务语义 +- 后续可以直接继续向 skill 演进，而不是推倒重来 + +重构建议： + +- 保持接口稳定 +- 在 planner / prompt 层优先把它们当作 management skill 的执行底座使用 +- 后续逐步把对话语义前移到 `xxx_management` + +### 二、建议保留为“只读能力”但弱化对外存在感的工具 + +这些工具适合继续保留，但主要作为查询型能力存在，不应成为复杂任务的主流程控制中心。 + +- `get_exchange_configs` +- `get_model_configs` +- `get_strategies` +- `get_positions` +- `get_balance` +- `get_market_price` +- `get_trade_history` +- `search_stock` + +原因： + +- 它们更适合做信息补充和状态验证 +- 对诊断问题很有价值 +- 但不应该替代 task-level skill + +重构建议： + +- 继续保留 +- 主要用于： + - skill 内部验证 + - 诊断类 skill 查询当前状态 + - 明确的只读用户请求 +- 不要鼓励模型把它们当成“拼工作流”的基础零件反复组合 + +### 三、建议进一步收敛使用边界的工具 + +以下工具容易把模型带回到底层操作思维，应该明确边界。 + +- `get_preferences` +- `manage_preferences` + +原因： + +- 长期偏好记忆是辅助能力，不是交易任务主线 +- 如果让模型频繁自由改偏好，容易污染上下文 + +重构建议： + +- 仅在用户明确表达“记住/修改/删除长期偏好”时使用 +- 不要把偏好系统混进交易执行和排障主流程 + +### 四、建议前移为 management / diagnosis skill 的现有高层工具 + +下面这些现有高层工具虽然可用，但语义仍然过宽，建议后续逐步前移为 management / diagnosis skill。 + +#### 1. `manage_trader` + +建议逐步前移为： + +- `trader_management` +- `trader_diagnosis` + +原因： + +- 创建、修改、启动、停止、删除虽然动作不同，但属于同一资源管理域 +- 诊断路径和执行路径应分开 + +#### 2. `manage_exchange_config` + +建议逐步前移为： + +- `exchange_management` +- `exchange_diagnosis` + +原因： + +- CRUD / query 属于同一资源管理域 +- invalid signature / timestamp / IP 白名单问题需要单独诊断路径 + +#### 3. `manage_model_config` + +建议逐步前移为： + +- `model_management` +- `model_diagnosis` + +原因： + +- 模型对象管理应集中到一个 management skill +- provider 配置失败和运行失败应集中到 diagnosis skill + +#### 4. `manage_strategy` + +建议逐步前移为： + +- `strategy_management` +- `strategy_diagnosis` + +原因： + +- 策略模板管理和策略问题排查是两类不同任务 +- create / update / activate / duplicate / delete / query 可以统一在 management skill 内处理 + +### 五、当前最适合直接做成硬 skill 的第一批对象 + +如果后续开始从“prompt 约束”走向“真正 dispatcher + skill runner”，建议优先落以下几类： + +1. `create_trader` +2. `trader_management` +3. `exchange_management` +4. `model_management` +5. `exchange_diagnosis` +6. `model_diagnosis` +7. `trader_diagnosis` + +原因： + +- 这些最常见 +- 多轮价值最高 +- 失败成本高 +- 用户对稳定性的感知最强 + +### 六、最终目标 + +`agent/tools.go` 中的工具未来应逐步承担“skill 的执行底座”角色，而不是直接承担全部对话策略。 + +也就是说，长期理想状态是： + +- 文档层：按 skill 组织 +- 对话层：先匹配 skill +- 执行层：skill 内部复用现有 tool +- planner 层：只兜底少数复杂情况 diff --git a/api/agent_preferences.go b/api/agent_preferences.go new file mode 100644 index 00000000..1c188840 --- /dev/null +++ b/api/agent_preferences.go @@ -0,0 +1,106 @@ +package api + +import ( + "encoding/json" + "net/http" + "strings" + + "nofx/agent" + + "github.com/gin-gonic/gin" +) + +type agentPreferencePayload struct { + Text string `json:"text"` +} + +func (s *Server) handleGetAgentPreferences(c *gin.Context) { + uid := agent.SessionUserIDFromKey(c.GetString("user_id")) + raw, err := s.store.GetSystemConfig(agent.PreferencesConfigKey(uid)) + if err != nil || strings.TrimSpace(raw) == "" { + c.JSON(http.StatusOK, gin.H{"preferences": []agent.PersistentPreference{}}) + return + } + + var prefs []agent.PersistentPreference + if err := json.Unmarshal([]byte(raw), &prefs); err != nil { + c.JSON(http.StatusOK, gin.H{"preferences": []agent.PersistentPreference{}}) + return + } + + c.JSON(http.StatusOK, gin.H{"preferences": prefs}) +} + +func (s *Server) handleCreateAgentPreference(c *gin.Context) { + uid := agent.SessionUserIDFromKey(c.GetString("user_id")) + + var req agentPreferencePayload + if err := c.ShouldBindJSON(&req); err != nil || strings.TrimSpace(req.Text) == "" { + c.JSON(http.StatusBadRequest, gin.H{"error": "text required"}) + return + } + + created, err := agent.NewPersistentPreference(req.Text) + if err != nil { + c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) + return + } + + prefs := s.loadAgentPreferences(uid) + prefs = append([]agent.PersistentPreference{created}, prefs...) + if len(prefs) > 20 { + prefs = prefs[:20] + } + + if err := s.saveAgentPreferences(uid, prefs); err != nil { + c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to save preference"}) + return + } + + c.JSON(http.StatusOK, gin.H{"preferences": prefs}) +} + +func (s *Server) handleDeleteAgentPreference(c *gin.Context) { + uid := agent.SessionUserIDFromKey(c.GetString("user_id")) + id := strings.TrimSpace(c.Param("id")) + if id == "" { + c.JSON(http.StatusBadRequest, gin.H{"error": "id required"}) + return + } + + prefs := s.loadAgentPreferences(uid) + filtered := prefs[:0] + for _, pref := range prefs { + if pref.ID != id { + filtered = append(filtered, pref) + } + } + + if err := s.saveAgentPreferences(uid, filtered); err != nil { + c.JSON(http.StatusInternalServerError, gin.H{"error": "failed to delete preference"}) + return + } + + c.JSON(http.StatusOK, gin.H{"preferences": filtered}) +} + +func (s *Server) loadAgentPreferences(userID int64) []agent.PersistentPreference { + raw, err := s.store.GetSystemConfig(agent.PreferencesConfigKey(userID)) + if err != nil || strings.TrimSpace(raw) == "" { + return []agent.PersistentPreference{} + } + + var prefs []agent.PersistentPreference + if err := json.Unmarshal([]byte(raw), &prefs); err != nil { + return []agent.PersistentPreference{} + } + return prefs +} + +func (s *Server) saveAgentPreferences(userID int64, prefs []agent.PersistentPreference) error { + data, err := json.Marshal(prefs) + if err != nil { + return err + } + return s.store.SetSystemConfig(agent.PreferencesConfigKey(userID), string(data)) +} diff --git a/api/agent_routes.go b/api/agent_routes.go new file mode 100644 index 00000000..91d09a0c --- /dev/null +++ b/api/agent_routes.go @@ -0,0 +1,26 @@ +package api + +import ( + "nofx/agent" + + "github.com/gin-gonic/gin" +) + +// RegisterAgentHandler registers NOFXi agent API routes on the main router. +// Chat endpoint requires authentication; market data endpoints are public. +func (s *Server) RegisterAgentHandler(h *agent.WebHandler) { + // Chat requires auth — can trigger trades and access account data + s.router.POST("/api/agent/chat", s.authMiddleware(), func(c *gin.Context) { + req := c.Request.WithContext(agent.WithStoreUserID(c.Request.Context(), c.GetString("user_id"))) + h.HandleChat(c.Writer, req) + }) + s.router.POST("/api/agent/chat/stream", s.authMiddleware(), func(c *gin.Context) { + req := c.Request.WithContext(agent.WithStoreUserID(c.Request.Context(), c.GetString("user_id"))) + h.HandleChatStream(c.Writer, req) + }) + // Public endpoints — read-only market data + s.router.GET("/api/agent/health", gin.WrapF(h.HandleHealth)) + s.router.GET("/api/agent/klines", gin.WrapF(h.HandleKlines)) + s.router.GET("/api/agent/ticker", gin.WrapF(h.HandleTicker)) + s.router.GET("/api/agent/tickers", gin.WrapF(h.HandleTickers)) +} diff --git a/api/handler_ai_model.go b/api/handler_ai_model.go index cba3d01c..91178dde 100644 --- a/api/handler_ai_model.go +++ b/api/handler_ai_model.go @@ -30,6 +30,7 @@ type SafeModelConfig struct { Name string `json:"name"` Provider string `json:"provider"` Enabled bool `json:"enabled"` + HasAPIKey bool `json:"has_api_key"` CustomAPIURL string `json:"customApiUrl"` // Custom API URL (usually not sensitive) CustomModelName string `json:"customModelName"` // Custom model name (not sensitive) WalletAddress string `json:"walletAddress,omitempty"` @@ -60,14 +61,14 @@ func (s *Server) handleGetModelConfigs(c *gin.Context) { if len(models) == 0 { logger.Infof("⚠️ No AI models in database, returning defaults") defaultModels := []SafeModelConfig{ - {ID: "deepseek", Name: "DeepSeek AI", Provider: "deepseek", Enabled: false}, - {ID: "qwen", Name: "Qwen AI", Provider: "qwen", Enabled: false}, - {ID: "openai", Name: "OpenAI", Provider: "openai", Enabled: false}, - {ID: "claude", Name: "Claude AI", Provider: "claude", Enabled: false}, - {ID: "gemini", Name: "Gemini AI", Provider: "gemini", Enabled: false}, - {ID: "grok", Name: "Grok AI", Provider: "grok", Enabled: false}, - {ID: "kimi", Name: "Kimi AI", Provider: "kimi", Enabled: false}, - {ID: "minimax", Name: "MiniMax AI", Provider: "minimax", Enabled: false}, + {ID: "deepseek", Name: "DeepSeek AI", Provider: "deepseek", Enabled: false, HasAPIKey: false}, + {ID: "qwen", Name: "Qwen AI", Provider: "qwen", Enabled: false, HasAPIKey: false}, + {ID: "openai", Name: "OpenAI", Provider: "openai", Enabled: false, HasAPIKey: false}, + {ID: "claude", Name: "Claude AI", Provider: "claude", Enabled: false, HasAPIKey: false}, + {ID: "gemini", Name: "Gemini AI", Provider: "gemini", Enabled: false, HasAPIKey: false}, + {ID: "grok", Name: "Grok AI", Provider: "grok", Enabled: false, HasAPIKey: false}, + {ID: "kimi", Name: "Kimi AI", Provider: "kimi", Enabled: false, HasAPIKey: false}, + {ID: "minimax", Name: "MiniMax AI", Provider: "minimax", Enabled: false, HasAPIKey: false}, } c.JSON(http.StatusOK, defaultModels) return @@ -83,6 +84,7 @@ func (s *Server) handleGetModelConfigs(c *gin.Context) { Name: model.Name, Provider: model.Provider, Enabled: model.Enabled, + HasAPIKey: model.APIKey != "", CustomAPIURL: model.CustomAPIURL, CustomModelName: model.CustomModelName, } @@ -171,7 +173,8 @@ func (s *Server) handleUpdateModelConfigs(c *gin.Context) { if modelData.CustomAPIURL != "" { cleanURL := strings.TrimSuffix(modelData.CustomAPIURL, "#") if err := security.ValidateURL(cleanURL); err != nil { - c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("Invalid custom_api_url for model %s: %s", modelID, err.Error())}) + logger.Warnf("Invalid custom_api_url for model %s: %v", modelID, err) + c.JSON(http.StatusBadRequest, gin.H{"error": fmt.Sprintf("Invalid custom_api_url for model %s: URL must be a valid HTTPS endpoint", modelID)}) return } } @@ -214,11 +217,13 @@ func (s *Server) handleGetSupportedModels(c *gin.Context) { {"id": "qwen", "name": "Qwen", "provider": "qwen", "defaultModel": "qwen3-max"}, {"id": "openai", "name": "OpenAI", "provider": "openai", "defaultModel": "gpt-5.1"}, {"id": "claude", "name": "Claude", "provider": "claude", "defaultModel": "claude-opus-4-6"}, - {"id": "gemini", "name": "Google Gemini", "provider": "gemini", "defaultModel": "gemini-3.1-pro"}, + {"id": "gemini", "name": "Google Gemini", "provider": "gemini", "defaultModel": "gemini-3-pro-preview"}, {"id": "grok", "name": "Grok (xAI)", "provider": "grok", "defaultModel": "grok-3-latest"}, {"id": "kimi", "name": "Kimi (Moonshot)", "provider": "kimi", "defaultModel": "moonshot-v1-auto"}, - {"id": "minimax", "name": "MiniMax", "provider": "minimax", "defaultModel": "MiniMax-M2.7"}, - {"id": "claw402", "name": "Claw402 (Base USDC)", "provider": "claw402", "defaultModel": "glm-5"}, + {"id": "minimax", "name": "MiniMax", "provider": "minimax", "defaultModel": "MiniMax-M2.5"}, + {"id": "blockrun-base", "name": "BlockRun (Base Wallet)", "provider": "blockrun-base", "defaultModel": "auto"}, + {"id": "blockrun-sol", "name": "BlockRun (Solana Wallet)", "provider": "blockrun-sol", "defaultModel": "auto"}, + {"id": "claw402", "name": "Claw402 (Base USDC)", "provider": "claw402", "defaultModel": "deepseek"}, } c.JSON(http.StatusOK, supportedModels) diff --git a/api/server.go b/api/server.go index 0f6c4c3c..7d4bed95 100644 --- a/api/server.go +++ b/api/server.go @@ -127,6 +127,9 @@ func (s *Server) setupRoutes() { s.route(protected, "POST", "/logout", "Logout (blacklist token)", s.handleLogout) s.route(protected, "POST", "/onboarding/beginner", "Prepare beginner claw402 wallet and default model", s.handleBeginnerOnboarding) s.route(protected, "GET", "/onboarding/beginner/current", "Get current beginner claw402 wallet", s.handleCurrentBeginnerWallet) + s.route(protected, "GET", "/agent/preferences", "Get persistent agent preferences", s.handleGetAgentPreferences) + s.route(protected, "POST", "/agent/preferences", "Create persistent agent preference", s.handleCreateAgentPreference) + s.route(protected, "DELETE", "/agent/preferences/:id", "Delete persistent agent preference", s.handleDeleteAgentPreference) // User account management s.routeWithSchema(protected, "PUT", "/user/password", "Change current user password", diff --git a/docs/agent-skills/diagnostic-skills.zh-CN.md b/docs/agent-skills/diagnostic-skills.zh-CN.md new file mode 100644 index 00000000..96607e51 --- /dev/null +++ b/docs/agent-skills/diagnostic-skills.zh-CN.md @@ -0,0 +1,203 @@ +# NOFXi 诊断与配置 Skills（第一批） + +这份文档用于沉淀交易智能助手的第一批高频诊断与配置 skill。 + +目标不是让模型“更会想”，而是让它面对常见问题时，优先走稳定、可复用的排查路径。 + +## 设计原则 + +- 优先按 skill 回答，不要对高频问题重复自由规划 +- 先归类问题，再给出原因、检查项和修复建议 +- 能通过工具验证当前状态时，先查再下结论 +- 敏感信息只指导填写，不完整回显 +- 对结论不确定时，要明确标注为“更可能”或“优先怀疑” + +## skill_model_api_setup + +### 适用场景 + +- 用户问某个大模型的 API key 去哪里申请 +- 用户问 base URL 怎么填 +- 用户问 model name 怎么填 +- 用户问 OpenAI / Claude / Gemini / DeepSeek / Qwen / Kimi / Grok / MiniMax 怎么接入 + +### 处理策略 + +1. 先确认用户要配置哪个 provider +2. 告诉用户需要准备的最少字段： + - provider + - API key + - custom_api_url + - custom_model_name +3. 如果系统已有默认地址和默认模型名，优先给推荐值 +4. 回答按步骤组织，不要泛泛解释概念 + +### 已知实现事实 + +- 系统内置 provider 默认运行配置，见 `agent.resolveModelRuntimeConfig(...)` +- 常见 provider 已有默认 URL 和默认 model name + +## skill_model_config_diagnosis + +### 适用场景 + +- 模型保存成功但 agent 仍然不可用 +- 提示 AI unavailable +- 提示模型没启用 +- 提示 custom_api_url 不合法 +- 配置后 trader 不生效 + +### 优先排查 + +1. 是否存在已启用模型 +2. API key 是否为空 +3. custom_api_url 是否为合法 HTTPS 地址 +4. custom_model_name 是否为空或不匹配 +5. 当前 trader 是否绑定了这个模型 +6. 更新模型后是否已触发 trader reload + +### 已知实现事实 + +- 非 HTTPS 的 `custom_api_url` 会被后端拒绝，见 `api/handler_ai_model.go` +- 已启用模型如果缺少 API Key 或 URL，会导致 agent 无法就绪，见 `agent.ensureAIClientForStoreUser(...)` +- 更新模型配置后，系统会尝试移除并重载相关 trader，使新配置立即生效 + +### 输出格式 + +- 现象 +- 更可能原因 +- 先检查什么 +- 下一步怎么修复 + +## skill_exchange_api_setup + +### 适用场景 + +- 用户要新建交易所 API +- 用户不知道交易所需要哪些权限 +- 用户问 API key / secret / passphrase 分别填什么 + +### 通用处理策略 + +1. 先确认交易所类型 +2. 告知必须权限与禁止权限 +3. 告知是否需要额外字段 +4. 强调 IP 白名单与权限配置 +5. 引导用户回到系统内完成绑定 + +### 特殊规则 + +- OKX 除 API Key 和 Secret 外，还需要 passphrase +- Bybit 永续/合约交易需要合约权限 +- 不建议开启提现权限 + +### 参考文档 + +- `docs/getting-started/okx-api.md` +- `docs/getting-started/bybit-api.md` + +## skill_exchange_api_diagnosis + +### 适用场景 + +- `invalid signature` +- `timestamp` 错误 +- `IP not allowed` +- `permission denied` +- 交易所连接不上 + +### 优先排查 + +1. 系统时间是否同步 +2. API Key / Secret 是否正确 +3. 是否遗漏额外字段，如 OKX passphrase +4. IP 白名单是否包含当前服务器 +5. 是否启用了交易或合约权限 +6. 密钥是否过期或已重建 + +### 已知实现事实 + +- 时间不同步是 `invalid signature` / `timestamp` 的高频根因，见 `docs/guides/TROUBLESHOOTING.zh-CN.md` +- OKX 的 passphrase 缺失会导致签名相关问题，见 `docs/getting-started/okx-api.md` + +### 输出格式 + +- 报错现象 +- 最常见根因 +- 优先检查顺序 +- 修复步骤 + +## skill_trader_start_diagnosis + +### 适用场景 + +- trader 启动不了 +- trader 启动了但没开始交易 +- 页面显示已启动但一直没有动作 +- 用户怀疑 strategy / model / exchange 绑定有问题 + +### 优先排查 + +1. 是否有已启用的模型配置 +2. 是否有已启用的交易所配置 +3. trader 是否绑定了 exchange_id / strategy_id / ai_model_id +4. 交易所余额和权限是否满足下单条件 +5. AI 最近的决策到底是 wait、hold 还是下单失败 + +### 回答原则 + +- 要区分“没启动”“启动了但 AI 选择不交易”“尝试下单但失败”这三类 +- 不要把“没开仓”直接等同于“系统故障” + +## skill_order_execution_diagnosis + +### 适用场景 + +- 下单失败 +- 只开空不开户 / 只开单边 +- 杠杆报错 +- position side mismatch + +### 优先排查 + +1. 账户模式是否匹配，例如 Binance 是否为 Hedge Mode +2. 是否为子账户杠杆限制 +3. 合约权限是否开启 +4. 余额、保证金、可交易 symbol 是否满足条件 + +### 已知实现事实 + +- Binance 在 One-way Mode 下，可能出现 `position side mismatch` 或单边行为 +- 某些子账户杠杆上限较低，超过限制会直接失败 +- 这些问题在 `docs/guides/TROUBLESHOOTING.md` 已有明确说明 + +## skill_strategy_diagnosis + +### 适用场景 + +- 用户说策略没生效 +- 用户说 prompt 预览和实际不一致 +- 用户说修改策略后 trader 行为没有变化 + +### 优先排查 + +1. 当前编辑的是策略模板，还是 trader 的 custom prompt +2. 策略是否真的保存成功 +3. 是否需要重新读取当前配置做对比 +4. 用户说的“没生效”是指未保存、未绑定，还是运行结果与预期不一致 + +### 回答原则 + +- 先明确“对象”再排查：strategy template / trader / prompt override +- 如果能读取当前保存值，就不要凭印象判断 + +## 后续扩展方向 + +下一批可以继续补： + +- `skill_balance_and_position_diagnosis` +- `skill_market_data_diagnosis` +- `skill_prompt_generation_diagnosis` +- `skill_strategy_test_run_diagnosis` +- `skill_exchange_specific_setup_` +- `skill_model_provider_setup_` diff --git a/docs/architecture/AGENT_CURRENT_DESIGN.zh-CN.md b/docs/architecture/AGENT_CURRENT_DESIGN.zh-CN.md new file mode 100644 index 00000000..40f93977 --- /dev/null +++ b/docs/architecture/AGENT_CURRENT_DESIGN.zh-CN.md @@ -0,0 +1,613 @@ +# NOFXi Agent 当前设计说明 + +## 目的 + +本文描述当前 NOFXi Agent 的实际设计，而不是早期版本的理想设计。重点回答这些问题： + +- 用户消息从哪里进入 +- 什么请求会进入 planner +- 当前有哪些记忆层 +- planner 如何生成与执行 plan +- tool 现在是怎么设计的 +- 动态快照和当前引用分别解决什么问题 +- 为什么某些问题会出现“看起来有历史，但模型还是会追问” + +本文对应的主要实现文件： + +- `agent/agent.go` +- `agent/web.go` +- `api/agent_routes.go` +- `agent/planner_runtime.go` +- `agent/execution_state.go` +- `agent/memory.go` +- `agent/history.go` +- `agent/tools.go` + +## 一句话总览 + +当前 Agent 的运行模型可以概括为： + +1. 前端把消息发到 `/api/agent/chat/stream` +2. 后端把登录用户身份放进 context +3. Agent 除 `/clear` 和 `/status` 外，其他消息全部进入 planner +4. planner 结合多层记忆、动态快照和 tool schema 生成 plan +5. 执行 plan 中的 `tool / reason / ask_user / respond` +6. 在执行过程中持续更新执行态、短期原话、长期摘要和当前对象引用 + +## 请求入口 + +### 前端入口 + +前端 Agent 页面在： + +- `web/src/pages/AgentChatPage.tsx` + +当前聊天使用： + +- `POST /api/agent/chat/stream` + +请求体里会传： + +- `message` +- `lang` +- `user_key` + +### 后端路由入口 + +路由注册在： + +- `api/agent_routes.go` + +这里会： + +1. 经过 `authMiddleware` +2. 从登录态里取出 `user_id` +3. 通过 `agent.WithStoreUserID(...)` 写入 request context + +### Agent Web Handler + +真正的 HTTP handler 在： + +- `agent/web.go` + +主要入口： + +- `HandleChat(...)` +- `HandleChatStream(...)` + +再往下进入： + +- `HandleMessageForStoreUser(...)` +- `HandleMessageStreamForStoreUser(...)` + +## 最外层分流 + +当前外层分流已经被收口。 + +在 `agent/agent.go` 中，除了这两个命令之外，其他输入全部交给 planner： + +- `/clear` +- `/status` + +也就是说，现在这些都不再在外层直接处理： + +- setup flow +- trade confirmation +- direct trade regex +- 自然语言配置流程 +- 自然语言策略创建 + +这些都统一进入 planner。 + +这是当前设计里一个很重要的原则： + +- 外层分流越少，行为边界越清晰 +- 自然语言理解尽量统一交给 planner + tool + +## 当前的 5 层记忆 + +当前不是 3 层，也不是 4 层，而是 5 层： + +1. `chatHistory` +2. `TaskState` +3. `ExecutionState` +4. `CurrentReferences` +5. `Persistent Preferences` + +### 1. chatHistory + +定义位置： + +- `agent/history.go` + +作用： + +- 保存最近几轮用户 / assistant 原始消息 +- 给模型保留最近原话上下文 +- 为后续摘要成 `TaskState` 提供原始素材 + +特点： + +- 只保留短期原话 +- 内存态 +- `/clear` 时清空 + +适合存： + +- 最近几轮对话原文 +- 用户的最新措辞 +- 刚刚的自然语言上下文 + +不适合存： + +- 长期真相 +- 当前外部系统状态 +- 当前流程精确执行位置 + +### 2. TaskState + +定义位置： + +- `agent/memory.go` + +作用： + +- 保存跨轮次仍然有意义的高层摘要 +- 注入 planner / reasoning / final response + +持久化 key： + +- `agent_task_state_` + +字段： + +- `CurrentGoal` +- `ActiveFlow` +- `OpenLoops` +- `ImportantFacts` +- `LastDecision` +- `UpdatedAt` + +适合存： + +- 当前高层目标 +- 跨轮次仍然成立的未闭环事项 +- 关键事实 +- 最近一次重要决策及其原因 + +不适合存： + +- step 级待办 +- “下一步调用哪个 tool” +- 动态余额、持仓、配置存在性 +- 任何可以通过 tool 重新读取的实时状态 + +### 3. ExecutionState + +定义位置： + +- `agent/execution_state.go` + +作用： + +- 保存当前 plan 的执行态 +- 支持 `ask_user` 之后继续执行 +- 保存 plan、当前步骤、执行日志、等待状态等 + +持久化 key： + +- `agent_execution_state_` + +当前关键字段： + +- `SessionID` +- `Goal` +- `Status` +- `PlanID` +- `Steps` +- `CurrentStepID` +- `DynamicSnapshots` +- `ExecutionLog` +- `SummaryNotes` +- `Waiting` +- `CurrentReferences` +- `FinalAnswer` +- `LastError` + +### 4. CurrentReferences + +定义位置： + +- `agent/execution_state.go` + +作用： + +- 记录当前对话里“这个 / 那个 / 刚才那个”到底指的是谁 + +当前支持的引用对象： + +- `strategy` +- `trader` +- `model` +- `exchange` + +这是为了解决一种常见问题： + +- 用户明明前一轮刚说过“激进策略” +- 下一轮说“改一下这个策略” +- 如果没有结构化引用，模型虽然有聊天历史，也容易重新追问 + +`CurrentReferences` 不是系统状态快照，而是： + +- 当前对话焦点对象 +- 当前代词绑定对象 + +### 5. Persistent Preferences + +对应工具： + +- `get_preferences` +- `manage_preferences` + +作用： + +- 保存用户长期偏好 + +适合存： + +- 默认中文回复 +- 偏好激进风格 +- 更关注 BTC / ETH +- 不喜欢高频 +- 每天固定时间简报 + +它和 `TaskState` 的区别是： + +- `TaskState` 偏向当前任务摘要 +- `Persistent Preferences` 偏向长期用户画像 + +## DynamicSnapshots 是什么 + +`DynamicSnapshots` 是当前真实系统状态的快照。 + +它不是历史，也不是长期记忆，而是 planner 在规划前或执行中插入的“当前事实”。 + +当前会进入快照的典型信息包括： + +- 当前模型配置列表 +- 当前交易所配置列表 +- 当前策略列表 +- 当前 trader 列表 +- 当前余额 +- 当前持仓 +- 最近交易历史 + +作用： + +- 防止 planner 盲信旧结论 +- 避免“之前没配置，现在其实已经配好了却还说没有” +- 避免“之前余额是 A，现在拿旧 observation 继续回答” + +一句话： + +- `DynamicSnapshots` = 当前世界里真实有什么 + +## CurrentReferences 和 DynamicSnapshots 的区别 + +这两个容易混淆，但职责完全不同。 + +`DynamicSnapshots`： + +- 当前系统状态快照 +- 是候选集合 / 当前事实 +- 例如当前有两个策略：`激进`、`新策略` + +`CurrentReferences`： + +- 当前对话焦点对象 +- 是“这个”到底指谁 +- 例如用户现在说的“这个策略”就是 `激进` + +可以这样理解： + +- `DynamicSnapshots` 是地图 +- `CurrentReferences` 是你手指现在指着地图上的哪个点 + +## Planner 的输入 + +planner 主逻辑在： + +- `agent/planner_runtime.go` + +生成计划时，当前会把这些东西一起送给模型： + +- 当前用户请求 +- tool schema +- `Persistent Preferences` +- `TaskState` +- `ExecutionState` +- `Resume context` +- `Structured waiting state` +- `Observation context` + +其中 observation context 不是旧版单数组，而是分层后的： + +- `dynamic_snapshots` +- `execution_log` +- `summary_notes` + +## Plan 的结构 + +当前 planner 只允许这 4 类 step： + +- `tool` +- `reason` +- `ask_user` +- `respond` + +这意味着现在的 Agent 不是一个“自由发挥的回复器”，而是： + +- 先规划 +- 再执行步骤 +- 必要时重规划 + +## 步骤执行流程 + +`executePlan(...)` 的核心逻辑是： + +1. 找下一个 pending step +2. 标记 step 为 running +3. 执行对应类型 +4. 写回 `ExecutionState` +5. 必要时触发 replanning + +不同 step 类型行为如下： + +### tool + +- 调内部 tool +- 把结果写入 `ExecutionLog` +- 根据结果更新 `CurrentReferences` +- 必要时触发 replanner + +### reason + +- 发起一次短 reasoning 调用 +- 生成一段简短中间推理 +- 写入 `ExecutionLog` + +### ask_user + +- 进入 `waiting_user` +- 保存 `WaitingState` +- 把问题直接回给用户 + +### respond + +- 生成最终回答 +- 标记当前执行完成 + +## WaitingState 是什么 + +`WaitingState` 用来解决： + +- 用户回复 `是` +- 用户回复 `继续` +- 用户回复 `那个就行` + +这类短回复如果没有结构化等待状态，很容易丢上下文。 + +当前字段包括： + +- `Question` +- `Intent` +- `PendingFields` +- `ConfirmationTarget` +- `CreatedAt` + +它的作用是： + +- 告诉 planner 上一轮到底在等什么 +- 让这轮短回复更容易被理解成“对上一问的回答” + +## CurrentReferences 如何更新 + +当前是双路径更新： + +### 1. 用户消息命中对象名时更新 + +如果用户说： + +- `修改激进策略` +- `停止 lky` +- `用 DeepSeek` + +系统会去当前用户的策略 / trader / model / exchange 列表里尝试匹配名称或 ID。 + +匹配成功后，更新 `CurrentReferences`。 + +### 2. tool 成功返回对象时更新 + +比如： + +- `manage_strategy(create/update/activate)` +- `manage_trader(create/update)` +- `manage_model_config(update)` +- `manage_exchange_config(update)` + +只要 tool 返回了具体对象，系统就会把对应 ID / name 写回当前引用。 + +## Tool 设计 + +当前 tool 是“资源型 tool”设计，不是“页面动作型 tool”。 + +### 当前主要工具 + +配置资源： + +- `get_exchange_configs` +- `manage_exchange_config` +- `get_model_configs` +- `manage_model_config` + +策略资源： + +- `get_strategies` +- `manage_strategy` + +trader 资源： + +- `manage_trader` + +交易 / 查询资源： + +- `search_stock` +- `execute_trade` +- `get_positions` +- `get_balance` +- `get_market_price` +- `get_trade_history` + +### 为什么这么设计 + +优点： + +- tool schema 稳定 +- 行为边界清晰 +- planner 更容易学会 +- 资源增删改查统一 + +当前 `manage_strategy` 支持： + +- `list` +- `get_default_config` +- `create` +- `update` +- `delete` +- `activate` +- `duplicate` + +当前 `manage_trader` 支持： + +- `list` +- `create` +- `update` +- `delete` +- `start` +- `stop` + +## 为什么“创建策略”不该默认依赖交易所和模型 + +当前设计里，策略模板应该是独立资源： + +- `strategy` + +而运行态对象是： + +- `trader` + +更合理的边界是： + +- 创建策略模板：用 `manage_strategy` +- 把策略跑起来：用 `manage_trader` + +也就是说： + +- 策略不默认依赖交易所和模型 +- 只有当用户要求“运行 / 部署 / 创建 trader”时，才需要进一步关联 exchange / model / trader + +## 当前一个完整例子 + +用户输入： + +`帮我创建一个新的激进策略模板，名字就叫激进。创建完后，再把这个策略绑定到 trader lky。` + +当前大致流程： + +1. 前端请求 `/api/agent/chat/stream` +2. 后端注入 `store_user_id` +3. Agent 进入 planner +4. planner 刷新动态快照： + - 当前策略 + - 当前 trader +5. 生成 plan，例如： + - `get_strategies` + - `manage_strategy(create)` + - `manage_trader(update)` + - `respond` +6. 执行 `manage_strategy(create)` 后： + - 写入 `ExecutionLog` + - 更新 `CurrentReferences.strategy` +7. 执行 `manage_trader(update)` 时： + - 直接使用刚创建策略的 ID +8. 输出最终回复 + +如果此后用户继续说： + +`把这个策略的 prompt 改激进一点` + +系统会优先从 `CurrentReferences.strategy` 理解“这个策略”。 + +## 为什么看起来“有历史”，模型还是会追问 + +因为“有聊天历史”不等于“有结构化对象绑定”。 + +如果没有 `CurrentReferences`： + +- 模型只能依赖原话文本推断“这个策略”是谁 +- 一旦中间插入多条消息，或者有多个候选策略 +- 就容易重新追问 + +所以当前设计里，`CurrentReferences` 是补齐这一块的关键。 + +## 当前已知限制 + +### 1. 外层虽然已经大幅收口，但仍然不是纯 graph runtime + +现在比之前更统一，但整体仍然是： + +- Agent 主入口 +- Planner +- Tool 执行 + +而不是完整 node-graph 引擎。 + +### 2. ExecutionState 仍然是按 userID 单槽位 + +这意味着： + +- 同一用户的多个并行任务仍然可能相互影响 + +更彻底的方向应该是： + +- 按 thread / session 多实例存储 + +### 3. CurrentReferences 目前还是轻量实现 + +当前只覆盖： + +- strategy +- trader +- model +- exchange + +后面如果要更强，需要考虑： + +- 多候选冲突消解 +- 昵称映射 +- 跨更长会话的稳定实体绑定 + +## 当前设计的核心思想 + +一句话总结： + +- `chatHistory` 记原话 +- `Persistent Preferences` 记长期偏好 +- `TaskState` 记高层摘要 +- `ExecutionState` 记当前流程 +- `DynamicSnapshots` 记当前事实 +- `CurrentReferences` 记当前指代对象 +- `planner` 决定步骤 +- `tools` 执行落地动作 + +这就是当前 NOFXi Agent 的实际运行设计。 diff --git a/docs/architecture/AGENT_MEMORY_AND_PLANNING.md b/docs/architecture/AGENT_MEMORY_AND_PLANNING.md new file mode 100644 index 00000000..7179bb17 --- /dev/null +++ b/docs/architecture/AGENT_MEMORY_AND_PLANNING.md @@ -0,0 +1,454 @@ +# NOFXi Agent Memory And Planning Design + +## Purpose + +This document explains how the current NOFXi agent handles: + +- short-term conversation memory +- durable task memory +- durable execution / planning state +- planner execution and replanning +- state reset and resume behavior + +The implementation described here is primarily in: + +- `agent/history.go` +- `agent/memory.go` +- `agent/execution_state.go` +- `agent/planner_runtime.go` +- `agent/agent.go` + +## High-Level Model + +The current agent uses three different layers of state: + +1. `chatHistory` +Recent in-memory user/assistant turns for the live conversation. + +2. `TaskState` +Durable summarized context that should survive beyond recent turns. + +3. `ExecutionState` +Durable workflow state for the currently running or recently blocked plan. + +These three layers serve different purposes and should not be treated as the same thing. + +## State Layers + +### 1. `chatHistory` + +Defined in `agent/history.go`. + +Role: + +- stores recent `user` / `assistant` messages in memory +- keyed by `userID` +- used as short-term conversational context +- acts as the source material for later compression into `TaskState` + +Characteristics: + +- in-memory only +- capped by `maxTurns` +- cleared by `/clear` +- not suitable as durable truth + +Typical contents: + +- the last few user questions +- the last few assistant replies +- temporary conversational wording + +### 2. `TaskState` + +Defined in `agent/memory.go`. + +Role: + +- stores durable, structured, non-derivable context +- persisted through `system_config` +- injected into planning and reasoning prompts + +Storage key: + +- `agent_task_state_` + +Fields: + +- `CurrentGoal` +- `ActiveFlow` +- `OpenLoops` +- `ImportantFacts` +- `LastDecision` +- `UpdatedAt` + +Intended contents: + +- user goal that still matters across turns +- high-level unresolved issues that still matter across turns +- facts that tools cannot cheaply re-fetch +- latest important decision summary + +Explicitly not intended for: + +- step-level pending items such as "wait for API key" +- execution actions such as "call get_exchange_configs" +- live balances +- current positions +- current market prices +- mutable configuration availability + +Those should be checked from tools at planning time instead of being trusted from old summaries. + +### 3. `ExecutionState` + +Defined in `agent/execution_state.go`. + +Role: + +- stores the current execution workflow +- allows the agent to resume after `ask_user` +- persists plan steps, observations, and completion status + +Storage key: + +- `agent_execution_state_` + +Fields: + +- `SessionID` +- `UserID` +- `Goal` +- `Status` +- `PlanID` +- `Steps` +- `CurrentStepID` +- `Observations` +- `FinalAnswer` +- `LastError` +- `UpdatedAt` + +This is the planner's working state, not a general memory store. + +## Data Flow + +### Request Entry + +Entry points: + +- `HandleMessage(...)` +- `HandleMessageStream(...)` + +Flow: + +1. user message enters `agent` +2. slash commands and explicit direct branches are handled first +3. all other requests go into planner flow via `thinkAndAct(...)` / `thinkAndActStream(...)` + +### Planner Flow + +The planner pipeline in `agent/planner_runtime.go` is: + +1. append user message into `chatHistory` +2. emit `planning` SSE event +3. load `ExecutionState` +4. optionally reset stale `ExecutionState` +5. optionally refresh dynamic configuration snapshots +6. create a fresh execution plan with the LLM +7. execute steps one by one +8. persist `ExecutionState` after important transitions +9. append assistant answer into `chatHistory` +10. maybe compress old conversation into `TaskState` + +## Short-Term vs Durable Memory + +### What lives in `chatHistory` + +Good fits: + +- raw recent messages +- conversational wording +- latest assistant phrasing + +Bad fits: + +- long-lived truths +- current external system state + +### What lives in `TaskState` + +Good fits: + +- durable goal +- high-level unfinished work that remains relevant across turns +- important facts the user stated +- previous decisions and why they were made + +Bad fits: + +- pending steps inside the current plan +- execution-level reminders such as "wait for a field" or "call a tool" +- old conclusions about whether tools exist +- old conclusions about whether model/exchange config is present +- live operational state that can change outside the chat + +### What lives in `ExecutionState` + +Good fits: + +- current plan steps +- observations from tool calls +- blocked-on-user-input status +- exact current workflow state +- step-level pending work and block reasons + +Bad fits: + +- evergreen user profile +- long-term semantic memory + +## Planning Logic + +### Plan Creation + +`createExecutionPlan(...)` sends the following into the planner model: + +- available tool definitions +- persistent preferences +- `TaskState` context +- `ExecutionState` JSON +- current user request + +The planner must return JSON only with step types: + +- `tool` +- `reason` +- `ask_user` +- `respond` + +### Step Execution + +`executePlan(...)` executes the plan loop: + +- `tool` + call tool and append observation +- `reason` + run reasoning sub-call and append observation +- `ask_user` + save `waiting_user` state and return question +- `respond` + generate final answer and mark completed + +After each completed step, `replanAfterStep(...)` may: + +- continue +- replace remaining steps +- ask user +- finish + +## Resume Behavior + +When `ExecutionState.Status == waiting_user`, the next user turn is treated as a reply to the pending question. + +Current safeguards: + +- latest asked question is extracted from the stored plan +- the user reply is appended as a `user_reply` observation +- planner prompt receives explicit `Resume context` + +This prevents short replies like `是` from being misread as unrelated fresh intents as often as before. + +## Dynamic State Refresh + +Configuration and trader management requests are dynamic by nature. Their truth can change outside the current chat, for example: + +- user configures exchange in the UI +- user adds model in another tab +- user creates trader elsewhere + +Because of that, configuration/trader requests should not trust stale model conclusions. + +Current protection in `planner_runtime.go`: + +- detects config / trader intent with `isConfigOrTraderIntent(...)` +- clears `TaskState` context from the planner prompt for these requests +- refreshes `ExecutionState.Observations` with fresh snapshots from: + - `toolGetModelConfigs(...)` + - `toolGetExchangeConfigs(...)` + - `toolListTraders(...)` + +This makes the planner rely more on current system state and less on older narrative memory. + +## Reset Strategy + +The system currently resets or weakens stale execution state when: + +- user says retry-like phrases such as `再试`, `继续`, `try again`, `continue` +- request is config / trader related and old execution state is failed / completed / waiting + +Reset scope: + +- `ExecutionState` may be cleared +- `TaskState` is not globally deleted, but it is intentionally ignored for config/trader planning + +Manual reset: + +- `/clear` + +This clears: + +- short-term chat history +- task state +- execution state + +## Compression Design + +`maybeCompressHistory(...)` moves older short-term chat content into `TaskState` when: + +- recent message count exceeds the configured window +- estimated token count exceeds the threshold + +Compression strategy: + +1. keep recent conversation in `chatHistory` +2. summarize older turns into structured `TaskState` +3. persist new `TaskState` +4. replace `chatHistory` with recent slice + +Important design rule: + +- `TaskState` should keep durable context only +- it should not become a stale copy of mutable operational state + +## Current Architecture Diagram + +```mermaid +flowchart TD + U[User Message] --> A[HandleMessage / HandleMessageStream] + A --> B{Direct command?} + B -->|Yes| C[Direct branch or slash command] + B -->|No| D[thinkAndAct / thinkAndActStream] + + D --> E[Append user turn to chatHistory] + D --> F[Load ExecutionState] + F --> G{waiting_user?} + G -->|Yes| H[Attach user_reply observation] + G -->|No| I[Create fresh ExecutionState] + + H --> J[Refresh dynamic snapshots if config/trader intent] + I --> J + J --> K[createExecutionPlan via LLM] + K --> L[Execution plan] + L --> M[executePlan loop] + + M --> N[tool step] + M --> O[reason step] + M --> P[ask_user step] + M --> Q[respond step] + + N --> R[Append Observation] + O --> R + R --> S[replanAfterStep] + S --> M + + P --> T[Persist waiting_user ExecutionState] + T --> UQ[Return question to user] + + Q --> V[Persist completed ExecutionState] + V --> W[Append assistant turn to chatHistory] + W --> X[maybeCompressHistory] + X --> Y[Persist TaskState] + Y --> Z[Final response] +``` + +## Memory Relationship Diagram + +```mermaid +flowchart LR + CH[chatHistory\nin-memory\nrecent turns] + TS[TaskState\npersisted summary\nsystem_config] + ES[ExecutionState\npersisted workflow\nsystem_config] + PL[Planner Prompt] + + CH -->|recent raw turns| PL + ES -->|current workflow JSON| PL + TS -->|durable structured context| PL + + CH -->|old turns compressed| TS + PL -->|plan / observations / status| ES +``` + +## State Transition Diagram + +```mermaid +stateDiagram-v2 + [*] --> planning + planning --> running: plan created + running --> waiting_user: ask_user step + waiting_user --> planning: user replies + running --> completed: respond step finished + running --> failed: step error + failed --> planning: retry / continue / config-trader reset + completed --> planning: new relevant request or retry flow +``` + +## Known Design Tradeoffs + +### Strengths + +- separates short-term chat from durable task summary +- allows blocked flows to resume +- supports replanning after every meaningful step +- can recover from stale assumptions better for dynamic config/trader requests + +### Weaknesses + +- `TaskState` is still summary-driven, so summarization quality matters +- planner still depends on model compliance for some transitions +- `ExecutionState` is single-track per user, not multiple concurrent workflows +- config/trader intent detection is heuristic and keyword-based + +## Practical Guidance + +### When to trust `TaskState` + +Trust it for: + +- user intent continuity +- open loops +- durable facts + +Do not trust it for: + +- whether current exchange/model/trader config exists now +- whether a specific operational action is currently possible + +### When to trust `ExecutionState` + +Trust it for: + +- current plan continuity +- exact blocked step +- latest observation chain + +Do not trust it blindly when: + +- user has changed configuration outside the chat +- the system capabilities changed after deployment + +### When to fetch live state again + +Always prefer fresh tool snapshots before answering about: + +- existing model configs +- existing exchange configs +- existing traders +- whether trader creation can proceed + +## Suggested Future Improvements + +- add workflow versioning so capability changes invalidate stale `ExecutionState` +- separate `waiting_user_confirmation` from generic `waiting_user` +- introduce code-level handling for short confirmations such as `是`, `好`, `继续` +- move dynamic state refresh from heuristic to explicit planner preflight stage +- support multiple concurrent execution sessions per user if needed diff --git a/docs/architecture/AGENT_MEMORY_AND_PLANNING.zh-CN.md b/docs/architecture/AGENT_MEMORY_AND_PLANNING.zh-CN.md new file mode 100644 index 00000000..5dd1e2d8 --- /dev/null +++ b/docs/architecture/AGENT_MEMORY_AND_PLANNING.zh-CN.md @@ -0,0 +1,453 @@ +# NOFXi Agent 记忆与规划设计 + +## 目的 + +本文说明当前 NOFXi agent 是如何处理以下能力的： + +- 短期对话记忆 +- 持久化任务记忆 +- 持久化执行态 / 规划态 +- planner 的执行与重规划 +- 状态重置与恢复 + +本文主要对应以下实现文件： + +- `agent/history.go` +- `agent/memory.go` +- `agent/execution_state.go` +- `agent/planner_runtime.go` +- `agent/agent.go` + +## 总体模型 + +当前 agent 使用三层不同的状态： + +1. `chatHistory` +用于保存当前会话最近几轮的原始用户/助手对话，驻留内存。 + +2. `TaskState` +用于保存跨轮次仍然有价值的结构化摘要，持久化存储。 + +3. `ExecutionState` +用于保存当前规划流程的执行态，支持流程中断后的继续执行。 + +这三层职责不同，不能混为一谈。 + +## 三层状态 + +### 1. `chatHistory` + +定义位置：`agent/history.go` + +作用： + +- 按 `userID` 保存最近的 `user` / `assistant` 消息 +- 作为短期对话上下文 +- 作为后续压缩进 `TaskState` 的原始素材 + +特性： + +- 仅在内存中存在 +- 有 `maxTurns` 上限 +- `/clear` 时会清空 +- 不适合作为长期真相来源 + +典型内容： + +- 最近几轮用户问题 +- 最近几轮助手回答 +- 临时措辞与上下文表达 + +### 2. `TaskState` + +定义位置：`agent/memory.go` + +作用： + +- 保存持久化、结构化、不可轻易从工具重新推导出的上下文 +- 通过 `system_config` 持久化 +- 注入到 planner / reasoning prompt 中 + +存储 key： + +- `agent_task_state_` + +字段： + +- `CurrentGoal` +- `ActiveFlow` +- `OpenLoops` +- `ImportantFacts` +- `LastDecision` +- `UpdatedAt` + +适合存放： + +- 当前仍有效的用户目标 +- 跨轮次仍然成立的高层未闭环问题 +- 无法简单通过工具重新读取的重要事实 +- 最近一次关键决策及原因 + +不适合存放： + +- “等用户提供 API Key” 这类 step 级待办 +- “调用 get_exchange_configs” 这类执行动作 +- 实时余额 +- 当前持仓 +- 当前行情价格 +- 是否存在某个配置这类会变化的状态 + +这些动态信息应该在规划阶段通过工具重新检查，而不是相信旧摘要。 + +### 3. `ExecutionState` + +定义位置：`agent/execution_state.go` + +作用： + +- 保存当前执行中的工作流状态 +- 支持 `ask_user` 之后恢复执行 +- 持久化保存计划步骤、观察结果和最终状态 + +存储 key： + +- `agent_execution_state_` + +字段： + +- `SessionID` +- `UserID` +- `Goal` +- `Status` +- `PlanID` +- `Steps` +- `CurrentStepID` +- `Observations` +- `FinalAnswer` +- `LastError` +- `UpdatedAt` + +它是 planner 的“工作态”，不是通用记忆仓库。 + +## 数据流 + +### 请求入口 + +入口函数： + +- `HandleMessage(...)` +- `HandleMessageStream(...)` + +流程： + +1. 用户消息进入 `agent` +2. 优先处理 slash command 和显式直达分支 +3. 其余请求进入 planner 流程：`thinkAndAct(...)` / `thinkAndActStream(...)` + +### Planner 主流程 + +`agent/planner_runtime.go` 中的 planner 管线如下： + +1. 把用户消息加入 `chatHistory` +2. 发出 `planning` SSE 事件 +3. 加载 `ExecutionState` +4. 视情况重置过期的 `ExecutionState` +5. 视情况刷新动态配置快照 +6. 调用 LLM 生成新的执行计划 +7. 按步骤执行计划 +8. 在关键状态变化后持久化 `ExecutionState` +9. 把助手回答加入 `chatHistory` +10. 视情况把旧对话压缩进 `TaskState` + +## 短期记忆 vs 持久记忆 + +### `chatHistory` 里应该放什么 + +适合： + +- 最近原始消息 +- 对话措辞 +- 最近一轮助手的表达方式 + +不适合： + +- 长期真相 +- 外部系统当前状态 + +### `TaskState` 里应该放什么 + +适合： + +- 持续目标 +- 跨轮次仍有意义的高层未闭环事项 +- 用户明确讲过的重要事实 +- 历史关键决策和原因 + +不适合： + +- 当前 plan 中尚未执行的步骤 +- “等待某个字段”“调用某个 tool” 这类执行级待办 +- “系统有没有这个工具” 这种过时结论 +- “当前有没有模型/交易所配置” 这种可变化状态 +- 可以通过工具重新查询到的动态状态 + +### `ExecutionState` 里应该放什么 + +适合： + +- 当前计划步骤 +- 工具调用观察结果 +- 当前是否卡在等用户补充信息 +- 当前工作流的精确执行位置 +- step 级待办和阻塞原因 + +不适合： + +- 长期用户画像 +- 通用长期语义记忆 + +## 规划逻辑 + +### 计划生成 + +`createExecutionPlan(...)` 会把以下信息送给 planner 模型： + +- 当前可用 tool 定义 +- 持久化用户偏好 +- `TaskState` 上下文 +- `ExecutionState` JSON +- 当前用户请求 + +planner 必须返回 JSON，且步骤类型只能是： + +- `tool` +- `reason` +- `ask_user` +- `respond` + +### 步骤执行 + +`executePlan(...)` 的执行循环如下： + +- `tool` + 调用工具并写入 observation +- `reason` + 发起 reasoning 子调用并写入 observation +- `ask_user` + 保存 `waiting_user` 状态并把问题返回给用户 +- `respond` + 生成最终回答并标记完成 + +每个步骤结束后，`replanAfterStep(...)` 还可以决定： + +- continue +- replace_remaining +- ask_user +- finish + +## 恢复执行 + +当 `ExecutionState.Status == waiting_user` 时，下一条用户消息会被视为对上一轮追问的回复。 + +当前保护机制： + +- 从已有 plan 中提取最近一次追问内容 +- 将用户回复作为 `user_reply` observation 追加 +- 在 planner prompt 中注入显式的 `Resume context` + +这样可以减少用户只回复 `是` 这类短消息时，被错误理解成全新意图的情况。 + +## 动态状态刷新 + +配置类与 trader 管理类请求本质上是动态请求，它们的真相可能在聊天之外发生变化，例如： + +- 用户在 Web UI 中配置了交易所 +- 用户在另一个页面新增了模型 +- 用户在别处创建了 trader + +因此，这类请求不能依赖旧的模型结论。 + +当前在 `planner_runtime.go` 中的保护措施： + +- 通过 `isConfigOrTraderIntent(...)` 检测配置 / trader 意图 +- 这类请求在 planner prompt 中不再注入旧 `TaskState` +- 同时刷新 `ExecutionState.Observations` 中的实时快照： + - `toolGetModelConfigs(...)` + - `toolGetExchangeConfigs(...)` + - `toolListTraders(...)` + +这样 planner 会更多依赖当前系统状态，而不是依赖旧记忆中的描述。 + +## 重置策略 + +当前系统在以下场景会重置或弱化旧执行态： + +- 用户说了类似 `再试`、`继续`、`try again`、`continue` +- 当前请求是配置 / trader 相关，并且旧 `ExecutionState` 已经失败 / 完成 / 正在等待用户 + +重置范围： + +- `ExecutionState` 可能会被清空 +- `TaskState` 不会整体删除，但在配置 / trader 请求中会被主动忽略 + +手动清理： + +- `/clear` + +这条命令会清掉： + +- 短期 chat history +- task state +- execution state + +## 压缩设计 + +`maybeCompressHistory(...)` 会在以下条件满足时把旧的短期对话压缩进 `TaskState`： + +- 最近消息数超过窗口 +- 估算 token 数超过阈值 + +压缩流程： + +1. 保留最近若干轮对话在 `chatHistory` +2. 把更早的内容总结成结构化 `TaskState` +3. 持久化新的 `TaskState` +4. 用最近消息切片替换 `chatHistory` + +重要设计原则： + +- `TaskState` 只保留长期有效上下文 +- 不能把它变成动态运营状态的陈旧副本 + +## 当前架构图 + +```mermaid +flowchart TD + U[用户消息] --> A[HandleMessage / HandleMessageStream] + A --> B{是否命中直达分支?} + B -->|是| C[直接处理 slash command 或快捷分支] + B -->|否| D[thinkAndAct / thinkAndActStream] + + D --> E[写入 chatHistory] + D --> F[加载 ExecutionState] + F --> G{是否 waiting_user?} + G -->|是| H[追加 user_reply observation] + G -->|否| I[创建新的 ExecutionState] + + H --> J[若为配置或 trader 请求则刷新动态快照] + I --> J + J --> K[createExecutionPlan 调用 LLM] + K --> L[得到 execution plan] + L --> M[executePlan 循环执行] + + M --> N[tool step] + M --> O[reason step] + M --> P[ask_user step] + M --> Q[respond step] + + N --> R[写入 Observation] + O --> R + R --> S[replanAfterStep] + S --> M + + P --> T[持久化 waiting_user ExecutionState] + T --> UQ[向用户返回追问] + + Q --> V[持久化 completed ExecutionState] + V --> W[把 assistant 回复写入 chatHistory] + W --> X[maybeCompressHistory] + X --> Y[持久化 TaskState] + Y --> Z[返回最终回答] +``` + +## 记忆关系图 + +```mermaid +flowchart LR + CH[chatHistory\n内存态\n最近对话] + TS[TaskState\n持久化摘要\nsystem_config] + ES[ExecutionState\n持久化执行态\nsystem_config] + PL[Planner Prompt] + + CH -->|最近原始对话| PL + ES -->|当前工作流 JSON| PL + TS -->|长期结构化上下文| PL + + CH -->|旧消息压缩| TS + PL -->|计划 / 观察 / 状态| ES +``` + +## 状态转换图 + +```mermaid +stateDiagram-v2 + [*] --> planning + planning --> running: plan created + running --> waiting_user: ask_user step + waiting_user --> planning: user replies + running --> completed: respond step finished + running --> failed: step error + failed --> planning: retry / continue / config-trader reset + completed --> planning: new relevant request or retry flow +``` + +## 当前设计的取舍 + +### 优点 + +- 将短期对话与长期摘要分离 +- 支持在 `ask_user` 之后恢复执行 +- 每个关键步骤后都支持重规划 +- 对配置 / 创建 trader 这类动态请求，已经能更好抵抗旧结论污染 + +### 缺点 + +- `TaskState` 的质量仍然依赖总结效果 +- 某些恢复逻辑仍依赖模型是否听话 +- 每个用户当前只有一条 `ExecutionState`，不支持多个并发工作流 +- 配置 / trader 意图识别目前仍是关键词启发式 + +## 实践建议 + +### 什么时候该相信 `TaskState` + +应该相信它用于： + +- 延续用户目标 +- 跟踪未完成事项 +- 保留长期有效事实 + +不应该相信它用于： + +- 当前是否存在模型 / 交易所 / trader 配置 +- 当前是否能够执行某个操作 + +### 什么时候该相信 `ExecutionState` + +应该相信它用于： + +- 当前工作流是否仍然连续 +- 当前阻塞在哪一步 +- 最近的 observation 链条 + +不应该盲信它用于： + +- 用户在聊天外已经修改过配置的场景 +- 系统能力或工具集发生变化后的旧结论 + +### 什么时候必须重新获取实时状态 + +以下场景应该优先重新通过工具获取： + +- 当前模型配置 +- 当前交易所配置 +- 当前 trader 列表 +- 当前是否满足 trader 创建条件 + +## 后续建议 + +- 为 `ExecutionState` 增加版本号或能力签名，能力变化时自动失效 +- 将 `waiting_user_confirmation` 与通用 `waiting_user` 分开 +- 对 `是`、`好`、`继续` 这类短确认增加代码级识别 +- 将动态快照刷新从启发式升级为显式 planner 预检查阶段 +- 如果后续需要，支持一个用户多条并发执行会话 diff --git a/main.go b/main.go index a2c4f441..dfd74c88 100644 --- a/main.go +++ b/main.go @@ -1,13 +1,15 @@ package main import ( + "log/slog" "nofx/api" + nofxiagent "nofx/agent" "nofx/auth" "nofx/config" "nofx/crypto" - "nofx/telemetry" "nofx/logger" "nofx/manager" + "nofx/telemetry" _ "nofx/mcp/payment" _ "nofx/mcp/provider" "nofx/store" @@ -141,6 +143,14 @@ func main() { } }() + // Start the NOFXi web agent on top of the current dev branch services. + nofxiAgent := nofxiagent.New(traderManager, st, nil, slog.Default()) + nofxiAgent.Start() + defer nofxiAgent.Stop() + + agentWeb := nofxiagent.NewWebHandler(nofxiAgent, slog.Default()) + server.RegisterAgentHandler(agentWeb) + // Start Telegram bot (if TELEGRAM_BOT_TOKEN is configured) go telegram.Start(cfg, st, telegramReloadCh) @@ -154,6 +164,14 @@ func main() { <-quit logger.Info("📴 Shutdown signal received, closing system...") + if err := server.Shutdown(); err != nil { + logger.Warnf("⚠️ HTTP server shutdown error: %v", err) + } + logger.Info("✅ HTTP server stopped") + + nofxiAgent.Stop() + logger.Info("✅ NOFXi agent stopped") + // Stop all traders traderManager.StopAll() logger.Info("✅ System shut down safely") diff --git a/manager/trader_manager.go b/manager/trader_manager.go index 36b745b8..dce65785 100644 --- a/manager/trader_manager.go +++ b/manager/trader_manager.go @@ -11,6 +11,13 @@ import ( "time" ) +func traderLogTag(traderID, traderName string) string { + if traderName != "" { + return fmt.Sprintf("[trader_id=%s trader_name=%s]", traderID, traderName) + } + return fmt.Sprintf("[trader_id=%s]", traderID) +} + // CompetitionCache competition data cache type CompetitionCache struct { data map[string]interface{} @@ -88,9 +95,9 @@ func (tm *TraderManager) StartAll() { logger.Info("🚀 Starting all traders...") for id, t := range tm.traders { go func(traderID string, at *trader.AutoTrader) { - logger.Infof("▶️ Starting %s...", at.GetName()) + logger.Infof("%s ▶️ Starting trader runtime", traderLogTag(traderID, at.GetName())) if err := at.Run(); err != nil { - logger.Infof("❌ %s runtime error: %v", at.GetName(), err) + logger.Warnf("%s runtime error: %v", traderLogTag(traderID, at.GetName()), err) } }(id, t) } @@ -136,9 +143,9 @@ func (tm *TraderManager) AutoStartRunningTraders(st *store.Store) { for id, t := range tm.traders { if runningTraderIDs[id] { go func(traderID string, at *trader.AutoTrader) { - logger.Infof("▶️ Auto-restoring %s...", at.GetName()) + logger.Infof("%s ▶️ Auto-restoring trader runtime", traderLogTag(traderID, at.GetName())) if err := at.Run(); err != nil { - logger.Infof("❌ %s runtime error: %v", at.GetName(), err) + logger.Warnf("%s runtime error: %v", traderLogTag(traderID, at.GetName()), err) } }(id, t) startedCount++ @@ -487,7 +494,7 @@ func (tm *TraderManager) LoadUserTradersFromStore(st *store.Store, userID string logger.Infof("📦 Loading trader %s (AI Model: %s, Exchange: %s/%s, Strategy ID: %s)", traderCfg.Name, aiModelCfg.Provider, exchangeCfg.ExchangeType, exchangeCfg.AccountName, traderCfg.StrategyID) err = tm.addTraderFromStore(traderCfg, aiModelCfg, exchangeCfg, st) if err != nil { - logger.Infof("❌ Failed to load trader %s: %v", traderCfg.Name, err) + logger.Warnf("%s failed to load trader: %v", traderLogTag(traderCfg.ID, traderCfg.Name), err) // Save error for later retrieval tm.loadErrors[traderCfg.ID] = err } else { @@ -592,7 +599,7 @@ func (tm *TraderManager) LoadTradersFromStore(st *store.Store) error { // Add to TraderManager (ai500APIURL/oiTopAPIURL already obtained from strategy config) err = tm.addTraderFromStore(traderCfg, aiModelCfg, exchangeCfg, st) if err != nil { - logger.Infof("❌ Failed to add trader %s: %v", traderCfg.Name, err) + logger.Warnf("%s failed to add trader: %v", traderLogTag(traderCfg.ID, traderCfg.Name), err) continue } } @@ -727,17 +734,17 @@ func (tm *TraderManager) addTraderFromStore(traderCfg *store.Trader, aiModelCfg // Auto-start if trader was running before shutdown if traderCfg.IsRunning { - logger.Infof("🔄 Auto-starting trader '%s' (was running before shutdown)...", traderCfg.Name) + logger.Infof("%s 🔄 Auto-starting trader (was running before shutdown)...", traderLogTag(traderCfg.ID, traderCfg.Name)) go func(trader *trader.AutoTrader, traderName, traderID, userID string) { if err := trader.Run(); err != nil { - logger.Warnf("⚠️ Trader '%s' stopped with error: %v", traderName, err) + logger.Warnf("%s trader stopped with error: %v", traderLogTag(traderID, traderName), err) // Update database to reflect stopped state if st != nil { _ = st.Trader().UpdateStatus(userID, traderID, false) } } }(at, traderCfg.Name, traderCfg.ID, traderCfg.UserID) - logger.Infof("✅ Trader '%s' auto-started successfully", traderCfg.Name) + logger.Infof("%s ✅ Trader auto-started successfully", traderLogTag(traderCfg.ID, traderCfg.Name)) } return nil diff --git a/mcp/request.go b/mcp/request.go index 548ef094..5359644c 100644 --- a/mcp/request.go +++ b/mcp/request.go @@ -1,5 +1,7 @@ package mcp +import "context" + // Message represents a conversation message. // Supports plain messages (Role+Content), assistant tool-call messages (ToolCalls), // and tool result messages (Role="tool", ToolCallID, Content). @@ -62,6 +64,9 @@ type Request struct { // Advanced features Tools []Tool `json:"tools,omitempty"` // Available tools list ToolChoice string `json:"tool_choice,omitempty"` // Tool choice strategy ("auto", "none", {"type": "function", "function": {"name": "xxx"}}) + + // Context for cancellation; not serialized. + Ctx context.Context `json:"-"` } // NewMessage creates a message diff --git a/safe/go.go b/safe/go.go new file mode 100644 index 00000000..8084e55b --- /dev/null +++ b/safe/go.go @@ -0,0 +1,59 @@ +// Package safe provides panic-recovery wrappers for goroutines. +// A panic in any bare goroutine tears down the entire process. +// Use safe.Go instead of `go func()` in long-running or critical paths. +package safe + +import ( + "fmt" + "nofx/logger" + "runtime/debug" +) + +// Go launches fn in a new goroutine with automatic panic recovery. +// If fn panics, the panic is logged (with stack trace) but the process +// continues running. An optional onPanic callback receives the recovered value. +func Go(fn func(), onPanic ...func(recovered interface{})) { + go func() { + defer func() { + if r := recover(); r != nil { + stack := string(debug.Stack()) + logger.Errorf("🔥 goroutine panic recovered: %v\n%s", r, stack) + + for _, cb := range onPanic { + func() { + defer func() { + if r2 := recover(); r2 != nil { + logger.Errorf("🔥 onPanic callback itself panicked: %v", r2) + } + }() + cb(r) + }() + } + } + }() + fn() + }() +} + +// GoNamed is like Go but tags the log line with a human-readable name. +func GoNamed(name string, fn func(), onPanic ...func(recovered interface{})) { + Go(func() { + fn() + }, append([]func(interface{}){ + func(r interface{}) { + logger.Errorf("🔥 [%s] goroutine panicked: %v", name, r) + }, + }, onPanic...)...) +} + +// Must converts a panic into an error. Useful inside goroutines where you +// want to handle panics as errors in the caller's recovery flow. +func Must(fn func()) (err error) { + defer func() { + if r := recover(); r != nil { + err = fmt.Errorf("panic: %v\n%s", r, debug.Stack()) + } + }() + fn() + return nil +} diff --git a/safe/io.go b/safe/io.go new file mode 100644 index 00000000..d6fec028 --- /dev/null +++ b/safe/io.go @@ -0,0 +1,29 @@ +// Package safe provides safe I/O helpers. +package safe + +import ( + "fmt" + "io" +) + +// MaxResponseBody is the default maximum size for HTTP response bodies (10MB). +const MaxResponseBody = 10 * 1024 * 1024 + +// ReadAllLimited reads all bytes from r up to maxBytes. +// If maxBytes <= 0, it defaults to MaxResponseBody (10MB). +// Returns an error if the response exceeds the limit. +func ReadAllLimited(r io.Reader, maxBytes ...int64) ([]byte, error) { + limit := int64(MaxResponseBody) + if len(maxBytes) > 0 && maxBytes[0] > 0 { + limit = maxBytes[0] + } + lr := io.LimitReader(r, limit+1) + data, err := io.ReadAll(lr) + if err != nil { + return nil, err + } + if int64(len(data)) > limit { + return nil, fmt.Errorf("response body exceeds %d bytes limit", limit) + } + return data, nil +} diff --git a/store/ai_model.go b/store/ai_model.go index ef577cc1..7cd08e2a 100644 --- a/store/ai_model.go +++ b/store/ai_model.go @@ -131,7 +131,7 @@ func (s *AIModelStore) GetDefault(userID string) (*AIModel, error) { if userID == "" { userID = "default" } - model, err := s.firstEnabled(userID) + model, err := s.firstEnabledUsable(userID) if err == nil { return model, nil } @@ -139,14 +139,14 @@ func (s *AIModelStore) GetDefault(userID string) (*AIModel, error) { return nil, err } if userID != "default" { - return s.firstEnabled("default") + return s.firstEnabledUsable("default") } return nil, fmt.Errorf("please configure an available AI model in the system first") } -func (s *AIModelStore) firstEnabled(userID string) (*AIModel, error) { +func (s *AIModelStore) firstEnabledUsable(userID string) (*AIModel, error) { var model AIModel - err := s.db.Where("user_id = ? AND enabled = ?", userID, true). + err := s.db.Where("user_id = ? AND enabled = ? AND api_key != ''", userID, true). Order("updated_at DESC, id ASC"). First(&model).Error if err != nil { @@ -303,3 +303,16 @@ func (s *AIModelStore) Create(userID, id, name, provider string, enabled bool, a // Use FirstOrCreate to ignore if already exists return s.db.Where("id = ?", id).FirstOrCreate(model).Error } + +// Delete removes a user-owned AI model configuration. +func (s *AIModelStore) Delete(userID, id string) error { + result := s.db.Where("user_id = ? AND id = ?", userID, id).Delete(&AIModel{}) + if result.Error != nil { + return result.Error + } + if result.RowsAffected == 0 { + return fmt.Errorf("ai model not found: id=%s, userID=%s", id, userID) + } + logger.Infof("🗑️ Deleted AI model: id=%s, userID=%s", id, userID) + return nil +} diff --git a/trader/auto_trader.go b/trader/auto_trader.go index 0a0a6786..1faaafd4 100644 --- a/trader/auto_trader.go +++ b/trader/auto_trader.go @@ -24,6 +24,31 @@ import ( "time" ) +func (at *AutoTrader) logTag() string { + if at == nil { + return "[trader_id=unknown]" + } + if at.name != "" { + return fmt.Sprintf("[trader_id=%s trader_name=%s]", at.id, at.name) + } + return fmt.Sprintf("[trader_id=%s]", at.id) +} + +func (at *AutoTrader) logInfof(format string, args ...interface{}) { + values := append([]interface{}{at.logTag()}, args...) + logger.Infof("%s "+format, values...) +} + +func (at *AutoTrader) logWarnf(format string, args ...interface{}) { + values := append([]interface{}{at.logTag()}, args...) + logger.Warnf("%s "+format, values...) +} + +func (at *AutoTrader) logErrorf(format string, args ...interface{}) { + values := append([]interface{}{at.logTag()}, args...) + logger.Errorf("%s "+format, values...) +} + // AutoTraderConfig auto trading configuration (simplified version - AI makes all decisions) type AutoTraderConfig struct { // Trader identification @@ -381,8 +406,8 @@ func (at *AutoTrader) Run() error { at.startTime = time.Now() logger.Info("🚀 AI-driven automatic trading system started") - logger.Infof("💰 Initial balance: %.2f USDT", at.initialBalance) - logger.Infof("⚙️ Scan interval: %v", at.config.ScanInterval) + at.logInfof("💰 Initial balance: %.2f USDT", at.initialBalance) + at.logInfof("⚙️ Scan interval: %v", at.config.ScanInterval) logger.Info("🤖 AI will make full decisions on leverage, position size, stop loss/take profit, etc.") // Pre-launch checks for claw402 users @@ -397,7 +422,7 @@ func (at *AutoTrader) Run() error { if at.exchange == "lighter" { if lighterTrader, ok := at.trader.(*lighter.LighterTraderV2); ok && at.store != nil { lighterTrader.StartOrderSync(at.id, at.exchangeID, at.exchange, at.store, 30*time.Second) - logger.Infof("🔄 [%s] Lighter order+position sync enabled (every 30s)", at.name) + at.logInfof("🔄 Lighter order+position sync enabled (every 30s)") } } @@ -405,7 +430,7 @@ func (at *AutoTrader) Run() error { if at.exchange == "hyperliquid" { if hyperliquidTrader, ok := at.trader.(*hyperliquid.HyperliquidTrader); ok && at.store != nil { hyperliquidTrader.StartOrderSync(at.id, at.exchangeID, at.exchange, at.store, 30*time.Second) - logger.Infof("🔄 [%s] Hyperliquid order+position sync enabled (every 30s)", at.name) + at.logInfof("🔄 Hyperliquid order+position sync enabled (every 30s)") } } @@ -413,7 +438,7 @@ func (at *AutoTrader) Run() error { if at.exchange == "bybit" { if bybitTrader, ok := at.trader.(*bybit.BybitTrader); ok && at.store != nil { bybitTrader.StartOrderSync(at.id, at.exchangeID, at.exchange, at.store, 30*time.Second) - logger.Infof("🔄 [%s] Bybit order+position sync enabled (every 30s)", at.name) + at.logInfof("🔄 Bybit order+position sync enabled (every 30s)") } } @@ -421,7 +446,7 @@ func (at *AutoTrader) Run() error { if at.exchange == "okx" { if okxTrader, ok := at.trader.(*okx.OKXTrader); ok && at.store != nil { okxTrader.StartOrderSync(at.id, at.exchangeID, at.exchange, at.store, 30*time.Second) - logger.Infof("🔄 [%s] OKX order+position sync enabled (every 30s)", at.name) + at.logInfof("🔄 OKX order+position sync enabled (every 30s)") } } @@ -429,7 +454,7 @@ func (at *AutoTrader) Run() error { if at.exchange == "bitget" { if bitgetTrader, ok := at.trader.(*bitget.BitgetTrader); ok && at.store != nil { bitgetTrader.StartOrderSync(at.id, at.exchangeID, at.exchange, at.store, 30*time.Second) - logger.Infof("🔄 [%s] Bitget order+position sync enabled (every 30s)", at.name) + at.logInfof("🔄 Bitget order+position sync enabled (every 30s)") } } @@ -437,7 +462,7 @@ func (at *AutoTrader) Run() error { if at.exchange == "aster" { if asterTrader, ok := at.trader.(*aster.AsterTrader); ok && at.store != nil { asterTrader.StartOrderSync(at.id, at.exchangeID, at.exchange, at.store, 30*time.Second) - logger.Infof("🔄 [%s] Aster order+position sync enabled (every 30s)", at.name) + at.logInfof("🔄 Aster order+position sync enabled (every 30s)") } } @@ -445,7 +470,7 @@ func (at *AutoTrader) Run() error { if at.exchange == "binance" { if binanceTrader, ok := at.trader.(*binance.FuturesTrader); ok && at.store != nil { binanceTrader.StartOrderSync(at.id, at.exchangeID, at.exchange, at.store, 30*time.Second) - logger.Infof("🔄 [%s] Binance order+position sync enabled (every 30s)", at.name) + at.logInfof("🔄 Binance order+position sync enabled (every 30s)") } } @@ -453,7 +478,7 @@ func (at *AutoTrader) Run() error { if at.exchange == "gate" { if gateTrader, ok := at.trader.(*gate.GateTrader); ok && at.store != nil { gateTrader.StartOrderSync(at.id, at.exchangeID, at.exchange, at.store, 30*time.Second) - logger.Infof("🔄 [%s] Gate order+position sync enabled (every 30s)", at.name) + at.logInfof("🔄 Gate order+position sync enabled (every 30s)") } } @@ -461,7 +486,7 @@ func (at *AutoTrader) Run() error { if at.exchange == "kucoin" { if kucoinTrader, ok := at.trader.(*kucoin.KuCoinTrader); ok && at.store != nil { kucoinTrader.StartOrderSync(at.id, at.exchangeID, at.exchange, at.store, 30*time.Second) - logger.Infof("🔄 [%s] KuCoin order+position sync enabled (every 30s)", at.name) + at.logInfof("🔄 KuCoin order+position sync enabled (every 30s)") } } @@ -471,9 +496,9 @@ func (at *AutoTrader) Run() error { // Check if this is a grid trading strategy isGridStrategy := at.IsGridStrategy() if isGridStrategy { - logger.Infof("🔲 [%s] Grid trading strategy detected, initializing grid...", at.name) + at.logInfof("🔲 Grid trading strategy detected, initializing grid...") if err := at.InitializeGrid(); err != nil { - logger.Errorf("❌ [%s] Failed to initialize grid: %v", at.name, err) + at.logErrorf("❌ Failed to initialize grid: %v", err) return fmt.Errorf("grid initialization failed: %w", err) } } @@ -481,11 +506,11 @@ func (at *AutoTrader) Run() error { // Execute immediately on first run if isGridStrategy { if err := at.RunGridCycle(); err != nil { - logger.Infof("❌ Grid execution failed: %v", err) + at.logErrorf("❌ Grid execution failed: %v", err) } } else { if err := at.runCycle(); err != nil { - logger.Infof("❌ Execution failed: %v", err) + at.logErrorf("❌ Execution failed: %v", err) } } @@ -502,15 +527,15 @@ func (at *AutoTrader) Run() error { case <-ticker.C: if isGridStrategy { if err := at.RunGridCycle(); err != nil { - logger.Infof("❌ Grid execution failed: %v", err) + at.logErrorf("❌ Grid execution failed: %v", err) } } else { if err := at.runCycle(); err != nil { - logger.Infof("❌ Execution failed: %v", err) + at.logErrorf("❌ Execution failed: %v", err) } } case <-at.stopMonitorCh: - logger.Infof("[%s] ⏹ Stop signal received, exiting automatic trading main loop", at.name) + at.logInfof("⏹ Stop signal received, exiting automatic trading main loop") return nil } } @@ -590,6 +615,22 @@ func (at *AutoTrader) GetSystemPromptTemplate() string { return "strategy" } +// GetCandidateCoins returns the current candidate coin set from the trader's strategy engine. +func (at *AutoTrader) GetCandidateCoins() ([]kernel.CandidateCoin, error) { + if at.strategyEngine == nil { + return nil, fmt.Errorf("strategy engine not configured") + } + return at.strategyEngine.GetCandidateCoins() +} + +// GetStrategyConfig returns the current strategy config used by the trader. +func (at *AutoTrader) GetStrategyConfig() *store.StrategyConfig { + if at.strategyEngine == nil { + return at.config.StrategyConfig + } + return at.strategyEngine.GetConfig() +} + // GetStore gets data store (for external access to decision records, etc.) func (at *AutoTrader) GetStore() *store.Store { return at.store diff --git a/trader/auto_trader_loop.go b/trader/auto_trader_loop.go index ae440699..c01b91f5 100644 --- a/trader/auto_trader_loop.go +++ b/trader/auto_trader_loop.go @@ -24,7 +24,7 @@ func (at *AutoTrader) runCycle() error { running := at.isRunning at.isRunningMutex.RUnlock() if !running { - logger.Infof("⏹ Trader is stopped, aborting cycle #%d", at.callCount) + at.logInfof("⏹ Trader is stopped, aborting cycle #%d", at.callCount) return nil } @@ -42,7 +42,7 @@ func (at *AutoTrader) runCycle() error { // 1. Check if trading needs to be stopped if time.Now().Before(at.stopUntil) { remaining := at.stopUntil.Sub(time.Now()) - logger.Infof("⏸ Risk control: Trading paused, remaining %.0f minutes", remaining.Minutes()) + at.logWarnf("⏸ Risk control: Trading paused, remaining %.0f minutes", remaining.Minutes()) record.Success = false record.ErrorMessage = fmt.Sprintf("Risk control paused, remaining %.0f minutes", remaining.Minutes()) at.saveDecision(record) @@ -59,6 +59,7 @@ func (at *AutoTrader) runCycle() error { // 4. Collect trading context ctx, err := at.buildTradingContext() if err != nil { + at.logErrorf("failed to build trading context: %v", err) record.Success = false record.ErrorMessage = fmt.Sprintf("Failed to build trading context: %v", err) at.saveDecision(record) @@ -71,7 +72,7 @@ func (at *AutoTrader) runCycle() error { // If no candidate coins available, log but do not error if len(ctx.CandidateCoins) == 0 { - logger.Infof("ℹ️ No candidate coins available, skipping this cycle") + at.logInfof("ℹ️ No candidate coins available, skipping this cycle") record.Success = true // Not an error, just no candidate coins record.ExecutionLog = append(record.ExecutionLog, "No candidate coins available, cycle skipped") record.AccountState = store.AccountSnapshot{ @@ -90,16 +91,16 @@ func (at *AutoTrader) runCycle() error { record.CandidateCoins = append(record.CandidateCoins, coin.Symbol) } - logger.Infof("📊 Account equity: %.2f USDT | Available: %.2f USDT | Positions: %d", + at.logInfof("📊 Account equity: %.2f USDT | Available: %.2f USDT | Positions: %d", ctx.Account.TotalEquity, ctx.Account.AvailableBalance, ctx.Account.PositionCount) // 5. Use strategy engine to call AI for decision - logger.Infof("🤖 Requesting AI analysis and decision... [Strategy Engine]") + at.logInfof("🤖 Requesting AI analysis and decision... [Strategy Engine]") aiDecision, err := kernel.GetFullDecisionWithStrategy(ctx, at.mcpClient, at.strategyEngine, "balanced") if aiDecision != nil && aiDecision.AIRequestDurationMs > 0 { record.AIRequestDurationMs = aiDecision.AIRequestDurationMs - logger.Infof("⏱️ AI call duration: %.2f seconds", float64(record.AIRequestDurationMs)/1000) + at.logInfof("⏱️ AI call duration: %.2f seconds", float64(record.AIRequestDurationMs)/1000) record.ExecutionLog = append(record.ExecutionLog, fmt.Sprintf("AI call duration: %d ms", record.AIRequestDurationMs)) } @@ -119,7 +120,7 @@ func (at *AutoTrader) runCycle() error { // Record AI charge (track cost regardless of decision outcome) if aiDecision != nil && at.store != nil { if chargeErr := at.store.AICharge().Record(at.id, at.aiModel, at.config.AIModel); chargeErr != nil { - logger.Warnf("⚠️ Failed to record AI charge: %v", chargeErr) + at.logWarnf("⚠️ Failed to record AI charge: %v", chargeErr) } } @@ -132,10 +133,9 @@ func (at *AutoTrader) runCycle() error { if at.consecutiveAIFailures >= 3 && !at.safeMode { at.safeMode = true at.safeModeReason = fmt.Sprintf("AI failed %d consecutive times: %v", at.consecutiveAIFailures, err) - logger.Errorf("🛡️ [%s] SAFE MODE ACTIVATED — AI failed %d times in a row. No new positions will be opened. Existing positions are protected with current stop-loss settings.", - at.name, at.consecutiveAIFailures) - logger.Errorf("🛡️ [%s] Reason: %v", at.name, err) - logger.Errorf("🛡️ [%s] Action: Will keep trying AI each cycle. Safe mode auto-deactivates when AI recovers.", at.name) + at.logErrorf("🛡️ SAFE MODE ACTIVATED — AI failed %d times in a row. No new positions will be opened. Existing positions are protected with current stop-loss settings.", at.consecutiveAIFailures) + at.logErrorf("🛡️ Reason: %v", err) + at.logErrorf("🛡️ Action: Will keep trying AI each cycle. Safe mode auto-deactivates when AI recovers.") } // Print system prompt and AI chain of thought (output even with errors for debugging) @@ -159,7 +159,7 @@ func (at *AutoTrader) runCycle() error { // In safe mode, don't return error — keep the loop running to retry next cycle if at.safeMode { - logger.Warnf("🛡️ [%s] Safe mode: skipping this cycle, will retry in %v", at.name, at.config.ScanInterval) + at.logWarnf("🛡️ Safe mode: skipping this cycle, will retry in %v", at.config.ScanInterval) return nil } @@ -168,11 +168,11 @@ func (at *AutoTrader) runCycle() error { // AI succeeded — reset failure counter and deactivate safe mode if at.consecutiveAIFailures > 0 { - logger.Infof("✅ [%s] AI recovered after %d consecutive failures", at.name, at.consecutiveAIFailures) + at.logInfof("✅ AI recovered after %d consecutive failures", at.consecutiveAIFailures) } at.consecutiveAIFailures = 0 if at.safeMode { - logger.Infof("🛡️ [%s] SAFE MODE DEACTIVATED — AI is working again. Resuming normal trading.", at.name) + at.logInfof("🛡️ SAFE MODE DEACTIVATED — AI is working again. Resuming normal trading.") at.safeMode = false at.safeModeReason = "" } @@ -219,7 +219,7 @@ func (at *AutoTrader) runCycle() error { running = at.isRunning at.isRunningMutex.RUnlock() if !running { - logger.Infof("⏹ Trader stopped before decision execution, aborting cycle #%d", at.callCount) + at.logInfof("⏹ Trader stopped before decision execution, aborting cycle #%d", at.callCount) return nil } @@ -228,14 +228,14 @@ func (at *AutoTrader) runCycle() error { filtered := make([]kernel.Decision, 0) for _, d := range sortedDecisions { if d.Action == "open_long" || d.Action == "open_short" { - logger.Warnf("🛡️ [%s] Safe mode: BLOCKED %s %s (no new positions allowed)", at.name, d.Action, d.Symbol) + at.logWarnf("🛡️ Safe mode: BLOCKED %s %s (no new positions allowed)", d.Action, d.Symbol) continue } filtered = append(filtered, d) } sortedDecisions = filtered if len(sortedDecisions) == 0 { - logger.Infof("🛡️ [%s] Safe mode: all decisions were open positions, nothing to execute", at.name) + at.logInfof("🛡️ Safe mode: all decisions were open positions, nothing to execute") } } @@ -246,7 +246,7 @@ func (at *AutoTrader) runCycle() error { running = at.isRunning at.isRunningMutex.RUnlock() if !running { - logger.Infof("⏹ Trader stopped during decision execution, aborting remaining decisions") + at.logInfof("⏹ Trader stopped during decision execution, aborting remaining decisions") break } @@ -265,7 +265,7 @@ func (at *AutoTrader) runCycle() error { } if err := at.executeDecisionWithRecord(&d, &actionRecord); err != nil { - logger.Infof("❌ Failed to execute decision (%s %s): %v", d.Symbol, d.Action, err) + at.logErrorf("❌ Failed to execute decision (%s %s): %v", d.Symbol, d.Action, err) actionRecord.Error = err.Error() record.ExecutionLog = append(record.ExecutionLog, fmt.Sprintf("❌ %s %s failed: %v", d.Symbol, d.Action, err)) } else { @@ -280,7 +280,7 @@ func (at *AutoTrader) runCycle() error { // 9. Save decision record if err := at.saveDecision(record); err != nil { - logger.Infof("⚠ Failed to save decision record: %v", err) + at.logWarnf("⚠ Failed to save decision record: %v", err) } return nil @@ -417,12 +417,12 @@ func (at *AutoTrader) buildTradingContext() (*kernel.Context, error) { // 3. Use strategy engine to get candidate coins (must have strategy engine) var candidateCoins []kernel.CandidateCoin if at.strategyEngine == nil { - logger.Infof("⚠️ [%s] No strategy engine configured, skipping candidate coins", at.name) + at.logWarnf("⚠️ No strategy engine configured, skipping candidate coins") } else { coins, err := at.strategyEngine.GetCandidateCoins() if err != nil { // Log warning but don't fail - equity snapshot should still be saved - logger.Infof("⚠️ [%s] Failed to get candidate coins: %v (will use empty list)", at.name, err) + at.logWarnf("⚠️ Failed to get candidate coins: %v (will use empty list)", err) } else { candidateCoins = coins logger.Infof("📋 [%s] Strategy engine fetched candidate coins: %d", at.name, len(candidateCoins)) @@ -473,7 +473,7 @@ func (at *AutoTrader) buildTradingContext() (*kernel.Context, error) { // Get recent 10 closed trades for AI context recentTrades, err := at.store.Position().GetRecentTrades(at.id, 10) if err != nil { - logger.Infof("⚠️ [%s] Failed to get recent trades: %v", at.name, err) + at.logWarnf("⚠️ Failed to get recent trades: %v", err) } else { logger.Infof("📊 [%s] Found %d recent closed trades for AI context", at.name, len(recentTrades)) for _, trade := range recentTrades { @@ -503,11 +503,11 @@ func (at *AutoTrader) buildTradingContext() (*kernel.Context, error) { // Get trading statistics for AI context stats, err := at.store.Position().GetFullStats(at.id) if err != nil { - logger.Infof("⚠️ [%s] Failed to get trading stats: %v", at.name, err) + at.logWarnf("⚠️ Failed to get trading stats: %v", err) } else if stats == nil { - logger.Infof("⚠️ [%s] GetFullStats returned nil", at.name) + at.logWarnf("⚠️ GetFullStats returned nil") } else if stats.TotalTrades == 0 { - logger.Infof("⚠️ [%s] GetFullStats returned 0 trades (traderID=%s)", at.name, at.id) + at.logWarnf("⚠️ GetFullStats returned 0 trades") } else { ctx.TradingStats = &kernel.TradingStats{ TotalTrades: stats.TotalTrades, @@ -523,7 +523,7 @@ func (at *AutoTrader) buildTradingContext() (*kernel.Context, error) { at.name, stats.TotalTrades, stats.WinRate, stats.ProfitFactor, stats.SharpeRatio, stats.MaxDrawdownPct) } } else { - logger.Infof("⚠️ [%s] Store is nil, cannot get recent trades", at.name) + at.logWarnf("⚠️ Store is nil, cannot get recent trades") } // 8. Get quantitative data (if enabled in strategy config) @@ -630,15 +630,15 @@ func (at *AutoTrader) checkClaw402Balance() { if at.claw402WalletAddr != "" { balance, err := wallet.QueryUSDCBalance(at.claw402WalletAddr) if err != nil { - logger.Warnf("⚠️ [%s] Failed to query USDC balance: %v", at.name, err) + at.logWarnf("⚠️ Failed to query USDC balance: %v", err) return } if balance < 1.0 { - logger.Warnf("⚠️ [%s] Low USDC balance: $%.2f — AI may stop soon!", at.name, balance) + at.logWarnf("⚠️ Low USDC balance: $%.2f — AI may stop soon!", balance) } if balance <= 0 { - logger.Errorf("🚨 [%s] USDC balance is ZERO — AI calls will fail!", at.name) + at.logErrorf("🚨 USDC balance is ZERO — AI calls will fail!") } runway := float64(0) diff --git a/web/src/components/agent/AgentStepPanel.tsx b/web/src/components/agent/AgentStepPanel.tsx new file mode 100644 index 00000000..9e999bb7 --- /dev/null +++ b/web/src/components/agent/AgentStepPanel.tsx @@ -0,0 +1,104 @@ +interface AgentStep { + id: string + label: string + status: 'planning' | 'pending' | 'running' | 'completed' | 'replanned' + detail?: string +} + +interface AgentStepPanelProps { + steps?: AgentStep[] + visible?: boolean +} + +const statusStyles: Record = { + planning: { dot: '#7c3aed', text: '#c4b5fd' }, + pending: { dot: 'rgba(255,255,255,0.18)', text: '#818198' }, + running: { dot: '#F0B90B', text: '#f6d67a' }, + completed: { dot: '#00e5a0', text: '#9cf5d5' }, + replanned: { dot: '#38bdf8', text: '#9bdcf7' }, +} + +export function AgentStepPanel({ steps, visible }: AgentStepPanelProps) { + if (!visible || !steps || steps.length === 0) { + return null + } + + return ( +
+
+ Live Run +
+
+ {steps.map((step) => { + const style = statusStyles[step.status] + return ( +
+ +
+
+ {step.label} +
+ {step.detail && ( +
+ {step.detail} +
+ )} +
+
+ ) + })} +
+
+ ) +} diff --git a/web/src/components/agent/ChatInput.tsx b/web/src/components/agent/ChatInput.tsx new file mode 100644 index 00000000..b2012cb5 --- /dev/null +++ b/web/src/components/agent/ChatInput.tsx @@ -0,0 +1,154 @@ +import { useRef, useState, useCallback, useEffect, useImperativeHandle, forwardRef } from 'react' +import { ArrowUp } from 'lucide-react' + +export interface ChatInputHandle { + focus: () => void + clear: () => void + getValue: () => string +} + +interface ChatInputProps { + language: string + loading: boolean + onSend: (text: string) => void +} + +export const ChatInput = forwardRef( + function ChatInput({ language, loading, onSend }, ref) { + const [input, setInput] = useState('') + const [composing, setComposing] = useState(false) + const inputRef = useRef(null) + + useImperativeHandle(ref, () => ({ + focus: () => inputRef.current?.focus(), + clear: () => { + setInput('') + if (inputRef.current) inputRef.current.style.height = 'auto' + }, + getValue: () => input, + })) + + const handleInputChange = useCallback( + (e: React.ChangeEvent) => { + setInput(e.target.value) + const el = e.target + el.style.height = 'auto' + el.style.height = Math.min(el.scrollHeight, 150) + 'px' + }, + [] + ) + + const handleSend = () => { + const msg = input.trim() + if (!msg || loading) return + setInput('') + if (inputRef.current) inputRef.current.style.height = 'auto' + onSend(msg) + inputRef.current?.focus() + } + + // Keyboard shortcut: Cmd+K to focus + useEffect(() => { + const handleKeyDown = (e: KeyboardEvent) => { + if ((e.metaKey || e.ctrlKey) && e.key === 'k') { + e.preventDefault() + inputRef.current?.focus() + } + } + window.addEventListener('keydown', handleKeyDown) + return () => window.removeEventListener('keydown', handleKeyDown) + }, []) + + return ( +
+
+