docs changes (#678)

Co-authored-by: Claude Opus 4.5 <[email protected]>

2 files changed, 73 insertions, 49 deletions

diff --git a/packages/openai-sdk-python/src/supermemory_openai/middleware.py b/packages/openai-sdk-python/src/supermemory_openai/middleware.py
index e2399bb6..4f6dc8ec 100644
--- a/packages/openai-sdk-python/src/supermemory_openai/middleware.py
+++ b/packages/openai-sdk-python/src/supermemory_openai/middleware.py
@@ -1,31 +1,31 @@
 """Supermemory middleware for OpenAI clients."""
 
-from dataclasses import dataclass
-from typing import Optional, Union, Any, Literal, cast
 import asyncio
 import os
+from dataclasses import dataclass
+from typing import Any, Literal, Optional, Union, cast
 
-from openai import OpenAI, AsyncOpenAI
+import supermemory
+from openai import AsyncOpenAI, OpenAI
 from openai.types.chat import (
     ChatCompletionMessageParam,
     ChatCompletionSystemMessageParam,
 )
-import supermemory
 
-from .utils import (
-    Logger,
-    create_logger,
-    get_last_user_message,
-    get_conversation_content,
-    convert_profile_to_markdown,
-    deduplicate_memories,
-)
 from .exceptions import (
-    SupermemoryConfigurationError,
     SupermemoryAPIError,
+    SupermemoryConfigurationError,
     SupermemoryMemoryOperationError,
     SupermemoryNetworkError,
 )
+from .utils import (
+    Logger,
+    convert_profile_to_markdown,
+    create_logger,
+    deduplicate_memories,
+    get_conversation_content,
+    get_last_user_message,
+)
 
 
 @dataclass
@@ -75,7 +75,7 @@ async def supermemory_profile_search(
                     raise SupermemoryAPIError(
                         "Supermemory profile search failed",
                         status_code=response.status,
-                        response_text=error_text
+                        response_text=error_text,
                     )
 
                 data = await response.json()
@@ -98,7 +98,7 @@ async def supermemory_profile_search(
             raise SupermemoryAPIError(
                 "Supermemory profile search failed",
                 status_code=response.status_code,
-                response_text=response.text
+                response_text=response.text,
             )
 
         return SupermemoryProfileSearch(response.json())
@@ -146,9 +146,18 @@ async def add_system_prompt(
     logger.debug(
         "Memory deduplication completed",
         {
-            "static": {"original": memory_count_static, "deduplicated": len(deduplicated.static)},
-            "dynamic": {"original": memory_count_dynamic, "deduplicated": len(deduplicated.dynamic)},
-            "search_results": {"original": memory_count_search, "deduplicated": len(deduplicated.search_results)},
+            "static": {
+                "original": memory_count_static,
+                "deduplicated": len(deduplicated.static),
+            },
+            "dynamic": {
+                "original": memory_count_dynamic,
+                "deduplicated": len(deduplicated.dynamic),
+            },
+            "search_results": {
+                "original": memory_count_search,
+                "deduplicated": len(deduplicated.search_results),
+            },
         },
     )
 
@@ -217,10 +226,10 @@ async def add_memory_tool(
 
         # Handle both sync and async supermemory clients
         try:
-            response = await client.memories.add(**add_params)
+            response = await client.add(**add_params)
         except TypeError:
             # If it's not awaitable, call it synchronously
-            response = client.memories.add(**add_params)
+            response = client.add(**add_params)
 
         logger.info(
             "Memory saved successfully",
@@ -237,18 +246,14 @@ async def add_memory_tool(
             {"error": str(network_error)},
         )
         raise SupermemoryNetworkError(
-            "Failed to save memory due to network error",
-            network_error
+            "Failed to save memory due to network error", network_error
         )
     except Exception as error:
         logger.error(
             "Error saving memory",
             {"error": str(error)},
         )
-        raise SupermemoryMemoryOperationError(
-            "Failed to save memory",
-            error
-        )
+        raise SupermemoryMemoryOperationError("Failed to save memory", error)
 
 
 class SupermemoryOpenAIWrapper:
@@ -271,16 +276,17 @@ class SupermemoryOpenAIWrapper:
         if not hasattr(supermemory, "Supermemory"):
             raise SupermemoryConfigurationError(
                 "supermemory package is required but not found",
-                ImportError("supermemory package not installed")
+                ImportError("supermemory package not installed"),
             )
 
         api_key = self._get_api_key()
         try:
-            self._supermemory_client: supermemory.Supermemory = supermemory.Supermemory(api_key=api_key)
+            self._supermemory_client: supermemory.Supermemory = supermemory.Supermemory(
+                api_key=api_key
+            )
         except Exception as e:
             raise SupermemoryConfigurationError(
-                f"Failed to initialize Supermemory client: {e}",
-                e
+                f"Failed to initialize Supermemory client: {e}", e
             )
 
         # Wrap the chat completions create method
@@ -359,15 +365,24 @@ class SupermemoryOpenAIWrapper:
                     try:
                         if task_obj.exception() is not None:
                             exception = task_obj.exception()
-                            if isinstance(exception, (SupermemoryNetworkError, SupermemoryAPIError)):
+                            if isinstance(
+                                exception,
+                                (SupermemoryNetworkError, SupermemoryAPIError),
+                            ):
                                 self._logger.warn(
                                     "Background memory storage failed",
-                                    {"error": str(exception), "type": type(exception).__name__}
+                                    {
+                                        "error": str(exception),
+                                        "type": type(exception).__name__,
+                                    },
                                 )
                             else:
                                 self._logger.error(
                                     "Unexpected error in background memory storage",
-                                    {"error": str(exception), "type": type(exception).__name__}
+                                    {
+                                        "error": str(exception),
+                                        "type": type(exception).__name__,
+                                    },
                                 )
                     except asyncio.CancelledError:
                         self._logger.debug("Memory storage task was cancelled")
@@ -440,7 +455,7 @@ class SupermemoryOpenAIWrapper:
                         # We're in an async context, log warning and skip memory saving
                         self._logger.warn(
                             "Cannot save memory in sync client from async context",
-                            {"error": str(e)}
+                            {"error": str(e)},
                         )
                     else:
                         raise
@@ -454,7 +469,7 @@ class SupermemoryOpenAIWrapper:
                     # Unexpected errors should be investigated
                     self._logger.error(
                         "Unexpected error saving memory",
-                        {"error": str(e), "type": type(e).__name__}
+                        {"error": str(e), "type": type(e).__name__},
                     )
 
         # Handle memory search and injection
@@ -464,11 +479,14 @@ class SupermemoryOpenAIWrapper:
                 self._logger.debug("No user message found, skipping memory search")
                 return original_create(**kwargs)
 
-        self._logger.info("Starting memory search", {
-            "container_tag": self._container_tag,
-            "conversation_id": self._options.conversation_id,
-            "mode": self._options.mode,
-        })
+        self._logger.info(
+            "Starting memory search",
+            {
+                "container_tag": self._container_tag,
+                "conversation_id": self._options.conversation_id,
+                "mode": self._options.mode,
+            },
+        )
 
         # Use asyncio.run() for memory search and injection
         try:
@@ -495,7 +513,7 @@ class SupermemoryOpenAIWrapper:
                             self._logger,
                             self._options.mode,
                             self._get_api_key(),
-                        )
+                        ),
                     )
                     enhanced_messages = future.result()
             else:
@@ -517,20 +535,24 @@ class SupermemoryOpenAIWrapper:
         if not self._background_tasks:
             return
 
-        self._logger.debug(f"Waiting for {len(self._background_tasks)} background tasks to complete")
+        self._logger.debug(
+            f"Waiting for {len(self._background_tasks)} background tasks to complete"
+        )
 
         try:
             if timeout is not None:
                 await asyncio.wait_for(
                     asyncio.gather(*self._background_tasks, return_exceptions=True),
-                    timeout=timeout
+                    timeout=timeout,
                 )
             else:
                 await asyncio.gather(*self._background_tasks, return_exceptions=True)
 
             self._logger.debug("All background tasks completed")
         except asyncio.TimeoutError:
-            self._logger.warn(f"Background tasks did not complete within {timeout}s timeout")
+            self._logger.warn(
+                f"Background tasks did not complete within {timeout}s timeout"
+            )
             # Cancel remaining tasks
             for task in self._background_tasks:
                 if not task.done():
@@ -580,7 +602,9 @@ class SupermemoryOpenAIWrapper:
                 else:
                     raise
             except asyncio.TimeoutError:
-                self._logger.warn("Some background memory tasks did not complete on exit")
+                self._logger.warn(
+                    "Some background memory tasks did not complete on exit"
+                )
                 self.cancel_background_tasks()
 
     def __getattr__(self, name: str) -> Any:
diff --git a/packages/openai-sdk-python/src/supermemory_openai/tools.py b/packages/openai-sdk-python/src/supermemory_openai/tools.py
index 111253cd..87c19428 100644
--- a/packages/openai-sdk-python/src/supermemory_openai/tools.py
+++ b/packages/openai-sdk-python/src/supermemory_openai/tools.py
@@ -1,14 +1,14 @@
 """Supermemory tools for OpenAI function calling."""
 
 import json
-from typing import Dict, List, Optional, Union, TypedDict
+from typing import Dict, List, Optional, TypedDict, Union
 
+import supermemory
 from openai.types.chat import (
+    ChatCompletionFunctionToolParam,
     ChatCompletionMessageToolCall,
     ChatCompletionToolMessageParam,
-    ChatCompletionFunctionToolParam,
 )
-import supermemory
 from supermemory.types import (
     MemoryAddResponse,
     MemoryGetResponse,
@@ -230,7 +230,7 @@ class SupermemoryTools:
             if metadata:
                 add_params["metadata"] = metadata
 
-            response: MemoryAddResponse = await self.client.memories.add(**add_params)
+            response: MemoryAddResponse = await self.client.add(**add_params)
 
             return MemoryAddResult(
                 success=True,