feat: new tools package (#407)

1 files changed, 0 insertions, 387 deletions

diff --git a/packages/openai-sdk-python/tests/test_infinite_chat.py b/packages/openai-sdk-python/tests/test_infinite_chat.py
deleted file mode 100644
index 9fdf52c5..00000000
--- a/packages/openai-sdk-python/tests/test_infinite_chat.py
+++ /dev/null
@@ -1,387 +0,0 @@
-"""Tests for infinite_chat module."""
-
-import os
-import pytest
-from typing import List
-
-from openai.types.chat import ChatCompletionMessageParam
-from ..src import (
-    SupermemoryOpenAI,
-    SupermemoryInfiniteChatConfigWithProviderName,
-    SupermemoryInfiniteChatConfigWithProviderUrl,
-    ProviderName,
-)
-
-
-# Test configuration
-PROVIDERS: List[ProviderName] = [
-    "openai",
-    "anthropic",
-    "openrouter",
-    "deepinfra",
-    "groq",
-    "google",
-    "cloudflare",
-]
-
-
[email protected]
-def test_api_key() -> str:
-    """Get test Supermemory API key from environment."""
-    api_key = os.getenv("SUPERMEMORY_API_KEY")
-    if not api_key:
-        pytest.skip("SUPERMEMORY_API_KEY environment variable is required for tests")
-    return api_key
-
-
[email protected]
-def test_provider_api_key() -> str:
-    """Get test provider API key from environment."""
-    api_key = os.getenv("PROVIDER_API_KEY")
-    if not api_key:
-        pytest.skip("PROVIDER_API_KEY environment variable is required for tests")
-    return api_key
-
-
[email protected]
-def test_provider_name() -> ProviderName:
-    """Get test provider name from environment."""
-    provider_name = os.getenv("PROVIDER_NAME", "openai")
-    if provider_name not in PROVIDERS:
-        pytest.fail(f"Invalid provider name: {provider_name}")
-    return provider_name  # type: ignore
-
-
[email protected]
-def test_provider_url() -> str:
-    """Get test provider URL from environment."""
-    return os.getenv("PROVIDER_URL", "")
-
-
[email protected]
-def test_model_name() -> str:
-    """Get test model name from environment."""
-    return os.getenv("MODEL_NAME", "gpt-4o-mini")
-
-
[email protected]
-def test_headers() -> dict:
-    """Get test headers."""
-    return {"custom-header": "test-value"}
-
-
[email protected]
-def test_messages() -> List[List[ChatCompletionMessageParam]]:
-    """Test message sets."""
-    return [
-        [{"role": "user", "content": "Hello!"}],
-        [
-            {"role": "system", "content": "You are a helpful assistant."},
-            {"role": "user", "content": "What is AI?"},
-        ],
-        [
-            {"role": "user", "content": "Tell me a joke"},
-            {
-                "role": "assistant",
-                "content": "Why don't scientists trust atoms? Because they make up everything!",
-            },
-            {"role": "user", "content": "Tell me another one"},
-        ],
-    ]
-
-
-class TestClientCreation:
-    """Test client creation."""
-
-    def test_create_client_with_provider_name(
-        self,
-        test_api_key: str,
-        test_provider_api_key: str,
-        test_provider_name: ProviderName,
-        test_headers: dict,
-    ):
-        """Test creating client with provider name configuration."""
-        config = SupermemoryInfiniteChatConfigWithProviderName(
-            provider_name=test_provider_name,
-            provider_api_key=test_provider_api_key,
-            headers=test_headers,
-        )
-
-        client = SupermemoryOpenAI(test_api_key, config)
-
-        assert client is not None
-        assert client.chat is not None
-
-    def test_create_client_with_openai_provider(
-        self, test_api_key: str, test_provider_api_key: str, test_headers: dict
-    ):
-        """Test creating client with OpenAI provider configuration."""
-        config = SupermemoryInfiniteChatConfigWithProviderName(
-            provider_name="openai",
-            provider_api_key=test_provider_api_key,
-            headers=test_headers,
-        )
-
-        client = SupermemoryOpenAI(test_api_key, config)
-
-        assert client is not None
-
-    def test_create_client_with_custom_provider_url(
-        self, test_api_key: str, test_provider_api_key: str, test_headers: dict
-    ):
-        """Test creating client with custom provider URL."""
-        custom_url = "https://custom-provider.com/v1"
-        config = SupermemoryInfiniteChatConfigWithProviderUrl(
-            provider_url=custom_url,
-            provider_api_key=test_provider_api_key,
-            headers=test_headers,
-        )
-
-        client = SupermemoryOpenAI(test_api_key, config)
-
-        assert client is not None
-
-
-class TestChatCompletions:
-    """Test chat completions functionality."""
-
-    @pytest.mark.asyncio
-    async def test_create_chat_completion_simple_message(
-        self,
-        test_api_key: str,
-        test_provider_api_key: str,
-        test_provider_name: ProviderName,
-        test_model_name: str,
-        test_messages: List[List[ChatCompletionMessageParam]],
-    ):
-        """Test creating chat completion with simple message."""
-        config = SupermemoryInfiniteChatConfigWithProviderName(
-            provider_name=test_provider_name,
-            provider_api_key=test_provider_api_key,
-            headers={},
-        )
-
-        client = SupermemoryOpenAI(test_api_key, config)
-
-        result = await client.create_chat_completion(
-            model=test_model_name,
-            messages=test_messages[0],  # "Hello!"
-        )
-
-        assert result is not None
-        assert hasattr(result, "choices")
-        assert len(result.choices) > 0
-        assert result.choices[0].message.content is not None
-
-    @pytest.mark.asyncio
-    async def test_chat_completion_convenience_method(
-        self,
-        test_api_key: str,
-        test_provider_api_key: str,
-        test_provider_name: ProviderName,
-        test_model_name: str,
-        test_messages: List[List[ChatCompletionMessageParam]],
-    ):
-        """Test chat completion using convenience method."""
-        config = SupermemoryInfiniteChatConfigWithProviderName(
-            provider_name=test_provider_name,
-            provider_api_key=test_provider_api_key,
-            headers={},
-        )
-
-        client = SupermemoryOpenAI(test_api_key, config)
-
-        result = await client.chat_completion(
-            messages=test_messages[1],  # System + user messages
-            model=test_model_name,
-            temperature=0.7,
-        )
-
-        assert result is not None
-        assert hasattr(result, "choices")
-        assert len(result.choices) > 0
-        assert result.choices[0].message.content is not None
-
-    @pytest.mark.asyncio
-    async def test_handle_conversation_history(
-        self,
-        test_api_key: str,
-        test_provider_api_key: str,
-        test_provider_name: ProviderName,
-        test_model_name: str,
-        test_messages: List[List[ChatCompletionMessageParam]],
-    ):
-        """Test handling conversation history."""
-        config = SupermemoryInfiniteChatConfigWithProviderName(
-            provider_name=test_provider_name,
-            provider_api_key=test_provider_api_key,
-            headers={},
-        )
-
-        client = SupermemoryOpenAI(test_api_key, config)
-
-        result = await client.chat_completion(
-            messages=test_messages[2],  # Multi-turn conversation
-            model=test_model_name,
-        )
-
-        assert result is not None
-        assert hasattr(result, "choices")
-        assert len(result.choices) > 0
-        assert result.choices[0].message.content is not None
-
-    @pytest.mark.asyncio
-    async def test_custom_headers(
-        self,
-        test_api_key: str,
-        test_provider_api_key: str,
-        test_provider_name: ProviderName,
-        test_model_name: str,
-    ):
-        """Test working with custom headers."""
-        config = SupermemoryInfiniteChatConfigWithProviderName(
-            provider_name=test_provider_name,
-            provider_api_key=test_provider_api_key,
-            headers={"x-custom-header": "test-value"},
-        )
-
-        client = SupermemoryOpenAI(test_api_key, config)
-
-        result = await client.chat_completion(
-            messages=[{"role": "user", "content": "Hello"}],
-            model=test_model_name,
-        )
-
-        assert result is not None
-        assert hasattr(result, "choices")
-
-
-class TestConfigurationValidation:
-    """Test configuration validation."""
-
-    def test_handle_empty_headers_object(
-        self,
-        test_api_key: str,
-        test_provider_api_key: str,
-        test_provider_name: ProviderName,
-    ):
-        """Test handling empty headers object."""
-        config = SupermemoryInfiniteChatConfigWithProviderName(
-            provider_name=test_provider_name,
-            provider_api_key=test_provider_api_key,
-            headers={},
-        )
-
-        client = SupermemoryOpenAI(test_api_key, config)
-
-        assert client is not None
-
-    def test_handle_configuration_without_headers(
-        self,
-        test_api_key: str,
-        test_provider_api_key: str,
-        test_provider_name: ProviderName,
-    ):
-        """Test handling configuration without headers."""
-        config = SupermemoryInfiniteChatConfigWithProviderName(
-            provider_name=test_provider_name,
-            provider_api_key=test_provider_api_key,
-        )
-
-        client = SupermemoryOpenAI(test_api_key, config)
-
-        assert client is not None
-
-    def test_handle_different_api_keys(self):
-        """Test handling different API keys."""
-        config = SupermemoryInfiniteChatConfigWithProviderName(
-            provider_name="openai",
-            provider_api_key="different-provider-key",
-        )
-
-        client = SupermemoryOpenAI("different-sm-key", config)
-
-        assert client is not None
-
-
-class TestDisabledEndpoints:
-    """Test that non-chat endpoints are disabled."""
-
-    def test_disabled_endpoints_throw_errors(
-        self, test_api_key: str, test_provider_api_key: str
-    ):
-        """Test that all disabled endpoints throw appropriate errors."""
-        config = SupermemoryInfiniteChatConfigWithProviderName(
-            provider_name="openai",
-            provider_api_key=test_provider_api_key,
-        )
-
-        client = SupermemoryOpenAI(test_api_key, config)
-
-        # Test that all disabled endpoints throw appropriate errors
-        with pytest.raises(
-            RuntimeError, match="Supermemory only supports chat completions"
-        ):
-            _ = client.embeddings
-
-        with pytest.raises(
-            RuntimeError, match="Supermemory only supports chat completions"
-        ):
-            _ = client.fine_tuning
-
-        with pytest.raises(
-            RuntimeError, match="Supermemory only supports chat completions"
-        ):
-            _ = client.images
-
-        with pytest.raises(
-            RuntimeError, match="Supermemory only supports chat completions"
-        ):
-            _ = client.audio
-
-        with pytest.raises(
-            RuntimeError, match="Supermemory only supports chat completions"
-        ):
-            _ = client.models
-
-        with pytest.raises(
-            RuntimeError, match="Supermemory only supports chat completions"
-        ):
-            _ = client.moderations
-
-        with pytest.raises(
-            RuntimeError, match="Supermemory only supports chat completions"
-        ):
-            _ = client.files
-
-        with pytest.raises(
-            RuntimeError, match="Supermemory only supports chat completions"
-        ):
-            _ = client.batches
-
-        with pytest.raises(
-            RuntimeError, match="Supermemory only supports chat completions"
-        ):
-            _ = client.uploads
-
-        with pytest.raises(
-            RuntimeError, match="Supermemory only supports chat completions"
-        ):
-            _ = client.beta
-
-    def test_chat_completions_still_work(
-        self, test_api_key: str, test_provider_api_key: str
-    ):
-        """Test that chat completions still work after disabling other endpoints."""
-        config = SupermemoryInfiniteChatConfigWithProviderName(
-            provider_name="openai",
-            provider_api_key=test_provider_api_key,
-        )
-
-        client = SupermemoryOpenAI(test_api_key, config)
-
-        # Chat completions should still be accessible
-        assert client.chat is not None
-        assert client.chat.completions is not None
-        assert callable(client.create_chat_completion)
-        assert callable(client.chat_completion)