Get up and running with Kimi, GLM, MiniMax, DeepSeek, gpt-oss, Qwen, Gemma and other models.
x: agent loop ux improvements (#13635)
Parth Sareen12e2b3514ad4
diff --git a/cmd/cmd.go b/cmd/cmd.goindex 3cecbbe2f..f56a1d4b7 100644--- a/cmd/cmd.go+++ b/cmd/cmd.go@@ -520,6 +520,7 @@ func RunHandler(cmd *cobra.Command, args []string) error {// Check for experimental flagisExperimental, _ := cmd.Flags().GetBool("experimental")+ yoloMode, _ := cmd.Flags().GetBool("yolo")if interactive {if err := loadOrUnloadModel(cmd, &opts); err != nil {@@ -547,9 +548,9 @@ func RunHandler(cmd *cobra.Command, args []string) error {}}- // Use experimental agent loop with+ // Use experimental agent loop with toolsif isExperimental {- return xcmd.GenerateInteractive(cmd, opts.Model, opts.WordWrap, opts.Options, opts.Think, opts.HideThinking, opts.KeepAlive)+ return xcmd.GenerateInteractive(cmd, opts.Model, opts.WordWrap, opts.Options, opts.Think, opts.HideThinking, opts.KeepAlive, yoloMode)}return generateInteractive(cmd, opts)@@ -1764,6 +1765,7 @@ func NewCLI() *cobra.Command {runCmd.Flags().Bool("truncate", false, "For embedding models: truncate inputs exceeding context length (default: true). Set --truncate=false to error instead")runCmd.Flags().Int("dimensions", 0, "Truncate output embeddings to specified dimension (embedding models only)")runCmd.Flags().Bool("experimental", false, "Enable experimental agent loop with tools")+ runCmd.Flags().BoolP("yolo", "y", false, "Skip all tool approval prompts (use with caution)")stopCmd := &cobra.Command{Use: "stop MODEL",diff --git a/readline/errors.go b/readline/errors.goindex bb3fbd473..83c26e86e 100644--- a/readline/errors.go+++ b/readline/errors.go@@ -6,6 +6,9 @@ import (var ErrInterrupt = errors.New("Interrupt")+// ErrExpandOutput is returned when user presses Ctrl+O to expand tool output+var ErrExpandOutput = errors.New("ExpandOutput")+type InterruptError struct {Line []rune}diff --git a/readline/readline.go b/readline/readline.goindex c12327472..8bbef66fd 100644--- a/readline/readline.go+++ b/readline/readline.go@@ -206,6 +206,9 @@ func (i *Instance) Readline() (string, error) {buf.DeleteBefore()case CharCtrlL:buf.ClearScreen()+ case CharCtrlO:+ // Ctrl+O - expand tool output+ return "", ErrExpandOutputcase CharCtrlW:buf.DeleteWord()case CharCtrlZ:diff --git a/readline/types.go b/readline/types.goindex f4efa8d92..f1509f63f 100644--- a/readline/types.go+++ b/readline/types.go@@ -18,6 +18,7 @@ const (CharCtrlL = 12CharEnter = 13CharNext = 14+ CharCtrlO = 15 // Ctrl+O - used for expanding tool outputCharPrev = 16CharBckSearch = 18CharFwdSearch = 19diff --git a/x/agent/approval.go b/x/agent/approval.goindex e2d429ac6..3a160e4d9 100644--- a/x/agent/approval.go+++ b/x/agent/approval.go@@ -4,6 +4,7 @@ package agentimport ("fmt""os"+ "path""path/filepath""strings""sync"@@ -179,6 +180,7 @@ func FormatDeniedResult(command string, pattern string) string {// extractBashPrefix extracts a prefix pattern from a bash command.// For commands like "cat tools/tools_test.go | head -200", returns "cat:tools/"// For commands without path args, returns empty string.+// Paths with ".." traversal that escape the base directory return empty string for security.func extractBashPrefix(command string) string {// Split command by pipes and get the first partparts := strings.Split(command, "|")@@ -204,8 +206,8 @@ func extractBashPrefix(command string) string {return ""}- // Find the first path-like argument (must contain / or start with .)- // First pass: look for clear paths (containing / or starting with .)+ // Find the first path-like argument (must contain / or \ or start with .)+ // First pass: look for clear paths (containing path separators or starting with .)for _, arg := range fields[1:] {// Skip flagsif strings.HasPrefix(arg, "-") {@@ -215,19 +217,49 @@ func extractBashPrefix(command string) string {if isNumeric(arg) {continue}- // Only process if it looks like a path (contains / or starts with .)- if !strings.Contains(arg, "/") && !strings.HasPrefix(arg, ".") {+ // Only process if it looks like a path (contains / or \ or starts with .)+ if !strings.Contains(arg, "/") && !strings.Contains(arg, "\\") && !strings.HasPrefix(arg, ".") {continue}- // If arg ends with /, it's a directory - use it directly- if strings.HasSuffix(arg, "/") {- return fmt.Sprintf("%s:%s", baseCmd, arg)+ // Normalize to forward slashes for consistent cross-platform matching+ arg = strings.ReplaceAll(arg, "\\", "/")++ // Security: reject absolute paths+ if path.IsAbs(arg) {+ return "" // Absolute path - don't create prefix+ }++ // Normalize the path using stdlib path.Clean (resolves . and ..)+ cleaned := path.Clean(arg)++ // Security: reject if cleaned path escapes to parent directory+ if strings.HasPrefix(cleaned, "..") {+ return "" // Path escapes - don't create prefix}- // Get the directory part of a file path- dir := filepath.Dir(arg)++ // Security: if original had "..", verify cleaned path didn't escape to sibling+ // e.g., "tools/a/b/../../../etc" -> "etc" (escaped tools/ to sibling)+ if strings.Contains(arg, "..") {+ origBase := strings.SplitN(arg, "/", 2)[0]+ cleanedBase := strings.SplitN(cleaned, "/", 2)[0]+ if origBase != cleanedBase {+ return "" // Path escaped to sibling directory+ }+ }++ // Check if arg ends with / (explicit directory)+ isDir := strings.HasSuffix(arg, "/")++ // Get the directory part+ var dir string+ if isDir {+ dir = cleaned+ } else {+ dir = path.Dir(cleaned)+ }+if dir == "." {- // Path is just a directory like "tools" or "src" (no trailing /)- return fmt.Sprintf("%s:%s/", baseCmd, arg)+ return fmt.Sprintf("%s:./", baseCmd)}return fmt.Sprintf("%s:%s/", baseCmd, dir)}@@ -332,6 +364,8 @@ func AllowlistKey(toolName string, args map[string]any) string {}// IsAllowed checks if a tool/command is allowed (exact match or prefix match).+// For bash commands, hierarchical path matching is used - if "cat:tools/" is allowed,+// then "cat:tools/subdir/" is also allowed (subdirectories inherit parent permissions).func (a *ApprovalManager) IsAllowed(toolName string, args map[string]any) bool {a.mu.RLock()defer a.mu.RUnlock()@@ -342,12 +376,20 @@ func (a *ApprovalManager) IsAllowed(toolName string, args map[string]any) bool {return true}- // For bash commands, check prefix matches+ // For bash commands, check prefix matches with hierarchical path supportif toolName == "bash" {if cmd, ok := args["command"].(string); ok {prefix := extractBashPrefix(cmd)- if prefix != "" && a.prefixes[prefix] {- return true+ if prefix != "" {+ // Check exact prefix match first+ if a.prefixes[prefix] {+ return true+ }+ // Check hierarchical match: if any stored prefix is a parent of current prefix+ // e.g., stored "cat:tools/" should match current "cat:tools/subdir/"+ if a.matchesHierarchicalPrefix(prefix) {+ return true+ }}}}@@ -360,6 +402,40 @@ func (a *ApprovalManager) IsAllowed(toolName string, args map[string]any) bool {return false}+// matchesHierarchicalPrefix checks if the given prefix matches any stored prefix hierarchically.+// For example, if "cat:tools/" is stored, it will match "cat:tools/subdir/" or "cat:tools/a/b/c/".+func (a *ApprovalManager) matchesHierarchicalPrefix(currentPrefix string) bool {+ // Split prefix into command and path parts (format: "cmd:path/")+ colonIdx := strings.Index(currentPrefix, ":")+ if colonIdx == -1 {+ return false+ }+ currentCmd := currentPrefix[:colonIdx]+ currentPath := currentPrefix[colonIdx+1:]++ for storedPrefix := range a.prefixes {+ storedColonIdx := strings.Index(storedPrefix, ":")+ if storedColonIdx == -1 {+ continue+ }+ storedCmd := storedPrefix[:storedColonIdx]+ storedPath := storedPrefix[storedColonIdx+1:]++ // Commands must match exactly+ if currentCmd != storedCmd {+ continue+ }++ // Check if current path starts with stored path (hierarchical match)+ // e.g., "tools/subdir/" starts with "tools/"+ if strings.HasPrefix(currentPath, storedPath) {+ return true+ }+ }++ return false+}+// AddToAllowlist adds a tool/command to the session allowlist.// For bash commands, it adds the prefix pattern instead of exact command.func (a *ApprovalManager) AddToAllowlist(toolName string, args map[string]any) {@@ -443,11 +519,12 @@ func formatToolDisplay(toolName string, args map[string]any) string {}}- // For web search, show query+ // For web search, show query and internet noticeif toolName == "web_search" {if query, ok := args["query"].(string); ok {sb.WriteString(fmt.Sprintf("Tool: %s\n", toolName))- sb.WriteString(fmt.Sprintf("Query: %s", query))+ sb.WriteString(fmt.Sprintf("Query: %s\n", query))+ sb.WriteString("Uses internet via ollama.com")return sb.String()}}@@ -951,3 +1028,79 @@ func FormatDenyResult(toolName string, reason string) string {}return fmt.Sprintf("User denied execution of %s.", toolName)}++// PromptYesNo displays a simple Yes/No prompt and returns the user's choice.+// Returns true for Yes, false for No.+func PromptYesNo(question string) (bool, error) {+ fd := int(os.Stdin.Fd())+ oldState, err := term.MakeRaw(fd)+ if err != nil {+ return false, err+ }+ defer term.Restore(fd, oldState)++ selected := 0 // 0 = Yes, 1 = No+ options := []string{"Yes", "No"}++ // Hide cursor+ fmt.Fprint(os.Stderr, "\033[?25l")+ defer fmt.Fprint(os.Stderr, "\033[?25h")++ renderYesNo := func() {+ // Move to start of line and clear+ fmt.Fprintf(os.Stderr, "\r\033[K")+ fmt.Fprintf(os.Stderr, "\033[36m%s\033[0m ", question)+ for i, opt := range options {+ if i == selected {+ fmt.Fprintf(os.Stderr, "\033[1;32m[%s]\033[0m ", opt)+ } else {+ fmt.Fprintf(os.Stderr, "\033[90m %s \033[0m ", opt)+ }+ }+ fmt.Fprintf(os.Stderr, "\033[90m(←/→ or y/n, Enter to confirm)\033[0m")+ }++ renderYesNo()++ buf := make([]byte, 3)+ for {+ n, err := os.Stdin.Read(buf)+ if err != nil {+ return false, err+ }++ if n == 1 {+ switch buf[0] {+ case 'y', 'Y':+ selected = 0+ renderYesNo()+ case 'n', 'N':+ selected = 1+ renderYesNo()+ case '\r', '\n': // Enter+ fmt.Fprintf(os.Stderr, "\r\033[K") // Clear line+ return selected == 0, nil+ case 3: // Ctrl+C+ fmt.Fprintf(os.Stderr, "\r\033[K")+ return false, nil+ case 27: // Escape - could be arrow key+ // Read more bytes for arrow keys+ continue+ }+ } else if n == 3 && buf[0] == 27 && buf[1] == 91 {+ // Arrow keys+ switch buf[2] {+ case 'D': // Left+ if selected > 0 {+ selected--+ }+ renderYesNo()+ case 'C': // Right+ if selected < len(options)-1 {+ selected+++ }+ renderYesNo()+ }+ }+ }+}diff --git a/x/agent/approval_test.go b/x/agent/approval_test.goindex 652ca8c3b..a05ea3d42 100644--- a/x/agent/approval_test.go+++ b/x/agent/approval_test.go@@ -151,6 +151,27 @@ func TestExtractBashPrefix(t *testing.T) {command: "head -n 100",expected: "",},+ // Path traversal security tests+ {+ name: "path traversal - parent escape",+ command: "cat tools/../../etc/passwd",+ expected: "", // Should NOT create a prefix - path escapes+ },+ {+ name: "path traversal - deep escape",+ command: "cat tools/a/b/../../../etc/passwd",+ expected: "", // Normalizes to "../etc/passwd" - escapes+ },+ {+ name: "path traversal - absolute path",+ command: "cat /etc/passwd",+ expected: "", // Absolute paths should not create prefix+ },+ {+ name: "path with safe dotdot - normalized",+ command: "cat tools/subdir/../file.go",+ expected: "cat:tools/", // Normalizes to tools/file.go - safe, creates prefix+ },}for _, tt := range tests {@@ -164,6 +185,34 @@ func TestExtractBashPrefix(t *testing.T) {}}+func TestApprovalManager_PathTraversalBlocked(t *testing.T) {+ am := NewApprovalManager()++ // Allow "cat tools/file.go" - creates prefix "cat:tools/"+ am.AddToAllowlist("bash", map[string]any{"command": "cat tools/file.go"})++ // Path traversal attack: should NOT be allowed+ if am.IsAllowed("bash", map[string]any{"command": "cat tools/../../etc/passwd"}) {+ t.Error("SECURITY: path traversal attack should NOT be allowed")+ }++ // Another traversal variant+ if am.IsAllowed("bash", map[string]any{"command": "cat tools/../../../etc/shadow"}) {+ t.Error("SECURITY: deep path traversal should NOT be allowed")+ }++ // Valid subdirectory access should still work+ if !am.IsAllowed("bash", map[string]any{"command": "cat tools/subdir/file.go"}) {+ t.Error("expected cat tools/subdir/file.go to be allowed")+ }++ // Safe ".." that normalizes to within allowed directory should work+ // tools/subdir/../other.go normalizes to tools/other.go which is under tools/+ if !am.IsAllowed("bash", map[string]any{"command": "cat tools/subdir/../other.go"}) {+ t.Error("expected cat tools/subdir/../other.go to be allowed (normalizes to tools/other.go)")+ }+}+func TestApprovalManager_PrefixAllowlist(t *testing.T) {am := NewApprovalManager()@@ -186,6 +235,119 @@ func TestApprovalManager_PrefixAllowlist(t *testing.T) {}}+func TestApprovalManager_HierarchicalPrefixAllowlist(t *testing.T) {+ am := NewApprovalManager()++ // Allow "cat tools/file.go" - this creates prefix "cat:tools/"+ am.AddToAllowlist("bash", map[string]any{"command": "cat tools/file.go"})++ // Should allow subdirectories (hierarchical matching)+ if !am.IsAllowed("bash", map[string]any{"command": "cat tools/subdir/file.go"}) {+ t.Error("expected cat tools/subdir/file.go to be allowed via hierarchical prefix")+ }++ // Should allow deeply nested subdirectories+ if !am.IsAllowed("bash", map[string]any{"command": "cat tools/a/b/c/deep.go"}) {+ t.Error("expected cat tools/a/b/c/deep.go to be allowed via hierarchical prefix")+ }++ // Should still allow same directory+ if !am.IsAllowed("bash", map[string]any{"command": "cat tools/another.go"}) {+ t.Error("expected cat tools/another.go to be allowed")+ }++ // Should NOT allow different base directory+ if am.IsAllowed("bash", map[string]any{"command": "cat src/main.go"}) {+ t.Error("expected cat src/main.go to NOT be allowed")+ }++ // Should NOT allow different command even in subdirectory+ if am.IsAllowed("bash", map[string]any{"command": "ls tools/subdir/"}) {+ t.Error("expected ls tools/subdir/ to NOT be allowed (different command)")+ }++ // Should NOT allow similar but different directory name+ if am.IsAllowed("bash", map[string]any{"command": "cat toolsbin/file.go"}) {+ t.Error("expected cat toolsbin/file.go to NOT be allowed (different directory)")+ }+}++func TestApprovalManager_HierarchicalPrefixAllowlist_CrossPlatform(t *testing.T) {+ am := NewApprovalManager()++ // Allow with forward slashes (Unix-style)+ am.AddToAllowlist("bash", map[string]any{"command": "cat tools/file.go"})++ // Should work with backslashes too (Windows-style) - normalized internally+ if !am.IsAllowed("bash", map[string]any{"command": "cat tools\\subdir\\file.go"}) {+ t.Error("expected cat tools\\subdir\\file.go to be allowed via hierarchical prefix (Windows path)")+ }++ // Mixed slashes should also work+ if !am.IsAllowed("bash", map[string]any{"command": "cat tools\\a/b\\c/deep.go"}) {+ t.Error("expected mixed slash path to be allowed via hierarchical prefix")+ }+}++func TestMatchesHierarchicalPrefix(t *testing.T) {+ am := NewApprovalManager()++ // Add prefix for "cat:tools/"+ am.prefixes["cat:tools/"] = true++ tests := []struct {+ name string+ prefix string+ expected bool+ }{+ {+ name: "exact match",+ prefix: "cat:tools/",+ expected: true, // exact match also passes HasPrefix - caller handles exact match first+ },+ {+ name: "subdirectory",+ prefix: "cat:tools/subdir/",+ expected: true,+ },+ {+ name: "deeply nested",+ prefix: "cat:tools/a/b/c/",+ expected: true,+ },+ {+ name: "different base directory",+ prefix: "cat:src/",+ expected: false,+ },+ {+ name: "different command same path",+ prefix: "ls:tools/",+ expected: false,+ },+ {+ name: "similar directory name",+ prefix: "cat:toolsbin/",+ expected: false,+ },+ {+ name: "invalid prefix format",+ prefix: "cattools",+ expected: false,+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ result := am.matchesHierarchicalPrefix(tt.prefix)+ if result != tt.expected {+ t.Errorf("matchesHierarchicalPrefix(%q) = %v, expected %v",+ tt.prefix, result, tt.expected)+ }+ })+ }+}+func TestFormatApprovalResult(t *testing.T) {tests := []struct {name stringdiff --git a/x/cmd/run.go b/x/cmd/run.goindex 2a76a5592..178659e9f 100644--- a/x/cmd/run.go+++ b/x/cmd/run.go@@ -6,10 +6,12 @@ import ("errors""fmt""io"+ "net/url""os""os/signal""strings""syscall"+ "time""github.com/spf13/cobra""golang.org/x/term"@@ -22,6 +24,101 @@ import ("github.com/ollama/ollama/x/tools")+// Tool output capping constants+const (+ // localModelTokenLimit is the token limit for local models (smaller context).+ localModelTokenLimit = 4000++ // defaultTokenLimit is the token limit for cloud/remote models.+ defaultTokenLimit = 10000++ // charsPerToken is a rough estimate of characters per token.+ // TODO: Estimate tokens more accurately using tokenizer if available+ charsPerToken = 4+)++// isLocalModel checks if the model is running locally (not a cloud model).+// TODO: Improve local/cloud model identification - could check model metadata+func isLocalModel(modelName string) bool {+ return !strings.HasSuffix(modelName, "-cloud")+}++// isLocalServer checks if connecting to a local Ollama server.+// TODO: Could also check other indicators of local vs cloud server+func isLocalServer() bool {+ host := os.Getenv("OLLAMA_HOST")+ if host == "" {+ return true // Default is localhost:11434+ }++ // Parse the URL to check host+ parsed, err := url.Parse(host)+ if err != nil {+ return true // If can't parse, assume local+ }++ hostname := parsed.Hostname()+ return hostname == "localhost" || hostname == "127.0.0.1" || strings.Contains(parsed.Host, ":11434")+}++// truncateToolOutput truncates tool output to prevent context overflow.+// Uses a smaller limit (4k tokens) for local models, larger (10k) for cloud/remote.+func truncateToolOutput(output, modelName string) string {+ var tokenLimit int+ if isLocalModel(modelName) && isLocalServer() {+ tokenLimit = localModelTokenLimit+ } else {+ tokenLimit = defaultTokenLimit+ }++ maxChars := tokenLimit * charsPerToken+ if len(output) > maxChars {+ return output[:maxChars] + "\n... (output truncated)"+ }+ return output+}++// waitForOllamaSignin shows the signin URL and polls until authentication completes.+func waitForOllamaSignin(ctx context.Context) error {+ client, err := api.ClientFromEnvironment()+ if err != nil {+ return err+ }++ // Get signin URL from initial Whoami call+ _, err = client.Whoami(ctx)+ if err != nil {+ var aErr api.AuthorizationError+ if errors.As(err, &aErr) && aErr.SigninURL != "" {+ fmt.Fprintf(os.Stderr, "\n To sign in, navigate to:\n")+ fmt.Fprintf(os.Stderr, " \033[36m%s\033[0m\n\n", aErr.SigninURL)+ fmt.Fprintf(os.Stderr, " \033[90mWaiting for sign in to complete...\033[0m")++ // Poll until auth succeeds+ ticker := time.NewTicker(2 * time.Second)+ defer ticker.Stop()++ for {+ select {+ case <-ctx.Done():+ fmt.Fprintf(os.Stderr, "\n")+ return ctx.Err()+ case <-ticker.C:+ user, whoamiErr := client.Whoami(ctx)+ if whoamiErr == nil && user != nil && user.Name != "" {+ fmt.Fprintf(os.Stderr, "\r\033[K \033[32mSigned in as %s\033[0m\n", user.Name)+ return nil+ }+ // Still waiting, show dot+ fmt.Fprintf(os.Stderr, ".")+ }+ }+ }+ return err+ }+ return nil+}+// RunOptions contains options for running an interactive agent session.type RunOptions struct {Model string@@ -37,6 +134,16 @@ type RunOptions struct {// Agent fields (managed externally for session persistence)Tools *tools.RegistryApproval *agent.ApprovalManager++ // YoloMode skips all tool approval prompts+ YoloMode bool++ // LastToolOutput stores the full output of the last tool execution+ // for Ctrl+O expansion. Updated by Chat(), read by caller.+ LastToolOutput *string++ // LastToolOutputTruncated stores the truncated version shown inline+ LastToolOutputTruncated *string}// Chat runs an agent chat loop with tool support.@@ -77,6 +184,7 @@ func Chat(ctx context.Context, opts RunOptions) (*api.Message, error) {var thinkTagOpened bool = falsevar thinkTagClosed bool = falsevar pendingToolCalls []api.ToolCall+ var consecutiveErrors int // Track consecutive 500 errors for retry limitrole := "assistant"messages := opts.Messages@@ -159,6 +267,58 @@ func Chat(ctx context.Context, opts RunOptions) (*api.Message, error) {return nil, nil}+ // Check for 401 Unauthorized - prompt user to sign in+ var authErr api.AuthorizationError+ if errors.As(err, &authErr) {+ p.StopAndClear()+ fmt.Fprintf(os.Stderr, "\033[33mAuthentication required to use this cloud model.\033[0m\n")+ result, promptErr := agent.PromptYesNo("Sign in to Ollama?")+ if promptErr == nil && result {+ if signinErr := waitForOllamaSignin(ctx); signinErr == nil {+ // Retry the chat request+ fmt.Fprintf(os.Stderr, "\033[90mRetrying...\033[0m\n")+ continue // Retry the loop+ }+ }+ return nil, fmt.Errorf("authentication required - run 'ollama signin' to authenticate")+ }++ // Check for 500 errors (often tool parsing failures) - inform the model+ var statusErr api.StatusError+ if errors.As(err, &statusErr) && statusErr.StatusCode >= 500 {+ consecutiveErrors+++ p.StopAndClear()++ if consecutiveErrors >= 3 {+ fmt.Fprintf(os.Stderr, "\033[31m✗ Too many consecutive errors, giving up\033[0m\n")+ return nil, fmt.Errorf("too many consecutive server errors: %s", statusErr.ErrorMessage)+ }++ fmt.Fprintf(os.Stderr, "\033[33m⚠ Server error (attempt %d/3): %s\033[0m\n", consecutiveErrors, statusErr.ErrorMessage)++ // Include both the model's response and the error so it can learn+ assistantContent := fullResponse.String()+ if assistantContent == "" {+ assistantContent = "(empty response)"+ }+ errorMsg := fmt.Sprintf("Your previous response caused an error: %s\n\nYour response was:\n%s\n\nPlease try again with a valid response.", statusErr.ErrorMessage, assistantContent)+ messages = append(messages,+ api.Message{Role: "user", Content: errorMsg},+ )++ // Reset state and retry+ fullResponse.Reset()+ thinkingContent.Reset()+ thinkTagOpened = false+ thinkTagClosed = false+ pendingToolCalls = nil+ state = &displayResponseState{}+ p = progress.NewProgress(os.Stderr)+ spinner = progress.NewSpinner("")+ p.Add("", spinner)+ continue+ }+if strings.Contains(err.Error(), "upstream error") {p.StopAndClear()fmt.Println("An error occurred while processing your message. Please try again.")@@ -168,6 +328,9 @@ func Chat(ctx context.Context, opts RunOptions) (*api.Message, error) {return nil, err}+ // Reset consecutive error counter on success+ consecutiveErrors = 0+// If no tool calls, we're doneif len(pendingToolCalls) == 0 || toolRegistry == nil {break@@ -216,7 +379,12 @@ func Chat(ctx context.Context, opts RunOptions) (*api.Message, error) {}// Check approval (uses prefix matching for bash commands)- if !skipApproval && !approval.IsAllowed(toolName, args) {+ // In yolo mode, skip all approval prompts+ if opts.YoloMode {+ if !skipApproval {+ fmt.Fprintf(os.Stderr, "\033[90m▶ Running: %s\033[0m\n", formatToolShort(toolName, args))+ }+ } else if !skipApproval && !approval.IsAllowed(toolName, args) {result, err := approval.RequestApproval(toolName, args)if err != nil {fmt.Fprintf(os.Stderr, "Error requesting approval: %v\n", err)@@ -250,6 +418,23 @@ func Chat(ctx context.Context, opts RunOptions) (*api.Message, error) {// Execute the tooltoolResult, err := toolRegistry.Execute(call)if err != nil {+ // Check if web search needs authentication+ if errors.Is(err, tools.ErrWebSearchAuthRequired) {+ // Prompt user to sign in+ fmt.Fprintf(os.Stderr, "\033[33m Web search requires authentication.\033[0m\n")+ result, promptErr := agent.PromptYesNo("Sign in to Ollama?")+ if promptErr == nil && result {+ // Get signin URL and wait for auth completion+ if signinErr := waitForOllamaSignin(ctx); signinErr == nil {+ // Retry the web search+ fmt.Fprintf(os.Stderr, "\033[90m Retrying web search...\033[0m\n")+ toolResult, err = toolRegistry.Execute(call)+ if err == nil {+ goto toolSuccess+ }+ }+ }+ }fmt.Fprintf(os.Stderr, "\033[31m Error: %v\033[0m\n", err)toolResults = append(toolResults, api.Message{Role: "tool",@@ -258,20 +443,34 @@ func Chat(ctx context.Context, opts RunOptions) (*api.Message, error) {})continue}+ toolSuccess:// Display tool output (truncated for display)+ truncatedOutput := ""if toolResult != "" {output := toolResultif len(output) > 300 {- output = output[:300] + "... (truncated)"+ output = output[:300] + "... (truncated, press Ctrl+O to expand)"}+ truncatedOutput = output// Show result in grey, indentedfmt.Fprintf(os.Stderr, "\033[90m %s\033[0m\n", strings.ReplaceAll(output, "\n", "\n "))}+ // Store full and truncated output for Ctrl+O toggle+ if opts.LastToolOutput != nil {+ *opts.LastToolOutput = toolResult+ }+ if opts.LastToolOutputTruncated != nil {+ *opts.LastToolOutputTruncated = truncatedOutput+ }++ // Truncate output to prevent context overflow+ toolResultForLLM := truncateToolOutput(toolResult, opts.Model)+toolResults = append(toolResults, api.Message{Role: "tool",- Content: toolResult,+ Content: toolResultForLLM,ToolCallID: call.ID,})}@@ -449,7 +648,8 @@ func checkModelCapabilities(ctx context.Context, modelName string) (supportsTool// GenerateInteractive runs an interactive agent session.// This is called from cmd.go when --experimental flag is set.-func GenerateInteractive(cmd *cobra.Command, modelName string, wordWrap bool, options map[string]any, think *api.ThinkValue, hideThinking bool, keepAlive *api.Duration) error {+// If yoloMode is true, all tool approvals are skipped.+func GenerateInteractive(cmd *cobra.Command, modelName string, wordWrap bool, options map[string]any, think *api.ThinkValue, hideThinking bool, keepAlive *api.Duration, yoloMode bool) error {scanner, err := readline.New(readline.Prompt{Prompt: ">>> ",AltPrompt: "... ",@@ -474,11 +674,11 @@ func GenerateInteractive(cmd *cobra.Command, modelName string, wordWrap bool, opvar toolRegistry *tools.Registryif supportsTools {toolRegistry = tools.DefaultRegistry()- fmt.Fprintf(os.Stderr, "Tools available: %s\n", strings.Join(toolRegistry.Names(), ", "))-- // Check for OLLAMA_API_KEY for web search- if os.Getenv("OLLAMA_API_KEY") == "" {- fmt.Fprintf(os.Stderr, "\033[33mWarning: OLLAMA_API_KEY not set - web search will not work\033[0m\n")+ if toolRegistry.Count() > 0 {+ fmt.Fprintf(os.Stderr, "\033[90mTools available: %s\033[0m\n", strings.Join(toolRegistry.Names(), ", "))+ }+ if yoloMode {+ fmt.Fprintf(os.Stderr, "\033[33m⚠ YOLO mode: All tool approvals will be skipped\033[0m\n")}} else {fmt.Fprintf(os.Stderr, "\033[33mNote: Model does not support tools - running in chat-only mode\033[0m\n")@@ -490,6 +690,11 @@ func GenerateInteractive(cmd *cobra.Command, modelName string, wordWrap bool, opvar messages []api.Messagevar sb strings.Builder+ // Track last tool output for Ctrl+O toggle+ var lastToolOutput string+ var lastToolOutputTruncated string+ var toolOutputExpanded bool+for {line, err := scanner.Readline()switch {@@ -502,6 +707,20 @@ func GenerateInteractive(cmd *cobra.Command, modelName string, wordWrap bool, op}sb.Reset()continue+ case errors.Is(err, readline.ErrExpandOutput):+ // Ctrl+O pressed - toggle between expanded and collapsed tool output+ if lastToolOutput == "" {+ fmt.Fprintf(os.Stderr, "\033[90mNo tool output to expand\033[0m\n")+ } else if toolOutputExpanded {+ // Currently expanded, show truncated+ fmt.Fprintf(os.Stderr, "\033[90m %s\033[0m\n", strings.ReplaceAll(lastToolOutputTruncated, "\n", "\n "))+ toolOutputExpanded = false+ } else {+ // Currently collapsed, show full+ fmt.Fprintf(os.Stderr, "\033[90m %s\033[0m\n", strings.ReplaceAll(lastToolOutput, "\n", "\n "))+ toolOutputExpanded = true+ }+ continuecase err != nil:return err}@@ -524,6 +743,9 @@ func GenerateInteractive(cmd *cobra.Command, modelName string, wordWrap bool, opfmt.Fprintln(os.Stderr, " /bye Exit")fmt.Fprintln(os.Stderr, " /?, /help Help for a command")fmt.Fprintln(os.Stderr, "")+ fmt.Fprintln(os.Stderr, "Keyboard Shortcuts:")+ fmt.Fprintln(os.Stderr, " Ctrl+O Expand last tool output")+ fmt.Fprintln(os.Stderr, "")continuecase strings.HasPrefix(line, "/"):fmt.Printf("Unknown command '%s'. Type /? for help\n", strings.Fields(line)[0])@@ -537,16 +759,21 @@ func GenerateInteractive(cmd *cobra.Command, modelName string, wordWrap bool, opmessages = append(messages, newMessage)opts := RunOptions{- Model: modelName,- Messages: messages,- WordWrap: wordWrap,- Options: options,- Think: think,- HideThinking: hideThinking,- KeepAlive: keepAlive,- Tools: toolRegistry,- Approval: approval,+ Model: modelName,+ Messages: messages,+ WordWrap: wordWrap,+ Options: options,+ Think: think,+ HideThinking: hideThinking,+ KeepAlive: keepAlive,+ Tools: toolRegistry,+ Approval: approval,+ YoloMode: yoloMode,+ LastToolOutput: &lastToolOutput,+ LastToolOutputTruncated: &lastToolOutputTruncated,}+ // Reset expanded state for new tool execution+ toolOutputExpanded = falseassistant, err := Chat(cmd.Context(), opts)if err != nil {diff --git a/x/cmd/run_test.go b/x/cmd/run_test.gonew file mode 100644index 000000000..a65e8cc80--- /dev/null+++ b/x/cmd/run_test.go@@ -0,0 +1,180 @@+package cmd++import (+ "testing"+)++func TestIsLocalModel(t *testing.T) {+ tests := []struct {+ name string+ modelName string+ expected bool+ }{+ {+ name: "local model without suffix",+ modelName: "llama3.2",+ expected: true,+ },+ {+ name: "local model with version",+ modelName: "qwen2.5:7b",+ expected: true,+ },+ {+ name: "cloud model",+ modelName: "gpt-4-cloud",+ expected: false,+ },+ {+ name: "cloud model with version",+ modelName: "claude-3-cloud",+ expected: false,+ },+ {+ name: "empty model name",+ modelName: "",+ expected: true,+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ result := isLocalModel(tt.modelName)+ if result != tt.expected {+ t.Errorf("isLocalModel(%q) = %v, expected %v", tt.modelName, result, tt.expected)+ }+ })+ }+}++func TestIsLocalServer(t *testing.T) {+ tests := []struct {+ name string+ host string+ expected bool+ }{+ {+ name: "empty host (default)",+ host: "",+ expected: true,+ },+ {+ name: "localhost",+ host: "http://localhost:11434",+ expected: true,+ },+ {+ name: "127.0.0.1",+ host: "http://127.0.0.1:11434",+ expected: true,+ },+ {+ name: "custom port on localhost",+ host: "http://localhost:8080",+ expected: true, // localhost is always considered local+ },+ {+ name: "remote host",+ host: "http://ollama.example.com:11434",+ expected: true, // has :11434+ },+ {+ name: "remote host different port",+ host: "http://ollama.example.com:8080",+ expected: false,+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ t.Setenv("OLLAMA_HOST", tt.host)+ result := isLocalServer()+ if result != tt.expected {+ t.Errorf("isLocalServer() with OLLAMA_HOST=%q = %v, expected %v", tt.host, result, tt.expected)+ }+ })+ }+}++func TestTruncateToolOutput(t *testing.T) {+ // Create outputs of different sizes+ localLimitOutput := make([]byte, 20000) // > 4k tokens (16k chars)+ defaultLimitOutput := make([]byte, 50000) // > 10k tokens (40k chars)+ for i := range localLimitOutput {+ localLimitOutput[i] = 'a'+ }+ for i := range defaultLimitOutput {+ defaultLimitOutput[i] = 'b'+ }++ tests := []struct {+ name string+ output string+ modelName string+ host string+ shouldTrim bool+ expectedLimit int+ }{+ {+ name: "short output local model",+ output: "hello world",+ modelName: "llama3.2",+ host: "",+ shouldTrim: false,+ expectedLimit: localModelTokenLimit,+ },+ {+ name: "long output local model - trimmed at 4k",+ output: string(localLimitOutput),+ modelName: "llama3.2",+ host: "",+ shouldTrim: true,+ expectedLimit: localModelTokenLimit,+ },+ {+ name: "long output cloud model - uses 10k limit",+ output: string(localLimitOutput), // 20k chars, under 10k token limit+ modelName: "gpt-4-cloud",+ host: "",+ shouldTrim: false,+ expectedLimit: defaultTokenLimit,+ },+ {+ name: "very long output cloud model - trimmed at 10k",+ output: string(defaultLimitOutput),+ modelName: "gpt-4-cloud",+ host: "",+ shouldTrim: true,+ expectedLimit: defaultTokenLimit,+ },+ {+ name: "long output remote server - uses 10k limit",+ output: string(localLimitOutput),+ modelName: "llama3.2",+ host: "http://remote.example.com:8080",+ shouldTrim: false,+ expectedLimit: defaultTokenLimit,+ },+ }++ for _, tt := range tests {+ t.Run(tt.name, func(t *testing.T) {+ t.Setenv("OLLAMA_HOST", tt.host)+ result := truncateToolOutput(tt.output, tt.modelName)++ if tt.shouldTrim {+ maxLen := tt.expectedLimit * charsPerToken+ if len(result) > maxLen+50 { // +50 for the truncation message+ t.Errorf("expected output to be truncated to ~%d chars, got %d", maxLen, len(result))+ }+ if result == tt.output {+ t.Error("expected output to be truncated but it wasn't")+ }+ } else {+ if result != tt.output {+ t.Error("expected output to not be truncated")+ }+ }+ })+ }+}diff --git a/x/tools/registry.go b/x/tools/registry.goindex f9136c9d7..fba0898b7 100644--- a/x/tools/registry.go+++ b/x/tools/registry.go@@ -3,6 +3,7 @@ package toolsimport ("fmt"+ "os""sort""github.com/ollama/ollama/api"@@ -88,9 +89,16 @@ func (r *Registry) Count() int {}// DefaultRegistry creates a registry with all built-in tools.+// Tools can be disabled via environment variables:+// - OLLAMA_AGENT_DISABLE_WEBSEARCH=1 disables web_search+// - OLLAMA_AGENT_DISABLE_BASH=1 disables bashfunc DefaultRegistry() *Registry {r := NewRegistry()- r.Register(&WebSearchTool{})- r.Register(&BashTool{})+ if os.Getenv("OLLAMA_AGENT_DISABLE_WEBSEARCH") == "" {+ r.Register(&WebSearchTool{})+ }+ if os.Getenv("OLLAMA_AGENT_DISABLE_BASH") == "" {+ r.Register(&BashTool{})+ }return r}diff --git a/x/tools/registry_test.go b/x/tools/registry_test.goindex 59539c721..a37410936 100644--- a/x/tools/registry_test.go+++ b/x/tools/registry_test.go@@ -108,6 +108,57 @@ func TestDefaultRegistry(t *testing.T) {}}+func TestDefaultRegistry_DisableWebsearch(t *testing.T) {+ t.Setenv("OLLAMA_AGENT_DISABLE_WEBSEARCH", "1")++ r := DefaultRegistry()++ if r.Count() != 1 {+ t.Errorf("expected 1 tool with websearch disabled, got %d", r.Count())+ }++ _, ok := r.Get("bash")+ if !ok {+ t.Error("expected bash tool in registry")+ }++ _, ok = r.Get("web_search")+ if ok {+ t.Error("expected web_search to be disabled")+ }+}++func TestDefaultRegistry_DisableBash(t *testing.T) {+ t.Setenv("OLLAMA_AGENT_DISABLE_BASH", "1")++ r := DefaultRegistry()++ if r.Count() != 1 {+ t.Errorf("expected 1 tool with bash disabled, got %d", r.Count())+ }++ _, ok := r.Get("web_search")+ if !ok {+ t.Error("expected web_search tool in registry")+ }++ _, ok = r.Get("bash")+ if ok {+ t.Error("expected bash to be disabled")+ }+}++func TestDefaultRegistry_DisableBoth(t *testing.T) {+ t.Setenv("OLLAMA_AGENT_DISABLE_WEBSEARCH", "1")+ t.Setenv("OLLAMA_AGENT_DISABLE_BASH", "1")++ r := DefaultRegistry()++ if r.Count() != 0 {+ t.Errorf("expected 0 tools with both disabled, got %d", r.Count())+ }+}+func TestBashTool_Schema(t *testing.T) {tool := &BashTool{}diff --git a/x/tools/websearch.go b/x/tools/websearch.goindex 04c3578e1..16b0dde2c 100644--- a/x/tools/websearch.go+++ b/x/tools/websearch.go@@ -2,15 +2,19 @@ package toolsimport ("bytes"+ "context""encoding/json"+ "errors""fmt""io""net/http"- "os"+ "net/url"+ "strconv""strings""time""github.com/ollama/ollama/api"+ "github.com/ollama/ollama/auth")const (@@ -18,6 +22,9 @@ const (webSearchTimeout = 15 * time.Second)+// ErrWebSearchAuthRequired is returned when web search requires authentication+var ErrWebSearchAuthRequired = errors.New("web search requires authentication")+// WebSearchTool implements web search using Ollama's hosted API.type WebSearchTool struct{}@@ -68,17 +75,13 @@ type webSearchResult struct {}// Execute performs the web search.+// Uses Ollama key signing for authentication - this makes requests via ollama.com API.func (w *WebSearchTool) Execute(args map[string]any) (string, error) {query, ok := args["query"].(string)if !ok || query == "" {return "", fmt.Errorf("query parameter is required")}- apiKey := os.Getenv("OLLAMA_API_KEY")- if apiKey == "" {- return "", fmt.Errorf("OLLAMA_API_KEY environment variable is required for web search")- }-// Prepare requestreqBody := webSearchRequest{Query: query,@@ -90,13 +93,34 @@ func (w *WebSearchTool) Execute(args map[string]any) (string, error) {return "", fmt.Errorf("marshaling request: %w", err)}- req, err := http.NewRequest("POST", webSearchAPI, bytes.NewBuffer(jsonBody))+ // Parse URL and add timestamp for signing+ searchURL, err := url.Parse(webSearchAPI)+ if err != nil {+ return "", fmt.Errorf("parsing search URL: %w", err)+ }++ q := searchURL.Query()+ q.Add("ts", strconv.FormatInt(time.Now().Unix(), 10))+ searchURL.RawQuery = q.Encode()++ // Sign the request using Ollama key (~/.ollama/id_ed25519)+ // This authenticates with ollama.com using the local signing key+ ctx := context.Background()+ data := fmt.Appendf(nil, "%s,%s", http.MethodPost, searchURL.RequestURI())+ signature, err := auth.Sign(ctx, data)+ if err != nil {+ return "", fmt.Errorf("signing request: %w", err)+ }++ req, err := http.NewRequestWithContext(ctx, http.MethodPost, searchURL.String(), bytes.NewBuffer(jsonBody))if err != nil {return "", fmt.Errorf("creating request: %w", err)}req.Header.Set("Content-Type", "application/json")- req.Header.Set("Authorization", "Bearer "+apiKey)+ if signature != "" {+ req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", signature))+ }// Send requestclient := &http.Client{Timeout: webSearchTimeout}@@ -111,6 +135,9 @@ func (w *WebSearchTool) Execute(args map[string]any) (string, error) {return "", fmt.Errorf("reading response: %w", err)}+ if resp.StatusCode == http.StatusUnauthorized {+ return "", ErrWebSearchAuthRequired+ }if resp.StatusCode != http.StatusOK {return "", fmt.Errorf("web search API returned status %d: %s", resp.StatusCode, string(body))}diff --git a/x/tools/websearch_test.go b/x/tools/websearch_test.gonew file mode 100644index 000000000..8f5774728--- /dev/null+++ b/x/tools/websearch_test.go@@ -0,0 +1,58 @@+package tools++import (+ "errors"+ "testing"+)++func TestWebSearchTool_Name(t *testing.T) {+ tool := &WebSearchTool{}+ if tool.Name() != "web_search" {+ t.Errorf("expected name 'web_search', got '%s'", tool.Name())+ }+}++func TestWebSearchTool_Description(t *testing.T) {+ tool := &WebSearchTool{}+ if tool.Description() == "" {+ t.Error("expected non-empty description")+ }+}++func TestWebSearchTool_Execute_MissingQuery(t *testing.T) {+ tool := &WebSearchTool{}++ // Test with no query+ _, err := tool.Execute(map[string]any{})+ if err == nil {+ t.Error("expected error for missing query")+ }++ // Test with empty query+ _, err = tool.Execute(map[string]any{"query": ""})+ if err == nil {+ t.Error("expected error for empty query")+ }+}++func TestErrWebSearchAuthRequired(t *testing.T) {+ // Test that the error type exists and can be checked with errors.Is+ err := ErrWebSearchAuthRequired+ if err == nil {+ t.Fatal("ErrWebSearchAuthRequired should not be nil")+ }++ if err.Error() != "web search requires authentication" {+ t.Errorf("unexpected error message: %s", err.Error())+ }++ // Test that errors.Is works+ wrappedErr := errors.New("wrapped: " + err.Error())+ if errors.Is(wrappedErr, ErrWebSearchAuthRequired) {+ t.Error("wrapped error should not match with errors.Is")+ }++ if !errors.Is(ErrWebSearchAuthRequired, ErrWebSearchAuthRequired) {+ t.Error("ErrWebSearchAuthRequired should match itself with errors.Is")+ }+}