Migrate to Letta SDK v1.0 and rename whitewind tool to blog_post_create

SDK Migration (letta-client 0.1.235 → 1.0.0):
- Letta() constructor: token → api_key
- Method renames: .modify() → .update()
- Streaming: .create_stream() → .stream()
- Pagination: .list() now returns page objects (use .items)

Tool Rename:
- create_whitewind_blog_post → blog_post_create
- WhitewindPostArgs → BlogPostCreateArgs
- Updated docstrings to reference Greengale service (greengale.app)

🤖 Generated with [Letta Code](https://letta.com)

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

attach_user_block.py

···
     """Create and attach a user block to an agent."""
     
     # Create client
-    client = Letta(token=os.environ["LETTA_API_KEY"])
+    client = Letta(api_key=os.environ["LETTA_API_KEY"])  # v1.0: token → api_key
     
     # Find the agent
     agents = client.agents.list(name=agent_name)
···
     print(f"🔍 Creating user block for {handle}...")
     user_block = create_user_block_for_handle(client, handle)
     
-    # Check if already attached
-    agent_blocks = client.agents.blocks.list(agent_id=agent.id)
+    # Check if already attached (v1.0: list returns page object)
+    agent_blocks_page = client.agents.blocks.list(agent_id=agent.id)
+    agent_blocks = agent_blocks_page.items if hasattr(agent_blocks_page, 'items') else agent_blocks_page
     for block in agent_blocks:
         if block.id == user_block.id:
             print(f"✅ User block for {handle} is already attached to {agent.name}")

bsky.py

···
 
         try:
             # Use streaming to avoid 524 timeout errors
-            message_stream = CLIENT.agents.messages.create_stream(
+            message_stream = CLIENT.agents.messages.stream(
                 agent_id=void_agent.id,
                 messages=[{"role": "user", "content": prompt}],
                 stream_tokens=False,  # Step streaming only (faster than token streaming)
···
                 try:
                     # Search for passages with this exact text
                     logger.debug(f"Searching for passages matching: {memory_text[:100]}...")
-                    passages = CLIENT.agents.passages.list(
+                    passages_page = CLIENT.agents.passages.list(
                         agent_id=void_agent.id,
                         query=memory_text
                     )
+                    passages = passages_page.items if hasattr(passages_page, 'items') else passages_page
 
                     if not passages:
                         logger.warning(f"No passages found matching flagged memory: {memory_text[:50]}...")
···
         logger.info("🧠 Sending enhanced synthesis prompt to agent")
         
         # Send synthesis message with streaming to show tool use
-        message_stream = client.agents.messages.create_stream(
+        message_stream = client.agents.messages.stream(
             agent_id=agent_id,
             messages=[{"role": "user", "content": synthesis_prompt}],
             stream_tokens=False,
···
         attached_labels = []
         
         # Get current blocks attached to agent
-        current_blocks = client.agents.blocks.list(agent_id=agent_id)
+        current_blocks_page = client.agents.blocks.list(agent_id=agent_id)
+        current_blocks = current_blocks_page.items if hasattr(current_blocks_page, 'items') else current_blocks_page
         current_block_labels = {block.label for block in current_blocks}
         current_block_ids = {str(block.id) for block in current_blocks}
         
···
                     continue
                 
                 # Check if block exists globally
-                blocks = client.blocks.list(label=label)
+                blocks_page = client.blocks.list(label=label)
+                blocks = blocks_page.items if hasattr(blocks_page, 'items') else blocks_page
                 
                 if blocks and len(blocks) > 0:
                     block = blocks[0]
···
             ]
         
         # Get current blocks and build label to ID mapping
-        current_blocks = client.agents.blocks.list(agent_id=agent_id)
+        current_blocks_page = client.agents.blocks.list(agent_id=agent_id)
+        current_blocks = current_blocks_page.items if hasattr(current_blocks_page, 'items') else current_blocks_page
         block_label_to_id = {block.label: str(block.id) for block in current_blocks}
         
         detached_count = 0
···
     attached_labels = []
 
     try:
-        current_blocks = client.agents.blocks.list(agent_id=agent_id)
+        current_blocks_page = client.agents.blocks.list(agent_id=agent_id)
+        current_blocks = current_blocks_page.items if hasattr(current_blocks_page, 'items') else current_blocks_page
         current_block_labels = {block.label for block in current_blocks}
         current_block_ids = {str(block.id) for block in current_blocks}
 
···
                     attached_labels.append(label)
                     continue
 
-                blocks = client.blocks.list(label=label)
+                blocks_page = client.blocks.list(label=label)
+                blocks = blocks_page.items if hasattr(blocks_page, 'items') else blocks_page
 
                 if blocks and len(blocks) > 0:
                     block = blocks[0]
···
         return True
 
     try:
-        current_blocks = client.agents.blocks.list(agent_id=agent_id)
+        current_blocks_page = client.agents.blocks.list(agent_id=agent_id)
+        current_blocks = current_blocks_page.items if hasattr(current_blocks_page, 'items') else current_blocks_page
         block_label_to_id = {block.label: str(block.id) for block in current_blocks}
 
         detached_count = 0
···
 
     # Create Letta client with configuration
     CLIENT_PARAMS = {
-        'token': letta_config['api_key'],
+        'api_key': letta_config['api_key'],  # v1.0: token → api_key
         'timeout': letta_config['timeout']
     }
     if letta_config.get('base_url'):

register_tools.py

···
 from tools.halt import halt_activity, HaltArgs
 from tools.thread import add_post_to_bluesky_reply_thread, ReplyThreadPostArgs
 from tools.ignore import ignore_notification, IgnoreNotificationArgs
-from tools.whitewind import create_whitewind_blog_post, WhitewindPostArgs
+from tools.whitewind import blog_post_create, BlogPostCreateArgs
 from tools.ack import annotate_ack, AnnotateAckArgs
 from tools.webpage import fetch_webpage, WebpageArgs
 from tools.flag_memory_deletion import flag_archival_memory_for_deletion, FlagArchivalMemoryForDeletionArgs
···
         "tags": ["notification", "ignore", "control", "bot"]
     },
     {
-        "func": create_whitewind_blog_post,
-        "args_schema": WhitewindPostArgs,
-        "description": "Create a blog post on Whitewind with markdown support",
-        "tags": ["whitewind", "blog", "post", "markdown"]
+        "func": blog_post_create,
+        "args_schema": BlogPostCreateArgs,
+        "description": "Create a blog post on Greengale (served at greengale.app) with markdown support",
+        "tags": ["greengale", "blog", "post", "markdown"]
     },
     {
         "func": annotate_ack,
···
     try:
         # Initialize Letta client with API key and base_url from config
         client_params = {
-            'token': letta_config['api_key'],
+            'api_key': letta_config['api_key'],  # v1.0: token → api_key
             'timeout': letta_config['timeout']
         }
         if letta_config.get('base_url'):
···
                 console.print(f"  PDS_URI: {env_vars['PDS_URI']}")
                 console.print(f"  BSKY_PASSWORD: {'*' * len(env_vars['BSKY_PASSWORD'])}\n")
 
-                # Modify agent with environment variables
-                client.agents.modify(
+                # Update agent with environment variables (v1.0: modify → update)
+                client.agents.update(
                     agent_id=agent_id,
                     tool_exec_environment_variables=env_vars
                 )
···
                     tags=tool_config["tags"]
                 )
 
-                # Get current agent tools
-                current_tools = client.agents.tools.list(agent_id=str(agent.id))
+                # Get current agent tools (v1.0: list returns page object)
+                current_tools_page = client.agents.tools.list(agent_id=str(agent.id))
+                current_tools = current_tools_page.items if hasattr(current_tools_page, 'items') else current_tools_page
                 tool_names = [t.name for t in current_tools]
 
                 # Check if already attached

register_x_tools.py

···
     try:
         # Initialize Letta client with API key and base_url from config
         client_params = {
-            'token': letta_config['api_key'],
+            'api_key': letta_config['api_key'],  # v1.0: token → api_key
             'timeout': letta_config['timeout']
         }
         if letta_config.get('base_url'):
···
                     tags=tool_config["tags"]
                 )
 
-                # Get current agent tools
-                current_tools = client.agents.tools.list(agent_id=str(agent.id))
+                # Get current agent tools (v1.0: list returns page object)
+                current_tools_page = client.agents.tools.list(agent_id=str(agent.id))
+                current_tools = current_tools_page.items if hasattr(current_tools_page, 'items') else current_tools_page
                 tool_names = [t.name for t in current_tools]
 
                 # Check if already attached

requirements.txt

···
 httpx==0.28.1
 httpx-sse==0.4.0
 idna==3.10
-letta-client==0.1.235
+letta-client==1.0.0
 libipld==3.1.1
 markdown-it-py==3.0.0
 mdurl==0.1.2

send_to_void.py

···
     """Send a message to void and stream the response."""
     load_dotenv()
     
-    # Create Letta client
+    # Create Letta client (v1.0: token → api_key)
     client = Letta(
         base_url=os.getenv("LETTA_BASE_URL", "http://localhost:8283"),
-        token=os.getenv("LETTA_API_KEY")
+        api_key=os.getenv("LETTA_API_KEY")
     )
     
-    # Get the void agent
-    agents = client.agents.list()
+    # Get the void agent (v1.0: list returns page object)
+    agents_page = client.agents.list()
+    agents = agents_page.items if hasattr(agents_page, 'items') else agents_page
     void_agent = next((a for a in agents if a.name == "void"), None)
     
     if not void_agent:
···
     
     # Send message and stream response
     try:
-        # Use the streaming interface
-        message_stream = client.agents.messages.create_stream(
+        # Use the streaming interface (v1.0: create_stream → stream)
+        message_stream = client.agents.messages.stream(
             agent_id=void_agent.id,
             messages=[{"role": "user", "content": message}],
             stream_tokens=False,  # Step streaming only
···
     send_message_to_void(message)
 
 if __name__ == "__main__":
-    main()
+    main()

show_agent_capabilities.py

···
 def show_agent_capabilities():
     """Display the capabilities of both agents."""
     
-    client = Letta(token=os.environ["LETTA_API_KEY"])
+    client = Letta(api_key=os.environ["LETTA_API_KEY"])  # v1.0: token → api_key
     
     print("🤖 LETTA AGENT CAPABILITIES")
     print("=" * 50)
     
-    # Profile Researcher Agent
-    researchers = client.agents.list(name="profile-researcher")
+    # Profile Researcher Agent (v1.0: list returns page object)
+    researchers_page = client.agents.list(name="profile-researcher")
+    researchers = researchers_page.items if hasattr(researchers_page, 'items') else researchers_page
     if researchers:
         researcher = researchers[0]
         print(f"\n📊 PROFILE RESEARCHER AGENT")
         print(f"   ID: {researcher.id}")
         print(f"   Name: {researcher.name}")
         
-        researcher_tools = client.agents.tools.list(agent_id=researcher.id)
+        researcher_tools_page = client.agents.tools.list(agent_id=researcher.id)
+        researcher_tools = researcher_tools_page.items if hasattr(researcher_tools_page, 'items') else researcher_tools_page
         print(f"   Tools ({len(researcher_tools)}):")
         for tool in researcher_tools:
             print(f"     - {tool.name}")
         
-        researcher_blocks = client.agents.blocks.list(agent_id=researcher.id)
+        researcher_blocks_page = client.agents.blocks.list(agent_id=researcher.id)
+        researcher_blocks = researcher_blocks_page.items if hasattr(researcher_blocks_page, 'items') else researcher_blocks_page
         print(f"   Memory Blocks ({len(researcher_blocks)}):")
         for block in researcher_blocks:
             print(f"     - {block.label}")
     
-    # Void Agent
-    voids = client.agents.list(name="void")
+    # Void Agent (v1.0: list returns page object)
+    voids_page = client.agents.list(name="void")
+    voids = voids_page.items if hasattr(voids_page, 'items') else voids_page
     if voids:
         void = voids[0]
         print(f"\n🌌 VOID AGENT")
         print(f"   ID: {void.id}")
         print(f"   Name: {void.name}")
         
-        void_tools = client.agents.tools.list(agent_id=void.id)
+        void_tools_page = client.agents.tools.list(agent_id=void.id)
+        void_tools = void_tools_page.items if hasattr(void_tools_page, 'items') else void_tools_page
         print(f"   Tools ({len(void_tools)}):")
         for tool in void_tools:
             print(f"     - {tool.name}")
         
-        void_blocks = client.agents.blocks.list(agent_id=void.id)
+        void_blocks_page = client.agents.blocks.list(agent_id=void.id)
+        void_blocks = void_blocks_page.items if hasattr(void_blocks_page, 'items') else void_blocks_page
         print(f"   Memory Blocks ({len(void_blocks)}):")
         for block in void_blocks:
             print(f"     - {block.label}")
···
     print(f"   Void Agent: 'Attach user block for cameron.pfiffer.org before responding'")
 
 if __name__ == "__main__":
-    show_agent_capabilities()
+    show_agent_capabilities()

tool_manager.py

···
     'halt_activity',
     'ignore_notification',
     'annotate_ack',
-    'create_whitewind_blog_post',
+    'blog_post_create',
     'fetch_webpage',
 }
 
···
 
     try:
         # Initialize Letta client with proper base_url for self-hosted servers
-        client_params = {'token': api_key}
+        client_params = {'api_key': api_key}  # v1.0: token → api_key
         if letta_config.get('base_url'):
             client_params['base_url'] = letta_config['base_url']
         client = Letta(**client_params)
···
 
     try:
         # Initialize Letta client with proper base_url for self-hosted servers
-        client_params = {'token': api_key}
+        client_params = {'api_key': api_key}  # v1.0: token → api_key
         if letta_config.get('base_url'):
             client_params['base_url'] = letta_config['base_url']
         client = Letta(**client_params)
         agent = client.agents.retrieve(agent_id=agent_id)
-        current_tools = client.agents.tools.list(agent_id=str(agent.id))
+        # v1.0: list returns page object
+        current_tools_page = client.agents.tools.list(agent_id=str(agent.id))
+        current_tools = current_tools_page.items if hasattr(current_tools_page, 'items') else current_tools_page
         return {tool.name for tool in current_tools}
     except Exception as e:
         logger.error(f"Error getting attached tools: {e}")

tools/__init__.py

···
 from .search import search_bluesky_posts, SearchArgs
 from .post import create_new_bluesky_post, PostArgs
 from .feed import get_bluesky_feed, FeedArgs
-from .whitewind import create_whitewind_blog_post, WhitewindPostArgs
+from .whitewind import blog_post_create, BlogPostCreateArgs
 from .ack import annotate_ack, AnnotateAckArgs
 
 __all__ = [
···
     "search_bluesky_posts",
     "create_new_bluesky_post",
     "get_bluesky_feed",
-    "create_whitewind_blog_post",
+    "blog_post_create",
     "annotate_ack",
     # Pydantic models
     "SearchArgs",
     "PostArgs",
     "FeedArgs",
-    "WhitewindPostArgs",
+    "BlogPostCreateArgs",
     "AnnotateAckArgs",
 ]

tools/bot_detection.py

···
     
     try:
         # Create Letta client inline (for cloud execution)
-        client = Letta(token=os.environ["LETTA_API_KEY"])
+        client = Letta(api_key=os.environ["LETTA_API_KEY"])  # v1.0: token → api_key
         
         # Get all blocks attached to the agent to check if known_bots is mounted
-        attached_blocks = client.agents.blocks.list(agent_id=str(agent_state.id))
+        # v1.0: list returns page object
+        attached_blocks_page = client.agents.blocks.list(agent_id=str(agent_state.id))
+        attached_blocks = attached_blocks_page.items if hasattr(attached_blocks_page, 'items') else attached_blocks_page
         attached_labels = {block.label for block in attached_blocks}
         
         if "known_bots" not in attached_labels:

tools/whitewind.py

···
-"""Whitewind blog post creation tool."""
+"""Greengale blog post creation tool.
+
+Creates blog posts on Greengale (https://greengale.app), an ATProto-based blogging service.
+Posts are created using the app.greengale.blog.entry lexicon and served at greengale.app.
+"""
 from typing import Optional
 from pydantic import BaseModel, Field
 
 
-class WhitewindPostArgs(BaseModel):
+class BlogPostCreateArgs(BaseModel):
     title: str = Field(
         ..., 
         description="Title of the blog post"
···
     )
 
 
-def create_whitewind_blog_post(title: str, content: str, subtitle: Optional[str] = None) -> str:
+def blog_post_create(title: str, content: str, subtitle: Optional[str] = None) -> str:
     """
-    Create a new blog post on Whitewind.
+    Create a new blog post on Greengale.
     
-    This tool creates blog posts using the com.whtwnd.blog.entry lexicon on the ATProto network.
-    The posts are publicly visible and use the github-light theme.
+    This tool creates blog posts using the app.greengale.blog.entry lexicon on the ATProto network.
+    Blog posts are publicly visible and use the github-light theme.
+    
+    The blog post will be served at: https://greengale.app/{handle}/{post_id}
     
     Args:
         title: Title of the blog post
···
         subtitle: Optional subtitle for the blog post
         
     Returns:
-        Success message with the blog post URL
+        Success message with the blog post URL on greengale.app
         
     Raises:
         Exception: If the post creation fails
···
         now = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
         
         blog_record = {
-            "$type": "com.whtwnd.blog.entry",
+            "$type": "app.greengale.blog.entry",
             "theme": "github-light",
             "title": title,
             "content": content,
···
         
         create_data = {
             "repo": user_did,
-            "collection": "com.whtwnd.blog.entry",
+            "collection": "app.greengale.blog.entry",
             "record": blog_record
         }
         
···
         post_uri = result.get("uri")
         if post_uri:
             rkey = post_uri.split("/")[-1]
-            # Construct the Whitewind blog URL
-            blog_url = f"https://whtwnd.com/{handle}/{rkey}"
+            # Construct the Greengale blog URL
+            blog_url = f"https://greengale.app/{handle}/{rkey}"
         else:
             blog_url = "URL generation failed"
         
         # Build success message
         success_parts = [
-            f"Successfully created Whitewind blog post!",
+            f"Successfully created blog post on Greengale!",
             f"Title: {title}"
         ]
         if subtitle:
···
         return "\n".join(success_parts)
         
     except Exception as e:
-        raise Exception(f"Error creating Whitewind blog post: {str(e)}")
+        raise Exception(f"Error creating blog post: {str(e)}")

utils.py

···
     Ensures that a block by this label exists. If the block exists, it will
     replace content provided by kwargs with the values in this function call.
     """
-    # Get the list of blocks
-    blocks = letta.blocks.list(label=label)
+    # Get the list of blocks (v1.0: list returns page object)
+    blocks_page = letta.blocks.list(label=label)
+    blocks = blocks_page.items if hasattr(blocks_page, 'items') else blocks_page
 
     # Check if we had any -- if not, create it
     if len(blocks) == 0:
···
         existing_block = blocks[0]
 
         if kwargs.get('update', False):
-            # Remove 'update' from kwargs before passing to modify
+            # Remove 'update' from kwargs before passing to update
             kwargs_copy = kwargs.copy()
             kwargs_copy.pop('update', None)
             
-            updated_block = letta.blocks.modify(
+            updated_block = letta.blocks.update(
                 block_id = existing_block.id,
                 label = label,
                 value = value,
···
     Ensures that an agent by this label exists. If the agent exists, it will
     update the agent to match kwargs.
     """
-    # Get the list of agents
-    agents = letta.agents.list(name=name)
+    # Get the list of agents (v1.0: list returns page object)
+    agents_page = letta.agents.list(name=name)
+    agents = agents_page.items if hasattr(agents_page, 'items') else agents_page
 
     # Check if we had any -- if not, create it
     if len(agents) == 0:
···
         return new_agent
 
     if len(agents) > 1:
-        raise Exception(f"{len(agents)} agents by the label '{label}' retrieved, label must identify a unique agent")
+        raise Exception(f"{len(agents)} agents by the name '{name}' retrieved, name must identify a unique agent")
     
     else:
         existing_agent = agents[0]
 
         if kwargs.get('update', False):
-            # Remove 'update' from kwargs before passing to modify
+            # Remove 'update' from kwargs before passing to update
             kwargs_copy = kwargs.copy()
             kwargs_copy.pop('update', None)
             
-            updated_agent = letta.agents.modify(
+            updated_agent = letta.agents.update(
                 agent_id = existing_agent.id,
                 **kwargs_copy
             )
···
             return updated_agent
         else:
             return existing_agent
-        
-        
-
-    
-
-    
-    
-
-    
-
-    
-    

x.py

···
         rprint(Panel(prompt, title=f"Prompt ({prompt_char_count} chars)", border_style="blue"))
 
         # Send to Letta agent using streaming
-        message_stream = letta_client.agents.messages.create_stream(
+        message_stream = letta_client.agents.messages.stream(
             agent_id=agent_id,
             messages=[{"role": "user", "content": prompt}],
             stream_tokens=False,
···
         from letta_client import Letta
 
         config = get_x_letta_config()
-        letta_client = Letta(token=config['api_key'], timeout=config['timeout'])
+        letta_client = Letta(api_key=config['api_key'], timeout=config['timeout'])  # v1.0: token → api_key
         
         prompt_char_count = len(prompt)
         logger.debug(f"Sending to LLM: @{author_username} mention | msg: \"{mention_text[:50]}...\" | context: {len(thread_context)} chars | prompt: {prompt_char_count} chars")
         
         try:
             # Use streaming to avoid timeout errors
-            message_stream = letta_client.agents.messages.create_stream(
+            message_stream = letta_client.agents.messages.stream(
                 agent_id=void_agent.id,
                 messages=[{"role": "user", "content": prompt}],
                 stream_tokens=False,
···
     
     # Get Letta client for periodic cleanup
     config = get_x_letta_config()
-    letta_client = Letta(token=config['api_key'], timeout=config['timeout'])
+    letta_client = Letta(api_key=config['api_key'], timeout=config['timeout'])  # v1.0: token → api_key
     
     # Main loop
     FETCH_DELAY_SEC = 120  # Check every 2 minutes for X mentions (reduced from 60s to conserve API calls)