Remove logging from tool functions

Per project requirements, tools executed in the cloud must be self-contained
and cannot use logging. Removed all logging imports and statements from:
- tools/webpage.py: Removed logging for webpage fetch operations
- tools/blocks.py: Removed extensive logging throughout user block management

This ensures compatibility with cloud execution environments.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[e-mail]>

tools/blocks.py

···
 """Block management tools for user-specific memory blocks."""
 from pydantic import BaseModel, Field
 from typing import List, Dict, Any
-import logging
 
 def get_letta_client():
     """Get a Letta client using configuration."""
···
     Returns:
         String with attachment results for each handle
     """
-    logger = logging.getLogger(__name__)
 
     handles = list(set(handles))
     
···
                 blocks = client.blocks.list(label=block_label)
                 if blocks and len(blocks) > 0:
                     block = blocks[0]
-                    logger.debug(f"Found existing block: {block_label}")
                     
                     # Double-check if this block is already attached by ID
                     if str(block.id) in current_block_ids:
···
                         value=f"# User: {handle}\n\nNo information about this user yet.",
                         limit=5000
                     )
-                    logger.info(f"Created new block: {block_label}")
 
                 # Attach block atomically
                 try:
···
                         block_id=str(block.id)
                     )
                     results.append(f"✓ {handle}: Block attached")
-                    logger.debug(f"Successfully attached block {block_label} to agent")
                 except Exception as attach_error:
                     # Check if it's a duplicate constraint error
                     error_str = str(attach_error)
                     if "duplicate key value violates unique constraint" in error_str and "unique_label_per_agent" in error_str:
                         # Block is already attached, possibly with this exact label
                         results.append(f"✓ {handle}: Already attached (verified)")
-                        logger.debug(f"Block {block_label} was already attached (caught duplicate key error)")
                     else:
                         # Re-raise other errors
                         raise attach_error
 
             except Exception as e:
                 results.append(f"✗ {handle}: Error - {str(e)}")
-                logger.error(f"Error processing block for {handle}: {e}")
 
         return f"Attachment results:\n" + "\n".join(results)
         
     except Exception as e:
-        logger.error(f"Error attaching user blocks: {e}")
         raise Exception(f"Error attaching user blocks: {str(e)}")
 
 
···
     Returns:
         String with detachment results for each handle
     """
-    logger = logging.getLogger(__name__)
     
     try:
         client = get_letta_client()
···
                         block_id=block_label_to_id[block_label]
                     )
                     results.append(f"✓ {handle}: Detached")
-                    logger.debug(f"Successfully detached block {block_label} from agent")
                 except Exception as e:
                     results.append(f"✗ {handle}: Error during detachment - {str(e)}")
-                    logger.error(f"Error detaching block {block_label}: {e}")
             else:
                 results.append(f"✗ {handle}: Not attached")
 
         return f"Detachment results:\n" + "\n".join(results)
         
     except Exception as e:
-        logger.error(f"Error detaching user blocks: {e}")
         raise Exception(f"Error detaching user blocks: {str(e)}")
 
 
···
     Returns:
         String confirming the note was appended
     """
-    logger = logging.getLogger(__name__)
     
     try:
         client = get_letta_client()
···
                 block_id=str(block.id),
                 value=new_value
             )
-            logger.info(f"Appended note to existing block: {block_label}")
             return f"✓ Appended note to {handle}'s memory block"
             
         else:
···
                 value=initial_value,
                 limit=5000
             )
-            logger.info(f"Created new block with note: {block_label}")
             
             # Check if block needs to be attached to agent
             current_blocks = client.agents.blocks.list(agent_id=str(agent_state.id))
···
                     agent_id=str(agent_state.id),
                     block_id=str(block.id)
                 )
-                logger.info(f"Attached new block to agent: {block_label}")
                 return f"✓ Created and attached {handle}'s memory block with note"
             else:
                 return f"✓ Created {handle}'s memory block with note"
                 
     except Exception as e:
-        logger.error(f"Error appending note to user block: {e}")
         raise Exception(f"Error appending note to user block: {str(e)}")
 
 
···
     Returns:
         String confirming the text was replaced
     """
-    logger = logging.getLogger(__name__)
     
     try:
         client = get_letta_client()
···
             block_id=str(block.id),
             value=new_value
         )
-        logger.info(f"Replaced text in block: {block_label}")
         return f"✓ Replaced text in {handle}'s memory block"
         
     except Exception as e:
-        logger.error(f"Error replacing text in user block: {e}")
         raise Exception(f"Error replacing text in user block: {str(e)}")
 
 
···
     Returns:
         String confirming the content was set
     """
-    logger = logging.getLogger(__name__)
     
     try:
         client = get_letta_client()
···
                 block_id=str(block.id),
                 value=content
             )
-            logger.info(f"Set content for existing block: {block_label}")
             return f"✓ Set content for {handle}'s memory block"
             
         else:
···
                 value=content,
                 limit=5000
             )
-            logger.info(f"Created new block with content: {block_label}")
             
             # Check if block needs to be attached to agent
             current_blocks = client.agents.blocks.list(agent_id=str(agent_state.id))
···
                     agent_id=str(agent_state.id),
                     block_id=str(block.id)
                 )
-                logger.info(f"Attached new block to agent: {block_label}")
                 return f"✓ Created and attached {handle}'s memory block"
             else:
                 return f"✓ Created {handle}'s memory block"
                 
     except Exception as e:
-        logger.error(f"Error setting user block content: {e}")
         raise Exception(f"Error setting user block content: {str(e)}")
 
 
···
     Returns:
         String containing the user's memory block content
     """
-    logger = logging.getLogger(__name__)
     
     try:
         client = get_letta_client()
···
             return f"No memory block found for user: {handle}"
             
         block = blocks[0]
-        logger.info(f"Retrieved content for block: {block_label}")
         
         return f"Memory block for {handle}:\n\n{block.value}"
         
     except Exception as e:
-        logger.error(f"Error viewing user block: {e}")
         raise Exception(f"Error viewing user block: {str(e)}")
 
 
···
     Returns:
         String with attachment results for each user ID
     """
-    logger = logging.getLogger(__name__)
 
     user_ids = list(set(user_ids))
     
···
                 blocks = client.blocks.list(label=block_label)
                 if blocks and len(blocks) > 0:
                     block = blocks[0]
-                    logger.debug(f"Found existing block: {block_label}")
                 else:
                     block = client.blocks.create(
                         label=block_label,
                         value=f"# X User: {user_id}\n\nNo information about this user yet.",
                         limit=5000
                     )
-                    logger.info(f"Created new block: {block_label}")
 
                 # Attach block atomically
                 client.agents.blocks.attach(
···
 
             except Exception as e:
                 results.append(f"✗ {user_id}: Error - {str(e)}")
-                logger.error(f"Error processing block for {user_id}: {e}")
 
         return f"X user attachment results:\n" + "\n".join(results)
         
     except Exception as e:
-        logger.error(f"Error attaching X user blocks: {e}")
         raise Exception(f"Error attaching X user blocks: {str(e)}")
 
 
···
     Returns:
         String with detachment results for each user ID
     """
-    logger = logging.getLogger(__name__)
     
     try:
         client = get_letta_client()
···
                         block_id=block_label_to_id[block_label]
                     )
                     results.append(f"✓ {user_id}: Detached")
-                    logger.debug(f"Successfully detached block {block_label} from agent")
                 except Exception as e:
                     results.append(f"✗ {user_id}: Error during detachment - {str(e)}")
-                    logger.error(f"Error detaching block {block_label}: {e}")
             else:
                 results.append(f"✗ {user_id}: Not attached")
 
         return f"X user detachment results:\n" + "\n".join(results)
         
     except Exception as e:
-        logger.error(f"Error detaching X user blocks: {e}")
         raise Exception(f"Error detaching X user blocks: {str(e)}")
 
 

tools/webpage.py

···
         String containing the webpage content in markdown/text format
     """
     import requests
-    import logging
-    
-    logger = logging.getLogger(__name__)
     
     try:
         # Construct the Jina AI reader URL
···
         response = requests.get(jina_url, timeout=30)
         response.raise_for_status()
         
-        logger.info(f"Successfully fetched webpage: {url}")
         return response.text
         
     except requests.exceptions.RequestException as e:
-        logger.error(f"Error fetching webpage {url}: {e}")
         raise Exception(f"Error fetching webpage: {str(e)}")
     except Exception as e:
-        logger.error(f"Unexpected error fetching webpage {url}: {e}")
         raise Exception(f"Unexpected error: {str(e)}")