chore: bump version to 0.4.8

fix: include custom tools in Ollama API requests
Custom tools were displayed as enabled in the UI but never sent to Ollama because getEnabledToolDefinitions() only queried the builtin tool registry. Now iterates customTools and includes enabled ones. Fixes #4
2026-01-03 15:32:04 +01:00 · 2026-01-03 15:29:25 +01:00 · 2026-01-02 22:42:35 +01:00 · 2026-01-02 22:41:37 +01:00 · 2026-01-02 22:35:03 +01:00 · 2026-01-02 21:54:50 +01:00
31 changed files with 2413 additions and 97 deletions
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -0,0 +1,27 @@
+name: Create Release
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          generate_release_notes: true
+          body: |
+            See the [full release notes on Gitea](https://somegit.dev/vikingowl/vessel/releases) for detailed information.
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
--- a/.gitignore
+++ b/.gitignore
@@ -33,3 +33,12 @@ backend/server
 # Docker
 *.pid
 docker-compose.override.yml
+
+# Claude Code project instructions (local only)
+CLAUDE.md
+
+# Dev artifacts
+dev.env
+backend/vessel-backend
+data/
+backend/data-dev/
--- a/backend/Dockerfile
+++ b/backend/Dockerfile
@@ -18,8 +18,8 @@ RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -o server ./cmd/serv
 # Final stage
 FROM alpine:latest

-# curl for web fetching, ca-certificates for HTTPS
-RUN apk --no-cache add ca-certificates curl
+# curl for web fetching, ca-certificates for HTTPS, python3 for tool execution
+RUN apk --no-cache add ca-certificates curl python3

 WORKDIR /app

--- a/backend/cmd/server/main.go
+++ b/backend/cmd/server/main.go
@@ -18,7 +18,7 @@ import (
 )

 // Version is set at build time via -ldflags, or defaults to dev
-var Version = "0.3.0"
+var Version = "0.4.8"

 func getEnvOrDefault(key, defaultValue string) string {
 	if value := os.Getenv(key); value != "" {
--- a/backend/internal/api/model_registry.go
+++ b/backend/internal/api/model_registry.go
@@ -70,6 +70,7 @@ type ScrapedModel struct {
 	PullCount    int64
 	Tags         []string
 	Capabilities []string
+	UpdatedAt    string // Relative time like "2 weeks ago" converted to RFC3339
 }

 // scrapeOllamaLibrary fetches the model list from ollama.com/library
@@ -168,6 +169,14 @@ func parseLibraryHTML(html string) ([]ScrapedModel, error) {
 			capabilities = append(capabilities, "cloud")
 		}

+		// Extract updated time from <span x-test-updated>2 weeks ago</span>
+		updatedPattern := regexp.MustCompile(`<span[^>]*x-test-updated[^>]*>([^<]+)</span>`)
+		updatedAt := ""
+		if um := updatedPattern.FindStringSubmatch(cardContent); len(um) > 1 {
+			relativeTime := strings.TrimSpace(um[1])
+			updatedAt = parseRelativeTime(relativeTime)
+		}
+
 		models[slug] = &ScrapedModel{
 			Slug:         slug,
 			Name:         slug,
@@ -176,6 +185,7 @@ func parseLibraryHTML(html string) ([]ScrapedModel, error) {
 			PullCount:    pullCount,
 			Tags:         tags,
 			Capabilities: capabilities,
+			UpdatedAt:    updatedAt,
 		}
 	}

@@ -211,6 +221,52 @@ func decodeHTMLEntities(s string) string {
 	return s
 }

+// parseRelativeTime converts relative time strings like "2 weeks ago" to RFC3339 timestamps
+func parseRelativeTime(s string) string {
+	s = strings.ToLower(strings.TrimSpace(s))
+	if s == "" {
+		return ""
+	}
+
+	now := time.Now()
+
+	// Parse patterns like "2 weeks ago", "1 month ago", "3 days ago"
+	pattern := regexp.MustCompile(`(\d+)\s*(second|minute|hour|day|week|month|year)s?\s*ago`)
+	matches := pattern.FindStringSubmatch(s)
+	if len(matches) < 3 {
+		return ""
+	}
+
+	num, err := strconv.Atoi(matches[1])
+	if err != nil {
+		return ""
+	}
+
+	unit := matches[2]
+	var duration time.Duration
+
+	switch unit {
+	case "second":
+		duration = time.Duration(num) * time.Second
+	case "minute":
+		duration = time.Duration(num) * time.Minute
+	case "hour":
+		duration = time.Duration(num) * time.Hour
+	case "day":
+		duration = time.Duration(num) * 24 * time.Hour
+	case "week":
+		duration = time.Duration(num) * 7 * 24 * time.Hour
+	case "month":
+		duration = time.Duration(num) * 30 * 24 * time.Hour
+	case "year":
+		duration = time.Duration(num) * 365 * 24 * time.Hour
+	default:
+		return ""
+	}
+
+	return now.Add(-duration).Format(time.RFC3339)
+}
+
 // extractDescription tries to find the description for a model
 func extractDescription(html, slug string) string {
 	// Look for text after the model link that looks like a description
@@ -417,15 +473,16 @@ func (s *ModelRegistryService) SyncModels(ctx context.Context, fetchDetails bool
 		modelType := inferModelType(model.Slug)

 		_, err := s.db.ExecContext(ctx, `
-			INSERT INTO remote_models (slug, name, description, model_type, url, pull_count, tags, capabilities, scraped_at)
-			VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+			INSERT INTO remote_models (slug, name, description, model_type, url, pull_count, tags, capabilities, ollama_updated_at, scraped_at)
+			VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
 			ON CONFLICT(slug) DO UPDATE SET
 				description = COALESCE(NULLIF(excluded.description, ''), remote_models.description),
 				model_type = excluded.model_type,
 				pull_count = excluded.pull_count,
 				capabilities = excluded.capabilities,
+				ollama_updated_at = COALESCE(excluded.ollama_updated_at, remote_models.ollama_updated_at),
 				scraped_at = excluded.scraped_at
-		`, model.Slug, model.Name, model.Description, modelType, model.URL, model.PullCount, string(tagsJSON), string(capsJSON), now)
+		`, model.Slug, model.Name, model.Description, modelType, model.URL, model.PullCount, string(tagsJSON), string(capsJSON), model.UpdatedAt, now)

 		if err != nil {
 			log.Printf("Failed to upsert model %s: %v", model.Slug, err)
@@ -434,6 +491,55 @@ func (s *ModelRegistryService) SyncModels(ctx context.Context, fetchDetails bool
 		count++
 	}

+	// If fetchDetails is true and we have an Ollama client, update capabilities
+	// for installed models using the actual /api/show response (more accurate than scraped data)
+	if fetchDetails && s.ollamaClient != nil {
+		installedModels, err := s.ollamaClient.List(ctx)
+		if err != nil {
+			log.Printf("Warning: failed to list installed models for capability sync: %v", err)
+		} else {
+			log.Printf("Syncing capabilities for %d installed models", len(installedModels.Models))
+
+			for _, installed := range installedModels.Models {
+				select {
+				case <-ctx.Done():
+					return count, ctx.Err()
+				default:
+				}
+
+				// Extract base model name (e.g., "deepseek-r1" from "deepseek-r1:14b")
+				modelName := installed.Model
+				baseName := strings.Split(modelName, ":")[0]
+
+				// Fetch real capabilities from Ollama
+				details, err := s.fetchModelDetails(ctx, modelName)
+				if err != nil {
+					log.Printf("Warning: failed to fetch details for %s: %v", modelName, err)
+					continue
+				}
+
+				// Extract capabilities from the actual Ollama response
+				capabilities := []string{}
+				if details.Capabilities != nil {
+					for _, cap := range details.Capabilities {
+						capabilities = append(capabilities, string(cap))
+					}
+				}
+				capsJSON, _ := json.Marshal(capabilities)
+
+				// Update capabilities for the base model name
+				_, err = s.db.ExecContext(ctx, `
+					UPDATE remote_models SET capabilities = ? WHERE slug = ?
+				`, string(capsJSON), baseName)
+				if err != nil {
+					log.Printf("Warning: failed to update capabilities for %s: %v", baseName, err)
+				} else {
+					log.Printf("Updated capabilities for %s: %v", baseName, capabilities)
+				}
+			}
+		}
+	}
+
 	return count, nil
 }

@@ -572,6 +678,106 @@ func formatParamCount(n int64) string {
 	return fmt.Sprintf("%d", n)
 }

+// parseParamSizeToFloat extracts numeric value from parameter size strings like "8b", "70b", "1.5b"
+// Returns value in billions (e.g., "8b" -> 8.0, "70b" -> 70.0, "500m" -> 0.5)
+func parseParamSizeToFloat(s string) float64 {
+	s = strings.ToLower(strings.TrimSpace(s))
+	if s == "" {
+		return 0
+	}
+
+	// Handle suffix
+	multiplier := 1.0
+	if strings.HasSuffix(s, "b") {
+		s = strings.TrimSuffix(s, "b")
+	} else if strings.HasSuffix(s, "m") {
+		s = strings.TrimSuffix(s, "m")
+		multiplier = 0.001 // Convert millions to billions
+	}
+
+	if f, err := strconv.ParseFloat(s, 64); err == nil {
+		return f * multiplier
+	}
+	return 0
+}
+
+// getSizeRange returns the size range category for a given parameter size
+// small: ≤3B, medium: 4-13B, large: 14-70B, xlarge: >70B
+func getSizeRange(paramSize string) string {
+	size := parseParamSizeToFloat(paramSize)
+	if size <= 0 {
+		return ""
+	}
+	if size <= 3 {
+		return "small"
+	}
+	if size <= 13 {
+		return "medium"
+	}
+	if size <= 70 {
+		return "large"
+	}
+	return "xlarge"
+}
+
+// modelMatchesSizeRanges checks if any of the model's tags fall within the requested size ranges
+// A model matches if at least one of its tags is in any of the requested ranges
+func modelMatchesSizeRanges(tags []string, sizeRanges []string) bool {
+	if len(tags) == 0 || len(sizeRanges) == 0 {
+		return false
+	}
+	for _, tag := range tags {
+		tagRange := getSizeRange(tag)
+		if tagRange == "" {
+			continue
+		}
+		for _, sr := range sizeRanges {
+			if sr == tagRange {
+				return true
+			}
+		}
+	}
+	return false
+}
+
+// getContextRange returns the context range category for a given context length
+// standard: ≤8K, extended: 8K-32K, large: 32K-128K, unlimited: >128K
+func getContextRange(ctxLen int64) string {
+	if ctxLen <= 0 {
+		return ""
+	}
+	if ctxLen <= 8192 {
+		return "standard"
+	}
+	if ctxLen <= 32768 {
+		return "extended"
+	}
+	if ctxLen <= 131072 {
+		return "large"
+	}
+	return "unlimited"
+}
+
+// extractFamily extracts the model family from slug (e.g., "llama3.2" -> "llama", "qwen2.5" -> "qwen")
+func extractFamily(slug string) string {
+	// Remove namespace prefix for community models
+	if idx := strings.LastIndex(slug, "/"); idx != -1 {
+		slug = slug[idx+1:]
+	}
+	// Extract letters before any digits
+	family := ""
+	for _, r := range slug {
+		if r >= '0' && r <= '9' {
+			break
+		}
+		if r == '-' || r == '_' || r == '.' {
+			break
+		}
+		family += string(r)
+	}
+	return strings.ToLower(family)
+}
+
 // GetModel retrieves a single model from the database
 func (s *ModelRegistryService) GetModel(ctx context.Context, slug string) (*RemoteModel, error) {
 	row := s.db.QueryRowContext(ctx, `
@@ -584,40 +790,65 @@ func (s *ModelRegistryService) GetModel(ctx context.Context, slug string) (*Remo
 	return scanRemoteModel(row)
 }

+// ModelSearchParams holds all search/filter parameters
+type ModelSearchParams struct {
+	Query         string
+	ModelType     string
+	Capabilities  []string
+	SizeRanges    []string // small, medium, large, xlarge
+	ContextRanges []string // standard, extended, large, unlimited
+	Family        string
+	SortBy        string
+	Limit         int
+	Offset        int
+}
+
 // SearchModels searches for models in the database
 func (s *ModelRegistryService) SearchModels(ctx context.Context, query string, modelType string, capabilities []string, sortBy string, limit, offset int) ([]RemoteModel, int, error) {
+	return s.SearchModelsAdvanced(ctx, ModelSearchParams{
+		Query:        query,
+		ModelType:    modelType,
+		Capabilities: capabilities,
+		SortBy:       sortBy,
+		Limit:        limit,
+		Offset:       offset,
+	})
+}
+
+// SearchModelsAdvanced searches for models with all filter options
+func (s *ModelRegistryService) SearchModelsAdvanced(ctx context.Context, params ModelSearchParams) ([]RemoteModel, int, error) {
 	// Build query
 	baseQuery := `FROM remote_models WHERE 1=1`
 	args := []any{}

-	if query != "" {
+	if params.Query != "" {
 		baseQuery += ` AND (slug LIKE ? OR name LIKE ? OR description LIKE ?)`
-		q := "%" + query + "%"
+		q := "%" + params.Query + "%"
 		args = append(args, q, q, q)
 	}

-	if modelType != "" {
+	if params.ModelType != "" {
 		baseQuery += ` AND model_type = ?`
-		args = append(args, modelType)
+		args = append(args, params.ModelType)
 	}

 	// Filter by capabilities (JSON array contains)
-	for _, cap := range capabilities {
+	for _, cap := range params.Capabilities {
 		// Use JSON contains for SQLite - capabilities column stores JSON array like ["vision","code"]
 		baseQuery += ` AND capabilities LIKE ?`
 		args = append(args, `%"`+cap+`"%`)
 	}

-	// Get total count
-	var total int
-	countQuery := "SELECT COUNT(*) " + baseQuery
-	if err := s.db.QueryRowContext(ctx, countQuery, args...).Scan(&total); err != nil {
-		return nil, 0, err
+	// Filter by family (extracted from slug)
+	if params.Family != "" {
+		// Match slugs that start with the family name
+		baseQuery += ` AND (slug LIKE ? OR slug LIKE ?)`
+		args = append(args, params.Family+"%", "%/"+params.Family+"%")
 	}

 	// Build ORDER BY clause based on sort parameter
 	orderBy := "pull_count DESC" // default: most popular
-	switch sortBy {
+	switch params.SortBy {
 	case "name_asc":
 		orderBy = "name ASC"
 	case "name_desc":
@@ -630,12 +861,25 @@ func (s *ModelRegistryService) SearchModels(ctx context.Context, query string, m
 		orderBy = "ollama_updated_at DESC NULLS LAST, scraped_at DESC"
 	}

-	// Get models
-	selectQuery := `SELECT slug, name, description, model_type, architecture, parameter_size,
-		context_length, embedding_length, quantization, capabilities, default_params,
-		license, pull_count, tags, tag_sizes, ollama_updated_at, details_fetched_at, scraped_at, url ` +
-		baseQuery + ` ORDER BY ` + orderBy + ` LIMIT ? OFFSET ?`
-	args = append(args, limit, offset)
+	// For size/context filtering, we need to fetch all matching models first
+	// then filter and paginate in memory (these filters require computed values)
+	needsPostFilter := len(params.SizeRanges) > 0 || len(params.ContextRanges) > 0
+
+	var selectQuery string
+	if needsPostFilter {
+		// Fetch all (no limit/offset) for post-filtering
+		selectQuery = `SELECT slug, name, description, model_type, architecture, parameter_size,
+			context_length, embedding_length, quantization, capabilities, default_params,
+			license, pull_count, tags, tag_sizes, ollama_updated_at, details_fetched_at, scraped_at, url ` +
+			baseQuery + ` ORDER BY ` + orderBy
+	} else {
+		// Direct pagination
+		selectQuery = `SELECT slug, name, description, model_type, architecture, parameter_size,
+			context_length, embedding_length, quantization, capabilities, default_params,
+			license, pull_count, tags, tag_sizes, ollama_updated_at, details_fetched_at, scraped_at, url ` +
+			baseQuery + ` ORDER BY ` + orderBy + ` LIMIT ? OFFSET ?`
+		args = append(args, params.Limit, params.Offset)
+	}

 	rows, err := s.db.QueryContext(ctx, selectQuery, args...)
 	if err != nil {
@@ -649,10 +893,64 @@ func (s *ModelRegistryService) SearchModels(ctx context.Context, query string, m
 		if err != nil {
 			return nil, 0, err
 		}
+
+		// Apply size range filter based on tags
+		if len(params.SizeRanges) > 0 {
+			if !modelMatchesSizeRanges(m.Tags, params.SizeRanges) {
+				continue // Skip models without matching size tags
+			}
+		}
+
+		// Apply context range filter
+		if len(params.ContextRanges) > 0 {
+			modelCtxRange := getContextRange(m.ContextLength)
+			if modelCtxRange == "" {
+				continue // Skip models without context info
+			}
+			found := false
+			for _, cr := range params.ContextRanges {
+				if cr == modelCtxRange {
+					found = true
+					break
+				}
+			}
+			if !found {
+				continue
+			}
+		}
+
 		models = append(models, *m)
 	}

-	return models, total, rows.Err()
+	if err := rows.Err(); err != nil {
+		return nil, 0, err
+	}
+
+	// Get total after filtering
+	total := len(models)
+
+	// Apply pagination for post-filtered results
+	if needsPostFilter {
+		if params.Offset >= len(models) {
+			models = []RemoteModel{}
+		} else {
+			end := params.Offset + params.Limit
+			if end > len(models) {
+				end = len(models)
+			}
+			models = models[params.Offset:end]
+		}
+	} else {
+		// Get total count from DB for non-post-filtered queries
+		countQuery := "SELECT COUNT(*) " + baseQuery
+		// Remove the limit/offset args we added
+		countArgs := args[:len(args)-2]
+		if err := s.db.QueryRowContext(ctx, countQuery, countArgs...).Scan(&total); err != nil {
+			return nil, 0, err
+		}
+	}
+
+	return models, total, nil
 }

 // GetSyncStatus returns info about when models were last synced
@@ -764,31 +1062,53 @@ func scanRemoteModelRows(rows *sql.Rows) (*RemoteModel, error) {
 // ListRemoteModelsHandler returns a handler for listing/searching remote models
 func (s *ModelRegistryService) ListRemoteModelsHandler() gin.HandlerFunc {
 	return func(c *gin.Context) {
-		query := c.Query("search")
-		modelType := c.Query("type")
-		sortBy := c.Query("sort") // name_asc, name_desc, pulls_asc, pulls_desc, updated_desc
-		limit := 50
-		offset := 0
+		params := ModelSearchParams{
+			Query:     c.Query("search"),
+			ModelType: c.Query("type"),
+			SortBy:    c.Query("sort"), // name_asc, name_desc, pulls_asc, pulls_desc, updated_desc
+			Family:    c.Query("family"),
+			Limit:     50,
+			Offset:    0,
+		}

 		if l, err := strconv.Atoi(c.Query("limit")); err == nil && l > 0 && l <= 200 {
-			limit = l
+			params.Limit = l
 		}
 		if o, err := strconv.Atoi(c.Query("offset")); err == nil && o >= 0 {
-			offset = o
+			params.Offset = o
 		}

 		// Parse capabilities filter (comma-separated)
-		var capabilities []string
 		if caps := c.Query("capabilities"); caps != "" {
 			for _, cap := range strings.Split(caps, ",") {
 				cap = strings.TrimSpace(cap)
 				if cap != "" {
-					capabilities = append(capabilities, cap)
+					params.Capabilities = append(params.Capabilities, cap)
 				}
 			}
 		}

-		models, total, err := s.SearchModels(c.Request.Context(), query, modelType, capabilities, sortBy, limit, offset)
+		// Parse size range filter (comma-separated: small,medium,large,xlarge)
+		if sizes := c.Query("sizeRange"); sizes != "" {
+			for _, sz := range strings.Split(sizes, ",") {
+				sz = strings.TrimSpace(strings.ToLower(sz))
+				if sz == "small" || sz == "medium" || sz == "large" || sz == "xlarge" {
+					params.SizeRanges = append(params.SizeRanges, sz)
+				}
+			}
+		}
+
+		// Parse context range filter (comma-separated: standard,extended,large,unlimited)
+		if ctx := c.Query("contextRange"); ctx != "" {
+			for _, cr := range strings.Split(ctx, ",") {
+				cr = strings.TrimSpace(strings.ToLower(cr))
+				if cr == "standard" || cr == "extended" || cr == "large" || cr == "unlimited" {
+					params.ContextRanges = append(params.ContextRanges, cr)
+				}
+			}
+		}
+
+		models, total, err := s.SearchModelsAdvanced(c.Request.Context(), params)
 		if err != nil {
 			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 			return
@@ -797,8 +1117,8 @@ func (s *ModelRegistryService) ListRemoteModelsHandler() gin.HandlerFunc {
 		c.JSON(http.StatusOK, gin.H{
 			"models": models,
 			"total":  total,
-			"limit":  limit,
-			"offset": offset,
+			"limit":  params.Limit,
+			"offset": params.Offset,
 		})
 	}
 }
@@ -1138,3 +1458,36 @@ func (s *ModelRegistryService) GetLocalFamiliesHandler() gin.HandlerFunc {
 		c.JSON(http.StatusOK, gin.H{"families": families})
 	}
 }
+
+// GetRemoteFamiliesHandler returns unique model families from remote models
+// Useful for populating filter dropdowns
+func (s *ModelRegistryService) GetRemoteFamiliesHandler() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		rows, err := s.db.QueryContext(c.Request.Context(), `SELECT DISTINCT slug FROM remote_models`)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+			return
+		}
+		defer rows.Close()
+
+		familySet := make(map[string]bool)
+		for rows.Next() {
+			var slug string
+			if err := rows.Scan(&slug); err != nil {
+				continue
+			}
+			family := extractFamily(slug)
+			if family != "" {
+				familySet[family] = true
+			}
+		}
+
+		families := make([]string, 0, len(familySet))
+		for f := range familySet {
+			families = append(families, f)
+		}
+		sort.Strings(families)
+
+		c.JSON(http.StatusOK, gin.H{"families": families})
+	}
+}
--- a/backend/internal/api/routes.go
+++ b/backend/internal/api/routes.go
@@ -66,6 +66,9 @@ func SetupRoutes(r *gin.Engine, db *sql.DB, ollamaURL string, appVersion string)
 		// IP-based geolocation (fallback when browser geolocation fails)
 		v1.GET("/location", IPGeolocationHandler())

+		// Tool execution (for Python tools)
+		v1.POST("/tools/execute", ExecuteToolHandler())
+
 		// Model registry routes (cached models from ollama.com)
 		models := v1.Group("/models")
 		{
@@ -80,6 +83,8 @@ func SetupRoutes(r *gin.Engine, db *sql.DB, ollamaURL string, appVersion string)
 			// === Remote Models (from ollama.com cache) ===
 			// List/search remote models (from cache)
 			models.GET("/remote", modelRegistry.ListRemoteModelsHandler())
+			// Get unique model families for filter dropdowns
+			models.GET("/remote/families", modelRegistry.GetRemoteFamiliesHandler())
 			// Get single model details
 			models.GET("/remote/:slug", modelRegistry.GetRemoteModelHandler())
 			// Fetch detailed info from Ollama (requires model to be pulled)
--- a/backend/internal/api/tools.go
+++ b/backend/internal/api/tools.go
@@ -0,0 +1,174 @@
+package api
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+	"os"
+	"os/exec"
+	"time"
+
+	"github.com/gin-gonic/gin"
+)
+
+// ExecuteToolRequest represents a tool execution request
+type ExecuteToolRequest struct {
+	Language string                 `json:"language" binding:"required,oneof=python javascript"`
+	Code     string                 `json:"code" binding:"required"`
+	Args     map[string]interface{} `json:"args"`
+	Timeout  int                    `json:"timeout"` // seconds, default 30
+}
+
+// ExecuteToolResponse represents the tool execution response
+type ExecuteToolResponse struct {
+	Success bool        `json:"success"`
+	Result  interface{} `json:"result,omitempty"`
+	Error   string      `json:"error,omitempty"`
+	Stdout  string      `json:"stdout,omitempty"`
+	Stderr  string      `json:"stderr,omitempty"`
+}
+
+// MaxOutputSize is the maximum size of tool output (100KB)
+const MaxOutputSize = 100 * 1024
+
+// ExecuteToolHandler handles tool execution requests
+func ExecuteToolHandler() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		var req ExecuteToolRequest
+		if err := c.ShouldBindJSON(&req); err != nil {
+			c.JSON(http.StatusBadRequest, ExecuteToolResponse{
+				Success: false,
+				Error:   "Invalid request: " + err.Error(),
+			})
+			return
+		}
+
+		// Default timeout
+		timeout := req.Timeout
+		if timeout <= 0 || timeout > 60 {
+			timeout = 30
+		}
+
+		var resp ExecuteToolResponse
+
+		switch req.Language {
+		case "python":
+			resp = executePython(req.Code, req.Args, timeout)
+		case "javascript":
+			// JavaScript execution not supported on backend (runs in browser)
+			resp = ExecuteToolResponse{
+				Success: false,
+				Error:   "JavaScript tools should be executed in the browser",
+			}
+		default:
+			resp = ExecuteToolResponse{
+				Success: false,
+				Error:   "Unsupported language: " + req.Language,
+			}
+		}
+
+		c.JSON(http.StatusOK, resp)
+	}
+}
+
+// executePython executes Python code with the given arguments
+func executePython(code string, args map[string]interface{}, timeout int) ExecuteToolResponse {
+	// Create a wrapper script that reads args from stdin
+	wrapperScript := `
+import json
+import sys
+
+# Read args from stdin
+args = json.loads(sys.stdin.read())
+
+# Execute user code
+` + code
+
+	// Create temp file for the script
+	tmpFile, err := os.CreateTemp("", "tool-*.py")
+	if err != nil {
+		return ExecuteToolResponse{
+			Success: false,
+			Error:   "Failed to create temp file: " + err.Error(),
+		}
+	}
+	defer os.Remove(tmpFile.Name())
+
+	if _, err := tmpFile.WriteString(wrapperScript); err != nil {
+		return ExecuteToolResponse{
+			Success: false,
+			Error:   "Failed to write script: " + err.Error(),
+		}
+	}
+	tmpFile.Close()
+
+	// Marshal args to JSON for stdin
+	argsJSON, err := json.Marshal(args)
+	if err != nil {
+		return ExecuteToolResponse{
+			Success: false,
+			Error:   "Failed to serialize args: " + err.Error(),
+		}
+	}
+
+	// Create context with timeout
+	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(timeout)*time.Second)
+	defer cancel()
+
+	// Execute Python (using exec.Command, not shell)
+	cmd := exec.CommandContext(ctx, "python3", tmpFile.Name())
+	cmd.Stdin = bytes.NewReader(argsJSON)
+
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	err = cmd.Run()
+
+	// Check for timeout
+	if ctx.Err() == context.DeadlineExceeded {
+		return ExecuteToolResponse{
+			Success: false,
+			Error:   "Execution timed out after " + string(rune(timeout)) + " seconds",
+			Stderr:  truncateOutput(stderr.String()),
+		}
+	}
+
+	// Truncate output if needed
+	stdoutStr := truncateOutput(stdout.String())
+	stderrStr := truncateOutput(stderr.String())
+
+	if err != nil {
+		return ExecuteToolResponse{
+			Success: false,
+			Error:   "Execution failed: " + err.Error(),
+			Stdout:  stdoutStr,
+			Stderr:  stderrStr,
+		}
+	}
+
+	// Try to parse stdout as JSON
+	var result interface{}
+	if stdoutStr != "" {
+		if err := json.Unmarshal([]byte(stdoutStr), &result); err != nil {
+			// If not valid JSON, return as string
+			result = stdoutStr
+		}
+	}
+
+	return ExecuteToolResponse{
+		Success: true,
+		Result:  result,
+		Stdout:  stdoutStr,
+		Stderr:  stderrStr,
+	}
+}
+
+// truncateOutput truncates output to MaxOutputSize
+func truncateOutput(s string) string {
+	if len(s) > MaxOutputSize {
+		return s[:MaxOutputSize] + "\n... (output truncated)"
+	}
+	return s
+}
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -1,17 +1,22 @@
 {
  "name": "vessel",
-  "version": "0.1.0",
+  "version": "0.3.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "vessel",
-      "version": "0.1.0",
+      "version": "0.3.0",
      "dependencies": {
+        "@codemirror/lang-javascript": "^6.2.3",
+        "@codemirror/lang-json": "^6.0.1",
+        "@codemirror/lang-python": "^6.1.7",
+        "@codemirror/theme-one-dark": "^6.1.2",
        "@skeletonlabs/skeleton": "^2.10.0",
        "@skeletonlabs/tw-plugin": "^0.4.0",
        "@sveltejs/adapter-node": "^5.4.0",
        "@types/dompurify": "^3.0.5",
+        "codemirror": "^6.0.1",
        "dexie": "^4.0.10",
        "dompurify": "^3.2.0",
        "marked": "^15.0.0",
@@ -110,6 +115,137 @@
        "node": ">=6.9.0"
      }
    },
+    "node_modules/@codemirror/autocomplete": {
+      "version": "6.20.0",
+      "resolved": "https://registry.npmjs.org/@codemirror/autocomplete/-/autocomplete-6.20.0.tgz",
+      "integrity": "sha512-bOwvTOIJcG5FVo5gUUupiwYh8MioPLQ4UcqbcRf7UQ98X90tCa9E1kZ3Z7tqwpZxYyOvh1YTYbmZE9RTfTp5hg==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/language": "^6.0.0",
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.17.0",
+        "@lezer/common": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/commands": {
+      "version": "6.10.1",
+      "resolved": "https://registry.npmjs.org/@codemirror/commands/-/commands-6.10.1.tgz",
+      "integrity": "sha512-uWDWFypNdQmz2y1LaNJzK7fL7TYKLeUAU0npEC685OKTF3KcQ2Vu3klIM78D7I6wGhktme0lh3CuQLv0ZCrD9Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/language": "^6.0.0",
+        "@codemirror/state": "^6.4.0",
+        "@codemirror/view": "^6.27.0",
+        "@lezer/common": "^1.1.0"
+      }
+    },
+    "node_modules/@codemirror/lang-javascript": {
+      "version": "6.2.4",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-javascript/-/lang-javascript-6.2.4.tgz",
+      "integrity": "sha512-0WVmhp1QOqZ4Rt6GlVGwKJN3KW7Xh4H2q8ZZNGZaP6lRdxXJzmjm4FqvmOojVj6khWJHIb9sp7U/72W7xQgqAA==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.0.0",
+        "@codemirror/language": "^6.6.0",
+        "@codemirror/lint": "^6.0.0",
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.17.0",
+        "@lezer/common": "^1.0.0",
+        "@lezer/javascript": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-json": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-json/-/lang-json-6.0.2.tgz",
+      "integrity": "sha512-x2OtO+AvwEHrEwR0FyyPtfDUiloG3rnVTSZV1W8UteaLL8/MajQd8DpvUb2YVzC+/T18aSDv0H9mu+xw0EStoQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/language": "^6.0.0",
+        "@lezer/json": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-python": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-python/-/lang-python-6.2.1.tgz",
+      "integrity": "sha512-IRjC8RUBhn9mGR9ywecNhB51yePWCGgvHfY1lWN/Mrp3cKuHr0isDKia+9HnvhiWNnMpbGhWrkhuWOc09exRyw==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.3.2",
+        "@codemirror/language": "^6.8.0",
+        "@codemirror/state": "^6.0.0",
+        "@lezer/common": "^1.2.1",
+        "@lezer/python": "^1.1.4"
+      }
+    },
+    "node_modules/@codemirror/language": {
+      "version": "6.12.1",
+      "resolved": "https://registry.npmjs.org/@codemirror/language/-/language-6.12.1.tgz",
+      "integrity": "sha512-Fa6xkSiuGKc8XC8Cn96T+TQHYj4ZZ7RdFmXA3i9xe/3hLHfwPZdM+dqfX0Cp0zQklBKhVD8Yzc8LS45rkqcwpQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.23.0",
+        "@lezer/common": "^1.5.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0",
+        "style-mod": "^4.0.0"
+      }
+    },
+    "node_modules/@codemirror/lint": {
+      "version": "6.9.2",
+      "resolved": "https://registry.npmjs.org/@codemirror/lint/-/lint-6.9.2.tgz",
+      "integrity": "sha512-sv3DylBiIyi+xKwRCJAAsBZZZWo82shJ/RTMymLabAdtbkV5cSKwWDeCgtUq3v8flTaXS2y1kKkICuRYtUswyQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.35.0",
+        "crelt": "^1.0.5"
+      }
+    },
+    "node_modules/@codemirror/search": {
+      "version": "6.5.11",
+      "resolved": "https://registry.npmjs.org/@codemirror/search/-/search-6.5.11.tgz",
+      "integrity": "sha512-KmWepDE6jUdL6n8cAAqIpRmLPBZ5ZKnicE8oGU/s3QrAVID+0VhLFrzUucVKHG5035/BSykhExDL/Xm7dHthiA==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.0.0",
+        "crelt": "^1.0.5"
+      }
+    },
+    "node_modules/@codemirror/state": {
+      "version": "6.5.3",
+      "resolved": "https://registry.npmjs.org/@codemirror/state/-/state-6.5.3.tgz",
+      "integrity": "sha512-MerMzJzlXogk2fxWFU1nKp36bY5orBG59HnPiz0G9nLRebWa0zXuv2siH6PLIHBvv5TH8CkQRqjBs0MlxCZu+A==",
+      "license": "MIT",
+      "dependencies": {
+        "@marijn/find-cluster-break": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/theme-one-dark": {
+      "version": "6.1.3",
+      "resolved": "https://registry.npmjs.org/@codemirror/theme-one-dark/-/theme-one-dark-6.1.3.tgz",
+      "integrity": "sha512-NzBdIvEJmx6fjeremiGp3t/okrLPYT0d9orIc7AFun8oZcRk58aejkqhv6spnz4MLAevrKNPMQYXEWMg4s+sKA==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/language": "^6.0.0",
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.0.0",
+        "@lezer/highlight": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/view": {
+      "version": "6.39.8",
+      "resolved": "https://registry.npmjs.org/@codemirror/view/-/view-6.39.8.tgz",
+      "integrity": "sha512-1rASYd9Z/mE3tkbC9wInRlCNyCkSn+nLsiQKZhEDUUJiUfs/5FHDpCUDaQpoTIaNGeDc6/bhaEAyLmeEucEFPw==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/state": "^6.5.0",
+        "crelt": "^1.0.6",
+        "style-mod": "^4.1.0",
+        "w3c-keyname": "^2.2.4"
+      }
+    },
    "node_modules/@csstools/color-helpers": {
      "version": "5.1.0",
      "dev": true,
@@ -698,6 +834,69 @@
        "@jridgewell/sourcemap-codec": "^1.4.14"
      }
    },
+    "node_modules/@lezer/common": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/@lezer/common/-/common-1.5.0.tgz",
+      "integrity": "sha512-PNGcolp9hr4PJdXR4ix7XtixDrClScvtSCYW3rQG106oVMOOI+jFb+0+J3mbeL/53g1Zd6s0kJzaw6Ri68GmAA==",
+      "license": "MIT"
+    },
+    "node_modules/@lezer/highlight": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@lezer/highlight/-/highlight-1.2.3.tgz",
+      "integrity": "sha512-qXdH7UqTvGfdVBINrgKhDsVTJTxactNNxLk7+UMwZhU13lMHaOBlJe9Vqp907ya56Y3+ed2tlqzys7jDkTmW0g==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.3.0"
+      }
+    },
+    "node_modules/@lezer/javascript": {
+      "version": "1.5.4",
+      "resolved": "https://registry.npmjs.org/@lezer/javascript/-/javascript-1.5.4.tgz",
+      "integrity": "sha512-vvYx3MhWqeZtGPwDStM2dwgljd5smolYD2lR2UyFcHfxbBQebqx8yjmFmxtJ/E6nN6u1D9srOiVWm3Rb4tmcUA==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.1.3",
+        "@lezer/lr": "^1.3.0"
+      }
+    },
+    "node_modules/@lezer/json": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@lezer/json/-/json-1.0.3.tgz",
+      "integrity": "sha512-BP9KzdF9Y35PDpv04r0VeSTKDeox5vVr3efE7eBbx3r4s3oNLfunchejZhjArmeieBH+nVOpgIiBJpEAv8ilqQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0"
+      }
+    },
+    "node_modules/@lezer/lr": {
+      "version": "1.4.5",
+      "resolved": "https://registry.npmjs.org/@lezer/lr/-/lr-1.4.5.tgz",
+      "integrity": "sha512-/YTRKP5yPPSo1xImYQk7AZZMAgap0kegzqCSYHjAL9x1AZ0ZQW+IpcEzMKagCsbTsLnVeWkxYrCNeXG8xEPrjg==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.0.0"
+      }
+    },
+    "node_modules/@lezer/python": {
+      "version": "1.1.18",
+      "resolved": "https://registry.npmjs.org/@lezer/python/-/python-1.1.18.tgz",
+      "integrity": "sha512-31FiUrU7z9+d/ElGQLJFXl+dKOdx0jALlP3KEOsGTex8mvj+SoE1FgItcHWK/axkxCHGUSpqIHt6JAWfWu9Rhg==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0"
+      }
+    },
+    "node_modules/@marijn/find-cluster-break": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@marijn/find-cluster-break/-/find-cluster-break-1.0.2.tgz",
+      "integrity": "sha512-l0h88YhZFyKdXIFNfSWpyjStDjGHwZ/U7iobcK1cQQD8sejsONdQtTVU+1wVN1PBw40PiiHB1vA5S7VTfQiP9g==",
+      "license": "MIT"
+    },
    "node_modules/@napi-rs/canvas": {
      "version": "0.1.88",
      "license": "MIT",
@@ -2049,6 +2248,21 @@
        "node": ">=6"
      }
    },
+    "node_modules/codemirror": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/codemirror/-/codemirror-6.0.2.tgz",
+      "integrity": "sha512-VhydHotNW5w1UGK0Qj96BwSk/Zqbp9WbnyK2W/eVMv4QyF41INRGpjUhFJY7/uDNuudSc33a/PKr4iDqRduvHw==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.0.0",
+        "@codemirror/commands": "^6.0.0",
+        "@codemirror/language": "^6.0.0",
+        "@codemirror/lint": "^6.0.0",
+        "@codemirror/search": "^6.0.0",
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.0.0"
+      }
+    },
    "node_modules/comma-separated-tokens": {
      "version": "2.0.3",
      "license": "MIT",
@@ -2075,6 +2289,12 @@
        "node": ">= 0.6"
      }
    },
+    "node_modules/crelt": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/crelt/-/crelt-1.0.6.tgz",
+      "integrity": "sha512-VQ2MBenTq1fWZUH9DJNGti7kKv6EeAuYr3cLwxUWhIu1baTaXh4Ib5W2CqHVqib4/MqbYGJqiL3Zb8GJZr3l4g==",
+      "license": "MIT"
+    },
    "node_modules/css-tree": {
      "version": "3.1.0",
      "dev": true,
@@ -3362,6 +3582,12 @@
        "url": "https://github.com/sponsors/wooorm"
      }
    },
+    "node_modules/style-mod": {
+      "version": "4.1.3",
+      "resolved": "https://registry.npmjs.org/style-mod/-/style-mod-4.1.3.tgz",
+      "integrity": "sha512-i/n8VsZydrugj3Iuzll8+x/00GH2vnYsk1eomD8QiRrSAeW6ItbCQDtfXCeJHd0iwiNagqjQkvpvREEPtW3IoQ==",
+      "license": "MIT"
+    },
    "node_modules/sucrase": {
      "version": "3.35.1",
      "license": "MIT",
@@ -3961,6 +4187,12 @@
        }
      }
    },
+    "node_modules/w3c-keyname": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/w3c-keyname/-/w3c-keyname-2.2.8.tgz",
+      "integrity": "sha512-dpojBhNsCNN7T82Tm7k26A6G9ML3NkhDsnw9n/eoxSRlVBB4CEtIQ/KTCLI2Fwf3ataSXRhYFkQi3SlnFwPvPQ==",
+      "license": "MIT"
+    },
    "node_modules/w3c-xmlserializer": {
      "version": "5.0.0",
      "dev": true,
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -1,6 +1,6 @@
 {
  "name": "vessel",
-  "version": "0.3.0",
+  "version": "0.4.8",
  "private": true,
  "type": "module",
  "scripts": {
@@ -32,7 +32,12 @@
    "vitest": "^4.0.16"
  },
  "dependencies": {
+    "@codemirror/lang-javascript": "^6.2.3",
+    "@codemirror/lang-json": "^6.0.1",
+    "@codemirror/lang-python": "^6.1.7",
+    "@codemirror/theme-one-dark": "^6.1.2",
    "@skeletonlabs/skeleton": "^2.10.0",
+    "codemirror": "^6.0.1",
    "@skeletonlabs/tw-plugin": "^0.4.0",
    "@sveltejs/adapter-node": "^5.4.0",
    "@types/dompurify": "^3.0.5",
--- a/frontend/src/lib/api/model-registry.ts
+++ b/frontend/src/lib/api/model-registry.ts
@@ -49,11 +49,20 @@ export interface SyncStatus {
 /** Sort options for model list */
 export type ModelSortOption = 'name_asc' | 'name_desc' | 'pulls_asc' | 'pulls_desc' | 'updated_desc';

+/** Size range filter options */
+export type SizeRange = 'small' | 'medium' | 'large' | 'xlarge';
+
+/** Context length range filter options */
+export type ContextRange = 'standard' | 'extended' | 'large' | 'unlimited';
+
 /** Search/filter options */
 export interface ModelSearchOptions {
 	search?: string;
 	type?: 'official' | 'community';
 	capabilities?: string[];
+	sizeRanges?: SizeRange[];
+	contextRanges?: ContextRange[];
+	family?: string;
 	sort?: ModelSortOption;
 	limit?: number;
 	offset?: number;
@@ -73,6 +82,13 @@ export async function fetchRemoteModels(options: ModelSearchOptions = {}): Promi
 	if (options.capabilities && options.capabilities.length > 0) {
 		params.set('capabilities', options.capabilities.join(','));
 	}
+	if (options.sizeRanges && options.sizeRanges.length > 0) {
+		params.set('sizeRange', options.sizeRanges.join(','));
+	}
+	if (options.contextRanges && options.contextRanges.length > 0) {
+		params.set('contextRange', options.contextRanges.join(','));
+	}
+	if (options.family) params.set('family', options.family);
 	if (options.sort) params.set('sort', options.sort);
 	if (options.limit) params.set('limit', String(options.limit));
 	if (options.offset) params.set('offset', String(options.offset));
@@ -87,6 +103,20 @@ export async function fetchRemoteModels(options: ModelSearchOptions = {}): Promi
 	return response.json();
 }

+/**
+ * Get unique model families for filter dropdowns (remote models)
+ */
+export async function fetchRemoteFamilies(): Promise<string[]> {
+	const response = await fetch(`${API_BASE}/remote/families`);
+
+	if (!response.ok) {
+		throw new Error(`Failed to fetch families: ${response.statusText}`);
+	}
+
+	const data = await response.json();
+	return data.families;
+}
+
 /**
 * Get a single remote model by slug
 */
@@ -135,9 +165,11 @@ export async function fetchTagSizes(slug: string): Promise<RemoteModel> {

 /**
 * Sync models from ollama.com
+ * @param fetchDetails - If true, also fetches real capabilities from Ollama for installed models
 */
-export async function syncModels(): Promise<SyncResponse> {
-	const response = await fetch(`${API_BASE}/remote/sync`, {
+export async function syncModels(fetchDetails: boolean = true): Promise<SyncResponse> {
+	const url = fetchDetails ? `${API_BASE}/remote/sync?details=true` : `${API_BASE}/remote/sync`;
+	const response = await fetch(url, {
 		method: 'POST'
 	});

--- a/frontend/src/lib/components/chat/ChatWindow.svelte
+++ b/frontend/src/lib/components/chat/ChatWindow.svelte
@@ -182,6 +182,15 @@
 		}
 	});

+	// Sync custom context limit with settings
+	$effect(() => {
+		if (settingsState.useCustomParameters) {
+			contextManager.setCustomContextLimit(settingsState.num_ctx);
+		} else {
+			contextManager.setCustomContextLimit(null);
+		}
+	});
+
 	// Update context manager when messages change
 	$effect(() => {
 		contextManager.updateMessages(chatState.visibleMessages);
@@ -604,12 +613,16 @@
 				// The results are stored in toolCalls and displayed by ToolCallDisplay
 			}

-			// Persist the assistant message (without flooding text content)
+			// Persist the assistant message (including toolCalls for reload persistence)
 			if (conversationId && assistantNode) {
 				const parentOfAssistant = assistantNode.parentId;
 				await addStoredMessage(
 					conversationId,
-					{ role: 'assistant', content: assistantNode.message.content },
+					{
+						role: 'assistant',
+						content: assistantNode.message.content,
+						toolCalls: assistantNode.message.toolCalls
+					},
 					parentOfAssistant,
 					assistantMessageId
 				);
--- a/frontend/src/lib/components/models/ModelCard.svelte
+++ b/frontend/src/lib/components/models/ModelCard.svelte
@@ -12,6 +12,28 @@

 	let { model, onSelect }: Props = $props();

+	/**
+	 * Format a date as relative time (e.g., "2d ago", "3w ago")
+	 */
+	function formatRelativeTime(date: string | Date | undefined): string {
+		if (!date) return '';
+		const now = Date.now();
+		const then = new Date(date).getTime();
+		const diff = now - then;
+
+		const minutes = Math.floor(diff / 60000);
+		const hours = Math.floor(diff / 3600000);
+		const days = Math.floor(diff / 86400000);
+		const weeks = Math.floor(days / 7);
+		const months = Math.floor(days / 30);
+
+		if (minutes < 60) return `${minutes}m ago`;
+		if (hours < 24) return `${hours}h ago`;
+		if (days < 7) return `${days}d ago`;
+		if (weeks < 4) return `${weeks}w ago`;
+		return `${months}mo ago`;
+	}
+
 	// Capability badges config (matches ollama.com capabilities)
 	const capabilityBadges: Record<string, { icon: string; color: string; label: string }> = {
 		vision: { icon: '👁', color: 'bg-purple-900/50 text-purple-300', label: 'Vision' },
@@ -92,6 +114,16 @@
 				<span>{formatContextLength(model.contextLength)}</span>
 			</div>
 		{/if}
+
+		<!-- Last Updated -->
+		{#if model.ollamaUpdatedAt}
+			<div class="flex items-center gap-1" title="Last updated on Ollama: {new Date(model.ollamaUpdatedAt).toLocaleDateString()}">
+				<svg xmlns="http://www.w3.org/2000/svg" class="h-3.5 w-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
+					<path stroke-linecap="round" stroke-linejoin="round" d="M12 8v4l3 3m6-3a9 9 0 11-18 0 9 9 0 0118 0z" />
+				</svg>
+				<span>{formatRelativeTime(model.ollamaUpdatedAt)}</span>
+			</div>
+		{/if}
 	</div>

 	<!-- Size Tags -->
--- a/frontend/src/lib/components/settings/ModelParametersPanel.svelte
+++ b/frontend/src/lib/components/settings/ModelParametersPanel.svelte
@@ -5,6 +5,7 @@
 	 */

 	import { settingsState } from '$lib/stores/settings.svelte';
+	import { modelsState, type ModelDefaults } from '$lib/stores/models.svelte';
 	import {
 		PARAMETER_RANGES,
 		PARAMETER_LABELS,
@@ -16,6 +17,26 @@
 	// Parameter keys for iteration
 	const parameterKeys: (keyof ModelParameters)[] = ['temperature', 'top_k', 'top_p', 'num_ctx'];

+	// Track model defaults for the selected model
+	let modelDefaults = $state<ModelDefaults>({});
+
+	// Fetch model defaults when panel opens or model changes
+	$effect(() => {
+		if (settingsState.isPanelOpen && modelsState.selectedId) {
+			modelsState.fetchModelDefaults(modelsState.selectedId).then((defaults) => {
+				modelDefaults = defaults;
+			});
+		}
+	});
+
+	/**
+	 * Get the default value for a parameter (from model or hardcoded fallback)
+	 */
+	function getDefaultValue(key: keyof ModelParameters): number {
+		const modelValue = modelDefaults[key];
+		return modelValue ?? DEFAULT_MODEL_PARAMETERS[key];
+	}
+
 	/**
 	 * Format a parameter value for display
 	 */
@@ -79,7 +100,7 @@
 				type="button"
 				role="switch"
 				aria-checked={settingsState.useCustomParameters}
-				onclick={() => settingsState.toggleCustomParameters()}
+				onclick={() => settingsState.toggleCustomParameters(modelDefaults)}
 				class="relative inline-flex h-5 w-9 flex-shrink-0 cursor-pointer rounded-full border-2 border-transparent transition-colors duration-200 ease-in-out focus:outline-none focus:ring-2 focus:ring-sky-500 focus:ring-offset-2 focus:ring-offset-theme-secondary {settingsState.useCustomParameters ? 'bg-sky-600' : 'bg-theme-tertiary'}"
 			>
 				<span
@@ -93,7 +114,7 @@
 			{#each parameterKeys as key}
 				{@const range = PARAMETER_RANGES[key]}
 				{@const value = getValue(key)}
-				{@const isDefault = value === DEFAULT_MODEL_PARAMETERS[key]}
+				{@const isDefault = value === getDefaultValue(key)}

 				<div>
 					<div class="mb-1 flex items-center justify-between">
@@ -132,7 +153,7 @@
 		<div class="mt-4 flex justify-end">
 			<button
 				type="button"
-				onclick={() => settingsState.resetToDefaults()}
+				onclick={() => settingsState.resetToDefaults(modelDefaults)}
 				class="rounded px-2 py-1 text-xs text-theme-muted hover:bg-theme-tertiary hover:text-theme-secondary"
 			>
 				Reset to defaults
--- a/frontend/src/lib/components/tools/CodeEditor.svelte
+++ b/frontend/src/lib/components/tools/CodeEditor.svelte
@@ -0,0 +1,127 @@
+<script lang="ts">
+	import { onMount, onDestroy } from 'svelte';
+	import { EditorView, basicSetup } from 'codemirror';
+	import { javascript } from '@codemirror/lang-javascript';
+	import { python } from '@codemirror/lang-python';
+	import { json } from '@codemirror/lang-json';
+	import { oneDark } from '@codemirror/theme-one-dark';
+	import { EditorState, Compartment } from '@codemirror/state';
+
+	interface Props {
+		value: string;
+		language?: 'javascript' | 'python' | 'json';
+		readonly?: boolean;
+		placeholder?: string;
+		minHeight?: string;
+		onchange?: (value: string) => void;
+	}
+
+	let {
+		value = $bindable(''),
+		language = 'javascript',
+		readonly = false,
+		placeholder = '',
+		minHeight = '200px',
+		onchange
+	}: Props = $props();
+
+	let editorContainer: HTMLDivElement;
+	let editorView: EditorView | null = null;
+	const languageCompartment = new Compartment();
+	const readonlyCompartment = new Compartment();
+
+	function getLanguageExtension(lang: string) {
+		switch (lang) {
+			case 'python':
+				return python();
+			case 'json':
+				return json();
+			case 'javascript':
+			default:
+				return javascript();
+		}
+	}
+
+	onMount(() => {
+		const updateListener = EditorView.updateListener.of((update) => {
+			if (update.docChanged) {
+				const newValue = update.state.doc.toString();
+				if (newValue !== value) {
+					value = newValue;
+					onchange?.(newValue);
+				}
+			}
+		});
+
+		const state = EditorState.create({
+			doc: value,
+			extensions: [
+				basicSetup,
+				languageCompartment.of(getLanguageExtension(language)),
+				readonlyCompartment.of(EditorState.readOnly.of(readonly)),
+				oneDark,
+				updateListener,
+				EditorView.theme({
+					'&': { minHeight },
+					'.cm-scroller': { overflow: 'auto' },
+					'.cm-content': { minHeight },
+					'&.cm-focused': { outline: 'none' }
+				}),
+				placeholder ? EditorView.contentAttributes.of({ 'aria-placeholder': placeholder }) : []
+			]
+		});
+
+		editorView = new EditorView({
+			state,
+			parent: editorContainer
+		});
+	});
+
+	onDestroy(() => {
+		editorView?.destroy();
+	});
+
+	// Update editor when value changes externally
+	$effect(() => {
+		if (editorView && editorView.state.doc.toString() !== value) {
+			editorView.dispatch({
+				changes: {
+					from: 0,
+					to: editorView.state.doc.length,
+					insert: value
+				}
+			});
+		}
+	});
+
+	// Update language when it changes
+	$effect(() => {
+		if (editorView) {
+			editorView.dispatch({
+				effects: languageCompartment.reconfigure(getLanguageExtension(language))
+			});
+		}
+	});
+
+	// Update readonly when it changes
+	$effect(() => {
+		if (editorView) {
+			editorView.dispatch({
+				effects: readonlyCompartment.reconfigure(EditorState.readOnly.of(readonly))
+			});
+		}
+	});
+</script>
+
+<div class="code-editor rounded-md overflow-hidden border border-surface-500/30" bind:this={editorContainer}></div>
+
+<style>
+	.code-editor :global(.cm-editor) {
+		font-size: 14px;
+		font-family: ui-monospace, SFMono-Regular, 'SF Mono', Menlo, Consolas, 'Liberation Mono', monospace;
+	}
+
+	.code-editor :global(.cm-gutters) {
+		border-right: 1px solid rgba(255, 255, 255, 0.1);
+	}
+</style>
--- a/frontend/src/lib/components/tools/ToolDocs.svelte
+++ b/frontend/src/lib/components/tools/ToolDocs.svelte
@@ -0,0 +1,117 @@
+<script lang="ts">
+	/**
+	 * ToolDocs - Inline documentation panel for tool creation
+	 */
+
+	interface Props {
+		language: 'javascript' | 'python';
+		isOpen?: boolean;
+		onclose?: () => void;
+	}
+
+	const { language, isOpen = false, onclose }: Props = $props();
+</script>
+
+{#if isOpen}
+	<div class="rounded-lg border border-theme-subtle bg-theme-tertiary/50 p-4">
+		<div class="flex items-center justify-between mb-3">
+			<h4 class="text-sm font-medium text-theme-primary">
+				{language === 'javascript' ? 'JavaScript' : 'Python'} Tool Guide
+			</h4>
+			{#if onclose}
+				<button
+					type="button"
+					onclick={onclose}
+					class="text-theme-muted hover:text-theme-primary"
+					aria-label="Close documentation"
+				>
+					<svg xmlns="http://www.w3.org/2000/svg" class="h-4 w-4" viewBox="0 0 20 20" fill="currentColor">
+						<path fill-rule="evenodd" d="M4.293 4.293a1 1 0 011.414 0L10 8.586l4.293-4.293a1 1 0 111.414 1.414L11.414 10l4.293 4.293a1 1 0 01-1.414 1.414L10 11.414l-4.293 4.293a1 1 0 01-1.414-1.414L8.586 10 4.293 5.707a1 1 0 010-1.414z" clip-rule="evenodd" />
+					</svg>
+				</button>
+			{/if}
+		</div>
+
+		<div class="space-y-4 text-sm text-theme-secondary">
+			{#if language === 'javascript'}
+				<!-- JavaScript Documentation -->
+				<div>
+					<h5 class="font-medium text-theme-primary mb-1">Arguments</h5>
+					<p>Access parameters via the <code class="bg-theme-primary/30 px-1 rounded text-xs">args</code> object:</p>
+					<pre class="mt-1 p-2 rounded bg-theme-primary/20 text-xs overflow-x-auto"><code>const name = args.name;
+const count = args.count || 10;</code></pre>
+				</div>
+
+				<div>
+					<h5 class="font-medium text-theme-primary mb-1">Return Value</h5>
+					<p>Return any JSON-serializable value:</p>
+					<pre class="mt-1 p-2 rounded bg-theme-primary/20 text-xs overflow-x-auto"><code>return {'{'}
+  success: true,
+  data: result
+{'}'};</code></pre>
+				</div>
+
+				<div>
+					<h5 class="font-medium text-theme-primary mb-1">Async/Await</h5>
+					<p>Full async support - use await for API calls:</p>
+					<pre class="mt-1 p-2 rounded bg-theme-primary/20 text-xs overflow-x-auto"><code>const res = await fetch(args.url);
+const data = await res.json();
+return data;</code></pre>
+				</div>
+
+				<div>
+					<h5 class="font-medium text-theme-primary mb-1">Error Handling</h5>
+					<p>Throw errors to signal failures:</p>
+					<pre class="mt-1 p-2 rounded bg-theme-primary/20 text-xs overflow-x-auto"><code>if (!args.required_param) {'{'}
+  throw new Error('Missing required param');
+{'}'}</code></pre>
+				</div>
+			{:else}
+				<!-- Python Documentation -->
+				<div>
+					<h5 class="font-medium text-theme-primary mb-1">Arguments</h5>
+					<p>Access parameters via the <code class="bg-theme-primary/30 px-1 rounded text-xs">args</code> dict:</p>
+					<pre class="mt-1 p-2 rounded bg-theme-primary/20 text-xs overflow-x-auto"><code>name = args.get('name')
+count = args.get('count', 10)</code></pre>
+				</div>
+
+				<div>
+					<h5 class="font-medium text-theme-primary mb-1">Return Value</h5>
+					<p>Print JSON to stdout (import json first):</p>
+					<pre class="mt-1 p-2 rounded bg-theme-primary/20 text-xs overflow-x-auto"><code>import json
+
+result = {'{'}'success': True, 'data': data{'}'}
+print(json.dumps(result))</code></pre>
+				</div>
+
+				<div>
+					<h5 class="font-medium text-theme-primary mb-1">Available Modules</h5>
+					<p>Python standard library is available:</p>
+					<pre class="mt-1 p-2 rounded bg-theme-primary/20 text-xs overflow-x-auto"><code>import json, math, re
+import hashlib, base64
+import urllib.request
+from collections import Counter</code></pre>
+				</div>
+
+				<div>
+					<h5 class="font-medium text-theme-primary mb-1">Error Handling</h5>
+					<p>Print error JSON or raise exceptions:</p>
+					<pre class="mt-1 p-2 rounded bg-theme-primary/20 text-xs overflow-x-auto"><code>try:
+    # risky operation
+except Exception as e:
+    print(json.dumps({'{'}'error': str(e){'}'})</code></pre>
+				</div>
+			{/if}
+
+			<div class="pt-2 border-t border-theme-subtle">
+				<h5 class="font-medium text-theme-primary mb-1">Tips</h5>
+				<ul class="list-disc list-inside space-y-1 text-xs text-theme-muted">
+					<li>Tools run with a 30-second timeout</li>
+					<li>Large outputs are truncated at 100KB</li>
+					<li>Network requests are allowed</li>
+					<li>Use descriptive error messages for debugging</li>
+				</ul>
+			</div>
+		</div>
+	</div>
+{/if}
--- a/frontend/src/lib/components/tools/ToolEditor.svelte
+++ b/frontend/src/lib/components/tools/ToolEditor.svelte
@@ -5,6 +5,10 @@

 	import { toolsState } from '$lib/stores';
 	import type { CustomTool, JSONSchema, JSONSchemaProperty, ToolImplementation } from '$lib/tools';
+	import { getTemplatesByLanguage, type ToolTemplate } from '$lib/tools';
+	import CodeEditor from './CodeEditor.svelte';
+	import ToolDocs from './ToolDocs.svelte';
+	import ToolTester from './ToolTester.svelte';

 	interface Props {
 		isOpen: boolean;
@@ -15,21 +19,62 @@

 	const { isOpen, editingTool = null, onClose, onSave }: Props = $props();

+	// Default code templates
+	const defaultJsCode = `// Arguments are available as \`args\` object
+// Return the result
+return { message: "Hello from custom tool!" };`;
+
+	const defaultPythonCode = `# Arguments available as \`args\` dict
+# Print JSON result to stdout
+import json
+
+result = {"message": f"Hello, {args.get('name', 'World')}!"}
+print(json.dumps(result))`;
+
 	// Form state
 	let name = $state('');
 	let description = $state('');
 	let implementation = $state<ToolImplementation>('javascript');
-	let code = $state('// Arguments are available as `args` object\n// Return the result\nreturn { message: "Hello from custom tool!" };');
+	let code = $state(defaultJsCode);
 	let endpoint = $state('');
 	let httpMethod = $state<'GET' | 'POST'>('POST');
 	let enabled = $state(true);

+	// Track previous implementation for code switching
+	let prevImplementation = $state<ToolImplementation>('javascript');
+
 	// Parameters state (simplified - array of parameter definitions)
 	let parameters = $state<Array<{ name: string; type: string; description: string; required: boolean }>>([]);

 	// Validation
 	let errors = $state<Record<string, string>>({});

+	// UI state
+	let showDocs = $state(false);
+	let showTemplates = $state(false);
+	let showTest = $state(false);
+
+	// Get templates for current language
+	const currentTemplates = $derived(
+		implementation === 'javascript' || implementation === 'python'
+			? getTemplatesByLanguage(implementation)
+			: []
+	);
+
+	function applyTemplate(template: ToolTemplate): void {
+		name = template.name.toLowerCase().replace(/[^a-z0-9]+/g, '_');
+		description = template.description;
+		code = template.code;
+		// Convert parameters from template
+		parameters = Object.entries(template.parameters.properties ?? {}).map(([paramName, prop]) => ({
+			name: paramName,
+			type: prop.type,
+			description: prop.description ?? '',
+			required: template.parameters.required?.includes(paramName) ?? false
+		}));
+		showTemplates = false;
+	}
+
 	// Reset form when modal opens or editing tool changes
 	$effect(() => {
 		if (isOpen) {
@@ -59,13 +104,32 @@
 		name = '';
 		description = '';
 		implementation = 'javascript';
-		code = '// Arguments are available as `args` object\n// Return the result\nreturn { message: "Hello from custom tool!" };';
+		prevImplementation = 'javascript';
+		code = defaultJsCode;
 		endpoint = '';
 		httpMethod = 'POST';
 		enabled = true;
 		parameters = [];
 	}

+	// Switch to default code when implementation changes (unless editing)
+	$effect(() => {
+		if (!editingTool && implementation !== prevImplementation) {
+			// Only switch code if it's still the default for the previous type
+			const isDefaultJs = code === defaultJsCode || code.trim() === '';
+			const isDefaultPy = code === defaultPythonCode;
+
+			if (isDefaultJs || isDefaultPy || code.trim() === '') {
+				if (implementation === 'python') {
+					code = defaultPythonCode;
+				} else if (implementation === 'javascript') {
+					code = defaultJsCode;
+				}
+			}
+			prevImplementation = implementation;
+		}
+	});
+
 	function addParameter(): void {
 		parameters = [...parameters, { name: '', type: 'string', description: '', required: false }];
 	}
@@ -93,8 +157,8 @@
 			newErrors.description = 'Description is required';
 		}

-		if (implementation === 'javascript' && !code.trim()) {
-			newErrors.code = 'JavaScript code is required';
+		if ((implementation === 'javascript' || implementation === 'python') && !code.trim()) {
+			newErrors.code = `${implementation === 'javascript' ? 'JavaScript' : 'Python'} code is required`;
 		}

 		if (implementation === 'http' && !endpoint.trim()) {
@@ -144,7 +208,7 @@
 			description: description.trim(),
 			parameters: buildParameterSchema(),
 			implementation,
-			code: implementation === 'javascript' ? code : undefined,
+			code: (implementation === 'javascript' || implementation === 'python') ? code : undefined,
 			endpoint: implementation === 'http' ? endpoint : undefined,
 			httpMethod: implementation === 'http' ? httpMethod : undefined,
 			enabled,
@@ -290,7 +354,7 @@
 				<!-- Implementation Type -->
 				<div>
 					<label class="block text-sm font-medium text-theme-secondary">Implementation</label>
-					<div class="mt-2 flex gap-4">
+					<div class="mt-2 flex flex-wrap gap-4">
 						<label class="flex items-center gap-2 text-theme-secondary">
 							<input
 								type="radio"
@@ -300,6 +364,15 @@
 							/>
 							JavaScript
 						</label>
+						<label class="flex items-center gap-2 text-theme-secondary">
+							<input
+								type="radio"
+								bind:group={implementation}
+								value="python"
+								class="text-blue-500"
+							/>
+							Python
+						</label>
 						<label class="flex items-center gap-2 text-theme-secondary">
 							<input
 								type="radio"
@@ -312,22 +385,102 @@
 					</div>
 				</div>

-				<!-- JavaScript Code -->
-				{#if implementation === 'javascript'}
+				<!-- Code Editor (JavaScript or Python) -->
+				{#if implementation === 'javascript' || implementation === 'python'}
 					<div>
-						<label for="tool-code" class="block text-sm font-medium text-theme-secondary">JavaScript Code</label>
-						<p class="mt-1 text-xs text-theme-muted">
-							Arguments are passed as an <code class="bg-theme-tertiary px-1 rounded">args</code> object. Return the result.
+						<div class="flex items-center justify-between mb-1">
+							<label class="block text-sm font-medium text-theme-secondary">
+								{implementation === 'javascript' ? 'JavaScript' : 'Python'} Code
+							</label>
+							<div class="flex items-center gap-2">
+								<!-- Templates dropdown -->
+								<div class="relative">
+									<button
+										type="button"
+										onclick={() => showTemplates = !showTemplates}
+										class="flex items-center gap-1 text-xs text-blue-400 hover:text-blue-300"
+									>
+										<svg xmlns="http://www.w3.org/2000/svg" class="h-4 w-4" viewBox="0 0 20 20" fill="currentColor">
+											<path d="M9 4.804A7.968 7.968 0 005.5 4c-1.255 0-2.443.29-3.5.804v10A7.969 7.969 0 015.5 14c1.669 0 3.218.51 4.5 1.385A7.962 7.962 0 0114.5 14c1.255 0 2.443.29 3.5.804v-10A7.968 7.968 0 0014.5 4c-1.255 0-2.443.29-3.5.804V12a1 1 0 11-2 0V4.804z" />
+										</svg>
+										Templates
+									</button>
+									{#if showTemplates && currentTemplates.length > 0}
+										<div class="absolute right-0 top-full mt-1 w-64 rounded-lg border border-theme-subtle bg-theme-secondary shadow-lg z-10">
+											<div class="p-2 space-y-1 max-h-48 overflow-y-auto">
+												{#each currentTemplates as template (template.id)}
+													<button
+														type="button"
+														onclick={() => applyTemplate(template)}
+														class="w-full text-left px-3 py-2 rounded hover:bg-theme-tertiary"
+													>
+														<div class="text-sm text-theme-primary">{template.name}</div>
+														<div class="text-xs text-theme-muted truncate">{template.description}</div>
+													</button>
+												{/each}
+											</div>
+										</div>
+									{/if}
+								</div>
+								<!-- Docs toggle -->
+								<button
+									type="button"
+									onclick={() => showDocs = !showDocs}
+									class="flex items-center gap-1 text-xs {showDocs ? 'text-emerald-400' : 'text-theme-muted hover:text-theme-secondary'}"
+								>
+									<svg xmlns="http://www.w3.org/2000/svg" class="h-4 w-4" viewBox="0 0 20 20" fill="currentColor">
+										<path fill-rule="evenodd" d="M18 10a8 8 0 11-16 0 8 8 0 0116 0zm-7-4a1 1 0 11-2 0 1 1 0 012 0zM9 9a1 1 0 000 2v3a1 1 0 001 1h1a1 1 0 100-2v-3a1 1 0 00-1-1H9z" clip-rule="evenodd" />
+									</svg>
+									Docs
+								</button>
+							</div>
+						</div>
+						<p class="text-xs text-theme-muted mb-2">
+							{#if implementation === 'javascript'}
+								Arguments are passed as an <code class="bg-theme-tertiary px-1 rounded">args</code> object. Return the result.
+							{:else}
+								Arguments are available as <code class="bg-theme-tertiary px-1 rounded">args</code> dict. Print JSON result to stdout.
+							{/if}
 						</p>
-						<textarea
-							id="tool-code"
-							bind:value={code}
-							rows="8"
-							class="mt-2 w-full rounded-lg border border-theme-subtle bg-theme-primary px-3 py-2 font-mono text-sm text-theme-primary placeholder-theme-muted focus:border-blue-500 focus:outline-none focus:ring-1 focus:ring-blue-500"
-						></textarea>
+
+						<!-- Documentation panel -->
+						<ToolDocs
+							language={implementation}
+							isOpen={showDocs}
+							onclose={() => showDocs = false}
+						/>
+
+						<div class="mt-2">
+							<CodeEditor
+								bind:value={code}
+								language={implementation === 'python' ? 'python' : 'javascript'}
+								minHeight="200px"
+							/>
+						</div>
 						{#if errors.code}
 							<p class="mt-1 text-sm text-red-400">{errors.code}</p>
 						{/if}
+
+						<!-- Test button -->
+						<button
+							type="button"
+							onclick={() => showTest = !showTest}
+							class="mt-3 flex items-center gap-2 text-sm {showTest ? 'text-emerald-400' : 'text-theme-muted hover:text-theme-secondary'}"
+						>
+							<svg xmlns="http://www.w3.org/2000/svg" class="h-4 w-4" viewBox="0 0 20 20" fill="currentColor">
+								<path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM9.555 7.168A1 1 0 008 8v4a1 1 0 001.555.832l3-2a1 1 0 000-1.664l-3-2z" clip-rule="evenodd" />
+							</svg>
+							{showTest ? 'Hide Test Panel' : 'Test Tool'}
+						</button>
+
+						<!-- Tool tester -->
+						<ToolTester
+							{implementation}
+							{code}
+							parameters={buildParameterSchema()}
+							isOpen={showTest}
+							onclose={() => showTest = false}
+						/>
 					</div>
 				{/if}

--- a/frontend/src/lib/components/tools/ToolTester.svelte
+++ b/frontend/src/lib/components/tools/ToolTester.svelte
@@ -0,0 +1,220 @@
+<script lang="ts">
+	/**
+	 * ToolTester - Test panel for running tools with sample inputs
+	 */
+
+	import type { JSONSchema, ToolImplementation } from '$lib/tools';
+	import CodeEditor from './CodeEditor.svelte';
+
+	interface Props {
+		implementation: ToolImplementation;
+		code: string;
+		parameters: JSONSchema;
+		isOpen?: boolean;
+		onclose?: () => void;
+	}
+
+	const { implementation, code, parameters, isOpen = false, onclose }: Props = $props();
+
+	let testInput = $state('{}');
+	let testResult = $state<{ success: boolean; result?: unknown; error?: string } | null>(null);
+	let isRunning = $state(false);
+
+	// Generate example input from parameters
+	$effect(() => {
+		if (isOpen && testInput === '{}' && parameters.properties) {
+			const example: Record<string, unknown> = {};
+			for (const [name, prop] of Object.entries(parameters.properties)) {
+				switch (prop.type) {
+					case 'string':
+						example[name] = prop.description ? `example_${name}` : '';
+						break;
+					case 'number':
+						example[name] = 0;
+						break;
+					case 'boolean':
+						example[name] = false;
+						break;
+					case 'array':
+						example[name] = [];
+						break;
+					case 'object':
+						example[name] = {};
+						break;
+				}
+			}
+			if (Object.keys(example).length > 0) {
+				testInput = JSON.stringify(example, null, 2);
+			}
+		}
+	});
+
+	async function runTest(): Promise<void> {
+		if (isRunning) return;
+
+		isRunning = true;
+		testResult = null;
+
+		try {
+			// Parse the input
+			let args: Record<string, unknown>;
+			try {
+				args = JSON.parse(testInput);
+			} catch {
+				testResult = { success: false, error: 'Invalid JSON input' };
+				isRunning = false;
+				return;
+			}
+
+			if (implementation === 'javascript') {
+				// Execute JavaScript directly in browser
+				try {
+					// eslint-disable-next-line @typescript-eslint/no-implied-eval
+					const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
+					const fn = new AsyncFunction(
+						'args',
+						`
+						"use strict";
+						${code}
+					`
+					);
+					const result = await fn(args);
+					testResult = { success: true, result };
+				} catch (error) {
+					testResult = {
+						success: false,
+						error: error instanceof Error ? error.message : String(error)
+					};
+				}
+			} else if (implementation === 'python') {
+				// Python requires backend execution
+				try {
+					const response = await fetch('/api/v1/tools/execute', {
+						method: 'POST',
+						headers: { 'Content-Type': 'application/json' },
+						body: JSON.stringify({
+							language: 'python',
+							code,
+							args,
+							timeout: 30
+						})
+					});
+
+					if (!response.ok) {
+						throw new Error(`Server error: ${response.status}`);
+					}
+
+					const data = await response.json();
+					if (data.success) {
+						testResult = { success: true, result: data.result };
+					} else {
+						testResult = { success: false, error: data.error || 'Unknown error' };
+					}
+				} catch (error) {
+					testResult = {
+						success: false,
+						error: error instanceof Error ? error.message : String(error)
+					};
+				}
+			} else {
+				testResult = { success: false, error: 'HTTP tools cannot be tested in the editor' };
+			}
+		} finally {
+			isRunning = false;
+		}
+	}
+
+	function formatResult(result: unknown): string {
+		if (result === undefined) return 'undefined';
+		if (result === null) return 'null';
+		try {
+			return JSON.stringify(result, null, 2);
+		} catch {
+			return String(result);
+		}
+	}
+</script>
+
+{#if isOpen}
+	<div class="rounded-lg border border-theme-subtle bg-theme-tertiary/50 p-4 mt-4">
+		<div class="flex items-center justify-between mb-3">
+			<h4 class="text-sm font-medium text-theme-primary flex items-center gap-2">
+				<svg xmlns="http://www.w3.org/2000/svg" class="h-4 w-4" viewBox="0 0 20 20" fill="currentColor">
+					<path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM9.555 7.168A1 1 0 008 8v4a1 1 0 001.555.832l3-2a1 1 0 000-1.664l-3-2z" clip-rule="evenodd" />
+				</svg>
+				Test Tool
+			</h4>
+			{#if onclose}
+				<button
+					type="button"
+					onclick={onclose}
+					class="text-theme-muted hover:text-theme-primary"
+					aria-label="Close test panel"
+				>
+					<svg xmlns="http://www.w3.org/2000/svg" class="h-4 w-4" viewBox="0 0 20 20" fill="currentColor">
+						<path fill-rule="evenodd" d="M4.293 4.293a1 1 0 011.414 0L10 8.586l4.293-4.293a1 1 0 111.414 1.414L11.414 10l4.293 4.293a1 1 0 01-1.414 1.414L10 11.414l-4.293 4.293a1 1 0 01-1.414-1.414L8.586 10 4.293 5.707a1 1 0 010-1.414z" clip-rule="evenodd" />
+					</svg>
+				</button>
+			{/if}
+		</div>
+
+		<div class="space-y-4">
+			<!-- Input -->
+			<div>
+				<label class="block text-xs font-medium text-theme-secondary mb-1">Input Arguments (JSON)</label>
+				<CodeEditor bind:value={testInput} language="json" minHeight="80px" />
+			</div>
+
+			<!-- Run button -->
+			<button
+				type="button"
+				onclick={runTest}
+				disabled={isRunning || !code.trim()}
+				class="flex items-center gap-2 px-3 py-1.5 text-sm font-medium rounded-lg bg-emerald-600 text-white hover:bg-emerald-500 disabled:opacity-50 disabled:cursor-not-allowed"
+			>
+				{#if isRunning}
+					<svg class="animate-spin h-4 w-4" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
+						<circle class="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" stroke-width="4"></circle>
+						<path class="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+					</svg>
+					Running...
+				{:else}
+					<svg xmlns="http://www.w3.org/2000/svg" class="h-4 w-4" viewBox="0 0 20 20" fill="currentColor">
+						<path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM9.555 7.168A1 1 0 008 8v4a1 1 0 001.555.832l3-2a1 1 0 000-1.664l-3-2z" clip-rule="evenodd" />
+					</svg>
+					Run Test
+				{/if}
+			</button>
+
+			<!-- Result -->
+			{#if testResult}
+				<div>
+					<label class="block text-xs font-medium text-theme-secondary mb-1">Result</label>
+					<div
+						class="rounded-lg p-3 text-sm font-mono overflow-x-auto {testResult.success
+							? 'bg-emerald-900/30 border border-emerald-500/30'
+							: 'bg-red-900/30 border border-red-500/30'}"
+					>
+						{#if testResult.success}
+							<div class="flex items-center gap-2 text-emerald-400 mb-2">
+								<svg xmlns="http://www.w3.org/2000/svg" class="h-4 w-4" viewBox="0 0 20 20" fill="currentColor">
+									<path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm3.707-9.293a1 1 0 00-1.414-1.414L9 10.586 7.707 9.293a1 1 0 00-1.414 1.414l2 2a1 1 0 001.414 0l4-4z" clip-rule="evenodd" />
+								</svg>
+								Success
+							</div>
+							<pre class="text-theme-primary whitespace-pre-wrap">{formatResult(testResult.result)}</pre>
+						{:else}
+							<div class="flex items-center gap-2 text-red-400 mb-2">
+								<svg xmlns="http://www.w3.org/2000/svg" class="h-4 w-4" viewBox="0 0 20 20" fill="currentColor">
+									<path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z" clip-rule="evenodd" />
+								</svg>
+								Error
+							</div>
+							<pre class="text-red-300 whitespace-pre-wrap">{testResult.error}</pre>
+						{/if}
+					</div>
+				</div>
+			{/if}
+		</div>
+	</div>
+{/if}
--- a/frontend/src/lib/components/tools/index.ts
+++ b/frontend/src/lib/components/tools/index.ts
@@ -2,4 +2,7 @@
 * Tools components exports
 */

+export { default as CodeEditor } from './CodeEditor.svelte';
+export { default as ToolDocs } from './ToolDocs.svelte';
 export { default as ToolEditor } from './ToolEditor.svelte';
+export { default as ToolTester } from './ToolTester.svelte';
--- a/frontend/src/lib/memory/context-manager.svelte.ts
+++ b/frontend/src/lib/memory/context-manager.svelte.ts
@@ -24,8 +24,14 @@ class ContextManager {
 	/** Current model name */
 	currentModel = $state<string>('');

-	/** Maximum context length for current model */
-	maxTokens = $state<number>(4096);
+	/** Maximum context length for current model (from model lookup) */
+	modelMaxTokens = $state<number>(4096);
+
+	/** Custom context limit override (from user settings) */
+	customMaxTokens = $state<number | null>(null);
+
+	/** Effective max tokens (custom override or model default) */
+	maxTokens = $derived(this.customMaxTokens ?? this.modelMaxTokens);

 	/**
 	 * Cached token estimates for messages (id -> estimate)
@@ -94,7 +100,15 @@ class ContextManager {
 	 */
 	setModel(modelName: string): void {
 		this.currentModel = modelName;
-		this.maxTokens = getModelContextLimit(modelName);
+		this.modelMaxTokens = getModelContextLimit(modelName);
+	}
+
+	/**
+	 * Set custom context limit override
+	 * Pass null to clear and use model default
+	 */
+	setCustomContextLimit(tokens: number | null): void {
+		this.customMaxTokens = tokens;
 	}

 	/**
--- a/frontend/src/lib/stores/local-models.svelte.ts
+++ b/frontend/src/lib/stores/local-models.svelte.ts
@@ -146,7 +146,8 @@ class LocalModelsState {
 			const response = await checkForUpdates();

 			this.updatesAvailable = response.updatesAvailable;
-			this.modelsWithUpdates = new Set(response.updates.map(m => m.name));
+			// Handle null/undefined updates array from API
+			this.modelsWithUpdates = new Set((response.updates ?? []).map(m => m.name));

 			return response;
 		} catch (err) {
--- a/frontend/src/lib/stores/model-registry.svelte.ts
+++ b/frontend/src/lib/stores/model-registry.svelte.ts
@@ -5,12 +5,15 @@

 import {
 	fetchRemoteModels,
+	fetchRemoteFamilies,
 	getSyncStatus,
 	syncModels,
 	type RemoteModel,
 	type SyncStatus,
 	type ModelSearchOptions,
-	type ModelSortOption
+	type ModelSortOption,
+	type SizeRange,
+	type ContextRange
 } from '$lib/api/model-registry';

 /** Store state */
@@ -25,6 +28,10 @@ class ModelRegistryState {
 	searchQuery = $state('');
 	modelType = $state<'official' | 'community' | ''>('');
 	selectedCapabilities = $state<string[]>([]);
+	selectedSizeRanges = $state<SizeRange[]>([]);
+	selectedContextRanges = $state<ContextRange[]>([]);
+	selectedFamily = $state<string>('');
+	availableFamilies = $state<string[]>([]);
 	sortBy = $state<ModelSortOption>('pulls_desc');
 	currentPage = $state(0);
 	pageSize = $state(24);
@@ -69,6 +76,18 @@ class ModelRegistryState {
 				options.capabilities = this.selectedCapabilities;
 			}

+			if (this.selectedSizeRanges.length > 0) {
+				options.sizeRanges = this.selectedSizeRanges;
+			}
+
+			if (this.selectedContextRanges.length > 0) {
+				options.contextRanges = this.selectedContextRanges;
+			}
+
+			if (this.selectedFamily) {
+				options.family = this.selectedFamily;
+			}
+
 			const response = await fetchRemoteModels(options);
 			this.models = response.models;
 			this.total = response.total;
@@ -119,6 +138,68 @@ class ModelRegistryState {
 		return this.selectedCapabilities.includes(capability);
 	}

+	/**
+	 * Toggle a size range filter
+	 */
+	async toggleSizeRange(size: SizeRange): Promise<void> {
+		const index = this.selectedSizeRanges.indexOf(size);
+		if (index === -1) {
+			this.selectedSizeRanges = [...this.selectedSizeRanges, size];
+		} else {
+			this.selectedSizeRanges = this.selectedSizeRanges.filter((s) => s !== size);
+		}
+		this.currentPage = 0;
+		await this.loadModels();
+	}
+
+	/**
+	 * Check if a size range is selected
+	 */
+	hasSizeRange(size: SizeRange): boolean {
+		return this.selectedSizeRanges.includes(size);
+	}
+
+	/**
+	 * Toggle a context range filter
+	 */
+	async toggleContextRange(range: ContextRange): Promise<void> {
+		const index = this.selectedContextRanges.indexOf(range);
+		if (index === -1) {
+			this.selectedContextRanges = [...this.selectedContextRanges, range];
+		} else {
+			this.selectedContextRanges = this.selectedContextRanges.filter((r) => r !== range);
+		}
+		this.currentPage = 0;
+		await this.loadModels();
+	}
+
+	/**
+	 * Check if a context range is selected
+	 */
+	hasContextRange(range: ContextRange): boolean {
+		return this.selectedContextRanges.includes(range);
+	}
+
+	/**
+	 * Set family filter
+	 */
+	async setFamily(family: string): Promise<void> {
+		this.selectedFamily = family;
+		this.currentPage = 0;
+		await this.loadModels();
+	}
+
+	/**
+	 * Load available families for filter dropdown
+	 */
+	async loadFamilies(): Promise<void> {
+		try {
+			this.availableFamilies = await fetchRemoteFamilies();
+		} catch (err) {
+			console.error('Failed to load families:', err);
+		}
+	}
+
 	/**
 	 * Set sort order
 	 */
@@ -200,6 +281,9 @@ class ModelRegistryState {
 		this.searchQuery = '';
 		this.modelType = '';
 		this.selectedCapabilities = [];
+		this.selectedSizeRanges = [];
+		this.selectedContextRanges = [];
+		this.selectedFamily = '';
 		this.sortBy = 'pulls_desc';
 		this.currentPage = 0;
 		await this.loadModels();
@@ -209,7 +293,7 @@ class ModelRegistryState {
 	 * Initialize the store
 	 */
 	async init(): Promise<void> {
-		await Promise.all([this.loadSyncStatus(), this.loadModels()]);
+		await Promise.all([this.loadSyncStatus(), this.loadModels(), this.loadFamilies()]);
 	}
 }

--- a/frontend/src/lib/stores/models.svelte.ts
+++ b/frontend/src/lib/stores/models.svelte.ts
@@ -65,6 +65,14 @@ export interface ModelUpdateStatus {
 	localModifiedAt: string;
 }

+/** Model default parameters from Ollama */
+export interface ModelDefaults {
+	temperature?: number;
+	top_k?: number;
+	top_p?: number;
+	num_ctx?: number;
+}
+
 /** Models state class with reactive properties */
 export class ModelsState {
 	// Core state
@@ -81,6 +89,10 @@ export class ModelsState {
 	private capabilitiesCache = $state<Map<string, OllamaCapability[]>>(new Map());
 	private capabilitiesFetching = new Set<string>();

+	// Model defaults cache: modelName -> default parameters
+	private modelDefaultsCache = $state<Map<string, ModelDefaults>>(new Map());
+	private modelDefaultsFetching = new Set<string>();
+
 	// Derived: Currently selected model
 	selected = $derived.by(() => {
 		if (!this.selectedId) return null;
@@ -429,6 +441,99 @@ export class ModelsState {
 		}
 		return count;
 	}
+
+	// =========================================================================
+	// Model Defaults
+	// =========================================================================
+
+	/**
+	 * Parse model parameters from the Ollama show response
+	 * The parameters field contains lines like "temperature 0.7" or "num_ctx 4096"
+	 */
+	private parseModelParameters(parametersStr: string): ModelDefaults {
+		const defaults: ModelDefaults = {};
+
+		if (!parametersStr) return defaults;
+
+		const lines = parametersStr.split('\n');
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed) continue;
+
+			// Parse "key value" format
+			const spaceIndex = trimmed.indexOf(' ');
+			if (spaceIndex === -1) continue;
+
+			const key = trimmed.substring(0, spaceIndex).toLowerCase();
+			const value = trimmed.substring(spaceIndex + 1).trim();
+
+			switch (key) {
+				case 'temperature':
+					defaults.temperature = parseFloat(value);
+					break;
+				case 'top_k':
+					defaults.top_k = parseInt(value, 10);
+					break;
+				case 'top_p':
+					defaults.top_p = parseFloat(value);
+					break;
+				case 'num_ctx':
+					defaults.num_ctx = parseInt(value, 10);
+					break;
+			}
+		}
+
+		return defaults;
+	}
+
+	/**
+	 * Fetch model defaults from Ollama /api/show
+	 */
+	async fetchModelDefaults(modelName: string): Promise<ModelDefaults> {
+		// Check cache first
+		const cached = this.modelDefaultsCache.get(modelName);
+		if (cached) return cached;
+
+		// Avoid duplicate fetches
+		if (this.modelDefaultsFetching.has(modelName)) {
+			await new Promise((r) => setTimeout(r, 100));
+			return this.modelDefaultsCache.get(modelName) ?? {};
+		}
+
+		this.modelDefaultsFetching.add(modelName);
+
+		try {
+			const response = await ollamaClient.showModel(modelName);
+			const defaults = this.parseModelParameters(response.parameters);
+
+			// Update cache reactively
+			const newCache = new Map(this.modelDefaultsCache);
+			newCache.set(modelName, defaults);
+			this.modelDefaultsCache = newCache;
+
+			return defaults;
+		} catch (err) {
+			console.warn(`Failed to fetch defaults for ${modelName}:`, err);
+			return {};
+		} finally {
+			this.modelDefaultsFetching.delete(modelName);
+		}
+	}
+
+	/**
+	 * Get cached model defaults (returns empty if not fetched)
+	 */
+	getModelDefaults(modelName: string): ModelDefaults {
+		return this.modelDefaultsCache.get(modelName) ?? {};
+	}
+
+	/**
+	 * Get defaults for selected model
+	 */
+	get selectedModelDefaults(): ModelDefaults {
+		if (!this.selectedId) return {};
+		return this.modelDefaultsCache.get(this.selectedId) ?? {};
+	}
 }

 /** Singleton models state instance */
--- a/frontend/src/lib/stores/settings.svelte.ts
+++ b/frontend/src/lib/stores/settings.svelte.ts
@@ -10,6 +10,7 @@ import {
 	DEFAULT_CHAT_SETTINGS,
 	PARAMETER_RANGES
 } from '$lib/types/settings';
+import type { ModelDefaults } from './models.svelte';

 const STORAGE_KEY = 'vessel-settings';

@@ -79,12 +80,30 @@ export class SettingsState {

 	/**
 	 * Toggle whether to use custom parameters
+	 * When enabling, optionally initialize from model defaults
 	 */
-	toggleCustomParameters(): void {
+	toggleCustomParameters(modelDefaults?: ModelDefaults): void {
 		this.useCustomParameters = !this.useCustomParameters;
+
+		// When enabling custom parameters, initialize from model defaults if provided
+		if (this.useCustomParameters && modelDefaults) {
+			this.initializeFromModelDefaults(modelDefaults);
+		}
+
 		this.saveToStorage();
 	}

+	/**
+	 * Initialize parameters from model defaults
+	 * Falls back to hardcoded defaults for any missing values
+	 */
+	initializeFromModelDefaults(modelDefaults: ModelDefaults): void {
+		this.temperature = modelDefaults.temperature ?? DEFAULT_MODEL_PARAMETERS.temperature;
+		this.top_k = modelDefaults.top_k ?? DEFAULT_MODEL_PARAMETERS.top_k;
+		this.top_p = modelDefaults.top_p ?? DEFAULT_MODEL_PARAMETERS.top_p;
+		this.num_ctx = modelDefaults.num_ctx ?? DEFAULT_MODEL_PARAMETERS.num_ctx;
+	}
+
 	/**
 	 * Update a single parameter
 	 */
@@ -112,14 +131,13 @@ export class SettingsState {
 	}

 	/**
-	 * Reset all parameters to defaults
+	 * Reset all parameters to model defaults (or hardcoded defaults if not available)
 	 */
-	resetToDefaults(): void {
-		this.temperature = DEFAULT_MODEL_PARAMETERS.temperature;
-		this.top_k = DEFAULT_MODEL_PARAMETERS.top_k;
-		this.top_p = DEFAULT_MODEL_PARAMETERS.top_p;
-		this.num_ctx = DEFAULT_MODEL_PARAMETERS.num_ctx;
-		this.useCustomParameters = false;
+	resetToDefaults(modelDefaults?: ModelDefaults): void {
+		this.temperature = modelDefaults?.temperature ?? DEFAULT_MODEL_PARAMETERS.temperature;
+		this.top_k = modelDefaults?.top_k ?? DEFAULT_MODEL_PARAMETERS.top_k;
+		this.top_p = modelDefaults?.top_p ?? DEFAULT_MODEL_PARAMETERS.top_p;
+		this.num_ctx = modelDefaults?.num_ctx ?? DEFAULT_MODEL_PARAMETERS.num_ctx;
 		this.saveToStorage();
 	}

--- a/frontend/src/lib/stores/tools.svelte.ts
+++ b/frontend/src/lib/stores/tools.svelte.ts
@@ -110,8 +110,25 @@ class ToolsState {
 			return [];
 		}

-		const definitions = toolRegistry.getDefinitions();
-		return definitions.filter(def => this.isToolEnabled(def.function.name));
+		// Get enabled builtin tools
+		const builtinDefs = toolRegistry.getDefinitions();
+		const enabled = builtinDefs.filter(def => this.isToolEnabled(def.function.name));
+
+		// Add enabled custom tools
+		for (const custom of this.customTools) {
+			if (custom.enabled && this.isToolEnabled(custom.name)) {
+				enabled.push({
+					type: 'function',
+					function: {
+						name: custom.name,
+						description: custom.description,
+						parameters: custom.parameters
+					}
+				});
+			}
+		}
+
+		return enabled;
 	}

 	/**
--- a/frontend/src/lib/tools/builtin.ts
+++ b/frontend/src/lib/tools/builtin.ts
@@ -292,7 +292,9 @@ class MathParser {
 const mathParser = new MathParser();

 const calculateHandler: BuiltinToolHandler<CalculateArgs> = (args) => {
-	const { expression, precision = 10 } = args;
+	const { expression } = args;
+	// Coerce to number - Ollama models sometimes output numbers as strings
+	const precision = Number(args.precision) || 10;

 	try {
 		const result = mathParser.parse(expression);
@@ -423,7 +425,10 @@ async function fetchViaProxy(url: string, maxLength: number, timeout: number): P
 }

 const fetchUrlHandler: BuiltinToolHandler<FetchUrlArgs> = async (args) => {
-	const { url, extract = 'text', maxLength = 50000, timeout = 30 } = args;
+	const { url, extract = 'text' } = args;
+	// Coerce to numbers - Ollama models sometimes output numbers as strings
+	const maxLength = Number(args.maxLength) || 50000;
+	const timeout = Number(args.timeout) || 30;

 	try {
 		const parsedUrl = new URL(url);
@@ -683,7 +688,10 @@ const webSearchDefinition: ToolDefinition = {
 };

 const webSearchHandler: BuiltinToolHandler<WebSearchArgs> = async (args) => {
-	const { query, maxResults = 5, site, freshness, region, timeout } = args;
+	const { query, site, freshness, region } = args;
+	// Coerce to numbers - Ollama models sometimes output numbers as strings
+	const maxResults = Number(args.maxResults) || 5;
+	const timeout = Number(args.timeout) || undefined;

 	if (!query || query.trim() === '') {
 		return { error: 'Search query is required' };
--- a/frontend/src/lib/tools/executor.ts
+++ b/frontend/src/lib/tools/executor.ts
@@ -41,6 +41,45 @@ async function executeJavaScriptTool(tool: CustomTool, args: Record<string, unkn
 	}
 }

+/**
+ * Execute a custom Python tool via backend API
+ *
+ * SECURITY NOTE: This sends user-provided Python code to the backend for execution.
+ * This is by design - users create custom tools with their own code.
+ * The backend executes code in a subprocess with timeout protection.
+ */
+async function executePythonTool(tool: CustomTool, args: Record<string, unknown>): Promise<unknown> {
+	if (!tool.code) {
+		throw new Error('Python tool has no code');
+	}
+
+	try {
+		const response = await fetch('/api/v1/tools/execute', {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify({
+				language: 'python',
+				code: tool.code,
+				args,
+				timeout: 30
+			})
+		});
+
+		if (!response.ok) {
+			throw new Error(`Backend error: ${response.status} ${response.statusText}`);
+		}
+
+		const data = await response.json();
+		if (!data.success) {
+			throw new Error(data.error || 'Python execution failed');
+		}
+
+		return data.result;
+	} catch (error) {
+		throw new Error(`Python tool error: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+
 /**
 * Execute a custom HTTP tool
 */
@@ -168,6 +207,8 @@ export async function executeCustomTool(
 	switch (tool.implementation) {
 		case 'javascript':
 			return executeJavaScriptTool(tool, args);
+		case 'python':
+			return executePythonTool(tool, args);
 		case 'http':
 			return executeHttpTool(tool, args);
 		default:
--- a/frontend/src/lib/tools/index.ts
+++ b/frontend/src/lib/tools/index.ts
@@ -21,3 +21,10 @@ export {
 	defaultToolConfig,
 	type ToolConfig
 } from './config.js';
+export {
+	toolTemplates,
+	getTemplatesByLanguage,
+	getTemplatesByCategory,
+	getTemplateById,
+	type ToolTemplate
+} from './templates.js';
--- a/frontend/src/lib/tools/templates.ts
+++ b/frontend/src/lib/tools/templates.ts
@@ -0,0 +1,352 @@
+/**
+ * Tool templates - Starter templates for custom tools
+ */
+
+import type { JSONSchema, ToolImplementation } from './types';
+
+export interface ToolTemplate {
+	id: string;
+	name: string;
+	description: string;
+	category: 'api' | 'data' | 'utility' | 'integration';
+	language: ToolImplementation;
+	code: string;
+	parameters: JSONSchema;
+}
+
+export const toolTemplates: ToolTemplate[] = [
+	// JavaScript Templates
+	{
+		id: 'js-api-fetch',
+		name: 'API Request',
+		description: 'Fetch data from an external REST API',
+		category: 'api',
+		language: 'javascript',
+		code: `// Fetch data from an API endpoint
+const response = await fetch(args.url, {
+  method: args.method || 'GET',
+  headers: {
+    'Content-Type': 'application/json',
+    ...(args.headers || {})
+  },
+  ...(args.body ? { body: JSON.stringify(args.body) } : {})
+});
+
+if (!response.ok) {
+  throw new Error(\`HTTP \${response.status}: \${response.statusText}\`);
+}
+
+return await response.json();`,
+		parameters: {
+			type: 'object',
+			properties: {
+				url: { type: 'string', description: 'The API endpoint URL' },
+				method: { type: 'string', description: 'HTTP method (GET, POST, etc.)' },
+				headers: { type: 'object', description: 'Additional headers' },
+				body: { type: 'object', description: 'Request body for POST/PUT' }
+			},
+			required: ['url']
+		}
+	},
+	{
+		id: 'js-json-transform',
+		name: 'JSON Transform',
+		description: 'Transform and filter JSON data',
+		category: 'data',
+		language: 'javascript',
+		code: `// Transform JSON data
+const data = args.data;
+const fields = args.fields || Object.keys(data[0] || data);
+
+// Handle both arrays and single objects
+const items = Array.isArray(data) ? data : [data];
+
+const result = items.map(item => {
+  const filtered = {};
+  for (const field of fields) {
+    if (field in item) {
+      filtered[field] = item[field];
+    }
+  }
+  return filtered;
+});
+
+return Array.isArray(data) ? result : result[0];`,
+		parameters: {
+			type: 'object',
+			properties: {
+				data: { type: 'object', description: 'JSON data to transform' },
+				fields: { type: 'array', description: 'Fields to keep (optional)' }
+			},
+			required: ['data']
+		}
+	},
+	{
+		id: 'js-string-utils',
+		name: 'String Utilities',
+		description: 'Common string manipulation operations',
+		category: 'utility',
+		language: 'javascript',
+		code: `// String manipulation utilities
+const text = args.text;
+const operation = args.operation;
+
+switch (operation) {
+  case 'uppercase':
+    return text.toUpperCase();
+  case 'lowercase':
+    return text.toLowerCase();
+  case 'capitalize':
+    return text.charAt(0).toUpperCase() + text.slice(1).toLowerCase();
+  case 'reverse':
+    return text.split('').reverse().join('');
+  case 'word_count':
+    return { count: text.split(/\\s+/).filter(w => w).length };
+  case 'char_count':
+    return { count: text.length };
+  case 'slug':
+    return text.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+  default:
+    return { text, error: 'Unknown operation' };
+}`,
+		parameters: {
+			type: 'object',
+			properties: {
+				text: { type: 'string', description: 'Input text to process' },
+				operation: { type: 'string', description: 'Operation: uppercase, lowercase, capitalize, reverse, word_count, char_count, slug' }
+			},
+			required: ['text', 'operation']
+		}
+	},
+	{
+		id: 'js-date-utils',
+		name: 'Date Utilities',
+		description: 'Date formatting and calculations',
+		category: 'utility',
+		language: 'javascript',
+		code: `// Date utilities
+const date = args.date ? new Date(args.date) : new Date();
+const format = args.format || 'iso';
+
+const formatDate = (d, fmt) => {
+  const pad = n => String(n).padStart(2, '0');
+
+  switch (fmt) {
+    case 'iso':
+      return d.toISOString();
+    case 'date':
+      return d.toLocaleDateString();
+    case 'time':
+      return d.toLocaleTimeString();
+    case 'unix':
+      return Math.floor(d.getTime() / 1000);
+    case 'relative':
+      const diff = Date.now() - d.getTime();
+      const mins = Math.floor(diff / 60000);
+      if (mins < 60) return \`\${mins} minutes ago\`;
+      const hours = Math.floor(mins / 60);
+      if (hours < 24) return \`\${hours} hours ago\`;
+      return \`\${Math.floor(hours / 24)} days ago\`;
+    default:
+      return d.toISOString();
+  }
+};
+
+return {
+  formatted: formatDate(date, format),
+  timestamp: date.getTime(),
+  iso: date.toISOString()
+};`,
+		parameters: {
+			type: 'object',
+			properties: {
+				date: { type: 'string', description: 'Date string or timestamp (default: now)' },
+				format: { type: 'string', description: 'Format: iso, date, time, unix, relative' }
+			}
+		}
+	},
+
+	// Python Templates
+	{
+		id: 'py-api-fetch',
+		name: 'API Request (Python)',
+		description: 'Fetch data from an external REST API using Python',
+		category: 'api',
+		language: 'python',
+		code: `# Fetch data from an API endpoint
+import json
+import urllib.request
+import urllib.error
+
+url = args.get('url')
+method = args.get('method', 'GET')
+headers = args.get('headers', {})
+body = args.get('body')
+
+req = urllib.request.Request(url, method=method)
+req.add_header('Content-Type', 'application/json')
+for key, value in headers.items():
+    req.add_header(key, value)
+
+data = json.dumps(body).encode() if body else None
+
+try:
+    with urllib.request.urlopen(req, data=data) as response:
+        result = json.loads(response.read().decode())
+        print(json.dumps(result))
+except urllib.error.HTTPError as e:
+    print(json.dumps({"error": f"HTTP {e.code}: {e.reason}"}))`,
+		parameters: {
+			type: 'object',
+			properties: {
+				url: { type: 'string', description: 'The API endpoint URL' },
+				method: { type: 'string', description: 'HTTP method (GET, POST, etc.)' },
+				headers: { type: 'object', description: 'Additional headers' },
+				body: { type: 'object', description: 'Request body for POST/PUT' }
+			},
+			required: ['url']
+		}
+	},
+	{
+		id: 'py-data-analysis',
+		name: 'Data Analysis (Python)',
+		description: 'Basic statistical analysis of numeric data',
+		category: 'data',
+		language: 'python',
+		code: `# Basic data analysis
+import json
+import math
+
+data = args.get('data', [])
+if not data:
+    print(json.dumps({"error": "No data provided"}))
+else:
+    n = len(data)
+    total = sum(data)
+    mean = total / n
+
+    sorted_data = sorted(data)
+    mid = n // 2
+    median = sorted_data[mid] if n % 2 else (sorted_data[mid-1] + sorted_data[mid]) / 2
+
+    variance = sum((x - mean) ** 2 for x in data) / n
+    std_dev = math.sqrt(variance)
+
+    result = {
+        "count": n,
+        "sum": total,
+        "mean": round(mean, 4),
+        "median": median,
+        "min": min(data),
+        "max": max(data),
+        "std_dev": round(std_dev, 4),
+        "variance": round(variance, 4)
+    }
+    print(json.dumps(result))`,
+		parameters: {
+			type: 'object',
+			properties: {
+				data: { type: 'array', description: 'Array of numbers to analyze' }
+			},
+			required: ['data']
+		}
+	},
+	{
+		id: 'py-text-analysis',
+		name: 'Text Analysis (Python)',
+		description: 'Analyze text for word frequency, sentiment indicators',
+		category: 'data',
+		language: 'python',
+		code: `# Text analysis
+import json
+import re
+from collections import Counter
+
+text = args.get('text', '')
+top_n = args.get('top_n', 10)
+
+# Tokenize and count
+words = re.findall(r'\\b\\w+\\b', text.lower())
+word_freq = Counter(words)
+
+# Basic stats
+sentences = re.split(r'[.!?]+', text)
+sentences = [s.strip() for s in sentences if s.strip()]
+
+result = {
+    "word_count": len(words),
+    "unique_words": len(word_freq),
+    "sentence_count": len(sentences),
+    "avg_word_length": round(sum(len(w) for w in words) / len(words), 2) if words else 0,
+    "top_words": dict(word_freq.most_common(top_n)),
+    "char_count": len(text),
+    "char_count_no_spaces": len(text.replace(' ', ''))
+}
+print(json.dumps(result))`,
+		parameters: {
+			type: 'object',
+			properties: {
+				text: { type: 'string', description: 'Text to analyze' },
+				top_n: { type: 'number', description: 'Number of top words to return (default: 10)' }
+			},
+			required: ['text']
+		}
+	},
+	{
+		id: 'py-hash-encode',
+		name: 'Hash & Encode (Python)',
+		description: 'Hash strings and encode/decode base64',
+		category: 'utility',
+		language: 'python',
+		code: `# Hash and encoding utilities
+import json
+import hashlib
+import base64
+
+text = args.get('text', '')
+operation = args.get('operation', 'md5')
+
+result = {}
+
+if operation == 'md5':
+    result['hash'] = hashlib.md5(text.encode()).hexdigest()
+elif operation == 'sha256':
+    result['hash'] = hashlib.sha256(text.encode()).hexdigest()
+elif operation == 'sha512':
+    result['hash'] = hashlib.sha512(text.encode()).hexdigest()
+elif operation == 'base64_encode':
+    result['encoded'] = base64.b64encode(text.encode()).decode()
+elif operation == 'base64_decode':
+    try:
+        result['decoded'] = base64.b64decode(text.encode()).decode()
+    except Exception as e:
+        result['error'] = str(e)
+else:
+    result['error'] = f'Unknown operation: {operation}'
+
+result['operation'] = operation
+result['input_length'] = len(text)
+
+print(json.dumps(result))`,
+		parameters: {
+			type: 'object',
+			properties: {
+				text: { type: 'string', description: 'Text to process' },
+				operation: { type: 'string', description: 'Operation: md5, sha256, sha512, base64_encode, base64_decode' }
+			},
+			required: ['text', 'operation']
+		}
+	}
+];
+
+export function getTemplatesByLanguage(language: ToolImplementation): ToolTemplate[] {
+	return toolTemplates.filter(t => t.language === language);
+}
+
+export function getTemplatesByCategory(category: ToolTemplate['category']): ToolTemplate[] {
+	return toolTemplates.filter(t => t.category === category);
+}
+
+export function getTemplateById(id: string): ToolTemplate | undefined {
+	return toolTemplates.find(t => t.id === id);
+}
--- a/frontend/src/lib/tools/types.ts
+++ b/frontend/src/lib/tools/types.ts
@@ -54,7 +54,7 @@ export interface ToolResult {
 }

 /** Tool implementation type */
-export type ToolImplementation = 'builtin' | 'javascript' | 'http';
+export type ToolImplementation = 'builtin' | 'javascript' | 'python' | 'http';

 /** Custom tool configuration */
 export interface CustomTool {
@@ -63,7 +63,7 @@ export interface CustomTool {
 	description: string;
 	parameters: JSONSchema;
 	implementation: ToolImplementation;
-	/** JavaScript code for 'javascript' implementation */
+	/** Code for 'javascript' or 'python' implementation */
 	code?: string;
 	/** HTTP endpoint for 'http' implementation */
 	endpoint?: string;
--- a/frontend/src/routes/models/+page.svelte
+++ b/frontend/src/routes/models/+page.svelte
@@ -40,12 +40,14 @@
 	let pullProgress = $state<{ status: string; completed?: number; total?: number } | null>(null);
 	let pullError = $state<string | null>(null);
 	let loadingSizes = $state(false);
+	let capabilitiesVerified = $state(false); // True if capabilities come from Ollama (installed model)

 	async function handleSelectModel(model: RemoteModel): Promise<void> {
 		selectedModel = model;
 		selectedTag = model.tags[0] || '';
 		pullProgress = null;
 		pullError = null;
+		capabilitiesVerified = false;

 		// Fetch tag sizes if not already loaded
 		if (!model.tagSizes || Object.keys(model.tagSizes).length === 0) {
@@ -60,6 +62,21 @@
 				loadingSizes = false;
 			}
 		}
+
+		// Try to fetch real capabilities from Ollama if model is installed locally
+		// This overrides scraped capabilities from ollama.com with accurate runtime data
+		try {
+			const realCapabilities = await modelsState.fetchCapabilities(model.slug);
+			// fetchCapabilities returns empty array on error, but we check hasCapability to confirm model exists
+			if (modelsState.hasCapability(model.slug, 'completion') || realCapabilities.length > 0) {
+				// Model is installed - use real capabilities from Ollama
+				selectedModel = { ...selectedModel!, capabilities: realCapabilities };
+				capabilitiesVerified = true;
+			}
+		} catch {
+			// Model not installed locally - keep scraped capabilities
+			capabilitiesVerified = false;
+		}
 	}

 	function closeDetails(): void {
@@ -219,7 +236,10 @@
 		// Initialize stores (backend handles heavy operations)
 		localModelsState.init();
 		modelRegistry.init();
-		modelsState.refresh();
+		modelsState.refresh().then(() => {
+			// Fetch capabilities for all installed models
+			modelsState.fetchAllCapabilities();
+		});
 	});
 </script>

@@ -476,6 +496,7 @@
 				{:else}
 					<div class="space-y-2">
 						{#each localModelsState.models as model (model.name)}
+							{@const caps = modelsState.getCapabilities(model.name) ?? []}
 							<div class="group rounded-lg border border-theme bg-theme-secondary p-4 transition-colors hover:border-theme-subtle">
 								<div class="flex items-center justify-between">
 									<div class="flex-1">
@@ -496,6 +517,36 @@
 											<span>Parameters: {model.parameterSize}</span>
 											<span>Quantization: {model.quantizationLevel}</span>
 										</div>
+										<!-- Capabilities (from Ollama runtime - verified) -->
+										{#if caps.length > 0}
+											<div class="mt-2 flex flex-wrap gap-1.5">
+												{#if caps.includes('vision')}
+													<span class="inline-flex items-center gap-1 rounded px-1.5 py-0.5 text-xs bg-purple-900/50 text-purple-300">
+														<span>👁</span><span>Vision</span>
+													</span>
+												{/if}
+												{#if caps.includes('tools')}
+													<span class="inline-flex items-center gap-1 rounded px-1.5 py-0.5 text-xs bg-blue-900/50 text-blue-300">
+														<span>🔧</span><span>Tools</span>
+													</span>
+												{/if}
+												{#if caps.includes('thinking')}
+													<span class="inline-flex items-center gap-1 rounded px-1.5 py-0.5 text-xs bg-pink-900/50 text-pink-300">
+														<span>🧠</span><span>Thinking</span>
+													</span>
+												{/if}
+												{#if caps.includes('embedding')}
+													<span class="inline-flex items-center gap-1 rounded px-1.5 py-0.5 text-xs bg-amber-900/50 text-amber-300">
+														<span>📊</span><span>Embedding</span>
+													</span>
+												{/if}
+												{#if caps.includes('code')}
+													<span class="inline-flex items-center gap-1 rounded px-1.5 py-0.5 text-xs bg-emerald-900/50 text-emerald-300">
+														<span>💻</span><span>Code</span>
+													</span>
+												{/if}
+											</div>
+										{/if}
 									</div>
 									<div class="flex items-center gap-2">
 										{#if deleteConfirm === model.name}
@@ -641,7 +692,7 @@
 			</div>

 			<!-- Capability Filters (matches ollama.com capabilities) -->
-			<div class="mb-6 flex flex-wrap items-center gap-2">
+			<div class="mb-4 flex flex-wrap items-center gap-2">
 				<span class="text-sm text-theme-muted">Capabilities:</span>
 				<button
 					type="button"
@@ -694,13 +745,81 @@
 					<span>Cloud</span>
 				</button>

-				{#if modelRegistry.selectedCapabilities.length > 0 || modelRegistry.modelType || modelRegistry.searchQuery || modelRegistry.sortBy !== 'pulls_desc'}
+				<!-- Capability info notice -->
+				<span class="ml-2 text-xs text-theme-muted" title="Capability data is sourced from ollama.com and may not be accurate. Actual capabilities are verified once a model is installed locally.">
+					<svg xmlns="http://www.w3.org/2000/svg" class="inline h-3.5 w-3.5 opacity-60" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
+						<path stroke-linecap="round" stroke-linejoin="round" d="M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" />
+					</svg>
+					<span class="opacity-60">from ollama.com</span>
+				</span>
+			</div>
+
+			<!-- Size Range Filters -->
+			<div class="mb-4 flex flex-wrap items-center gap-2">
+				<span class="text-sm text-theme-muted">Size:</span>
+				<button
+					type="button"
+					onclick={() => modelRegistry.toggleSizeRange('small')}
+					class="rounded-full px-3 py-1 text-sm transition-colors {modelRegistry.hasSizeRange('small')
+						? 'bg-emerald-600 text-theme-primary'
+						: 'bg-theme-secondary text-theme-muted hover:bg-theme-tertiary hover:text-theme-primary'}"
+				>
+					≤3B
+				</button>
+				<button
+					type="button"
+					onclick={() => modelRegistry.toggleSizeRange('medium')}
+					class="rounded-full px-3 py-1 text-sm transition-colors {modelRegistry.hasSizeRange('medium')
+						? 'bg-emerald-600 text-theme-primary'
+						: 'bg-theme-secondary text-theme-muted hover:bg-theme-tertiary hover:text-theme-primary'}"
+				>
+					4-13B
+				</button>
+				<button
+					type="button"
+					onclick={() => modelRegistry.toggleSizeRange('large')}
+					class="rounded-full px-3 py-1 text-sm transition-colors {modelRegistry.hasSizeRange('large')
+						? 'bg-emerald-600 text-theme-primary'
+						: 'bg-theme-secondary text-theme-muted hover:bg-theme-tertiary hover:text-theme-primary'}"
+				>
+					14-70B
+				</button>
+				<button
+					type="button"
+					onclick={() => modelRegistry.toggleSizeRange('xlarge')}
+					class="rounded-full px-3 py-1 text-sm transition-colors {modelRegistry.hasSizeRange('xlarge')
+						? 'bg-emerald-600 text-theme-primary'
+						: 'bg-theme-secondary text-theme-muted hover:bg-theme-tertiary hover:text-theme-primary'}"
+				>
+					>70B
+				</button>
+			</div>
+
+			<!-- Family Filter + Clear All -->
+			<div class="mb-6 flex flex-wrap items-center gap-4">
+				{#if modelRegistry.availableFamilies.length > 0}
+					<div class="flex items-center gap-2">
+						<span class="text-sm text-theme-muted">Family:</span>
+						<select
+							value={modelRegistry.selectedFamily}
+							onchange={(e) => modelRegistry.setFamily((e.target as HTMLSelectElement).value)}
+							class="rounded-lg border border-theme bg-theme-secondary px-3 py-1.5 text-sm text-theme-primary focus:border-blue-500 focus:outline-none focus:ring-1 focus:ring-blue-500"
+						>
+							<option value="">All Families</option>
+							{#each modelRegistry.availableFamilies as family}
+								<option value={family}>{family}</option>
+							{/each}
+						</select>
+					</div>
+				{/if}
+
+				{#if modelRegistry.selectedCapabilities.length > 0 || modelRegistry.selectedSizeRanges.length > 0 || modelRegistry.selectedFamily || modelRegistry.modelType || modelRegistry.searchQuery || modelRegistry.sortBy !== 'pulls_desc'}
 					<button
 						type="button"
 						onclick={() => { modelRegistry.clearFilters(); searchInput = ''; }}
-						class="ml-2 text-sm text-theme-muted hover:text-theme-primary"
+						class="text-sm text-theme-muted hover:text-theme-primary"
 					>
-						Clear filters
+						Clear all filters
 					</button>
 				{/if}
 			</div>
@@ -826,14 +945,40 @@
 			{/if}

 			<!-- Capabilities -->
-			{#if selectedModel.capabilities.length > 0}
+			{#if selectedModel.capabilities.length > 0 || !capabilitiesVerified}
 				<div class="mb-6">
-					<h3 class="mb-2 text-sm font-medium text-theme-secondary">Capabilities</h3>
-					<div class="flex flex-wrap gap-2">
-						{#each selectedModel.capabilities as cap}
-							<span class="rounded bg-theme-tertiary px-2 py-1 text-xs text-theme-secondary">{cap}</span>
-						{/each}
-					</div>
+					<h3 class="mb-2 flex items-center gap-2 text-sm font-medium text-theme-secondary">
+						<span>Capabilities</span>
+						{#if capabilitiesVerified}
+							<span class="inline-flex items-center gap-1 rounded bg-green-900/30 px-1.5 py-0.5 text-xs text-green-400" title="Capabilities verified from installed model">
+								<svg xmlns="http://www.w3.org/2000/svg" class="h-3 w-3" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
+									<path stroke-linecap="round" stroke-linejoin="round" d="M5 13l4 4L19 7" />
+								</svg>
+								verified
+							</span>
+						{:else}
+							<span class="inline-flex items-center gap-1 rounded bg-amber-900/30 px-1.5 py-0.5 text-xs text-amber-400" title="Capabilities sourced from ollama.com - install model for verified data">
+								<svg xmlns="http://www.w3.org/2000/svg" class="h-3 w-3" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
+									<path stroke-linecap="round" stroke-linejoin="round" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z" />
+								</svg>
+								unverified
+							</span>
+						{/if}
+					</h3>
+					{#if selectedModel.capabilities.length > 0}
+						<div class="flex flex-wrap gap-2">
+							{#each selectedModel.capabilities as cap}
+								<span class="rounded bg-theme-tertiary px-2 py-1 text-xs text-theme-secondary">{cap}</span>
+							{/each}
+						</div>
+					{:else}
+						<p class="text-xs text-theme-muted">No capabilities reported</p>
+					{/if}
+					{#if !capabilitiesVerified}
+						<p class="mt-2 text-xs text-theme-muted">
+							Install model to verify actual capabilities
+						</p>
+					{/if}
 				</div>
 			{/if}

--- a/frontend/vite.config.ts
+++ b/frontend/vite.config.ts
@@ -4,11 +4,12 @@ import { defineConfig } from 'vite';
 // Use environment variable or default to localhost (works with host network mode)
 const ollamaUrl = process.env.OLLAMA_API_URL || 'http://localhost:11434';
 const backendUrl = process.env.BACKEND_URL || 'http://localhost:9090';
+const devPort = parseInt(process.env.DEV_PORT || '7842', 10);

 export default defineConfig({
 	plugins: [sveltekit()],
 	server: {
-		port: 7842,
+		port: devPort,
 		proxy: {
 			// Backend health check
 			'/health': {
Author	SHA1	Message	Date
vikingowl	e19b6330e9	chore: bump version to 0.4.8 Some checks failed Create Release / release (push) Has been cancelled Details	2026-01-03 15:32:04 +01:00
vikingowl	c194a4e0e9	fix: include custom tools in Ollama API requests Custom tools were displayed as enabled in the UI but never sent to Ollama because getEnabledToolDefinitions() only queried the builtin tool registry. Now iterates customTools and includes enabled ones. Fixes #4	2026-01-03 15:29:25 +01:00
vikingowl	04c3018360	chore: bump version to 0.4.7 Some checks failed Create Release / release (push) Has been cancelled Details	2026-01-02 22:42:35 +01:00
vikingowl	2699f1cd5c	fix: handle null updates array and show capabilities for local models - Fix TypeError when check updates returns null updates array - Display verified capabilities from Ollama runtime in Local Models tab - Fetch all model capabilities on page mount - Add data-dev to gitignore	2026-01-02 22:41:37 +01:00
vikingowl	9f313e6599	feat: verify model capabilities from Ollama runtime Some checks failed Create Release / release (push) Has been cancelled Details - Add capability verification for installed models using /api/show - SyncModels now updates real capabilities when fetchDetails=true - Model browser shows verified/unverified badges for capabilities - Add info notice that capabilities are sourced from ollama.com - Fix incorrect capability data (e.g., deepseek-r1 "tools" badge) Capabilities from ollama.com website may be inaccurate. Once a model is installed, Vessel fetches actual capabilities from Ollama runtime and displays a "verified" badge in the model details panel.	2026-01-02 22:35:03 +01:00
vikingowl	802db229a6	feat: add model filters and last updated display Some checks failed Create Release / release (push) Has been cancelled Details - Add size filter (≤3B, 4-13B, 14-70B, >70B) based on model tags - Add model family filter dropdown with dynamic family list - Display last updated date on model cards (scraped from ollama.com) - Add /api/v1/models/remote/families endpoint - Convert relative time strings ("2 weeks ago") to timestamps during sync	2026-01-02 21:54:50 +01:00
vikingowl	14b566ce2a	feat: add DEV_PORT env var for running dev alongside production	2026-01-02 21:17:32 +01:00
vikingowl	7ef29aba37	fix: coerce numeric tool args to handle string values from Ollama Ollama models sometimes output numbers as strings in tool call arguments. Go backend strictly rejects string→int coercion, causing errors like: "cannot unmarshal string into Go struct field URLFetchRequest.maxLength" - fetch_url: coerce maxLength, timeout - web_search: coerce maxResults, timeout - calculate: coerce precision	2026-01-02 21:08:52 +01:00
vikingowl	3c8d811cdc	chore: bump version to 0.4.3 Some checks failed Create Release / release (push) Has been cancelled Details	2026-01-02 21:05:03 +01:00
vikingowl	5cab71dd78	fix: sync context progress bar with custom context length setting - Add customMaxTokens override to ContextManager - maxTokens is now derived from custom override or model default - ChatWindow syncs settings.num_ctx to context manager - Progress bar now shows custom context length when enabled	2026-01-02 21:04:47 +01:00
vikingowl	41bee19f6b	chore: bump version to 0.4.2 Some checks failed Create Release / release (push) Has been cancelled Details	2026-01-02 20:54:55 +01:00
vikingowl	f4febf8973	fix: initialize custom parameters from model defaults - Fetch actual model defaults from Ollama's /api/show endpoint - Parse YAML-like parameters field (e.g., "temperature 0.7") - Cache model defaults to avoid repeated API calls - Initialize sliders with model's actual values when enabling custom params - Show asterisk indicator when parameter differs from model default - Reset button now restores to model defaults, not hardcoded values	2026-01-02 20:52:47 +01:00
vikingowl	a552f4a223	chore: bump version to 0.4.1 Some checks failed Create Release / release (push) Has been cancelled Details	2026-01-02 20:36:03 +01:00
vikingowl	4a9e45b40b	fix: persist toolCalls to database for reload persistence Tool usage was not showing after page reload because the toolCalls field was not being included when saving assistant messages to the database. Now toolCalls are properly persisted and restored.	2026-01-02 20:34:53 +01:00
vikingowl	862f47c46e	feat(tools): enhanced custom tool creation with CodeMirror, Python support, and testing Some checks failed Create Release / release (push) Has been cancelled Details - Add CodeMirror editor with syntax highlighting for JavaScript and Python - Add 8 starter templates (4 JS, 4 Python) for common tool patterns - Add inline documentation panel with language-specific guidance - Add tool testing UI to run tools with sample inputs before saving - Add Python tool execution via backend API with 30s timeout - Add POST /api/v1/tools/execute endpoint for backend tool execution - Update Dockerfile to include Python 3 for tool execution - Bump version to 0.4.0	2026-01-02 20:15:40 +01:00
vikingowl	5572cd3a0d	ci: auto-create GitHub release on tag push	2026-01-02 19:46:29 +01:00
vikingowl	6426850714	chore: add CLAUDE.md to gitignore	2026-01-02 19:42:47 +01:00