chore: import upstream snapshot with attribution

python/assistant-ui-sync-server-api/tests/__init__.py

@@ -0,0 +1 @@
+# Tests for assistant-ui package

python/assistant-ui-sync-server-api/tests/test_client.py

@@ -0,0 +1,510 @@
+"""Tests for the assistant-ui-sync-server-api client."""
+
+import pytest
+import httpx
+import warnings
+from unittest.mock import AsyncMock, Mock, patch
+from assistant_ui import AssistantClient
+from assistant_ui.types import Message, AssistantTransportCommand
+
+
+@pytest.mark.asyncio
+async def test_basic_chat():
+    """Test basic async chat functionality."""
+    client = AssistantClient(
+        base_url="https://api.example.com",
+        headers={"Authorization": "Bearer test"}
+    )
+    
+    messages: list[Message] = [
+        {
+            "role": "user",
+            "content": [{"type": "text", "text": "Hello"}],
+        }
+    ]
+    
+    mock_response = AsyncMock()
+    mock_response.is_success = True
+    mock_response.status_code = 200
+    mock_response.json.return_value = {"response": "Hi there!"}
+    mock_response.text = "Success"
+    
+    with patch.object(client, "_ensure_async_client") as mock_ensure:
+        mock_client = AsyncMock()
+        mock_client.request = AsyncMock(return_value=mock_response)
+        mock_ensure.return_value = mock_client
+        
+        thread = client.threads("thread-123")
+
+        # Suppress deprecation warning for this test
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore", DeprecationWarning)
+            response = await thread.chat(
+                messages=messages,
+                system="You are helpful"
+            )
+
+        assert response.status_code == 200
+
+        # Check the request was made correctly
+        call_args = mock_client.request.call_args
+        payload = call_args[1]["json"]
+
+        assert payload["threadId"] == "thread-123"
+        assert payload["messages"] == messages
+        assert payload["system"] == "You are helpful"
+        # Commands should also be present due to conversion
+        assert "commands" in payload
+    
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_chat_with_tools():
+    """Test chat with tools."""
+    async with AssistantClient(base_url="https://api.example.com") as client:
+        messages: list[Message] = []
+        tools = {"search": {"description": "Search the web"}}
+        
+        mock_response = AsyncMock()
+        mock_response.is_success = True
+        mock_response.status_code = 200
+        
+        with patch.object(client, "_ensure_async_client") as mock_ensure:
+            mock_client = AsyncMock()
+            mock_client.request = AsyncMock(return_value=mock_response)
+            mock_ensure.return_value = mock_client
+            
+            thread = client.threads("thread-456")
+            await thread.chat(messages=messages, tools=tools)
+            
+            # Check tools were included
+            call_args = mock_client.request.call_args
+            assert call_args[1]["json"]["tools"] == tools
+
+
+@pytest.mark.asyncio
+async def test_cancel():
+    """Test cancel functionality."""
+    client = AssistantClient(base_url="https://api.example.com")
+    
+    mock_response = AsyncMock()
+    mock_response.is_success = True
+    mock_response.status_code = 200
+    
+    with patch.object(client, "_ensure_async_client") as mock_ensure:
+        mock_client = AsyncMock()
+        mock_client.request = AsyncMock(return_value=mock_response)
+        mock_ensure.return_value = mock_client
+        
+        thread = client.threads("thread-789")
+        await thread.cancel()
+        
+        # Check cancel request was made
+        mock_client.request.assert_called_once_with(
+            "POST",
+            "/api/cancel",
+            headers={"Content-Type": "application/json"},
+            json={"threadId": "thread-789"}
+        )
+    
+    await client.close()
+
+
+def test_sync_chat():
+    """Test synchronous chat."""
+    with AssistantClient(base_url="https://api.example.com") as client:
+        messages: list[Message] = [
+            {
+                "role": "assistant",
+                "content": [
+                    {"type": "text", "text": "I can help."},
+                    {
+                        "type": "tool-call",
+                        "toolCallId": "call-123",
+                        "toolName": "search",
+                        "args": {"query": "weather"}
+                    }
+                ],
+            }
+        ]
+        
+        mock_response = Mock()
+        mock_response.is_success = True
+        mock_response.status_code = 200
+        mock_response.text = "Success"
+        
+        with patch.object(client, "_ensure_sync_client") as mock_ensure:
+            mock_client = Mock()
+            mock_client.request = Mock(return_value=mock_response)
+            mock_ensure.return_value = mock_client
+            
+            thread = client.threads("thread-sync")
+            response = thread.chat_sync(messages=messages)
+            
+            assert response.status_code == 200
+
+
+@pytest.mark.asyncio
+async def test_async_headers():
+    """Test with async header function."""
+    async def get_headers():
+        return {"Authorization": "Bearer dynamic-token"}
+    
+    client = AssistantClient(
+        base_url="https://api.example.com",
+        headers=get_headers
+    )
+    
+    mock_response = AsyncMock()
+    mock_response.is_success = True
+    mock_response.status_code = 200
+    
+    with patch.object(client, "_ensure_async_client") as mock_ensure:
+        mock_client = AsyncMock()
+        mock_client.request = AsyncMock(return_value=mock_response)
+        mock_ensure.return_value = mock_client
+        
+        thread = client.threads("thread-async-headers")
+        await thread.chat(messages=[])
+        
+        # Check dynamic headers were used
+        call_args = mock_client.request.call_args
+        assert call_args[1]["headers"]["Authorization"] == "Bearer dynamic-token"
+    
+    await client.close()
+
+
+def test_sync_with_async_headers_raises():
+    """Test that sync methods raise error with async headers."""
+    async def get_headers():
+        return {"Authorization": "Bearer token"}
+    
+    client = AssistantClient(
+        base_url="https://api.example.com",
+        headers=get_headers
+    )
+    
+    thread = client.threads("thread-123")
+    
+    with pytest.raises(ValueError) as exc_info:
+        thread.chat_sync(messages=[])
+    
+    assert "async header functions" in str(exc_info.value)
+
+
+@pytest.mark.asyncio
+async def test_error_handling():
+    """Test error handling."""
+    client = AssistantClient(base_url="https://api.example.com")
+    
+    mock_response = AsyncMock()
+    mock_response.is_success = False
+    mock_response.status_code = 500
+    mock_response.text = "Internal Server Error"
+    
+    with patch.object(client, "_ensure_async_client") as mock_ensure:
+        mock_client = AsyncMock()
+        mock_client.request = AsyncMock(return_value=mock_response)
+        mock_ensure.return_value = mock_client
+        
+        thread = client.threads("thread-error")
+        
+        with pytest.raises(Exception) as exc_info:
+            await thread.chat(messages=[])
+        
+        assert "Request failed with status 500" in str(exc_info.value)
+    
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_context_manager():
+    """Test async context manager."""
+    async with AssistantClient(base_url="https://api.example.com") as client:
+        assert client._async_client is None  # Not created until first use
+        
+        # Force client creation
+        mock_response = AsyncMock()
+        mock_response.is_success = True
+        
+        with patch("httpx.AsyncClient") as mock_async_client_class:
+            mock_instance = AsyncMock()
+            mock_instance.request = AsyncMock(return_value=mock_response)
+            mock_async_client_class.return_value = mock_instance
+            
+            thread = client.threads("test")
+            await thread.chat(messages=[])
+            
+            assert client._async_client is not None
+    
+    # After context exit, client should be closed
+    assert client._async_client is None
+
+
+def test_sync_context_manager():
+    """Test sync context manager."""
+    with AssistantClient(base_url="https://api.example.com") as client:
+        assert client._sync_client is None  # Not created until first use
+        
+        # Force client creation
+        mock_response = Mock()
+        mock_response.is_success = True
+        
+        with patch("httpx.Client") as mock_client_class:
+            mock_instance = Mock()
+            mock_instance.request = Mock(return_value=mock_response)
+            mock_client_class.return_value = mock_instance
+            
+            thread = client.threads("test")
+            thread.chat_sync(messages=[])
+            
+            assert client._sync_client is not None
+    
+    # After context exit, client should be closed
+    assert client._sync_client is None
+
+
+@pytest.mark.asyncio
+async def test_all_parameters():
+    """Test chat with all possible parameters."""
+    client = AssistantClient(
+        base_url="https://api.example.com",
+        headers={"X-API-Key": "test-key"},
+        timeout=30.0
+    )
+    
+    messages: list[Message] = [
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": "Analyze this:"},
+                {"type": "image", "image": "https://example.com/img.jpg"},
+                {"type": "file", "data": "https://example.com/doc.pdf", "mimeType": "application/pdf"}
+            ],
+            "unstable_id": "msg-123",
+        }
+    ]
+    
+    tools = {
+        "analyze": {
+            "description": "Analyze content",
+            "parameters": {
+                "type": "object",
+                "properties": {"content": {"type": "string"}},
+                "required": ["content"]
+            }
+        }
+    }
+    
+    mock_response = AsyncMock()
+    mock_response.is_success = True
+    mock_response.status_code = 200
+    
+    with patch.object(client, "_ensure_async_client") as mock_ensure:
+        mock_client = AsyncMock()
+        mock_client.request = AsyncMock(return_value=mock_response)
+        mock_ensure.return_value = mock_client
+        
+        thread = client.threads("thread-all-params")
+        await thread.chat(
+            messages=messages,
+            tools=tools,
+            system="You are an analyzer",
+            unstable_assistantMessageId="asst-456",
+            runConfig={"model": "gpt-5.4-nano"},
+            state={"session": "abc"},
+            custom_field="custom_value"
+        )
+        
+        # Check all parameters were included
+        call_args = mock_client.request.call_args
+        payload = call_args[1]["json"]
+        
+        assert payload["threadId"] == "thread-all-params"
+        assert payload["system"] == "You are an analyzer"
+        assert payload["messages"] == messages
+        assert payload["tools"] == tools
+        assert payload["unstable_assistantMessageId"] == "asst-456"
+        assert payload["runConfig"] == {"model": "gpt-5.4-nano"}
+        assert payload["state"] == {"session": "abc"}
+        assert payload["custom_field"] == "custom_value"
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_chat_with_commands():
+    """Test chat with commands instead of messages."""
+    client = AssistantClient(
+        base_url="https://api.example.com",
+        headers={"Authorization": "Bearer test"}
+    )
+
+    commands: list[AssistantTransportCommand] = [
+        {
+            "type": "add-message",
+            "message": {
+                "role": "user",
+                "parts": [{"type": "text", "text": "Hello with commands"}]
+            }
+        },
+        {
+            "type": "add-tool-result",
+            "toolCallId": "call-789",
+            "toolName": "search",
+            "result": {"data": "search results"},
+            "isError": False,
+            "artifact": None
+        }
+    ]
+
+    mock_response = AsyncMock()
+    mock_response.is_success = True
+    mock_response.status_code = 200
+
+    with patch.object(client, "_ensure_async_client") as mock_ensure:
+        mock_client = AsyncMock()
+        mock_client.request = AsyncMock(return_value=mock_response)
+        mock_ensure.return_value = mock_client
+
+        thread = client.threads("thread-cmd")
+        response = await thread.chat(commands=commands)
+
+        assert response.status_code == 200
+
+        # Check the request was made with commands
+        call_args = mock_client.request.call_args
+        payload = call_args[1]["json"]
+
+        assert payload["threadId"] == "thread-cmd"
+        assert payload["commands"] == commands
+        assert "messages" not in payload
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_chat_with_deprecated_messages():
+    """Test that messages parameter shows deprecation warning."""
+    client = AssistantClient(base_url="https://api.example.com")
+
+    messages: list[Message] = [
+        {
+            "role": "user",
+            "content": [{"type": "text", "text": "Using deprecated API"}],
+        }
+    ]
+
+    mock_response = AsyncMock()
+    mock_response.is_success = True
+    mock_response.status_code = 200
+
+    with patch.object(client, "_ensure_async_client") as mock_ensure:
+        mock_client = AsyncMock()
+        mock_client.request = AsyncMock(return_value=mock_response)
+        mock_ensure.return_value = mock_client
+
+        thread = client.threads("thread-deprecated")
+
+        # Check deprecation warning
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            await thread.chat(messages=messages)
+
+            assert len(w) == 1
+            assert issubclass(w[0].category, DeprecationWarning)
+            assert "messages' parameter is deprecated" in str(w[0].message)
+
+        # Check both messages and commands were sent
+        call_args = mock_client.request.call_args
+        payload = call_args[1]["json"]
+
+        assert payload["messages"] == messages
+        assert "commands" in payload
+        assert len(payload["commands"]) > 0
+
+    await client.close()
+
+
+@pytest.mark.asyncio
+async def test_chat_messages_and_commands_together():
+    """Test using both messages and commands together."""
+    client = AssistantClient(base_url="https://api.example.com")
+
+    messages: list[Message] = [
+        {
+            "role": "assistant",
+            "content": [{"type": "text", "text": "Previous message"}],
+        }
+    ]
+
+    commands: list[AssistantTransportCommand] = [
+        {
+            "type": "add-message",
+            "message": {
+                "role": "user",
+                "parts": [{"type": "text", "text": "New command"}]
+            }
+        }
+    ]
+
+    mock_response = AsyncMock()
+    mock_response.is_success = True
+    mock_response.status_code = 200
+
+    with patch.object(client, "_ensure_async_client") as mock_ensure:
+        mock_client = AsyncMock()
+        mock_client.request = AsyncMock(return_value=mock_response)
+        mock_ensure.return_value = mock_client
+
+        thread = client.threads("thread-both")
+
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            await thread.chat(messages=messages, commands=commands)
+
+        # Check both were merged
+        call_args = mock_client.request.call_args
+        payload = call_args[1]["json"]
+
+        assert payload["messages"] == messages
+        assert "commands" in payload
+        # Should have original command plus converted message
+        assert len(payload["commands"]) >= 2
+
+    await client.close()
+
+
+def test_sync_chat_with_commands():
+    """Test synchronous chat with commands."""
+    with AssistantClient(base_url="https://api.example.com") as client:
+        commands: list[AssistantTransportCommand] = [
+            {
+                "type": "add-message",
+                "message": {
+                    "role": "assistant",
+                    "parts": [{"type": "text", "text": "Sync command test"}]
+                }
+            }
+        ]
+
+        mock_response = Mock()
+        mock_response.is_success = True
+        mock_response.status_code = 200
+
+        with patch.object(client, "_ensure_sync_client") as mock_ensure:
+            mock_client = Mock()
+            mock_client.request = Mock(return_value=mock_response)
+            mock_ensure.return_value = mock_client
+
+            thread = client.threads("thread-sync-cmd")
+            response = thread.chat_sync(commands=commands)
+
+            assert response.status_code == 200
+
+            # Check commands were sent
+            call_args = mock_client.request.call_args
+            payload = call_args[1]["json"]
+
+            assert payload["commands"] == commands