ugh this isn't going great, but excited

simplemind/__init__.py

@@ -1,3 +1 @@
-from .core.client import Client
-
-__all__ = ["Client"]
+from .core import SimpleMind

simplemind/core/__init__.py

@@ -9,21 +9,23 @@ from .config import settings
 class SimpleMind:
     """Main class for SimpleMind functionality."""
 
-    def __init__(
-        self, api_key: str, provider: str = "openai", context: Optional[Context] = None
-    ):
+    def __init__(self, provider: str = "openai", context: Optional[Context] = None):
         """Initialize SimpleMind with the specified provider."""
-        self.api_key = api_key
         self.provider = provider
         self.context = context or Context()
         self._client = self._get_provider()
 
     def _get_provider(self) -> BaseClientProvider:
         """Get the appropriate provider client."""
-        from .integrations.openai import OpenAI
-        from .integrations.anthropic import Anthropic
+        from ..providers.openai import OpenAI
+        from ..providers.anthropic import Anthropic
 
-        providers = {"openai": OpenAI, "anthropic": Anthropic}
+        # Initialize providers based on environment variables.
+        providers = {}
+        if settings.openai_api_key:
+            providers.update({"openai": OpenAI})
+        if settings.anthropic_api_key:
+            providers.update({"anthropic": Anthropic})
 
         if self.provider not in providers:
             raise ValueError(
@@ -34,13 +36,16 @@ class SimpleMind:
 
     def generate(self, prompt: str, **kwargs) -> AIResponse:
         """Generate a response using the configured provider."""
+
         return self._client.message(prompt, **kwargs)
 
     def create_conversation(self, initial_message: str) -> str:
         """Create a new conversation and return its ID."""
+
         conversation = self._client.create_conversation(initial_message)
         return conversation.id
 
     def send_message(self, conversation_id: str, message: str) -> AIResponse:
         """Send a message in an existing conversation."""
+
         return self._client.send_message(conversation_id, message)

simplemind/providers/__init__.py

@@ -1,3 +1,18 @@
-from .anthropic import Anthropic
-from .openai import OpenAI
-from .ollama import Ollama
+from ..core.config import settings
+
+__all__ = []
+
+if settings.anthropic_api_key:
+    from .anthropic import Anthropic
+
+    __all__.append("Anthropic")
+
+if settings.openai_api_key:
+    from .openai import OpenAI
+
+    __all__.append("OpenAI")
+
+if settings.ollama_host_url:
+    from .ollama import Ollama
+
+    __all__.append("Ollama")

simplemind/providers/ollama.py

@@ -4,7 +4,7 @@ from ollama import Client as BaseOllama
 
 from .base import BaseClientProvider
 from ..core.models import AIResponse
-from ..conversation import Conversation
+from ..concepts.conversation import Conversation
 
 TIMEOUT = 60
 

simplemind/providers/openai.py

@@ -5,8 +5,6 @@ from ..core.config import settings
 from ..core.logger import logger
 from .base import BaseClientProvider
 
-DEFAULT_MODEL = "gpt-4"
-
 
 class OpenAI(BaseClientProvider):
     def __init__(self, model: str = "gpt-4", api_key: Optional[str] = None):
@@ -49,7 +47,7 @@ class OpenAI(BaseClientProvider):
         logger.error(f"OpenAI API error: {e}")
         raise ProviderError(f"OpenAI API error: {e}")
 
-    def generate_response(self, conversation, **kwargs) -> str:
+    def generate_response(self, conversation) -> str:
         """Generate a response using the OpenAI API."""
         try:
             messages = [
@@ -57,24 +55,10 @@ class OpenAI(BaseClientProvider):
                 for msg in conversation.messages
             ]
 
-            # Ensure we're using a valid model name, not the API key
-            if not isinstance(self.model, str) or self.model.startswith("sk-"):
-                logger.warning(
-                    f"Invalid model name detected. Falling back to {DEFAULT_MODEL!r}"
-                )
-                model_name = DEFAULT_MODEL
-            else:
-                model_name = self.model
-
-            r = self.client.chat.completions.create(
-                model=model_name,  # Use the validated model name
-                messages=messages,
-                **kwargs,
+            response = self.client.chat.completions.create(
+                model=self.model, messages=messages
             )
-            return r
+
+            return response.choices[0].message.content
         except Exception as e:
             self._handle_api_error(e)
-
-    def generate_text(self, conversation, **kwargs) -> str:
-        """Generate a text response using the OpenAI API."""
-        return self.generate_response(conversation, **kwargs).choices[0].message.content

t.py

@@ -1,15 +1,9 @@
-import simplemind
+from simplemind import SimpleMind
 
-from simplemind.core import settings
-
-print(settings)
-
-# Initialize client without explicit API key
-ai = simplemind.Client()
-
-print(ai.available_models)
+sm = SimpleMind()
 
 # The provider will automatically use OPENAI_API_KEY from environment
-conversation = ai.create_conversation(provider="openai")
-response = ai.send_message(conversation, "Who is Kenneth Reitz?")
-print(response)
+conversation = sm.create_conversation()
+r = conversation.send_message("Who is Kenneth Reitz?", model="gpt-4o")
+print(r)
+#