handle errors correctly in the other tools

kujtimiihoxha · kujtimiihoxha · commit 0b3e5f5bd42a · 2025-04-21T13:41:27.000+02:00
diff --git a/internal/llm/tools/edit.go b/internal/llm/tools/edit.go
@@ -27,8 +27,9 @@ type EditPermissionsParams struct {
 }
 
 type EditResponseMetadata struct {
-	Additions int `json:"additions"`
-	Removals  int `json:"removals"`
+	Diff      string `json:"diff"`
+	Additions int    `json:"additions"`
+	Removals  int    `json:"removals"`
 }
 
 type editTool struct {
@@ -216,6 +217,7 @@ func (e *editTool) createNewFile(ctx context.Context, filePath, content string)
 	return WithResponseMetadata(
 		NewTextResponse("File created: "+filePath),
 		EditResponseMetadata{
+			Diff:      diff,
 			Additions: stats.Additions,
 			Removals:  stats.Removals,
 		},
@@ -308,6 +310,7 @@ func (e *editTool) deleteContent(ctx context.Context, filePath, oldString string
 	return WithResponseMetadata(
 		NewTextResponse("Content deleted from file: "+filePath),
 		EditResponseMetadata{
+			Diff:      diff,
 			Additions: stats.Additions,
 			Removals:  stats.Removals,
 		},
@@ -401,6 +404,7 @@ func (e *editTool) replaceContent(ctx context.Context, filePath, oldString, newS
 	return WithResponseMetadata(
 		NewTextResponse("Content replaced in file: "+filePath),
 		EditResponseMetadata{
+			Diff:      diff,
 			Additions: stats.Additions,
 			Removals:  stats.Removals,
 		}), nil
diff --git a/internal/llm/tools/fetch.go b/internal/llm/tools/fetch.go
@@ -86,6 +86,7 @@ func (t *fetchTool) Info() ToolInfo {
 			"format": map[string]any{
 				"type":        "string",
 				"description": "The format to return the content in (text, markdown, or html)",
+				"enum":        []string{"text", "markdown", "html"},
 			},
 			"timeout": map[string]any{
 				"type":        "number",
@@ -126,7 +127,7 @@ func (t *fetchTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error
 	)
 
 	if !p {
-		return NewTextErrorResponse("Permission denied to fetch from URL: " + params.URL), nil
+		return ToolResponse{}, permission.ErrorPermissionDenied
 	}
 
 	client := t.client
@@ -142,14 +143,14 @@ func (t *fetchTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error
 
 	req, err := http.NewRequestWithContext(ctx, "GET", params.URL, nil)
 	if err != nil {
-		return NewTextErrorResponse("Failed to create request: " + err.Error()), nil
+		return ToolResponse{}, fmt.Errorf("failed to create request: %w", err)
 	}
 
 	req.Header.Set("User-Agent", "termai/1.0")
 
 	resp, err := client.Do(req)
 	if err != nil {
-		return NewTextErrorResponse("Failed to execute request: " + err.Error()), nil
+		return ToolResponse{}, fmt.Errorf("failed to fetch URL: %w", err)
 	}
 	defer resp.Body.Close()
 
diff --git a/internal/llm/tools/glob.go b/internal/llm/tools/glob.go
@@ -63,6 +63,11 @@ type GlobParams struct {
 	Path    string `json:"path"`
 }
 
+type GlobMetadata struct {
+	NumberOfFiles int  `json:"number_of_files"`
+	Truncated     bool `json:"truncated"`
+}
+
 type globTool struct{}
 
 func NewGlobTool() BaseTool {
@@ -104,7 +109,7 @@ func (g *globTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error)
 
 	files, truncated, err := globFiles(params.Pattern, searchPath, 100)
 	if err != nil {
-		return NewTextErrorResponse(fmt.Sprintf("error performing glob search: %s", err)), nil
+		return ToolResponse{}, fmt.Errorf("error finding files: %w", err)
 	}
 
 	var output string
@@ -117,7 +122,13 @@ func (g *globTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error)
 		}
 	}
 
-	return NewTextResponse(output), nil
+	return WithResponseMetadata(
+		NewTextResponse(output),
+		GlobMetadata{
+			NumberOfFiles: len(files),
+			Truncated:     truncated,
+		},
+	), nil
 }
 
 func globFiles(pattern, searchPath string, limit int) ([]string, bool, error) {
diff --git a/internal/llm/tools/grep.go b/internal/llm/tools/grep.go
@@ -27,6 +27,11 @@ type grepMatch struct {
 	modTime time.Time
 }
 
+type GrepMetadata struct {
+	NumberOfMatches int  `json:"number_of_matches"`
+	Truncated       bool `json:"truncated"`
+}
+
 type grepTool struct{}
 
 const (
@@ -110,7 +115,7 @@ func (g *grepTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error)
 
 	matches, truncated, err := searchFiles(params.Pattern, searchPath, params.Include, 100)
 	if err != nil {
-		return NewTextErrorResponse(fmt.Sprintf("error searching files: %s", err)), nil
+		return ToolResponse{}, fmt.Errorf("error searching files: %w", err)
 	}
 
 	var output string
@@ -127,7 +132,13 @@ func (g *grepTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error)
 		}
 	}
 
-	return NewTextResponse(output), nil
+	return WithResponseMetadata(
+		NewTextResponse(output),
+		GrepMetadata{
+			NumberOfMatches: len(matches),
+			Truncated:       truncated,
+		},
+	), nil
 }
 
 func pluralize(count int) string {
diff --git a/internal/llm/tools/ls.go b/internal/llm/tools/ls.go
@@ -23,6 +23,11 @@ type TreeNode struct {
 	Children []*TreeNode `json:"children,omitempty"`
 }
 
+type LSMetadata struct {
+	NumberOfFiles int  `json:"number_of_files"`
+	Truncated     bool `json:"truncated"`
+}
+
 type lsTool struct{}
 
 const (
@@ -104,7 +109,7 @@ func (l *lsTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error) {
 
 	files, truncated, err := listDirectory(searchPath, params.Ignore, MaxLSFiles)
 	if err != nil {
-		return NewTextErrorResponse(fmt.Sprintf("error listing directory: %s", err)), nil
+		return ToolResponse{}, fmt.Errorf("error listing directory: %w", err)
 	}
 
 	tree := createFileTree(files)
@@ -114,7 +119,13 @@ func (l *lsTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error) {
 		output = fmt.Sprintf("There are more than %d files in the directory. Use a more specific path or use the Glob tool to find specific files. The first %d files and directories are included below:\n\n%s", MaxLSFiles, MaxLSFiles, output)
 	}
 
-	return NewTextResponse(output), nil
+	return WithResponseMetadata(
+		NewTextResponse(output),
+		LSMetadata{
+			NumberOfFiles: len(files),
+			Truncated:     truncated,
+		},
+	), nil
 }
 
 func listDirectory(initialPath string, ignorePatterns []string, limit int) ([]string, bool, error) {
diff --git a/internal/llm/tools/sourcegraph.go b/internal/llm/tools/sourcegraph.go
@@ -18,6 +18,11 @@ type SourcegraphParams struct {
 	Timeout       int    `json:"timeout,omitempty"`
 }
 
+type SourcegraphMetadata struct {
+	NumberOfMatches int  `json:"number_of_matches"`
+	Truncated       bool `json:"truncated"`
+}
+
 type sourcegraphTool struct {
 	client *http.Client
 }
@@ -198,7 +203,7 @@ func (t *sourcegraphTool) Run(ctx context.Context, call ToolCall) (ToolResponse,
 
 	graphqlQueryBytes, err := json.Marshal(request)
 	if err != nil {
-		return NewTextErrorResponse("Failed to create GraphQL request: " + err.Error()), nil
+		return ToolResponse{}, fmt.Errorf("failed to marshal GraphQL request: %w", err)
 	}
 	graphqlQuery := string(graphqlQueryBytes)
 
@@ -209,15 +214,15 @@ func (t *sourcegraphTool) Run(ctx context.Context, call ToolCall) (ToolResponse,
 		bytes.NewBuffer([]byte(graphqlQuery)),
 	)
 	if err != nil {
-		return NewTextErrorResponse("Failed to create request: " + err.Error()), nil
+		return ToolResponse{}, fmt.Errorf("failed to create request: %w", err)
 	}
 
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("User-Agent", "termai/1.0")
 
 	resp, err := client.Do(req)
 	if err != nil {
-		return NewTextErrorResponse("Failed to execute request: " + err.Error()), nil
+		return ToolResponse{}, fmt.Errorf("failed to fetch URL: %w", err)
 	}
 	defer resp.Body.Close()
 
@@ -231,12 +236,12 @@ func (t *sourcegraphTool) Run(ctx context.Context, call ToolCall) (ToolResponse,
 	}
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
-		return NewTextErrorResponse("Failed to read response body: " + err.Error()), nil
+		return ToolResponse{}, fmt.Errorf("failed to read response body: %w", err)
 	}
 
 	var result map[string]any
 	if err = json.Unmarshal(body, &result); err != nil {
-		return NewTextErrorResponse("Failed to parse response: " + err.Error()), nil
+		return ToolResponse{}, fmt.Errorf("failed to unmarshal response: %w", err)
 	}
 
 	formattedResults, err := formatSourcegraphResults(result, params.ContextWindow)
diff --git a/internal/llm/tools/view.go b/internal/llm/tools/view.go
@@ -135,7 +135,7 @@ func (v *viewTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error)
 
 			return NewTextErrorResponse(fmt.Sprintf("File not found: %s", filePath)), nil
 		}
-		return NewTextErrorResponse(fmt.Sprintf("Failed to access file: %s", err)), nil
+		return ToolResponse{}, fmt.Errorf("error accessing file: %w", err)
 	}
 
 	// Check if it's a directory
@@ -156,14 +156,15 @@ func (v *viewTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error)
 
 	// Check if it's an image file
 	isImage, imageType := isImageFile(filePath)
+	// TODO: handle images
 	if isImage {
 		return NewTextErrorResponse(fmt.Sprintf("This is an image file of type: %s\nUse a different tool to process images", imageType)), nil
 	}
 
 	// Read the file content
 	content, lineCount, err := readTextFile(filePath, params.Offset, params.Limit)
 	if err != nil {
-		return NewTextErrorResponse(fmt.Sprintf("Failed to read file: %s", err)), nil
+		return ToolResponse{}, fmt.Errorf("error reading file: %w", err)
 	}
 
 	notifyLspOpenFile(ctx, filePath, v.lspClients)
diff --git a/internal/llm/tools/write.go b/internal/llm/tools/write.go
@@ -30,8 +30,9 @@ type writeTool struct {
 }
 
 type WriteResponseMetadata struct {
-	Additions int `json:"additions"`
-	Removals  int `json:"removals"`
+	Diff      string `json:"diff"`
+	Additions int    `json:"additions"`
+	Removals  int    `json:"removals"`
 }
 
 const (
@@ -128,12 +129,12 @@ func (w *writeTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error
 			return NewTextErrorResponse(fmt.Sprintf("File %s already contains the exact content. No changes made.", filePath)), nil
 		}
 	} else if !os.IsNotExist(err) {
-		return NewTextErrorResponse(fmt.Sprintf("Failed to access file: %s", err)), nil
+		return ToolResponse{}, fmt.Errorf("error checking file: %w", err)
 	}
 
 	dir := filepath.Dir(filePath)
 	if err = os.MkdirAll(dir, 0o755); err != nil {
-		return NewTextErrorResponse(fmt.Sprintf("Failed to create parent directories: %s", err)), nil
+		return ToolResponse{}, fmt.Errorf("error creating directory: %w", err)
 	}
 
 	oldContent := ""
@@ -146,15 +147,15 @@ func (w *writeTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error
 
 	sessionID, messageID := GetContextValues(ctx)
 	if sessionID == "" || messageID == "" {
-		return NewTextErrorResponse("session ID or message ID is missing"), nil
+		return ToolResponse{}, fmt.Errorf("session_id and message_id are required")
 	}
 	diff, stats, err := git.GenerateGitDiffWithStats(
 		removeWorkingDirectoryPrefix(filePath),
 		oldContent,
 		params.Content,
 	)
 	if err != nil {
-		return NewTextErrorResponse(fmt.Sprintf("Failed to get file diff: %s", err)), nil
+		return ToolResponse{}, fmt.Errorf("error generating diff: %w", err)
 	}
 	p := w.permissions.Request(
 		permission.CreatePermissionRequest{
@@ -169,12 +170,12 @@ func (w *writeTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error
 		},
 	)
 	if !p {
-		return NewTextErrorResponse(fmt.Sprintf("Permission denied to create file: %s", filePath)), nil
+		return ToolResponse{}, permission.ErrorPermissionDenied
 	}
 
 	err = os.WriteFile(filePath, []byte(params.Content), 0o644)
 	if err != nil {
-		return NewTextErrorResponse(fmt.Sprintf("Failed to write file: %s", err)), nil
+		return ToolResponse{}, fmt.Errorf("error writing file: %w", err)
 	}
 
 	recordFileWrite(filePath)
@@ -186,6 +187,7 @@ func (w *writeTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error
 	result += getDiagnostics(filePath, w.lspClients)
 	return WithResponseMetadata(NewTextResponse(result),
 		WriteResponseMetadata{
+			Diff:      diff,
 			Additions: stats.Additions,
 			Removals:  stats.Removals,
 		},

Original file line number	Diff line number	Diff line change
`@@ -63,6 +63,11 @@ type GlobParams struct {`
`63`	`63`	Path string `json:"path"`
`64`	`64`	`}`
`65`	`65`
	`66`	`+type GlobMetadata struct {`
	`67`	+ NumberOfFiles int `json:"number_of_files"`
	`68`	+ Truncated bool `json:"truncated"`
	`69`	`+}`
	`70`	`+`
`66`	`71`	`type globTool struct{}`
`67`	`72`
`68`	`73`	`func NewGlobTool() BaseTool {`
`@@ -104,7 +109,7 @@ func (g *globTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error)`
`104`	`109`
`105`	`110`	`files, truncated, err := globFiles(params.Pattern, searchPath, 100)`
`106`	`111`	`if err != nil {`
`107`		`- return NewTextErrorResponse(fmt.Sprintf("error performing glob search: %s", err)), nil`
	`112`	`+ return ToolResponse{}, fmt.Errorf("error finding files: %w", err)`
`108`	`113`	`}`
`109`	`114`
`110`	`115`	`var output string`
`@@ -117,7 +122,13 @@ func (g *globTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error)`
`117`	`122`	`}`
`118`	`123`	`}`
`119`	`124`
`120`		`- return NewTextResponse(output), nil`
	`125`	`+ return WithResponseMetadata(`
	`126`	`+ NewTextResponse(output),`
	`127`	`+ GlobMetadata{`
	`128`	`+ NumberOfFiles: len(files),`
	`129`	`+ Truncated: truncated,`
	`130`	`+ },`
	`131`	`+ ), nil`
`121`	`132`	`}`
`122`	`133`
`123`	`134`	`func globFiles(pattern, searchPath string, limit int) ([]string, bool, error) {`
Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,11 @@ type grepMatch struct {`
`27`	`27`	`modTime time.Time`
`28`	`28`	`}`
`29`	`29`
	`30`	`+type GrepMetadata struct {`
	`31`	+ NumberOfMatches int `json:"number_of_matches"`
	`32`	+ Truncated bool `json:"truncated"`
	`33`	`+}`
	`34`	`+`
`30`	`35`	`type grepTool struct{}`
`31`	`36`
`32`	`37`	`const (`
`@@ -110,7 +115,7 @@ func (g *grepTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error)`
`110`	`115`
`111`	`116`	`matches, truncated, err := searchFiles(params.Pattern, searchPath, params.Include, 100)`
`112`	`117`	`if err != nil {`
`113`		`- return NewTextErrorResponse(fmt.Sprintf("error searching files: %s", err)), nil`
	`118`	`+ return ToolResponse{}, fmt.Errorf("error searching files: %w", err)`
`114`	`119`	`}`
`115`	`120`
`116`	`121`	`var output string`
`@@ -127,7 +132,13 @@ func (g *grepTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error)`
`127`	`132`	`}`
`128`	`133`	`}`
`129`	`134`
`130`		`- return NewTextResponse(output), nil`
	`135`	`+ return WithResponseMetadata(`
	`136`	`+ NewTextResponse(output),`
	`137`	`+ GrepMetadata{`
	`138`	`+ NumberOfMatches: len(matches),`
	`139`	`+ Truncated: truncated,`
	`140`	`+ },`
	`141`	`+ ), nil`
`131`	`142`	`}`
`132`	`143`
`133`	`144`	`func pluralize(count int) string {`
Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,11 @@ type SourcegraphParams struct {`
`18`	`18`	Timeout int `json:"timeout,omitempty"`
`19`	`19`	`}`
`20`	`20`
	`21`	`+type SourcegraphMetadata struct {`
	`22`	+ NumberOfMatches int `json:"number_of_matches"`
	`23`	+ Truncated bool `json:"truncated"`
	`24`	`+}`
	`25`	`+`
`21`	`26`	`type sourcegraphTool struct {`
`22`	`27`	`client *http.Client`
`23`	`28`	`}`
`@@ -198,7 +203,7 @@ func (t *sourcegraphTool) Run(ctx context.Context, call ToolCall) (ToolResponse,`
`198`	`203`
`199`	`204`	`graphqlQueryBytes, err := json.Marshal(request)`
`200`	`205`	`if err != nil {`
`201`		`- return NewTextErrorResponse("Failed to create GraphQL request: " + err.Error()), nil`
	`206`	`+ return ToolResponse{}, fmt.Errorf("failed to marshal GraphQL request: %w", err)`
`202`	`207`	`}`
`203`	`208`	`graphqlQuery := string(graphqlQueryBytes)`
`204`	`209`
`@@ -209,15 +214,15 @@ func (t *sourcegraphTool) Run(ctx context.Context, call ToolCall) (ToolResponse,`
`209`	`214`	`bytes.NewBuffer([]byte(graphqlQuery)),`
`210`	`215`	`)`
`211`	`216`	`if err != nil {`
`212`		`- return NewTextErrorResponse("Failed to create request: " + err.Error()), nil`
	`217`	`+ return ToolResponse{}, fmt.Errorf("failed to create request: %w", err)`
`213`	`218`	`}`
`214`	`219`
`215`	`220`	`req.Header.Set("Content-Type", "application/json")`
`216`	`221`	`req.Header.Set("User-Agent", "termai/1.0")`
`217`	`222`
`218`	`223`	`resp, err := client.Do(req)`
`219`	`224`	`if err != nil {`
`220`		`- return NewTextErrorResponse("Failed to execute request: " + err.Error()), nil`
	`225`	`+ return ToolResponse{}, fmt.Errorf("failed to fetch URL: %w", err)`
`221`	`226`	`}`
`222`	`227`	`defer resp.Body.Close()`
`223`	`228`
`@@ -231,12 +236,12 @@ func (t *sourcegraphTool) Run(ctx context.Context, call ToolCall) (ToolResponse,`
`231`	`236`	`}`
`232`	`237`	`body, err := io.ReadAll(resp.Body)`
`233`	`238`	`if err != nil {`
`234`		`- return NewTextErrorResponse("Failed to read response body: " + err.Error()), nil`
	`239`	`+ return ToolResponse{}, fmt.Errorf("failed to read response body: %w", err)`
`235`	`240`	`}`
`236`	`241`
`237`	`242`	`var result map[string]any`
`238`	`243`	`if err = json.Unmarshal(body, &result); err != nil {`
`239`		`- return NewTextErrorResponse("Failed to parse response: " + err.Error()), nil`
	`244`	`+ return ToolResponse{}, fmt.Errorf("failed to unmarshal response: %w", err)`
`240`	`245`	`}`
`241`	`246`
`242`	`247`	`formattedResults, err := formatSourcegraphResults(result, params.ContextWindow)`
Original file line number	Diff line number	Diff line change
`@@ -135,7 +135,7 @@ func (v *viewTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error)`
`135`	`135`
`136`	`136`	`return NewTextErrorResponse(fmt.Sprintf("File not found: %s", filePath)), nil`
`137`	`137`	`}`
`138`		`- return NewTextErrorResponse(fmt.Sprintf("Failed to access file: %s", err)), nil`
	`138`	`+ return ToolResponse{}, fmt.Errorf("error accessing file: %w", err)`
`139`	`139`	`}`
`140`	`140`
`141`	`141`	`// Check if it's a directory`
`@@ -156,14 +156,15 @@ func (v *viewTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error)`
`156`	`156`
`157`	`157`	`// Check if it's an image file`
`158`	`158`	`isImage, imageType := isImageFile(filePath)`
	`159`	`+ // TODO: handle images`
`159`	`160`	`if isImage {`
`160`	`161`	`return NewTextErrorResponse(fmt.Sprintf("This is an image file of type: %s\nUse a different tool to process images", imageType)), nil`
`161`	`162`	`}`
`162`	`163`
`163`	`164`	`// Read the file content`
`164`	`165`	`content, lineCount, err := readTextFile(filePath, params.Offset, params.Limit)`
`165`	`166`	`if err != nil {`
`166`		`- return NewTextErrorResponse(fmt.Sprintf("Failed to read file: %s", err)), nil`
	`167`	`+ return ToolResponse{}, fmt.Errorf("error reading file: %w", err)`
`167`	`168`	`}`
`168`	`169`
`169`	`170`	`notifyLspOpenFile(ctx, filePath, v.lspClients)`
Original file line number	Diff line number	Diff line change
`@@ -30,8 +30,9 @@ type writeTool struct {`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`type WriteResponseMetadata struct {`
`33`		- Additions int `json:"additions"`
`34`		- Removals int `json:"removals"`
	`33`	+ Diff string `json:"diff"`
	`34`	+ Additions int `json:"additions"`
	`35`	+ Removals int `json:"removals"`
`35`	`36`	`}`
`36`	`37`
`37`	`38`	`const (`
`@@ -128,12 +129,12 @@ func (w *writeTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error`
`128`	`129`	`return NewTextErrorResponse(fmt.Sprintf("File %s already contains the exact content. No changes made.", filePath)), nil`
`129`	`130`	`}`
`130`	`131`	`} else if !os.IsNotExist(err) {`
`131`		`- return NewTextErrorResponse(fmt.Sprintf("Failed to access file: %s", err)), nil`
	`132`	`+ return ToolResponse{}, fmt.Errorf("error checking file: %w", err)`
`132`	`133`	`}`
`133`	`134`
`134`	`135`	`dir := filepath.Dir(filePath)`
`135`	`136`	`if err = os.MkdirAll(dir, 0o755); err != nil {`
`136`		`- return NewTextErrorResponse(fmt.Sprintf("Failed to create parent directories: %s", err)), nil`
	`137`	`+ return ToolResponse{}, fmt.Errorf("error creating directory: %w", err)`
`137`	`138`	`}`
`138`	`139`
`139`	`140`	`oldContent := ""`
`@@ -146,15 +147,15 @@ func (w *writeTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error`
`146`	`147`
`147`	`148`	`sessionID, messageID := GetContextValues(ctx)`
`148`	`149`	`if sessionID == "" \|\| messageID == "" {`
`149`		`- return NewTextErrorResponse("session ID or message ID is missing"), nil`
	`150`	`+ return ToolResponse{}, fmt.Errorf("session_id and message_id are required")`
`150`	`151`	`}`
`151`	`152`	`diff, stats, err := git.GenerateGitDiffWithStats(`
`152`	`153`	`removeWorkingDirectoryPrefix(filePath),`
`153`	`154`	`oldContent,`
`154`	`155`	`params.Content,`
`155`	`156`	`)`
`156`	`157`	`if err != nil {`
`157`		`- return NewTextErrorResponse(fmt.Sprintf("Failed to get file diff: %s", err)), nil`
	`158`	`+ return ToolResponse{}, fmt.Errorf("error generating diff: %w", err)`
`158`	`159`	`}`
`159`	`160`	`p := w.permissions.Request(`
`160`	`161`	`permission.CreatePermissionRequest{`
`@@ -169,12 +170,12 @@ func (w *writeTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error`
`169`	`170`	`},`
`170`	`171`	`)`
`171`	`172`	`if !p {`
`172`		`- return NewTextErrorResponse(fmt.Sprintf("Permission denied to create file: %s", filePath)), nil`
	`173`	`+ return ToolResponse{}, permission.ErrorPermissionDenied`
`173`	`174`	`}`
`174`	`175`
`175`	`176`	`err = os.WriteFile(filePath, []byte(params.Content), 0o644)`
`176`	`177`	`if err != nil {`
`177`		`- return NewTextErrorResponse(fmt.Sprintf("Failed to write file: %s", err)), nil`
	`178`	`+ return ToolResponse{}, fmt.Errorf("error writing file: %w", err)`
`178`	`179`	`}`
`179`	`180`
`180`	`181`	`recordFileWrite(filePath)`
`@@ -186,6 +187,7 @@ func (w *writeTool) Run(ctx context.Context, call ToolCall) (ToolResponse, error`
`186`	`187`	`result += getDiagnostics(filePath, w.lspClients)`
`187`	`188`	`return WithResponseMetadata(NewTextResponse(result),`
`188`	`189`	`WriteResponseMetadata{`
	`190`	`+ Diff: diff,`
`189`	`191`	`Additions: stats.Additions,`
`190`	`192`	`Removals: stats.Removals,`
`191`	`193`	`},`