feat: Claw402 x402 payment provider + Telegram agent + x402 refactoring (#1409)

* feat(telegram): add AI agent bot with streaming and account context - Add Telegram bot with long-polling and AI agent loop (api_call tool) - SSE streaming with real-time message editing and ⏳ placeholder - Account state injection at conversation start (models, exchanges, strategies, traders, per-trader PnL and statistics) - Lane semaphore per chat serializes concurrent messages (60s timeout) - Idle timeout watchdog (60s) prevents hung streaming connections - Look-ahead buffer prevents partial <api_call> tag leaking to user - Fix PUT /strategies/:id to merge config (read-then-merge pattern) - Add route registry with full API schema for LLM documentation - Add TelegramConfig store and Web UI config modal - Add GetAnyEnabled to AIModel store for bot LLM client selection * fix(telegram): eliminate narration, add full-setup workflow and tests - Rewrite NO NARRATION rule: response is EITHER api_call tag alone OR final text reply — no text before api_call under any circumstances - Ban all narration patterns: 现在我将/好的/正在/I will/Let me etc. - Add 'create strategy + create trader + start' full setup workflow - Add 12 automated tests covering: - No narration leaking to user (5 narration variants tested) - api_call tag never leaks to user - Full setup workflow: POST strategy → verify → POST trader → start - Start existing trader workflow - Max iterations safety, tag stripping, parser edge cases * refactor(agent): replace XML api_call with native function calling Migrate the Telegram bot agent from an XML tag hack (<api_call>) to OpenAI-native function calling via CallWithRequestFull. Key changes: - mcp/interface.go: add parseMCPResponseFull to clientHooks interface - mcp/client.go: route callWithRequestFull through hooks for overridability - mcp/claude_client.go: override parseMCPResponseFull for Claude response format (tool_use blocks instead of choices[].message.tool_calls) - telegram/agent/agent.go: rewrite Run() to use CallWithRequestFull; define api_request tool with JSON Schema; implement tool-call loop with role="tool" result messages; remove XML parsing entirely - telegram/agent/apicall.go: remove parseAPICall (dead code) - telegram/agent/prompt.go: simplify — remove XML format instructions, replace with concise api_request tool usage instructions - telegram/agent/agent_test.go: rebuild all tests using LLMResponse objects; add TestNarrationStructurallyImpossible, TestOnChunkCalledWithFinalReply, TestToolCallIDPropagated; remove XML-specific tests Architecture advantage: with native function calling, the LLM returns EITHER ToolCalls OR Content — never both. Narration is now structurally impossible at the protocol level, not just enforced by prompt rules. All 11 agent tests pass. mcp package tests pass. * refactor(mcp): route buildRequestBodyFromRequest through hooks + full Anthropic format Problem: callWithRequest/Full/Stream all called client.buildRequestBodyFromRequest directly (not via hooks), so ClaudeClient could never override it. This meant tool calling sent OpenAI format to Anthropic (wrong field names, wrong roles). Changes: mcp/interface.go - Add buildRequestBodyFromRequest(*Request) map[string]any to clientHooks - Improve comments: document what each hook group does and why mcp/client.go - All three paths (callWithRequest, callWithRequestFull, CallWithRequestStream) now call client.hooks.buildRequestBodyFromRequest — ClaudeClient picks up mcp/claude_client.go - Full rewrite with format comparison table in package doc - buildRequestBodyFromRequest: produces correct Anthropic wire format * system prompt → top-level "system" field * tools: parameters → input_schema, no "type:function" wrapper * tool_choice "auto" → {"type":"auto"} object * assistant tool calls → content[{type:tool_use, id, name, input}] * role=tool results → role=user content[{type:tool_result,...}] * consecutive tool results merged into single user turn - convertMessagesToAnthropic: handles all three message types - parseMCPResponseFull: extracts text + tool_use blocks - parseMCPResponse: delegates to parseMCPResponseFull All mcp and agent tests pass. * fix(telegram): fix claude client dispatch + strategy creation workflow - telegram/bot.go: clientForProvider now returns NewClaudeClient() for 'claude' provider (was incorrectly falling back to DeepSeekClient which uses OpenAI wire format, breaking Anthropic API calls) - api/server.go: fix scan_interval_minutes schema default (3, not 60); POST /api/strategies now clearly states config is OPTIONAL with complete working defaults; POST /api/traders removes redundant GET workflow note - telegram/agent/prompt.go: simplify strategy creation — just POST {name} without config (backend applies full working defaults automatically); only include config when user requests custom settings * test(mcp): add ClaudeClient wire format tests Tests cover all Anthropic-specific format conversions: - system prompt lifted to top-level field - tools use input_schema (not parameters) - tool_choice is object {type:auto} not string - assistant tool calls → content[{type:tool_use}] - consecutive tool results merged into single user turn - parseMCPResponseFull: text, tool_use, and error cases - x-api-key header (not Authorization: Bearer) - /messages endpoint URL * fix(telegram): clientForProvider returns correct client for all 7 providers Previously qwen/kimi/grok/gemini all fell back to DeepSeekClient. Each provider now gets its own dedicated client with correct default base URL and model. All 7 providers now fully supported: openai, deepseek, claude, qwen, kimi, grok, gemini * fix(telegram): newLLMClient uses bound user's model, not any user's model GetAnyEnabled() searched across all users in DB — if user B has an enabled model, bot could use their API key while acting as user A. Now uses GetDefault(botUserID) which only looks up the bound user's enabled model, matching the same user scope as all API calls. * fix(auth): single-user deployment by default, no open registration Registration logic redesigned: - Empty DB (first-time setup): registration always open, no config needed - After first user exists: registration closed by default - Multi-user opt-in: set REGISTRATION_ENABLED=true + MAX_USERS=N in .env Config defaults changed: - RegistrationEnabled: true → false (closed after first user) - MaxUsers: 10 → 1 (single-user deployment default) This eliminates the confusion of multiple users appearing in a personal deployment where Telegram is bound to a single admin account. * feat(solo): beginner-friendly onboarding — smart setup guide + direct config commands start.sh: - Interactive Telegram Bot Token prompt on first run - Token format validation (must match 12345:ABC... pattern) - Friendly step-by-step startup instructions after launch telegram/bot.go: - /start now shows context-aware setup guide based on actual config state: - No AI model → explains how to configure, lists all providers - AI model OK but no exchange → guides to configure exchange via chat - All configured → full capabilities welcome message - New: direct setup commands ('配置 deepseek sk-xxx') bypass LLM entirely so AI model can be configured even before any model exists (bootstrap fix) - All messages now in Chinese (匹配用户语言) telegram/agent/prompt.go: - Added first-time setup detection section - Agent told to never ask user to visit web UI — everything via chat * feat(i18n): bilingual EN/ZH setup guide with language selection store/telegram_config.go: - Add Language field to TelegramConfig (persisted in DB) - Add SetLanguage(lang) and GetLanguage() methods - Default language: English (en) telegram/bot.go: - First /start triggers language selection (1=English, 2=中文) - /lang command to change language at any time - awaitingLang state machine handles language choice before any other input - buildSetupGuide() now fully bilingual (EN/ZH), context-aware: Step 1: configure AI model (no model yet) Step 2: configure exchange (model OK, no exchange) Ready: show full capabilities - tryHandleSetupCommand() bilingual: 'configure/配置 <provider> <key>' - helpMessage(lang) fully bilingual - All error/status messages bilingual Default: English. isLangDefault() detects whether user has explicitly chosen a language vs falling back to the 'en' default. * fix(telegram): use Markdown rendering + simplify language selection condition - sendMarkdownMsg() helper: sends with ParseMode=Markdown, falls back to plain text - All formatted messages (langSelectionMsg, buildSetupGuide, helpMessage) now render bold text and code blocks correctly in Telegram - Simplify /start language check: isLangDefault(st) alone is sufficient (lang == 'en' && isLangDefault was redundant — GetLanguage returns 'en' when empty) * fix(start.sh): translate all user-facing text to English Entire script was in Chinese. Now English-first throughout: - startup banner, prompts, success/error messages - setup_telegram(): English instructions and validation messages - start(): English next-steps after launch - stop/restart/clean/update/regenerate-keys/show_help: all English * fix(telegram): remove 'default' user fallback — resolve user dynamically - botUserID no longer captured once at startup (was 'default' if no user yet) - resolveBotUser() reads first registered user from DB on demand: * called on every /start (handles: registered after bot launch) * called before every AI message (handles mid-session registration) - If no user registered: clear English error 'No account found. Please register on the web UI first' - start.sh: fix set_env_var appending without newline (token was concatenated to prev line) * refactor(telegram): clean onboarding — web UI for setup, Telegram for operations - /start shows clean status: 'setup required → open web UI' or 'ready → examples' - Removed tryHandleSetupCommand (no more CLI-style 'configure deepseek sk-xxx') - Removed automatic language selection on /start (use /lang anytime instead) - newLLMClient returns nil when no model → clear guard, not fallback - statusMsg() replaces buildSetupGuide(): two states only (missing config / ready) - Bot is now purely an operations interface; config lives in the web UI * refactor: single-user web-based setup — replace env config with Settings UI Move from multi-user env-var config to single-user web-first architecture: - Add SetupPage for first-time initialization (replaces /register) - Add SettingsPage for AI models, exchanges, Telegram, and password management - Enrich all API route schemas with exact ID usage documentation - Add PUT /user/password endpoint for in-app password changes - Remove REGISTRATION_ENABLED, MAX_USERS, TELEGRAM_BOT_TOKEN from env config - Simplify LoginPage design, remove admin mode and registration links - Telegram bot now resolves user email for identity display - start.sh no longer runs interactive Telegram setup * feat: add blockRun (x402 USDC) support to all AI model consumers - telegram/bot.go: add blockrun-base, blockrun-sol, minimax to clientForProvider; fix newLLMClient to prefer TelegramConfig.ModelID over GetDefault; log USDC payment provider usage - debate/engine.go: add blockrun-base, blockrun-sol to InitializeClients - api/strategy.go: add blockrun-base, blockrun-sol to runRealAITest - backtest/ai_client.go: add blockrun-base, blockrun-sol to configureMCPClient * feat: add Claw402 (claw402.ai) x402 USDC payment provider Add Claw402Client for claw402.ai's x402 micropayment gateway (Base USDC). Supports 15+ AI models (GPT-5.4, Claude Opus, DeepSeek, Qwen, Grok, etc.) with per-model endpoint routing. - mcp/claw402.go: new client with model→endpoint mapping, x402 v2 payment flow - mcp/blockrun_base.go: extract shared signX402Payment() for reuse - Register "claw402" provider in all 6 consumer switch statements: api/server.go, api/strategy.go, trader/auto_trader.go, telegram/bot.go, debate/engine.go, backtest/ai_client.go * feat: redesign Claw402 model config UI — friendly wallet setup, USDC guide, official logo, nginx no-cache for index.html * refactor: centralize x402 payment flow into shared mcp/x402.go Extract duplicated doRequestWithPayment/call/CallWithRequestFull/buildRequest/ setAuthHeader (~165 lines x3) into shared helpers in mcp/x402.go. Consolidate shared types (x402v2PaymentRequired, x402AcceptOption, x402Resource) and remove duplicate Solana types. Fix validAfter to 0 (official SDK standard), drain 402 body before retry, log Payment-Response tx hash, check Payment-Required before X-Payment-Required. * fix: stop PR template bot from overwriting user-written descriptions The pr-template-suggester workflow was triggered on opened/edited/synchronize events and forcefully replaced the PR body with a template when body < 100 chars. This caused user-written descriptions to be overwritten. Replace with a lightweight labeler (OpenClaw-style) that: - Only adds labels (backend/frontend/docs, size: XS/S/M/L/XL) - Never modifies the PR body - Simplified unified PR template at .github/pull_request_template.md * chore: simplify PR template (OpenClaw-style)
2026-06-04 01:48:22 +08:00 · 2026-03-11 16:01:42 +08:00
parent 6f77ed2fcb
commit 9c5c976d9a
53 changed files with 7572 additions and 1093 deletions
@@ -0,0 +1,285 @@
+package agent
+
+import (
+	"encoding/json"
+	"fmt"
+	"nofx/auth"
+	"nofx/logger"
+	"nofx/mcp"
+	"nofx/telegram/session"
+	"strings"
+)
+
+const maxIterations = 10
+
+// apiRequestTool is the single tool exposed to the LLM.
+// Native function calling means the LLM returns EITHER ToolCalls OR Content — never both.
+// This makes narration structurally impossible: text cannot appear alongside a tool call.
+var apiRequestTool = mcp.Tool{
+	Type: "function",
+	Function: mcp.FunctionDef{
+		Name:        "api_request",
+		Description: "Call the NOFX trading system REST API",
+		Parameters: map[string]any{
+			"type": "object",
+			"properties": map[string]any{
+				"method": map[string]any{
+					"type":        "string",
+					"enum":        []string{"GET", "POST", "PUT", "DELETE"},
+					"description": "HTTP method",
+				},
+				"path": map[string]any{
+					"type":        "string",
+					"description": "API path; include query params in path: /api/positions?trader_id=xxx",
+				},
+				"body": map[string]any{
+					"type":        "object",
+					"description": "Request body; use {} for GET requests",
+				},
+			},
+			"required": []string{"method", "path", "body"},
+		},
+	},
+}
+
+// Agent is a stateful AI agent for one Telegram chat.
+// It exposes a single "api_request" tool and runs a loop until the LLM
+// returns a plain-text reply (no tool calls).
+type Agent struct {
+	apiTool      *apiCallTool
+	getLLM       func() mcp.AIClient
+	memory       *session.Memory
+	systemPrompt string
+	userID       string
+}
+
+// New creates an Agent for one chat session.
+func New(apiPort int, botToken, userID string, getLLM func() mcp.AIClient, systemPrompt string) *Agent {
+	return &Agent{
+		apiTool:      newAPICallTool(apiPort, botToken),
+		getLLM:       getLLM,
+		memory:       session.NewMemory(getLLM()),
+		systemPrompt: systemPrompt,
+		userID:       userID,
+	}
+}
+
+// GenerateBotToken creates a long-lived JWT for the bot's internal API calls.
+// userID must match the actual registered user's ID so bot-made changes
+// are visible in the frontend (shared user namespace).
+func GenerateBotToken(userID string) (string, error) {
+	return auth.GenerateJWT(userID, "bot@internal")
+}
+
+// buildAccountContext fetches the live account state (models, exchanges, strategies, traders,
+// and per-trader account summary + statistics) and returns it as a formatted string for
+// injection into the LLM context at the start of each conversation.
+func (a *Agent) buildAccountContext() string {
+	var sb strings.Builder
+	sb.WriteString(fmt.Sprintf("[Current Account State — User: %s]\n\n", a.userID))
+
+	// ── AI Models ─────────────────────────────────────────────────────────────
+	modelsRaw := a.apiTool.execute(&apiRequest{Method: "GET", Path: "/api/models"})
+	sb.WriteString("## AI Models\n")
+	sb.WriteString("⚠️  When creating a trader, use the EXACT \"id\" value below for \"ai_model_id\".\n")
+	sb.WriteString("    DO NOT use the \"provider\" field — it is NOT a valid ai_model_id.\n\n")
+
+	var models []struct {
+		ID       string `json:"id"`
+		Name     string `json:"name"`
+		Provider string `json:"provider"`
+		Enabled  bool   `json:"enabled"`
+	}
+	if err := json.Unmarshal([]byte(modelsRaw), &models); err == nil && len(models) > 0 {
+		for _, m := range models {
+			status := "disabled"
+			if m.Enabled {
+				status = "ENABLED"
+			}
+			sb.WriteString(fmt.Sprintf("  • ai_model_id=\"%s\"  provider=%s  name=%s  [%s]\n", m.ID, m.Provider, m.Name, status))
+		}
+	} else {
+		sb.WriteString(modelsRaw)
+	}
+	sb.WriteString("\n")
+
+	// ── Exchanges ─────────────────────────────────────────────────────────────
+	exchangesRaw := a.apiTool.execute(&apiRequest{Method: "GET", Path: "/api/exchanges"})
+	sb.WriteString("## Exchanges\n")
+	sb.WriteString("⚠️  Use the EXACT \"id\" value below for \"exchange_id\" when creating a trader.\n\n")
+
+	var exchanges []struct {
+		ID           string `json:"id"`
+		Name         string `json:"name"`
+		ExchangeType string `json:"exchange_type"`
+		AccountName  string `json:"account_name"`
+		Enabled      bool   `json:"enabled"`
+	}
+	if err := json.Unmarshal([]byte(exchangesRaw), &exchanges); err == nil && len(exchanges) > 0 {
+		for _, e := range exchanges {
+			status := "disabled"
+			if e.Enabled {
+				status = "ENABLED"
+			}
+			sb.WriteString(fmt.Sprintf("  • exchange_id=\"%s\"  type=%s  account=%s  [%s]\n", e.ID, e.ExchangeType, e.AccountName, status))
+		}
+	} else {
+		sb.WriteString(exchangesRaw)
+	}
+	sb.WriteString("\n")
+
+	// ── Strategies ────────────────────────────────────────────────────────────
+	strategiesRaw := a.apiTool.execute(&apiRequest{Method: "GET", Path: "/api/strategies"})
+	sb.WriteString("## Strategies\n")
+
+	var strategies []struct {
+		ID   string `json:"id"`
+		Name string `json:"name"`
+	}
+	if err := json.Unmarshal([]byte(strategiesRaw), &strategies); err == nil && len(strategies) > 0 {
+		for _, s := range strategies {
+			sb.WriteString(fmt.Sprintf("  • strategy_id=\"%s\"  name=%s\n", s.ID, s.Name))
+		}
+	} else {
+		sb.WriteString(strategiesRaw)
+	}
+	sb.WriteString("\n")
+
+	// ── Traders ───────────────────────────────────────────────────────────────
+	tradersRaw := a.apiTool.execute(&apiRequest{Method: "GET", Path: "/api/my-traders"})
+	sb.WriteString("## Traders\n")
+
+	var traders []struct {
+		TraderID  string `json:"trader_id"`
+		Name      string `json:"trader_name"`
+		IsRunning bool   `json:"is_running"`
+	}
+	if err := json.Unmarshal([]byte(tradersRaw), &traders); err == nil && len(traders) > 0 {
+		for _, t := range traders {
+			status := "stopped"
+			if t.IsRunning {
+				status = "RUNNING"
+			}
+			sb.WriteString(fmt.Sprintf("  • trader_id=\"%s\"  name=%s  [%s]\n", t.TraderID, t.Name, status))
+		}
+	} else {
+		sb.WriteString(tradersRaw)
+	}
+	sb.WriteString("\n")
+
+	// ── Per-trader live data (running traders only) ────────────────────────────
+	for _, t := range traders {
+		if !t.IsRunning {
+			continue
+		}
+		acct := a.apiTool.execute(&apiRequest{Method: "GET", Path: "/api/account?trader_id=" + t.TraderID})
+		sb.WriteString(fmt.Sprintf("Account [%s]:\n%s\n\n", t.Name, acct))
+		stats := a.apiTool.execute(&apiRequest{Method: "GET", Path: "/api/statistics?trader_id=" + t.TraderID})
+		sb.WriteString(fmt.Sprintf("Statistics [%s]:\n%s\n\n", t.Name, stats))
+	}
+
+	return sb.String()
+}
+
+// Run processes one user message through the native function-calling agent loop.
+//
+// Architecture:
+//   - LLM receives the api_request tool definition alongside conversation history.
+//   - LLM response is EITHER ToolCalls (execute API) OR Content (final reply) — never both.
+//     This is enforced by the protocol: narration is structurally impossible.
+//   - Loop continues until the LLM returns a plain-text reply (no tool calls).
+//
+// On the first message of a conversation the live account state is fetched and injected.
+// onChunk is optional; when set it is called once with the complete final reply text.
+func (a *Agent) Run(userMessage string, onChunk func(string)) string {
+	llm := a.getLLM()
+	if llm == nil {
+		return "AI assistant unavailable. Please configure an AI model in the Web UI."
+	}
+
+	// Build initial user message: prepend account state on first turn, history on subsequent turns.
+	histCtx := a.memory.BuildContext()
+	var firstUserContent string
+	if histCtx == "" {
+		accountCtx := a.buildAccountContext()
+		firstUserContent = accountCtx + "\n[User Message]\n" + userMessage
+	} else {
+		firstUserContent = histCtx + "\n---\nUser: " + userMessage
+	}
+
+	turnMsgs := []mcp.Message{mcp.NewUserMessage(firstUserContent)}
+
+	for i := 0; i < maxIterations; i++ {
+		req, err := mcp.NewRequestBuilder().
+			WithSystemPrompt(a.systemPrompt).
+			AddConversationHistory(turnMsgs).
+			AddTool(apiRequestTool).
+			WithToolChoice("auto").
+			Build()
+		if err != nil {
+			logger.Errorf("Agent: failed to build request: %v", err)
+			break
+		}
+
+		resp, err := llm.CallWithRequestFull(req)
+		if err != nil {
+			logger.Errorf("Agent: LLM call failed (iteration %d): %v", i+1, err)
+			return "AI assistant temporarily unavailable. Please try again."
+		}
+
+		// No tool calls → LLM returned a final text reply.
+		if len(resp.ToolCalls) == 0 {
+			reply := strings.TrimSpace(resp.Content)
+			if onChunk != nil {
+				onChunk(reply)
+			}
+			a.memory.Add("user", userMessage)
+			a.memory.Add("assistant", reply)
+			return reply
+		}
+
+		// Tool call iteration — show thinking indicator.
+		if onChunk != nil {
+			onChunk("⏳")
+		}
+
+		// Append assistant message carrying the tool calls (no content field).
+		turnMsgs = append(turnMsgs, mcp.Message{
+			Role:      "assistant",
+			ToolCalls: resp.ToolCalls,
+		})
+
+		// Execute each tool call and append the results as tool messages.
+		for _, tc := range resp.ToolCalls {
+			var apiReq apiRequest
+			if err := json.Unmarshal([]byte(tc.Function.Arguments), &apiReq); err != nil {
+				logger.Errorf("Agent: invalid tool args for call %s: %v", tc.ID, err)
+				turnMsgs = append(turnMsgs, mcp.Message{
+					Role:       "tool",
+					ToolCallID: tc.ID,
+					Content:    fmt.Sprintf(`{"error":"invalid arguments: %s"}`, err.Error()),
+				})
+				continue
+			}
+			logger.Infof("Agent: iter=%d tool=%s %s %s", i+1, tc.ID, apiReq.Method, apiReq.Path)
+			result := a.apiTool.execute(&apiReq)
+			turnMsgs = append(turnMsgs, mcp.Message{
+				Role:       "tool",
+				ToolCallID: tc.ID,
+				Content:    result,
+			})
+		}
+	}
+
+	// Safety: max iterations reached.
+	logger.Warnf("Agent: max iterations (%d) reached for message: %q", maxIterations, userMessage)
+	reply := "操作已完成，请检查您的账户查看最新状态。"
+	a.memory.Add("user", userMessage)
+	a.memory.Add("assistant", reply)
+	return reply
+}
+
+// ResetMemory clears conversation history (called on /start).
+func (a *Agent) ResetMemory() {
+	a.memory.ResetFull()
+}
@@ -0,0 +1,439 @@
+package agent
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"nofx/mcp"
+)
+
+// mockLLM implements mcp.AIClient using pre-programmed LLMResponse objects.
+// Native function calling: CallWithRequestFull is the primary method;
+// CallWithRequest and CallWithRequestStream are stubs kept for interface compliance.
+type mockLLM struct {
+	responses []*mcp.LLMResponse
+	calls     int
+	lastMsgs  []mcp.Message
+}
+
+func (m *mockLLM) SetAPIKey(_, _, _ string)   {}
+func (m *mockLLM) SetTimeout(_ time.Duration) {}
+
+func (m *mockLLM) CallWithMessages(_, _ string) (string, error) { return "", nil }
+
+func (m *mockLLM) CallWithRequest(req *mcp.Request) (string, error) {
+	r, err := m.next()
+	if err != nil {
+		return "", err
+	}
+	return r.Content, nil
+}
+
+func (m *mockLLM) CallWithRequestStream(req *mcp.Request, onChunk func(string)) (string, error) {
+	r, err := m.next()
+	if err != nil {
+		return "", err
+	}
+	if onChunk != nil {
+		onChunk(r.Content)
+	}
+	return r.Content, nil
+}
+
+func (m *mockLLM) CallWithRequestFull(req *mcp.Request) (*mcp.LLMResponse, error) {
+	m.lastMsgs = req.Messages
+	return m.next()
+}
+
+func (m *mockLLM) next() (*mcp.LLMResponse, error) {
+	if m.calls < len(m.responses) {
+		r := m.responses[m.calls]
+		m.calls++
+		return r, nil
+	}
+	return &mcp.LLMResponse{Content: "OK"}, nil
+}
+
+// toolCall builds a mock LLM response that contains a single tool invocation.
+func toolCall(id, method, path string, body string) *mcp.LLMResponse {
+	if body == "" {
+		body = "{}"
+	}
+	return &mcp.LLMResponse{
+		ToolCalls: []mcp.ToolCall{{
+			ID:   id,
+			Type: "function",
+			Function: mcp.ToolCallFunction{
+				Name:      "api_request",
+				Arguments: fmt.Sprintf(`{"method":%q,"path":%q,"body":%s}`, method, path, body),
+			},
+		}},
+	}
+}
+
+// textReply builds a mock LLM response with a plain-text final answer.
+func textReply(content string) *mcp.LLMResponse {
+	return &mcp.LLMResponse{Content: content}
+}
+
+func mockGetLLM(llm *mockLLM) func() mcp.AIClient {
+	return func() mcp.AIClient { return llm }
+}
+
+const testPrompt = "You are a test assistant."
+
+// mockAPIServer creates a test HTTP server with configurable route handlers.
+func mockAPIServer(handlers map[string]string) (*httptest.Server, int) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		key := r.Method + " " + r.URL.Path
+		if body, ok := handlers[key]; ok {
+			w.Write([]byte(body)) //nolint:errcheck
+			return
+		}
+		// Also try path-only match (for GET)
+		if body, ok := handlers[r.URL.Path]; ok {
+			w.Write([]byte(body)) //nolint:errcheck
+			return
+		}
+		w.WriteHeader(http.StatusNotFound)
+		w.Write([]byte(`{"error":"not found"}`)) //nolint:errcheck
+	}))
+	var port int
+	fmt.Sscanf(srv.Listener.Addr().String(), "127.0.0.1:%d", &port)
+	return srv, port
+}
+
+// ── Basic agent behaviour ──────────────────────────────────────────────────
+
+// TestAgentDirectReply: LLM replies with text (no tool calls) — one LLM call.
+func TestAgentDirectReply(t *testing.T) {
+	llm := &mockLLM{responses: []*mcp.LLMResponse{textReply("Hello! How can I help you?")}}
+	a := New(8080, "tok", "test-user", mockGetLLM(llm), testPrompt)
+
+	reply := a.Run("hello", nil)
+
+	if reply != "Hello! How can I help you?" {
+		t.Fatalf("unexpected reply: %q", reply)
+	}
+	if llm.calls != 1 {
+		t.Fatalf("expected 1 LLM call, got %d", llm.calls)
+	}
+}
+
+// TestAgentAPICall: LLM makes one tool call, gets result, gives final reply — two LLM calls.
+func TestAgentAPICall(t *testing.T) {
+	srv, port := mockAPIServer(map[string]string{
+		"/api/my-traders": `[{"trader_id":"t1","trader_name":"BTC Trader","is_running":false}]`,
+	})
+	defer srv.Close()
+
+	llm := &mockLLM{responses: []*mcp.LLMResponse{
+		toolCall("c1", "GET", "/api/my-traders", "{}"),
+		textReply("You have one trader: BTC Trader."),
+	}}
+	a := New(port, "tok", "test-user", mockGetLLM(llm), testPrompt)
+
+	reply := a.Run("list my traders", nil)
+
+	if reply != "You have one trader: BTC Trader." {
+		t.Fatalf("unexpected reply: %q", reply)
+	}
+	if llm.calls != 2 {
+		t.Fatalf("expected 2 LLM calls, got %d", llm.calls)
+	}
+}
+
+// TestAgentMultiStep: LLM chains two tool calls before final reply — three LLM calls.
+func TestAgentMultiStep(t *testing.T) {
+	srv, port := mockAPIServer(map[string]string{
+		"/api/account":   `{"total_equity":1000}`,
+		"/api/positions": `[]`,
+	})
+	defer srv.Close()
+
+	llm := &mockLLM{responses: []*mcp.LLMResponse{
+		toolCall("c1", "GET", "/api/account", "{}"),
+		toolCall("c2", "GET", "/api/positions", "{}"),
+		textReply("Account looks healthy and no open positions."),
+	}}
+	a := New(port, "tok", "test-user", mockGetLLM(llm), testPrompt)
+
+	reply := a.Run("show me account status", nil)
+
+	if llm.calls != 3 {
+		t.Fatalf("expected 3 LLM calls (2 tool + 1 final), got %d", llm.calls)
+	}
+	if reply != "Account looks healthy and no open positions." {
+		t.Fatalf("unexpected final reply: %q", reply)
+	}
+}
+
+// TestAgentAPIResultInContext: tool result must appear as a tool message in the next LLM call.
+func TestAgentAPIResultInContext(t *testing.T) {
+	srv, port := mockAPIServer(map[string]string{
+		"/api/account": `{"balance":1234.56}`,
+	})
+	defer srv.Close()
+
+	llm := &mockLLM{responses: []*mcp.LLMResponse{
+		toolCall("c1", "GET", "/api/account", "{}"),
+		textReply("Balance is 1234.56 USDT."),
+	}}
+	a := New(port, "tok", "test-user", mockGetLLM(llm), testPrompt)
+	a.Run("show balance", nil)
+
+	// The last request must contain a tool-result message with the balance data.
+	found := false
+	for _, msg := range llm.lastMsgs {
+		if msg.Role == "tool" && strings.Contains(msg.Content, "balance") {
+			found = true
+			break
+		}
+	}
+	if !found {
+		t.Fatalf("tool result message not found in subsequent LLM context; messages: %+v", llm.lastMsgs)
+	}
+}
+
+// ── Narration-free architecture tests ─────────────────────────────────────
+
+// TestNarrationStructurallyImpossible: when ToolCalls are present in the response,
+// any Content field is ignored and never surfaced to the user.
+// In real LLM APIs, Content is always empty alongside ToolCalls, but we verify
+// our agent handles a malformed response defensively.
+func TestNarrationStructurallyImpossible(t *testing.T) {
+	srv, port := mockAPIServer(map[string]string{
+		"/api/strategies": `[{"id":"s1","name":"BTC Trend"}]`,
+	})
+	defer srv.Close()
+
+	// Simulate a (malformed) response that has both Content and ToolCalls.
+	malformed := &mcp.LLMResponse{
+		Content: "现在我将为您查询策略。", // narration — must NOT reach user
+		ToolCalls: []mcp.ToolCall{{
+			ID:   "c1",
+			Type: "function",
+			Function: mcp.ToolCallFunction{
+				Name:      "api_request",
+				Arguments: `{"method":"GET","path":"/api/strategies","body":{}}`,
+			},
+		}},
+	}
+
+	llm := &mockLLM{responses: []*mcp.LLMResponse{
+		malformed,
+		textReply("你有1个策略：BTC Trend。"),
+	}}
+	a := New(port, "tok", "test-user", mockGetLLM(llm), testPrompt)
+	reply := a.Run("查询我的策略", nil)
+
+	if strings.Contains(reply, "现在我将") {
+		t.Fatalf("narration leaked into final reply: %q", reply)
+	}
+	if reply != "你有1个策略：BTC Trend。" {
+		t.Fatalf("unexpected reply: %q", reply)
+	}
+}
+
+// TestOnChunkCalledWithFinalReply: onChunk receives the complete final reply.
+func TestOnChunkCalledWithFinalReply(t *testing.T) {
+	srv, port := mockAPIServer(map[string]string{
+		"/api/account": `{"equity":500}`,
+	})
+	defer srv.Close()
+
+	llm := &mockLLM{responses: []*mcp.LLMResponse{
+		toolCall("c1", "GET", "/api/account", "{}"),
+		textReply("Equity: 500 USDT."),
+	}}
+	a := New(port, "tok", "test-user", mockGetLLM(llm), testPrompt)
+
+	var chunks []string
+	reply := a.Run("show equity", func(chunk string) {
+		chunks = append(chunks, chunk)
+	})
+
+	if reply != "Equity: 500 USDT." {
+		t.Fatalf("unexpected reply: %q", reply)
+	}
+	// Should have received ⏳ for the tool call, then the final reply.
+	if len(chunks) < 2 {
+		t.Fatalf("expected at least 2 chunks (⏳ + final), got: %v", chunks)
+	}
+	lastChunk := chunks[len(chunks)-1]
+	if lastChunk != "Equity: 500 USDT." {
+		t.Fatalf("last chunk should be final reply, got: %q", lastChunk)
+	}
+}
+
+// ── Workflow tests ─────────────────────────────────────────────────────────
+
+// TestCreateStrategyWorkflow: simulates creating a BTC trend strategy.
+// Verifies: POST strategy → GET verify → final reply shows strategy info.
+func TestCreateStrategyWorkflow(t *testing.T) {
+	srv, port := mockAPIServer(map[string]string{
+		"POST /api/strategies":   `{"id":"s1","name":"BTC趋势"}`,
+		"GET /api/strategies/s1": `{"id":"s1","name":"BTC趋势","config":{"coin_source":{"source_type":"static","static_coins":["BTC/USDT"]},"leverage":5}}`,
+	})
+	defer srv.Close()
+
+	llm := &mockLLM{responses: []*mcp.LLMResponse{
+		toolCall("c1", "POST", "/api/strategies", `{"name":"BTC趋势","config":{}}`),
+		toolCall("c2", "GET", "/api/strategies/s1", "{}"),
+		textReply("策略已创建：BTC趋势，币种 BTC/USDT，杠杆 5x。"),
+	}}
+	a := New(port, "tok", "test-user", mockGetLLM(llm), testPrompt)
+	reply := a.Run("帮我配置个btc趋势交易的策略", nil)
+
+	if llm.calls != 3 {
+		t.Fatalf("expected 3 LLM calls, got %d", llm.calls)
+	}
+	if reply == "" {
+		t.Fatalf("empty final reply")
+	}
+}
+
+// TestFullSetupWorkflow: create strategy → verify → create trader → start trader.
+// This is the "帮我配置策略并跑起来" workflow.
+func TestFullSetupWorkflow(t *testing.T) {
+	calls := map[string]int{}
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		key := r.Method + " " + r.URL.Path
+		calls[key]++
+		switch key {
+		case "POST /api/strategies":
+			w.Write([]byte(`{"id":"s1","name":"BTC趋势"}`)) //nolint:errcheck
+		case "GET /api/strategies/s1":
+			w.Write([]byte(`{"id":"s1","name":"BTC趋势","config":{}}`)) //nolint:errcheck
+		case "POST /api/traders":
+			w.Write([]byte(`{"id":"tr1","name":"BTC趋势交易员"}`)) //nolint:errcheck
+		case "POST /api/traders/tr1/start":
+			w.Write([]byte(`{"ok":true}`)) //nolint:errcheck
+		default:
+			w.WriteHeader(http.StatusNotFound)
+		}
+	}))
+	defer srv.Close()
+	var port int
+	fmt.Sscanf(srv.Listener.Addr().String(), "127.0.0.1:%d", &port)
+
+	llm := &mockLLM{responses: []*mcp.LLMResponse{
+		toolCall("c1", "POST", "/api/strategies", `{"name":"BTC趋势"}`),
+		toolCall("c2", "GET", "/api/strategies/s1", "{}"),
+		toolCall("c3", "POST", "/api/traders", `{"name":"BTC趋势交易员","strategy_id":"s1"}`),
+		toolCall("c4", "POST", "/api/traders/tr1/start", "{}"),
+		textReply("策略和交易员已创建并启动！BTC趋势交易员正在运行。"),
+	}}
+	a := New(port, "tok", "test-user", mockGetLLM(llm), testPrompt)
+	reply := a.Run("帮我配置个btc趋势交易的策略交易 跑起来", nil)
+
+	if llm.calls != 5 {
+		t.Fatalf("expected 5 LLM calls, got %d", llm.calls)
+	}
+	if calls["POST /api/strategies"] != 1 {
+		t.Errorf("expected 1 POST /api/strategies, got %d", calls["POST /api/strategies"])
+	}
+	if calls["POST /api/traders"] != 1 {
+		t.Errorf("expected 1 POST /api/traders, got %d", calls["POST /api/traders"])
+	}
+	if calls["POST /api/traders/tr1/start"] != 1 {
+		t.Errorf("expected 1 POST /api/traders/tr1/start, got %d", calls["POST /api/traders/tr1/start"])
+	}
+	if reply == "" {
+		t.Fatalf("empty final reply")
+	}
+}
+
+// TestStartExistingTrader: when trader already exists, just start it.
+func TestStartExistingTrader(t *testing.T) {
+	calls := map[string]int{}
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		key := r.Method + " " + r.URL.Path
+		calls[key]++
+		switch key {
+		case "GET /api/my-traders":
+			w.Write([]byte(`[{"trader_id":"tr1","trader_name":"BTC Trader","is_running":false}]`)) //nolint:errcheck
+		case "POST /api/traders/tr1/start":
+			w.Write([]byte(`{"ok":true}`)) //nolint:errcheck
+		default:
+			w.WriteHeader(http.StatusNotFound)
+		}
+	}))
+	defer srv.Close()
+	var port int
+	fmt.Sscanf(srv.Listener.Addr().String(), "127.0.0.1:%d", &port)
+
+	llm := &mockLLM{responses: []*mcp.LLMResponse{
+		toolCall("c1", "GET", "/api/my-traders", "{}"),
+		toolCall("c2", "POST", "/api/traders/tr1/start", "{}"),
+		textReply("交易员 BTC Trader 已启动。"),
+	}}
+	a := New(port, "tok", "test-user", mockGetLLM(llm), testPrompt)
+	reply := a.Run("启动交易员", nil)
+
+	if calls["POST /api/traders/tr1/start"] != 1 {
+		t.Errorf("expected trader to be started, got %d start calls", calls["POST /api/traders/tr1/start"])
+	}
+	if reply != "交易员 BTC Trader 已启动。" {
+		t.Fatalf("unexpected reply: %q", reply)
+	}
+}
+
+// ── Safety limit ───────────────────────────────────────────────────────────
+
+// TestMaxIterations: agent terminates after maxIterations and returns fallback message.
+func TestMaxIterations(t *testing.T) {
+	srv, port := mockAPIServer(map[string]string{
+		"/api/account": `{"ok":true}`,
+	})
+	defer srv.Close()
+
+	// Always returns another tool call — should hit max iterations.
+	responses := make([]*mcp.LLMResponse, maxIterations+2)
+	for i := range responses {
+		responses[i] = toolCall(fmt.Sprintf("c%d", i), "GET", "/api/account", "{}")
+	}
+
+	llm := &mockLLM{responses: responses}
+	a := New(port, "tok", "test-user", mockGetLLM(llm), testPrompt)
+	reply := a.Run("loop forever", nil)
+
+	if reply == "" {
+		t.Fatalf("expected a fallback reply, got empty string")
+	}
+	// Agent should have made exactly maxIterations tool-call LLM calls.
+	if llm.calls != maxIterations {
+		t.Fatalf("expected %d LLM calls (max iterations), got %d", maxIterations, llm.calls)
+	}
+}
+
+// TestToolCallIDPropagated: tool result messages carry the correct ToolCallID.
+func TestToolCallIDPropagated(t *testing.T) {
+	srv, port := mockAPIServer(map[string]string{
+		"/api/account": `{"balance":999}`,
+	})
+	defer srv.Close()
+
+	llm := &mockLLM{responses: []*mcp.LLMResponse{
+		toolCall("call-xyz-123", "GET", "/api/account", "{}"),
+		textReply("Balance is 999."),
+	}}
+	a := New(port, "tok", "test-user", mockGetLLM(llm), testPrompt)
+	a.Run("check balance", nil)
+
+	// Find the tool result message and verify ToolCallID matches.
+	found := false
+	for _, msg := range llm.lastMsgs {
+		if msg.Role == "tool" && msg.ToolCallID == "call-xyz-123" {
+			found = true
+			break
+		}
+	}
+	if !found {
+		t.Fatalf("tool result with ToolCallID='call-xyz-123' not found in messages: %+v", llm.lastMsgs)
+	}
+}
@@ -0,0 +1,88 @@
+package agent
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"nofx/logger"
+	"strings"
+	"time"
+)
+
+// apiCallTool executes HTTP requests against the NOFX API server.
+// This is the only tool available to the agent.
+type apiCallTool struct {
+	baseURL string
+	token   string
+	client  *http.Client
+}
+
+// apiRequest holds the arguments decoded from the LLM's api_request tool call.
+type apiRequest struct {
+	Method string         `json:"method"`
+	Path   string         `json:"path"`
+	Body   map[string]any `json:"body"`
+}
+
+func newAPICallTool(port int, token string) *apiCallTool {
+	return &apiCallTool{
+		baseURL: fmt.Sprintf("http://127.0.0.1:%d", port),
+		token:   token,
+		client:  &http.Client{Timeout: 30 * time.Second},
+	}
+}
+
+// execute calls the API and returns the response as a string for LLM consumption.
+func (t *apiCallTool) execute(req *apiRequest) string {
+	if req.Method == "" || req.Path == "" {
+		return "error: method and path are required"
+	}
+	if !strings.HasPrefix(req.Path, "/") {
+		req.Path = "/" + req.Path
+	}
+
+	var bodyReader io.Reader
+	if req.Method != "GET" && len(req.Body) > 0 {
+		b, err := json.Marshal(req.Body)
+		if err != nil {
+			return fmt.Sprintf("error marshaling body: %v", err)
+		}
+		bodyReader = bytes.NewReader(b)
+	}
+
+	httpReq, err := http.NewRequest(req.Method, t.baseURL+req.Path, bodyReader)
+	if err != nil {
+		return fmt.Sprintf("error creating request: %v", err)
+	}
+	httpReq.Header.Set("Content-Type", "application/json")
+	httpReq.Header.Set("Authorization", "Bearer "+t.token)
+
+	resp, err := t.client.Do(httpReq)
+	if err != nil {
+		return fmt.Sprintf("API call failed: %v", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Sprintf("error reading response: %v", err)
+	}
+
+	logger.Infof("Agent api_call: %s %s -> %d", req.Method, req.Path, resp.StatusCode)
+
+	if resp.StatusCode >= 400 {
+		return fmt.Sprintf("API error %d: %s", resp.StatusCode, string(body))
+	}
+
+	// Pretty-print JSON for better LLM readability
+	var v any
+	if json.Unmarshal(body, &v) == nil {
+		if pretty, err := json.MarshalIndent(v, "", "  "); err == nil {
+			return string(pretty)
+		}
+	}
+	return string(body)
+}
+
@@ -0,0 +1,79 @@
+package agent
+
+import (
+	"nofx/logger"
+	"nofx/mcp"
+	"sync"
+	"time"
+)
+
+// Manager holds one Agent per Telegram chat ID.
+// Messages for the same chat are serialized (OpenClaw Lane Queue pattern).
+type Manager struct {
+	mu           sync.Mutex
+	agents       map[int64]*Agent
+	lanes        map[int64]chan struct{}
+	apiPort      int
+	botToken     string
+	userID       string
+	getLLM       func() mcp.AIClient
+	systemPrompt string
+}
+
+// NewManager creates a Manager. Call api.GetAPIDocs() before this and pass the result as apiDocs.
+// userEmail is the registered email shown to the user when they ask "who am I".
+// userID is the internal DB UUID used for API authentication.
+func NewManager(apiPort int, botToken, userEmail, userID string, getLLM func() mcp.AIClient, apiDocs string) *Manager {
+	return &Manager{
+		agents:       make(map[int64]*Agent),
+		lanes:        make(map[int64]chan struct{}),
+		apiPort:      apiPort,
+		botToken:     botToken,
+		userID:       userID,
+		getLLM:       getLLM,
+		systemPrompt: BuildAgentPrompt(apiDocs, userEmail, userID),
+	}
+}
+
+// Run processes a message for the given chat ID.
+// If the same chat is already processing a message, this call blocks until it completes
+// or the lane wait times out (60 s), whichever comes first.
+// onChunk is optional — when set, LLM reply chunks are forwarded progressively (SSE streaming).
+func (m *Manager) Run(chatID int64, userMessage string, onChunk func(string)) string {
+	a, lane := m.getOrCreate(chatID)
+	select {
+	case lane <- struct{}{}:
+	case <-time.After(60 * time.Second):
+		logger.Warnf("Agent: lane wait timeout for chat %d — previous message still processing", chatID)
+		return "上一条消息仍在处理中，请稍等片刻后再试。"
+	}
+	defer func() { <-lane }()
+	return a.Run(userMessage, onChunk)
+}
+
+// Reset clears memory for the given chat (called on /start).
+func (m *Manager) Reset(chatID int64) {
+	m.mu.Lock()
+	a, ok := m.agents[chatID]
+	m.mu.Unlock()
+	if ok {
+		a.ResetMemory()
+	}
+}
+
+func (m *Manager) getOrCreate(chatID int64) (*Agent, chan struct{}) {
+	m.mu.Lock()
+	defer m.mu.Unlock()
+
+	a, ok := m.agents[chatID]
+	if !ok {
+		a = New(m.apiPort, m.botToken, m.userID, m.getLLM, m.systemPrompt)
+		m.agents[chatID] = a
+	}
+	lane, ok := m.lanes[chatID]
+	if !ok {
+		lane = make(chan struct{}, 1) // binary semaphore: one message at a time per chat
+		m.lanes[chatID] = lane
+	}
+	return a, lane
+}
@@ -0,0 +1,97 @@
+package agent
+
+import "fmt"
+
+// BuildAgentPrompt constructs the full system prompt with live API documentation injected.
+// apiDocs is the output of api.GetAPIDocs() — reflects all currently registered routes with full schemas.
+// userEmail is the registered email of the bound user (shown when user asks "who am I").
+// userID is the internal DB UUID used for API authentication only.
+func BuildAgentPrompt(apiDocs, userEmail, userID string) string {
+	return fmt.Sprintf(`You are the NOFX quantitative trading system AI assistant.
+
+## Your Identity
+- You are operating as: %s
+- Internal user ID (for API calls only): %s
+- When asked "which user / account / email" — answer with the email address above
+- All API calls are made on behalf of this user
+
+## Tool: api_request
+Use the api_request tool to call the NOFX REST API:
+- method: "GET" | "POST" | "PUT" | "DELETE"
+- path: API path; query params go in the path: /api/positions?trader_id=xxx
+- body: JSON object (use {} for GET requests)
+
+## NOFX API Documentation
+
+%s
+
+## CRITICAL: Exact ID Rule (read this before every API call)
+API fields like "ai_model_id", "exchange_id", "strategy_id", "trader_id" require the EXACT "id" value
+from the corresponding API response. NEVER use "provider", "type", or any other field as a substitute.
+
+Wrong:  {"ai_model_id": "deepseek"}          ← "deepseek" is the provider, NOT the id
+Correct: {"ai_model_id": "abc123_deepseek"}  ← full "id" from GET /api/models
+
+The Account State block at the start of this conversation lists every resource with its exact id.
+Read the id field from there and copy it verbatim — do not abbreviate, shorten, or guess.
+
+## Behavior Rules
+1. Reply in the same language the user used (中文→中文, English→English)
+2. Keep final replies concise — show results, not process
+3. Ask for ALL missing required info in ONE message — never ask one field at a time
+4. When user provides enough info, act immediately — no confirmation needed
+5. Be decisive — infer intent from context, use schema to fill in smart defaults
+
+## Verification Rule (CRITICAL)
+After ANY PUT or POST that creates or modifies a resource:
+1. Immediately GET the resource to read actual saved values
+2. Show the user the KEY fields they care about from the GET response
+3. NEVER just say "updated successfully" without showing the actual values
+4. If saved values look wrong, correct them automatically
+
+## Error Handling
+- 400: explain what was wrong, ask user to correct
+- 404: resource doesn't exist — you may have used the wrong ID format; check the Account State for the exact id
+- "AI model not enabled": tell user to enable the model first via PUT /api/models
+- "Exchange not enabled": tell user to enable the exchange first
+- 5xx: server error, ask user to try again
+
+## Account State (injected at conversation start)
+At the start of each new conversation, a [Current Account State] block is provided with:
+- AI Models: all configured models with their IDs and enabled status
+- Exchanges: all configured exchanges with their IDs and enabled status
+- Strategies: all existing strategies with their IDs
+- Traders: all existing traders with their IDs and running status
+
+Use this to:
+- NEVER ask for exchange/model info that is already configured — use the existing IDs directly
+- Know instantly if the user has 0 or N resources of each type
+- If only one exchange/model exists and user doesn't specify, use it directly without asking
+- If multiple exist, list them and ask which one to use
+
+## Common Workflows
+
+**Create strategy** (independent from traders):
+- Never GET trader info just to create a strategy.
+- POST {"name":"<descriptive name>"} — config is OPTIONAL. Backend applies complete working defaults automatically (ai500 top coins, all indicators, standard risk control). Strategy is immediately usable.
+- Only include "config" when user explicitly requests custom settings (specific coins, custom leverage, different timeframes).
+- After POST: GET /api/strategies/:id to verify → show user: name, coin_source.source_type, key risk_control values
+
+**"帮我配置策略并跑起来" / "create strategy and start" (full setup workflow)**:
+Execute these steps IN ORDER with NO user confirmation between them:
+1. POST /api/strategies — body: {"name":"<descriptive name>"} — no config needed, defaults are complete
+2. GET /api/strategies/:id — verify strategy was saved
+3. POST /api/traders — create trader: use exchange_id and model_id from Account State (if only one each, use directly); set strategy_id from step 1; set name matching the strategy
+4. POST /api/traders/:id/start — start the trader
+5. Final reply: show strategy name, trader name, coin source, confirm running
+
+**Update strategy config**:
+1. GET /api/strategies/:id to read current full config
+2. Modify only what user asked (keep all other fields)
+3. PUT /api/strategies/:id with complete merged config
+4. GET /api/strategies/:id to verify → show user actual saved values for changed fields
+
+**Start/stop existing trader**: From Account State, if only one trader, act directly. If multiple, list and ask.
+
+**Query data**: Use trader_id from Account State, then query /api/positions?trader_id=xxx or /api/account?trader_id=xxx etc.`, userEmail, userID, apiDocs)
+}
@@ -0,0 +1,479 @@
+package telegram
+
+import (
+	"nofx/api"
+	"nofx/config"
+	"nofx/logger"
+	"nofx/mcp"
+	"nofx/store"
+	"nofx/telegram/agent"
+	"os"
+	"strings"
+	"sync"
+	"time"
+
+	tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
+)
+
+// Start initializes and runs the Telegram bot in a blocking supervisor loop.
+// Supports hot-reload: when a signal is sent on reloadCh, the bot restarts
+// with the latest token (re-read from DB or env). Must be called as a goroutine from main.go.
+func Start(cfg *config.Config, st *store.Store, reloadCh <-chan struct{}) {
+	for {
+		token := resolveToken(cfg, st)
+		if token == "" {
+			logger.Info("Telegram bot disabled (no token configured), waiting for reload signal...")
+			<-reloadCh
+			continue
+		}
+
+		stopped := runBot(token, cfg, st)
+		if !stopped {
+			return
+		}
+
+		select {
+		case <-reloadCh:
+			logger.Info("Reloading Telegram bot with new token...")
+		}
+	}
+}
+
+// resolveToken returns the bot token from DB (configured via Web UI).
+func resolveToken(cfg *config.Config, st *store.Store) string {
+	dbCfg, err := st.TelegramConfig().Get()
+	if err == nil && dbCfg.BotToken != "" {
+		return dbCfg.BotToken
+	}
+	return ""
+}
+
+// runBot runs the bot until the updates channel closes (clean stop → true) or a fatal error (false).
+func runBot(token string, cfg *config.Config, st *store.Store) bool {
+	bot, err := tgbotapi.NewBotAPI(token)
+	if err != nil {
+		logger.Errorf("Telegram bot failed to start: %v", err)
+		return false
+	}
+	logger.Infof("Telegram bot @%s started", bot.Self.UserName)
+
+	// Allowed chat ID: read from DB binding (0 = unbound, first /start will bind).
+	allowedChatID := int64(0)
+	if id, err := st.TelegramConfig().GetBoundChatID(); err == nil && id != 0 {
+		allowedChatID = id
+	}
+
+	// botUserID / botToken / agents are resolved lazily and refresh when user registers.
+	var (
+		botUserID    string
+		botUserEmail string
+		botToken     string
+		agents       *agent.Manager
+	)
+
+	resolveBotUser := func() bool {
+		users, err := st.User().GetAll()
+		if err != nil || len(users) == 0 {
+			return false
+		}
+		u := users[0]
+		if u.ID == botUserID {
+			return true
+		}
+		newToken, err := agent.GenerateBotToken(u.ID)
+		if err != nil {
+			logger.Errorf("Failed to generate bot JWT for user %s: %v", u.ID, err)
+			return false
+		}
+		prev := botUserID
+		botUserID = u.ID
+		botUserEmail = u.Email
+		botToken = newToken
+		agents = agent.NewManager(cfg.APIServerPort, botToken, botUserEmail, botUserID,
+			func() mcp.AIClient { return newLLMClient(st, botUserID) },
+			api.GetAPIDocs(),
+		)
+		if prev == "" {
+			logger.Infof("Bot: resolved user %s (%s)", botUserID, botUserEmail)
+		} else {
+			logger.Infof("Bot: user changed → %s (%s)", botUserID, botUserEmail)
+		}
+		return true
+	}
+	resolveBotUser()
+
+	u := tgbotapi.NewUpdate(0)
+	u.Timeout = 60
+	updates := bot.GetUpdatesChan(u)
+
+	// awaitingLang is set only when the user explicitly runs /lang.
+	awaitingLang := false
+
+	for update := range updates {
+		if update.Message == nil {
+			continue
+		}
+		chatID := update.Message.Chat.ID
+		text := strings.TrimSpace(update.Message.Text)
+
+		// ── Language selection (triggered only by /lang) ──────────────────────
+		if awaitingLang && chatID == allowedChatID {
+			if lang := parseLangChoice(text); lang != "" {
+				awaitingLang = false
+				st.TelegramConfig().SetLanguage(lang) //nolint:errcheck
+				sendMarkdownMsg(bot, chatID, statusMsg(st, botUserID, cfg.APIServerPort, lang))
+			} else {
+				sendMarkdownMsg(bot, chatID, langMenuMsg())
+			}
+			continue
+		}
+
+		// ── /start ────────────────────────────────────────────────────────────
+		if text == "/start" {
+			resolveBotUser()
+			if botUserID == "" {
+				sendMsg(bot, chatID,
+					"No account found.\nOpen the web dashboard to register, then send /start.")
+				continue
+			}
+			if allowedChatID == 0 {
+				username := update.Message.From.UserName
+				if err := st.TelegramConfig().BindUser(chatID, "@"+username); err != nil {
+					logger.Errorf("Failed to bind Telegram user: %v", err)
+					sendMsg(bot, chatID, "Binding failed. Please try again.")
+					continue
+				}
+				allowedChatID = chatID
+				logger.Infof("Telegram bound to @%s (chatID: %d)", username, chatID)
+			} else if chatID != allowedChatID {
+				sendMsg(bot, chatID, "This bot is already bound to another account.")
+				continue
+			} else {
+				agents.Reset(chatID)
+			}
+			lang := st.TelegramConfig().GetLanguage()
+			sendMarkdownMsg(bot, chatID, statusMsg(st, botUserID, cfg.APIServerPort, lang))
+			continue
+		}
+
+		// ── /lang ─────────────────────────────────────────────────────────────
+		if text == "/lang" {
+			awaitingLang = true
+			sendMarkdownMsg(bot, chatID, langMenuMsg())
+			continue
+		}
+
+		// ── /help ─────────────────────────────────────────────────────────────
+		if text == "/help" {
+			lang := st.TelegramConfig().GetLanguage()
+			sendMarkdownMsg(bot, chatID, helpMsg(lang))
+			continue
+		}
+
+		// ── Access control ────────────────────────────────────────────────────
+		if allowedChatID != 0 && chatID != allowedChatID {
+			sendMsg(bot, chatID, "Unauthorized.")
+			continue
+		}
+		if allowedChatID == 0 {
+			sendMsg(bot, chatID, "Send /start first.")
+			continue
+		}
+		if text == "" {
+			continue
+		}
+
+		// ── Refresh user before every AI call ────────────────────────────────
+		resolveBotUser()
+		if botUserID == "" {
+			sendMsg(bot, chatID, "No account found. Open the web dashboard to register.")
+			continue
+		}
+
+		lang := st.TelegramConfig().GetLanguage()
+
+		// ── Guard: show status if not ready for trading ───────────────────────
+		if newLLMClient(st, botUserID) == nil {
+			sendMarkdownMsg(bot, chatID, statusMsg(st, botUserID, cfg.APIServerPort, lang))
+			continue
+		}
+
+		// ── AI agent ─────────────────────────────────────────────────────────
+		go func(chatID int64, text string) {
+			sent, err := bot.Send(tgbotapi.NewMessage(chatID, "⏳"))
+			placeholderID := 0
+			if err == nil {
+				placeholderID = sent.MessageID
+			}
+
+			var (
+				mu       sync.Mutex
+				lastEdit time.Time
+			)
+			onChunk := func(accumulated string) {
+				if placeholderID == 0 {
+					return
+				}
+				mu.Lock()
+				defer mu.Unlock()
+				if accumulated != "⏳" && time.Since(lastEdit) < time.Second {
+					return
+				}
+				lastEdit = time.Now()
+				edit := tgbotapi.NewEditMessageText(chatID, placeholderID, accumulated)
+				bot.Send(edit) //nolint:errcheck
+			}
+
+			reply := agents.Run(chatID, text, onChunk)
+
+			if placeholderID != 0 {
+				edit := tgbotapi.NewEditMessageText(chatID, placeholderID, reply)
+				edit.ParseMode = "Markdown"
+				if _, err := bot.Send(edit); err != nil {
+					edit2 := tgbotapi.NewEditMessageText(chatID, placeholderID, reply)
+					bot.Send(edit2) //nolint:errcheck
+				}
+			} else {
+				msg := tgbotapi.NewMessage(chatID, reply)
+				msg.ParseMode = "Markdown"
+				if _, err := bot.Send(msg); err != nil {
+					msg.ParseMode = ""
+					bot.Send(msg) //nolint:errcheck
+				}
+			}
+		}(chatID, text)
+	}
+
+	return true
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+func sendMsg(bot *tgbotapi.BotAPI, chatID int64, text string) {
+	msg := tgbotapi.NewMessage(chatID, text)
+	bot.Send(msg) //nolint:errcheck
+}
+
+func sendMarkdownMsg(bot *tgbotapi.BotAPI, chatID int64, text string) {
+	msg := tgbotapi.NewMessage(chatID, text)
+	msg.ParseMode = "Markdown"
+	if _, err := bot.Send(msg); err != nil {
+		plain := tgbotapi.NewMessage(chatID, text)
+		bot.Send(plain) //nolint:errcheck
+	}
+}
+
+// ── LLM client ───────────────────────────────────────────────────────────────
+
+func newLLMClient(st *store.Store, userID string) mcp.AIClient {
+	// 1. Prefer the model explicitly configured for Telegram (Settings → Telegram → AI Model)
+	if tgCfg, err := st.TelegramConfig().Get(); err == nil && tgCfg.ModelID != "" {
+		if model, err := st.AIModel().Get(userID, tgCfg.ModelID); err == nil && model.Enabled {
+			apiKey := string(model.APIKey)
+			if apiKey != "" {
+				client := clientForProvider(model.Provider)
+				client.SetAPIKey(apiKey, model.CustomAPIURL, model.CustomModelName)
+				if isUSDCProvider(model.Provider) {
+					logger.Infof("Telegram agent: provider=%s (USDC payment) user=%s", model.Provider, userID)
+				} else {
+					logger.Infof("Telegram agent: provider=%s user=%s", model.Provider, userID)
+				}
+				return client
+			}
+		}
+	}
+
+	// 2. Fall back to first enabled model
+	if model, err := st.AIModel().GetDefault(userID); err == nil {
+		apiKey := string(model.APIKey)
+		if apiKey != "" {
+			client := clientForProvider(model.Provider)
+			client.SetAPIKey(apiKey, model.CustomAPIURL, model.CustomModelName)
+			if isUSDCProvider(model.Provider) {
+				logger.Infof("Telegram agent: provider=%s (USDC payment) user=%s", model.Provider, userID)
+			} else {
+				logger.Infof("Telegram agent: provider=%s user=%s", model.Provider, userID)
+			}
+			return client
+		}
+	}
+
+	// 3. Environment variable fallback
+	for _, pair := range []struct{ provider, key, url string }{
+		{"deepseek", os.Getenv("DEEPSEEK_API_KEY"), mcp.DefaultDeepSeekBaseURL},
+		{"openai", os.Getenv("OPENAI_API_KEY"), ""},
+		{"claude", os.Getenv("ANTHROPIC_API_KEY"), ""},
+	} {
+		if pair.key != "" {
+			client := clientForProvider(pair.provider)
+			client.SetAPIKey(pair.key, pair.url, "")
+			return client
+		}
+	}
+	return nil
+}
+
+// isUSDCProvider returns true for providers that pay per call with USDC (x402 protocol).
+func isUSDCProvider(provider string) bool {
+	return provider == "blockrun-base" || provider == "blockrun-sol" || provider == "claw402"
+}
+
+func clientForProvider(provider string) mcp.AIClient {
+	switch provider {
+	case "openai":
+		return mcp.NewOpenAIClient()
+	case "deepseek":
+		return mcp.NewDeepSeekClient()
+	case "claude":
+		return mcp.NewClaudeClient()
+	case "qwen":
+		return mcp.NewQwenClient()
+	case "kimi":
+		return mcp.NewKimiClient()
+	case "grok":
+		return mcp.NewGrokClient()
+	case "gemini":
+		return mcp.NewGeminiClient()
+	case "minimax":
+		return mcp.NewMiniMaxClient()
+	case "blockrun-base":
+		return mcp.NewBlockRunBaseClient()
+	case "blockrun-sol":
+		return mcp.NewBlockRunSolClient()
+	case "claw402":
+		return mcp.NewClaw402Client()
+	default:
+		return mcp.NewDeepSeekClient()
+	}
+}
+
+// ── Status message ────────────────────────────────────────────────────────────
+
+// statusMsg is the single entry-point message shown after /start.
+// It checks what's configured and shows either a setup prompt or the ready state.
+func statusMsg(st *store.Store, userID string, apiPort int, lang string) string {
+	webURL := "http://localhost:3000"
+
+	// Determine what's missing.
+	hasModel := false
+	if _, err := st.AIModel().GetDefault(userID); err == nil {
+		hasModel = true
+	}
+
+	hasExchange := false
+	if exchanges, err := st.Exchange().List(userID); err == nil {
+		for _, e := range exchanges {
+			if e.Enabled {
+				hasExchange = true
+				break
+			}
+		}
+	}
+
+	if !hasModel || !hasExchange {
+		missing := ""
+		if lang == "zh" {
+			if !hasModel {
+				missing += "\n❌ AI 模型 → 设置 → AI 模型 → 添加"
+			}
+			if !hasExchange {
+				missing += "\n❌ 交易所 → 设置 → 交易所 → 添加"
+			}
+			return "⚙️ *需要完成初始配置*\n\n打开 Web 管理界面完成配置：\n→ " + webURL + "\n" + missing + "\n\n配置完成后发送 /start"
+		}
+		if !hasModel {
+			missing += "\n❌ AI Model → Settings → AI Models → Add"
+		}
+		if !hasExchange {
+			missing += "\n❌ Exchange → Settings → Exchanges → Add"
+		}
+		return "⚙️ *Setup required*\n\nOpen the web dashboard to complete setup:\n→ " + webURL + "\n" + missing + "\n\nSend /start when done."
+	}
+
+	// All configured — show ready state.
+	if lang == "zh" {
+		return `✅ *NOFX 就绪，开始交易吧！*
+
+直接告诉我你想做什么：
+
+📊 "查看我的持仓"
+💰 "账户余额多少"
+🤖 "帮我创建 BTC 趋势策略并启动"
+⏹ "停止所有交易员"
+
+/help 查看更多 · /lang 切换语言`
+	}
+	return `✅ *NOFX is ready!*
+
+Just tell me what you want:
+
+📊 "Show my positions"
+💰 "What's my balance?"
+🤖 "Create a BTC trend strategy and start it"
+⏹ "Stop all traders"
+
+/help for more · /lang to change language`
+}
+
+// ── Language ──────────────────────────────────────────────────────────────────
+
+func langMenuMsg() string {
+	return "🌐 *Choose your language*\n\n1 — English\n2 — 中文\n\nReply with 1 or 2"
+}
+
+func parseLangChoice(text string) string {
+	switch strings.TrimSpace(text) {
+	case "1", "en", "EN", "English", "english":
+		return "en"
+	case "2", "zh", "ZH", "中文", "chinese", "Chinese":
+		return "zh"
+	}
+	return ""
+}
+
+// ── Help ──────────────────────────────────────────────────────────────────────
+
+func helpMsg(lang string) string {
+	if lang == "zh" {
+		return `*NOFX 使用指南*
+
+*查询*
+• "查看我的持仓"
+• "账户余额多少"
+• "列出我的交易员"
+
+*创建 & 启动*
+• "帮我创建 BTC 趋势策略并跑起来"
+• "保守型策略，只交易 BTC 和 ETH"
+
+*控制*
+• "启动交易员"
+• "暂停交易员"
+• "停止所有交易"
+
+*命令*
+/start — 刷新状态
+/lang  — 切换语言
+/help  — 帮助`
+	}
+	return `*NOFX Help*
+
+*Query*
+• "Show my positions"
+• "What's my balance?"
+• "List my traders"
+
+*Create & start*
+• "Create a BTC trend strategy and start it"
+• "Conservative strategy, BTC and ETH only"
+
+*Control*
+• "Start trader"
+• "Stop trader"
+• "Stop all trading"
+
+*Commands*
+/start — refresh status
+/lang  — change language
+/help  — show this`
+}
@@ -0,0 +1,105 @@
+package session
+
+import (
+	"fmt"
+	"nofx/mcp"
+	"strings"
+)
+
+const (
+	compactionThresholdTokens = 3000
+	charsPerToken             = 3 // rough estimate for token counting
+)
+
+type Message struct {
+	Role    string // "user" or "assistant"
+	Content string
+}
+
+// Memory manages conversation history with automatic compaction.
+// Inspired by openclaw's compaction pattern:
+// when ShortTerm exceeds threshold, LLM silently summarizes it into LongTerm.
+type Memory struct {
+	LongTerm  string    // Durable summary (survives compaction, user never sees this happen)
+	ShortTerm []Message // Recent conversation (cleared on compaction)
+	llm       mcp.AIClient
+}
+
+func NewMemory(llm mcp.AIClient) *Memory {
+	return &Memory{llm: llm}
+}
+
+// Add appends a message and triggers compaction if threshold exceeded
+func (m *Memory) Add(role, content string) {
+	m.ShortTerm = append(m.ShortTerm, Message{Role: role, Content: content})
+	if m.estimateTokens() > compactionThresholdTokens {
+		m.compact()
+	}
+}
+
+// BuildContext returns context string for the agent's conversation history.
+func (m *Memory) BuildContext() string {
+	var sb strings.Builder
+	if m.LongTerm != "" {
+		sb.WriteString("[Summary of earlier conversation]\n")
+		sb.WriteString(m.LongTerm)
+		sb.WriteString("\n\n")
+	}
+	if len(m.ShortTerm) > 0 {
+		sb.WriteString("[Recent conversation]\n")
+		for _, msg := range m.ShortTerm {
+			sb.WriteString(fmt.Sprintf("%s: %s\n", msg.Role, msg.Content))
+		}
+	}
+	return sb.String()
+}
+
+// Reset clears short-term history (LongTerm preserved intentionally)
+func (m *Memory) Reset() {
+	m.ShortTerm = []Message{}
+}
+
+// ResetFull clears everything including long-term memory
+func (m *Memory) ResetFull() {
+	m.ShortTerm = []Message{}
+	m.LongTerm = ""
+}
+
+func (m *Memory) estimateTokens() int {
+	total := len(m.LongTerm)
+	for _, msg := range m.ShortTerm {
+		total += len(msg.Content)
+	}
+	return total / charsPerToken
+}
+
+// compact summarizes short-term history into long-term memory.
+// This runs silently - the user never sees it happen.
+// If LLM call fails, short-term is preserved as-is (no data loss).
+func (m *Memory) compact() {
+	if m.llm == nil || len(m.ShortTerm) == 0 {
+		return
+	}
+	history := m.BuildContext()
+	systemPrompt := `You are a conversation summarizer. Compress the following trading assistant conversation into a concise summary.
+
+Must preserve:
+- What the user is configuring (strategy/exchange/model/trader)
+- Confirmed parameters (trading pairs, leverage, stop loss, indicators, etc.)
+- Pending or missing parameters
+- User preferences and requirements
+
+Output: plain text summary, under 200 words.`
+
+	summary, err := m.llm.CallWithMessages(systemPrompt, history)
+	if err != nil {
+		// Compaction failed: keep short-term as-is, never lose user data
+		return
+	}
+	if m.LongTerm != "" {
+		m.LongTerm = m.LongTerm + "\n" + summary
+	} else {
+		m.LongTerm = summary
+	}
+	m.ShortTerm = []Message{}
+}