airtrain 0.1.14__py3-none-any.whl → 0.1.18__py3-none-any.whl

airtrain/__init__.py

@@ -1,6 +1,6 @@
 """Airtrain - A platform for building and deploying AI agents with structured skills"""
 
-__version__ = "0.1.14"
+__version__ = "0.1.18"
 
 # Core imports
 from .core.skills import Skill, ProcessingError
@@ -22,7 +22,7 @@ from .integrations.cerebras.credentials import CerebrasCredentials
 from .integrations.openai.skills import OpenAIChatSkill, OpenAIParserSkill
 from .integrations.anthropic.skills import AnthropicChatSkill
 from .integrations.aws.skills import AWSBedrockSkill
-from .integrations.google.skills import VertexAISkill
+from .integrations.google.skills import GoogleChatSkill
 from .integrations.groq.skills import GroqChatSkill
 from .integrations.together.skills import TogetherAIChatSkill
 from .integrations.ollama.skills import OllamaChatSkill
@@ -51,7 +51,7 @@ __all__ = [
     "OpenAIParserSkill",
     "AnthropicChatSkill",
     "AWSBedrockSkill",
-    "VertexAISkill",
+    "GoogleChatSkill",
     "GroqChatSkill",
     "TogetherAIChatSkill",
     "OllamaChatSkill",

airtrain/integrations/__init__.py

@@ -15,7 +15,7 @@ from .cerebras.credentials import CerebrasCredentials
 from .openai.skills import OpenAIChatSkill, OpenAIParserSkill
 from .anthropic.skills import AnthropicChatSkill
 from .aws.skills import AWSBedrockSkill
-from .google.skills import VertexAISkill
+from .google.skills import GoogleChatSkill
 from .groq.skills import GroqChatSkill
 from .together.skills import TogetherAIChatSkill
 from .ollama.skills import OllamaChatSkill

airtrain/integrations/anthropic/skills.py

@@ -18,16 +18,22 @@ class AnthropicInput(InputSchema):
         default="You are a helpful assistant.",
         description="System prompt to guide the model's behavior",
     )
+    conversation_history: List[Dict[str, str]] = Field(
+        default_factory=list,
+        description="List of previous conversation messages in [{'role': 'user|assistant', 'content': 'message'}] format",
+    )
     model: str = Field(
         default="claude-3-opus-20240229", description="Anthropic model to use"
     )
-    max_tokens: int = Field(default=1024, description="Maximum tokens in response")
+    max_tokens: Optional[int] = Field(
+        default=1024, description="Maximum tokens in response"
+    )
     temperature: float = Field(
         default=0.7, description="Temperature for response generation", ge=0, le=1
     )
-    images: Optional[List[Path]] = Field(
-        default=None,
-        description="Optional list of image paths to include in the message",
+    images: List[Path] = Field(
+        default_factory=list,
+        description="List of image paths to include in the message",
     )
 
 
@@ -42,94 +48,80 @@ class AnthropicOutput(OutputSchema):
 
 
 class AnthropicChatSkill(Skill[AnthropicInput, AnthropicOutput]):
-    """Skill for interacting with Anthropic's Claude models"""
+    """Skill for Anthropic chat"""
 
     input_schema = AnthropicInput
     output_schema = AnthropicOutput
 
     def __init__(self, credentials: Optional[AnthropicCredentials] = None):
-        """Initialize the skill with optional credentials"""
         super().__init__()
         self.credentials = credentials or AnthropicCredentials.from_env()
         self.client = Anthropic(
             api_key=self.credentials.anthropic_api_key.get_secret_value()
         )
 
-    def _encode_image(self, image_path: Path) -> Dict[str, Any]:
-        """Convert image to base64 for API consumption"""
-        try:
-            if not image_path.exists():
-                raise FileNotFoundError(f"Image file not found: {image_path}")
-
-            with open(image_path, "rb") as img_file:
-                encoded = base64.b64encode(img_file.read()).decode()
-                return {
-                    "type": "image",
-                    "source": {
-                        "type": "base64",
-                        "media_type": f"image/{image_path.suffix[1:]}",
-                        "data": encoded,
-                    },
-                }
-        except Exception as e:
-            logger.error(f"Failed to encode image {image_path}: {str(e)}")
-            raise ProcessingError(f"Image encoding failed: {str(e)}")
+    def _build_messages(self, input_data: AnthropicInput) -> List[Dict[str, Any]]:
+        """
+        Build messages list from input data including conversation history.
 
-    def process(self, input_data: AnthropicInput) -> AnthropicOutput:
-        """Process the input using Anthropic's API"""
-        try:
-            logger.info(f"Processing request with model {input_data.model}")
+        Args:
+            input_data: The input data containing system prompt, conversation history, and user input
 
-            # Prepare message content
-            content = []
+        Returns:
+            List[Dict[str, Any]]: List of messages in the format required by Anthropic
+        """
+        messages = []
+
+        # Add conversation history if present
+        if input_data.conversation_history:
+            messages.extend(input_data.conversation_history)
 
-            # Add text content
-            content.append({"type": "text", "text": input_data.user_input})
+        # Prepare user message content
+        user_message = {"type": "text", "text": input_data.user_input}
 
-            # Add images if provided
-            if input_data.images:
-                logger.debug(f"Processing {len(input_data.images)} images")
-                for image_path in input_data.images:
-                    content.append(self._encode_image(image_path))
+        # Add images if present
+        if input_data.images:
+            content = []
+            for image_path in input_data.images:
+                with open(image_path, "rb") as img_file:
+                    base64_image = base64.b64encode(img_file.read()).decode("utf-8")
+                content.append(
+                    {
+                        "type": "image",
+                        "source": {
+                            "type": "base64",
+                            "media_type": "image/jpeg",
+                            "data": base64_image,
+                        },
+                    }
+                )
+            content.append(user_message)
+            messages.append({"role": "user", "content": content})
+        else:
+            messages.append({"role": "user", "content": [user_message]})
+
+        return messages
+
+    def process(self, input_data: AnthropicInput) -> AnthropicOutput:
+        try:
+            # Build messages using the helper method
+            messages = self._build_messages(input_data)
 
-            # Create message
+            # Create chat completion with system prompt as a separate parameter
             response = self.client.messages.create(
                 model=input_data.model,
+                system=input_data.system_prompt,  # System prompt passed directly
+                messages=messages,
                 max_tokens=input_data.max_tokens,
                 temperature=input_data.temperature,
-                system=input_data.system_prompt,
-                messages=[{"role": "user", "content": content}],
             )
 
-            # Validate response content
-            if not response.content:
-                logger.error("Empty response received from Anthropic API")
-                raise ProcessingError("Empty response received from Anthropic API")
-
-            if not isinstance(response.content, list) or not response.content:
-                logger.error("Invalid response format from Anthropic API")
-                raise ProcessingError("Invalid response format from Anthropic API")
-
-            first_content = response.content[0]
-            if not hasattr(first_content, "text"):
-                logger.error("Response content does not contain text")
-                raise ProcessingError("Response content does not contain text")
-
-            logger.success("Successfully processed Anthropic request")
-
-            # Create output
             return AnthropicOutput(
-                response=first_content.text,
-                used_model=response.model,
-                usage={
-                    "input_tokens": response.usage.input_tokens,
-                    "output_tokens": response.usage.output_tokens,
-                },
+                response=response.content[0].text,
+                used_model=input_data.model,
+                usage=response.usage.model_dump(),
             )
 
-        except ProcessingError:
-            # Re-raise ProcessingError without modification
-            raise
         except Exception as e:
             logger.exception(f"Anthropic processing failed: {str(e)}")
             raise ProcessingError(f"Anthropic processing failed: {str(e)}")

airtrain/integrations/cerebras/credentials.py

@@ -1,16 +1,13 @@
-from pydantic import Field, SecretStr, HttpUrl
+from pydantic import Field, SecretStr
 from airtrain.core.credentials import BaseCredentials, CredentialValidationError
-from typing import Optional
 
 
 class CerebrasCredentials(BaseCredentials):
     """Cerebras credentials"""
 
-    api_key: SecretStr = Field(..., description="Cerebras API key")
-    endpoint_url: HttpUrl = Field(..., description="Cerebras API endpoint")
-    project_id: Optional[str] = Field(None, description="Cerebras Project ID")
+    cerebras_api_key: SecretStr = Field(..., description="Cerebras API key")
 
-    _required_credentials = {"api_key", "endpoint_url"}
+    _required_credentials = {"cerebras_api_key"}
 
     async def validate_credentials(self) -> bool:
         """Validate Cerebras credentials"""

airtrain/integrations/cerebras/skills.py

@@ -1,27 +1,36 @@
-from typing import Optional, Dict, Any
+from typing import List, Optional, Dict, Any
 from pydantic import Field
+from cerebras.cloud.sdk import Cerebras
+from loguru import logger
+
 from airtrain.core.skills import Skill, ProcessingError
 from airtrain.core.schemas import InputSchema, OutputSchema
 from .credentials import CerebrasCredentials
 
 
 class CerebrasInput(InputSchema):
-    """Schema for Cerebras input"""
+    """Schema for Cerebras chat input"""
 
     user_input: str = Field(..., description="User's input text")
     system_prompt: str = Field(
         default="You are a helpful assistant.",
         description="System prompt to guide the model's behavior",
     )
-    model: str = Field(default="cerebras-gpt", description="Cerebras model to use")
-    max_tokens: int = Field(default=1024, description="Maximum tokens in response")
+    conversation_history: List[Dict[str, str]] = Field(
+        default_factory=list,
+        description="List of previous conversation messages in [{'role': 'user|assistant', 'content': 'message'}] format",
+    )
+    model: str = Field(default="llama3.1-8b", description="Cerebras model to use")
+    max_tokens: Optional[int] = Field(
+        default=1024, description="Maximum tokens in response"
+    )
     temperature: float = Field(
         default=0.7, description="Temperature for response generation", ge=0, le=1
     )
 
 
 class CerebrasOutput(OutputSchema):
-    """Schema for Cerebras output"""
+    """Schema for Cerebras chat output"""
 
     response: str = Field(..., description="Model's response text")
     used_model: str = Field(..., description="Model used for generation")
@@ -29,13 +38,58 @@ class CerebrasOutput(OutputSchema):
 
 
 class CerebrasChatSkill(Skill[CerebrasInput, CerebrasOutput]):
-    """Skill for Cerebras - Not Implemented"""
+    """Skill for Cerebras chat"""
 
     input_schema = CerebrasInput
     output_schema = CerebrasOutput
 
     def __init__(self, credentials: Optional[CerebrasCredentials] = None):
-        raise NotImplementedError("CerebrasChatSkill is not implemented yet")
+        super().__init__()
+        self.credentials = credentials or CerebrasCredentials.from_env()
+        self.client = Cerebras(
+            api_key=self.credentials.cerebras_api_key.get_secret_value()
+        )
+
+    def _build_messages(self, input_data: CerebrasInput) -> List[Dict[str, str]]:
+        """
+        Build messages list from input data including conversation history.
+
+        Args:
+            input_data: The input data containing system prompt, conversation history, and user input
+
+        Returns:
+            List[Dict[str, str]]: List of messages in the format required by Cerebras
+        """
+        messages = [{"role": "system", "content": input_data.system_prompt}]
+
+        # Add conversation history if present
+        if input_data.conversation_history:
+            messages.extend(input_data.conversation_history)
+
+        # Add current user input
+        messages.append({"role": "user", "content": input_data.user_input})
+
+        return messages
 
     def process(self, input_data: CerebrasInput) -> CerebrasOutput:
-        raise NotImplementedError("CerebrasChatSkill is not implemented yet")
+        try:
+            # Build messages using the helper method
+            messages = self._build_messages(input_data)
+
+            # Create chat completion
+            response = self.client.chat.completions.create(
+                model=input_data.model,
+                messages=messages,
+                temperature=input_data.temperature,
+                max_tokens=input_data.max_tokens,
+            )
+
+            return CerebrasOutput(
+                response=response.choices[0].message.content,
+                used_model=input_data.model,
+                usage=response.usage.model_dump(),
+            )
+
+        except Exception as e:
+            logger.exception(f"Cerebras processing failed: {str(e)}")
+            raise ProcessingError(f"Cerebras processing failed: {str(e)}")

airtrain/integrations/fireworks/conversation_manager.py

@@ -0,0 +1,109 @@
+from typing import List, Dict, Optional
+from pydantic import BaseModel, Field
+from .skills import FireworksChatSkill, FireworksInput, FireworksOutput
+
+# TODO: Test this thing.
+
+
+class ConversationState(BaseModel):
+    """Model to track conversation state"""
+
+    messages: List[Dict[str, str]] = Field(
+        default_factory=list, description="List of conversation messages"
+    )
+    system_prompt: str = Field(
+        default="You are a helpful assistant.",
+        description="System prompt for the conversation",
+    )
+    model: str = Field(
+        default="accounts/fireworks/models/deepseek-r1",
+        description="Model being used for the conversation",
+    )
+    temperature: float = Field(default=0.7, description="Temperature setting")
+    max_tokens: Optional[int] = Field(default=None, description="Max tokens setting")
+
+
+class FireworksConversationManager:
+    """Manager for handling conversation state with Fireworks AI"""
+
+    def __init__(
+        self,
+        skill: Optional[FireworksChatSkill] = None,
+        system_prompt: str = "You are a helpful assistant.",
+        model: str = "accounts/fireworks/models/deepseek-r1",
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+    ):
+        """
+        Initialize conversation manager.
+
+        Args:
+            skill: FireworksChatSkill instance (creates new one if None)
+            system_prompt: Initial system prompt
+            model: Model to use
+            temperature: Temperature setting
+            max_tokens: Max tokens setting
+        """
+        self.skill = skill or FireworksChatSkill()
+        self.state = ConversationState(
+            system_prompt=system_prompt,
+            model=model,
+            temperature=temperature,
+            max_tokens=max_tokens,
+        )
+
+    def send_message(self, user_input: str) -> FireworksOutput:
+        """
+        Send a message and get response while maintaining conversation history.
+
+        Args:
+            user_input: User's message
+
+        Returns:
+            FireworksOutput: Model's response
+        """
+        # Create input with current conversation state
+        input_data = FireworksInput(
+            user_input=user_input,
+            system_prompt=self.state.system_prompt,
+            conversation_history=self.state.messages,
+            model=self.state.model,
+            temperature=self.state.temperature,
+            max_tokens=self.state.max_tokens,
+        )
+
+        # Get response
+        result = self.skill.process(input_data)
+
+        # Update conversation history
+        self.state.messages.extend(
+            [
+                {"role": "user", "content": user_input},
+                {"role": "assistant", "content": result.response},
+            ]
+        )
+
+        return result
+
+    def reset_conversation(self) -> None:
+        """Reset the conversation history while maintaining other settings"""
+        self.state.messages = []
+
+    def get_conversation_history(self) -> List[Dict[str, str]]:
+        """Get the current conversation history"""
+        return self.state.messages.copy()
+
+    def update_system_prompt(self, new_prompt: str) -> None:
+        """Update the system prompt for future messages"""
+        self.state.system_prompt = new_prompt
+
+    def save_state(self, file_path: str) -> None:
+        """Save conversation state to a file"""
+        with open(file_path, "w") as f:
+            f.write(self.state.model_dump_json(indent=2))
+
+    def load_state(self, file_path: str) -> None:
+        """Load conversation state from a file"""
+        with open(file_path, "r") as f:
+            data = f.read()
+            self.state = ConversationState.model_validate_json(data)

airtrain/integrations/fireworks/skills.py

@@ -17,6 +17,10 @@ class FireworksInput(InputSchema):
         default="You are a helpful assistant.",
         description="System prompt to guide the model's behavior",
     )
+    conversation_history: List[Dict[str, str]] = Field(
+        default_factory=list,
+        description="List of previous conversation messages in [{'role': 'user|assistant', 'content': 'message'}] format",
+    )
     model: str = Field(
         default="accounts/fireworks/models/deepseek-r1",
         description="Fireworks AI model to use",
@@ -52,16 +56,34 @@ class FireworksChatSkill(Skill[FireworksInput, FireworksOutput]):
         self.credentials = credentials or FireworksCredentials.from_env()
         self.base_url = "https://api.fireworks.ai/inference/v1"
 
+    def _build_messages(self, input_data: FireworksInput) -> List[Dict[str, str]]:
+        """
+        Build messages list from input data including conversation history.
+
+        Args:
+            input_data: The input data containing system prompt, conversation history, and user input
+
+        Returns:
+            List[Dict[str, str]]: List of messages in the format required by Fireworks AI
+        """
+        messages = [{"role": "system", "content": input_data.system_prompt}]
+
+        # Add conversation history if present
+        if input_data.conversation_history:
+            messages.extend(input_data.conversation_history)
+
+        # Add current user input
+        messages.append({"role": "user", "content": input_data.user_input})
+
+        return messages
+
     def process(self, input_data: FireworksInput) -> FireworksOutput:
         """Process the input using Fireworks AI API"""
         try:
             logger.info(f"Processing request with model {input_data.model}")
 
-            # Prepare messages
-            messages = [
-                {"role": "system", "content": input_data.system_prompt},
-                {"role": "user", "content": input_data.user_input},
-            ]
+            # Build messages using the helper method
+            messages = self._build_messages(input_data)
 
             # Prepare request payload
             payload = {

airtrain/integrations/google/__init__.py

@@ -1,6 +1,7 @@
 """Google Cloud integration module"""
 
 from .credentials import GoogleCloudCredentials
-from .skills import VertexAISkill
+from .skills import GoogleChatSkill
+# from .skills import VertexAISkill
 
 __all__ = ["GoogleCloudCredentials", "VertexAISkill"]

airtrain/integrations/google/credentials.py

@@ -1,5 +1,8 @@
 from pydantic import Field, SecretStr
 from airtrain.core.credentials import BaseCredentials, CredentialValidationError
+import google.genai as genai
+from google.cloud import storage
+import os
 
 # from google.cloud import storage
 
@@ -26,3 +29,30 @@ class GoogleCloudCredentials(BaseCredentials):
             raise CredentialValidationError(
                 f"Invalid Google Cloud credentials: {str(e)}"
             )
+
+
+class GeminiCredentials(BaseCredentials):
+    """Gemini API credentials"""
+
+    gemini_api_key: SecretStr = Field(..., description="Gemini API Key")
+
+    _required_credentials = {"gemini_api_key"}
+
+    @classmethod
+    def from_env(cls) -> "GeminiCredentials":
+        """Create credentials from environment variables"""
+        return cls(gemini_api_key=SecretStr(os.environ.get("GEMINI_API_KEY", "")))
+
+    async def validate_credentials(self) -> bool:
+        """Validate Gemini API credentials"""
+        try:
+            # Configure Gemini with API key
+            genai.configure(api_key=self.gemini_api_key.get_secret_value())
+
+            # Test API call with a simple model
+            model = genai.GenerativeModel("gemini-1.5-flash")
+            response = model.generate_content("test")
+
+            return True
+        except Exception as e:
+            raise CredentialValidationError(f"Invalid Gemini credentials: {str(e)}")

airtrain/integrations/google/skills.py

@@ -1,41 +1,122 @@
-from typing import Optional, Dict, Any
+from typing import List, Optional, Dict, Any
 from pydantic import Field
+import google.generativeai as genai
+from loguru import logger
+
 from airtrain.core.skills import Skill, ProcessingError
 from airtrain.core.schemas import InputSchema, OutputSchema
-from .credentials import GoogleCloudCredentials
+from .credentials import GeminiCredentials
+
+
+class GoogleGenerationConfig(InputSchema):
+    """Schema for Google generation config"""
+
+    temperature: float = Field(
+        default=1.0, description="Temperature for response generation", ge=0, le=1
+    )
+    top_p: float = Field(
+        default=0.95, description="Top p sampling parameter", ge=0, le=1
+    )
+    top_k: int = Field(default=40, description="Top k sampling parameter")
+    max_output_tokens: int = Field(
+        default=8192, description="Maximum tokens in response"
+    )
+    response_mime_type: str = Field(
+        default="text/plain", description="Response MIME type"
+    )
 
 
-class VertexAIInput(InputSchema):
-    """Schema for Google Vertex AI input"""
+class GoogleInput(InputSchema):
+    """Schema for Google chat input"""
 
     user_input: str = Field(..., description="User's input text")
     system_prompt: str = Field(
         default="You are a helpful assistant.",
         description="System prompt to guide the model's behavior",
     )
-    model: str = Field(default="text-bison", description="Vertex AI model to use")
-    max_tokens: int = Field(default=1024, description="Maximum tokens in response")
-    temperature: float = Field(
-        default=0.7, description="Temperature for response generation", ge=0, le=1
+    conversation_history: List[Dict[str, str | List[Dict[str, str]]]] = Field(
+        default_factory=list,
+        description="List of conversation messages in Google's format",
+    )
+    model: str = Field(default="gemini-1.5-flash", description="Google model to use")
+    generation_config: GoogleGenerationConfig = Field(
+        default_factory=GoogleGenerationConfig, description="Generation configuration"
     )
 
 
-class VertexAIOutput(OutputSchema):
-    """Schema for Vertex AI output"""
+class GoogleOutput(OutputSchema):
+    """Schema for Google chat output"""
 
     response: str = Field(..., description="Model's response text")
     used_model: str = Field(..., description="Model used for generation")
     usage: Dict[str, Any] = Field(default_factory=dict, description="Usage statistics")
 
 
-class VertexAISkill(Skill[VertexAIInput, VertexAIOutput]):
-    """Skill for Google Vertex AI - Not Implemented"""
+class GoogleChatSkill(Skill[GoogleInput, GoogleOutput]):
+    """Skill for Google chat"""
+
+    input_schema = GoogleInput
+    output_schema = GoogleOutput
+
+    def __init__(self, credentials: Optional[GeminiCredentials] = None):
+        super().__init__()
+        self.credentials = credentials or GeminiCredentials.from_env()
+        genai.configure(api_key=self.credentials.gemini_api_key.get_secret_value())
+
+    def _convert_history_format(
+        self, history: List[Dict[str, str]]
+    ) -> List[Dict[str, List[Dict[str, str]]]]:
+        """Convert standard history format to Google's format"""
+        google_history = []
+        for msg in history:
+            google_msg = {
+                "role": "user" if msg["role"] == "user" else "model",
+                "parts": [{"text": msg["content"]}],
+            }
+            google_history.append(google_msg)
+        return google_history
+
+    def process(self, input_data: GoogleInput) -> GoogleOutput:
+        try:
+            # Create generation config
+            generation_config = {
+                "temperature": input_data.generation_config.temperature,
+                "top_p": input_data.generation_config.top_p,
+                "top_k": input_data.generation_config.top_k,
+                "max_output_tokens": input_data.generation_config.max_output_tokens,
+                "response_mime_type": input_data.generation_config.response_mime_type,
+            }
+
+            # Initialize model
+            model = genai.GenerativeModel(
+                model_name=input_data.model,
+                generation_config=generation_config,
+                system_instruction=input_data.system_prompt,
+            )
+
+            # Convert history format if needed
+            history = (
+                input_data.conversation_history
+                if input_data.conversation_history
+                else self._convert_history_format([])
+            )
+
+            # Start chat session
+            chat = model.start_chat(history=history)
 
-    input_schema = VertexAIInput
-    output_schema = VertexAIOutput
+            # Send message and get response
+            response = chat.send_message(input_data.user_input)
 
-    def __init__(self, credentials: Optional[GoogleCloudCredentials] = None):
-        raise NotImplementedError("VertexAISkill is not implemented yet")
+            return GoogleOutput(
+                response=response.text,
+                used_model=input_data.model,
+                usage={
+                    "prompt_tokens": 0,
+                    "completion_tokens": 0,
+                    "total_tokens": 0,
+                },  # Google API doesn't provide usage stats
+            )
 
-    def process(self, input_data: VertexAIInput) -> VertexAIOutput:
-        raise NotImplementedError("VertexAISkill is not implemented yet")
+        except Exception as e:
+            logger.exception(f"Google processing failed: {str(e)}")
+            raise ProcessingError(f"Google processing failed: {str(e)}")

airtrain/integrations/groq/credentials.py

@@ -6,14 +6,14 @@ from groq import Groq
 class GroqCredentials(BaseCredentials):
     """Groq API credentials"""
 
-    api_key: SecretStr = Field(..., description="Groq API key")
+    groq_api_key: SecretStr = Field(..., description="Groq API key")
 
-    _required_credentials = {"api_key"}
+    _required_credentials = {"groq_api_key"}
 
     async def validate_credentials(self) -> bool:
         """Validate Groq credentials"""
         try:
-            client = Groq(api_key=self.api_key.get_secret_value())
+            client = Groq(api_key=self.groq_api_key.get_secret_value())
             await client.chat.completions.create(
                 messages=[{"role": "user", "content": "Hi"}],
                 model="mixtral-8x7b-32768",

airtrain/integrations/groq/skills.py

@@ -1,8 +1,9 @@
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, List
 from pydantic import Field
 from airtrain.core.skills import Skill, ProcessingError
 from airtrain.core.schemas import InputSchema, OutputSchema
 from .credentials import GroqCredentials
+from groq import Groq
 
 
 class GroqInput(InputSchema):
@@ -13,6 +14,10 @@ class GroqInput(InputSchema):
         default="You are a helpful assistant.",
         description="System prompt to guide the model's behavior",
     )
+    conversation_history: List[Dict[str, str]] = Field(
+        default_factory=list,
+        description="List of previous conversation messages in [{'role': 'user|assistant', 'content': 'message'}] format",
+    )
     model: str = Field(default="mixtral-8x7b", description="Groq model to use")
     max_tokens: int = Field(default=1024, description="Maximum tokens in response")
     temperature: float = Field(
@@ -29,13 +34,55 @@ class GroqOutput(OutputSchema):
 
 
 class GroqChatSkill(Skill[GroqInput, GroqOutput]):
-    """Skill for Groq - Not Implemented"""
+    """Skill for Groq chat"""
 
     input_schema = GroqInput
     output_schema = GroqOutput
 
     def __init__(self, credentials: Optional[GroqCredentials] = None):
-        raise NotImplementedError("GroqChatSkill is not implemented yet")
+        super().__init__()
+        self.credentials = credentials or GroqCredentials.from_env()
+        self.client = Groq(api_key=self.credentials.groq_api_key.get_secret_value())
+
+    def _build_messages(self, input_data: GroqInput) -> List[Dict[str, str]]:
+        """
+        Build messages list from input data including conversation history.
+
+        Args:
+            input_data: The input data containing system prompt, conversation history, and user input
+
+        Returns:
+            List[Dict[str, str]]: List of messages in the format required by Groq
+        """
+        messages = [{"role": "system", "content": input_data.system_prompt}]
+
+        # Add conversation history if present
+        if input_data.conversation_history:
+            messages.extend(input_data.conversation_history)
+
+        # Add current user input
+        messages.append({"role": "user", "content": input_data.user_input})
+
+        return messages
 
     def process(self, input_data: GroqInput) -> GroqOutput:
-        raise NotImplementedError("GroqChatSkill is not implemented yet")
+        try:
+            # Build messages using the helper method
+            messages = self._build_messages(input_data)
+
+            # Create chat completion
+            response = self.client.chat.completions.create(
+                model=input_data.model,
+                messages=messages,
+                temperature=input_data.temperature,
+                max_tokens=input_data.max_tokens,
+            )
+
+            return GroqOutput(
+                response=response.choices[0].message.content,
+                used_model=input_data.model,
+                usage=response.usage.model_dump(),
+            )
+
+        except Exception as e:
+            raise ProcessingError(f"Groq processing failed: {str(e)}")

airtrain/integrations/sambanova/credentials.py

@@ -5,10 +5,10 @@ from airtrain.core.credentials import BaseCredentials, CredentialValidationError
 class SambanovaCredentials(BaseCredentials):
     """SambaNova credentials"""
 
-    api_key: SecretStr = Field(..., description="SambaNova API key")
-    endpoint_url: HttpUrl = Field(..., description="SambaNova API endpoint")
+    sambanova_api_key: SecretStr = Field(..., description="SambaNova API key")
+    sambanova_endpoint_url: HttpUrl = Field(..., description="SambaNova API endpoint")
 
-    _required_credentials = {"api_key", "endpoint_url"}
+    _required_credentials = {"sambanova_api_key", "sambanova_endpoint_url"}
 
     async def validate_credentials(self) -> bool:
         """Validate SambaNova credentials"""

airtrain/integrations/sambanova/skills.py

@@ -1,8 +1,9 @@
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, List
 from pydantic import Field
 from airtrain.core.skills import Skill, ProcessingError
 from airtrain.core.schemas import InputSchema, OutputSchema
 from .credentials import SambanovaCredentials
+import openai
 
 
 class SambanovaInput(InputSchema):
@@ -13,11 +14,20 @@ class SambanovaInput(InputSchema):
         default="You are a helpful assistant.",
         description="System prompt to guide the model's behavior",
     )
-    model: str = Field(default="sambanova-llm", description="Sambanova model to use")
+    conversation_history: List[Dict[str, str]] = Field(
+        default_factory=list,
+        description="List of previous conversation messages in [{'role': 'user|assistant', 'content': 'message'}] format",
+    )
+    model: str = Field(
+        default="DeepSeek-R1-Distill-Llama-70B", description="Sambanova model to use"
+    )
     max_tokens: int = Field(default=1024, description="Maximum tokens in response")
     temperature: float = Field(
         default=0.7, description="Temperature for response generation", ge=0, le=1
     )
+    top_p: float = Field(
+        default=0.1, description="Top p sampling parameter", ge=0, le=1
+    )
 
 
 class SambanovaOutput(OutputSchema):
@@ -29,13 +39,59 @@ class SambanovaOutput(OutputSchema):
 
 
 class SambanovaChatSkill(Skill[SambanovaInput, SambanovaOutput]):
-    """Skill for Sambanova - Not Implemented"""
+    """Skill for Sambanova chat"""
 
     input_schema = SambanovaInput
     output_schema = SambanovaOutput
 
     def __init__(self, credentials: Optional[SambanovaCredentials] = None):
-        raise NotImplementedError("SambanovaChatSkill is not implemented yet")
+        super().__init__()
+        self.credentials = credentials or SambanovaCredentials.from_env()
+        self.client = openai.OpenAI(
+            api_key=self.credentials.sambanova_api_key.get_secret_value(),
+            base_url="https://api.sambanova.ai/v1",
+        )
+
+    def _build_messages(self, input_data: SambanovaInput) -> List[Dict[str, str]]:
+        """
+        Build messages list from input data including conversation history.
+
+        Args:
+            input_data: The input data containing system prompt, conversation history, and user input
+
+        Returns:
+            List[Dict[str, str]]: List of messages in the format required by Sambanova
+        """
+        messages = [{"role": "system", "content": input_data.system_prompt}]
+
+        # Add conversation history if present
+        if input_data.conversation_history:
+            messages.extend(input_data.conversation_history)
+
+        # Add current user input
+        messages.append({"role": "user", "content": input_data.user_input})
+
+        return messages
 
     def process(self, input_data: SambanovaInput) -> SambanovaOutput:
-        raise NotImplementedError("SambanovaChatSkill is not implemented yet")
+        try:
+            # Build messages using the helper method
+            messages = self._build_messages(input_data)
+
+            # Create chat completion
+            response = self.client.chat.completions.create(
+                model=input_data.model,
+                messages=messages,
+                temperature=input_data.temperature,
+                max_tokens=input_data.max_tokens,
+                top_p=input_data.top_p,
+            )
+
+            return SambanovaOutput(
+                response=response.choices[0].message.content,
+                used_model=input_data.model,
+                usage=response.usage.model_dump(),
+            )
+
+        except Exception as e:
+            raise ProcessingError(f"Sambanova processing failed: {str(e)}")

airtrain/integrations/together/image_skill.py

@@ -34,12 +34,12 @@ class TogetherAIImageInput(InputSchema):
 class GeneratedImage(OutputSchema):
     """Individual generated image data"""
 
-    b64_json: str = Field(..., description="Base64 encoded image data")
+    b64_json: Optional[str] = Field(None, description="Base64 encoded image data")
+    url: str = Field(..., description="URL of the generated image")
     seed: Optional[int] = Field(None, description="Seed used for this image")
     finish_reason: Optional[str] = Field(
         None, description="Reason for finishing generation"
     )
-    url: Optional[str] = Field(None, description="URL of the generated image")
 
 
 class TogetherAIImageOutput(OutputSchema):
@@ -87,47 +87,19 @@ class TogetherAIImageSkill(Skill[TogetherAIImageInput, TogetherAIImageOutput]):
             # Calculate total time
             total_time = time.time() - start_time
 
-            # Debug print the response structure
-            print(f"Response type: {type(response)}")
-            print(f"Response data type: {type(response.data)}")
-            if response.data:
-                print(f"First image type: {type(response.data[0])}")
-                print(f"First image attributes: {dir(response.data[0])}")
-
             # Convert response to our output format
             generated_images = []
             for img in response.data:
-                # Try different possible attribute names for image data
-                b64_data = None
-                for attr in ["b64_json", "image", "base64", "data"]:
-                    if hasattr(img, attr):
-                        b64_data = getattr(img, attr)
-                        if b64_data:
-                            break
-
-                if not b64_data:
-                    # If no direct attribute found, try accessing as dictionary
-                    try:
-                        if hasattr(img, "__dict__"):
-                            img_dict = img.__dict__
-                            for key in ["b64_json", "image", "base64", "data"]:
-                                if key in img_dict and img_dict[key]:
-                                    b64_data = img_dict[key]
-                                    break
-                    except:
-                        pass
-
-                if not b64_data:
+                if not hasattr(img, "url"):
                     raise ProcessingError(
-                        f"No image data found in API response. Response structure: {dir(img)}"
+                        f"No URL found in API response. Response structure: {dir(img)}"
                     )
 
                 generated_images.append(
                     GeneratedImage(
-                        b64_json=b64_data,
+                        url=img.url,
                         seed=getattr(img, "seed", None),
                         finish_reason=getattr(img, "finish_reason", None),
-                        url=getattr(img, "url", None),
                     )
                 )
 

airtrain/integrations/together/skills.py

@@ -18,8 +18,12 @@ class TogetherAIInput(InputSchema):
         default="You are a helpful assistant.",
         description="System prompt to guide the model's behavior",
     )
+    conversation_history: List[Dict[str, str]] = Field(
+        default_factory=list,
+        description="List of previous conversation messages in [{'role': 'user|assistant', 'content': 'message'}] format",
+    )
     model: str = Field(
-        default="togethercomputer/llama-2-70b", description="Together AI model to use"
+        default="deepseek-ai/DeepSeek-R1", description="Together AI model to use"
     )
     max_tokens: int = Field(default=1024, description="Maximum tokens in response")
     temperature: float = Field(
@@ -36,16 +40,60 @@ class TogetherAIOutput(OutputSchema):
 
 
 class TogetherAIChatSkill(Skill[TogetherAIInput, TogetherAIOutput]):
-    """Skill for Together AI - Not Implemented"""
+    """Skill for Together AI chat"""
 
     input_schema = TogetherAIInput
     output_schema = TogetherAIOutput
 
     def __init__(self, credentials: Optional[TogetherAICredentials] = None):
-        raise NotImplementedError("TogetherAIChatSkill is not implemented yet")
+        super().__init__()
+        self.credentials = credentials or TogetherAICredentials.from_env()
+        self.client = Together(
+            api_key=self.credentials.together_api_key.get_secret_value()
+        )
+
+    def _build_messages(self, input_data: TogetherAIInput) -> List[Dict[str, str]]:
+        """
+        Build messages list from input data including conversation history.
+
+        Args:
+            input_data: The input data containing system prompt, conversation history, and user input
+
+        Returns:
+            List[Dict[str, str]]: List of messages in the format required by Together AI
+        """
+        messages = [{"role": "system", "content": input_data.system_prompt}]
+
+        # Add conversation history if present
+        if input_data.conversation_history:
+            messages.extend(input_data.conversation_history)
+
+        # Add current user input
+        messages.append({"role": "user", "content": input_data.user_input})
+
+        return messages
 
     def process(self, input_data: TogetherAIInput) -> TogetherAIOutput:
-        raise NotImplementedError("TogetherAIChatSkill is not implemented yet")
+        try:
+            # Build messages using the helper method
+            messages = self._build_messages(input_data)
+
+            # Create chat completion
+            response = self.client.chat.completions.create(
+                model=input_data.model,
+                messages=messages,
+                max_tokens=input_data.max_tokens,
+                temperature=input_data.temperature,
+            )
+
+            return TogetherAIOutput(
+                response=response.choices[0].message.content,
+                used_model=input_data.model,
+                usage=response.usage.model_dump(),
+            )
+
+        except Exception as e:
+            raise ProcessingError(f"Together AI processing failed: {str(e)}")
 
 
 class TogetherAIImageSkill(Skill[TogetherAIImageInput, TogetherAIImageOutput]):

{airtrain-0.1.14.dist-info → airtrain-0.1.18.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: airtrain
-Version: 0.1.14
+Version: 0.1.18
 Summary: A platform for building and deploying AI agents with structured skills
 Home-page: https://github.com/rosaboyle/airtrain.dev
 Author: Dheeraj Pai

{airtrain-0.1.14.dist-info → airtrain-0.1.18.dist-info}/RECORD

@@ -1,4 +1,4 @@
-airtrain/__init__.py,sha256=FRI-wOLxVAu3ECtPJGQ8ZLjDSM1PgoiDGvn8ctNtS_8,2095
+airtrain/__init__.py,sha256=bcYpLgGSnetAPw4UsnE8Adgc57puLFct9LeKEiqjiT8,2099
 airtrain/contrib/__init__.py,sha256=pG-7mJ0pBMqp3Q86mIF9bo1PqoBOVSGlnEK1yY1U1ok,641
 airtrain/contrib/travel/__init__.py,sha256=clmBodw4nkTA-DsgjVGcXfJGPaWxIpCZDtdO-8RzL0M,811
 airtrain/contrib/travel/agents.py,sha256=tpQtZ0WUiXBuhvZtc2JlEam5TuR5l-Tndi14YyImDBM,8975
@@ -7,26 +7,27 @@ airtrain/core/__init__.py,sha256=9h7iKwTzZocCPc9bU6j8bA02BokteWIOcO1uaqGMcrk,254
 airtrain/core/credentials.py,sha256=PgQotrQc46J5djidKnkK1znUv3fyNkUFDO-m2Kn_Gzo,4006
 airtrain/core/schemas.py,sha256=MMXrDviC4gRea_QaPpbjgO--B_UKxnD7YrxqZOLJZZU,7003
 airtrain/core/skills.py,sha256=LljalzeSHK5eQPTAOEAYc5D8Qn1kVSfiz9WgziTD5UM,4688
-airtrain/integrations/__init__.py,sha256=Y-nxbWlPGy0Txt6qkRzLKQGapfAfL_q9W6U3ISTSg_I,1486
+airtrain/integrations/__init__.py,sha256=-3Vz2bqAUNvVHEZxFGUv5BfzJZsO_7MRyLifbHsweEE,1488
 airtrain/integrations/anthropic/__init__.py,sha256=qwlWLDh1rEVizYFbW8430z-f1SxHio7_Gaw5cCTUtoo,274
 airtrain/integrations/anthropic/credentials.py,sha256=hlTSw9HX66kYNaeQUtn0JjdZQBMNkzzFOJOoLOOzvcY,1246
-airtrain/integrations/anthropic/skills.py,sha256=sT7dBYPVCsICYjgBjUlyyP84A8h9OkbgkslvKHk3Tjs,5273
+airtrain/integrations/anthropic/skills.py,sha256=3yr9-X_O_sw7Z57qiqi9A7uuo6EREmXqHFG7MAwcxDw,4645
 airtrain/integrations/aws/__init__.py,sha256=3x7v2NxpAfI-U-YgwQeH5PtsmUrNLPMfLyUGFLiBjbs,155
 airtrain/integrations/aws/credentials.py,sha256=nN-daKAl7qOb_VdRpsThG8gN5GeSUkx-ji5E_gF_vYw,1444
 airtrain/integrations/aws/skills.py,sha256=TQiMXeXRRcJ14fe8Xi7Uk20iS6_INbcznuLGtMorcKY,3870
 airtrain/integrations/cerebras/__init__.py,sha256=zAD-qV38OzHhMCz1z-NvjjqcYEhURbm8RWTOKHNqbew,174
-airtrain/integrations/cerebras/credentials.py,sha256=IFkn8LxMAaOpvEWXDpb94VQGtqcDxQ7rZHKH-tX4Nuw,884
-airtrain/integrations/cerebras/skills.py,sha256=O9vwFzvv_tUOwFOVE8CszAQEac711eVYVUj_8dVMTpc,1596
+airtrain/integrations/cerebras/credentials.py,sha256=KDEH4r8FGT68L9p34MLZWK65wq_a703pqIF3ODaSbts,694
+airtrain/integrations/cerebras/skills.py,sha256=Ksggq_s5wHWlf_xQIOO8MFoNTYV0cm9SHZ7GESOd2YE,3527
 airtrain/integrations/fireworks/__init__.py,sha256=9pJvP0u1FJbNtB0oHa09mHVJLctELf_c27LOYyDk2ZI,271
+airtrain/integrations/fireworks/conversation_manager.py,sha256=m6VEHijqpYEYawkKhuHtb8RQxw4kxGWFWdbSK6zGuro,3704
 airtrain/integrations/fireworks/credentials.py,sha256=UpcwR9V5Hbk5sJbjFDJDbHMRqc90IQSqAvrtJCOvwEo,524
 airtrain/integrations/fireworks/models.py,sha256=F-MddbLCLAsTjwRr1l6IpJxOegyY4pD7jN9ySPiypSo,593
-airtrain/integrations/fireworks/skills.py,sha256=ZykowW8lMbTcZVJ0GO2Ut6E-u2-keXvE4F-_j-3JI4k,4074
-airtrain/integrations/google/__init__.py,sha256=INZFNOcNebz3m-Ggk07ZjmX0kNHIbTe_St9gBlZBki8,176
-airtrain/integrations/google/credentials.py,sha256=Mm4jNWF02rIf0_GuHLcUUPyLHC4NMRdF_iTCoVTQ0Bs,1033
-airtrain/integrations/google/skills.py,sha256=uwmgetl5Ien7fLOA5HIZdqoL6AZnexFDyzfsrGuJ1RU,1606
+airtrain/integrations/fireworks/skills.py,sha256=-6zfe5eooygDYL1cyrk4PUT2TLEmAT2ZRfH2cr42DaU,4960
+airtrain/integrations/google/__init__.py,sha256=ElwgcXfbg_gGMm6zbkMXCQPFKZUb-yTJk986o19A7Cs,214
+airtrain/integrations/google/credentials.py,sha256=KSvWNqW8Mjr4MkysRvUqlrOSGdShNIe5u2OPO6vRrWY,2047
+airtrain/integrations/google/skills.py,sha256=ytsoksCY4qbfRO9Brnxhc2694fAj0ytnHX20SXS_FOM,4547
 airtrain/integrations/groq/__init__.py,sha256=B_X2fXbsJfFD6GquKeVCsEJjwd9Ygbq1uEHlV4Jy7YE,154
-airtrain/integrations/groq/credentials.py,sha256=A8-VIyoZTkHFQb-O-lmu-UrgaLZ3hfWfzzigkYteESk,829
-airtrain/integrations/groq/skills.py,sha256=Qy6SBAb19SzOFuqgcLyzdyRBp4D7jKqsEeJ6UTDaqMM,1528
+airtrain/integrations/groq/credentials.py,sha256=bdTHykcIeaQ7td8KZlQBPfEFAkvJuxk2f_cbTLPD_I4,844
+airtrain/integrations/groq/skills.py,sha256=oXgNLV8qRrYEY2VotKcaESQrQZAXJKzWLaHpVAp88VM,3269
 airtrain/integrations/ollama/__init__.py,sha256=zMHBsGzViVrvxAeJmfq6r-ZfSE6Dy5QcKLhe4d5fEcM,164
 airtrain/integrations/ollama/credentials.py,sha256=D7O4kUAb_VHs5s1ncUN9Ezhu5PvLfgj3RifAkB9sEZk,940
 airtrain/integrations/ollama/skills.py,sha256=M_Un8D5VJ5XtPEq9IClzqV3jCPBoFTSm2ve6EO8W2JU,1556
@@ -36,22 +37,22 @@ airtrain/integrations/openai/credentials.py,sha256=NfRyp1QgEtgm8cxt2-BOLq-6d0X-P
 airtrain/integrations/openai/models_config.py,sha256=bzosqqpDy2AJxu2vGdk2H4voqEGlv7LORR6fpJLhNic,3962
 airtrain/integrations/openai/skills.py,sha256=Olg9-6f_p2XgkVwwcB9tvjAMApmM2EK81i8LP4qVVvs,7676
 airtrain/integrations/sambanova/__init__.py,sha256=dp_263iOckM_J9pOEvyqpf3FrejD6-_x33r0edMCTe0,179
-airtrain/integrations/sambanova/credentials.py,sha256=U36RAEIPNuwo-vTrt3U9kkkj2GfdqSclA1ttOYHxS-w,784
-airtrain/integrations/sambanova/skills.py,sha256=Po1ur_QFwzVIugbkk2mt73WdXDz_Gr9ASlUc9Y12Kok,1614
+airtrain/integrations/sambanova/credentials.py,sha256=JyN8sbMCoXuXAjim46aI3LTicBijoemS7Ao0rn4yBJU,824
+airtrain/integrations/sambanova/skills.py,sha256=SDFY-ZzhOEIxQgTkQJzX9gN7UDqqnCBJdK7I2JydIoY,3625
 airtrain/integrations/together/__init__.py,sha256=we4KXn_pUs6Dxo3QcB-t40BSRraQFdKg2nXw7yi2FjM,185
 airtrain/integrations/together/audio_models_config.py,sha256=GtqfmKR1vJ5x4B3kScvEO3x4exvzwNP78vcGVTk_fBE,1004
 airtrain/integrations/together/credentials.py,sha256=cYNhyIwgsxm8LfiFfT-omBvgV3mUP6SZeRSukyzzDlI,747
 airtrain/integrations/together/embedding_models_config.py,sha256=F0ISAXCG_Pcnf-ojkvZwIXacXD8LaU8hQmGHCFzmlds,2927
 airtrain/integrations/together/image_models_config.py,sha256=JlCozrphI9zE4uYpGfj4DCWSN6GZGyr84Tb1HmjNQ28,2455
-airtrain/integrations/together/image_skill.py,sha256=FMO9-TRwfucLRlpvij9VpeVsrTiP9wux_je_pFz6OXs,6508
+airtrain/integrations/together/image_skill.py,sha256=wQ8wSzfL-QHpM_esYGLNXf8ciOPPsz-QJw6zSrxZT68,5214
 airtrain/integrations/together/models.py,sha256=ZW5xfEN9fU18aeltb-sB2O-Bnu5sLkDPZqvUtxgoH-U,2112
 airtrain/integrations/together/models_config.py,sha256=XMKp0Oq1nWWnMMdNAZxkFXmJaURwWrwLE18kFXsMsRw,8829
 airtrain/integrations/together/rerank_models_config.py,sha256=coCg0IOG2tU4L2uc2uPtPdoBwGjSc_zQwxENwdDuwHE,1188
 airtrain/integrations/together/rerank_skill.py,sha256=gjH24hLWCweWKPyyfKZMG3K_g9gWzm80WgiJNjkA9eg,1894
 airtrain/integrations/together/schemas.py,sha256=pBMrbX67oxPCr-sg4K8_Xqu1DWbaC4uLCloVSascROg,1210
-airtrain/integrations/together/skills.py,sha256=UfLHnseZbA7R7q5dDco6mpV546Zfd3DTliZSrNkCL6Q,4518
+airtrain/integrations/together/skills.py,sha256=mUoHc2r5TYQi5iGzwz2aDuUeROGq7teCtNrOlNApef4,6276
 airtrain/integrations/together/vision_models_config.py,sha256=m28HwYDk2Kup_J-a1FtynIa2ZVcbl37kltfoHnK8zxs,1544
-airtrain-0.1.14.dist-info/METADATA,sha256=l4IPKLJ7Bf3gmZYSRPVEfz4oe1XGt_lWfvuZg68cNnE,4536
-airtrain-0.1.14.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-airtrain-0.1.14.dist-info/top_level.txt,sha256=cFWW1vY6VMCb3AGVdz6jBDpZ65xxBRSqlsPyySxTkxY,9
-airtrain-0.1.14.dist-info/RECORD,,
+airtrain-0.1.18.dist-info/METADATA,sha256=AxrqXPt97vDxPwWAs0CCZLuUMOH4aBVifqykVawII6U,4536
+airtrain-0.1.18.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+airtrain-0.1.18.dist-info/top_level.txt,sha256=cFWW1vY6VMCb3AGVdz6jBDpZ65xxBRSqlsPyySxTkxY,9
+airtrain-0.1.18.dist-info/RECORD,,