feat: Phase 3 插件与工具系统 — Plugin SDK + Plugin Manager + 13内置插件 (40文件, 3293行)

- Plugin SDK: Plugin/Tool/ComplexTool/HostAPI 标准化接口
- Plugin Manager: 插件生命周期管理 (Install/Enable/Disable/Uninstall/Reload)
- Tool Registry: 聚合工具注册表 (Register/Execute/Dispatch)
- 13 个内置插件: 将原有硬编码工具迁移为标准插件格式
- REST API: 11 个端点 (net/http, 零外部依赖)
- ai-core 集成: PluginManagerClient 替代本地工具调用
- plugin.json 元数据: 每个插件含完整 author/version/category/permissions

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

backend/plugin-manager/plugins/calculator/plugin.go

@@ -0,0 +1,279 @@
+package calculator
+
+import (
+	"context"
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+	"unicode"
+
+	"github.com/yourname/cyrene-ai/plugin-manager/internal/sdk"
+)
+
+type CalculatorPlugin struct {
+	sdk.BasePlugin
+}
+
+func (p *CalculatorPlugin) Metadata() sdk.PluginMetadata {
+	return sdk.PluginMetadata{
+		Name: "calculator", DisplayName: "Calculator", Version: "1.0.0",
+		Description: "Safe mathematical expression evaluation with custom parser",
+		Category: "utility", Author: sdk.PluginAuthor{Name: "Cyrene Team"},
+	}
+}
+
+func (p *CalculatorPlugin) Tools() []sdk.Tool {
+	return []sdk.Tool{&CalculatorTool{}}
+}
+
+type CalculatorTool struct {
+	sdk.BaseTool
+}
+
+func (t *CalculatorTool) Definition() sdk.ToolDefinition {
+	return sdk.ToolDefinition{
+		ID: "calculator", Name: "calculator", DisplayName: "Calculator",
+		Description: "Execute mathematical calculations. Supports arithmetic, trig, logs, powers.",
+		Category: "utility", Complexity: sdk.ComplexitySimple,
+		Parameters: map[string]interface{}{
+			"type": "object", "properties": map[string]interface{}{"expression": map[string]interface{}{"type": "string"}},
+			"required": []string{"expression"},
+		},
+	}
+}
+
+func (t *CalculatorTool) Validate(args map[string]interface{}) error {
+	if _, ok := args["expression"]; !ok {
+		return fmt.Errorf("missing required parameter: expression")
+	}
+	return nil
+}
+
+func (t *CalculatorTool) Execute(_ context.Context, args map[string]interface{}) (*sdk.ToolResult, error) {
+	expr, _ := args["expression"].(string)
+	result, err := evalExpression(expr)
+	if err != nil {
+		return &sdk.ToolResult{ToolName: "calculator", Success: false, Error: err.Error()}, nil
+	}
+	return &sdk.ToolResult{ToolName: "calculator", Success: true, Output: fmt.Sprintf("%v", result)}, nil
+}
+
+// Expression parser supporting +, -, *, /, %, ^, functions, constants.
+type exprParser struct {
+	s   string
+	pos int
+}
+
+func evalExpression(s string) (float64, error) {
+	p := &exprParser{s: strings.TrimSpace(s)}
+	result, err := p.parseAddSub()
+	if err != nil {
+		return 0, err
+	}
+	if p.pos < len(p.s) {
+		return 0, fmt.Errorf("unexpected character at position %d: %c", p.pos, p.s[p.pos])
+	}
+	return result, nil
+}
+
+func (p *exprParser) peek() byte {
+	if p.pos < len(p.s) {
+		return p.s[p.pos]
+	}
+	return 0
+}
+
+func (p *exprParser) skipSpaces() {
+	for p.pos < len(p.s) && p.s[p.pos] == ' ' {
+		p.pos++
+	}
+}
+
+func (p *exprParser) parseAddSub() (float64, error) {
+	left, err := p.parseMulDiv()
+	if err != nil {
+		return 0, err
+	}
+	for {
+		p.skipSpaces()
+		op := p.peek()
+		if op != '+' && op != '-' {
+			break
+		}
+		p.pos++
+		right, err := p.parseMulDiv()
+		if err != nil {
+			return 0, err
+		}
+		if op == '+' {
+			left += right
+		} else {
+			left -= right
+		}
+	}
+	return left, nil
+}
+
+func (p *exprParser) parseMulDiv() (float64, error) {
+	left, err := p.parsePower()
+	if err != nil {
+		return 0, err
+	}
+	for {
+		p.skipSpaces()
+		op := p.peek()
+		if op != '*' && op != '/' && op != '%' {
+			break
+		}
+		p.pos++
+		right, err := p.parsePower()
+		if err != nil {
+			return 0, err
+		}
+		switch op {
+		case '*':
+			left *= right
+		case '/':
+			if right == 0 {
+				return 0, fmt.Errorf("division by zero")
+			}
+			left /= right
+		case '%':
+			left = math.Mod(left, right)
+		}
+	}
+	return left, nil
+}
+
+func (p *exprParser) parsePower() (float64, error) {
+	left, err := p.parseUnary()
+	if err != nil {
+		return 0, err
+	}
+	p.skipSpaces()
+	if p.peek() == '^' {
+		p.pos++
+		right, err := p.parseUnary()
+		if err != nil {
+			return 0, err
+		}
+		return math.Pow(left, right), nil
+	}
+	return left, nil
+}
+
+func (p *exprParser) parseUnary() (float64, error) {
+	p.skipSpaces()
+	if p.peek() == '-' {
+		p.pos++
+		val, err := p.parseAtom()
+		if err != nil {
+			return 0, err
+		}
+		return -val, nil
+	}
+	if p.peek() == '+' {
+		p.pos++
+	}
+	return p.parseAtom()
+}
+
+func (p *exprParser) parseAtom() (float64, error) {
+	p.skipSpaces()
+	if p.peek() == '(' {
+		p.pos++
+		result, err := p.parseAddSub()
+		if err != nil {
+			return 0, err
+		}
+		p.skipSpaces()
+		if p.peek() != ')' {
+			return 0, fmt.Errorf("missing closing parenthesis")
+		}
+		p.pos++
+		return result, nil
+	}
+	if p.peek() == 0 {
+		return 0, fmt.Errorf("unexpected end of expression")
+	}
+	if unicode.IsDigit(rune(p.peek())) || p.peek() == '.' {
+		return p.parseNumber()
+	}
+	return p.parseFuncOrConst()
+}
+
+func (p *exprParser) parseNumber() (float64, error) {
+	start := p.pos
+	for p.pos < len(p.s) && (unicode.IsDigit(rune(p.s[p.pos])) || p.s[p.pos] == '.') {
+		p.pos++
+	}
+	return strconv.ParseFloat(p.s[start:p.pos], 64)
+}
+
+func (p *exprParser) parseFuncOrConst() (float64, error) {
+	start := p.pos
+	for p.pos < len(p.s) && (unicode.IsLetter(rune(p.s[p.pos])) || p.s[p.pos] == '_') {
+		p.pos++
+	}
+	name := p.s[start:p.pos]
+	p.skipSpaces()
+
+	switch name {
+	case "pi":
+		return math.Pi, nil
+	case "e":
+		return math.E, nil
+	case "sqrt", "sin", "cos", "tan", "abs", "floor", "ceil", "round", "log", "ln":
+		if p.peek() != '(' {
+			return 0, fmt.Errorf("expected '(' after function %s", name)
+		}
+		p.pos++
+		arg, err := p.parseAddSub()
+		if err != nil {
+			return 0, err
+		}
+		if p.peek() != ')' {
+			return 0, fmt.Errorf("missing ')' after function argument")
+		}
+		p.pos++
+		return applyFunc(name, arg)
+	default:
+		return 0, fmt.Errorf("unknown function or constant: %s", name)
+	}
+}
+
+func applyFunc(name string, x float64) (float64, error) {
+	switch name {
+	case "sqrt":
+		if x < 0 {
+			return 0, fmt.Errorf("square root of negative number")
+		}
+		return math.Sqrt(x), nil
+	case "sin":
+		return math.Sin(x), nil
+	case "cos":
+		return math.Cos(x), nil
+	case "tan":
+		return math.Tan(x), nil
+	case "abs":
+		return math.Abs(x), nil
+	case "floor":
+		return math.Floor(x), nil
+	case "ceil":
+		return math.Ceil(x), nil
+	case "round":
+		return math.Round(x), nil
+	case "log":
+		if x <= 0 {
+			return 0, fmt.Errorf("log of non-positive number")
+		}
+		return math.Log10(x), nil
+	case "ln":
+		if x <= 0 {
+			return 0, fmt.Errorf("ln of non-positive number")
+		}
+		return math.Log(x), nil
+	}
+	return 0, fmt.Errorf("unknown function: %s", name)
+}

backend/plugin-manager/plugins/calculator/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "calculator",
+  "displayName": "Calculator",
+  "version": "1.0.0",
+  "minCyreneVersion": "1.0.0",
+  "author": { "name": "Cyrene Team" },
+  "description": "Safe mathematical expression evaluation with custom parser",
+  "license": "MIT",
+  "keywords": ["math", "calculator", "arithmetic"],
+  "category": "utility"
+}

backend/plugin-manager/plugins/crypto/plugin.go

@@ -0,0 +1,116 @@
+package crypto
+
+import (
+	"context"
+	"crypto/md5"
+	"crypto/sha1"
+	"crypto/sha256"
+	"crypto/sha512"
+	"encoding/base64"
+	"fmt"
+	"hash"
+	"net/url"
+
+	"github.com/yourname/cyrene-ai/plugin-manager/internal/sdk"
+)
+
+type CryptoPlugin struct{ sdk.BasePlugin }
+
+func (p *CryptoPlugin) Metadata() sdk.PluginMetadata {
+	return sdk.PluginMetadata{
+		Name: "crypto", DisplayName: "Crypto & Encoding", Version: "1.0.0",
+		Description: "Hashing (MD5/SHA) and encoding (Base64, URL) utilities",
+		Category: "utility", Author: sdk.PluginAuthor{Name: "Cyrene Team"},
+	}
+}
+
+func (p *CryptoPlugin) Tools() []sdk.Tool { return []sdk.Tool{&CryptoTool{}} }
+
+type CryptoTool struct{ sdk.BaseTool }
+
+func (t *CryptoTool) Definition() sdk.ToolDefinition {
+	return sdk.ToolDefinition{
+		ID: "crypto", Name: "crypto", DisplayName: "Crypto & Encoding",
+		Description: "Crypto hash and encoding utilities. MD5/SHA hashing, Base64 encode/decode, URL encode/decode.",
+		Category: "utility", Complexity: sdk.ComplexitySimple,
+		Parameters: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"action":    map[string]interface{}{"type": "string", "enum": []string{"hash", "base64_encode", "base64_decode", "url_encode", "url_decode"}},
+				"input":     map[string]interface{}{"type": "string"},
+				"algorithm": map[string]interface{}{"type": "string", "enum": []string{"md5", "sha1", "sha256", "sha512"}},
+			},
+			"required": []string{"action", "input"},
+		},
+	}
+}
+
+func (t *CryptoTool) Validate(args map[string]interface{}) error {
+	for _, k := range []string{"action", "input"} {
+		if _, ok := args[k]; !ok {
+			return fmt.Errorf("missing required parameter: %s", k)
+		}
+	}
+	return nil
+}
+
+func (t *CryptoTool) Execute(_ context.Context, args map[string]interface{}) (*sdk.ToolResult, error) {
+	action, _ := args["action"].(string)
+	input, _ := args["input"].(string)
+
+	switch action {
+	case "hash":
+		alg, _ := args["algorithm"].(string)
+		if alg == "" {
+			alg = "sha256"
+		}
+		var h hash.Hash
+		switch alg {
+		case "md5":
+			h = md5.New()
+		case "sha1":
+			h = sha1.New()
+		case "sha256":
+			h = sha256.New()
+		case "sha512":
+			h = sha512.New()
+		default:
+			return &sdk.ToolResult{ToolName: "crypto", Success: false, Error: "unsupported algorithm: " + alg}, nil
+		}
+		h.Write([]byte(input))
+		return &sdk.ToolResult{ToolName: "crypto", Success: true,
+			Output: fmt.Sprintf("%s: %x", alg, h.Sum(nil))}, nil
+
+	case "base64_encode":
+		return &sdk.ToolResult{ToolName: "crypto", Success: true,
+			Output: base64.StdEncoding.EncodeToString([]byte(input))}, nil
+
+	case "base64_decode":
+		for _, enc := range []*base64.Encoding{base64.StdEncoding, base64.RawStdEncoding, base64.URLEncoding, base64.RawURLEncoding} {
+			if decoded, err := enc.DecodeString(input); err == nil {
+				return &sdk.ToolResult{ToolName: "crypto", Success: true, Output: truncate(string(decoded), 200)}, nil
+			}
+		}
+		return &sdk.ToolResult{ToolName: "crypto", Success: false, Error: "failed to decode base64"}, nil
+
+	case "url_encode":
+		return &sdk.ToolResult{ToolName: "crypto", Success: true,
+			Output: url.QueryEscape(input)}, nil
+
+	case "url_decode":
+		decoded, err := url.QueryUnescape(input)
+		if err != nil {
+			return &sdk.ToolResult{ToolName: "crypto", Success: false, Error: err.Error()}, nil
+		}
+		return &sdk.ToolResult{ToolName: "crypto", Success: true, Output: decoded}, nil
+	}
+	return &sdk.ToolResult{ToolName: "crypto", Success: false, Error: "unknown action: " + action}, nil
+}
+
+func truncate(s string, n int) string {
+	runes := []rune(s)
+	if len(runes) > n {
+		return string(runes[:n]) + "..."
+	}
+	return s
+}

backend/plugin-manager/plugins/crypto/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "crypto",
+  "displayName": "Crypto & Encoding",
+  "version": "1.0.0",
+  "minCyreneVersion": "1.0.0",
+  "author": { "name": "Cyrene Team" },
+  "description": "Hashing (MD5/SHA) and encoding (Base64, URL) utilities",
+  "license": "MIT",
+  "keywords": ["crypto", "hash", "base64", "encode"],
+  "category": "utility"
+}

backend/plugin-manager/plugins/datetime/plugin.go

@@ -0,0 +1,166 @@
+package datetime
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/yourname/cyrene-ai/plugin-manager/internal/sdk"
+)
+
+type DatetimePlugin struct{ sdk.BasePlugin }
+
+func (p *DatetimePlugin) Metadata() sdk.PluginMetadata {
+	return sdk.PluginMetadata{
+		Name: "datetime", DisplayName: "Date & Time", Version: "1.0.0",
+		Description: "Date/time utilities: now, format, arithmetic, diff, timezone list",
+		Category: "utility", Author: sdk.PluginAuthor{Name: "Cyrene Team"},
+	}
+}
+
+func (p *DatetimePlugin) Tools() []sdk.Tool { return []sdk.Tool{&DatetimeTool{}} }
+
+type DatetimeTool struct{ sdk.BaseTool }
+
+func (t *DatetimeTool) Definition() sdk.ToolDefinition {
+	return sdk.ToolDefinition{
+		ID: "datetime", Name: "datetime", DisplayName: "Date & Time",
+		Description: "Date/time utility. Get current time, format dates, date arithmetic, date diff, list timezones.",
+		Category: "utility", Complexity: sdk.ComplexitySimple,
+		Parameters: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"action":   map[string]interface{}{"type": "string", "enum": []string{"now", "format", "add", "diff", "timezone_list"}},
+				"format":   map[string]interface{}{"type": "string"},
+				"timezone": map[string]interface{}{"type": "string"},
+				"date":     map[string]interface{}{"type": "string"},
+				"duration": map[string]interface{}{"type": "string"},
+				"date2":    map[string]interface{}{"type": "string"},
+			},
+			"required": []string{"action"},
+		},
+	}
+}
+
+func (t *DatetimeTool) Validate(args map[string]interface{}) error {
+	if _, ok := args["action"]; !ok {
+		return fmt.Errorf("missing required parameter: action")
+	}
+	return nil
+}
+
+func (t *DatetimeTool) Execute(_ context.Context, args map[string]interface{}) (*sdk.ToolResult, error) {
+	action, _ := args["action"].(string)
+	tzStr, _ := args["timezone"].(string)
+	loc, _ := parseLocation(tzStr)
+	now := time.Now().In(loc)
+
+	switch action {
+	case "now":
+		return &sdk.ToolResult{ToolName: "datetime", Success: true,
+			Output: fmt.Sprintf("Current time: %s (unix: %d, zone: %s)", now.Format(time.RFC3339), now.Unix(), loc.String())}, nil
+
+	case "format":
+		dateStr, _ := args["date"].(string)
+		format, _ := args["format"].(string)
+		if format == "" {
+			format = time.RFC3339
+		}
+		parsed, err := parseDate(dateStr, loc)
+		if err != nil {
+			return &sdk.ToolResult{ToolName: "datetime", Success: false, Error: err.Error()}, nil
+		}
+		return &sdk.ToolResult{ToolName: "datetime", Success: true,
+			Output: fmt.Sprintf("Formatted: %s", parsed.Format(format))}, nil
+
+	case "add":
+		dateStr, _ := args["date"].(string)
+		durStr, _ := args["duration"].(string)
+		base := now
+		if dateStr != "" {
+			var err error
+			base, err = parseDate(dateStr, loc)
+			if err != nil {
+				return &sdk.ToolResult{ToolName: "datetime", Success: false, Error: err.Error()}, nil
+			}
+		}
+		result, err := addDuration(base, durStr)
+		if err != nil {
+			return &sdk.ToolResult{ToolName: "datetime", Success: false, Error: err.Error()}, nil
+		}
+		return &sdk.ToolResult{ToolName: "datetime", Success: true,
+			Output: fmt.Sprintf("%s + %s = %s", base.Format(time.RFC3339), durStr, result.Format(time.RFC3339))}, nil
+
+	case "diff":
+		d1, _ := args["date"].(string)
+		d2, _ := args["date2"].(string)
+		t1, err := parseDate(d1, loc)
+		if err != nil {
+			return &sdk.ToolResult{ToolName: "datetime", Success: false, Error: err.Error()}, nil
+		}
+		t2, err := parseDate(d2, loc)
+		if err != nil {
+			return &sdk.ToolResult{ToolName: "datetime", Success: false, Error: err.Error()}, nil
+		}
+		diff := t2.Sub(t1)
+		if diff < 0 {
+			diff = -diff
+		}
+		days := int(diff.Hours()) / 24
+		hours := int(diff.Hours()) % 24
+		minutes := int(diff.Minutes()) % 60
+		seconds := int(diff.Seconds()) % 60
+		return &sdk.ToolResult{ToolName: "datetime", Success: true,
+			Output: fmt.Sprintf("Difference: %d days, %d hours, %d minutes, %d seconds", days, hours, minutes, seconds)}, nil
+
+	case "timezone_list":
+		return &sdk.ToolResult{ToolName: "datetime", Success: true,
+			Output: "Common timezones: UTC, Asia/Shanghai, Asia/Tokyo, Asia/Seoul, Asia/Singapore, Asia/Kolkata, Asia/Dubai, Europe/London, Europe/Paris, Europe/Moscow, America/New_York, America/Chicago, America/Los_Angeles, America/Sao_Paulo, Australia/Sydney, Pacific/Auckland, Africa/Cairo, Africa/Lagos"}, nil
+
+	default:
+		return &sdk.ToolResult{ToolName: "datetime", Success: false,
+			Error: fmt.Sprintf("unknown action: %s", action)}, nil
+	}
+}
+
+func parseLocation(tz string) (*time.Location, error) {
+	if tz == "" {
+		return time.UTC, nil
+	}
+	return time.LoadLocation(tz)
+}
+
+func parseDate(s string, loc *time.Location) (time.Time, error) {
+	formats := []string{time.RFC3339, "2006-01-02T15:04:05", "2006-01-02 15:04:05", "2006-01-02", "2006/01/02"}
+	for _, f := range formats {
+		if t, err := time.ParseInLocation(f, s, loc); err == nil {
+			return t, nil
+		}
+	}
+	return time.Time{}, fmt.Errorf("cannot parse date: %s", s)
+}
+
+func addDuration(t time.Time, durStr string) (time.Time, error) {
+	durStr = strings.TrimSpace(durStr)
+	if durStr == "" {
+		return t, nil
+	}
+	// Handle months and years
+	if strings.Contains(durStr, "M") || strings.Contains(durStr, "y") {
+		months := 0
+		years := 0
+		if strings.Contains(durStr, "y") {
+			fmt.Sscanf(durStr, "%dy", &years)
+		}
+		if strings.Contains(durStr, "M") {
+			fmt.Sscanf(durStr, "%dM", &months)
+		}
+		return t.AddDate(years, months, 0), nil
+	}
+	d, err := time.ParseDuration(durStr)
+	if err != nil {
+		return t, fmt.Errorf("invalid duration: %s", durStr)
+	}
+	return t.Add(d), nil
+}

backend/plugin-manager/plugins/datetime/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "datetime",
+  "displayName": "Date & Time",
+  "version": "1.0.0",
+  "minCyreneVersion": "1.0.0",
+  "author": { "name": "Cyrene Team" },
+  "description": "Date/time utilities: now, format, arithmetic, diff, timezone list",
+  "license": "MIT",
+  "keywords": ["datetime", "time", "timezone"],
+  "category": "utility"
+}

backend/plugin-manager/plugins/file/plugin.go

@@ -0,0 +1,158 @@
+package file
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/yourname/cyrene-ai/plugin-manager/internal/sdk"
+)
+
+type FilePlugin struct {
+	sdk.BasePlugin
+	dataDir string
+}
+
+func NewFilePlugin(dataDir string) *FilePlugin {
+	if dataDir == "" {
+		dataDir = "/tmp/cyrene_data"
+	}
+	return &FilePlugin{dataDir: dataDir}
+}
+
+func (p *FilePlugin) Metadata() sdk.PluginMetadata {
+	return sdk.PluginMetadata{
+		Name: "file", DisplayName: "File Operations", Version: "1.0.0",
+		Description: "Sandboxed file operations: read, write, list, delete within DATA_DIR",
+		Category: "system", Author: sdk.PluginAuthor{Name: "Cyrene Team"},
+	}
+}
+
+func (p *FilePlugin) Tools() []sdk.Tool { return []sdk.Tool{&FileTool{dataDir: p.dataDir}} }
+
+type FileTool struct {
+	sdk.BaseTool
+	dataDir string
+}
+
+func (t *FileTool) Definition() sdk.ToolDefinition {
+	return sdk.ToolDefinition{
+		ID: "file_ops", Name: "file_ops", DisplayName: "File Operations",
+		Description: "File operations within a sandboxed data directory. Read, write, list, check existence, delete.",
+		Category: "system", Complexity: sdk.ComplexitySimple,
+		DangerLevel: "medium",
+		Parameters: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"action":  map[string]interface{}{"type": "string", "enum": []string{"read", "write", "list", "exists", "delete"}},
+				"path":    map[string]interface{}{"type": "string"},
+				"content": map[string]interface{}{"type": "string"},
+			},
+			"required": []string{"action", "path"},
+		},
+	}
+}
+
+func (t *FileTool) Validate(args map[string]interface{}) error {
+	for _, k := range []string{"action", "path"} {
+		if _, ok := args[k]; !ok {
+			return fmt.Errorf("missing required parameter: %s", k)
+		}
+	}
+	return nil
+}
+
+func (t *FileTool) safePath(p string) (string, error) {
+	clean := filepath.Clean(p)
+	abs, err := filepath.Abs(filepath.Join(t.dataDir, clean))
+	if err != nil {
+		return "", fmt.Errorf("path resolution failed: %w", err)
+	}
+	if !strings.HasPrefix(abs, filepath.Clean(t.dataDir)+string(os.PathSeparator)) && abs != filepath.Clean(t.dataDir) {
+		return "", fmt.Errorf("path traversal denied: %s", p)
+	}
+	return abs, nil
+}
+
+func (t *FileTool) Execute(_ context.Context, args map[string]interface{}) (*sdk.ToolResult, error) {
+	action, _ := args["action"].(string)
+	pathStr, _ := args["path"].(string)
+
+	safePath, err := t.safePath(pathStr)
+	if err != nil {
+		return &sdk.ToolResult{ToolName: "file_ops", Success: false, Error: err.Error()}, nil
+	}
+
+	switch action {
+	case "read":
+		info, err := os.Stat(safePath)
+		if err != nil {
+			return &sdk.ToolResult{ToolName: "file_ops", Success: false, Error: err.Error()}, nil
+		}
+		if info.IsDir() {
+			return &sdk.ToolResult{ToolName: "file_ops", Success: false, Error: "cannot read a directory"}, nil
+		}
+		if info.Size() > 100*1024 {
+			return &sdk.ToolResult{ToolName: "file_ops", Success: false, Error: "file too large (>100KB)"}, nil
+		}
+		data, err := os.ReadFile(safePath)
+		if err != nil {
+			return &sdk.ToolResult{ToolName: "file_ops", Success: false, Error: err.Error()}, nil
+		}
+		return &sdk.ToolResult{ToolName: "file_ops", Success: true, Output: string(data)}, nil
+
+	case "write":
+		content, _ := args["content"].(string)
+		dir := filepath.Dir(safePath)
+		if err := os.MkdirAll(dir, 0755); err != nil {
+			return &sdk.ToolResult{ToolName: "file_ops", Success: false, Error: err.Error()}, nil
+		}
+		if err := os.WriteFile(safePath, []byte(content), 0644); err != nil {
+			return &sdk.ToolResult{ToolName: "file_ops", Success: false, Error: err.Error()}, nil
+		}
+		return &sdk.ToolResult{ToolName: "file_ops", Success: true, Output: fmt.Sprintf("Written %d bytes to %s", len(content), pathStr)}, nil
+
+	case "list":
+		entries, err := os.ReadDir(safePath)
+		if err != nil {
+			return &sdk.ToolResult{ToolName: "file_ops", Success: false, Error: err.Error()}, nil
+		}
+		var out strings.Builder
+		for _, e := range entries {
+			info, _ := e.Info()
+			if e.IsDir() {
+				out.WriteString(fmt.Sprintf("[DIR]  %s/\n", e.Name()))
+			} else {
+				out.WriteString(fmt.Sprintf("[FILE] %s (%d bytes)\n", e.Name(), info.Size()))
+			}
+		}
+		return &sdk.ToolResult{ToolName: "file_ops", Success: true, Output: out.String()}, nil
+
+	case "exists":
+		info, err := os.Stat(safePath)
+		if err != nil {
+			return &sdk.ToolResult{ToolName: "file_ops", Success: true, Output: fmt.Sprintf("Path does not exist: %s", pathStr)}, nil
+		}
+		kind := "file"
+		if info.IsDir() {
+			kind = "directory"
+		}
+		return &sdk.ToolResult{ToolName: "file_ops", Success: true, Output: fmt.Sprintf("Path exists (%s): %s", kind, pathStr)}, nil
+
+	case "delete":
+		info, err := os.Stat(safePath)
+		if err != nil {
+			return &sdk.ToolResult{ToolName: "file_ops", Success: false, Error: err.Error()}, nil
+		}
+		if info.IsDir() {
+			return &sdk.ToolResult{ToolName: "file_ops", Success: false, Error: "cannot delete a directory"}, nil
+		}
+		if err := os.Remove(safePath); err != nil {
+			return &sdk.ToolResult{ToolName: "file_ops", Success: false, Error: err.Error()}, nil
+		}
+		return &sdk.ToolResult{ToolName: "file_ops", Success: true, Output: fmt.Sprintf("Deleted: %s", pathStr)}, nil
+	}
+	return &sdk.ToolResult{ToolName: "file_ops", Success: false, Error: "unknown action: " + action}, nil
+}

backend/plugin-manager/plugins/file/plugin.json

@@ -0,0 +1,12 @@
+{
+  "name": "file",
+  "displayName": "File Operations",
+  "version": "1.0.0",
+  "minCyreneVersion": "1.0.0",
+  "author": { "name": "Cyrene Team" },
+  "description": "Sandboxed file operations: read, write, list, delete within DATA_DIR",
+  "license": "MIT",
+  "keywords": ["file", "read", "write"],
+  "category": "system",
+  "permissions": ["file:read", "file:write"]
+}

backend/plugin-manager/plugins/http/plugin.go

@@ -0,0 +1,122 @@
+package http
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/yourname/cyrene-ai/plugin-manager/internal/sdk"
+)
+
+type HTTPPlugin struct {
+	sdk.BasePlugin
+	client *http.Client
+}
+
+func NewHTTPPlugin() *HTTPPlugin {
+	return &HTTPPlugin{client: &http.Client{Timeout: 10 * time.Second}}
+}
+
+func (p *HTTPPlugin) Metadata() sdk.PluginMetadata {
+	return sdk.PluginMetadata{
+		Name: "http", DisplayName: "HTTP Client", Version: "1.0.0",
+		Description: "Send arbitrary HTTP requests with custom methods, headers, body",
+		Category: "network", Author: sdk.PluginAuthor{Name: "Cyrene Team"},
+	}
+}
+
+func (p *HTTPPlugin) Tools() []sdk.Tool { return []sdk.Tool{&HTTPTool{client: p.client}} }
+
+type HTTPTool struct {
+	sdk.BaseTool
+	client *http.Client
+}
+
+func (t *HTTPTool) Definition() sdk.ToolDefinition {
+	return sdk.ToolDefinition{
+		ID: "http_request", Name: "http_request", DisplayName: "HTTP Client",
+		Description: "Send arbitrary HTTP requests. Supports custom methods, headers, and body.",
+		Category: "network", Complexity: sdk.ComplexitySimple,
+		DangerLevel: "low",
+		Parameters: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"url":     map[string]interface{}{"type": "string"},
+				"method":  map[string]interface{}{"type": "string", "enum": []string{"GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"}},
+				"headers": map[string]interface{}{"type": "object"},
+				"body":    map[string]interface{}{"type": "string"},
+				"timeout": map[string]interface{}{"type": "number"},
+			},
+			"required": []string{"url"},
+		},
+	}
+}
+
+var allowedMethods = map[string]bool{
+	"GET": true, "POST": true, "PUT": true, "DELETE": true,
+	"PATCH": true, "HEAD": true, "OPTIONS": true,
+}
+
+func (t *HTTPTool) Validate(args map[string]interface{}) error {
+	if _, ok := args["url"]; !ok {
+		return fmt.Errorf("missing required parameter: url")
+	}
+	return nil
+}
+
+func (t *HTTPTool) Execute(_ context.Context, args map[string]interface{}) (*sdk.ToolResult, error) {
+	urlStr, _ := args["url"].(string)
+	method, _ := args["method"].(string)
+	if method == "" {
+		method = "GET"
+	}
+	if !allowedMethods[method] {
+		return &sdk.ToolResult{ToolName: "http_request", Success: false, Error: "invalid method: " + method}, nil
+	}
+	if !strings.HasPrefix(urlStr, "http://") && !strings.HasPrefix(urlStr, "https://") {
+		return &sdk.ToolResult{ToolName: "http_request", Success: false, Error: "only http/https URLs allowed"}, nil
+	}
+
+	var bodyReader io.Reader
+	if body, _ := args["body"].(string); body != "" {
+		bodyReader = strings.NewReader(body)
+	}
+
+	req, err := http.NewRequest(method, urlStr, bodyReader)
+	if err != nil {
+		return &sdk.ToolResult{ToolName: "http_request", Success: false, Error: err.Error()}, nil
+	}
+	req.Header.Set("User-Agent", "CyreneBot/1.0")
+
+	if headers, ok := args["headers"].(map[string]interface{}); ok {
+		for k, v := range headers {
+			req.Header.Set(k, fmt.Sprint(v))
+		}
+	}
+
+	client := t.client
+	if timeout, _ := args["timeout"].(float64); timeout > 0 {
+		client = &http.Client{Timeout: time.Duration(timeout) * time.Second}
+	}
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return &sdk.ToolResult{ToolName: "http_request", Success: false, Error: err.Error()}, nil
+	}
+	defer resp.Body.Close()
+
+	bodyBytes, _ := io.ReadAll(io.LimitReader(resp.Body, 50*1024))
+	return &sdk.ToolResult{ToolName: "http_request", Success: resp.StatusCode < 500, Output: fmt.Sprintf(
+		"HTTP %d\n%s\n\n%s", resp.StatusCode, formatHeaders(resp.Header), string(bodyBytes))}, nil
+}
+
+func formatHeaders(h http.Header) string {
+	var lines []string
+	for k, v := range h {
+		lines = append(lines, fmt.Sprintf("%s: %s", k, strings.Join(v, ", ")))
+	}
+	return strings.Join(lines, "\n")
+}

backend/plugin-manager/plugins/http/plugin.json

@@ -0,0 +1,12 @@
+{
+  "name": "http",
+  "displayName": "HTTP Client",
+  "version": "1.0.0",
+  "minCyreneVersion": "1.0.0",
+  "author": { "name": "Cyrene Team" },
+  "description": "Send arbitrary HTTP requests with custom methods, headers, body",
+  "license": "MIT",
+  "keywords": ["http", "request", "fetch"],
+  "category": "network",
+  "permissions": ["network:outbound"]
+}

backend/plugin-manager/plugins/iot_control/plugin.go

@@ -0,0 +1,189 @@
+package iotcontrol
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/yourname/cyrene-ai/plugin-manager/internal/sdk"
+)
+
+// IoTController extends IoTClient with control operations.
+type IoTController interface {
+	GetDevice(ctx context.Context, deviceID string) (*sdk.IoTDeviceState, error)
+	SetDeviceProperty(ctx context.Context, deviceID, property string, value interface{}) error
+	ToggleDevice(ctx context.Context, deviceID string) (*sdk.IoTDeviceState, error)
+}
+
+type IoTControlPlugin struct {
+	sdk.BasePlugin
+	iotClient IoTController
+}
+
+func NewIoTControlPlugin(client IoTController) *IoTControlPlugin {
+	return &IoTControlPlugin{iotClient: client}
+}
+
+func (p *IoTControlPlugin) Metadata() sdk.PluginMetadata {
+	return sdk.PluginMetadata{
+		Name: "iot_control", DisplayName: "IoT Device Control", Version: "1.0.0",
+		Description: "Control smart home devices: toggle, set temperature/brightness/mode/color",
+		Category: "iot", Author: sdk.PluginAuthor{Name: "Cyrene Team"},
+	}
+}
+
+func (p *IoTControlPlugin) Tools() []sdk.Tool {
+	return []sdk.Tool{&IoTControlTool{iotClient: p.iotClient}}
+}
+
+type IoTControlTool struct {
+	sdk.BaseTool
+	iotClient IoTController
+}
+
+func (t *IoTControlTool) Definition() sdk.ToolDefinition {
+	return sdk.ToolDefinition{
+		ID: "iot_control", Name: "iot_control", DisplayName: "IoT Device Control",
+		Description: "Control smart home devices. Supports toggle, turn_on, turn_off, set_temperature, set_brightness, set_position, set_mode, set_color.",
+		Category: "iot", Complexity: sdk.ComplexitySimple,
+		DangerLevel: "medium",
+		Parameters: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"device_id": map[string]interface{}{"type": "string"},
+				"action":    map[string]interface{}{"type": "string", "enum": []string{"toggle", "turn_on", "turn_off", "set_temperature", "set_brightness", "set_position", "set_mode", "set_color"}},
+				"value":     map[string]interface{}{},
+			},
+			"required": []string{"device_id", "action"},
+		},
+	}
+}
+
+func (t *IoTControlTool) Validate(args map[string]interface{}) error {
+	for _, k := range []string{"device_id", "action"} {
+		if _, ok := args[k]; !ok {
+			return fmt.Errorf("missing required parameter: %s", k)
+		}
+	}
+	return nil
+}
+
+func (t *IoTControlTool) Execute(ctx context.Context, args map[string]interface{}) (*sdk.ToolResult, error) {
+	if t.iotClient == nil {
+		return &sdk.ToolResult{ToolName: "iot_control", Success: false, Error: "IoT client not configured"}, nil
+	}
+
+	deviceID, _ := args["device_id"].(string)
+	if deviceID == "" {
+		deviceID, _ = args["entity_id"].(string)
+	}
+	action := normalizeAction(args)
+
+	switch action {
+	case "turn_on", "turn_off":
+		status := "on"
+		if action == "turn_off" {
+			status = "off"
+		}
+		if err := t.iotClient.SetDeviceProperty(ctx, deviceID, "status", status); err != nil {
+			return &sdk.ToolResult{ToolName: "iot_control", Success: false, Error: err.Error()}, nil
+		}
+		return &sdk.ToolResult{ToolName: "iot_control", Success: true,
+			Output: fmt.Sprintf("Device %s turned %s", deviceID, status)}, nil
+
+	case "set_temperature":
+		value := toFloat64(args["value"])
+		old := ""
+		if dev, err := t.iotClient.GetDevice(ctx, deviceID); err == nil {
+			old = fmt.Sprintf(" (was %.1fC)", dev.Temperature)
+		}
+		if err := t.iotClient.SetDeviceProperty(ctx, deviceID, "temperature", value); err != nil {
+			return &sdk.ToolResult{ToolName: "iot_control", Success: false, Error: err.Error()}, nil
+		}
+		return &sdk.ToolResult{ToolName: "iot_control", Success: true,
+			Output: fmt.Sprintf("Temperature set to %.1fC%s", value, old)}, nil
+
+	case "set_brightness":
+		value := toFloat64(args["value"])
+		if err := t.iotClient.SetDeviceProperty(ctx, deviceID, "brightness", value); err != nil {
+			return &sdk.ToolResult{ToolName: "iot_control", Success: false, Error: err.Error()}, nil
+		}
+		return &sdk.ToolResult{ToolName: "iot_control", Success: true,
+			Output: fmt.Sprintf("Brightness set to %.0f%%", value)}, nil
+
+	case "set_position":
+		value := toFloat64(args["value"])
+		if err := t.iotClient.SetDeviceProperty(ctx, deviceID, "position", value); err != nil {
+			return &sdk.ToolResult{ToolName: "iot_control", Success: false, Error: err.Error()}, nil
+		}
+		return &sdk.ToolResult{ToolName: "iot_control", Success: true,
+			Output: fmt.Sprintf("Position set to %.0f%%", value)}, nil
+
+	case "set_mode":
+		value, _ := args["value"].(string)
+		if err := t.iotClient.SetDeviceProperty(ctx, deviceID, "mode", value); err != nil {
+			return &sdk.ToolResult{ToolName: "iot_control", Success: false, Error: err.Error()}, nil
+		}
+		return &sdk.ToolResult{ToolName: "iot_control", Success: true,
+			Output: fmt.Sprintf("Mode set to %s", value)}, nil
+
+	case "set_color":
+		value, _ := args["value"].(string)
+		if err := t.iotClient.SetDeviceProperty(ctx, deviceID, "color", value); err != nil {
+			return &sdk.ToolResult{ToolName: "iot_control", Success: false, Error: err.Error()}, nil
+		}
+		return &sdk.ToolResult{ToolName: "iot_control", Success: true,
+			Output: fmt.Sprintf("Color set to %s", value)}, nil
+
+	case "toggle":
+		dev, err := t.iotClient.ToggleDevice(ctx, deviceID)
+		if err != nil {
+			return &sdk.ToolResult{ToolName: "iot_control", Success: false, Error: err.Error()}, nil
+		}
+		return &sdk.ToolResult{ToolName: "iot_control", Success: true,
+			Output: fmt.Sprintf("Device %s toggled to %s", deviceID, dev.Status)}, nil
+
+	default:
+		return &sdk.ToolResult{ToolName: "iot_control", Success: false,
+			Error: fmt.Sprintf("unknown action: %s", action)}, nil
+	}
+}
+
+func normalizeAction(args map[string]interface{}) string {
+	action, _ := args["action"].(string)
+	// Chinese aliases
+	switch action {
+	case "打开":
+		return "turn_on"
+	case "关闭", "关掉", "关上":
+		return "turn_off"
+	case "设置温度", "调温度":
+		return "set_temperature"
+	case "设置亮度", "调亮度":
+		return "set_brightness"
+	case "设置位置":
+		return "set_position"
+	case "设置模式":
+		return "set_mode"
+	case "设置颜色":
+		return "set_color"
+	case "开关", "切换":
+		return "toggle"
+	}
+	return action
+}
+
+func toFloat64(v interface{}) float64 {
+	switch n := v.(type) {
+	case float64:
+		return n
+	case int:
+		return float64(n)
+	case int64:
+		return float64(n)
+	case string:
+		var f float64
+		fmt.Sscanf(n, "%f", &f)
+		return f
+	}
+	return 0
+}

backend/plugin-manager/plugins/iot_control/plugin.json

@@ -0,0 +1,12 @@
+{
+  "name": "iot_control",
+  "displayName": "IoT Device Control",
+  "version": "1.0.0",
+  "minCyreneVersion": "1.0.0",
+  "author": { "name": "Cyrene Team" },
+  "description": "Control smart home devices: toggle, set temperature/brightness/mode/color",
+  "license": "MIT",
+  "keywords": ["iot", "control", "toggle", "temperature"],
+  "category": "iot",
+  "permissions": ["iot:read", "iot:write"]
+}

backend/plugin-manager/plugins/iot_query/plugin.go

@@ -0,0 +1,120 @@
+package iotquery
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/yourname/cyrene-ai/plugin-manager/internal/sdk"
+)
+
+// IoTClient is the interface for IoT device access.
+type IoTClient interface {
+	GetAllDevices(ctx context.Context) ([]sdk.IoTDeviceState, error)
+	GetDevice(ctx context.Context, deviceID string) (*sdk.IoTDeviceState, error)
+}
+
+type IoTQueryPlugin struct {
+	sdk.BasePlugin
+	iotClient IoTClient
+}
+
+func NewIoTQueryPlugin(client IoTClient) *IoTQueryPlugin {
+	return &IoTQueryPlugin{iotClient: client}
+}
+
+func (p *IoTQueryPlugin) Metadata() sdk.PluginMetadata {
+	return sdk.PluginMetadata{
+		Name: "iot_query", DisplayName: "IoT Device Query", Version: "1.0.0",
+		Description: "Query smart home device status (single device or all devices)",
+		Category: "iot", Author: sdk.PluginAuthor{Name: "Cyrene Team"},
+	}
+}
+
+func (p *IoTQueryPlugin) Tools() []sdk.Tool { return []sdk.Tool{&IoTQueryTool{iotClient: p.iotClient}} }
+
+type IoTQueryTool struct {
+	sdk.BaseTool
+	iotClient IoTClient
+}
+
+func (t *IoTQueryTool) Definition() sdk.ToolDefinition {
+	return sdk.ToolDefinition{
+		ID: "iot_query", Name: "iot_query", DisplayName: "IoT Device Query",
+		Description: "Query smart home device status. Device status is typically auto-injected; use this only when status is stale.",
+		Category: "iot", Complexity: sdk.ComplexitySimple,
+		Parameters: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{"device_id": map[string]interface{}{"type": "string"}},
+		},
+	}
+}
+
+func (t *IoTQueryTool) Validate(args map[string]interface{}) error { return nil }
+
+func (t *IoTQueryTool) Execute(ctx context.Context, args map[string]interface{}) (*sdk.ToolResult, error) {
+	if t.iotClient == nil {
+		return &sdk.ToolResult{ToolName: "iot_query", Success: false, Error: "IoT client not configured"}, nil
+	}
+
+	deviceID, _ := args["device_id"].(string)
+	if deviceID != "" {
+		dev, err := t.iotClient.GetDevice(ctx, deviceID)
+		if err != nil {
+			return &sdk.ToolResult{ToolName: "iot_query", Success: false, Error: err.Error()}, nil
+		}
+		return &sdk.ToolResult{ToolName: "iot_query", Success: true, Output: formatDevice(dev)}, nil
+	}
+
+	devices, err := t.iotClient.GetAllDevices(ctx)
+	if err != nil {
+		return &sdk.ToolResult{ToolName: "iot_query", Success: false, Error: err.Error()}, nil
+	}
+	if len(devices) == 0 {
+		return &sdk.ToolResult{ToolName: "iot_query", Success: true, Output: "No devices found"}, nil
+	}
+	var out string
+	for _, d := range devices {
+		out += formatDeviceLine(&d) + "\n"
+	}
+	return &sdk.ToolResult{ToolName: "iot_query", Success: true, Output: out}, nil
+}
+
+func formatDevice(d *sdk.IoTDeviceState) string {
+	emoji := deviceEmoji(d.Type)
+	return fmt.Sprintf("%s %s (%s)\n   Status: %s\n   ID: %s", emoji, d.Name, d.Type, d.Status, d.ID)
+}
+
+func formatDeviceLine(d *sdk.IoTDeviceState) string {
+	emoji := deviceEmoji(d.Type)
+	switch d.Type {
+	case "light":
+		return fmt.Sprintf("%s %s: %s (brightness: %d, color: %s)", emoji, d.Name, d.Status, d.Brightness, d.Color)
+	case "ac":
+		return fmt.Sprintf("%s %s: %s (mode: %s, temp: %.1fC)", emoji, d.Name, d.Status, d.Mode, d.Temperature)
+	case "curtain":
+		return fmt.Sprintf("%s %s: %s (position: %d%%)", emoji, d.Name, d.Status, d.Position)
+	case "sensor":
+		return fmt.Sprintf("%s %s: %.1f%s", emoji, d.Name, d.Value, d.Unit)
+	case "lock":
+		return fmt.Sprintf("%s %s: %s (battery: %d%%)", emoji, d.Name, d.Status, d.Battery)
+	default:
+		return fmt.Sprintf("%s %s: %s", emoji, d.Name, d.Status)
+	}
+}
+
+func deviceEmoji(t string) string {
+	switch t {
+	case "light":
+		return "\U0001F4A1"
+	case "ac":
+		return "❄️"
+	case "curtain":
+		return "\U0001F3E0"
+	case "sensor":
+		return "\U0001F4CA"
+	case "lock":
+		return "\U0001F512"
+	default:
+		return "\U0001F4E6"
+	}
+}

backend/plugin-manager/plugins/iot_query/plugin.json

@@ -0,0 +1,12 @@
+{
+  "name": "iot_query",
+  "displayName": "IoT Device Query",
+  "version": "1.0.0",
+  "minCyreneVersion": "1.0.0",
+  "author": { "name": "Cyrene Team" },
+  "description": "Query smart home device status (single device or all devices)",
+  "license": "MIT",
+  "keywords": ["iot", "query", "device", "status"],
+  "category": "iot",
+  "permissions": ["iot:read"]
+}

backend/plugin-manager/plugins/json/plugin.go

@@ -0,0 +1,132 @@
+package jsonplugin
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"github.com/yourname/cyrene-ai/plugin-manager/internal/sdk"
+)
+
+type JSONPlugin struct{ sdk.BasePlugin }
+
+func (p *JSONPlugin) Metadata() sdk.PluginMetadata {
+	return sdk.PluginMetadata{
+		Name: "json", DisplayName: "JSON Processor", Version: "1.0.0",
+		Description: "JSON parsing, dot-path query, validation, pretty-print",
+		Category: "format", Author: sdk.PluginAuthor{Name: "Cyrene Team"},
+	}
+}
+
+func (p *JSONPlugin) Tools() []sdk.Tool { return []sdk.Tool{&JSONTool{}} }
+
+type JSONTool struct{ sdk.BaseTool }
+
+func (t *JSONTool) Definition() sdk.ToolDefinition {
+	return sdk.ToolDefinition{
+		ID: "json_ops", Name: "json_ops", DisplayName: "JSON Processor",
+		Description: "JSON processing. Parse/pretty-print, query by dot-notation path, validate.",
+		Category: "format", Complexity: sdk.ComplexitySimple,
+		Parameters: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"action":      map[string]interface{}{"type": "string", "enum": []string{"parse", "query", "validate"}},
+				"json_string": map[string]interface{}{"type": "string"},
+				"path":        map[string]interface{}{"type": "string"},
+			},
+			"required": []string{"action", "json_string"},
+		},
+	}
+}
+
+func (t *JSONTool) Validate(args map[string]interface{}) error {
+	for _, k := range []string{"action", "json_string"} {
+		if _, ok := args[k]; !ok {
+			return fmt.Errorf("missing required parameter: %s", k)
+		}
+	}
+	return nil
+}
+
+func (t *JSONTool) Execute(_ context.Context, args map[string]interface{}) (*sdk.ToolResult, error) {
+	action, _ := args["action"].(string)
+	jsonStr, _ := args["json_string"].(string)
+
+	switch action {
+	case "parse":
+		var v interface{}
+		if err := json.Unmarshal([]byte(jsonStr), &v); err != nil {
+			return &sdk.ToolResult{ToolName: "json_ops", Success: false, Error: err.Error()}, nil
+		}
+		pretty, err := json.MarshalIndent(v, "", "  ")
+		if err != nil {
+			return &sdk.ToolResult{ToolName: "json_ops", Success: false, Error: err.Error()}, nil
+		}
+		return &sdk.ToolResult{ToolName: "json_ops", Success: true, Output: string(pretty)}, nil
+
+	case "query":
+		var v interface{}
+		if err := json.Unmarshal([]byte(jsonStr), &v); err != nil {
+			return &sdk.ToolResult{ToolName: "json_ops", Success: false, Error: err.Error()}, nil
+		}
+		path, _ := args["path"].(string)
+		if path == "" {
+			return &sdk.ToolResult{ToolName: "json_ops", Success: false, Error: "path is required for query"}, nil
+		}
+		result, err := jsonPathQuery(v, path)
+		if err != nil {
+			return &sdk.ToolResult{ToolName: "json_ops", Success: false, Error: err.Error()}, nil
+		}
+		out, _ := json.Marshal(result)
+		return &sdk.ToolResult{ToolName: "json_ops", Success: true, Output: string(out)}, nil
+
+	case "validate":
+		var v interface{}
+		if err := json.Unmarshal([]byte(jsonStr), &v); err != nil {
+			return &sdk.ToolResult{ToolName: "json_ops", Success: true, Output: "Invalid JSON: " + err.Error()}, nil
+		}
+		typeStr := "unknown"
+		switch v.(type) {
+		case map[string]interface{}:
+			typeStr = "object"
+		case []interface{}:
+			typeStr = "array"
+		case string:
+			typeStr = "string"
+		case float64:
+			typeStr = "number"
+		case bool:
+			typeStr = "boolean"
+		}
+		return &sdk.ToolResult{ToolName: "json_ops", Success: true,
+			Output: fmt.Sprintf("Valid JSON (type: %s, size: %d bytes)", typeStr, len(jsonStr))}, nil
+	}
+	return &sdk.ToolResult{ToolName: "json_ops", Success: false, Error: "unknown action: " + action}, nil
+}
+
+func jsonPathQuery(root interface{}, path string) (interface{}, error) {
+	path = strings.TrimPrefix(path, "$.")
+	parts := strings.Split(path, ".")
+	current := root
+	for _, part := range parts {
+		switch v := current.(type) {
+		case map[string]interface{}:
+			var ok bool
+			current, ok = v[part]
+			if !ok {
+				return nil, fmt.Errorf("key %q not found", part)
+			}
+		case []interface{}:
+			idx, err := strconv.Atoi(part)
+			if err != nil || idx < 0 || idx >= len(v) {
+				return nil, fmt.Errorf("invalid array index: %s", part)
+			}
+			current = v[idx]
+		default:
+			return nil, fmt.Errorf("cannot traverse into %T at path segment %q", current, part)
+		}
+	}
+	return current, nil
+}

backend/plugin-manager/plugins/json/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "json",
+  "displayName": "JSON Processor",
+  "version": "1.0.0",
+  "minCyreneVersion": "1.0.0",
+  "author": { "name": "Cyrene Team" },
+  "description": "JSON parsing, dot-path query, validation, pretty-print",
+  "license": "MIT",
+  "keywords": ["json", "parse", "query", "validate"],
+  "category": "format"
+}

backend/plugin-manager/plugins/markdown/plugin.go

@@ -0,0 +1,184 @@
+package markdown
+
+import (
+	"context"
+	"fmt"
+	"regexp"
+	"strings"
+
+	"github.com/yourname/cyrene-ai/plugin-manager/internal/sdk"
+)
+
+type MarkdownPlugin struct{ sdk.BasePlugin }
+
+func (p *MarkdownPlugin) Metadata() sdk.PluginMetadata {
+	return sdk.PluginMetadata{
+		Name: "markdown", DisplayName: "Markdown Processor", Version: "1.0.0",
+		Description: "Markdown processing: to HTML, extract text/links/code, generate TOC",
+		Category: "format", Author: sdk.PluginAuthor{Name: "Cyrene Team"},
+	}
+}
+
+func (p *MarkdownPlugin) Tools() []sdk.Tool { return []sdk.Tool{&MarkdownTool{}} }
+
+type MarkdownTool struct{ sdk.BaseTool }
+
+func (t *MarkdownTool) Definition() sdk.ToolDefinition {
+	return sdk.ToolDefinition{
+		ID: "markdown", Name: "markdown", DisplayName: "Markdown Processor",
+		Description: "Markdown processing. Convert to HTML, extract plain text, extract links/code blocks, generate TOC.",
+		Category: "format", Complexity: sdk.ComplexitySimple,
+		Parameters: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"action":   map[string]interface{}{"type": "string", "enum": []string{"to_html", "to_text", "extract_links", "extract_code", "table_of_contents"}},
+				"markdown": map[string]interface{}{"type": "string"},
+			},
+			"required": []string{"action", "markdown"},
+		},
+	}
+}
+
+func (t *MarkdownTool) Validate(args map[string]interface{}) error {
+	for _, k := range []string{"action", "markdown"} {
+		if _, ok := args[k]; !ok {
+			return fmt.Errorf("missing required parameter: %s", k)
+		}
+	}
+	return nil
+}
+
+func (t *MarkdownTool) Execute(_ context.Context, args map[string]interface{}) (*sdk.ToolResult, error) {
+	action, _ := args["action"].(string)
+	md, _ := args["markdown"].(string)
+
+	switch action {
+	case "to_html":
+		return &sdk.ToolResult{ToolName: "markdown", Success: true, Output: mdToHTML(md)}, nil
+
+	case "to_text":
+		text := md
+		reCode := regexp.MustCompile("(?s)```.*?```")
+		text = reCode.ReplaceAllString(text, "")
+		text = regexp.MustCompile(`\*\*([^*]+)\*\*`).ReplaceAllString(text, "$1")
+		text = regexp.MustCompile(`\*([^*]+)\*`).ReplaceAllString(text, "$1")
+		text = regexp.MustCompile(`~~([^~]+)~~`).ReplaceAllString(text, "$1")
+		text = regexp.MustCompile(`^#{1,6}\s+`).ReplaceAllString(text, "")
+		text = regexp.MustCompile(`^[*-]\s+`).ReplaceAllString(text, "- ")
+		text = regexp.MustCompile(`^>\s+`).ReplaceAllString(text, "")
+		text = regexp.MustCompile(`\n{3,}`).ReplaceAllString(text, "\n\n")
+		return &sdk.ToolResult{ToolName: "markdown", Success: true, Output: strings.TrimSpace(text)}, nil
+
+	case "extract_links":
+		re := regexp.MustCompile(`\[([^\]]+)\]\(([^)]+)\)`)
+		matches := re.FindAllStringSubmatch(md, -1)
+		if len(matches) == 0 {
+			return &sdk.ToolResult{ToolName: "markdown", Success: true, Output: "No links found"}, nil
+		}
+		var out strings.Builder
+		for i, m := range matches {
+			out.WriteString(fmt.Sprintf("%d. %s -> %s\n", i+1, m[1], m[2]))
+		}
+		return &sdk.ToolResult{ToolName: "markdown", Success: true, Output: out.String()}, nil
+
+	case "extract_code":
+		re := regexp.MustCompile("(?s)```(\\w*)\n?(.*?)```")
+		matches := re.FindAllStringSubmatch(md, -1)
+		if len(matches) == 0 {
+			return &sdk.ToolResult{ToolName: "markdown", Success: true, Output: "No code blocks found"}, nil
+		}
+		var out strings.Builder
+		for i, m := range matches {
+			lang := m[1]
+			if lang == "" {
+				lang = "text"
+			}
+			code := m[2]
+			if len([]rune(code)) > 500 {
+				code = string([]rune(code)[:500]) + "..."
+			}
+			out.WriteString(fmt.Sprintf("--- Block %d (%s) ---\n%s\n\n", i+1, lang, code))
+		}
+		return &sdk.ToolResult{ToolName: "markdown", Success: true, Output: out.String()}, nil
+
+	case "table_of_contents":
+		re := regexp.MustCompile(`(?m)^(#{1,6})\s+(.+)$`)
+		matches := re.FindAllStringSubmatch(md, -1)
+		if len(matches) == 0 {
+			return &sdk.ToolResult{ToolName: "markdown", Success: true, Output: "No headings found"}, nil
+		}
+		var out strings.Builder
+		for _, m := range matches {
+			depth := len(m[1])
+			indent := strings.Repeat("  ", depth-1)
+			out.WriteString(fmt.Sprintf("%s- %s\n", indent, m[2]))
+		}
+		return &sdk.ToolResult{ToolName: "markdown", Success: true, Output: out.String()}, nil
+	}
+	return &sdk.ToolResult{ToolName: "markdown", Success: false, Error: "unknown action: " + action}, nil
+}
+
+func mdToHTML(md string) string {
+	// Save code blocks
+	type placeholder struct {
+		orig     string
+		content  string
+		language string
+	}
+	blocks := []*placeholder{}
+	reCode := regexp.MustCompile("(?s)```(\\w*)\n?(.*?)```")
+	md = reCode.ReplaceAllStringFunc(md, func(s string) string {
+		m := reCode.FindStringSubmatch(s)
+		b := &placeholder{orig: fmt.Sprintf("\x00CODE%d\x00", len(blocks)), language: m[1], content: escapeHTML(m[2])}
+		blocks = append(blocks, b)
+		return b.orig
+	})
+
+	// Inline elements
+	md = regexp.MustCompile("`([^`]+)`").ReplaceAllString(md, "<code>$1</code>")
+	md = regexp.MustCompile(`!\[([^\]]*)\]\(([^)]+)\)`).ReplaceAllString(md, `<img src="$2" alt="$1">`)
+	md = regexp.MustCompile(`\[([^\]]+)\]\(([^)]+)\)`).ReplaceAllString(md, `<a href="$2">$1</a>`)
+	md = regexp.MustCompile(`\*\*([^*]+)\*\*`).ReplaceAllString(md, `<strong>$1</strong>`)
+	md = regexp.MustCompile(`\*([^*]+)\*`).ReplaceAllString(md, `<em>$1</em>`)
+	md = regexp.MustCompile(`~~([^~]+)~~`).ReplaceAllString(md, `<del>$1</del>`)
+	md = regexp.MustCompile(`(?m)^#{6}\s+(.+)$`).ReplaceAllString(md, `<h6>$1</h6>`)
+	md = regexp.MustCompile(`(?m)^#{5}\s+(.+)$`).ReplaceAllString(md, `<h5>$1</h5>`)
+	md = regexp.MustCompile(`(?m)^#{4}\s+(.+)$`).ReplaceAllString(md, `<h4>$1</h4>`)
+	md = regexp.MustCompile(`(?m)^#{3}\s+(.+)$`).ReplaceAllString(md, `<h3>$1</h3>`)
+	md = regexp.MustCompile(`(?m)^#{2}\s+(.+)$`).ReplaceAllString(md, `<h2>$1</h2>`)
+	md = regexp.MustCompile(`(?m)^#{1}\s+(.+)$`).ReplaceAllString(md, `<h1>$1</h1>`)
+	md = regexp.MustCompile(`(?m)^---\s*$`).ReplaceAllString(md, `<hr>`)
+	md = regexp.MustCompile(`(?m)^>\s+(.+)$`).ReplaceAllString(md, `<blockquote>$1</blockquote>`)
+
+	// Restore code blocks
+	for _, b := range blocks {
+		langAttr := ""
+		if b.language != "" {
+			langAttr = " class=\"language-" + b.language + "\""
+		}
+		md = strings.Replace(md, b.orig, "<pre><code"+langAttr+">"+b.content+"</code></pre>", 1)
+	}
+
+	// Paragraphs
+	lines := strings.Split(md, "\n")
+	var out strings.Builder
+	for _, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		if trimmed == "" {
+			continue
+		}
+		if strings.HasPrefix(trimmed, "<") {
+			out.WriteString(trimmed + "\n")
+		} else {
+			out.WriteString("<p>" + trimmed + "</p>\n")
+		}
+	}
+	return out.String()
+}
+
+func escapeHTML(s string) string {
+	s = strings.ReplaceAll(s, "&", "&amp;")
+	s = strings.ReplaceAll(s, "<", "&lt;")
+	s = strings.ReplaceAll(s, ">", "&gt;")
+	return s
+}

backend/plugin-manager/plugins/markdown/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "markdown",
+  "displayName": "Markdown Processor",
+  "version": "1.0.0",
+  "minCyreneVersion": "1.0.0",
+  "author": { "name": "Cyrene Team" },
+  "description": "Markdown processing: to HTML, extract text/links/code, generate TOC",
+  "license": "MIT",
+  "keywords": ["markdown", "html", "text", "toc"],
+  "category": "format"
+}

backend/plugin-manager/plugins/random/plugin.go

@@ -0,0 +1,175 @@
+package random
+
+import (
+	"context"
+	"crypto/rand"
+	"fmt"
+	"math/big"
+	mathrand "math/rand"
+	"strings"
+
+	"github.com/yourname/cyrene-ai/plugin-manager/internal/sdk"
+)
+
+type RandomPlugin struct{ sdk.BasePlugin }
+
+func (p *RandomPlugin) Metadata() sdk.PluginMetadata {
+	return sdk.PluginMetadata{
+		Name: "random", DisplayName: "Random Generator", Version: "1.0.0",
+		Description: "Random generation: numbers, UUIDs, secure passwords, pick/shuffle",
+		Category: "utility", Author: sdk.PluginAuthor{Name: "Cyrene Team"},
+	}
+}
+
+func (p *RandomPlugin) Tools() []sdk.Tool { return []sdk.Tool{&RandomTool{}} }
+
+type RandomTool struct{ sdk.BaseTool }
+
+func (t *RandomTool) Definition() sdk.ToolDefinition {
+	return sdk.ToolDefinition{
+		ID: "random", Name: "random", DisplayName: "Random Generator",
+		Description: "Random generation. Random numbers, UUID v4, secure passwords, pick from list, shuffle list.",
+		Category: "utility", Complexity: sdk.ComplexitySimple,
+		Parameters: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"action": map[string]interface{}{"type": "string", "enum": []string{"number", "uuid", "password", "pick", "shuffle"}},
+				"min":    map[string]interface{}{"type": "number"},
+				"max":    map[string]interface{}{"type": "number"},
+				"length": map[string]interface{}{"type": "number"},
+				"items":  map[string]interface{}{"type": "array", "items": map[string]interface{}{"type": "string"}},
+				"count":  map[string]interface{}{"type": "number"},
+			},
+			"required": []string{"action"},
+		},
+	}
+}
+
+func (t *RandomTool) Validate(args map[string]interface{}) error {
+	if _, ok := args["action"]; !ok {
+		return fmt.Errorf("missing required parameter: action")
+	}
+	return nil
+}
+
+func (t *RandomTool) Execute(_ context.Context, args map[string]interface{}) (*sdk.ToolResult, error) {
+	action, _ := args["action"].(string)
+
+	switch action {
+	case "number":
+		min := getIntArg(args, "min", 0)
+		max := getIntArg(args, "max", 100)
+		n, err := rand.Int(rand.Reader, big.NewInt(int64(max-min+1)))
+		if err != nil {
+			return &sdk.ToolResult{ToolName: "random", Success: false, Error: err.Error()}, nil
+		}
+		return &sdk.ToolResult{ToolName: "random", Success: true,
+			Output: fmt.Sprintf("%d", int(n.Int64())+min)}, nil
+
+	case "uuid":
+		uuid := make([]byte, 16)
+		rand.Read(uuid)
+		uuid[6] = (uuid[6] & 0x0f) | 0x40
+		uuid[8] = (uuid[8] & 0x3f) | 0x80
+		return &sdk.ToolResult{ToolName: "random", Success: true,
+			Output: fmt.Sprintf("%x-%x-%x-%x-%x", uuid[0:4], uuid[4:6], uuid[6:8], uuid[8:10], uuid[10:])}, nil
+
+	case "password":
+		length := getIntArg(args, "length", 16)
+		if length < 4 {
+			length = 4
+		}
+		if length > 128 {
+			length = 128
+		}
+		upper := "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+		lower := "abcdefghijklmnopqrstuvwxyz"
+		digits := "0123456789"
+		symbols := "!@#$%^&*()_+-=[]{}|;:,.<>?"
+		all := upper + lower + digits + symbols
+		bytes := make([]byte, length)
+		for i := range bytes {
+			idx, _ := rand.Int(rand.Reader, big.NewInt(int64(len(all))))
+			bytes[i] = all[idx.Int64()]
+		}
+		return &sdk.ToolResult{ToolName: "random", Success: true, Output: string(bytes)}, nil
+
+	case "pick":
+		items := getStringSliceArg(args, "items")
+		if len(items) == 0 {
+			return &sdk.ToolResult{ToolName: "random", Success: false, Error: "items list is empty"}, nil
+		}
+		count := getIntArg(args, "count", 1)
+		if count > len(items) {
+			count = len(items)
+		}
+		indices := shuffledIndices(len(items))
+		picked := make([]string, count)
+		for i := 0; i < count; i++ {
+			picked[i] = items[indices[i]]
+		}
+		return &sdk.ToolResult{ToolName: "random", Success: true, Output: strings.Join(picked, ", ")}, nil
+
+	case "shuffle":
+		items := getStringSliceArg(args, "items")
+		indices := shuffledIndices(len(items))
+		shuffled := make([]string, len(items))
+		for i, idx := range indices {
+			shuffled[i] = items[idx]
+		}
+		return &sdk.ToolResult{ToolName: "random", Success: true, Output: strings.Join(shuffled, ", ")}, nil
+	}
+	return &sdk.ToolResult{ToolName: "random", Success: false, Error: "unknown action: " + action}, nil
+}
+
+func getIntArg(args map[string]interface{}, key string, defaultVal int) int {
+	v, ok := args[key]
+	if !ok {
+		return defaultVal
+	}
+	switch n := v.(type) {
+	case float64:
+		return int(n)
+	case int:
+		return n
+	case int64:
+		return int(n)
+	}
+	return defaultVal
+}
+
+func getStringSliceArg(args map[string]interface{}, key string) []string {
+	v, ok := args[key]
+	if !ok {
+		return nil
+	}
+	switch s := v.(type) {
+	case []string:
+		return s
+	case []interface{}:
+		result := make([]string, len(s))
+		for i, item := range s {
+			result[i] = fmt.Sprint(item)
+		}
+		return result
+	}
+	return nil
+}
+
+func shuffledIndices(n int) []int {
+	indices := make([]int, n)
+	for i := range indices {
+		indices[i] = i
+	}
+	for i := n - 1; i > 0; i-- {
+		jBig, err := rand.Int(rand.Reader, big.NewInt(int64(i+1)))
+		if err != nil {
+			j := mathrand.Intn(i + 1)
+			indices[i], indices[j] = indices[j], indices[i]
+			continue
+		}
+		j := int(jBig.Int64())
+		indices[i], indices[j] = indices[j], indices[i]
+	}
+	return indices
+}

backend/plugin-manager/plugins/random/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "random",
+  "displayName": "Random Generator",
+  "version": "1.0.0",
+  "minCyreneVersion": "1.0.0",
+  "author": { "name": "Cyrene Team" },
+  "description": "Random generation: numbers, UUIDs, secure passwords, pick/shuffle",
+  "license": "MIT",
+  "keywords": ["random", "uuid", "password", "shuffle"],
+  "category": "utility"
+}

backend/plugin-manager/plugins/text/plugin.go

@@ -0,0 +1,177 @@
+package text
+
+import (
+	"context"
+	"fmt"
+	"regexp"
+	"strings"
+	"unicode"
+
+	"github.com/yourname/cyrene-ai/plugin-manager/internal/sdk"
+)
+
+type TextPlugin struct{ sdk.BasePlugin }
+
+func (p *TextPlugin) Metadata() sdk.PluginMetadata {
+	return sdk.PluginMetadata{
+		Name: "text", DisplayName: "Text Processing", Version: "1.0.0",
+		Description: "Text processing: count stats, summarize, regex extract",
+		Category: "utility", Author: sdk.PluginAuthor{Name: "Cyrene Team"},
+	}
+}
+
+func (p *TextPlugin) Tools() []sdk.Tool { return []sdk.Tool{&TextTool{}} }
+
+type TextTool struct{ sdk.BaseTool }
+
+func (t *TextTool) Definition() sdk.ToolDefinition {
+	return sdk.ToolDefinition{
+		ID: "text", Name: "text", DisplayName: "Text Processing",
+		Description: "Text processing. Count stats, summarize, translate, regex extract.",
+		Category: "utility", Complexity: sdk.ComplexitySimple,
+		Parameters: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"action":      map[string]interface{}{"type": "string", "enum": []string{"count", "summarize", "translate", "extract"}},
+				"text":        map[string]interface{}{"type": "string"},
+				"target_lang": map[string]interface{}{"type": "string", "enum": []string{"en", "zh", "ja", "ko", "fr", "de"}},
+				"pattern":     map[string]interface{}{"type": "string"},
+			},
+			"required": []string{"action", "text"},
+		},
+	}
+}
+
+func (t *TextTool) Validate(args map[string]interface{}) error {
+	for _, k := range []string{"action", "text"} {
+		if _, ok := args[k]; !ok {
+			return fmt.Errorf("missing required parameter: %s", k)
+		}
+	}
+	return nil
+}
+
+func (t *TextTool) Execute(_ context.Context, args map[string]interface{}) (*sdk.ToolResult, error) {
+	action, _ := args["action"].(string)
+	txt, _ := args["text"].(string)
+
+	switch action {
+	case "count":
+		charsNoSpace := 0
+		chineseChars := 0
+		for _, r := range txt {
+			if !unicode.IsSpace(r) {
+				charsNoSpace++
+			}
+			if unicode.Is(unicode.Han, r) {
+				chineseChars++
+			}
+		}
+		words := strings.Fields(txt)
+		lines := strings.Split(txt, "\n")
+		paragraphs := regexp.MustCompile(`\n\s*\n`).Split(txt, -1)
+		return &sdk.ToolResult{ToolName: "text", Success: true, Output: fmt.Sprintf(
+			"Characters: %d (no spaces: %d, Chinese: %d)\nBytes: %d\nWords: %d\nLines: %d\nParagraphs: %d",
+			len([]rune(txt)), charsNoSpace, chineseChars, len(txt), len(words), len(lines), len(paragraphs))}, nil
+
+	case "summarize":
+		paragraphs := regexp.MustCompile(`\n\s*\n`).Split(txt, -1)
+		firstPara := ""
+		if len(paragraphs) > 0 {
+			runes := []rune(paragraphs[0])
+			if len(runes) > 300 {
+				runes = runes[:300]
+			}
+			firstPara = string(runes)
+		}
+		sentences := regexp.MustCompile(`[。！？.!?]+`).Split(txt, -1)
+		keywords := []string{"重要", "关键", "因此", "总结", "important", "key", "conclusion", "therefore"}
+		type scored struct {
+			text  string
+			score int
+		}
+		var scoredSents []scored
+		for _, s := range sentences {
+			s = strings.TrimSpace(s)
+			if len([]rune(s)) < 10 {
+				continue
+			}
+			score := len([]rune(s))
+			for _, kw := range keywords {
+				if strings.Contains(strings.ToLower(s), strings.ToLower(kw)) {
+					score += 20
+				}
+			}
+			scoredSents = append(scoredSents, scored{s, score})
+		}
+		var out strings.Builder
+		out.WriteString(fmt.Sprintf("First paragraph: %s\n\nKey sentences:\n", firstPara))
+		count := 0
+		for i := 0; i < len(scoredSents) && count < 5; i++ {
+			out.WriteString(fmt.Sprintf("- %s\n", scoredSents[i].text))
+			count++
+		}
+		return &sdk.ToolResult{ToolName: "text", Success: true, Output: out.String()}, nil
+
+	case "translate":
+		targetLang, _ := args["target_lang"].(string)
+		if targetLang == "" {
+			targetLang = "en"
+		}
+		return &sdk.ToolResult{ToolName: "text", Success: true, Output: fmt.Sprintf(
+			"[Translation request] Please translate the following text to %s.\n\nOriginal text:\n%s", targetLang, txt)}, nil
+
+	case "extract":
+		pattern, _ := args["pattern"].(string)
+		var out strings.Builder
+		extracted := false
+		if pattern == "" || pattern == "email" {
+			re := regexp.MustCompile(`[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}`)
+			if matches := re.FindAllString(txt, -1); len(matches) > 0 {
+				out.WriteString("Emails:\n")
+				for _, m := range matches {
+					out.WriteString(fmt.Sprintf("- %s\n", m))
+				}
+				extracted = true
+			}
+		}
+		if pattern == "" || pattern == "phone" {
+			re := regexp.MustCompile(`1[3-9]\d{9}`)
+			if matches := re.FindAllString(txt, -1); len(matches) > 0 {
+				out.WriteString("Phone numbers:\n")
+				for _, m := range matches {
+					out.WriteString(fmt.Sprintf("- %s\n", m))
+				}
+				extracted = true
+			}
+		}
+		if pattern == "" || pattern == "url" {
+			re := regexp.MustCompile(`https?://[^\s<>"{}|\\^` + "`" + `\[\]]+`)
+			if matches := re.FindAllString(txt, -1); len(matches) > 0 {
+				out.WriteString("URLs:\n")
+				for _, m := range matches {
+					out.WriteString(fmt.Sprintf("- %s\n", m))
+				}
+				extracted = true
+			}
+		}
+		if !extracted && pattern != "" && pattern != "email" && pattern != "phone" && pattern != "url" {
+			re, err := regexp.Compile(pattern)
+			if err != nil {
+				return &sdk.ToolResult{ToolName: "text", Success: false, Error: "Invalid regex: " + err.Error()}, nil
+			}
+			if matches := re.FindAllString(txt, -1); len(matches) > 0 {
+				out.WriteString(fmt.Sprintf("Pattern matches (%s):\n", pattern))
+				for _, m := range matches {
+					out.WriteString(fmt.Sprintf("- %s\n", m))
+				}
+				extracted = true
+			}
+		}
+		if !extracted {
+			return &sdk.ToolResult{ToolName: "text", Success: true, Output: "No matches found"}, nil
+		}
+		return &sdk.ToolResult{ToolName: "text", Success: true, Output: out.String()}, nil
+	}
+	return &sdk.ToolResult{ToolName: "text", Success: false, Error: "unknown action: " + action}, nil
+}

backend/plugin-manager/plugins/text/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "text",
+  "displayName": "Text Processing",
+  "version": "1.0.0",
+  "minCyreneVersion": "1.0.0",
+  "author": { "name": "Cyrene Team" },
+  "description": "Text processing: count stats, summarize, regex extract",
+  "license": "MIT",
+  "keywords": ["text", "count", "summarize", "extract"],
+  "category": "utility"
+}

backend/plugin-manager/plugins/web_fetch/plugin.go

@@ -0,0 +1,113 @@
+package webfetch
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/yourname/cyrene-ai/plugin-manager/internal/sdk"
+)
+
+type WebFetchPlugin struct {
+	sdk.BasePlugin
+	client *http.Client
+}
+
+func NewWebFetchPlugin() *WebFetchPlugin {
+	return &WebFetchPlugin{client: &http.Client{Timeout: 15 * time.Second}}
+}
+
+func (p *WebFetchPlugin) Metadata() sdk.PluginMetadata {
+	return sdk.PluginMetadata{
+		Name: "web_fetch", DisplayName: "Web Fetch", Version: "1.0.0",
+		Description: "Fetch and extract text content from URLs",
+		Category: "network", Author: sdk.PluginAuthor{Name: "Cyrene Team"},
+	}
+}
+
+func (p *WebFetchPlugin) Tools() []sdk.Tool { return []sdk.Tool{&WebFetchTool{client: p.client}} }
+
+type WebFetchTool struct {
+	sdk.BaseTool
+	client *http.Client
+}
+
+func (t *WebFetchTool) Definition() sdk.ToolDefinition {
+	return sdk.ToolDefinition{
+		ID: "web_fetch", Name: "web_fetch", DisplayName: "Web Fetch",
+		Description: "Fetch content of a specified URL. Returns plain text summary (first 2000 characters). HTTP/HTTPS only.",
+		Category: "network", Complexity: sdk.ComplexitySimple,
+		Parameters: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{"url": map[string]interface{}{"type": "string"}},
+			"required": []string{"url"},
+		},
+	}
+}
+
+func (t *WebFetchTool) Validate(args map[string]interface{}) error {
+	if _, ok := args["url"]; !ok {
+		return fmt.Errorf("missing required parameter: url")
+	}
+	return nil
+}
+
+func (t *WebFetchTool) Execute(_ context.Context, args map[string]interface{}) (*sdk.ToolResult, error) {
+	urlStr, _ := args["url"].(string)
+	if !strings.HasPrefix(urlStr, "http://") && !strings.HasPrefix(urlStr, "https://") {
+		return &sdk.ToolResult{ToolName: "web_fetch", Success: false, Error: "only http/https URLs allowed"}, nil
+	}
+
+	req, _ := http.NewRequest("GET", urlStr, nil)
+	req.Header.Set("User-Agent", "CyreneBot/1.0")
+	resp, err := t.client.Do(req)
+	if err != nil {
+		return &sdk.ToolResult{ToolName: "web_fetch", Success: false, Error: err.Error()}, nil
+	}
+	defer resp.Body.Close()
+
+	bodyBytes, _ := io.ReadAll(io.LimitReader(resp.Body, 100*1024))
+	text := stripHTMLFull(string(bodyBytes))
+	text = removeBlankLines(text)
+	runes := []rune(text)
+	if len(runes) > 2000 {
+		text = string(runes[:2000]) + "..."
+	}
+	return &sdk.ToolResult{ToolName: "web_fetch", Success: true, Output: fmt.Sprintf(
+		"URL: %s\nStatus: %d\nContent-Type: %s\n\n%s",
+		urlStr, resp.StatusCode, resp.Header.Get("Content-Type"), text)}, nil
+}
+
+func stripHTMLFull(s string) string {
+	result := make([]rune, 0, len([]rune(s)))
+	inTag := false
+	for _, r := range s {
+		if r == '<' {
+			inTag = true
+			continue
+		}
+		if r == '>' {
+			inTag = false
+			continue
+		}
+		if !inTag {
+			result = append(result, r)
+		}
+	}
+	return string(result)
+}
+
+func removeBlankLines(s string) string {
+	lines := strings.Split(s, "\n")
+	var result []string
+	for _, line := range lines {
+		trimmed := strings.TrimSpace(line)
+		if trimmed != "" {
+			result = append(result, trimmed)
+		}
+	}
+	return strings.Join(result, "\n")
+}

backend/plugin-manager/plugins/web_fetch/plugin.json

@@ -0,0 +1,12 @@
+{
+  "name": "web_fetch",
+  "displayName": "Web Fetch",
+  "version": "1.0.0",
+  "minCyreneVersion": "1.0.0",
+  "author": { "name": "Cyrene Team" },
+  "description": "Fetch and extract text content from URLs",
+  "license": "MIT",
+  "keywords": ["fetch", "web", "scrape"],
+  "category": "network",
+  "permissions": ["network:outbound"]
+}

backend/plugin-manager/plugins/web_search/plugin.go

@@ -0,0 +1,136 @@
+package websearch
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"github.com/yourname/cyrene-ai/plugin-manager/internal/sdk"
+)
+
+type WebSearchPlugin struct {
+	sdk.BasePlugin
+	client *http.Client
+}
+
+func NewWebSearchPlugin() *WebSearchPlugin {
+	return &WebSearchPlugin{client: &http.Client{Timeout: 10 * time.Second}}
+}
+
+func (p *WebSearchPlugin) Metadata() sdk.PluginMetadata {
+	return sdk.PluginMetadata{
+		Name: "web_search", DisplayName: "Web Search", Version: "1.0.0",
+		Description: "Search the internet via DuckDuckGo Instant Answer API",
+		Category: "network", Author: sdk.PluginAuthor{Name: "Cyrene Team"},
+	}
+}
+
+func (p *WebSearchPlugin) Tools() []sdk.Tool { return []sdk.Tool{&WebSearchTool{client: p.client}} }
+
+type WebSearchTool struct {
+	sdk.BaseTool
+	client *http.Client
+}
+
+type ddgResponse struct {
+	Abstract     string `json:"Abstract"`
+	AbstractText string `json:"AbstractText"`
+	Answer       string `json:"Answer"`
+	Heading      string `json:"Heading"`
+	Results      []ddgTopic `json:"Results"`
+	RelatedTopics []ddgTopic `json:"RelatedTopics"`
+}
+
+type ddgTopic struct {
+	FirstURL string `json:"FirstURL"`
+	Text     string `json:"Text"`
+}
+
+func (t *WebSearchTool) Definition() sdk.ToolDefinition {
+	return sdk.ToolDefinition{
+		ID: "web_search", Name: "web_search", DisplayName: "Web Search",
+		Description: "Search the internet using DuckDuckGo Instant Answer API. Returns up to 5 results.",
+		Category: "network", Complexity: sdk.ComplexitySimple,
+		Parameters: map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{"query": map[string]interface{}{"type": "string"}},
+			"required": []string{"query"},
+		},
+	}
+}
+
+func (t *WebSearchTool) Validate(args map[string]interface{}) error {
+	if _, ok := args["query"]; !ok {
+		return fmt.Errorf("missing required parameter: query")
+	}
+	return nil
+}
+
+func (t *WebSearchTool) Execute(_ context.Context, args map[string]interface{}) (*sdk.ToolResult, error) {
+	query, _ := args["query"].(string)
+	apiURL := fmt.Sprintf("https://api.duckduckgo.com/?q=%s&format=json&no_html=1", url.QueryEscape(query))
+	resp, err := t.client.Get(apiURL)
+	if err != nil {
+		return &sdk.ToolResult{ToolName: "web_search", Success: false, Error: err.Error()}, nil
+	}
+	defer resp.Body.Close()
+
+	var result ddgResponse
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		return &sdk.ToolResult{ToolName: "web_search", Success: false, Error: err.Error()}, nil
+	}
+
+	var out strings.Builder
+	if result.Answer != "" {
+		out.WriteString(fmt.Sprintf("Answer: %s\n\n", result.Answer))
+	}
+	if result.AbstractText != "" {
+		text := result.AbstractText
+		if len([]rune(text)) > 500 {
+			text = string([]rune(text)[:500]) + "..."
+		}
+		out.WriteString(fmt.Sprintf("Abstract: %s\n\n", stripHTML(text)))
+	}
+	topics := result.Results
+	if len(topics) == 0 {
+		topics = result.RelatedTopics
+	}
+	count := 0
+	for _, topic := range topics {
+		if count >= 5 {
+			break
+		}
+		if topic.Text == "" {
+			continue
+		}
+		out.WriteString(fmt.Sprintf("%d. %s (%s)\n", count+1, stripHTML(topic.Text), topic.FirstURL))
+		count++
+	}
+	if out.Len() == 0 {
+		return &sdk.ToolResult{ToolName: "web_search", Success: true, Output: "No results found for: " + query}, nil
+	}
+	return &sdk.ToolResult{ToolName: "web_search", Success: true, Output: out.String()}, nil
+}
+
+func stripHTML(s string) string {
+	result := make([]rune, 0, len([]rune(s)))
+	inTag := false
+	for _, r := range s {
+		if r == '<' {
+			inTag = true
+			continue
+		}
+		if r == '>' {
+			inTag = false
+			continue
+		}
+		if !inTag {
+			result = append(result, r)
+		}
+	}
+	return strings.TrimSpace(string(result))
+}

backend/plugin-manager/plugins/web_search/plugin.json

@@ -0,0 +1,12 @@
+{
+  "name": "web_search",
+  "displayName": "Web Search",
+  "version": "1.0.0",
+  "minCyreneVersion": "1.0.0",
+  "author": { "name": "Cyrene Team" },
+  "description": "Search the internet via DuckDuckGo Instant Answer API",
+  "license": "MIT",
+  "keywords": ["search", "web", "duckduckgo"],
+  "category": "network",
+  "permissions": ["network:outbound"]
+}