airtrain 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

airtrain/integrations/search/__init__.py

@@ -0,0 +1,21 @@
+"""
+Search integrations for AirTrain.
+
+This package provides integrations with various search providers.
+"""
+
+# Import specific search integrations as needed
+from .exa import (
+    ExaCredentials,
+    ExaSearchInputSchema,
+    ExaSearchOutputSchema,
+    ExaSearchSkill,
+)
+
+__all__ = [
+    # Exa Search
+    "ExaCredentials",
+    "ExaSearchInputSchema",
+    "ExaSearchOutputSchema",
+    "ExaSearchSkill",
+]

airtrain/integrations/search/exa/__init__.py

@@ -0,0 +1,23 @@
+"""
+Exa Search API integration.
+
+This module provides integration with the Exa search API for web searching capabilities.
+"""
+
+from .credentials import ExaCredentials
+from .schemas import (
+    ExaSearchInputSchema,
+    ExaSearchOutputSchema,
+    ExaContentConfig,
+    ExaSearchResult,
+)
+from .skills import ExaSearchSkill
+
+__all__ = [
+    "ExaCredentials",
+    "ExaSearchInputSchema",
+    "ExaSearchOutputSchema",
+    "ExaContentConfig",
+    "ExaSearchResult",
+    "ExaSearchSkill",
+]

airtrain/integrations/search/exa/credentials.py

@@ -0,0 +1,30 @@
+"""
+Credentials for Exa Search API.
+
+This module provides credential management for the Exa search API.
+"""
+
+from typing import Optional
+from pydantic import Field, SecretStr
+
+from airtrain.core.credentials import BaseCredentials
+
+
+class ExaCredentials(BaseCredentials):
+    """Credentials for accessing the Exa search API."""
+
+    exa_api_key: SecretStr = Field(
+        description="Exa search API key",
+    )
+
+    _required_credentials = {"exa_api_key"}
+
+    async def validate_credentials(self) -> bool:
+        """Validate that the required credentials are present and valid."""
+        # First check that required credentials are present
+        await super().validate_credentials()
+
+        # In a production environment, we might want to make a test API call here
+        # to verify the API key is actually valid, but for now we'll just check
+        # that it's present
+        return True

airtrain/integrations/search/exa/schemas.py

@@ -0,0 +1,114 @@
+"""
+Schemas for Exa Search API.
+
+This module defines the input and output schemas for the Exa search API.
+"""
+
+from typing import Dict, List, Optional, Any, Union, bool
+from pydantic import BaseModel, Field, HttpUrl
+
+from airtrain.core.schemas import InputSchema, OutputSchema
+
+
+class ExaContentConfig(BaseModel):
+    """Configuration for the content to be returned by Exa search."""
+
+    text: bool = Field(default=True, description="Whether to return text content.")
+    extractedText: Optional[bool] = Field(
+        default=None, description="Whether to return extracted text content."
+    )
+    embedded: Optional[bool] = Field(
+        default=None, description="Whether to return embedded content."
+    )
+    links: Optional[bool] = Field(
+        default=None, description="Whether to return links from the content."
+    )
+    screenshot: Optional[bool] = Field(
+        default=None, description="Whether to return screenshots of the content."
+    )
+    highlighted: Optional[bool] = Field(
+        default=None, description="Whether to return highlighted text."
+    )
+
+
+class ExaSearchInputSchema(InputSchema):
+    """Input schema for Exa search API."""
+
+    query: str = Field(description="The search query to execute.")
+    numResults: Optional[int] = Field(
+        default=None, description="Number of results to return."
+    )
+    contents: Optional[ExaContentConfig] = Field(
+        default_factory=ExaContentConfig,
+        description="Configuration for the content to be returned.",
+    )
+    highlights: Optional[dict] = Field(
+        default=None, description="Highlighting configuration for search results."
+    )
+    useAutoprompt: Optional[bool] = Field(
+        default=None, description="Whether to use autoprompt for the search."
+    )
+    type: Optional[str] = Field(default=None, description="Type of search to perform.")
+    includeDomains: Optional[List[str]] = Field(
+        default=None, description="List of domains to include in the search."
+    )
+    excludeDomains: Optional[List[str]] = Field(
+        default=None, description="List of domains to exclude from the search."
+    )
+
+
+class ExaModerationConfig(BaseModel):
+    """Moderation configuration returned in search results."""
+
+    llamaguardS1: Optional[bool] = None
+    llamaguardS3: Optional[bool] = None
+    llamaguardS4: Optional[bool] = None
+    llamaguardS12: Optional[bool] = None
+    domainBlacklisted: Optional[bool] = None
+    domainBlacklistedMedia: Optional[bool] = None
+
+
+class ExaHighlight(BaseModel):
+    """Highlight information for a search result."""
+
+    text: str
+    score: float
+
+
+class ExaSearchResult(BaseModel):
+    """Individual search result from Exa."""
+
+    id: str
+    url: str
+    title: Optional[str] = None
+    text: Optional[str] = None
+    extractedText: Optional[str] = None
+    embedded: Optional[Dict[str, Any]] = None
+    score: float
+    published: Optional[str] = None
+    author: Optional[str] = None
+    highlights: Optional[List[ExaHighlight]] = None
+    robotsAllowed: Optional[bool] = None
+    moderationConfig: Optional[ExaModerationConfig] = None
+    urls: Optional[List[str]] = None
+
+
+class ExaCostDetails(BaseModel):
+    """Cost details for an Exa search request."""
+
+    total: float
+    search: Dict[str, float]
+    contents: Dict[str, float]
+
+
+class ExaSearchOutputSchema(OutputSchema):
+    """Output schema for Exa search API."""
+
+    results: List[ExaSearchResult] = Field(description="List of search results.")
+    query: str = Field(description="The original search query.")
+    autopromptString: Optional[str] = Field(
+        default=None, description="Autoprompt string used for the search if enabled."
+    )
+    costDollars: Optional[ExaCostDetails] = Field(
+        default=None, description="Cost details for the search request."
+    )

airtrain/integrations/search/exa/skills.py

@@ -0,0 +1,115 @@
+"""
+Skills for Exa Search API.
+
+This module provides skills for using the Exa search API.
+"""
+
+import json
+import logging
+import httpx
+from typing import Optional, Dict, Any, List, cast
+
+from pydantic import ValidationError
+
+from airtrain.core.skills import Skill
+from airtrain.core.errors import ProcessingError
+from .credentials import ExaCredentials
+from .schemas import ExaSearchInputSchema, ExaSearchOutputSchema, ExaSearchResult
+
+
+logger = logging.getLogger(__name__)
+
+
+class ExaSearchSkill(Skill[ExaSearchInputSchema, ExaSearchOutputSchema]):
+    """Skill for searching the web using the Exa search API."""
+
+    input_schema = ExaSearchInputSchema
+    output_schema = ExaSearchOutputSchema
+
+    EXA_API_ENDPOINT = "https://api.exa.ai/search"
+
+    def __init__(
+        self,
+        credentials: ExaCredentials,
+        timeout: float = 60.0,
+        max_retries: int = 3,
+        **kwargs,
+    ):
+        """
+        Initialize the Exa search skill.
+
+        Args:
+            credentials: Credentials for accessing the Exa API
+            timeout: Timeout for API requests in seconds
+            max_retries: Maximum number of retries for failed requests
+        """
+        super().__init__(**kwargs)
+        self.credentials = credentials
+        self.timeout = timeout
+        self.max_retries = max_retries
+
+    async def process(self, input_data: ExaSearchInputSchema) -> ExaSearchOutputSchema:
+        """
+        Process a search request using the Exa API.
+
+        Args:
+            input_data: Search input parameters
+
+        Returns:
+            Search results from Exa
+
+        Raises:
+            ProcessingError: If there's an issue with the API request
+        """
+        try:
+            # Prepare request payload
+            payload = input_data.model_dump(exclude_none=True)
+
+            # Build request headers
+            headers = {
+                "content-type": "application/json",
+                "Authorization": f"Bearer {self.credentials.api_key.get_secret_value()}",
+            }
+
+            # Make the API request
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    self.EXA_API_ENDPOINT,
+                    headers=headers,
+                    json=payload,
+                    timeout=self.timeout,
+                )
+
+                # Check for successful response
+                if response.status_code == 200:
+                    result_data = response.json()
+
+                    # Construct the output schema
+                    output = ExaSearchOutputSchema(
+                        results=result_data.get("results", []),
+                        query=input_data.query,
+                        autopromptString=result_data.get("autopromptString"),
+                        costDollars=result_data.get("costDollars"),
+                    )
+
+                    return output
+                else:
+                    # Handle error responses
+                    error_message = f"Exa API returned status code {response.status_code}: {response.text}"
+                    logger.error(error_message)
+                    raise ProcessingError(error_message)
+
+        except httpx.TimeoutException:
+            error_message = f"Timeout while querying Exa API (timeout={self.timeout}s)"
+            logger.error(error_message)
+            raise ProcessingError(error_message)
+
+        except ValidationError as e:
+            error_message = f"Schema validation error: {str(e)}"
+            logger.error(error_message)
+            raise ProcessingError(error_message)
+
+        except Exception as e:
+            error_message = f"Unexpected error while querying Exa API: {str(e)}"
+            logger.error(error_message)
+            raise ProcessingError(error_message)

airtrain/integrations/together/__init__.py

@@ -0,0 +1,33 @@
+"""Together AI integration module"""
+
+from .credentials import TogetherAICredentials
+from .skills import TogetherAIChatSkill, TogetherAIInput, TogetherAIOutput
+from .models_config import (
+    get_model_config_with_capabilities,
+    get_max_completion_tokens,
+    supports_tool_use,
+    supports_json_mode,
+    TOGETHER_MODELS_CONFIG,
+)
+from .list_models import (
+    TogetherListModelsSkill,
+    TogetherListModelsInput,
+    TogetherListModelsOutput,
+)
+from .models import TogetherModel
+
+__all__ = [
+    "TogetherAICredentials", 
+    "TogetherAIChatSkill",
+    "TogetherAIInput",
+    "TogetherAIOutput",
+    "TogetherListModelsSkill",
+    "TogetherListModelsInput",
+    "TogetherListModelsOutput",
+    "TogetherModel",
+    "get_model_config_with_capabilities",
+    "get_max_completion_tokens",
+    "supports_tool_use",
+    "supports_json_mode",
+    "TOGETHER_MODELS_CONFIG",
+]

airtrain/integrations/together/audio_models_config.py

@@ -0,0 +1,34 @@
+from typing import Dict, NamedTuple
+
+
+class AudioModelConfig(NamedTuple):
+    organization: str
+    display_name: str
+
+
+TOGETHER_AUDIO_MODELS: Dict[str, AudioModelConfig] = {
+    "Cartesia/Sonic": AudioModelConfig(
+        organization="Cartesia", display_name="Cartesia/Sonic"
+    )
+}
+
+
+def get_audio_model_config(model_id: str) -> AudioModelConfig:
+    """Get audio model configuration by model ID"""
+    if model_id not in TOGETHER_AUDIO_MODELS:
+        raise ValueError(f"Model {model_id} not found in Together AI audio models")
+    return TOGETHER_AUDIO_MODELS[model_id]
+
+
+def list_audio_models_by_organization(organization: str) -> Dict[str, AudioModelConfig]:
+    """Get all audio models for a specific organization"""
+    return {
+        model_id: config
+        for model_id, config in TOGETHER_AUDIO_MODELS.items()
+        if config.organization.lower() == organization.lower()
+    }
+
+
+def get_default_audio_model() -> str:
+    """Get the default audio model ID"""
+    return "Cartesia/Sonic"

airtrain/integrations/together/credentials.py

@@ -0,0 +1,22 @@
+from pydantic import Field, SecretStr
+from airtrain.core.credentials import BaseCredentials, CredentialValidationError
+import together
+
+
+class TogetherAICredentials(BaseCredentials):
+    """Together AI credentials"""
+
+    together_api_key: SecretStr = Field(..., description="Together AI API key")
+
+    _required_credentials = {"together_api_key"}
+
+    async def validate_credentials(self) -> bool:
+        """Validate Together AI credentials"""
+        try:
+            together.api_key = self.together_api_key.get_secret_value()
+            await together.Models.list()
+            return True
+        except Exception as e:
+            raise CredentialValidationError(
+                f"Invalid Together AI credentials: {str(e)}"
+            )

airtrain/integrations/together/embedding_models_config.py

@@ -0,0 +1,92 @@
+from typing import Dict, NamedTuple
+
+
+class EmbeddingModelConfig(NamedTuple):
+    organization: str
+    display_name: str
+    model_size: str
+    embedding_dimension: int
+    context_window: int
+
+
+TOGETHER_EMBEDDING_MODELS: Dict[str, EmbeddingModelConfig] = {
+    "togethercomputer/m2-bert-80M-2k-retrieval": EmbeddingModelConfig(
+        organization="Together",
+        display_name="M2-BERT-80M-2K-Retrieval",
+        model_size="80M",
+        embedding_dimension=768,
+        context_window=2048,
+    ),
+    "togethercomputer/m2-bert-80M-8k-retrieval": EmbeddingModelConfig(
+        organization="Together",
+        display_name="M2-BERT-80M-8K-Retrieval",
+        model_size="80M",
+        embedding_dimension=768,
+        context_window=8192,
+    ),
+    "togethercomputer/m2-bert-80M-32k-retrieval": EmbeddingModelConfig(
+        organization="Together",
+        display_name="M2-BERT-80M-32K-Retrieval",
+        model_size="80M",
+        embedding_dimension=768,
+        context_window=32768,
+    ),
+    "WhereIsAI/UAE-Large-V1": EmbeddingModelConfig(
+        organization="WhereIsAI",
+        display_name="UAE-Large-v1",
+        model_size="326M",
+        embedding_dimension=1024,
+        context_window=512,
+    ),
+    "BAAI/bge-large-en-v1.5": EmbeddingModelConfig(
+        organization="BAAI",
+        display_name="BGE-Large-EN-v1.5",
+        model_size="326M",
+        embedding_dimension=1024,
+        context_window=512,
+    ),
+    "BAAI/bge-base-en-v1.5": EmbeddingModelConfig(
+        organization="BAAI",
+        display_name="BGE-Base-EN-v1.5",
+        model_size="102M",
+        embedding_dimension=768,
+        context_window=512,
+    ),
+    "sentence-transformers/msmarco-bert-base-dot-v5": EmbeddingModelConfig(
+        organization="sentence-transformers",
+        display_name="Sentence-BERT",
+        model_size="110M",
+        embedding_dimension=768,
+        context_window=512,
+    ),
+    "bert-base-uncased": EmbeddingModelConfig(
+        organization="Hugging Face",
+        display_name="BERT",
+        model_size="110M",
+        embedding_dimension=768,
+        context_window=512,
+    ),
+}
+
+
+def get_embedding_model_config(model_id: str) -> EmbeddingModelConfig:
+    """Get embedding model configuration by model ID"""
+    if model_id not in TOGETHER_EMBEDDING_MODELS:
+        raise ValueError(f"Model {model_id} not found in Together AI embedding models")
+    return TOGETHER_EMBEDDING_MODELS[model_id]
+
+
+def list_embedding_models_by_organization(
+    organization: str,
+) -> Dict[str, EmbeddingModelConfig]:
+    """Get all embedding models for a specific organization"""
+    return {
+        model_id: config
+        for model_id, config in TOGETHER_EMBEDDING_MODELS.items()
+        if config.organization.lower() == organization.lower()
+    }
+
+
+def get_default_embedding_model() -> str:
+    """Get the default embedding model ID"""
+    return "togethercomputer/m2-bert-80M-32k-retrieval"

airtrain/integrations/together/image_models_config.py

@@ -0,0 +1,69 @@
+from typing import Dict, NamedTuple, Optional
+
+
+class ImageModelConfig(NamedTuple):
+    organization: str
+    display_name: str
+    default_steps: Optional[int]
+
+
+TOGETHER_IMAGE_MODELS: Dict[str, ImageModelConfig] = {
+    "black-forest-labs/FLUX.1-schnell-Free": ImageModelConfig(
+        organization="Black Forest Labs",
+        display_name="Flux.1 [schnell] (free)",
+        default_steps=None,
+    ),
+    "black-forest-labs/FLUX.1-schnell": ImageModelConfig(
+        organization="Black Forest Labs",
+        display_name="Flux.1 [schnell] (Turbo)",
+        default_steps=4,
+    ),
+    "black-forest-labs/FLUX.1-dev": ImageModelConfig(
+        organization="Black Forest Labs", display_name="Flux.1 Dev", default_steps=28
+    ),
+    "black-forest-labs/FLUX.1-canny": ImageModelConfig(
+        organization="Black Forest Labs", display_name="Flux.1 Canny", default_steps=28
+    ),
+    "black-forest-labs/FLUX.1-depth": ImageModelConfig(
+        organization="Black Forest Labs", display_name="Flux.1 Depth", default_steps=28
+    ),
+    "black-forest-labs/FLUX.1-redux": ImageModelConfig(
+        organization="Black Forest Labs", display_name="Flux.1 Redux", default_steps=28
+    ),
+    "black-forest-labs/FLUX.1.1-pro": ImageModelConfig(
+        organization="Black Forest Labs",
+        display_name="Flux1.1 [pro]",
+        default_steps=None,
+    ),
+    "black-forest-labs/FLUX.1-pro": ImageModelConfig(
+        organization="Black Forest Labs",
+        display_name="Flux.1 [pro]",
+        default_steps=None,
+    ),
+    "stabilityai/stable-diffusion-xl-base-1.0": ImageModelConfig(
+        organization="Stability AI",
+        display_name="Stable Diffusion XL 1.0",
+        default_steps=None,
+    ),
+}
+
+
+def get_image_model_config(model_id: str) -> ImageModelConfig:
+    """Get image model configuration by model ID"""
+    if model_id not in TOGETHER_IMAGE_MODELS:
+        raise ValueError(f"Model {model_id} not found in Together AI image models")
+    return TOGETHER_IMAGE_MODELS[model_id]
+
+
+def list_image_models_by_organization(organization: str) -> Dict[str, ImageModelConfig]:
+    """Get all image models for a specific organization"""
+    return {
+        model_id: config
+        for model_id, config in TOGETHER_IMAGE_MODELS.items()
+        if config.organization.lower() == organization.lower()
+    }
+
+
+def get_default_image_model() -> str:
+    """Get the default image model ID"""
+    return "black-forest-labs/FLUX.1-schnell-Free"