Skip to content

armgit / letta

Public Imported from GitHub
0

Platform for stateful agents: AI with advanced memory that can learn and self-improve over time.

test: migrate sources test to 1.0 sdk [LET-6317] (#6367)

cthomas0ecf72567aed
diff --git a/tests/helpers/utils.py b/tests/helpers/utils.py
index eaf989f97..52b13bc7d 100644
--- a/tests/helpers/utils.py
+++ b/tests/helpers/utils.py
@@ -1,7 +1,7 @@
import functools
import os
import time
-from typing import Optional, Union
+from typing import Any, Optional, Union
from letta_client import AsyncLetta, Letta
@@ -294,22 +294,32 @@ def upload_file_and_wait(
"""Helper function to upload a file and wait for processing to complete"""
with open(file_path, "rb") as f:
if duplicate_handling:
- file_metadata = client.sources.files.upload(source_id=source_id, file=f, duplicate_handling=duplicate_handling, name=name)
+ file_metadata = client.folders.files.upload(folder_id=source_id, file=f, duplicate_handling=duplicate_handling, name=name)
else:
- file_metadata = client.sources.files.upload(source_id=source_id, file=f, name=name)
+ file_metadata = client.folders.files.upload(folder_id=source_id, file=f, name=name)
# wait for the file to be processed
start_time = time.time()
- while file_metadata.processing_status != "completed" and file_metadata.processing_status != "error":
+ file_metadata_id = file_metadata.id
+ processing_status = file_metadata.processing_status
+ while processing_status != "completed" and processing_status != "error":
if time.time() - start_time > max_wait:
raise TimeoutError(f"File processing timed out after {max_wait} seconds")
time.sleep(1)
- file_metadata = client.sources.get_file_metadata(source_id=source_id, file_id=file_metadata.id)
- print("Waiting for file processing to complete...", file_metadata.processing_status)
+ file_metadata = client.get(
+ path=f"/v1/sources/{source_id}/files/{file_metadata_id}",
+ cast_to=dict[str, Any],
+ )
+ print("Waiting for file processing to complete...", file_metadata["processing_status"])
+ processing_status = file_metadata["processing_status"]
- if file_metadata.processing_status == "error":
+ if isinstance(file_metadata, dict) and file_metadata["processing_status"] == "error":
+ raise RuntimeError(f"File processing failed: {file_metadata['error_message']}")
+ elif hasattr(file_metadata, "processing_status") and file_metadata.processing_status == "error":
raise RuntimeError(f"File processing failed: {file_metadata.error_message}")
+ if not isinstance(file_metadata, dict):
+ file_metadata = file_metadata.model_dump()
return file_metadata
diff --git a/tests/test_sources.py b/tests/test_sources.py
index 39eb82aec..e4d14d69b 100644
--- a/tests/test_sources.py
+++ b/tests/test_sources.py
@@ -5,11 +5,13 @@ import tempfile
import threading
import time
from datetime import datetime, timedelta
+from typing import Any
import pytest
from dotenv import load_dotenv
-from letta_client import CreateBlock, Letta as LettaSDKClient, LettaRequest, MessageCreate as ClientMessageCreate
-from letta_client.types import AgentState
+from letta_client import Letta as LettaSDKClient
+from letta_client.types import CreateBlockParam
+from letta_client.types.agent_state import AgentState
from letta.constants import DEFAULT_ORG_ID, FILES_TOOLS
from letta.helpers.pinecone_utils import should_use_pinecone
@@ -27,16 +29,17 @@ SERVER_PORT = 8283
def get_raw_system_message(client: LettaSDKClient, agent_id: str) -> str:
"""Helper function to get the raw system message from an agent's preview payload."""
- raw_payload = client.agents.messages.preview_raw_payload(
- agent_id=agent_id,
- request=LettaRequest(
- messages=[
- ClientMessageCreate(
- role="user",
- content="Testing",
- )
+ raw_payload = client.post(
+ f"/v1/agents/{agent_id}/messages/preview-raw-payload",
+ cast_to=dict[str, Any],
+ body={
+ "messages": [
+ {
+ "role": "user",
+ "content": "Testing",
+ }
],
- ),
+ },
)
return raw_payload["messages"][0]["content"]
@@ -44,8 +47,8 @@ def get_raw_system_message(client: LettaSDKClient, agent_id: str) -> str:
@pytest.fixture(autouse=True)
def clear_sources(client: LettaSDKClient):
# Clear existing sources
- for source in client.sources.list():
- client.sources.delete(source_id=source.id)
+ for source in list(client.folders.list()):
+ client.folders.delete(folder_id=source.id)
def run_server():
@@ -67,21 +70,21 @@ def client() -> LettaSDKClient:
thread.start()
wait_for_server(server_url)
print("Running client tests with server:", server_url)
- client = LettaSDKClient(base_url=server_url, token=None)
+ client = LettaSDKClient(base_url=server_url)
client.tools.upsert_base_tools()
yield client
@pytest.fixture
def agent_state(disable_pinecone, client: LettaSDKClient):
- open_file_tool = client.tools.list(name="open_files")[0]
- search_files_tool = client.tools.list(name="semantic_search_files")[0]
- grep_tool = client.tools.list(name="grep_files")[0]
+ open_file_tool = list(client.tools.list(name="open_files"))[0]
+ search_files_tool = list(client.tools.list(name="semantic_search_files"))[0]
+ grep_tool = list(client.tools.list(name="grep_files"))[0]
agent_state = client.agents.create(
name="test_sources_agent",
memory_blocks=[
- CreateBlock(
+ CreateBlockParam(
label="human",
value="username: sarah",
),
@@ -101,7 +104,7 @@ def test_auto_attach_detach_files_tools(disable_pinecone, disable_turbopuffer, c
# Create agent with basic configuration
agent = client.agents.create(
memory_blocks=[
- CreateBlock(label="human", value="username: sarah"),
+ CreateBlockParam(label="human", value="username: sarah"),
],
model="openai/gpt-4o-mini",
embedding="openai/text-embedding-3-small",
@@ -125,28 +128,32 @@ def test_auto_attach_detach_files_tools(disable_pinecone, disable_turbopuffer, c
assert_no_file_tools(agent)
# Create and attach first source
- source_1 = client.sources.create(name="test_source", embedding="openai/text-embedding-3-small")
- assert len(client.sources.list()) == 1
+ source_1 = client.folders.create(name="test_source", embedding="openai/text-embedding-3-small")
+ assert len(list(client.folders.list())) == 1
- agent = client.agents.sources.attach(source_id=source_1.id, agent_id=agent.id)
- assert len(client.agents.retrieve(agent_id=agent.id).sources) == 1
+ client.agents.folders.attach(folder_id=source_1.id, agent_id=agent.id)
+ agent = client.agents.retrieve(agent_id=agent.id, include=["agent.sources", "agent.tools"])
+ assert len(agent.sources) == 1
assert_file_tools_present(agent, set(FILES_TOOLS))
# Create and attach second source
- source_2 = client.sources.create(name="another_test_source", embedding="openai/text-embedding-3-small")
- assert len(client.sources.list()) == 2
+ source_2 = client.folders.create(name="another_test_source", embedding="openai/text-embedding-3-small")
+ assert len(list(client.folders.list())) == 2
- agent = client.agents.sources.attach(source_id=source_2.id, agent_id=agent.id)
- assert len(client.agents.retrieve(agent_id=agent.id).sources) == 2
+ client.agents.folders.attach(folder_id=source_2.id, agent_id=agent.id)
+ agent = client.agents.retrieve(agent_id=agent.id, include=["agent.sources", "agent.tools"])
+ assert len(agent.sources) == 2
# File tools should remain after attaching second source
assert_file_tools_present(agent, set(FILES_TOOLS))
# Detach second source - tools should remain (first source still attached)
- agent = client.agents.sources.detach(source_id=source_2.id, agent_id=agent.id)
+ client.agents.folders.detach(folder_id=source_2.id, agent_id=agent.id)
+ agent = client.agents.retrieve(agent_id=agent.id, include=["agent.sources", "agent.tools"])
assert_file_tools_present(agent, set(FILES_TOOLS))
# Detach first source - all file tools should be removed
- agent = client.agents.sources.detach(source_id=source_1.id, agent_id=agent.id)
+ client.agents.folders.detach(folder_id=source_1.id, agent_id=agent.id)
+ agent = client.agents.retrieve(agent_id=agent.id, include=["agent.sources", "agent.tools"])
assert_no_file_tools(agent)
@@ -185,22 +192,22 @@ def test_file_upload_creates_source_blocks_correctly(
settings.mistral_api_key = None
# Create a new source
- source = client.sources.create(name="test_source", embedding="openai/text-embedding-3-small")
- assert len(client.sources.list()) == 1
+ source = client.folders.create(name="test_source", embedding="openai/text-embedding-3-small")
+ assert len(list(client.folders.list())) == 1
# Attach
- client.agents.sources.attach(source_id=source.id, agent_id=agent_state.id)
+ client.agents.folders.attach(folder_id=source.id, agent_id=agent_state.id)
# Upload the file
upload_file_and_wait(client, source.id, file_path)
# Get uploaded files
- files = client.sources.files.list(source_id=source.id, limit=1)
+ files = list(client.folders.files.list(folder_id=source.id, limit=1))
assert len(files) == 1
assert files[0].source_id == source.id
# Check that blocks were created
- agent_state = client.agents.retrieve(agent_id=agent_state.id)
+ agent_state = client.agents.retrieve(agent_id=agent_state.id, include=["agent.blocks"])
blocks = agent_state.memory.file_blocks
assert len(blocks) == 1
assert any(expected_value in b.value for b in blocks)
@@ -217,10 +224,10 @@ def test_file_upload_creates_source_blocks_correctly(
assert 'status="open"' in raw_system_message
# Remove file from source
- client.sources.files.delete(source_id=source.id, file_id=files[0].id)
+ client.folders.files.delete(folder_id=source.id, file_id=files[0].id)
# Confirm blocks were removed
- agent_state = client.agents.retrieve(agent_id=agent_state.id)
+ agent_state = client.agents.retrieve(agent_id=agent_state.id, include=["agent.blocks"])
blocks = agent_state.memory.file_blocks
assert len(blocks) == 0
assert not any(expected_value in b.value for b in blocks)
@@ -243,8 +250,8 @@ def test_attach_existing_files_creates_source_blocks_correctly(
disable_pinecone, disable_turbopuffer, client: LettaSDKClient, agent_state: AgentState
):
# Create a new source
- source = client.sources.create(name="test_source", embedding="openai/text-embedding-3-small")
- assert len(client.sources.list()) == 1
+ source = client.folders.create(name="test_source", embedding="openai/text-embedding-3-small")
+ assert len(list(client.folders.list())) == 1
# Load files into the source
file_path = "tests/data/test.txt"
@@ -253,12 +260,12 @@ def test_attach_existing_files_creates_source_blocks_correctly(
upload_file_and_wait(client, source.id, file_path)
# Get the first file with pagination
- files = client.sources.files.list(source_id=source.id, limit=1)
+ files = list(client.folders.files.list(folder_id=source.id, limit=1))
assert len(files) == 1
assert files[0].source_id == source.id
# Attach after uploading the file
- client.agents.sources.attach(source_id=source.id, agent_id=agent_state.id)
+ client.agents.folders.attach(folder_id=source.id, agent_id=agent_state.id)
raw_system_message = get_raw_system_message(client, agent_state.id)
# Assert that the expected chunk is in the raw system message
@@ -284,17 +291,17 @@ def test_attach_existing_files_creates_source_blocks_correctly(
assert expected_chunk in raw_system_message
# Get the agent state, check blocks exist
- agent_state = client.agents.retrieve(agent_id=agent_state.id)
+ agent_state = client.agents.retrieve(agent_id=agent_state.id, include=["agent.blocks"])
blocks = agent_state.memory.file_blocks
assert len(blocks) == 1
assert any("test" in b.value for b in blocks)
assert any(b.value.startswith("[Viewing file start") for b in blocks)
# Detach the source
- client.agents.sources.detach(source_id=source.id, agent_id=agent_state.id)
+ client.agents.folders.detach(folder_id=source.id, agent_id=agent_state.id)
# Get the agent state, check blocks do NOT exist
- agent_state = client.agents.retrieve(agent_id=agent_state.id)
+ agent_state = client.agents.retrieve(agent_id=agent_state.id, include=["agent.blocks"])
blocks = agent_state.memory.file_blocks
assert len(blocks) == 0
assert not any("test" in b.value for b in blocks)
@@ -310,10 +317,10 @@ def test_delete_source_removes_source_blocks_correctly(
disable_pinecone, disable_turbopuffer, client: LettaSDKClient, agent_state: AgentState
):
# Create a new source
- source = client.sources.create(name="test_source", embedding="openai/text-embedding-3-small")
- assert len(client.sources.list()) == 1
+ source = client.folders.create(name="test_source", embedding="openai/text-embedding-3-small")
+ assert len(list(client.folders.list())) == 1
- client.agents.sources.attach(source_id=source.id, agent_id=agent_state.id)
+ client.agents.folders.attach(folder_id=source.id, agent_id=agent_state.id)
raw_system_message = get_raw_system_message(client, agent_state.id)
assert "test_source" in raw_system_message
assert "<directories>" in raw_system_message
@@ -347,20 +354,20 @@ def test_delete_source_removes_source_blocks_correctly(
assert expected_chunk in raw_system_message
# Get the agent state, check blocks exist
- agent_state = client.agents.retrieve(agent_id=agent_state.id)
+ agent_state = client.agents.retrieve(agent_id=agent_state.id, include=["agent.blocks"])
blocks = agent_state.memory.file_blocks
assert len(blocks) == 1
assert any("test" in b.value for b in blocks)
# Remove file from source
- client.sources.delete(source_id=source.id)
+ client.folders.delete(folder_id=source.id)
raw_system_message_after_detach = get_raw_system_message(client, agent_state.id)
assert expected_chunk not in raw_system_message_after_detach
assert "test_source" not in raw_system_message_after_detach
assert "<directories>" not in raw_system_message_after_detach
# Get the agent state, check blocks do NOT exist
- agent_state = client.agents.retrieve(agent_id=agent_state.id)
+ agent_state = client.agents.retrieve(agent_id=agent_state.id, include=["agent.blocks"])
blocks = agent_state.memory.file_blocks
assert len(blocks) == 0
assert not any("test" in b.value for b in blocks)
@@ -368,13 +375,13 @@ def test_delete_source_removes_source_blocks_correctly(
def test_agent_uses_open_close_file_correctly(disable_pinecone, disable_turbopuffer, client: LettaSDKClient, agent_state: AgentState):
# Create a new source
- source = client.sources.create(name="test_source", embedding="openai/text-embedding-3-small")
+ source = client.folders.create(name="test_source", embedding="openai/text-embedding-3-small")
- sources_list = client.sources.list()
+ sources_list = list(client.folders.list())
assert len(sources_list) == 1
# Attach source to agent
- client.agents.sources.attach(source_id=source.id, agent_id=agent_state.id)
+ client.agents.folders.attach(folder_id=source.id, agent_id=agent_state.id)
# Load files into the source
file_path = "tests/data/long_test.txt"
@@ -383,13 +390,13 @@ def test_agent_uses_open_close_file_correctly(disable_pinecone, disable_turbopuf
upload_file_and_wait(client, source.id, file_path)
# Get uploaded files
- files = client.sources.files.list(source_id=source.id, limit=1)
+ files = list(client.folders.files.list(folder_id=source.id, limit=1))
assert len(files) == 1
assert files[0].source_id == source.id
file = files[0]
# Check that file is opened initially
- agent_state = client.agents.retrieve(agent_id=agent_state.id)
+ agent_state = client.agents.retrieve(agent_id=agent_state.id, include=["agent.blocks"])
blocks = agent_state.memory.file_blocks
print(f"Agent has {len(blocks)} file block(s)")
if blocks:
@@ -414,8 +421,9 @@ def test_agent_uses_open_close_file_correctly(disable_pinecone, disable_turbopuf
print(open_response1.messages)
# Check that file is opened
- agent_state = client.agents.retrieve(agent_id=agent_state.id)
+ agent_state = client.agents.retrieve(agent_id=agent_state.id, include=["agent.blocks"])
blocks = agent_state.memory.file_blocks
+ assert len(blocks) == 1
old_value = blocks[0].value
old_content_length = len(old_value)
print(f"File content length after first open: {old_content_length} characters")
@@ -443,7 +451,7 @@ def test_agent_uses_open_close_file_correctly(disable_pinecone, disable_turbopuf
# Check that file is opened, but for different range
print("Verifying file is opened with second range...")
- agent_state = client.agents.retrieve(agent_id=agent_state.id)
+ agent_state = client.agents.retrieve(agent_id=agent_state.id, include=["agent.blocks"])
blocks = agent_state.memory.file_blocks
new_value = blocks[0].value
new_content_length = len(new_value)
@@ -471,13 +479,13 @@ def test_agent_uses_open_close_file_correctly(disable_pinecone, disable_turbopuf
def test_agent_uses_search_files_correctly(disable_pinecone, disable_turbopuffer, client: LettaSDKClient, agent_state: AgentState):
# Create a new source
- source = client.sources.create(name="test_source", embedding="openai/text-embedding-3-small")
+ source = client.folders.create(name="test_source", embedding="openai/text-embedding-3-small")
- sources_list = client.sources.list()
+ sources_list = list(client.folders.list())
assert len(sources_list) == 1
# Attach source to agent
- client.agents.sources.attach(source_id=source.id, agent_id=agent_state.id)
+ client.agents.folders.attach(folder_id=source.id, agent_id=agent_state.id)
# Load files into the source
file_path = "tests/data/long_test.txt"
@@ -485,10 +493,10 @@ def test_agent_uses_search_files_correctly(disable_pinecone, disable_turbopuffer
# Upload the files
file_metadata = upload_file_and_wait(client, source.id, file_path)
- print(f"File uploaded and processed: {file_metadata.file_name}")
+ print(f"File uploaded and processed: {file_metadata['file_name']}")
# Get uploaded files
- files = client.sources.files.list(source_id=source.id, limit=1)
+ files = list(client.folders.files.list(folder_id=source.id, limit=1))
assert len(files) == 1
assert files[0].source_id == source.id
@@ -517,13 +525,13 @@ def test_agent_uses_search_files_correctly(disable_pinecone, disable_turbopuffer
def test_agent_uses_grep_correctly_basic(disable_pinecone, disable_turbopuffer, client: LettaSDKClient, agent_state: AgentState):
# Create a new source
- source = client.sources.create(name="test_source", embedding="openai/text-embedding-3-small")
+ source = client.folders.create(name="test_source", embedding="openai/text-embedding-3-small")
- sources_list = client.sources.list()
+ sources_list = list(client.folders.list())
assert len(sources_list) == 1
# Attach source to agent
- client.agents.sources.attach(source_id=source.id, agent_id=agent_state.id)
+ client.agents.folders.attach(folder_id=source.id, agent_id=agent_state.id)
# Load files into the source
file_path = "tests/data/long_test.txt"
@@ -531,10 +539,12 @@ def test_agent_uses_grep_correctly_basic(disable_pinecone, disable_turbopuffer,
# Upload the files
file_metadata = upload_file_and_wait(client, source.id, file_path)
- print(f"File uploaded and processed: {file_metadata.file_name}")
+ if not isinstance(file_metadata, dict):
+ file_metadata = file_metadata.model_dump()
+ print(f"File uploaded and processed: {file_metadata['file_name']}")
# Get uploaded files
- files = client.sources.files.list(source_id=source.id, limit=1)
+ files = list(client.folders.files.list(folder_id=source.id, limit=1))
assert len(files) == 1
assert files[0].source_id == source.id
@@ -559,13 +569,13 @@ def test_agent_uses_grep_correctly_basic(disable_pinecone, disable_turbopuffer,
def test_agent_uses_grep_correctly_advanced(disable_pinecone, disable_turbopuffer, client: LettaSDKClient, agent_state: AgentState):
# Create a new source
- source = client.sources.create(name="test_source", embedding="openai/text-embedding-3-small")
+ source = client.folders.create(name="test_source", embedding="openai/text-embedding-3-small")
- sources_list = client.sources.list()
+ sources_list = list(client.folders.list())
assert len(sources_list) == 1
# Attach source to agent
- client.agents.sources.attach(source_id=source.id, agent_id=agent_state.id)
+ client.agents.folders.attach(folder_id=source.id, agent_id=agent_state.id)
# Load files into the source
file_path = "tests/data/list_tools.json"
@@ -573,10 +583,12 @@ def test_agent_uses_grep_correctly_advanced(disable_pinecone, disable_turbopuffe
# Upload the files
file_metadata = upload_file_and_wait(client, source.id, file_path)
- print(f"File uploaded and processed: {file_metadata.file_name}")
+ if not isinstance(file_metadata, dict):
+ file_metadata = file_metadata.model_dump()
+ print(f"File uploaded and processed: {file_metadata['file_name']}")
# Get uploaded files
- files = client.sources.files.list(source_id=source.id, limit=1)
+ files = list(client.folders.files.list(folder_id=source.id, limit=1))
assert len(files) == 1
assert files[0].source_id == source.id
@@ -608,15 +620,15 @@ def test_agent_uses_grep_correctly_advanced(disable_pinecone, disable_turbopuffe
def test_create_agent_with_source_ids_creates_source_blocks_correctly(disable_pinecone, disable_turbopuffer, client: LettaSDKClient):
"""Test that creating an agent with source_ids parameter correctly creates source blocks."""
# Create a new source
- source = client.sources.create(name="test_source", embedding="openai/text-embedding-3-small")
- assert len(client.sources.list()) == 1
+ source = client.folders.create(name="test_source", embedding="openai/text-embedding-3-small")
+ assert len(list(client.folders.list())) == 1
# Upload a file to the source before attaching
file_path = "tests/data/long_test.txt"
upload_file_and_wait(client, source.id, file_path)
# Get uploaded files to verify
- files = client.sources.files.list(source_id=source.id, limit=1)
+ files = list(client.folders.files.list(folder_id=source.id, limit=1))
assert len(files) == 1
assert files[0].source_id == source.id
@@ -624,7 +636,7 @@ def test_create_agent_with_source_ids_creates_source_blocks_correctly(disable_pi
temp_agent_state = client.agents.create(
name="test_agent_with_sources",
memory_blocks=[
- CreateBlock(
+ CreateBlockParam(
label="human",
value="username: sarah",
),
@@ -650,13 +662,13 @@ def test_create_agent_with_source_ids_creates_source_blocks_correctly(disable_pi
def test_view_ranges_have_metadata(disable_pinecone, disable_turbopuffer, client: LettaSDKClient, agent_state: AgentState):
# Create a new source
- source = client.sources.create(name="test_source", embedding="openai/text-embedding-3-small")
+ source = client.folders.create(name="test_source", embedding="openai/text-embedding-3-small")
- sources_list = client.sources.list()
+ sources_list = list(client.folders.list())
assert len(sources_list) == 1
# Attach source to agent
- client.agents.sources.attach(source_id=source.id, agent_id=agent_state.id)
+ client.agents.folders.attach(folder_id=source.id, agent_id=agent_state.id)
# Load files into the source
file_path = "tests/data/1_to_100.py"
@@ -665,13 +677,13 @@ def test_view_ranges_have_metadata(disable_pinecone, disable_turbopuffer, client
upload_file_and_wait(client, source.id, file_path)
# Get uploaded files
- files = client.sources.files.list(source_id=source.id, limit=1)
+ files = list(client.folders.files.list(folder_id=source.id, limit=1))
assert len(files) == 1
assert files[0].source_id == source.id
file = files[0]
# Check that file is opened initially
- agent_state = client.agents.retrieve(agent_id=agent_state.id)
+ agent_state = client.agents.retrieve(agent_id=agent_state.id, include=["agent.blocks"])
blocks = agent_state.memory.file_blocks
assert len(blocks) == 1
block = blocks[0]
@@ -693,7 +705,7 @@ def test_view_ranges_have_metadata(disable_pinecone, disable_turbopuffer, client
print(open_response.messages)
# Check that file is opened correctly
- agent_state = client.agents.retrieve(agent_id=agent_state.id)
+ agent_state = client.agents.retrieve(agent_id=agent_state.id, include=["agent.blocks"])
blocks = agent_state.memory.file_blocks
assert len(blocks) == 1
block = blocks[0]
@@ -714,22 +726,22 @@ def test_view_ranges_have_metadata(disable_pinecone, disable_turbopuffer, client
def test_duplicate_file_renaming(disable_pinecone, disable_turbopuffer, client: LettaSDKClient):
"""Test that duplicate files are renamed with count-based suffixes (e.g., file.txt, file (1).txt, file (2).txt)"""
# Create a new source
- source = client.sources.create(name="test_duplicate_source", embedding="openai/text-embedding-3-small")
+ source = client.folders.create(name="test_duplicate_source", embedding="openai/text-embedding-3-small")
# Upload the same file three times
file_path = "tests/data/test.txt"
with open(file_path, "rb") as f:
- first_file = client.sources.files.upload(source_id=source.id, file=f)
+ first_file = client.folders.files.upload(folder_id=source.id, file=f)
with open(file_path, "rb") as f:
- second_file = client.sources.files.upload(source_id=source.id, file=f)
+ second_file = client.folders.files.upload(folder_id=source.id, file=f)
with open(file_path, "rb") as f:
- third_file = client.sources.files.upload(source_id=source.id, file=f)
+ third_file = client.folders.files.upload(folder_id=source.id, file=f)
# Get all uploaded files
- files = client.sources.files.list(source_id=source.id, limit=10)
+ files = list(client.folders.files.list(folder_id=source.id, limit=10))
assert len(files) == 3, f"Expected 3 files, got {len(files)}"
# Sort files by creation time to ensure predictable order
@@ -753,13 +765,13 @@ def test_duplicate_file_renaming(disable_pinecone, disable_turbopuffer, client:
def test_duplicate_file_handling_replace(disable_pinecone, disable_turbopuffer, client: LettaSDKClient):
"""Test that DuplicateFileHandling.REPLACE replaces existing files with same name"""
# Create a new source
- source = client.sources.create(name="test_replace_source", embedding="openai/text-embedding-3-small")
+ source = client.folders.create(name="test_replace_source", embedding="openai/text-embedding-3-small")
# Create agent and attach source to test memory blocks
agent_state = client.agents.create(
name="test_replace_agent",
memory_blocks=[
- CreateBlock(label="human", value="username: sarah"),
+ CreateBlockParam(label="human", value="username: sarah"),
],
model="openai/gpt-4o-mini",
embedding="openai/text-embedding-3-small",
@@ -778,13 +790,13 @@ def test_duplicate_file_handling_replace(disable_pinecone, disable_turbopuffer,
upload_file_and_wait(client, source.id, temp_file_path)
# Verify original file was uploaded
- files = client.sources.files.list(source_id=source.id, limit=10)
+ files = list(client.folders.files.list(folder_id=source.id, limit=10))
assert len(files) == 1, f"Expected 1 file, got {len(files)}"
original_file = files[0]
assert original_file.original_file_name == temp_filename
# Get agent state and verify original content is in memory blocks
- agent_state = client.agents.retrieve(agent_id=agent_state.id)
+ agent_state = client.agents.retrieve(agent_id=agent_state.id, include=["agent.blocks"])
file_blocks = agent_state.memory.file_blocks
assert len(file_blocks) == 1, f"Expected 1 file block, got {len(file_blocks)}"
original_block_content = file_blocks[0].value
@@ -801,7 +813,7 @@ def test_duplicate_file_handling_replace(disable_pinecone, disable_turbopuffer,
replacement_file = upload_file_and_wait(client, source.id, temp_file_path, duplicate_handling=DuplicateFileHandling.REPLACE)
# Verify we still have only 1 file (replacement, not addition)
- files_after_replace = client.sources.files.list(source_id=source.id, limit=10)
+ files_after_replace = list(client.folders.files.list(folder_id=source.id, limit=10))
assert len(files_after_replace) == 1, f"Expected 1 file after replacement, got {len(files_after_replace)}"
replaced_file = files_after_replace[0]
@@ -814,7 +826,7 @@ def test_duplicate_file_handling_replace(disable_pinecone, disable_turbopuffer,
assert replaced_file.id != original_file.id, "Replacement file should have different ID"
# Verify agent memory blocks contain replacement content
- agent_state = client.agents.retrieve(agent_id=agent_state.id)
+ agent_state = client.agents.retrieve(agent_id=agent_state.id, include=["agent.blocks"])
updated_file_blocks = agent_state.memory.file_blocks
assert len(updated_file_blocks) == 1, f"Expected 1 file block after replacement, got {len(updated_file_blocks)}"
@@ -838,11 +850,11 @@ def test_upload_file_with_custom_name(disable_pinecone, disable_turbopuffer, cli
agent_state = client.agents.create(
name="test_agent_custom_name",
memory_blocks=[
- CreateBlock(
+ CreateBlockParam(
label="persona",
value="I am a helpful assistant",
),
- CreateBlock(
+ CreateBlockParam(
label="human",
value="The user is a developer",
),
@@ -852,10 +864,10 @@ def test_upload_file_with_custom_name(disable_pinecone, disable_turbopuffer, cli
)
# Create source
- source = client.sources.create(name="test_source_custom_name", embedding="openai/text-embedding-3-small")
+ source = client.folders.create(name="test_source_custom_name", embedding="openai/text-embedding-3-small")
# Attach source to agent
- client.agents.sources.attach(source_id=source.id, agent_id=agent_state.id)
+ client.agents.folders.attach(folder_id=source.id, agent_id=agent_state.id)
# Create a temporary file with specific content
import tempfile
@@ -869,19 +881,21 @@ def test_upload_file_with_custom_name(disable_pinecone, disable_turbopuffer, cli
# Upload file with custom name
custom_name = "my_custom_file_name.txt"
file_metadata = upload_file_and_wait(client, source.id, temp_file_path, name=custom_name)
+ if not isinstance(file_metadata, dict):
+ file_metadata = file_metadata.model_dump()
# Verify the file uses the custom name
- assert file_metadata.file_name == custom_name
- assert file_metadata.original_file_name == custom_name
+ assert file_metadata["file_name"] == custom_name
+ assert file_metadata["original_file_name"] == custom_name
# Verify file appears in source files list with custom name
- files = client.sources.files.list(source_id=source.id, limit=1)
+ files = list(client.folders.files.list(folder_id=source.id, limit=1))
assert len(files) == 1
assert files[0].file_name == custom_name
assert files[0].original_file_name == custom_name
# Verify the custom name is used in file blocks
- agent_state = client.agents.retrieve(agent_id=agent_state.id)
+ agent_state = client.agents.retrieve(agent_id=agent_state.id, include=["agent.blocks"])
file_blocks = agent_state.memory.file_blocks
assert len(file_blocks) == 1
# Check that the custom name appears in the block label
@@ -897,11 +911,13 @@ def test_upload_file_with_custom_name(disable_pinecone, disable_turbopuffer, cli
# Upload same file with different custom name should succeed
different_custom_name = "folder_a/folder_b/another_custom_name.txt"
file_metadata2 = upload_file_and_wait(client, source.id, temp_file_path, name=different_custom_name)
- assert file_metadata2.file_name == different_custom_name
- assert file_metadata2.original_file_name == different_custom_name
+ if not isinstance(file_metadata2, dict):
+ file_metadata2 = file_metadata2.model_dump()
+ assert file_metadata2["file_name"] == different_custom_name
+ assert file_metadata2["original_file_name"] == different_custom_name
# Verify both files exist
- files = client.sources.files.list(source_id=source.id, limit=10)
+ files = list(client.folders.files.list(folder_id=source.id, limit=10))
assert len(files) == 2
file_names = {f.file_name for f in files}
assert custom_name in file_names
@@ -917,7 +933,7 @@ def test_open_files_schema_descriptions(disable_pinecone, disable_turbopuffer, c
"""Test that open_files tool schema contains correct descriptions from docstring"""
# Get the open_files tool
- tools = client.tools.list(name="open_files")
+ tools = list(client.tools.list(name="open_files"))
assert len(tools) == 1, "Expected exactly one open_files tool"
open_files_tool = tools[0]
@@ -1000,7 +1016,7 @@ def test_grep_files_schema_descriptions(disable_pinecone, disable_turbopuffer, c
"""Test that grep_files tool schema contains correct descriptions from docstring"""
# Get the grep_files tool
- tools = client.tools.list(name="grep_files")
+ tools = list(client.tools.list(name="grep_files"))
assert len(tools) == 1, "Expected exactly one grep_files tool"
grep_files_tool = tools[0]
@@ -1085,17 +1101,19 @@ def test_grep_files_schema_descriptions(disable_pinecone, disable_turbopuffer, c
def test_agent_open_file(disable_pinecone, disable_turbopuffer, client: LettaSDKClient, agent_state: AgentState):
"""Test client.agents.open_file() function"""
# Create a new source
- source = client.sources.create(name="test_source", embedding="openai/text-embedding-3-small")
+ source = client.folders.create(name="test_source", embedding="openai/text-embedding-3-small")
# Attach source to agent
- client.agents.sources.attach(source_id=source.id, agent_id=agent_state.id)
+ client.agents.folders.attach(folder_id=source.id, agent_id=agent_state.id)
# Upload a file
file_path = "tests/data/test.txt"
file_metadata = upload_file_and_wait(client, source.id, file_path)
+ if not isinstance(file_metadata, dict):
+ file_metadata = file_metadata.model_dump()
# Basic test open_file function
- closed_files = client.agents.files.open(agent_id=agent_state.id, file_id=file_metadata.id)
+ closed_files = client.agents.files.open(agent_id=agent_state.id, file_id=file_metadata["id"])
assert len(closed_files) == 0
system = get_raw_system_message(client, agent_state.id)
@@ -1106,20 +1124,22 @@ def test_agent_open_file(disable_pinecone, disable_turbopuffer, client: LettaSDK
def test_agent_close_file(disable_pinecone, disable_turbopuffer, client: LettaSDKClient, agent_state: AgentState):
"""Test client.agents.close_file() function"""
# Create a new source
- source = client.sources.create(name="test_source", embedding="openai/text-embedding-3-small")
+ source = client.folders.create(name="test_source", embedding="openai/text-embedding-3-small")
# Attach source to agent
- client.agents.sources.attach(source_id=source.id, agent_id=agent_state.id)
+ client.agents.folders.attach(folder_id=source.id, agent_id=agent_state.id)
# Upload a file
file_path = "tests/data/test.txt"
file_metadata = upload_file_and_wait(client, source.id, file_path)
+ if not isinstance(file_metadata, dict):
+ file_metadata = file_metadata.model_dump()
# First open the file
- client.agents.files.open(agent_id=agent_state.id, file_id=file_metadata.id)
+ client.agents.files.open(agent_id=agent_state.id, file_id=file_metadata["id"])
# Test close_file function
- client.agents.files.close(agent_id=agent_state.id, file_id=file_metadata.id)
+ client.agents.files.close(agent_id=agent_state.id, file_id=file_metadata["id"])
system = get_raw_system_message(client, agent_state.id)
assert '<file status="closed" name="test_source/test.txt">' in system
@@ -1128,19 +1148,21 @@ def test_agent_close_file(disable_pinecone, disable_turbopuffer, client: LettaSD
def test_agent_close_all_open_files(disable_pinecone, disable_turbopuffer, client: LettaSDKClient, agent_state: AgentState):
"""Test client.agents.close_all_open_files() function"""
# Create a new source
- source = client.sources.create(name="test_source", embedding="openai/text-embedding-3-small")
+ source = client.folders.create(name="test_source", embedding="openai/text-embedding-3-small")
# Attach source to agent
- client.agents.sources.attach(source_id=source.id, agent_id=agent_state.id)
+ client.agents.folders.attach(folder_id=source.id, agent_id=agent_state.id)
# Upload multiple files
file_paths = ["tests/data/test.txt", "tests/data/test.md"]
file_metadatas = []
for file_path in file_paths:
file_metadata = upload_file_and_wait(client, source.id, file_path)
+ if not isinstance(file_metadata, dict):
+ file_metadata = file_metadata.model_dump()
file_metadatas.append(file_metadata)
# Open each file
- client.agents.files.open(agent_id=agent_state.id, file_id=file_metadata.id)
+ client.agents.files.open(agent_id=agent_state.id, file_id=file_metadata["id"])
system = get_raw_system_message(client, agent_state.id)
assert '<file status="open"' in system
@@ -1159,12 +1181,12 @@ def test_agent_close_all_open_files(disable_pinecone, disable_turbopuffer, clien
def test_file_processing_timeout(disable_pinecone, disable_turbopuffer, client: LettaSDKClient):
"""Test that files in non-terminal states are moved to error after timeout"""
# Create a source
- source = client.sources.create(name="test_timeout_source", embedding="openai/text-embedding-3-small")
+ source = client.folders.create(name="test_timeout_source", embedding="openai/text-embedding-3-small")
# Upload a file
file_path = "tests/data/test.txt"
with open(file_path, "rb") as f:
- file_metadata = client.sources.files.upload(source_id=source.id, file=f)
+ file_metadata = client.folders.files.upload(folder_id=source.id, file=f)
# Get the file ID
file_id = file_metadata.id
@@ -1177,20 +1199,26 @@ def test_file_processing_timeout(disable_pinecone, disable_turbopuffer, client:
assert FileProcessingStatus.PENDING.is_terminal_state() == False
# For testing the actual timeout logic, we can check the current file status
- current_file = client.sources.get_file_metadata(source_id=source.id, file_id=file_id)
+ current_file = client.get(
+ path=f"/v1/sources/{source.id}/files/{file_id}",
+ cast_to=dict[str, Any],
+ )
# Convert string status to enum for testing
- status_enum = FileProcessingStatus(current_file.processing_status)
+ if not isinstance(current_file, dict):
+ current_file = current_file.model_dump()
+ processing_status = current_file["processing_status"]
+ status_enum = FileProcessingStatus(processing_status)
# Verify that files in terminal states are not affected by timeout checks
if status_enum.is_terminal_state():
# This is the expected behavior - files that completed processing shouldn't timeout
- print(f"File {file_id} is in terminal state: {current_file.processing_status}")
+ print(f"File {file_id} is in terminal state: {processing_status}")
assert status_enum in [FileProcessingStatus.COMPLETED, FileProcessingStatus.ERROR]
else:
# If file is still processing, it should eventually complete or timeout
# In a real scenario, we'd wait and check, but for unit tests we just verify the logic exists
- print(f"File {file_id} is still processing: {current_file.processing_status}")
+ print(f"File {file_id} is still processing: {processing_status}")
assert status_enum in [FileProcessingStatus.PENDING, FileProcessingStatus.PARSING, FileProcessingStatus.EMBEDDING]
@@ -1222,7 +1250,7 @@ def test_file_processing_timeout_logic():
def test_letta_free_embedding(disable_pinecone, disable_turbopuffer, client: LettaSDKClient):
"""Test creating a source with letta/letta-free embedding and uploading a file"""
# create a source with letta-free embedding
- source = client.sources.create(name="test_letta_free_source", embedding="letta/letta-free")
+ source = client.folders.create(name="test_letta_free_source", embedding="letta/letta-free")
# verify source was created with correct embedding
assert source.name == "test_letta_free_source"
@@ -1233,17 +1261,19 @@ def test_letta_free_embedding(disable_pinecone, disable_turbopuffer, client: Let
file_metadata = upload_file_and_wait(client, source.id, file_path)
# verify file was uploaded successfully
- assert file_metadata.processing_status == "completed"
- assert file_metadata.source_id == source.id
- assert file_metadata.file_name == "test.txt"
+ if not isinstance(file_metadata, dict):
+ file_metadata = file_metadata.model_dump()
+ assert file_metadata["processing_status"] == "completed"
+ assert file_metadata["source_id"] == source.id
+ assert file_metadata["file_name"] == "test.txt"
# verify file appears in source files list
- files = client.sources.files.list(source_id=source.id, limit=1)
+ files = list(client.folders.files.list(folder_id=source.id, limit=1))
assert len(files) == 1
- assert files[0].id == file_metadata.id
+ assert files[0].id == file_metadata["id"]
# cleanup
- client.sources.delete(source_id=source.id)
+ client.folders.delete(folder_id=source.id)
# --- Pinecone Tests ---
@@ -1260,15 +1290,15 @@ def test_pinecone_search_files_tool(disable_turbopuffer, client: LettaSDKClient)
agent = client.agents.create(
name="test_pinecone_agent",
memory_blocks=[
- CreateBlock(label="human", value="username: testuser"),
+ CreateBlockParam(label="human", value="username: testuser"),
],
model="openai/gpt-4o-mini",
embedding="openai/text-embedding-3-small",
)
# Create source and attach to agent
- source = client.sources.create(name="test_pinecone_source", embedding="openai/text-embedding-3-small")
- client.agents.sources.attach(source_id=source.id, agent_id=agent.id)
+ source = client.folders.create(name="test_pinecone_source", embedding="openai/text-embedding-3-small")
+ client.agents.folders.attach(folder_id=source.id, agent_id=agent.id)
# Upload a file with searchable content
file_path = "tests/data/long_test.txt"
@@ -1304,7 +1334,7 @@ def test_pinecone_list_files_status(disable_turbopuffer, client: LettaSDKClient)
pytest.skip("Pinecone not configured (missing API key or disabled), skipping Pinecone-specific tests")
# create source
- source = client.sources.create(name="test_list_files_status", embedding="openai/text-embedding-3-small")
+ source = client.folders.create(name="test_list_files_status", embedding="openai/text-embedding-3-small")
file_paths = ["tests/data/long_test.txt"]
uploaded_files = []
@@ -1312,25 +1342,29 @@ def test_pinecone_list_files_status(disable_turbopuffer, client: LettaSDKClient)
# use the new helper that polls via list_files
file_metadata = upload_file_and_wait_list_files(client, source.id, file_path)
uploaded_files.append(file_metadata)
- assert file_metadata.processing_status == "completed", f"File {file_path} should be completed"
+ if not isinstance(file_metadata, dict):
+ file_metadata = file_metadata.model_dump()
+ assert file_metadata["processing_status"] == "completed", f"File {file_path} should be completed"
# now get files using list_source_files to verify status checking works
- files_list = client.sources.files.list(source_id=source.id, limit=100)
+ files_list = client.folders.files.list(folder_id=source.id, limit=100)
# verify all files show completed status and have proper embedding counts
assert len(files_list) == len(uploaded_files), f"Expected {len(uploaded_files)} files, got {len(files_list)}"
for file_metadata in files_list:
- assert file_metadata.processing_status == "completed", f"File {file_metadata.file_name} should show completed status"
+ if not isinstance(file_metadata, dict):
+ file_metadata = file_metadata.model_dump()
+ assert file_metadata["processing_status"] == "completed", f"File {file_metadata['file_name']} should show completed status"
# verify embedding counts for files that have chunks
- if file_metadata.total_chunks and file_metadata.total_chunks > 0:
- assert file_metadata.chunks_embedded == file_metadata.total_chunks, (
- f"File {file_metadata.file_name} should have all chunks embedded: {file_metadata.chunks_embedded}/{file_metadata.total_chunks}"
+ if file_metadata["total_chunks"] and file_metadata["total_chunks"] > 0:
+ assert file_metadata["chunks_embedded"] == file_metadata["total_chunks"], (
+ f"File {file_metadata['file_name']} should have all chunks embedded: {file_metadata['chunks_embedded']}/{file_metadata['total_chunks']}"
)
# cleanup
- client.sources.delete(source_id=source.id)
+ client.folders.delete(folder_id=source.id)
def test_pinecone_lifecycle_file_and_source_deletion(disable_turbopuffer, client: LettaSDKClient):
@@ -1343,7 +1377,7 @@ def test_pinecone_lifecycle_file_and_source_deletion(disable_turbopuffer, client
print("Testing Pinecone file and source deletion lifecycle")
# Create source
- source = client.sources.create(name="test_lifecycle_source", embedding="openai/text-embedding-3-small")
+ source = client.folders.create(name="test_lifecycle_source", embedding="openai/text-embedding-3-small")
# Upload multiple files and wait for processing
file_paths = ["tests/data/test.txt", "tests/data/test.md"]
@@ -1364,7 +1398,7 @@ def test_pinecone_lifecycle_file_and_source_deletion(disable_turbopuffer, client
print(f"Found {len(records_before)} records for file before deletion")
# Delete the file
- client.sources.files.delete(source_id=source.id, file_id=file_to_delete.id)
+ client.folders.files.delete(folder_id=source.id, file_id=file_to_delete.id)
# Allow time for deletion to propagate
time.sleep(2)
@@ -1386,7 +1420,7 @@ def test_pinecone_lifecycle_file_and_source_deletion(disable_turbopuffer, client
print(f"Found {records_before} records for remaining files before source deletion")
# Delete the entire source
- client.sources.delete(source_id=source.id)
+ client.folders.delete(folder_id=source.id)
# Allow time for deletion to propagate
time.sleep(3)
@@ -1413,14 +1447,14 @@ def test_turbopuffer_search_files_tool(disable_pinecone, client: LettaSDKClient)
agent = client.agents.create(
name="test_turbopuffer_agent",
memory_blocks=[
- CreateBlock(label="human", value="username: testuser"),
+ CreateBlockParam(label="human", value="username: testuser"),
],
model="openai/gpt-4o-mini",
embedding="openai/text-embedding-3-small",
)
- source = client.sources.create(name="test_turbopuffer_source", embedding="openai/text-embedding-3-small")
- client.agents.sources.attach(source_id=source.id, agent_id=agent.id)
+ source = client.folders.create(name="test_turbopuffer_source", embedding="openai/text-embedding-3-small")
+ client.agents.folders.attach(folder_id=source.id, agent_id=agent.id)
file_path = "tests/data/long_test.txt"
upload_file_and_wait(client, source.id, file_path)
@@ -1445,40 +1479,44 @@ def test_turbopuffer_search_files_tool(disable_pinecone, client: LettaSDKClient)
)
client.agents.delete(agent_id=agent.id)
- client.sources.delete(source_id=source.id)
+ client.folders.delete(folder_id=source.id)
def test_turbopuffer_file_processing_status(disable_pinecone, client: LettaSDKClient):
"""Test that file processing completes successfully with Turbopuffer"""
print("Testing Turbopuffer file processing status")
- source = client.sources.create(name="test_tpuf_file_status", embedding="openai/text-embedding-3-small")
+ source = client.folders.create(name="test_tpuf_file_status", embedding="openai/text-embedding-3-small")
file_paths = ["tests/data/long_test.txt", "tests/data/test.md"]
uploaded_files = []
for file_path in file_paths:
file_metadata = upload_file_and_wait(client, source.id, file_path)
uploaded_files.append(file_metadata)
- assert file_metadata.processing_status == "completed", f"File {file_path} should be completed"
+ if not isinstance(file_metadata, dict):
+ file_metadata = file_metadata.model_dump()
+ assert file_metadata["processing_status"] == "completed", f"File {file_path} should be completed"
- files_list = client.sources.files.list(source_id=source.id, limit=100)
+ files_list = client.folders.files.list(folder_id=source.id, limit=100).items
assert len(files_list) == len(uploaded_files), f"Expected {len(uploaded_files)} files, got {len(files_list)}"
for file_metadata in files_list:
- assert file_metadata.processing_status == "completed", f"File {file_metadata.file_name} should show completed status"
+ if not isinstance(file_metadata, dict):
+ file_metadata = file_metadata.model_dump()
+ assert file_metadata["processing_status"] == "completed", f"File {file_metadata['file_name']} should show completed status"
- if file_metadata.total_chunks and file_metadata.total_chunks > 0:
- assert file_metadata.chunks_embedded == file_metadata.total_chunks, (
- f"File {file_metadata.file_name} should have all chunks embedded: {file_metadata.chunks_embedded}/{file_metadata.total_chunks}"
+ if file_metadata["total_chunks"] and file_metadata["total_chunks"] > 0:
+ assert file_metadata["chunks_embedded"] == file_metadata["total_chunks"], (
+ f"File {file_metadata['file_name']} should have all chunks embedded: {file_metadata['chunks_embedded']}/{file_metadata['total_chunks']}"
)
- client.sources.delete(source_id=source.id)
+ client.folders.delete(folder_id=source.id)
def test_turbopuffer_lifecycle_file_and_source_deletion(disable_pinecone, client: LettaSDKClient):
"""Test that file and source deletion removes records from Turbopuffer"""
- source = client.sources.create(name="test_tpuf_lifecycle", embedding="openai/text-embedding-3-small")
+ source = client.folders.create(name="test_tpuf_lifecycle", embedding="openai/text-embedding-3-small")
file_paths = ["tests/data/test.txt", "tests/data/test.md"]
uploaded_files = []
@@ -1495,19 +1533,19 @@ def test_turbopuffer_lifecycle_file_and_source_deletion(disable_pinecone, client
passages_before = asyncio.run(
tpuf_client.query_file_passages(
- source_ids=[source.id], organization_id=user.organization_id, actor=user, file_id=file_to_delete.id, top_k=100
+ source_ids=[source.id], organization_id=user.organization_id, actor=user, file_id=file_to_delete["id"], top_k=100
)
)
print(f"Found {len(passages_before)} passages for file before deletion")
assert len(passages_before) > 0, "Should have passages before deletion"
- client.sources.files.delete(source_id=source.id, file_id=file_to_delete.id)
+ client.folders.files.delete(folder_id=source.id, file_id=file_to_delete["id"])
time.sleep(2)
passages_after = asyncio.run(
tpuf_client.query_file_passages(
- source_ids=[source.id], organization_id=user.organization_id, actor=user, file_id=file_to_delete.id, top_k=100
+ source_ids=[source.id], organization_id=user.organization_id, actor=user, file_id=file_to_delete["id"], top_k=100
)
)
print(f"Found {len(passages_after)} passages for file after deletion")
@@ -1518,7 +1556,7 @@ def test_turbopuffer_lifecycle_file_and_source_deletion(disable_pinecone, client
for file_metadata in uploaded_files[1:]:
passages = asyncio.run(
tpuf_client.query_file_passages(
- source_ids=[source.id], organization_id=user.organization_id, actor=user, file_id=file_metadata.id, top_k=100
+ source_ids=[source.id], organization_id=user.organization_id, actor=user, file_id=file_metadata["id"], top_k=100
)
)
remaining_passages_before.extend(passages)
@@ -1526,7 +1564,7 @@ def test_turbopuffer_lifecycle_file_and_source_deletion(disable_pinecone, client
print(f"Found {len(remaining_passages_before)} passages for remaining files before source deletion")
assert len(remaining_passages_before) > 0, "Should have passages for remaining files"
- client.sources.delete(source_id=source.id)
+ client.folders.delete(folder_id=source.id)
time.sleep(3)
@@ -1535,7 +1573,7 @@ def test_turbopuffer_lifecycle_file_and_source_deletion(disable_pinecone, client
try:
passages = asyncio.run(
tpuf_client.query_file_passages(
- source_ids=[source.id], organization_id=user.organization_id, actor=user, file_id=file_metadata.id, top_k=100
+ source_ids=[source.id], organization_id=user.organization_id, actor=user, file_id=file_metadata["id"], top_k=100
)
)
remaining_passages_after.extend(passages)
@@ -1550,8 +1588,8 @@ def test_turbopuffer_lifecycle_file_and_source_deletion(disable_pinecone, client
def test_turbopuffer_multiple_sources(disable_pinecone, client: LettaSDKClient):
"""Test that Turbopuffer correctly isolates passages by source in org-scoped namespace"""
- source1 = client.sources.create(name="test_tpuf_source1", embedding="openai/text-embedding-3-small")
- source2 = client.sources.create(name="test_tpuf_source2", embedding="openai/text-embedding-3-small")
+ source1 = client.folders.create(name="test_tpuf_source1", embedding="openai/text-embedding-3-small")
+ source2 = client.folders.create(name="test_tpuf_source2", embedding="openai/text-embedding-3-small")
file1_metadata = upload_file_and_wait(client, source1.id, "tests/data/test.txt")
file2_metadata = upload_file_and_wait(client, source2.id, "tests/data/test.md")
@@ -1574,15 +1612,15 @@ def test_turbopuffer_multiple_sources(disable_pinecone, client: LettaSDKClient):
assert len(source2_passages) > 0, "Source2 should have passages"
for passage, _, _ in source1_passages:
- assert passage.source_id == source1.id, f"Passage should belong to source1, but has source_id={passage.source_id}"
- assert passage.file_id == file1_metadata.id, f"Passage should belong to file1, but has file_id={passage.file_id}"
+ assert passage.source_id == source1.id, f"Passage should belong to source1, but has folder_id={passage.source_id}"
+ assert passage.file_id == file1_metadata["id"], f"Passage should belong to file1, but has file_id={passage.file_id}"
for passage, _, _ in source2_passages:
- assert passage.source_id == source2.id, f"Passage should belong to source2, but has source_id={passage.source_id}"
- assert passage.file_id == file2_metadata.id, f"Passage should belong to file2, but has file_id={passage.file_id}"
+ assert passage.source_id == source2.id, f"Passage should belong to source2, but has folder_id={passage.source_id}"
+ assert passage.file_id == file2_metadata["id"], f"Passage should belong to file2, but has file_id={passage.file_id}"
# delete source1 and verify source2 is unaffected
- client.sources.delete(source_id=source1.id)
+ client.folders.delete(folder_id=source1.id)
time.sleep(2)
source2_passages_after = asyncio.run(
@@ -1593,7 +1631,7 @@ def test_turbopuffer_multiple_sources(disable_pinecone, client: LettaSDKClient):
f"Source2 should still have all passages after source1 deletion: {len(source2_passages_after)} vs {len(source2_passages)}"
)
- client.sources.delete(source_id=source2.id)
+ client.folders.delete(folder_id=source2.id)
# --- End Turbopuffer Tests ---