antfly-sdk 0.0.2.dev2__py3-none-any.whl

antfly/client_generated/models/chat_tools_config.py

@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.chat_tool_name import ChatToolName
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.fetch_config import FetchConfig
+    from ..models.web_search_config import WebSearchConfig
+
+
+T = TypeVar("T", bound="ChatToolsConfig")
+
+
+@_attrs_define
+class ChatToolsConfig:
+    """Configuration for chat agent tools.
+
+    If `enabled_tools` is empty/omitted, defaults to: add_filter, ask_clarification, search.
+
+    For models that don't support native tool calling (e.g., Ollama),
+    a prompt-based fallback is used with structured output parsing.
+
+        Attributes:
+            enabled_tools (list[ChatToolName] | Unset): List of tools to enable. If empty, defaults to filter,
+                clarification, and search.
+                 Example: ['add_filter', 'search', 'websearch'].
+            websearch_config (WebSearchConfig | Unset): A unified configuration for web search providers.
+
+                Each provider has specific configuration requirements. Use the appropriate
+                provider-specific config or set common options at the top level.
+
+                **Environment Variables (fallbacks):**
+                - GOOGLE_CSE_API_KEY, GOOGLE_CSE_ID
+                - BING_SEARCH_API_KEY
+                - SERPER_API_KEY
+                - TAVILY_API_KEY
+                - BRAVE_API_KEY
+            fetch_config (FetchConfig | Unset): Configuration for URL content fetching.
+
+                Uses go/pkg/antfly/lib/scraping for downloading and processing. Supports:
+                - HTTP/HTTPS URLs with security validation
+                - HTML pages (extracts readable text via go-readability)
+                - PDF files (extracts text)
+                - Images (returns as data URIs)
+                - Plain text files
+                - S3 URLs (requires s3_credentials)
+
+                Security features (from go/pkg/antfly/lib/scraping.ContentSecurityConfig):
+                - Allowed host whitelist
+                - Private IP blocking (SSRF prevention)
+                - Download size limits
+                - Timeout controls
+            max_tool_iterations (int | Unset): Maximum number of tool call iterations per turn.
+                Prevents infinite loops in tool execution.
+                 Default: 5.
+    """
+
+    enabled_tools: list[ChatToolName] | Unset = UNSET
+    websearch_config: WebSearchConfig | Unset = UNSET
+    fetch_config: FetchConfig | Unset = UNSET
+    max_tool_iterations: int | Unset = 5
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        enabled_tools: list[str] | Unset = UNSET
+        if not isinstance(self.enabled_tools, Unset):
+            enabled_tools = []
+            for enabled_tools_item_data in self.enabled_tools:
+                enabled_tools_item = enabled_tools_item_data.value
+                enabled_tools.append(enabled_tools_item)
+
+        websearch_config: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.websearch_config, Unset):
+            websearch_config = self.websearch_config.to_dict()
+
+        fetch_config: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.fetch_config, Unset):
+            fetch_config = self.fetch_config.to_dict()
+
+        max_tool_iterations = self.max_tool_iterations
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if enabled_tools is not UNSET:
+            field_dict["enabled_tools"] = enabled_tools
+        if websearch_config is not UNSET:
+            field_dict["websearch_config"] = websearch_config
+        if fetch_config is not UNSET:
+            field_dict["fetch_config"] = fetch_config
+        if max_tool_iterations is not UNSET:
+            field_dict["max_tool_iterations"] = max_tool_iterations
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.fetch_config import FetchConfig
+        from ..models.web_search_config import WebSearchConfig
+
+        d = dict(src_dict)
+        _enabled_tools = d.pop("enabled_tools", UNSET)
+        enabled_tools: list[ChatToolName] | Unset = UNSET
+        if _enabled_tools is not UNSET:
+            enabled_tools = []
+            for enabled_tools_item_data in _enabled_tools:
+                enabled_tools_item = ChatToolName(enabled_tools_item_data)
+
+                enabled_tools.append(enabled_tools_item)
+
+        _websearch_config = d.pop("websearch_config", UNSET)
+        websearch_config: WebSearchConfig | Unset
+        if isinstance(_websearch_config, Unset):
+            websearch_config = UNSET
+        else:
+            websearch_config = WebSearchConfig.from_dict(_websearch_config)
+
+        _fetch_config = d.pop("fetch_config", UNSET)
+        fetch_config: FetchConfig | Unset
+        if isinstance(_fetch_config, Unset):
+            fetch_config = UNSET
+        else:
+            fetch_config = FetchConfig.from_dict(_fetch_config)
+
+        max_tool_iterations = d.pop("max_tool_iterations", UNSET)
+
+        chat_tools_config = cls(
+            enabled_tools=enabled_tools,
+            websearch_config=websearch_config,
+            fetch_config=fetch_config,
+            max_tool_iterations=max_tool_iterations,
+        )
+
+        chat_tools_config.additional_properties = d
+        return chat_tools_config
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/chunk_options.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.audio_chunk_options import AudioChunkOptions
+    from ..models.text_chunk_options import TextChunkOptions
+
+
+T = TypeVar("T", bound="ChunkOptions")
+
+
+@_attrs_define
+class ChunkOptions:
+    """Per-request configuration for chunking. All fields are optional - zero/omitted values use chunker defaults.
+
+    Attributes:
+        max_chunks (int | Unset): Maximum number of chunks to generate per document.
+        threshold (float | Unset): Confidence threshold for model-based chunking (0.0-1.0).
+        text (TextChunkOptions | Unset): Options specific to text chunking.
+        audio (AudioChunkOptions | Unset): Options specific to audio chunking.
+    """
+
+    max_chunks: int | Unset = UNSET
+    threshold: float | Unset = UNSET
+    text: TextChunkOptions | Unset = UNSET
+    audio: AudioChunkOptions | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        max_chunks = self.max_chunks
+
+        threshold = self.threshold
+
+        text: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.text, Unset):
+            text = self.text.to_dict()
+
+        audio: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.audio, Unset):
+            audio = self.audio.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if max_chunks is not UNSET:
+            field_dict["max_chunks"] = max_chunks
+        if threshold is not UNSET:
+            field_dict["threshold"] = threshold
+        if text is not UNSET:
+            field_dict["text"] = text
+        if audio is not UNSET:
+            field_dict["audio"] = audio
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.audio_chunk_options import AudioChunkOptions
+        from ..models.text_chunk_options import TextChunkOptions
+
+        d = dict(src_dict)
+        max_chunks = d.pop("max_chunks", UNSET)
+
+        threshold = d.pop("threshold", UNSET)
+
+        _text = d.pop("text", UNSET)
+        text: TextChunkOptions | Unset
+        if isinstance(_text, Unset):
+            text = UNSET
+        else:
+            text = TextChunkOptions.from_dict(_text)
+
+        _audio = d.pop("audio", UNSET)
+        audio: AudioChunkOptions | Unset
+        if isinstance(_audio, Unset):
+            audio = UNSET
+        else:
+            audio = AudioChunkOptions.from_dict(_audio)
+
+        chunk_options = cls(
+            max_chunks=max_chunks,
+            threshold=threshold,
+            text=text,
+            audio=audio,
+        )
+
+        chunk_options.additional_properties = d
+        return chunk_options
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/chunker_config.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.chunker_provider import ChunkerProvider
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.chunker_config_full_text_index import ChunkerConfigFullTextIndex
+
+
+T = TypeVar("T", bound="ChunkerConfig")
+
+
+@_attrs_define
+class ChunkerConfig:
+    """A unified configuration for a chunking provider.
+
+    Example:
+        {'provider': 'antfly', 'model': 'fixed', 'text': {'target_tokens': 500, 'overlap_tokens': 50}}
+
+    Attributes:
+        provider (ChunkerProvider): The chunking provider to use.
+        store_chunks (bool | Unset): Controls whether chunk data is persisted to storage. When false (default), chunks
+            are generated in memory and only embeddings are stored. When true, both chunks and embeddings are stored.
+            Default: False.
+        full_text_index (ChunkerConfigFullTextIndex | Unset): Configuration for full-text indexing of chunks in Bleve.
+            When present (even if empty), chunks will be stored with :cft: suffix and indexed in Bleve's _chunks field.
+            When absent, chunks use :c: suffix and are only used for vector embeddings.
+    """
+
+    provider: ChunkerProvider
+    store_chunks: bool | Unset = False
+    full_text_index: ChunkerConfigFullTextIndex | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        provider = self.provider.value
+
+        store_chunks = self.store_chunks
+
+        full_text_index: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.full_text_index, Unset):
+            full_text_index = self.full_text_index.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "provider": provider,
+            }
+        )
+        if store_chunks is not UNSET:
+            field_dict["store_chunks"] = store_chunks
+        if full_text_index is not UNSET:
+            field_dict["full_text_index"] = full_text_index
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.chunker_config_full_text_index import ChunkerConfigFullTextIndex
+
+        d = dict(src_dict)
+        provider = ChunkerProvider(d.pop("provider"))
+
+        store_chunks = d.pop("store_chunks", UNSET)
+
+        _full_text_index = d.pop("full_text_index", UNSET)
+        full_text_index: ChunkerConfigFullTextIndex | Unset
+        if isinstance(_full_text_index, Unset):
+            full_text_index = UNSET
+        else:
+            full_text_index = ChunkerConfigFullTextIndex.from_dict(_full_text_index)
+
+        chunker_config = cls(
+            provider=provider,
+            store_chunks=store_chunks,
+            full_text_index=full_text_index,
+        )
+
+        chunker_config.additional_properties = d
+        return chunker_config
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/chunker_config_full_text_index.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ChunkerConfigFullTextIndex")
+
+
+@_attrs_define
+class ChunkerConfigFullTextIndex:
+    """Configuration for full-text indexing of chunks in Bleve.
+    When present (even if empty), chunks will be stored with :cft: suffix and indexed in Bleve's _chunks field.
+    When absent, chunks use :c: suffix and are only used for vector embeddings.
+
+    """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        chunker_config_full_text_index = cls()
+
+        chunker_config_full_text_index.additional_properties = d
+        return chunker_config_full_text_index
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/chunker_provider.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class ChunkerProvider(str, Enum):
+    ANTFLY = "antfly"
+    MOCK = "mock"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/classification_step_config.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.query_strategy import QueryStrategy
+from ..models.semantic_query_mode import SemanticQueryMode
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.chain_link import ChainLink
+    from ..models.generator_config import GeneratorConfig
+
+
+T = TypeVar("T", bound="ClassificationStepConfig")
+
+
+@_attrs_define
+class ClassificationStepConfig:
+    """Configuration for the classification step. This step analyzes the query,
+    selects the optimal retrieval strategy, and generates semantic transformations.
+
+        Attributes:
+            enabled (bool | Unset): Enable query classification and strategy selection Default: False.
+            generator (GeneratorConfig | Unset): A unified configuration for a generative AI provider.
+                 Example: {'provider': 'openai', 'model': 'gpt-4.1', 'temperature': 0.7, 'max_tokens': 2048}.
+            chain (list[ChainLink] | Unset): Chain of generators to try in order. Mutually exclusive with 'generator'.
+            with_reasoning (bool | Unset): Include pre-retrieval reasoning explaining query analysis and strategy selection
+                Default: False.
+            force_strategy (QueryStrategy | Unset): Strategy for query transformation and retrieval:
+                - simple: Direct query with multi-phrase expansion. Best for straightforward factual queries.
+                - decompose: Break complex queries into sub-questions, retrieve for each. Best for multi-part questions.
+                - step_back: Generate broader background query first, then specific query. Best for questions needing context.
+                - hyde: Generate hypothetical answer document, embed that for retrieval. Best for abstract/conceptual questions.
+            force_semantic_mode (SemanticQueryMode | Unset): Mode for semantic query generation:
+                - rewrite: Transform query into expanded keywords/concepts optimized for vector search (Level 2 optimization)
+                - hypothetical: Generate a hypothetical answer that would appear in relevant documents (HyDE - Level 3
+                optimization)
+            multi_phrase_count (int | Unset): Number of alternative query phrasings to generate Default: 3.
+    """
+
+    enabled: bool | Unset = False
+    generator: GeneratorConfig | Unset = UNSET
+    chain: list[ChainLink] | Unset = UNSET
+    with_reasoning: bool | Unset = False
+    force_strategy: QueryStrategy | Unset = UNSET
+    force_semantic_mode: SemanticQueryMode | Unset = UNSET
+    multi_phrase_count: int | Unset = 3
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        enabled = self.enabled
+
+        generator: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.generator, Unset):
+            generator = self.generator.to_dict()
+
+        chain: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.chain, Unset):
+            chain = []
+            for chain_item_data in self.chain:
+                chain_item = chain_item_data.to_dict()
+                chain.append(chain_item)
+
+        with_reasoning = self.with_reasoning
+
+        force_strategy: str | Unset = UNSET
+        if not isinstance(self.force_strategy, Unset):
+            force_strategy = self.force_strategy.value
+
+        force_semantic_mode: str | Unset = UNSET
+        if not isinstance(self.force_semantic_mode, Unset):
+            force_semantic_mode = self.force_semantic_mode.value
+
+        multi_phrase_count = self.multi_phrase_count
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if enabled is not UNSET:
+            field_dict["enabled"] = enabled
+        if generator is not UNSET:
+            field_dict["generator"] = generator
+        if chain is not UNSET:
+            field_dict["chain"] = chain
+        if with_reasoning is not UNSET:
+            field_dict["with_reasoning"] = with_reasoning
+        if force_strategy is not UNSET:
+            field_dict["force_strategy"] = force_strategy
+        if force_semantic_mode is not UNSET:
+            field_dict["force_semantic_mode"] = force_semantic_mode
+        if multi_phrase_count is not UNSET:
+            field_dict["multi_phrase_count"] = multi_phrase_count
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.chain_link import ChainLink
+        from ..models.generator_config import GeneratorConfig
+
+        d = dict(src_dict)
+        enabled = d.pop("enabled", UNSET)
+
+        _generator = d.pop("generator", UNSET)
+        generator: GeneratorConfig | Unset
+        if isinstance(_generator, Unset):
+            generator = UNSET
+        else:
+            generator = GeneratorConfig.from_dict(_generator)
+
+        _chain = d.pop("chain", UNSET)
+        chain: list[ChainLink] | Unset = UNSET
+        if _chain is not UNSET:
+            chain = []
+            for chain_item_data in _chain:
+                chain_item = ChainLink.from_dict(chain_item_data)
+
+                chain.append(chain_item)
+
+        with_reasoning = d.pop("with_reasoning", UNSET)
+
+        _force_strategy = d.pop("force_strategy", UNSET)
+        force_strategy: QueryStrategy | Unset
+        if isinstance(_force_strategy, Unset):
+            force_strategy = UNSET
+        else:
+            force_strategy = QueryStrategy(_force_strategy)
+
+        _force_semantic_mode = d.pop("force_semantic_mode", UNSET)
+        force_semantic_mode: SemanticQueryMode | Unset
+        if isinstance(_force_semantic_mode, Unset):
+            force_semantic_mode = UNSET
+        else:
+            force_semantic_mode = SemanticQueryMode(_force_semantic_mode)
+
+        multi_phrase_count = d.pop("multi_phrase_count", UNSET)
+
+        classification_step_config = cls(
+            enabled=enabled,
+            generator=generator,
+            chain=chain,
+            with_reasoning=with_reasoning,
+            force_strategy=force_strategy,
+            force_semantic_mode=force_semantic_mode,
+            multi_phrase_count=multi_phrase_count,
+        )
+
+        classification_step_config.additional_properties = d
+        return classification_step_config
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties