Get up and running with Kimi, GLM, MiniMax, DeepSeek, gpt-oss, Qwen, Gemma and other models.
x/cmd: enable web search and web fetch with flag (#13690)
Parth Sareend06acbcb199d
diff --git a/cmd/cmd.go b/cmd/cmd.goindex 8a0811638..09940bda5 100644--- a/cmd/cmd.go+++ b/cmd/cmd.go@@ -537,6 +537,7 @@ func RunHandler(cmd *cobra.Command, args []string) error {// Check for experimental flagisExperimental, _ := cmd.Flags().GetBool("experimental")yoloMode, _ := cmd.Flags().GetBool("experimental-yolo")+ enableWebsearch, _ := cmd.Flags().GetBool("experimental-websearch")if interactive {if err := loadOrUnloadModel(cmd, &opts); err != nil {@@ -566,7 +567,7 @@ func RunHandler(cmd *cobra.Command, args []string) error {// Use experimental agent loop with toolsif isExperimental {- return xcmd.GenerateInteractive(cmd, opts.Model, opts.WordWrap, opts.Options, opts.Think, opts.HideThinking, opts.KeepAlive, yoloMode)+ return xcmd.GenerateInteractive(cmd, opts.Model, opts.WordWrap, opts.Options, opts.Think, opts.HideThinking, opts.KeepAlive, yoloMode, enableWebsearch)}return generateInteractive(cmd, opts)@@ -1786,6 +1787,7 @@ func NewCLI() *cobra.Command {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().Bool("experimental-yolo", false, "Skip all tool approval prompts (use with caution)")+ runCmd.Flags().Bool("experimental-websearch", false, "Enable web search tool in experimental mode")// Image generation flags (width, height, steps, seed, etc.)imagegen.RegisterFlags(runCmd)diff --git a/x/agent/approval.go b/x/agent/approval.goindex 1e1f3f0d2..fa1084260 100644--- a/x/agent/approval.go+++ b/x/agent/approval.go@@ -41,6 +41,7 @@ var optionLabels = []string{var toolDisplayNames = map[string]string{"bash": "Bash","web_search": "Web Search",+ "web_fetch": "Web Fetch",}// ToolDisplayName returns the human-readable display name for a tool.@@ -565,6 +566,16 @@ func formatToolDisplay(toolName string, args map[string]any) string {}}+ // For web fetch, show URL and internet notice+ if toolName == "web_fetch" {+ if url, ok := args["url"].(string); ok {+ sb.WriteString(fmt.Sprintf("Tool: %s\n", displayName))+ sb.WriteString(fmt.Sprintf("URL: %s\n", url))+ sb.WriteString("Uses internet via ollama.com")+ return sb.String()+ }+ }+// Generic displaysb.WriteString(fmt.Sprintf("Tool: %s", displayName))if len(args) > 0 {@@ -1017,6 +1028,16 @@ func FormatApprovalResult(toolName string, args map[string]any, result ApprovalR}}+ if toolName == "web_fetch" {+ if url, ok := args["url"].(string); ok {+ // Truncate long URLs+ if len(url) > 50 {+ url = url[:47] + "..."+ }+ return fmt.Sprintf("\033[1m%s:\033[0m %s: %s", label, displayName, url)+ }+ }+return fmt.Sprintf("\033[1m%s:\033[0m %s", label, displayName)}diff --git a/x/cmd/run.go b/x/cmd/run.goindex db5522f5e..f32254ebe 100644--- a/x/cmd/run.go+++ b/x/cmd/run.go@@ -650,7 +650,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.// 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 {+// If enableWebsearch is true, the web search tool is registered.+func GenerateInteractive(cmd *cobra.Command, modelName string, wordWrap bool, options map[string]any, think *api.ThinkValue, hideThinking bool, keepAlive *api.Duration, yoloMode bool, enableWebsearch bool) error {scanner, err := readline.New(readline.Prompt{Prompt: ">>> ",AltPrompt: "... ",@@ -676,6 +677,12 @@ func GenerateInteractive(cmd *cobra.Command, modelName string, wordWrap bool, opif supportsTools {toolRegistry = tools.DefaultRegistry()+ // Register web search and web fetch tools if enabled via flag+ if enableWebsearch {+ toolRegistry.RegisterWebSearch()+ toolRegistry.RegisterWebFetch()+ }+if toolRegistry.Has("bash") {fmt.Fprintln(os.Stderr)fmt.Fprintln(os.Stderr, "This experimental version of Ollama has the \033[1mbash\033[0m tool enabled.")@@ -683,6 +690,11 @@ func GenerateInteractive(cmd *cobra.Command, modelName string, wordWrap bool, opfmt.Fprintln(os.Stderr)}+ if toolRegistry.Has("web_search") || toolRegistry.Has("web_fetch") {+ fmt.Fprintln(os.Stderr, "The \033[1mWeb Search\033[0m and \033[1mWeb Fetch\033[0m tools are enabled. Models can search and fetch web content via ollama.com.")+ fmt.Fprintln(os.Stderr)+ }+if yoloMode {fmt.Fprintf(os.Stderr, "\033[1mwarning:\033[0m yolo mode - all tool approvals will be skipped\n")}diff --git a/x/tools/registry.go b/x/tools/registry.goindex 881a61bb5..8a43db0dc 100644--- a/x/tools/registry.go+++ b/x/tools/registry.go@@ -54,6 +54,16 @@ func (r *Registry) RegisterBash() {r.Register(&BashTool{})}+// RegisterWebSearch adds the web search tool to the registry.+func (r *Registry) RegisterWebSearch() {+ r.Register(&WebSearchTool{})+}++// RegisterWebFetch adds the web fetch tool to the registry.+func (r *Registry) RegisterWebFetch() {+ r.Register(&WebFetchTool{})+}+// Get retrieves a tool by name.func (r *Registry) Get(name string) (Tool, bool) {tool, ok := r.tools[name]diff --git a/x/tools/webfetch.go b/x/tools/webfetch.gonew file mode 100644index 000000000..82a006233--- /dev/null+++ b/x/tools/webfetch.go@@ -0,0 +1,162 @@+package tools++import (+ "bytes"+ "context"+ "encoding/json"+ "errors"+ "fmt"+ "io"+ "net/http"+ "net/url"+ "strconv"+ "strings"+ "time"++ "github.com/ollama/ollama/api"+ "github.com/ollama/ollama/auth"+)++const (+ webFetchAPI = "https://ollama.com/api/web_fetch"+ webFetchTimeout = 30 * time.Second+)++// ErrWebFetchAuthRequired is returned when web fetch requires authentication+var ErrWebFetchAuthRequired = errors.New("web fetch requires authentication")++// WebFetchTool implements web page fetching using Ollama's hosted API.+type WebFetchTool struct{}++// Name returns the tool name.+func (w *WebFetchTool) Name() string {+ return "web_fetch"+}++// Description returns a description of the tool.+func (w *WebFetchTool) Description() string {+ return "Fetch and extract text content from a web page. Use this to read the full content of a URL found in search results or provided by the user."+}++// Schema returns the tool's parameter schema.+func (w *WebFetchTool) Schema() api.ToolFunction {+ props := api.NewToolPropertiesMap()+ props.Set("url", api.ToolProperty{+ Type: api.PropertyType{"string"},+ Description: "The URL to fetch and extract content from",+ })+ return api.ToolFunction{+ Name: w.Name(),+ Description: w.Description(),+ Parameters: api.ToolFunctionParameters{+ Type: "object",+ Properties: props,+ Required: []string{"url"},+ },+ }+}++// webFetchRequest is the request body for the web fetch API.+type webFetchRequest struct {+ URL string `json:"url"`+}++// webFetchResponse is the response from the web fetch API.+type webFetchResponse struct {+ Title string `json:"title"`+ Content string `json:"content"`+ Links []string `json:"links,omitempty"`+}++// Execute fetches content from a web page.+// Uses Ollama key signing for authentication - this makes requests via ollama.com API.+func (w *WebFetchTool) Execute(args map[string]any) (string, error) {+ urlStr, ok := args["url"].(string)+ if !ok || urlStr == "" {+ return "", fmt.Errorf("url parameter is required")+ }++ // Validate URL+ if _, err := url.Parse(urlStr); err != nil {+ return "", fmt.Errorf("invalid URL: %w", err)+ }++ // Prepare request+ reqBody := webFetchRequest{+ URL: urlStr,+ }++ jsonBody, err := json.Marshal(reqBody)+ if err != nil {+ return "", fmt.Errorf("marshaling request: %w", err)+ }++ // Parse URL and add timestamp for signing+ fetchURL, err := url.Parse(webFetchAPI)+ if err != nil {+ return "", fmt.Errorf("parsing fetch URL: %w", err)+ }++ q := fetchURL.Query()+ q.Add("ts", strconv.FormatInt(time.Now().Unix(), 10))+ fetchURL.RawQuery = q.Encode()++ // Sign the request using Ollama key (~/.ollama/id_ed25519)+ ctx := context.Background()+ data := fmt.Appendf(nil, "%s,%s", http.MethodPost, fetchURL.RequestURI())+ signature, err := auth.Sign(ctx, data)+ if err != nil {+ return "", fmt.Errorf("signing request: %w", err)+ }++ req, err := http.NewRequestWithContext(ctx, http.MethodPost, fetchURL.String(), bytes.NewBuffer(jsonBody))+ if err != nil {+ return "", fmt.Errorf("creating request: %w", err)+ }++ req.Header.Set("Content-Type", "application/json")+ if signature != "" {+ req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", signature))+ }++ // Send request+ client := &http.Client{Timeout: webFetchTimeout}+ resp, err := client.Do(req)+ if err != nil {+ return "", fmt.Errorf("sending request: %w", err)+ }+ defer resp.Body.Close()++ body, err := io.ReadAll(resp.Body)+ if err != nil {+ return "", fmt.Errorf("reading response: %w", err)+ }++ if resp.StatusCode == http.StatusUnauthorized {+ return "", ErrWebFetchAuthRequired+ }+ if resp.StatusCode != http.StatusOK {+ return "", fmt.Errorf("web fetch API returned status %d: %s", resp.StatusCode, string(body))+ }++ // Parse response+ var fetchResp webFetchResponse+ if err := json.Unmarshal(body, &fetchResp); err != nil {+ return "", fmt.Errorf("parsing response: %w", err)+ }++ // Format result+ var sb strings.Builder+ if fetchResp.Title != "" {+ sb.WriteString(fmt.Sprintf("Title: %s\n\n", fetchResp.Title))+ }++ if fetchResp.Content != "" {+ sb.WriteString("Content:\n")+ sb.WriteString(fetchResp.Content)+ } else {+ sb.WriteString("No content could be extracted from the page.")+ }++ return sb.String(), nil+}