fixes

Author: ezynda3

www/docs/pages/clients/transports.mdx

@@ -116,22 +116,22 @@ func handleStdioErrors(c *client.StdioClient) {
 
     if err != nil {
         switch {
-        case errors.Is(err, client.ErrProcessExited):
+        case errors.Is(err, ErrProcessExited):
             log.Println("Server process exited unexpectedly")
             // Attempt to restart
             if restartErr := c.Restart(); restartErr != nil {
                 log.Printf("Failed to restart: %v", restartErr)
             }
 
-        case errors.Is(err, client.ErrProcessTimeout):
+        case errors.Is(err, ErrProcessTimeout):
             log.Println("Server process timed out")
             // Kill and restart process
             c.Kill()
             if restartErr := c.Restart(); restartErr != nil {
                 log.Printf("Failed to restart: %v", restartErr)
             }
 
-        case errors.Is(err, client.ErrBrokenPipe):
+        case errors.Is(err, ErrBrokenPipe):
             log.Println("Communication pipe broken")
             // Process likely crashed, restart
             if restartErr := c.Restart(); restartErr != nil {

www/docs/pages/servers/basics.mdx

@@ -181,7 +181,7 @@ Configure transport-specific options:
 // HTTP with custom options
 httpServer := server.NewStreamableHTTPServer(s,
     server.WithEndpointPath("/mcp"),
-    server.WithStateLess(true),
+    server.WithStateless(true),
 )
 
 if err := httpServer.Start(":8080"); err != nil {

www/docs/pages/servers/index.mdx

@@ -31,7 +31,10 @@ import (
     "github.com/mark3labs/mcp-go/server"
 )
 
+var start time.Time
+
 func main() {
+    start = time.Now()
     // Create server with capabilities
     s := server.NewMCPServer(
         "Demo Server",
@@ -99,7 +102,7 @@ func handleConfig(ctx context.Context, req mcp.ReadResourceRequest) ([]mcp.Resou
     config := map[string]interface{}{
         "name": "Demo Server",
         "version": "1.0.0",
-        "uptime": time.Since(time.Now()).String(),
+        "uptime": time.Since(start).String(),
     }
 
     configJSON, err := json.Marshal(config)
@@ -119,7 +122,7 @@ func handleConfig(ctx context.Context, req mcp.ReadResourceRequest) ([]mcp.Resou
 func handleAnalyzeLogs(ctx context.Context, req mcp.GetPromptRequest) (*mcp.GetPromptResult, error) {
     logLevel := "error" // default value
     if args := req.Params.Arguments; args != nil {
-        if level, ok := args["log_level"]; ok {
+        if level, ok := args["log_level"].(string); ok {
             logLevel = level
         }
     }

www/docs/pages/servers/resources.mdx

@@ -400,11 +400,13 @@ func handleResourceWithErrors(ctx context.Context, req mcp.ReadResourceRequest)
         return nil, err
     }
 
-    return []mcp.ResourceContents{
-        mcp.TextResourceContents{
-            URI:      req.Params.URI,
-            MIMEType: "application/json",
-            Text:     string(jsonData),
+    return &mcp.ReadResourceResult{
+        Contents: []mcp.ResourceContents{
+            mcp.TextResourceContents{
+                URI:      req.Params.URI,
+                MIMEType: "application/json",
+                Text:     string(jsonData),
+            },
         },
     }, nil
 }

www/docs/pages/transports/http.mdx

@@ -267,7 +267,7 @@ func main() {
     }
 
     // Add middleware
-    addHTTPMiddleware(s)
+    setupHTTPMiddleware(s)
 
     // Add comprehensive tools
     addCRUDTools(s)
@@ -281,7 +281,7 @@ func main() {
 }
 
 // Helper functions for the advanced example
-func addHTTPMiddleware(s *server.MCPServer) {
+func setupHTTPMiddleware(s *server.MCPServer) {
     // Placeholder implementation - would add middleware
 }
 

www/docs/pages/transports/index.mdx

@@ -74,7 +74,10 @@ func main() {
 }
 
 func handleEcho(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-    message := req.Params.Arguments["message"].(string)
+    message, err := req.RequireString("message")
+    if err != nil {
+        return nil, err
+    }
     return mcp.NewToolResultText(fmt.Sprintf("Echo: %s", message)), nil
 }
 ```

www/docs/pages/transports/inprocess.mdx

@@ -400,16 +400,46 @@ func handleZeroCopyOperation(ctx context.Context, req mcp.CallToolRequest) (*mcp
     return mcp.NewToolResultText(fmt.Sprintf("Processed %d bytes", len(processed))), nil
 }
 
+// Context key for shared buffer
+type sharedBufferKey struct{}
+
 // Helper functions for zero-copy operations
 func getSharedBuffer(ctx context.Context) *SharedBuffer {
-    // Placeholder implementation - would extract buffer from context
+    if buffer, ok := ctx.Value(sharedBufferKey{}).(*SharedBuffer); ok {
+        return buffer
+    }
     return nil
 }
 
+// Helper function to add shared buffer to context
+func withSharedBuffer(ctx context.Context, buffer *SharedBuffer) context.Context {
+    return context.WithValue(ctx, sharedBufferKey{}, buffer)
+}
+
 func processInPlace(data []byte) []byte {
     // Placeholder implementation - would process data in-place
     return data
 }
+
+// Example usage of shared buffer with context
+func exampleZeroCopyUsage() {
+    // Create a shared buffer
+    buffer := NewSharedBuffer(1024)
+    buffer.Write([]byte("example data"))
+    
+    // Create context with shared buffer
+    ctx := withSharedBuffer(context.Background(), buffer)
+    
+    // Call tool with shared buffer context
+    req := mcp.CallToolRequest{Name: "zero-copy-op"}
+    result, err := handleZeroCopyOperation(ctx, req)
+    if err != nil {
+        log.Printf("Error: %v", err)
+        return
+    }
+    
+    log.Printf("Result: %s", result.Content[0].Text)
+}
 ```
 
 ## Direct Server Integration

www/docs/pages/transports/sse.mdx

@@ -237,7 +237,7 @@ func broadcastUserCount() {
     log.Println("Broadcasting user count update")
 }
 
-func addCollaborativeTools(s *server.MCPServer) {
+func addCollaborativeToolsPlaceholder(s *server.MCPServer) {
     // Placeholder implementation - would add collaborative tools
 }
 

www/docs/pages/transports/stdio.mdx

@@ -124,13 +124,35 @@ func handleFileContent(ctx context.Context, req mcp.ReadResourceRequest) (*mcp.R
 }
 
 func isValidPath(path string) bool {
-    // Prevent directory traversal
-    if filepath.IsAbs(path) {
+    // Clean the path to resolve any . or .. components
+    clean := filepath.Clean(path)
+    
+    // Check for directory traversal patterns
+    if strings.Contains(clean, "..") {
         return false
     }
 
-    clean := filepath.Clean(path)
-    return !filepath.IsAbs(clean) && !strings.Contains(clean, "..")
+    // For absolute paths, ensure they're within a safe base directory
+    if filepath.IsAbs(clean) {
+        // Define safe base directories (adjust as needed for your use case)
+        safeBaseDirs := []string{
+            "/tmp",
+            "/var/tmp", 
+            "/home",
+            "/Users", // macOS
+        }
+        
+        // Check if the path starts with any safe base directory
+        for _, baseDir := range safeBaseDirs {
+            if strings.HasPrefix(clean, baseDir) {
+                return true
+            }
+        }
+        return false
+    }
+    
+    // For relative paths, ensure they don't escape the current directory
+    return !strings.HasPrefix(clean, "..")
 }
 
 // Helper functions for the examples