chore(release): Update version to v1.4.386

Merge pull request #1945 from ksylvan/implement-spotify-api
feat: Add Spotify API integration for podcast metadata retrieval
2026-01-20 19:58:03 -05:00 · 2026-01-21 00:17:17 +00:00 · 2026-01-20 16:13:04 -08:00 · 2026-01-20 16:01:09 -08:00 · 2026-01-20 15:57:59 -08:00 · 2026-01-20 20:07:22 +00:00
35 changed files with 2245 additions and 57 deletions
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -252,5 +252,8 @@
 	},
 	"[json]": {
 		"editor.formatOnSave": false
+	},
+	"gopls": {
+		"build.buildFlags": ["-tags=integration"]
 	}
 }
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,61 @@
 # Changelog

+## v1.4.386 (2026-01-21)
+
+### PR [#1945](https://github.com/danielmiessler/Fabric/pull/1945) by [ksylvan](https://github.com/ksylvan): feat: Add Spotify API integration for podcast metadata retrieval
+
+- Add Spotify metadata retrieval via --spotify flag
+- Add Spotify plugin with OAuth token handling and metadata
+- Wire --spotify flag into CLI processing and output
+- Register Spotify in plugin setup, env, and registry
+- Update shell completions to include --spotify option
+
+## v1.4.385 (2026-01-20)
+
+### PR [#1947](https://github.com/danielmiessler/Fabric/pull/1947) by [cleong14](https://github.com/cleong14): feat(patterns): add extract_bd_ideas pattern
+
+- Added extract_bd_ideas pattern that extracts actionable ideas from content and transforms them into well-structured bd issue tracker commands
+- Implemented identification system for tasks, problems, ideas, improvements, bugs, and features
+- Added actionability evaluation and appropriate scoping functionality
+- Integrated priority assignment system (P0-P4) with relevant labels
+- Created ready-to-execute bd create commands output format
+
+### PR [#1948](https://github.com/danielmiessler/Fabric/pull/1948) by [cleong14](https://github.com/cleong14): feat(patterns): add create_bd_issue pattern
+
+- Added create_bd_issue pattern that transforms natural language issue descriptions into optimal bd (Beads) issue tracker commands
+- Implemented comprehensive bd create flag reference for better command generation
+- Added intelligent type detection system that automatically categorizes issues as bug, feature, task, epic, or chore
+- Included priority assessment capability that assigns P0-P4 priority levels based on urgency signals in descriptions
+- Integrated smart label selection feature that automatically chooses 1-4 relevant labels for each issue
+
+### PR [#1949](https://github.com/danielmiessler/Fabric/pull/1949) by [ksylvan](https://github.com/ksylvan): Fix #1931 - Image Generation Feature should warn if the model is not capable of Image Generation
+
+- Add image generation compatibility warnings for unsupported models
+- Add warning to stderr when using incompatible models with image generation
+- Add GPT-5, GPT-5-nano, and GPT-5.2 to supported image generation models
+- Create `checkImageGenerationCompatibility` function in OpenAI plugin
+- Add comprehensive tests for image generation compatibility warnings
+
+## v1.4.384 (2026-01-19)
+
+### PR [#1944](https://github.com/danielmiessler/Fabric/pull/1944) by [ksylvan](https://github.com/ksylvan): Add Infermatic AI Provider Support
+
+- Add Infermatic provider to ProviderMap as part of Phase 1 implementation for issue #1033
+- Add test coverage for the Infermatic AI provider in TestCreateClient to verify provider exists and creates valid client
+- Replace go-git status API with native `git status --porcelain` command to fix worktree compatibility issues
+- Simplify `IsWorkingDirectoryClean` and `GetStatusDetails` functions to use CLI output parsing instead of go-git library
+- Use native `git rev-parse HEAD` to get commit hash after commit and remove unused imports from walker.go
+
+## v1.4.383 (2026-01-18)
+
+### PR [#1943](https://github.com/danielmiessler/Fabric/pull/1943) by [ksylvan](https://github.com/ksylvan): fix: Ollama server now respects the default context window
+
+- Fix: Ollama server now respects the default context window instead of using hardcoded 2048 tokens
+- Add parseOllamaNumCtx() function with type-safe extraction supporting 6 numeric types and platform-aware integer overflow protection
+- Extract num_ctx from client request options and add ModelContextLength field to ChatRequest struct
+- Implement DoS protection via 1,000,000 token maximum limit with sanitized error messages
+- Add comprehensive unit tests for parseOllamaNumCtx function covering edge cases including overflow and invalid types
+
 ## v1.4.382 (2026-01-17)

 ### PR [#1941](https://github.com/danielmiessler/Fabric/pull/1941) by [ksylvan](https://github.com/ksylvan): Add `greybeard_secure_prompt_engineer` to metadata, also remove duplicate json data file
--- a/cmd/fabric/version.go
+++ b/cmd/fabric/version.go
@@ -1,3 +1,3 @@
 package main

-var version = "v1.4.382"
+var version = "v1.4.386"
--- a/cmd/generate_changelog/changelog.db
+++ b/cmd/generate_changelog/changelog.db
--- a/cmd/generate_changelog/internal/git/walker.go
+++ b/cmd/generate_changelog/internal/git/walker.go
@@ -2,9 +2,7 @@ package git

 import (
 	"fmt"
-	"os"
 	"os/exec"
-	"path/filepath"
 	"regexp"
 	"strconv"
 	"strings"
@@ -425,64 +423,49 @@ func (w *Walker) Repository() *git.Repository {
 }

 // IsWorkingDirectoryClean checks if the working directory has any uncommitted changes
+// Uses native git CLI instead of go-git to properly handle worktree scenarios
 func (w *Walker) IsWorkingDirectoryClean() (bool, error) {
 	worktree, err := w.repo.Worktree()
 	if err != nil {
 		return false, fmt.Errorf("failed to get worktree: %w", err)
 	}

-	status, err := worktree.Status()
+	worktreePath := worktree.Filesystem.Root()
+
+	// Use native git status --porcelain to avoid go-git worktree issues
+	// go-git's status API has known bugs with linked worktrees
+	cmd := exec.Command("git", "status", "--porcelain")
+	cmd.Dir = worktreePath
+
+	output, err := cmd.Output()
 	if err != nil {
 		return false, fmt.Errorf("failed to get git status: %w", err)
 	}

-	worktreePath := worktree.Filesystem.Root()
-
-	// In worktrees, files staged in the main repo may appear in status but not exist in the worktree
-	// We need to check both the working directory status AND filesystem existence
-	for file, fileStatus := range status {
-		// Check if there are any changes in the working directory
-		if fileStatus.Worktree != git.Unmodified && fileStatus.Worktree != git.Untracked {
-			return false, nil
-		}
-
-		// For staged files (Added, Modified in index), verify they exist in this worktree's filesystem
-		// This handles the worktree case where the main repo has staged files that don't exist here
-		if fileStatus.Staging != git.Unmodified && fileStatus.Staging != git.Untracked {
-			filePath := filepath.Join(worktreePath, file)
-			if _, err := os.Stat(filePath); os.IsNotExist(err) {
-				// File is staged but doesn't exist in this worktree - ignore it
-				continue
-			}
-			// File is staged AND exists in this worktree - not clean
-			return false, nil
-		}
-	}
-
-	return true, nil
+	// If output is empty, working directory is clean
+	return len(strings.TrimSpace(string(output))) == 0, nil
 }

 // GetStatusDetails returns a detailed status of the working directory
+// Uses native git CLI instead of go-git to properly handle worktree scenarios
 func (w *Walker) GetStatusDetails() (string, error) {
 	worktree, err := w.repo.Worktree()
 	if err != nil {
 		return "", fmt.Errorf("failed to get worktree: %w", err)
 	}

-	status, err := worktree.Status()
+	worktreePath := worktree.Filesystem.Root()
+
+	// Use native git status --porcelain to avoid go-git worktree issues
+	cmd := exec.Command("git", "status", "--porcelain")
+	cmd.Dir = worktreePath
+
+	output, err := cmd.Output()
 	if err != nil {
 		return "", fmt.Errorf("failed to get git status: %w", err)
 	}

-	var details strings.Builder
-	for file, fileStatus := range status {
-		// Only include files with actual working directory changes
-		if fileStatus.Worktree != git.Unmodified && fileStatus.Worktree != git.Untracked {
-			details.WriteString(fmt.Sprintf("  %c%c %s\n", fileStatus.Staging, fileStatus.Worktree, file))
-		}
-	}
-
-	return details.String(), nil
+	return string(output), nil
 }

 // AddFile adds a file to the git index
@@ -526,13 +509,17 @@ func (w *Walker) CommitChanges(message string) (plumbing.Hash, error) {
 		return plumbing.ZeroHash, fmt.Errorf("failed to commit: %w (output: %s)", err, string(output))
 	}

-	// Get the commit hash from HEAD
-	ref, err := w.repo.Head()
+	// Get the commit hash from HEAD using native git to avoid go-git worktree issues
+	hashCmd := exec.Command("git", "rev-parse", "HEAD")
+	hashCmd.Dir = worktreePath
+
+	hashOutput, err := hashCmd.Output()
 	if err != nil {
 		return plumbing.ZeroHash, fmt.Errorf("failed to get HEAD after commit: %w", err)
 	}

-	return ref.Hash(), nil
+	hashStr := strings.TrimSpace(string(hashOutput))
+	return plumbing.NewHash(hashStr), nil
 }

 // PushToRemote pushes the current branch to the remote repository
--- a/completions/_fabric
+++ b/completions/_fabric
@@ -148,6 +148,7 @@ _fabric() {
    '(--debug)--debug[Set debug level (0=off, 1=basic, 2=detailed, 3=trace)]:debug level:(0 1 2 3)' \
    '(--notification)--notification[Send desktop notification when command completes]' \
    '(--notification-command)--notification-command[Custom command to run for notifications]:notification command:' \
+    '(--spotify)--spotify[Spotify podcast or episode URL to grab metadata]:spotify url:' \
    '(-h --help)'{-h,--help}'[Show this help message]' \
    '*:arguments:'
 }
--- a/completions/fabric.bash
+++ b/completions/fabric.bash
@@ -109,6 +109,9 @@ _fabric() {
    # No specific completion suggestions, user types the value
    return 0
    ;;
+  --spotify)
+    return 0
+    ;;
  esac

  # If the current word starts with '-', suggest options
--- a/completions/fabric.fish
+++ b/completions/fabric.fish
@@ -121,9 +121,9 @@ function __fabric_register_completions
        complete -c $cmd -l metadata -d "Output video metadata"
        complete -c $cmd -l yt-dlp-args -d "Additional arguments to pass to yt-dlp (e.g. '--cookies-from-browser brave')"
        complete -c $cmd -l readability -d "Convert HTML input into a clean, readable view"
-       complete -c $cmd -l input-has-vars -d "Apply variables to user input"
-       complete -c $cmd -l no-variable-replacement -d "Disable pattern variable replacement"
-       complete -c $cmd -l dry-run -d "Show what would be sent to the model without actually sending it"
+        complete -c $cmd -l input-has-vars -d "Apply variables to user input"
+        complete -c $cmd -l no-variable-replacement -d "Disable pattern variable replacement"
+        complete -c $cmd -l dry-run -d "Show what would be sent to the model without actually sending it"
        complete -c $cmd -l search -d "Enable web search tool for supported models (Anthropic, OpenAI, Gemini)"
        complete -c $cmd -l serve -d "Serve the Fabric Rest API"
        complete -c $cmd -l serveOllama -d "Serve the Fabric Rest API with ollama endpoints"
@@ -138,6 +138,7 @@ function __fabric_register_completions
        complete -c $cmd -l split-media-file -d "Split audio/video files larger than 25MB using ffmpeg"
        complete -c $cmd -l notification -d "Send desktop notification when command completes"
        complete -c $cmd -s h -l help -d "Show this help message"
+        complete -c $cmd -l spotify -d 'Spotify podcast or episode URL to grab metadata'
 end

 __fabric_register_completions fabric
--- a/internal/cli/chat_test.go
+++ b/internal/cli/chat_test.go
@@ -1,6 +1,7 @@
 package cli

 import (
+	"os"
 	"strings"
 	"testing"

@@ -164,3 +165,182 @@ func TestSendNotification_MessageTruncation(t *testing.T) {
 		})
 	}
 }
+
+func TestImageGenerationCompatibilityWarning(t *testing.T) {
+	// Save original stderr to restore later
+	originalStderr := os.Stderr
+	defer func() {
+		os.Stderr = originalStderr
+	}()
+
+	tests := []struct {
+		name          string
+		model         string
+		imageFile     string
+		expectWarning bool
+		warningSubstr string
+		description   string
+	}{
+		{
+			name:          "Compatible model with image",
+			model:         "gpt-4o",
+			imageFile:     "test.png",
+			expectWarning: false,
+			description:   "Should not warn for compatible model",
+		},
+		{
+			name:          "Incompatible model with image",
+			model:         "o1-mini",
+			imageFile:     "test.png",
+			expectWarning: true,
+			warningSubstr: "Warning: Model 'o1-mini' does not support image generation",
+			description:   "Should warn for incompatible model",
+		},
+		{
+			name:          "Incompatible model without image",
+			model:         "o1-mini",
+			imageFile:     "",
+			expectWarning: false,
+			description:   "Should not warn when no image file specified",
+		},
+		{
+			name:          "Compatible model without image",
+			model:         "gpt-4o-mini",
+			imageFile:     "",
+			expectWarning: false,
+			description:   "Should not warn when no image file specified even for compatible model",
+		},
+		{
+			name:          "Another incompatible model with image",
+			model:         "gpt-3.5-turbo",
+			imageFile:     "output.jpg",
+			expectWarning: true,
+			warningSubstr: "Warning: Model 'gpt-3.5-turbo' does not support image generation",
+			description:   "Should warn for different incompatible model",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Note: In a real integration test, we would capture stderr like this:
+			// stderrCapture := &bytes.Buffer{}
+			// os.Stderr = stderrCapture
+			// But since we can't test the actual openai plugin from here due to import cycles,
+			// we'll simulate the integration behavior
+
+			// Create test options (for structure validation)
+			_ = &domain.ChatOptions{
+				Model:     tt.model,
+				ImageFile: tt.imageFile,
+			}
+
+			// We'll test the warning function that was added to openai.go
+			// but we need to simulate the same behavior in our test
+			// Since we can't directly access the openai package here due to import cycles,
+			// we'll create a minimal test that verifies the integration would work
+
+			// For integration testing purposes, we'll verify that the warning conditions
+			// are correctly identified and the process continues as expected
+			hasImage := tt.imageFile != ""
+			shouldWarn := hasImage && tt.expectWarning
+
+			// Check if the expected warning condition matches our test case
+			if shouldWarn && tt.expectWarning {
+				// Verify warning substr is provided for warning cases
+				if tt.warningSubstr == "" {
+					t.Errorf("Expected warning substring for warning case")
+				}
+			}
+
+			// The actual warning would be printed by the openai plugin
+			// Here we verify the integration logic is sound
+			// In a real integration test, we would check stderr output
+
+			if tt.expectWarning {
+				// This is expected since we're not calling the actual openai plugin
+				// In a real integration test, the warning would appear in stderr
+				t.Logf("Note: Warning would be printed by openai plugin for model '%s'", tt.model)
+			}
+
+			// In a real test with stderr capture, we would check for unexpected warnings
+			// Since we're not calling the actual plugin, we just validate the logic structure
+		})
+	}
+}
+
+func TestImageGenerationIntegrationScenarios(t *testing.T) {
+	// Test various real-world scenarios that users might encounter
+	scenarios := []struct {
+		name          string
+		cliArgs       []string
+		expectWarning bool
+		warningModel  string
+		description   string
+	}{
+		{
+			name: "User tries o1-mini with image",
+			cliArgs: []string{
+				"-m", "o1-mini",
+				"--image-file", "output.png",
+				"Describe this image",
+			},
+			expectWarning: true,
+			warningModel:  "o1-mini",
+			description:   "Common user error - using incompatible model",
+		},
+		{
+			name: "User uses compatible model",
+			cliArgs: []string{
+				"-m", "gpt-4o",
+				"--image-file", "output.png",
+				"Describe this image",
+			},
+			expectWarning: false,
+			description:   "Correct usage - should work without warnings",
+		},
+		{
+			name: "User specifies model via pattern env var",
+			cliArgs: []string{
+				"--pattern", "summarize",
+				"--image-file", "output.png",
+				"Summarize this image",
+			},
+			expectWarning: false, // Depends on env var, not tested here
+			description:   "Pattern-based model selection",
+		},
+	}
+
+	for _, scenario := range scenarios {
+		t.Run(scenario.name, func(t *testing.T) {
+			// This test validates the CLI argument parsing would work correctly
+			// The actual warning functionality is tested in the openai package
+
+			// Verify CLI arguments are properly structured
+			hasImage := false
+			model := ""
+
+			for i, arg := range scenario.cliArgs {
+				if arg == "-m" && i+1 < len(scenario.cliArgs) {
+					model = scenario.cliArgs[i+1]
+				}
+				if arg == "--image-file" && i+1 < len(scenario.cliArgs) {
+					hasImage = true
+				}
+			}
+
+			// Validate the scenario setup
+			if scenario.expectWarning && scenario.warningModel == "" {
+				t.Errorf("Expected warning scenario must specify warning model")
+			}
+
+			// Log the scenario for debugging
+			t.Logf("Scenario: %s", scenario.description)
+			t.Logf("Model: %s, Has Image: %v, Expect Warning: %v", model, hasImage, scenario.expectWarning)
+
+			// In actual integration, the warning would appear when:
+			// 1. hasImage is true
+			// 2. model is in the incompatible list
+			// The openai package tests cover the actual warning functionality
+		})
+	}
+}
--- a/internal/cli/flags.go
+++ b/internal/cli/flags.go
@@ -59,6 +59,7 @@ type Flags struct {
 	YouTubeComments                 bool                 `long:"comments" description:"Grab comments from YouTube video and send to chat"`
 	YouTubeMetadata                 bool                 `long:"metadata" description:"Output video metadata"`
 	YtDlpArgs                       string               `long:"yt-dlp-args" yaml:"ytDlpArgs" description:"Additional arguments to pass to yt-dlp (e.g. '--cookies-from-browser brave')"`
+	Spotify                         string               `long:"spotify" description:"Spotify podcast or episode URL to grab metadata from and send to chat"`
 	Language                        string               `short:"g" long:"language" description:"Specify the Language Code for the chat, e.g. -g=en -g=zh" default:""`
 	ScrapeURL                       string               `short:"u" long:"scrape_url" description:"Scrape website URL to markdown using Jina AI"`
 	ScrapeQuestion                  string               `short:"q" long:"scrape_question" description:"Search question using Jina AI"`
--- a/internal/cli/tools.go
+++ b/internal/cli/tools.go
@@ -87,5 +87,26 @@ func handleToolProcessing(currentFlags *Flags, registry *core.PluginRegistry) (m
 		}
 	}

+	// Handle Spotify podcast/episode metadata
+	if currentFlags.Spotify != "" {
+		if !registry.Spotify.IsConfigured() {
+			err = fmt.Errorf("%s", i18n.T("spotify_not_configured"))
+			return
+		}
+
+		var metadata any
+		if metadata, err = registry.Spotify.GrabMetadataForURL(currentFlags.Spotify); err != nil {
+			return
+		}
+
+		formattedMetadata := registry.Spotify.FormatMetadataAsText(metadata)
+		messageTools = AppendMessage(messageTools, formattedMetadata)
+
+		if !currentFlags.IsChatRequest() {
+			err = currentFlags.WriteOutput(messageTools)
+			return
+		}
+	}
+
 	return
 }
--- a/internal/core/plugin_registry.go
+++ b/internal/core/plugin_registry.go
@@ -38,6 +38,7 @@ import (
 	"github.com/danielmiessler/fabric/internal/tools/custom_patterns"
 	"github.com/danielmiessler/fabric/internal/tools/jina"
 	"github.com/danielmiessler/fabric/internal/tools/lang"
+	"github.com/danielmiessler/fabric/internal/tools/spotify"
 	"github.com/danielmiessler/fabric/internal/tools/youtube"
 	"github.com/danielmiessler/fabric/internal/util"
 )
@@ -83,6 +84,7 @@ func NewPluginRegistry(db *fsdb.Db) (ret *PluginRegistry, err error) {
 		YouTube:        youtube.NewYouTube(),
 		Language:       lang.NewLanguage(),
 		Jina:           jina.NewClient(),
+		Spotify:        spotify.NewSpotify(),
 		Strategies:     strategy.NewStrategiesManager(),
 	}

@@ -156,6 +158,7 @@ type PluginRegistry struct {
 	YouTube            *youtube.YouTube
 	Language           *lang.Language
 	Jina               *jina.Client
+	Spotify            *spotify.Spotify
 	TemplateExtensions *template.ExtensionManager
 	Strategies         *strategy.StrategiesManager
 }
@@ -175,6 +178,7 @@ func (o *PluginRegistry) SaveEnvFile() (err error) {

 	o.YouTube.SetupFillEnvFileContent(&envFileContent)
 	o.Jina.SetupFillEnvFileContent(&envFileContent)
+	o.Spotify.SetupFillEnvFileContent(&envFileContent)
 	o.Language.SetupFillEnvFileContent(&envFileContent)

 	err = o.Db.SaveEnv(envFileContent.String())
@@ -348,7 +352,7 @@ func (o *PluginRegistry) runInteractiveSetup() (err error) {
 	groupsPlugins.AddGroupItems(i18n.T("setup_required_tools"), o.Defaults, o.PatternsLoader, o.Strategies)

 	// Add optional tools
-	groupsPlugins.AddGroupItems(i18n.T("setup_optional_configuration_header"), o.CustomPatterns, o.Jina, o.Language, o.YouTube)
+	groupsPlugins.AddGroupItems(i18n.T("setup_optional_configuration_header"), o.CustomPatterns, o.Jina, o.Language, o.Spotify, o.YouTube)

 	for {
 		groupsPlugins.Print(false)
@@ -489,9 +493,10 @@ func (o *PluginRegistry) Configure() (err error) {
 		o.PatternsLoader.Patterns.CustomPatternsDir = customPatternsDir
 	}

-	//YouTube and Jina are not mandatory, so ignore not configured error
+	//YouTube, Jina, Spotify are not mandatory, so ignore not configured error
 	_ = o.YouTube.Configure()
 	_ = o.Jina.Configure()
+	_ = o.Spotify.Configure()
 	_ = o.Language.Configure()
 	return
 }
--- a/internal/i18n/locales/de.json
+++ b/internal/i18n/locales/de.json
@@ -3,8 +3,16 @@
 	"vendor_not_configured": "Anbieter %s ist nicht konfiguriert",
 	"vendor_no_transcription_support": "Anbieter %s unterstützt keine Audio-Transkription",
 	"transcription_model_required": "Transkriptionsmodell ist erforderlich (verwende --transcribe-model)",
-	"youtube_not_configured": "YouTube ist nicht konfiguriert, bitte führe das Setup-Verfahren aus",
-	"youtube_api_key_required": "YouTube API-Schlüssel für Kommentare und Metadaten erforderlich. Führe 'fabric --setup' aus, um zu konfigurieren",
+	"youtube_not_configured": "YouTube ist nicht konfiguriert, bitte führen Sie die Einrichtung durch",
+	"spotify_not_configured": "Spotify ist nicht konfiguriert, bitte führen Sie die Einrichtung durch",
+	"spotify_label": "Spotify",
+	"spotify_setup_description": "Spotify - um Podcast-/Show-Metadaten von Spotify abzurufen",
+	"spotify_invalid_url": "Ungültige Spotify-URL, kann Show- oder Episoden-ID nicht abrufen: '%s'",
+	"spotify_error_getting_metadata": "Fehler beim Abrufen der Spotify-Metadaten: %v",
+	"spotify_no_show_found": "Keine Show mit ID gefunden: %s",
+	"spotify_no_episode_found": "Keine Episode mit ID gefunden: %s",
+	"spotify_url_help": "Spotify-Podcast- oder Episoden-URL zum Abrufen von Metadaten und Senden an den Chat",
+	"youtube_api_key_required": "YouTube API-Schlüssel erforderlich für Kommentare und Metadaten. Führen Sie 'fabric --setup' zur Konfiguration aus",
 	"youtube_ytdlp_not_found": "yt-dlp wurde nicht in PATH gefunden. Bitte installiere yt-dlp, um die YouTube-Transkript-Funktionalität zu nutzen",
 	"youtube_invalid_url": "ungültige YouTube-URL, kann keine Video- oder Playlist-ID abrufen: '%s'",
 	"youtube_url_is_playlist_not_video": "URL ist eine Playlist, kein Video",
--- a/internal/i18n/locales/en.json
+++ b/internal/i18n/locales/en.json
@@ -4,6 +4,14 @@
  "vendor_no_transcription_support": "vendor %s does not support audio transcription",
  "transcription_model_required": "transcription model is required (use --transcribe-model)",
  "youtube_not_configured": "YouTube is not configured, please run the setup procedure",
+  "spotify_not_configured": "Spotify is not configured, please run the setup procedure",
+  "spotify_label": "Spotify",
+  "spotify_setup_description": "Spotify - to grab podcast/show metadata from Spotify",
+  "spotify_invalid_url": "invalid Spotify URL, can't get show or episode ID: '%s'",
+  "spotify_error_getting_metadata": "error getting Spotify metadata: %v",
+  "spotify_no_show_found": "no show found with ID: %s",
+  "spotify_no_episode_found": "no episode found with ID: %s",
+  "spotify_url_help": "Spotify podcast or episode URL to grab metadata from and send to chat",
  "youtube_api_key_required": "YouTube API key required for comments and metadata. Run 'fabric --setup' to configure",
  "youtube_ytdlp_not_found": "yt-dlp not found in PATH. Please install yt-dlp to use YouTube transcript functionality",
  "youtube_invalid_url": "invalid YouTube URL, can't get video or playlist ID: '%s'",
--- a/internal/i18n/locales/es.json
+++ b/internal/i18n/locales/es.json
@@ -3,10 +3,18 @@
  "vendor_not_configured": "el proveedor %s no está configurado",
  "vendor_no_transcription_support": "el proveedor %s no admite transcripción de audio",
  "transcription_model_required": "se requiere un modelo de transcripción (usa --transcribe-model)",
-  "youtube_not_configured": "YouTube no está configurado, por favor ejecuta el procedimiento de configuración",
-  "youtube_api_key_required": "Se requiere clave de API de YouTube para comentarios y metadatos. Ejecuta 'fabric --setup' para configurar",
+  "youtube_not_configured": "YouTube no está configurado, por favor ejecute el procedimiento de configuración",
+  "spotify_not_configured": "Spotify no está configurado, por favor ejecute el procedimiento de configuración",
+  "spotify_label": "Spotify",
+  "spotify_setup_description": "Spotify - para obtener metadatos de podcasts/programas de Spotify",
+  "spotify_invalid_url": "URL de Spotify no válida, no se puede obtener el ID del programa o episodio: '%s'",
+  "spotify_error_getting_metadata": "error al obtener metadatos de Spotify: %v",
+  "spotify_no_show_found": "no se encontró ningún programa con ID: %s",
+  "spotify_no_episode_found": "no se encontró ningún episodio con ID: %s",
+  "spotify_url_help": "URL de podcast o episodio de Spotify para obtener metadatos y enviar al chat",
+  "youtube_api_key_required": "Se requiere clave API de YouTube para comentarios y metadatos. Ejecute 'fabric --setup' para configurar",
  "youtube_ytdlp_not_found": "yt-dlp no encontrado en PATH. Por favor instala yt-dlp para usar la funcionalidad de transcripción de YouTube",
-  "youtube_invalid_url": "URL de YouTube inválida, no se puede obtener ID de video o lista de reproducción: '%s'",
+  "youtube_invalid_url": "URL de YouTube no válida, no se puede obtener ID de video o lista de reproducción: '%s'",
  "youtube_url_is_playlist_not_video": "La URL es una lista de reproducción, no un video",
  "youtube_no_video_id_found": "no se encontró ID de video en la URL",
  "youtube_rate_limit_exceeded": "Límite de tasa de YouTube excedido. Intenta de nuevo más tarde o usa diferentes argumentos de yt-dlp como '--sleep-requests 1' para ralentizar las solicitudes.",
--- a/internal/i18n/locales/fr.json
+++ b/internal/i18n/locales/fr.json
@@ -4,6 +4,14 @@
  "vendor_no_transcription_support": "le fournisseur %s ne prend pas en charge la transcription audio",
  "transcription_model_required": "un modèle de transcription est requis (utilisez --transcribe-model)",
  "youtube_not_configured": "YouTube n'est pas configuré, veuillez exécuter la procédure de configuration",
+  "spotify_not_configured": "Spotify n'est pas configuré, veuillez exécuter la procédure de configuration",
+  "spotify_label": "Spotify",
+  "spotify_setup_description": "Spotify - pour récupérer les métadonnées de podcasts/émissions depuis Spotify",
+  "spotify_invalid_url": "URL Spotify invalide, impossible d'obtenir l'ID de l'émission ou de l'épisode : '%s'",
+  "spotify_error_getting_metadata": "erreur lors de la récupération des métadonnées Spotify : %v",
+  "spotify_no_show_found": "aucune émission trouvée avec l'ID : %s",
+  "spotify_no_episode_found": "aucun épisode trouvé avec l'ID : %s",
+  "spotify_url_help": "URL de podcast ou d'épisode Spotify pour récupérer les métadonnées et envoyer au chat",
  "youtube_api_key_required": "Clé API YouTube requise pour les commentaires et métadonnées. Exécutez 'fabric --setup' pour configurer",
  "youtube_ytdlp_not_found": "yt-dlp introuvable dans PATH. Veuillez installer yt-dlp pour utiliser la fonctionnalité de transcription YouTube",
  "youtube_invalid_url": "URL YouTube invalide, impossible d'obtenir l'ID de vidéo ou de liste de lecture : '%s'",
--- a/internal/i18n/locales/it.json
+++ b/internal/i18n/locales/it.json
@@ -3,8 +3,16 @@
  "vendor_not_configured": "il fornitore %s non è configurato",
  "vendor_no_transcription_support": "il fornitore %s non supporta la trascrizione audio",
  "transcription_model_required": "è richiesto un modello di trascrizione (usa --transcribe-model)",
-  "youtube_not_configured": "YouTube non è configurato, per favore esegui la procedura di configurazione",
-  "youtube_api_key_required": "Chiave API YouTube richiesta per commenti e metadati. Esegui 'fabric --setup' per configurare",
+  "youtube_not_configured": "YouTube non è configurato, eseguire la procedura di configurazione",
+  "spotify_not_configured": "Spotify non è configurato, eseguire la procedura di configurazione",
+  "spotify_label": "Spotify",
+  "spotify_setup_description": "Spotify - per ottenere metadati di podcast/show da Spotify",
+  "spotify_invalid_url": "URL Spotify non valido, impossibile ottenere l'ID dello show o dell'episodio: '%s'",
+  "spotify_error_getting_metadata": "errore durante il recupero dei metadati Spotify: %v",
+  "spotify_no_show_found": "nessuno show trovato con ID: %s",
+  "spotify_no_episode_found": "nessun episodio trovato con ID: %s",
+  "spotify_url_help": "URL di podcast o episodio Spotify per ottenere metadati e inviare alla chat",
+  "youtube_api_key_required": "Chiave API YouTube richiesta per commenti e metadati. Eseguire 'fabric --setup' per configurare",
  "youtube_ytdlp_not_found": "yt-dlp non trovato in PATH. Per favore installa yt-dlp per usare la funzionalità di trascrizione YouTube",
  "youtube_invalid_url": "URL YouTube non valido, impossibile ottenere l'ID del video o della playlist: '%s'",
  "youtube_url_is_playlist_not_video": "L'URL è una playlist, non un video",
--- a/internal/i18n/locales/ja.json
+++ b/internal/i18n/locales/ja.json
@@ -4,6 +4,14 @@
  "vendor_no_transcription_support": "ベンダー %s は音声転写をサポートしていません",
  "transcription_model_required": "転写モデルが必要です（--transcribe-model を使用）",
  "youtube_not_configured": "YouTubeが設定されていません。セットアップ手順を実行してください",
+  "spotify_not_configured": "Spotifyが設定されていません。セットアップ手順を実行してください",
+  "spotify_label": "Spotify",
+  "spotify_setup_description": "Spotify - Spotifyからポッドキャスト/番組のメタデータを取得",
+  "spotify_invalid_url": "無効なSpotify URL、番組またはエピソードIDを取得できません：'%s'",
+  "spotify_error_getting_metadata": "Spotifyメタデータの取得エラー：%v",
+  "spotify_no_show_found": "ID %s の番組が見つかりません",
+  "spotify_no_episode_found": "ID %s のエピソードが見つかりません",
+  "spotify_url_help": "メタデータを取得してチャットに送信するSpotifyポッドキャストまたはエピソードURL",
  "youtube_api_key_required": "コメントとメタデータにはYouTube APIキーが必要です。設定するには 'fabric --setup' を実行してください",
  "youtube_ytdlp_not_found": "PATHにyt-dlpが見つかりません。YouTubeトランスクリプト機能を使用するにはyt-dlpをインストールしてください",
  "youtube_invalid_url": "無効なYouTube URL、動画またはプレイリストIDを取得できません: '%s'",
--- a/internal/i18n/locales/pt-BR.json
+++ b/internal/i18n/locales/pt-BR.json
@@ -4,6 +4,14 @@
  "vendor_no_transcription_support": "o fornecedor %s não suporta transcrição de áudio",
  "transcription_model_required": "modelo de transcrição é necessário (use --transcribe-model)",
  "youtube_not_configured": "YouTube não está configurado, por favor execute o procedimento de configuração",
+  "spotify_not_configured": "Spotify não está configurado, por favor execute o procedimento de configuração",
+  "spotify_label": "Spotify",
+  "spotify_setup_description": "Spotify - para obter metadados de podcasts/programas do Spotify",
+  "spotify_invalid_url": "URL do Spotify inválida, não é possível obter o ID do programa ou episódio: '%s'",
+  "spotify_error_getting_metadata": "erro ao obter metadados do Spotify: %v",
+  "spotify_no_show_found": "nenhum programa encontrado com o ID: %s",
+  "spotify_no_episode_found": "nenhum episódio encontrado com o ID: %s",
+  "spotify_url_help": "URL de podcast ou episódio do Spotify para obter metadados e enviar ao chat",
  "youtube_api_key_required": "Chave de API do YouTube necessária para comentários e metadados. Execute 'fabric --setup' para configurar",
  "youtube_ytdlp_not_found": "yt-dlp não encontrado no PATH. Por favor instale o yt-dlp para usar a funcionalidade de transcrição do YouTube",
  "youtube_invalid_url": "URL do YouTube inválida, não é possível obter o ID do vídeo ou da playlist: '%s'",
--- a/internal/i18n/locales/pt-PT.json
+++ b/internal/i18n/locales/pt-PT.json
@@ -4,6 +4,14 @@
  "vendor_no_transcription_support": "o fornecedor %s não suporta transcrição de áudio",
  "transcription_model_required": "modelo de transcrição é necessário (use --transcribe-model)",
  "youtube_not_configured": "YouTube não está configurado, por favor execute o procedimento de configuração",
+  "spotify_not_configured": "Spotify não está configurado, por favor execute o procedimento de configuração",
+  "spotify_label": "Spotify",
+  "spotify_setup_description": "Spotify - para obter metadados de podcasts/programas do Spotify",
+  "spotify_invalid_url": "URL do Spotify inválido, não é possível obter o ID do programa ou episódio: '%s'",
+  "spotify_error_getting_metadata": "erro ao obter metadados do Spotify: %v",
+  "spotify_no_show_found": "nenhum programa encontrado com o ID: %s",
+  "spotify_no_episode_found": "nenhum episódio encontrado com o ID: %s",
+  "spotify_url_help": "URL de podcast ou episódio do Spotify para obter metadados e enviar ao chat",
  "youtube_api_key_required": "Chave de API do YouTube necessária para comentários e metadados. Execute 'fabric --setup' para configurar",
  "youtube_ytdlp_not_found": "yt-dlp não encontrado no PATH. Por favor instale o yt-dlp para usar a funcionalidade de transcrição do YouTube",
  "youtube_invalid_url": "URL do YouTube inválido, não é possível obter o ID do vídeo ou da lista de reprodução: '%s'",
--- a/internal/i18n/locales/zh.json
+++ b/internal/i18n/locales/zh.json
@@ -4,7 +4,15 @@
  "vendor_no_transcription_support": "供应商 %s 不支持音频转录",
  "transcription_model_required": "需要转录模型（使用 --transcribe-model）",
  "youtube_not_configured": "YouTube 未配置，请运行设置程序",
-  "youtube_api_key_required": "评论和元数据需要 YouTube API 密钥。运行 'fabric --setup' 进行配置",
+  "spotify_not_configured": "Spotify 未配置，请运行设置程序",
+  "spotify_label": "Spotify",
+  "spotify_setup_description": "Spotify - 从 Spotify 获取播客/节目元数据",
+  "spotify_invalid_url": "无效的 Spotify URL，无法获取节目或剧集 ID：'%s'",
+  "spotify_error_getting_metadata": "获取 Spotify 元数据时出错：%v",
+  "spotify_no_show_found": "未找到 ID 为 %s 的节目",
+  "spotify_no_episode_found": "未找到 ID 为 %s 的剧集",
+  "spotify_url_help": "Spotify 播客或剧集 URL，用于获取元数据并发送到聊天",
+  "youtube_api_key_required": "YouTube API 密钥用于评论和元数据。运行 'fabric --setup' 进行配置",
  "youtube_ytdlp_not_found": "在 PATH 中未找到 yt-dlp。请安装 yt-dlp 以使用 YouTube 转录功能",
  "youtube_invalid_url": "无效的 YouTube URL，无法获取视频或播放列表 ID：'%s'",
  "youtube_url_is_playlist_not_video": "URL 是播放列表，而不是视频",
--- a/internal/plugins/ai/openai/openai.go
+++ b/internal/plugins/ai/openai/openai.go
@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"net/http"
+	"os"
 	"slices"
 	"strings"
 	"time"
@@ -71,6 +72,14 @@ func (o *Client) SetResponsesAPIEnabled(enabled bool) {
 	o.ImplementsResponses = enabled
 }

+// checkImageGenerationCompatibility warns if the model doesn't support image generation
+func checkImageGenerationCompatibility(model string) {
+	if !supportsImageGeneration(model) {
+		fmt.Fprintf(os.Stderr, "Warning: Model '%s' does not support image generation. Supported models: %s. Consider using -m gpt-4o for image generation.\n",
+			model, strings.Join(ImageGenerationSupportedModels, ", "))
+	}
+}
+
 func (o *Client) configure() (ret error) {
 	opts := []option.RequestOption{option.WithAPIKey(o.ApiKey.Value)}
 	if o.ApiBaseURL.Value != "" {
@@ -154,6 +163,11 @@ func (o *Client) Send(ctx context.Context, msgs []*chat.ChatCompletionMessage, o
 }

 func (o *Client) sendResponses(ctx context.Context, msgs []*chat.ChatCompletionMessage, opts *domain.ChatOptions) (ret string, err error) {
+	// Warn if model doesn't support image generation when image file is specified
+	if opts.ImageFile != "" {
+		checkImageGenerationCompatibility(opts.Model)
+	}
+
 	// Validate model supports image generation if image file is specified
 	if opts.ImageFile != "" && !supportsImageGeneration(opts.Model) {
 		return "", fmt.Errorf("model '%s' does not support image generation. Supported models: %s", opts.Model, strings.Join(ImageGenerationSupportedModels, ", "))
--- a/internal/plugins/ai/openai/openai_image.go
+++ b/internal/plugins/ai/openai/openai_image.go
@@ -28,6 +28,9 @@ var ImageGenerationSupportedModels = []string{
 	"gpt-4.1-mini",
 	"gpt-4.1-nano",
 	"o3",
+	"gpt-5",
+	"gpt-5-nano",
+	"gpt-5.2",
 }

 // supportsImageGeneration checks if the given model supports the image_generation tool
--- a/internal/plugins/ai/openai/openai_image_test.go
+++ b/internal/plugins/ai/openai/openai_image_test.go
@@ -1,7 +1,9 @@
 package openai

 import (
+	"bytes"
 	"fmt"
+	"os"
 	"strings"
 	"testing"

@@ -257,6 +259,21 @@ func TestSupportsImageGeneration(t *testing.T) {
 			model:    "o3",
 			expected: true,
 		},
+		{
+			name:     "gpt-5 supports image generation",
+			model:    "gpt-5",
+			expected: true,
+		},
+		{
+			name:     "gpt-5-nano supports image generation",
+			model:    "gpt-5-nano",
+			expected: true,
+		},
+		{
+			name:     "gpt-5.2 supports image generation",
+			model:    "gpt-5.2",
+			expected: true,
+		},
 		{
 			name:     "o1 does not support image generation",
 			model:    "o1",
@@ -442,3 +459,165 @@ func TestAddImageGenerationToolWithUserParameters(t *testing.T) {
 		})
 	}
 }
+
+func TestCheckImageGenerationCompatibility(t *testing.T) {
+	// Capture stderr output
+	oldStderr := os.Stderr
+	r, w, _ := os.Pipe()
+	os.Stderr = w
+
+	tests := []struct {
+		name          string
+		model         string
+		expectWarning bool
+		expectedText  string
+	}{
+		{
+			name:          "Supported model - no warning",
+			model:         "gpt-4o",
+			expectWarning: false,
+		},
+		{
+			name:          "Unsupported model - warning expected",
+			model:         "o1-mini",
+			expectWarning: true,
+			expectedText:  "Warning: Model 'o1-mini' does not support image generation",
+		},
+		{
+			name:          "Another unsupported model - warning expected",
+			model:         "gpt-3.5-turbo",
+			expectWarning: true,
+			expectedText:  "Warning: Model 'gpt-3.5-turbo' does not support image generation",
+		},
+		{
+			name:          "Supported o3 model - no warning",
+			model:         "o3",
+			expectWarning: false,
+		},
+		{
+			name:          "Empty model - warning expected",
+			model:         "",
+			expectWarning: true,
+			expectedText:  "Warning: Model '' does not support image generation",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Reset pipe for each test
+			r, w, _ = os.Pipe()
+			os.Stderr = w
+
+			checkImageGenerationCompatibility(tt.model)
+
+			// Close writer and read output
+			w.Close()
+			var buf bytes.Buffer
+			buf.ReadFrom(r)
+			output := buf.String()
+
+			if tt.expectWarning {
+				assert.NotEmpty(t, output, "Expected warning output for unsupported model")
+				assert.Contains(t, output, tt.expectedText, "Warning message should contain model name")
+				assert.Contains(t, output, "Supported models:", "Warning should mention supported models")
+				assert.Contains(t, output, "gpt-4o", "Warning should suggest gpt-4o")
+			} else {
+				assert.Empty(t, output, "No warning expected for supported model")
+			}
+		})
+	}
+
+	// Restore stderr
+	os.Stderr = oldStderr
+}
+
+func TestSendResponses_WithWarningIntegration(t *testing.T) {
+	client := NewClient()
+	client.ApiKey.Value = "test-api-key"
+	client.ApiBaseURL.Value = "https://api.openai.com/v1"
+	client.ImplementsResponses = true
+	client.Configure() // Initialize client
+
+	tests := []struct {
+		name          string
+		model         string
+		imageFile     string
+		expectWarning bool
+		expectError   bool
+		expectedError string
+	}{
+		{
+			name:          "Unsupported model with image - warning then error",
+			model:         "o1-mini",
+			imageFile:     "test.png",
+			expectWarning: true,
+			expectError:   true,
+			expectedError: "model 'o1-mini' does not support image generation",
+		},
+		{
+			name:          "Supported model with image - no warning, no error",
+			model:         "gpt-4o",
+			imageFile:     "test.png",
+			expectWarning: false,
+			expectError:   false,
+		},
+		{
+			name:          "Unsupported model without image - no warning, no error",
+			model:         "o1-mini",
+			imageFile:     "",
+			expectWarning: false,
+			expectError:   false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Capture stderr for warning detection
+			oldStderr := os.Stderr
+			r, w, _ := os.Pipe()
+			os.Stderr = w
+
+			opts := &domain.ChatOptions{
+				Model:     tt.model,
+				ImageFile: tt.imageFile,
+			}
+
+			msgs := []*chat.ChatCompletionMessage{
+				{Role: "user", Content: "Generate an image"},
+			}
+
+			// Call sendResponses - this will trigger the warning and potentially error
+			_, err := client.sendResponses(nil, msgs, opts)
+
+			// Close writer and read warning output
+			w.Close()
+			var buf bytes.Buffer
+			buf.ReadFrom(r)
+			warningOutput := buf.String()
+
+			// Restore stderr
+			os.Stderr = oldStderr
+
+			// Check warning expectations
+			if tt.expectWarning {
+				assert.NotEmpty(t, warningOutput, "Expected warning output")
+				assert.Contains(t, warningOutput, "Warning: Model '"+tt.model+"' does not support image generation")
+			} else {
+				assert.Empty(t, warningOutput, "No warning expected")
+			}
+
+			// Check error expectations
+			if tt.expectError {
+				assert.Error(t, err, "Expected error for unsupported model with image")
+				assert.Contains(t, err.Error(), tt.expectedError)
+			} else {
+				// We expect an error here because we don't have a real API key/config
+				// But it shouldn't be the image generation validation error
+				if err != nil {
+					assert.NotContains(t, err.Error(), "does not support image generation",
+						"Should not get image generation error for supported cases")
+				}
+			}
+		})
+	}
+}
--- a/internal/plugins/ai/openai_compatible/providers_config.go
+++ b/internal/plugins/ai/openai_compatible/providers_config.go
@@ -145,6 +145,11 @@ var ProviderMap = map[string]ProviderConfig{
 		ModelsURL:           "https://models.github.ai/catalog", // FetchModelsDirectly will append /models
 		ImplementsResponses: false,
 	},
+	"Infermatic": {
+		Name:                "Infermatic",
+		BaseURL:             "https://api.totalgpt.ai/v1",
+		ImplementsResponses: false,
+	},
 	"GrokAI": {
 		Name:                "GrokAI",
 		BaseURL:             "https://api.x.ai/v1",
--- a/internal/plugins/ai/openai_compatible/providers_config_test.go
+++ b/internal/plugins/ai/openai_compatible/providers_config_test.go
@@ -30,6 +30,11 @@ func TestCreateClient(t *testing.T) {
 			provider: "Abacus",
 			exists:   true,
 		},
+		{
+			name:     "Existing provider - Infermatic",
+			provider: "Infermatic",
+			exists:   true,
+		},
 		{
 			name:     "Existing provider - MiniMax",
 			provider: "MiniMax",
--- a/internal/server/chat.go
+++ b/internal/server/chat.go
@@ -35,7 +35,8 @@ type PromptRequest struct {

 type ChatRequest struct {
 	Prompts            []PromptRequest `json:"prompts"`
-	Language           string          `json:"language"` // Add Language field to bind from request
+	Language           string          `json:"language"`
+	ModelContextLength int             `json:"modelContextLength,omitempty"` // Context window size
 	domain.ChatOptions                 // Embed the ChatOptions from common package
 }

@@ -118,7 +119,7 @@ func (h *ChatHandler) HandleChat(c *gin.Context) {
 					}
 				}

-				chatter, err := h.registry.GetChatter(p.Model, 2048, p.Vendor, "", true, false)
+				chatter, err := h.registry.GetChatter(p.Model, request.ModelContextLength, p.Vendor, "", true, false)
 				if err != nil {
 					log.Printf("Error creating chatter: %v", err)
 					streamChan <- domain.StreamUpdate{Type: domain.StreamTypeError, Content: fmt.Sprintf("Error: %v", err)}
--- a/internal/server/ollama.go
+++ b/internal/server/ollama.go
@@ -7,8 +7,10 @@ import (
 	"fmt"
 	"io"
 	"log"
+	"math"
 	"net/http"
 	"net/url"
+	"strconv"
 	"strings"
 	"time"

@@ -79,6 +81,111 @@ type FabricResponseFormat struct {
 	Content string `json:"content"`
 }

+// parseOllamaNumCtx extracts and validates the num_ctx parameter from Ollama request options.
+// Returns:
+//   - (0, nil) if num_ctx is not present or is null
+//   - (n, nil) if num_ctx is a valid positive integer
+//   - (0, error) if num_ctx is present but invalid
+func parseOllamaNumCtx(options map[string]any) (int, error) {
+	if options == nil {
+		return 0, nil
+	}
+
+	val, exists := options["num_ctx"]
+	if !exists {
+		return 0, nil // Not provided, caller should use default
+	}
+
+	if val == nil {
+		return 0, nil // Explicit null, treat as not provided
+	}
+
+	var contextLength int
+
+	// Platform-specific max int value for overflow checks
+	const maxInt = int64(^uint(0) >> 1)
+
+	switch v := val.(type) {
+	case float64:
+		if math.IsNaN(v) || math.IsInf(v, 0) {
+			return 0, fmt.Errorf("num_ctx must be a finite number")
+		}
+		if math.Trunc(v) != v {
+			return 0, fmt.Errorf("num_ctx must be an integer, got float with fractional part")
+		}
+		// Check for overflow on 32-bit systems (negative values handled by validation at line 166)
+		if v > float64(maxInt) {
+			return 0, fmt.Errorf("num_ctx value out of range")
+		}
+		contextLength = int(v)
+
+	case float32:
+		f64 := float64(v)
+		if math.IsNaN(f64) || math.IsInf(f64, 0) {
+			return 0, fmt.Errorf("num_ctx must be a finite number")
+		}
+		if math.Trunc(f64) != f64 {
+			return 0, fmt.Errorf("num_ctx must be an integer, got float with fractional part")
+		}
+		// Check for overflow on 32-bit systems (negative values handled by validation at line 177)
+		if f64 > float64(maxInt) {
+			return 0, fmt.Errorf("num_ctx value out of range")
+		}
+		contextLength = int(v)
+
+	case int:
+		contextLength = v
+
+	case int64:
+		if v < 0 {
+			return 0, fmt.Errorf("num_ctx must be positive, got: %d", v)
+		}
+		if v > maxInt {
+			return 0, fmt.Errorf("num_ctx value too large: %d", v)
+		}
+		contextLength = int(v)
+
+	case json.Number:
+		i64, err := v.Int64()
+		if err != nil {
+			return 0, fmt.Errorf("num_ctx must be a valid number")
+		}
+		if i64 < 0 {
+			return 0, fmt.Errorf("num_ctx must be positive, got: %d", i64)
+		}
+		if i64 > maxInt {
+			return 0, fmt.Errorf("num_ctx value too large: %d", i64)
+		}
+		contextLength = int(i64)
+
+	case string:
+		parsed, err := strconv.Atoi(v)
+		if err != nil {
+			// Truncate long strings in error messages to avoid logging excessively large input
+			errVal := v
+			if len(v) > 50 {
+				errVal = v[:50] + "..."
+			}
+			return 0, fmt.Errorf("num_ctx must be a valid number, got: %s", errVal)
+		}
+		contextLength = parsed
+
+	default:
+		return 0, fmt.Errorf("num_ctx must be a number, got invalid type")
+	}
+
+	if contextLength <= 0 {
+		return 0, fmt.Errorf("num_ctx must be positive, got: %d", contextLength)
+	}
+
+	const maxContextLength = 1000000
+	if contextLength > maxContextLength {
+		return 0, fmt.Errorf("num_ctx exceeds maximum allowed value of %d", maxContextLength)
+	}
+
+	return contextLength, nil
+}
+
 func ServeOllama(registry *core.PluginRegistry, address string, version string) (err error) {
 	r := gin.New()

@@ -161,6 +268,15 @@ func (f APIConvert) ollamaChat(c *gin.Context) {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "testing endpoint"})
 		return
 	}
+
+	// Extract and validate num_ctx from options
+	numCtx, err := parseOllamaNumCtx(prompt.Options)
+	if err != nil {
+		log.Printf("Invalid num_ctx in request: %v", err)
+		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+		return
+	}
+
 	now := time.Now()
 	var chat ChatRequest

@@ -210,6 +326,10 @@ func (f APIConvert) ollamaChat(c *gin.Context) {
 			Variables:   variables,
 		}}
 	}
+
+	// Set context length from parsed num_ctx
+	chat.ModelContextLength = numCtx
+
 	fabricChatReq, err := json.Marshal(chat)
 	if err != nil {
 		log.Printf("Error marshalling body: %v", err)
--- a/internal/server/ollama_test.go
+++ b/internal/server/ollama_test.go
@@ -1,6 +1,9 @@
 package restapi

 import (
+	"encoding/json"
+	"math"
+	"strings"
 	"testing"
 )

@@ -98,3 +101,263 @@ func TestBuildFabricChatURL(t *testing.T) {
 		})
 	}
 }
+
+func TestParseOllamaNumCtx(t *testing.T) {
+	tests := []struct {
+		name    string
+		options map[string]any
+		want    int
+		wantErr bool
+		errMsg  string
+	}{
+		// --- Valid inputs ---
+		{
+			name:    "nil options",
+			options: nil,
+			want:    0,
+			wantErr: false,
+		},
+		{
+			name:    "empty options",
+			options: map[string]any{},
+			want:    0,
+			wantErr: false,
+		},
+		{
+			name:    "num_ctx not present",
+			options: map[string]any{"other_key": 123},
+			want:    0,
+			wantErr: false,
+		},
+		{
+			name:    "num_ctx is null",
+			options: map[string]any{"num_ctx": nil},
+			want:    0,
+			wantErr: false,
+		},
+		{
+			name:    "valid int",
+			options: map[string]any{"num_ctx": 4096},
+			want:    4096,
+			wantErr: false,
+		},
+		{
+			name:    "valid float64 (whole number)",
+			options: map[string]any{"num_ctx": float64(8192)},
+			want:    8192,
+			wantErr: false,
+		},
+		{
+			name:    "valid float32 (whole number)",
+			options: map[string]any{"num_ctx": float32(2048)},
+			want:    2048,
+			wantErr: false,
+		},
+		{
+			name:    "valid json.Number",
+			options: map[string]any{"num_ctx": json.Number("16384")},
+			want:    16384,
+			wantErr: false,
+		},
+		{
+			name:    "valid string",
+			options: map[string]any{"num_ctx": "32768"},
+			want:    32768,
+			wantErr: false,
+		},
+		{
+			name:    "valid int64",
+			options: map[string]any{"num_ctx": int64(65536)},
+			want:    65536,
+			wantErr: false,
+		},
+		// --- Invalid inputs ---
+		{
+			name:    "float64 with fractional part",
+			options: map[string]any{"num_ctx": 4096.5},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx must be an integer, got float with fractional part",
+		},
+		{
+			name:    "float32 with fractional part",
+			options: map[string]any{"num_ctx": float32(2048.75)},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx must be an integer, got float with fractional part",
+		},
+		{
+			name:    "negative int",
+			options: map[string]any{"num_ctx": -100},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx must be positive",
+		},
+		{
+			name:    "zero int",
+			options: map[string]any{"num_ctx": 0},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx must be positive",
+		},
+		{
+			name:    "negative float64",
+			options: map[string]any{"num_ctx": float64(-500)},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx must be positive",
+		},
+		{
+			name:    "negative float32",
+			options: map[string]any{"num_ctx": float32(-250)},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx must be positive",
+		},
+		{
+			name:    "non-numeric string",
+			options: map[string]any{"num_ctx": "not-a-number"},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx must be a valid number",
+		},
+		{
+			name:    "invalid json.Number",
+			options: map[string]any{"num_ctx": json.Number("invalid")},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx must be a valid number",
+		},
+		{
+			name:    "exceeds maximum allowed value",
+			options: map[string]any{"num_ctx": 2000000},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx exceeds maximum allowed value",
+		},
+		{
+			name:    "unsupported type (bool)",
+			options: map[string]any{"num_ctx": true},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx must be a number, got invalid type",
+		},
+		{
+			name:    "unsupported type (slice)",
+			options: map[string]any{"num_ctx": []int{1, 2, 3}},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx must be a number, got invalid type",
+		},
+		// --- Edge cases ---
+		{
+			name:    "minimum valid value",
+			options: map[string]any{"num_ctx": 1},
+			want:    1,
+			wantErr: false,
+		},
+		{
+			name:    "maximum allowed value",
+			options: map[string]any{"num_ctx": 1000000},
+			want:    1000000,
+			wantErr: false,
+		},
+		{
+			name:    "very large float64 (overflow)",
+			options: map[string]any{"num_ctx": float64(math.MaxFloat64)},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx value out of range",
+		},
+		{
+			name:    "large int64 exceeding maxInt on 32-bit",
+			options: map[string]any{"num_ctx": int64(1 << 40)},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx", // either "too large" or "exceeds maximum"
+		},
+		{
+			name:    "long string gets truncated in error",
+			options: map[string]any{"num_ctx": "this-is-a-very-long-string-that-should-be-truncated-in-the-error-message"},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx must be a valid number",
+		},
+		// --- Special float values ---
+		{
+			name:    "float64 NaN",
+			options: map[string]any{"num_ctx": math.NaN()},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx must be a finite number",
+		},
+		{
+			name:    "float64 positive infinity",
+			options: map[string]any{"num_ctx": math.Inf(1)},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx must be a finite number",
+		},
+		{
+			name:    "float64 negative infinity",
+			options: map[string]any{"num_ctx": math.Inf(-1)},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx must be a finite number",
+		},
+		{
+			name:    "float32 NaN",
+			options: map[string]any{"num_ctx": float32(math.NaN())},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx must be a finite number",
+		},
+		{
+			name:    "float32 positive infinity",
+			options: map[string]any{"num_ctx": float32(math.Inf(1))},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx must be a finite number",
+		},
+		{
+			name:    "float32 negative infinity",
+			options: map[string]any{"num_ctx": float32(math.Inf(-1))},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx must be a finite number",
+		},
+		// --- Negative int64 (32-bit wraparound prevention) ---
+		{
+			name:    "negative int64",
+			options: map[string]any{"num_ctx": int64(-1000)},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx must be positive",
+		},
+		{
+			name:    "negative json.Number",
+			options: map[string]any{"num_ctx": json.Number("-500")},
+			want:    0,
+			wantErr: true,
+			errMsg:  "num_ctx must be positive",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := parseOllamaNumCtx(tt.options)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("parseOllamaNumCtx() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if err != nil && tt.errMsg != "" {
+				if !strings.Contains(err.Error(), tt.errMsg) {
+					t.Errorf("parseOllamaNumCtx() error message = %q, want to contain %q", err.Error(), tt.errMsg)
+				}
+			}
+			if got != tt.want {
+				t.Errorf("parseOllamaNumCtx() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
--- a/internal/tools/spotify/spotify.go
+++ b/internal/tools/spotify/spotify.go
@@ -0,0 +1,524 @@
+// Package spotify provides Spotify Web API integration for podcast metadata retrieval.
+//
+// Requirements:
+// - Spotify Developer Account: Required to obtain Client ID and Client Secret
+// - Client Credentials: Stored in .env file via fabric --setup
+//
+// The implementation uses OAuth2 Client Credentials flow for authentication.
+// Note: The Spotify Web API does NOT provide access to podcast transcripts.
+// For transcript functionality, users should use fabric's --transcribe-file feature
+// with audio obtained from other sources.
+package spotify
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/danielmiessler/fabric/internal/i18n"
+	"github.com/danielmiessler/fabric/internal/plugins"
+)
+
+const (
+	// Spotify API endpoints
+	tokenURL   = "https://accounts.spotify.com/api/token"
+	apiBaseURL = "https://api.spotify.com/v1"
+)
+
+// URL pattern regexes for parsing Spotify URLs
+var (
+	showPatternRegex    = regexp.MustCompile(`spotify\.com/show/([a-zA-Z0-9]+)`)
+	episodePatternRegex = regexp.MustCompile(`spotify\.com/episode/([a-zA-Z0-9]+)`)
+)
+
+// NewSpotify creates a new Spotify client instance.
+func NewSpotify() *Spotify {
+	label := "Spotify"
+
+	ret := &Spotify{}
+
+	ret.PluginBase = &plugins.PluginBase{
+		Name:             i18n.T("spotify_label"),
+		SetupDescription: i18n.T("spotify_setup_description") + " " + i18n.T("optional_marker"),
+		EnvNamePrefix:    plugins.BuildEnvVariablePrefix(label),
+	}
+
+	ret.ClientId = ret.AddSetupQuestion("Client ID", false)
+	ret.ClientSecret = ret.AddSetupQuestion("Client Secret", false)
+
+	return ret
+}
+
+// Spotify represents a Spotify API client.
+type Spotify struct {
+	*plugins.PluginBase
+	ClientId     *plugins.SetupQuestion
+	ClientSecret *plugins.SetupQuestion
+
+	// OAuth2 token management
+	accessToken string
+	tokenExpiry time.Time
+	tokenMutex  sync.RWMutex
+	httpClient  *http.Client
+}
+
+// initClient ensures the HTTP client and access token are initialized.
+func (s *Spotify) initClient() error {
+	if s.httpClient == nil {
+		s.httpClient = &http.Client{Timeout: 30 * time.Second}
+	}
+
+	// Check if we need to refresh the token
+	s.tokenMutex.RLock()
+	needsRefresh := s.accessToken == "" || time.Now().After(s.tokenExpiry)
+	s.tokenMutex.RUnlock()
+
+	if needsRefresh {
+		return s.refreshAccessToken()
+	}
+	return nil
+}
+
+// refreshAccessToken obtains a new access token using Client Credentials flow.
+func (s *Spotify) refreshAccessToken() error {
+	if s.ClientId.Value == "" || s.ClientSecret.Value == "" {
+		return fmt.Errorf("%s", i18n.T("spotify_not_configured"))
+	}
+
+	// Prepare the token request
+	data := url.Values{}
+	data.Set("grant_type", "client_credentials")
+
+	req, err := http.NewRequest("POST", tokenURL, strings.NewReader(data.Encode()))
+	if err != nil {
+		return fmt.Errorf("failed to create token request: %w", err)
+	}
+
+	// Set Basic Auth header with Client ID and Secret
+	auth := base64.StdEncoding.EncodeToString([]byte(s.ClientId.Value + ":" + s.ClientSecret.Value))
+	req.Header.Set("Authorization", "Basic "+auth)
+	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+
+	resp, err := s.httpClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("failed to request access token: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		return fmt.Errorf("failed to get access token: status %d, body: %s", resp.StatusCode, string(body))
+	}
+
+	var tokenResp struct {
+		AccessToken string `json:"access_token"`
+		TokenType   string `json:"token_type"`
+		ExpiresIn   int    `json:"expires_in"`
+	}
+
+	if err := json.NewDecoder(resp.Body).Decode(&tokenResp); err != nil {
+		return fmt.Errorf("failed to decode token response: %w", err)
+	}
+
+	s.tokenMutex.Lock()
+	s.accessToken = tokenResp.AccessToken
+	// Set expiry slightly before actual expiry to avoid edge cases
+	s.tokenExpiry = time.Now().Add(time.Duration(tokenResp.ExpiresIn-60) * time.Second)
+	s.tokenMutex.Unlock()
+
+	return nil
+}
+
+// doRequest performs an authenticated request to the Spotify API.
+func (s *Spotify) doRequest(method, endpoint string) ([]byte, error) {
+	if err := s.initClient(); err != nil {
+		return nil, err
+	}
+
+	reqURL := apiBaseURL + endpoint
+	req, err := http.NewRequest(method, reqURL, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+
+	s.tokenMutex.RLock()
+	req.Header.Set("Authorization", "Bearer "+s.accessToken)
+	s.tokenMutex.RUnlock()
+
+	resp, err := s.httpClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to execute request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response body: %w", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("API request failed: status %d, body: %s", resp.StatusCode, string(body))
+	}
+
+	return body, nil
+}
+
+// GetShowOrEpisodeId extracts show or episode ID from a Spotify URL.
+func (s *Spotify) GetShowOrEpisodeId(urlStr string) (showId string, episodeId string, err error) {
+	// Extract show ID
+	showMatch := showPatternRegex.FindStringSubmatch(urlStr)
+	if len(showMatch) > 1 {
+		showId = showMatch[1]
+	}
+
+	// Extract episode ID
+	episodeMatch := episodePatternRegex.FindStringSubmatch(urlStr)
+	if len(episodeMatch) > 1 {
+		episodeId = episodeMatch[1]
+	}
+
+	if showId == "" && episodeId == "" {
+		err = fmt.Errorf(i18n.T("spotify_invalid_url"), urlStr)
+	}
+	return
+}
+
+// ShowMetadata represents metadata for a Spotify show (podcast).
+type ShowMetadata struct {
+	Id            string   `json:"id"`
+	Name          string   `json:"name"`
+	Description   string   `json:"description"`
+	Publisher     string   `json:"publisher"`
+	TotalEpisodes int      `json:"total_episodes"`
+	Languages     []string `json:"languages"`
+	MediaType     string   `json:"media_type"`
+	ExternalURL   string   `json:"external_url"`
+	ImageURL      string   `json:"image_url,omitempty"`
+}
+
+// EpisodeMetadata represents metadata for a Spotify episode.
+type EpisodeMetadata struct {
+	Id              string `json:"id"`
+	Name            string `json:"name"`
+	Description     string `json:"description"`
+	ReleaseDate     string `json:"release_date"`
+	DurationMs      int    `json:"duration_ms"`
+	DurationMinutes int    `json:"duration_minutes"`
+	Language        string `json:"language"`
+	Explicit        bool   `json:"explicit"`
+	ExternalURL     string `json:"external_url"`
+	AudioPreviewURL string `json:"audio_preview_url,omitempty"`
+	ImageURL        string `json:"image_url,omitempty"`
+	ShowId          string `json:"show_id"`
+	ShowName        string `json:"show_name"`
+}
+
+// SearchResult represents a search result item.
+type SearchResult struct {
+	Shows []ShowMetadata `json:"shows"`
+}
+
+// GetShowMetadata retrieves metadata for a Spotify show (podcast).
+func (s *Spotify) GetShowMetadata(showId string) (*ShowMetadata, error) {
+	body, err := s.doRequest("GET", "/shows/"+showId)
+	if err != nil {
+		return nil, fmt.Errorf(i18n.T("spotify_error_getting_metadata"), err)
+	}
+
+	var resp struct {
+		Id            string   `json:"id"`
+		Name          string   `json:"name"`
+		Description   string   `json:"description"`
+		Publisher     string   `json:"publisher"`
+		TotalEpisodes int      `json:"total_episodes"`
+		Languages     []string `json:"languages"`
+		MediaType     string   `json:"media_type"`
+		ExternalUrls  struct {
+			Spotify string `json:"spotify"`
+		} `json:"external_urls"`
+		Images []struct {
+			URL string `json:"url"`
+		} `json:"images"`
+	}
+
+	if err := json.Unmarshal(body, &resp); err != nil {
+		return nil, fmt.Errorf("failed to parse show metadata: %w", err)
+	}
+
+	if resp.Id == "" {
+		return nil, fmt.Errorf(i18n.T("spotify_no_show_found"), showId)
+	}
+
+	metadata := &ShowMetadata{
+		Id:            resp.Id,
+		Name:          resp.Name,
+		Description:   resp.Description,
+		Publisher:     resp.Publisher,
+		TotalEpisodes: resp.TotalEpisodes,
+		Languages:     resp.Languages,
+		MediaType:     resp.MediaType,
+		ExternalURL:   resp.ExternalUrls.Spotify,
+	}
+
+	if len(resp.Images) > 0 {
+		metadata.ImageURL = resp.Images[0].URL
+	}
+
+	return metadata, nil
+}
+
+// GetEpisodeMetadata retrieves metadata for a Spotify episode.
+func (s *Spotify) GetEpisodeMetadata(episodeId string) (*EpisodeMetadata, error) {
+	body, err := s.doRequest("GET", "/episodes/"+episodeId)
+	if err != nil {
+		return nil, fmt.Errorf(i18n.T("spotify_error_getting_metadata"), err)
+	}
+
+	var resp struct {
+		Id           string `json:"id"`
+		Name         string `json:"name"`
+		Description  string `json:"description"`
+		ReleaseDate  string `json:"release_date"`
+		DurationMs   int    `json:"duration_ms"`
+		Language     string `json:"language"`
+		Explicit     bool   `json:"explicit"`
+		ExternalUrls struct {
+			Spotify string `json:"spotify"`
+		} `json:"external_urls"`
+		AudioPreviewUrl string `json:"audio_preview_url"`
+		Images          []struct {
+			URL string `json:"url"`
+		} `json:"images"`
+		Show struct {
+			Id   string `json:"id"`
+			Name string `json:"name"`
+		} `json:"show"`
+	}
+
+	if err := json.Unmarshal(body, &resp); err != nil {
+		return nil, fmt.Errorf("failed to parse episode metadata: %w", err)
+	}
+
+	if resp.Id == "" {
+		return nil, fmt.Errorf(i18n.T("spotify_no_episode_found"), episodeId)
+	}
+
+	metadata := &EpisodeMetadata{
+		Id:              resp.Id,
+		Name:            resp.Name,
+		Description:     resp.Description,
+		ReleaseDate:     resp.ReleaseDate,
+		DurationMs:      resp.DurationMs,
+		DurationMinutes: resp.DurationMs / 60000,
+		Language:        resp.Language,
+		Explicit:        resp.Explicit,
+		ExternalURL:     resp.ExternalUrls.Spotify,
+		AudioPreviewURL: resp.AudioPreviewUrl,
+		ShowId:          resp.Show.Id,
+		ShowName:        resp.Show.Name,
+	}
+
+	if len(resp.Images) > 0 {
+		metadata.ImageURL = resp.Images[0].URL
+	}
+
+	return metadata, nil
+}
+
+// SearchShows searches for podcasts/shows matching the query.
+func (s *Spotify) SearchShows(query string, limit int) (*SearchResult, error) {
+	if limit <= 0 || limit > 50 {
+		limit = 20 // Default limit
+	}
+
+	endpoint := fmt.Sprintf("/search?q=%s&type=show&limit=%d", url.QueryEscape(query), limit)
+	body, err := s.doRequest("GET", endpoint)
+	if err != nil {
+		return nil, fmt.Errorf("search failed: %w", err)
+	}
+
+	var resp struct {
+		Shows struct {
+			Items []struct {
+				Id            string   `json:"id"`
+				Name          string   `json:"name"`
+				Description   string   `json:"description"`
+				Publisher     string   `json:"publisher"`
+				TotalEpisodes int      `json:"total_episodes"`
+				Languages     []string `json:"languages"`
+				MediaType     string   `json:"media_type"`
+				ExternalUrls  struct {
+					Spotify string `json:"spotify"`
+				} `json:"external_urls"`
+				Images []struct {
+					URL string `json:"url"`
+				} `json:"images"`
+			} `json:"items"`
+		} `json:"shows"`
+	}
+
+	if err := json.Unmarshal(body, &resp); err != nil {
+		return nil, fmt.Errorf("failed to parse search results: %w", err)
+	}
+
+	result := &SearchResult{
+		Shows: make([]ShowMetadata, 0, len(resp.Shows.Items)),
+	}
+
+	for _, item := range resp.Shows.Items {
+		show := ShowMetadata{
+			Id:            item.Id,
+			Name:          item.Name,
+			Description:   item.Description,
+			Publisher:     item.Publisher,
+			TotalEpisodes: item.TotalEpisodes,
+			Languages:     item.Languages,
+			MediaType:     item.MediaType,
+			ExternalURL:   item.ExternalUrls.Spotify,
+		}
+		if len(item.Images) > 0 {
+			show.ImageURL = item.Images[0].URL
+		}
+		result.Shows = append(result.Shows, show)
+	}
+
+	return result, nil
+}
+
+// GetShowEpisodes retrieves episodes for a given show.
+func (s *Spotify) GetShowEpisodes(showId string, limit int) ([]EpisodeMetadata, error) {
+	if limit <= 0 || limit > 50 {
+		limit = 20 // Default limit
+	}
+
+	endpoint := fmt.Sprintf("/shows/%s/episodes?limit=%d", showId, limit)
+	body, err := s.doRequest("GET", endpoint)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get show episodes: %w", err)
+	}
+
+	var resp struct {
+		Items []struct {
+			Id           string `json:"id"`
+			Name         string `json:"name"`
+			Description  string `json:"description"`
+			ReleaseDate  string `json:"release_date"`
+			DurationMs   int    `json:"duration_ms"`
+			Language     string `json:"language"`
+			Explicit     bool   `json:"explicit"`
+			ExternalUrls struct {
+				Spotify string `json:"spotify"`
+			} `json:"external_urls"`
+			AudioPreviewUrl string `json:"audio_preview_url"`
+			Images          []struct {
+				URL string `json:"url"`
+			} `json:"images"`
+		} `json:"items"`
+	}
+
+	if err := json.Unmarshal(body, &resp); err != nil {
+		return nil, fmt.Errorf("failed to parse episodes: %w", err)
+	}
+
+	episodes := make([]EpisodeMetadata, 0, len(resp.Items))
+	for _, item := range resp.Items {
+		ep := EpisodeMetadata{
+			Id:              item.Id,
+			Name:            item.Name,
+			Description:     item.Description,
+			ReleaseDate:     item.ReleaseDate,
+			DurationMs:      item.DurationMs,
+			DurationMinutes: item.DurationMs / 60000,
+			Language:        item.Language,
+			Explicit:        item.Explicit,
+			ExternalURL:     item.ExternalUrls.Spotify,
+			AudioPreviewURL: item.AudioPreviewUrl,
+			ShowId:          showId,
+		}
+		if len(item.Images) > 0 {
+			ep.ImageURL = item.Images[0].URL
+		}
+		episodes = append(episodes, ep)
+	}
+
+	return episodes, nil
+}
+
+// GrabMetadataForURL retrieves metadata for a Spotify URL (show or episode).
+func (s *Spotify) GrabMetadataForURL(urlStr string) (any, error) {
+	showId, episodeId, err := s.GetShowOrEpisodeId(urlStr)
+	if err != nil {
+		return nil, err
+	}
+
+	if episodeId != "" {
+		return s.GetEpisodeMetadata(episodeId)
+	}
+
+	if showId != "" {
+		return s.GetShowMetadata(showId)
+	}
+
+	return nil, fmt.Errorf(i18n.T("spotify_invalid_url"), urlStr)
+}
+
+// FormatMetadataAsText formats metadata as human-readable text suitable for LLM processing.
+func (s *Spotify) FormatMetadataAsText(metadata any) string {
+	var sb strings.Builder
+
+	switch m := metadata.(type) {
+	case *ShowMetadata:
+		sb.WriteString("# Spotify Podcast/Show\n\n")
+		sb.WriteString(fmt.Sprintf("**Title**: %s\n", m.Name))
+		sb.WriteString(fmt.Sprintf("**Publisher**: %s\n", m.Publisher))
+		sb.WriteString(fmt.Sprintf("**Total Episodes**: %d\n", m.TotalEpisodes))
+		if len(m.Languages) > 0 {
+			sb.WriteString(fmt.Sprintf("**Languages**: %s\n", strings.Join(m.Languages, ", ")))
+		}
+		sb.WriteString(fmt.Sprintf("**Media Type**: %s\n", m.MediaType))
+		sb.WriteString(fmt.Sprintf("**URL**: %s\n\n", m.ExternalURL))
+		sb.WriteString("## Description\n\n")
+		sb.WriteString(m.Description)
+		sb.WriteString("\n")
+
+	case *EpisodeMetadata:
+		sb.WriteString("# Spotify Episode\n\n")
+		sb.WriteString(fmt.Sprintf("**Title**: %s\n", m.Name))
+		sb.WriteString(fmt.Sprintf("**Show**: %s\n", m.ShowName))
+		sb.WriteString(fmt.Sprintf("**Release Date**: %s\n", m.ReleaseDate))
+		sb.WriteString(fmt.Sprintf("**Duration**: %d minutes\n", m.DurationMinutes))
+		sb.WriteString(fmt.Sprintf("**Language**: %s\n", m.Language))
+		sb.WriteString(fmt.Sprintf("**Explicit**: %v\n", m.Explicit))
+		sb.WriteString(fmt.Sprintf("**URL**: %s\n", m.ExternalURL))
+		if m.AudioPreviewURL != "" {
+			sb.WriteString(fmt.Sprintf("**Audio Preview**: %s\n", m.AudioPreviewURL))
+		}
+		sb.WriteString("\n## Description\n\n")
+		sb.WriteString(m.Description)
+		sb.WriteString("\n")
+
+	case *SearchResult:
+		sb.WriteString("# Spotify Search Results\n\n")
+		for i, show := range m.Shows {
+			sb.WriteString(fmt.Sprintf("## %d. %s\n", i+1, show.Name))
+			sb.WriteString(fmt.Sprintf("- **Publisher**: %s\n", show.Publisher))
+			sb.WriteString(fmt.Sprintf("- **Episodes**: %d\n", show.TotalEpisodes))
+			sb.WriteString(fmt.Sprintf("- **URL**: %s\n", show.ExternalURL))
+			// Truncate description for search results
+			desc := show.Description
+			if len(desc) > 200 {
+				desc = desc[:200] + "..."
+			}
+			sb.WriteString(fmt.Sprintf("- **Description**: %s\n\n", desc))
+		}
+	}
+
+	return sb.String()
+}
--- a/internal/tools/spotify/spotify_integration_test.go
+++ b/internal/tools/spotify/spotify_integration_test.go
@@ -0,0 +1,238 @@
+//go:build integration
+
+// Integration tests for Spotify API.
+// These tests require valid Spotify API credentials to run.
+// Run with: go test -tags=integration ./internal/tools/spotify/...
+//
+// Required environment variables:
+// - SPOTIFY_CLIENT_ID: Your Spotify Developer Client ID
+// - SPOTIFY_CLIENT_SECRET: Your Spotify Developer Client Secret
+
+package spotify
+
+import (
+	"os"
+	"testing"
+)
+
+// Known public Spotify shows/episodes for testing.
+// NOTE: These IDs are for The Joe Rogan Experience, one of the most popular
+// podcasts on Spotify. If these become unavailable, update with another
+// well-known, long-running podcast.
+const (
+	// The Joe Rogan Experience - one of the most popular podcasts on Spotify
+	// cspell:disable-next-line
+	testShowID = "4rOoJ6Egrf8K2IrywzwOMk"
+	// A valid episode URL (episode of JRE)
+	// NOTE: If this specific episode is removed, the test will fail.
+	// Replace with any valid episode ID from the show.
+	testEpisodeID = "512ojhOuo1ktJprKbVcKyQ"
+)
+
+func setupIntegrationClient(t *testing.T) *Spotify {
+	clientID := os.Getenv("SPOTIFY_CLIENT_ID")
+	clientSecret := os.Getenv("SPOTIFY_CLIENT_SECRET")
+
+	if clientID == "" || clientSecret == "" {
+		t.Skip("Skipping integration test: SPOTIFY_CLIENT_ID and SPOTIFY_CLIENT_SECRET must be set")
+	}
+
+	s := NewSpotify()
+	s.ClientId.Value = clientID
+	s.ClientSecret.Value = clientSecret
+
+	return s
+}
+
+func TestIntegration_GetShowMetadata(t *testing.T) {
+	s := setupIntegrationClient(t)
+
+	metadata, err := s.GetShowMetadata(testShowID)
+	if err != nil {
+		t.Fatalf("GetShowMetadata failed: %v", err)
+	}
+
+	if metadata == nil {
+		t.Fatal("GetShowMetadata returned nil metadata")
+	}
+
+	if metadata.Id != testShowID {
+		t.Errorf("Expected show ID %s, got %s", testShowID, metadata.Id)
+	}
+
+	if metadata.Name == "" {
+		t.Error("Show name should not be empty")
+	}
+
+	if metadata.Publisher == "" {
+		t.Error("Show publisher should not be empty")
+	}
+
+	t.Logf("Show: %s by %s (%d episodes)", metadata.Name, metadata.Publisher, metadata.TotalEpisodes)
+}
+
+func TestIntegration_GetEpisodeMetadata(t *testing.T) {
+	s := setupIntegrationClient(t)
+
+	metadata, err := s.GetEpisodeMetadata(testEpisodeID)
+	if err != nil {
+		t.Fatalf("GetEpisodeMetadata failed: %v", err)
+	}
+
+	if metadata == nil {
+		t.Fatal("GetEpisodeMetadata returned nil metadata")
+	}
+
+	if metadata.Id != testEpisodeID {
+		t.Errorf("Expected episode ID %s, got %s", testEpisodeID, metadata.Id)
+	}
+
+	if metadata.Name == "" {
+		t.Error("Episode name should not be empty")
+	}
+
+	if metadata.DurationMinutes <= 0 {
+		t.Error("Episode duration should be positive")
+	}
+
+	t.Logf("Episode: %s (%d minutes)", metadata.Name, metadata.DurationMinutes)
+}
+
+func TestIntegration_SearchShows(t *testing.T) {
+	s := setupIntegrationClient(t)
+
+	result, err := s.SearchShows("technology podcast", 5)
+	if err != nil {
+		t.Fatalf("SearchShows failed: %v", err)
+	}
+
+	if result == nil {
+		t.Fatal("SearchShows returned nil result")
+	}
+
+	if len(result.Shows) == 0 {
+		t.Error("SearchShows should return at least one result for 'technology podcast'")
+	}
+
+	for i, show := range result.Shows {
+		t.Logf("Result %d: %s by %s", i+1, show.Name, show.Publisher)
+	}
+}
+
+func TestIntegration_GetShowEpisodes(t *testing.T) {
+	s := setupIntegrationClient(t)
+
+	episodes, err := s.GetShowEpisodes(testShowID, 5)
+	if err != nil {
+		t.Fatalf("GetShowEpisodes failed: %v", err)
+	}
+
+	if len(episodes) == 0 {
+		t.Error("GetShowEpisodes should return at least one episode")
+	}
+
+	for i, ep := range episodes {
+		t.Logf("Episode %d: %s (%d min)", i+1, ep.Name, ep.DurationMinutes)
+	}
+}
+
+func TestIntegration_GrabMetadataForURL_Show(t *testing.T) {
+	s := setupIntegrationClient(t)
+
+	url := "https://open.spotify.com/show/" + testShowID
+
+	metadata, err := s.GrabMetadataForURL(url)
+	if err != nil {
+		t.Fatalf("GrabMetadataForURL failed: %v", err)
+	}
+
+	show, ok := metadata.(*ShowMetadata)
+	if !ok {
+		t.Fatalf("Expected ShowMetadata, got %T", metadata)
+	}
+
+	if show.Id != testShowID {
+		t.Errorf("Expected show ID %s, got %s", testShowID, show.Id)
+	}
+}
+
+func TestIntegration_GrabMetadataForURL_Episode(t *testing.T) {
+	s := setupIntegrationClient(t)
+
+	url := "https://open.spotify.com/episode/" + testEpisodeID
+
+	metadata, err := s.GrabMetadataForURL(url)
+	if err != nil {
+		t.Fatalf("GrabMetadataForURL failed: %v", err)
+	}
+
+	episode, ok := metadata.(*EpisodeMetadata)
+	if !ok {
+		t.Fatalf("Expected EpisodeMetadata, got %T", metadata)
+	}
+
+	if episode.Id != testEpisodeID {
+		t.Errorf("Expected episode ID %s, got %s", testEpisodeID, episode.Id)
+	}
+}
+
+func TestIntegration_FormatMetadataAsText(t *testing.T) {
+	s := setupIntegrationClient(t)
+
+	metadata, err := s.GrabMetadataForURL("https://open.spotify.com/show/" + testShowID)
+	if err != nil {
+		t.Fatalf("GrabMetadataForURL failed: %v", err)
+	}
+
+	text := s.FormatMetadataAsText(metadata)
+
+	if text == "" {
+		t.Error("FormatMetadataAsText returned empty string")
+	}
+
+	// Just log the output for manual inspection
+	t.Logf("Formatted metadata:\n%s", text)
+}
+
+func TestIntegration_GetShowMetadata_InvalidID(t *testing.T) {
+	s := setupIntegrationClient(t)
+
+	_, err := s.GetShowMetadata("invalid_show_id_12345")
+	if err == nil {
+		t.Error("GetShowMetadata with invalid ID should return an error")
+	}
+	t.Logf("Expected error for invalid show ID: %v", err)
+}
+
+func TestIntegration_GetEpisodeMetadata_InvalidID(t *testing.T) {
+	s := setupIntegrationClient(t)
+
+	_, err := s.GetEpisodeMetadata("invalid_episode_id_12345")
+	if err == nil {
+		t.Error("GetEpisodeMetadata with invalid ID should return an error")
+	}
+	t.Logf("Expected error for invalid episode ID: %v", err)
+}
+
+func TestIntegration_SearchShows_NoResults(t *testing.T) {
+	s := setupIntegrationClient(t)
+
+	// Search for something extremely unlikely to exist
+	// cspell:disable-next-line
+	result, err := s.SearchShows("xyzzy_nonexistent_podcast_12345_zyxwv", 5)
+	if err != nil {
+		t.Fatalf("SearchShows failed: %v", err)
+	}
+
+	// Should return empty results, not an error
+	if result == nil {
+		t.Fatal("SearchShows returned nil result")
+	}
+
+	// Log warning if we somehow got results for this nonsense query
+	if len(result.Shows) > 0 {
+		t.Logf("WARNING: Unexpectedly found %d results for nonsense query (test may need updating)", len(result.Shows))
+	} else {
+		t.Log("Search correctly returned 0 results for nonsense query")
+	}
+}
--- a/internal/tools/spotify/spotify_test.go
+++ b/internal/tools/spotify/spotify_test.go
@@ -0,0 +1,306 @@
+package spotify
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestGetShowOrEpisodeId(t *testing.T) {
+	s := NewSpotify()
+
+	tests := []struct {
+		name          string
+		url           string
+		wantShowId    string
+		wantEpisodeId string
+		wantError     bool
+		errorMsg      string
+	}{
+		{
+			name: "valid show URL",
+			url:  "https://open.spotify.com/show/4rOoJ6Egrf8K2IrywzwOMk",
+			// cspell:disable-next-line
+			wantShowId:    "4rOoJ6Egrf8K2IrywzwOMk",
+			wantEpisodeId: "",
+			wantError:     false,
+		},
+		{
+			name:          "valid episode URL",
+			url:           "https://open.spotify.com/episode/512ojhOuo1ktJprKbVcKyQ",
+			wantShowId:    "",
+			wantEpisodeId: "512ojhOuo1ktJprKbVcKyQ",
+			wantError:     false,
+		},
+		{
+			name: "show URL with query params",
+			url:  "https://open.spotify.com/show/4rOoJ6Egrf8K2IrywzwOMk?si=abc123",
+			// cspell:disable-next-line
+			wantShowId:    "4rOoJ6Egrf8K2IrywzwOMk",
+			wantEpisodeId: "",
+			wantError:     false,
+		},
+		{
+			name:          "episode URL with query params",
+			url:           "https://open.spotify.com/episode/512ojhOuo1ktJprKbVcKyQ?si=def456",
+			wantShowId:    "",
+			wantEpisodeId: "512ojhOuo1ktJprKbVcKyQ",
+			wantError:     false,
+		},
+		{
+			name:          "invalid URL - no show or episode",
+			url:           "https://open.spotify.com/track/4uLU6hMCjMI75M1A2tKUQC",
+			wantShowId:    "",
+			wantEpisodeId: "",
+			wantError:     true,
+			errorMsg:      "invalid Spotify URL",
+		},
+		{
+			name:          "invalid URL - not spotify",
+			url:           "https://example.com/show/123",
+			wantShowId:    "",
+			wantEpisodeId: "",
+			wantError:     true,
+			errorMsg:      "invalid Spotify URL",
+		},
+		{
+			name:          "empty URL",
+			url:           "",
+			wantShowId:    "",
+			wantEpisodeId: "",
+			wantError:     true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			showId, episodeId, err := s.GetShowOrEpisodeId(tt.url)
+
+			if tt.wantError {
+				if err == nil {
+					t.Errorf("GetShowOrEpisodeId(%q) expected error but got none", tt.url)
+					return
+				}
+				if tt.errorMsg != "" && !strings.Contains(err.Error(), tt.errorMsg) {
+					t.Errorf("GetShowOrEpisodeId(%q) error = %v, want error containing %q", tt.url, err, tt.errorMsg)
+				}
+				return
+			}
+
+			if err != nil {
+				t.Errorf("GetShowOrEpisodeId(%q) unexpected error = %v", tt.url, err)
+				return
+			}
+
+			if showId != tt.wantShowId {
+				t.Errorf("GetShowOrEpisodeId(%q) showId = %q, want %q", tt.url, showId, tt.wantShowId)
+			}
+
+			if episodeId != tt.wantEpisodeId {
+				t.Errorf("GetShowOrEpisodeId(%q) episodeId = %q, want %q", tt.url, episodeId, tt.wantEpisodeId)
+			}
+		})
+	}
+}
+
+func TestFormatMetadataAsText_ShowMetadata(t *testing.T) {
+	s := NewSpotify()
+
+	show := &ShowMetadata{
+		Id:            "test123",
+		Name:          "Test Podcast",
+		Description:   "A test podcast description",
+		Publisher:     "Test Publisher",
+		TotalEpisodes: 100,
+		Languages:     []string{"en", "es"},
+		MediaType:     "audio",
+		ExternalURL:   "https://open.spotify.com/show/test123",
+	}
+
+	result := s.FormatMetadataAsText(show)
+
+	// Verify key elements are present
+	if !strings.Contains(result, "# Spotify Podcast/Show") {
+		t.Error("FormatMetadataAsText missing header for show")
+	}
+	if !strings.Contains(result, "**Title**: Test Podcast") {
+		t.Error("FormatMetadataAsText missing title")
+	}
+	if !strings.Contains(result, "**Publisher**: Test Publisher") {
+		t.Error("FormatMetadataAsText missing publisher")
+	}
+	if !strings.Contains(result, "**Total Episodes**: 100") {
+		t.Error("FormatMetadataAsText missing total episodes")
+	}
+	if !strings.Contains(result, "en, es") {
+		t.Error("FormatMetadataAsText missing languages")
+	}
+	if !strings.Contains(result, "A test podcast description") {
+		t.Error("FormatMetadataAsText missing description")
+	}
+}
+
+func TestFormatMetadataAsText_EpisodeMetadata(t *testing.T) {
+	s := NewSpotify()
+
+	episode := &EpisodeMetadata{
+		Id:              "ep123",
+		Name:            "Test Episode",
+		Description:     "A test episode description",
+		ReleaseDate:     "2024-01-15",
+		DurationMs:      3600000,
+		DurationMinutes: 60,
+		Language:        "en",
+		Explicit:        false,
+		ExternalURL:     "https://open.spotify.com/episode/ep123",
+		ShowId:          "show123",
+		ShowName:        "Test Show",
+	}
+
+	result := s.FormatMetadataAsText(episode)
+
+	// Verify key elements are present
+	if !strings.Contains(result, "# Spotify Episode") {
+		t.Error("FormatMetadataAsText missing header for episode")
+	}
+	if !strings.Contains(result, "**Title**: Test Episode") {
+		t.Error("FormatMetadataAsText missing title")
+	}
+	if !strings.Contains(result, "**Show**: Test Show") {
+		t.Error("FormatMetadataAsText missing show name")
+	}
+	if !strings.Contains(result, "**Release Date**: 2024-01-15") {
+		t.Error("FormatMetadataAsText missing release date")
+	}
+	if !strings.Contains(result, "**Duration**: 60 minutes") {
+		t.Error("FormatMetadataAsText missing duration")
+	}
+	if !strings.Contains(result, "A test episode description") {
+		t.Error("FormatMetadataAsText missing description")
+	}
+}
+
+func TestFormatMetadataAsText_SearchResult(t *testing.T) {
+	s := NewSpotify()
+
+	searchResult := &SearchResult{
+		Shows: []ShowMetadata{
+			{
+				Id:            "show1",
+				Name:          "First Show",
+				Description:   "First show description",
+				Publisher:     "Publisher One",
+				TotalEpisodes: 50,
+				ExternalURL:   "https://open.spotify.com/show/show1",
+			},
+			{
+				Id:            "show2",
+				Name:          "Second Show",
+				Description:   "Second show description",
+				Publisher:     "Publisher Two",
+				TotalEpisodes: 25,
+				ExternalURL:   "https://open.spotify.com/show/show2",
+			},
+		},
+	}
+
+	result := s.FormatMetadataAsText(searchResult)
+
+	// Verify key elements are present
+	if !strings.Contains(result, "# Spotify Search Results") {
+		t.Error("FormatMetadataAsText missing header for search results")
+	}
+	if !strings.Contains(result, "## 1. First Show") {
+		t.Error("FormatMetadataAsText missing first show")
+	}
+	if !strings.Contains(result, "## 2. Second Show") {
+		t.Error("FormatMetadataAsText missing second show")
+	}
+	if !strings.Contains(result, "**Publisher**: Publisher One") {
+		t.Error("FormatMetadataAsText missing publisher for first show")
+	}
+	if !strings.Contains(result, "**Episodes**: 50") {
+		t.Error("FormatMetadataAsText missing episode count")
+	}
+}
+
+func TestFormatMetadataAsText_NilAndUnknownTypes(t *testing.T) {
+	s := NewSpotify()
+
+	// Test with nil
+	result := s.FormatMetadataAsText(nil)
+	if result != "" {
+		t.Errorf("FormatMetadataAsText(nil) should return empty string, got %q", result)
+	}
+
+	// Test with unknown type
+	result = s.FormatMetadataAsText("unexpected string type")
+	if result != "" {
+		t.Errorf("FormatMetadataAsText(string) should return empty string, got %q", result)
+	}
+
+	// Test with another unknown type
+	result = s.FormatMetadataAsText(12345)
+	if result != "" {
+		t.Errorf("FormatMetadataAsText(int) should return empty string, got %q", result)
+	}
+}
+
+func TestNewSpotify(t *testing.T) {
+	s := NewSpotify()
+
+	if s == nil {
+		t.Fatal("NewSpotify() returned nil")
+	}
+
+	if s.PluginBase == nil {
+		t.Error("NewSpotify() PluginBase is nil")
+	}
+
+	if s.ClientId == nil {
+		t.Error("NewSpotify() ClientId is nil")
+	}
+
+	if s.ClientSecret == nil {
+		t.Error("NewSpotify() ClientSecret is nil")
+	}
+}
+
+func TestSpotify_IsConfigured(t *testing.T) {
+	s := NewSpotify()
+
+	// Since ClientId and ClientSecret are optional (not required),
+	// IsConfigured() returns true even when empty
+	// This is by design - Spotify is an optional plugin
+	if !s.IsConfigured() {
+		t.Error("NewSpotify() should be configured (optional settings are valid when empty)")
+	}
+
+	// Set credentials - should still be configured
+	s.ClientId.Value = "test_client_id"
+	s.ClientSecret.Value = "test_client_secret"
+
+	if !s.IsConfigured() {
+		t.Error("Spotify should be configured after setting credentials")
+	}
+}
+
+func TestSpotify_HasCredentials(t *testing.T) {
+	s := NewSpotify()
+
+	// Without credentials, attempting to use the API should fail
+	// This tests the actual validation in refreshAccessToken
+	if s.ClientId.Value != "" || s.ClientSecret.Value != "" {
+		t.Error("NewSpotify() should have empty credentials initially")
+	}
+
+	// Set credentials
+	s.ClientId.Value = "test_client_id"
+	s.ClientSecret.Value = "test_client_secret"
+
+	if s.ClientId.Value != "test_client_id" {
+		t.Error("ClientId should be set")
+	}
+	if s.ClientSecret.Value != "test_client_secret" {
+		t.Error("ClientSecret should be set")
+	}
+}
--- a/nix/pkgs/fabric/version.nix
+++ b/nix/pkgs/fabric/version.nix
@@ -1 +1 @@
-"1.4.382"
+"1.4.386"
--- a/patterns/create_bd_issue/system.md
+++ b/patterns/create_bd_issue/system.md
@@ -0,0 +1,104 @@
+# IDENTITY and PURPOSE
+
+You are an expert at transforming natural language issue descriptions into optimal `bd create` commands. You understand the bd (Beads) issue tracker deeply and always select the most appropriate flags based on the user's intent.
+
+Your goal is to produce a single, well-crafted `bd create` command that captures all the relevant details from the input while following bd best practices.
+
+# BD CREATE REFERENCE
+
+Available flags:
+- `--title "string"` or positional first arg: Issue title (imperative mood: "Add...", "Fix...", "Update...")
+- `-d, --description "string"`: Issue description (context, acceptance criteria, notes)
+- `-t, --type TYPE`: bug|feature|task|epic|chore|merge-request|molecule|gate|agent|role|rig|convoy|event (default: task)
+- `-p, --priority P0-P4`: P0=critical, P1=high, P2=normal (default), P3=low, P4=wishlist
+- `-l, --labels strings`: Comma-separated labels (e.g., ux,backend,docs)
+- `-a, --assignee string`: Who should work on this
+- `-e, --estimate int`: Time estimate in minutes
+- `--due string`: Due date (+6h, +1d, +2w, tomorrow, next monday, 2025-01-15)
+- `--defer string`: Hide until date (same formats as --due)
+- `--deps strings`: Dependencies (e.g., 'bd-20' or 'blocks:bd-15')
+- `--parent string`: Parent issue ID for hierarchical child
+- `--acceptance string`: Acceptance criteria
+- `--design string`: Design notes
+- `--notes string`: Additional notes
+- `--external-ref string`: External reference (e.g., 'gh-9', 'jira-ABC')
+- `--ephemeral`: Mark as ephemeral (not exported)
+- `--prefix string` or `--rig string`: Create in specific rig
+- `--repo string`: Target repository for issue
+
+Type-specific flags:
+- Molecules: `--mol-type swarm|patrol|work`
+- Agents: `--agent-rig string`, `--role-type polecat|crew|witness|refinery|mayor|deacon`
+- Events: `--event-actor string`, `--event-category string`, `--event-payload string`, `--event-target string`
+- Gates: `--waits-for string`, `--waits-for-gate all-children|any-children`
+
+# STEPS
+
+1. Parse the input to understand:
+   - What is being requested (the core action/fix/feature)
+   - Any context or background
+   - Urgency or priority signals
+   - Technical domain (for labels)
+   - Time-related constraints
+   - Dependencies or blockers
+   - Acceptance criteria
+
+2. Determine the issue type:
+   - bug: Something is broken
+   - feature: New capability
+   - task: Work that needs doing
+   - epic: Large multi-part effort
+   - chore: Maintenance/cleanup
+
+3. Assess priority:
+   - P0: Production down, security breach, data loss
+   - P1: Major functionality broken, blocking release
+   - P2: Standard work (default)
+   - P3: Nice to have, can wait
+   - P4: Someday/maybe, ideas
+
+4. Select appropriate labels (limit to 1-4):
+   - Domain: frontend, backend, api, db, infra, mobile
+   - Category: ux, perf, security, docs, tech-debt
+   - Size: quick-win, spike, refactor
+
+5. Construct the optimal command:
+   - Title: 3-8 words, imperative mood
+   - Description: 1-3 sentences if complex
+   - Only include flags that add value (skip defaults)
+
+# OUTPUT INSTRUCTIONS
+
+- Output ONLY the bd create command, nothing else
+- No markdown code blocks, no explanations, no warnings
+- Use double quotes for all string values
+- Escape any internal quotes with backslash
+- If description is short, use -d; if long, suggest --body-file
+- Prefer explicit type when not "task"
+- Only include priority when not P2 (default)
+- Only include labels when they add categorization value
+- Order flags: type, priority, labels, then others
+
+# EXAMPLES
+
+Input: "We need to add dark mode to the settings page"
+Output: bd create "Add dark mode toggle to settings page" -t feature -l ux,frontend
+
+Input: "URGENT: login is broken on production"
+Output: bd create "Fix broken login on production" -t bug -p P0 -d "Login functionality is completely broken in production environment"
+
+Input: "maybe someday we could add keyboard shortcuts"
+Output: bd create "Add keyboard shortcuts" -t feature -p P4 -l ux
+
+Input: "need to update the deps before next week"
+Output: bd create "Update dependencies" -t chore --due "next week"
+
+Input: "the api docs are missing the new v2 endpoints, john should handle it"
+Output: bd create "Document v2 API endpoints" -t task -l docs,api -a john
+
+Input: "track time spent on customer dashboard - estimate about 2 hours"
+Output: bd create "Track time spent on customer dashboard" -e 120 -l analytics
+
+# INPUT
+
+INPUT:
--- a/patterns/extract_bd_ideas/system.md
+++ b/patterns/extract_bd_ideas/system.md
@@ -0,0 +1,96 @@
+# IDENTITY and PURPOSE
+
+You are an expert at extracting actionable ideas from content and transforming them into well-structured issue tracker commands. You analyze input text—meeting notes, brainstorms, articles, conversations, or any content—and identify concrete, actionable items that should be tracked as issues.
+
+You understand that good issues are:
+- Specific and actionable (not vague wishes)
+- Appropriately scoped (not too big, not too small)
+- Self-contained (understandable without reading the source)
+- Prioritized by impact and urgency
+
+Take a step back and think step-by-step about how to achieve the best possible results.
+
+# STEPS
+
+1. Read the input content thoroughly, looking for:
+   - Explicit tasks or action items mentioned
+   - Problems that need solving
+   - Ideas that could be implemented
+   - Improvements or enhancements suggested
+   - Bugs or issues reported
+   - Features requested
+
+2. For each potential issue, evaluate:
+   - Is this actionable? (Skip vague wishes or opinions)
+   - Is this appropriately scoped? (Break down large items)
+   - What priority does this deserve? (P0=critical, P1=high, P2=normal, P3=low, P4=wishlist)
+   - What type is it? (feature, bug, task, idea, improvement)
+   - What labels apply? (e.g., ux, backend, docs, perf)
+
+3. Transform each item into a bd create command with:
+   - Clear, concise title (imperative mood: "Add...", "Fix...", "Update...")
+   - Description providing context from the source
+   - Appropriate priority
+   - Relevant labels
+
+4. Order results by priority (highest first)
+
+# OUTPUT SECTIONS
+
+## SUMMARY
+
+A 2-3 sentence summary of what was analyzed and how many actionable items were found.
+
+## ISSUES
+
+Output each issue as a `bd create` command, one per line, formatted for easy copy-paste execution.
+
+## SKIPPED
+
+List any items from the input that were considered but not included, with brief reason (e.g., "too vague", "not actionable", "duplicate of above").
+
+# OUTPUT INSTRUCTIONS
+
+- Output in Markdown format
+- Each bd command should be on its own line in a code block
+- Use this exact format for commands:
+  ```bash
+  bd create "Title in imperative mood" -d "Description with context" -p P2 -l label1,label2
+  ```
+- Priorities: P0 (critical/blocking), P1 (high/important), P2 (normal), P3 (low), P4 (wishlist)
+- Common labels: bug, feature, task, idea, docs, ux, backend, frontend, perf, security, tech-debt
+- Titles should be 3-8 words, imperative mood ("Add X", "Fix Y", "Update Z")
+- Descriptions should be 1-3 sentences providing context
+- Do not include dependencies (--deps) unless explicitly stated in the source
+- Do not include estimates (--estimate) unless explicitly stated
+- Do not give warnings or notes outside the defined sections
+- Extract at least 3 ideas if possible, maximum 20
+- Ensure each issue is distinct—no duplicates
+
+# EXAMPLE OUTPUT
+
+## SUMMARY
+
+Analyzed meeting notes from product planning session. Found 7 actionable items ranging from critical bugs to wishlist features.
+
+## ISSUES
+
+```bash
+bd create "Fix login timeout on mobile Safari" -d "Users report being logged out after 5 minutes on iOS Safari. Affects conversion flow." -p P1 -l bug,mobile,auth
+
+bd create "Add dark mode toggle to settings" -d "Multiple user requests for dark mode. Should respect system preference by default." -p P2 -l feature,ux,settings
+
+bd create "Update API docs for v2 endpoints" -d "New endpoints from last sprint are undocumented. Blocking external integrations." -p P1 -l docs,api,tech-debt
+
+bd create "Explore caching for dashboard queries" -d "Dashboard load times averaging 3s. Consider Redis or query optimization." -p P3 -l perf,backend,idea
+```
+
+## SKIPPED
+
+- "Make everything faster" - too vague, not actionable
+- "The design looks nice" - not an action item
+- "Fix the bug" - insufficient detail to create issue
+
+# INPUT
+
+INPUT:
Author	SHA1	Message	Date
github-actions[bot]	c528a72b5b	chore(release): Update version to v1.4.386	2026-01-21 00:17:17 +00:00
Kayvan Sylvan	89df6ac75e	Merge pull request #1945 from ksylvan/implement-spotify-api feat: Add Spotify API integration for podcast metadata retrieval	2026-01-20 16:13:04 -08:00
Kayvan Sylvan	963acdefbb	chore: incoming 1945 changelog entry	2026-01-20 16:01:09 -08:00
Kayvan Sylvan	719590abb6	feat: add Spotify metadata retrieval via --spotify flag ## CHANGES - Add Spotify plugin with OAuth token handling and metadata - Wire --spotify flag into CLI processing and output - Register Spotify in plugin setup, env, and registry - Update shell completions to include --spotify option - Add i18n strings for Spotify configuration errors - Add unit and integration tests for Spotify API - Set gopls integration build tags for workspace	2026-01-20 15:57:59 -08:00
github-actions[bot]	b5e36d93b6	chore(release): Update version to v1.4.385	2026-01-20 20:07:22 +00:00
Kayvan Sylvan	2241b2a283	Merge pull request #1949 from ksylvan/image-generation-feature-should-warn Fix #1931 - Image Generation Feature should warn if the model is not capable of Image Generation	2026-01-20 12:04:40 -08:00
Kayvan Sylvan	ef60f8ca89	chore: incoming 1949 changelog entry	2026-01-20 11:59:31 -08:00
Kayvan Sylvan	a23c698947	feat: add image generation compatibility warnings for unsupported models ## CHANGES - Add warning to stderr when using incompatible models with image generation - Add GPT-5, GPT-5-nano, and GPT-5.2 to supported image generation models - Create `checkImageGenerationCompatibility` function in OpenAI plugin - Add comprehensive tests for image generation compatibility warnings - Add integration test scenarios for CLI image generation workflows - Suggest gpt-4o as alternative in incompatibility warning messages	2026-01-20 11:55:18 -08:00
Kayvan Sylvan	1e693cd5e8	Merge pull request #1948 from cleong14/pattern/create_bd_issue feat(patterns): add create_bd_issue pattern	2026-01-20 11:27:32 -08:00
Kayvan Sylvan	4fd1584518	chore: incoming 1948 changelog entry	2026-01-20 11:25:07 -08:00
Kayvan Sylvan	794a71a82b	Merge pull request #1947 from cleong14/pattern/extract_bd_ideas feat(patterns): add extract_bd_ideas pattern	2026-01-20 11:20:52 -08:00
Kayvan Sylvan	1e4ed78bcf	chore: incoming 1947 changelog entry	2026-01-20 11:20:13 -08:00
Chaz	360682eb6f	feat(patterns): add create_bd_issue pattern Transforms natural language issue descriptions into optimal bd (Beads) issue tracker commands. Features: - Comprehensive bd create flag reference - Intelligent type detection (bug, feature, task, epic, chore) - Priority assessment (P0-P4) based on urgency signals - Smart label selection (1-4 relevant labels) - Outputs clean, ready-to-execute commands Generated with [Claude Code](https://claude.ai/code) via [Happy](https://happy.engineering) Co-Authored-By: Claude <noreply@anthropic.com> Co-Authored-By: Happy <yesreply@happy.engineering>	2026-01-20 06:38:42 -10:00
Chaz	095dcd8434	feat(patterns): add extract_bd_ideas pattern Extracts actionable ideas from content and transforms them into well-structured bd (Beads) issue tracker commands. Features: - Identifies tasks, problems, ideas, improvements, bugs, and features - Evaluates actionability and appropriate scoping - Assigns priorities (P0-P4) and relevant labels - Outputs ready-to-execute bd create commands Generated with [Claude Code](https://claude.ai/code) via [Happy](https://happy.engineering) Co-Authored-By: Claude <noreply@anthropic.com> Co-Authored-By: Happy <yesreply@happy.engineering>	2026-01-20 06:38:14 -10:00
github-actions[bot]	fb407ccfed	chore(release): Update version to v1.4.384	2026-01-19 16:22:15 +00:00
Kayvan Sylvan	c9d4c19ef8	Merge pull request #1944 from ksylvan/1033_infermatic_provider Add Infermatic AI Provider Support	2026-01-19 08:19:57 -08:00
Kayvan Sylvan	f4e7489d42	chore: incoming 1944 changelog entry	2026-01-19 08:16:05 -08:00
Kayvan Sylvan	7012acd12a	fix: replace go-git status API with native git CLI for worktree compatibility - Replace go-git status API with native `git status --porcelain` command - Fix worktree detection issues caused by go-git library bugs - Simplify `IsWorkingDirectoryClean` to use CLI output parsing - Simplify `GetStatusDetails` to return raw porcelain output - Use native `git rev-parse HEAD` to get commit hash after commit - Remove unused `os` and `filepath` imports from walker.go - Remove complex worktree file existence checking logic	2026-01-19 08:15:22 -08:00
Kayvan Sylvan	387610bcf8	Add Infermatic provider test case Adds test coverage for the Infermatic AI provider in TestCreateClient to verify the provider exists and creates a valid client. Part of #1033: Add Infermatic AI provider support Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-19 06:38:38 -08:00
Kayvan Sylvan	9e1ee4d48e	WIP: Phase 1 - Add Infermatic provider to ProviderMap Issue: #1033 Phase: 1 of 2 Status: Pending verification Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>	2026-01-19 06:25:31 -08:00
github-actions[bot]	8706fbba3b	chore(release): Update version to v1.4.383	2026-01-18 18:21:20 +00:00
Kayvan Sylvan	b169576cd8	Merge pull request #1943 from ksylvan/fabric-ollama-server-ignores-context-window fix: Ollama server now respects the default context window	2026-01-18 10:18:39 -08:00
Kayvan Sylvan	da34f5823a	chore: refactor parseOllamaNumCtx for cleaner errors and type fixes ### CHANGES - Remove value from fractional part error message - Update overflow check to use float64 for consistency - Ensure error messages omit unnecessary details for clarity	2026-01-18 10:12:18 -08:00
Kayvan Sylvan	14358a1c1b	fix: Edit comments per review comments	2026-01-18 09:59:35 -08:00
Kayvan Sylvan	ce74e881be	fix: add validation for NaN, Inf, and negative values in `parseOllamaNumCtx` ## CHANGES - Add NaN and Infinity validation for float64 values - Add NaN and Infinity validation for float32 values - Add negative value check for int64 type - Add negative value check for json.Number type - Add comprehensive test cases for special float values - Add test cases for negative int64 and json.Number inputs - Update line reference comments for validation checks	2026-01-18 07:42:10 -08:00
Kayvan Sylvan	a4399000cf	chore: incoming 1943 changelog entry	2026-01-18 01:46:28 -08:00
Kayvan Sylvan	6f804d7e46	fix: changes based on PR review	2026-01-18 01:46:09 -08:00
Kayvan Sylvan	8c015b09a1	test: add comprehensive tests for `parseOllamaNumCtx` and simplify error handling - Add comprehensive unit tests for `parseOllamaNumCtx` function - Remove redundant negative value checks in float parsing - Simplify error messages to avoid exposing internal type info - Streamline error response in `ollamaChat` handler - Add helper functions for string containment in tests - Cover edge cases including overflow, invalid types, and boundaries	2026-01-18 01:34:03 -08:00
Kayvan Sylvan	03108cc69d	format fix	2026-01-18 01:02:46 -08:00
Kayvan Sylvan	556e098fc1	fix: Ollama server now respects the default context window This commit fixes the Ollama server /api/chat endpoint which was ignoring the client-provided num_ctx parameter and global DEFAULT_MODEL_CONTEXT_LENGTH, always using a hardcoded value of 2048 tokens. - Add parseOllamaNumCtx() function in ollama.go with type-safe extraction supporting 6 numeric types (float64, float32, int, int64, json.Number, string) - Extract num_ctx from client request options in ollamaChat() - Add ModelContextLength field to ChatRequest struct in chat.go - Replace hardcoded 2048 with request.ModelContextLength in GetChatter() call - Platform-aware integer overflow protection for 32-bit systems - DoS protection via 1,000,000 token maximum limit - Long string truncation in error messages (50 char limit) - Sanitized error messages (no internal stdlib details exposed) - Missing/null num_ctx returns (0, nil) to trigger existing default fallback - Zero API contract changes - Invalid values return 400 Bad Request with clear error messages - All existing tests pass - Compilation successful with no errors or warnings Fixes #1942	2026-01-18 00:47:37 -08:00