from azure.ai.projects.operations import ConnectionsOperations
# Methods: ['get', 'get_default', 'list']

ConnectionsOperations.list(
    self,
    *,
    connection_type: Union[str, ConnectionType, None] = None,
    default_connection: Optional[bool] = None,
    **kwargs
) -> ItemPaged['Connection']

ConnectionsOperations.get(
    self,
    name: str,
    *,
    include_credentials: Optional[bool] = False,
    **kwargs
) -> Connection

connections = client.connections.list(
    connection_type=ConnectionType.AZURE_AI_SEARCH
)
for conn in connections:
    print(conn.name, conn.target)  # name and search endpoint

ConnectionType values:
  AZURE_OPEN_AI         = 'AzureOpenAI'
  AZURE_BLOB_STORAGE    = 'AzureBlob'
  AZURE_STORAGE_ACCOUNT = 'AzureStorageAccount'
  AZURE_AI_SEARCH       = 'CognitiveSearch'     # <-- THIS ONE
  COSMOS_DB             = 'CosmosDB'
  API_KEY               = 'ApiKey'
  APPLICATION_CONFIGURATION = 'AppConfig'
  APPLICATION_INSIGHTS  = 'AppInsights'
  CUSTOM                = 'CustomKeys'
  REMOTE_TOOL           = 'RemoteTool_Preview'

from azure.ai.projects.operations import IndexesOperations
# Methods: ['create_or_update', 'delete', 'get', 'list', 'list_versions']

IndexesOperations.list(self, **kwargs) -> ItemPaged['Index']
IndexesOperations.get(self, name: str, version: str, **kwargs) -> Index
IndexesOperations.list_versions(self, name: str, **kwargs) -> ItemPaged['Index']

indexes = client.indexes.list()
for idx in indexes:
    print(idx.name, idx.version, idx.type)

from azure.ai.projects.models import (
    AzureAISearchTool,
    AzureAISearchToolResource,
    AISearchIndexResource,
    AzureAISearchQueryType,
)

tool = AzureAISearchTool(
    azure_ai_search=AzureAISearchToolResource(
        indexes=[
            AISearchIndexResource(
                project_connection_id="<connection-name-or-id>",
                index_name="<index-name>",
                query_type=AzureAISearchQueryType.VECTOR_SEMANTIC_HYBRID,
                top_k=5,
                filter=None,
                index_asset_id=None,
            )
        ]
    )
)

from azure.ai.projects.models import MCPTool

tool = MCPTool(
    server_label="foundry-iq",                    # Required: label for tool calls
    server_url="https://<endpoint>/mcp",           # One of server_url or connector_id
    connector_id=None,                             # Pre-built connector (Dropbox, Gmail, etc.)
    authorization="Bearer <token>",                # OAuth token if needed
    server_description="Foundry IQ knowledge base",
    headers={"x-custom": "value"},                 # Optional headers
    allowed_tools=["search", "retrieve"],           # Filter which tools to expose
    require_approval="never",                      # "always" | "never" | MCPToolRequireApproval
    project_connection_id="<connection-id>",        # Connection storing auth details
)

from azure.ai.projects.models import PromptAgentDefinition

definition = PromptAgentDefinition(
    model="gpt-4o",
    instructions="You are an HCP...",
    tools=[
        AzureAISearchTool(
            azure_ai_search=AzureAISearchToolResource(
                indexes=[
                    AISearchIndexResource(
                        project_connection_id="my-search-connection",
                        index_name="product-knowledge-base",
                        query_type=AzureAISearchQueryType.VECTOR_SEMANTIC_HYBRID,
                        top_k=5,
                    )
                ]
            )
        )
    ],
)

async def create_agent(
    db: AsyncSession,
    name: str,
    instructions: str,
    model: str | None = None,
    *,
    metadata: dict[str, str] | None = None,
    endpoint_override: str = "",
    key_override: str = "",
) -> dict:
    definition = PromptAgentDefinition(model=model, instructions=instructions)
    result = await asyncio.to_thread(
        client.agents.create_version,
        agent_name=agent_name,
        definition=definition,
        description=f"HCP Agent: {name}",
        metadata=metadata,
    )

async def create_agent(
    db, name, instructions, model=None, *,
    metadata=None,
    tools: list | None = None,    # NEW
    endpoint_override="", key_override="",
) -> dict:
    definition = PromptAgentDefinition(
        model=model,
        instructions=instructions,
        tools=tools or [],         # NEW — pass tools list
    )

# Knowledge base configuration
kb_connection_id: Mapped[str] = mapped_column(String(255), default="")
kb_index_name: Mapped[str] = mapped_column(String(255), default="")
kb_query_type: Mapped[str] = mapped_column(String(50), default="vector_semantic_hybrid")
kb_top_k: Mapped[int] = mapped_column(default=5)
kb_enabled: Mapped[bool] = mapped_column(Boolean, default=False)

class HcpKnowledgeConfig(Base, TimestampMixin):
    __tablename__ = "hcp_knowledge_configs"
    hcp_profile_id: FK -> hcp_profiles.id (unique, 1:1)
    connection_id: String(255)   # AI Search connection name
    index_name: String(255)      # Index name
    query_type: String(50)       # AzureAISearchQueryType value
    top_k: int                   # default 5
    filter_expression: Text      # OData filter (optional)
    is_enabled: bool             # default False

async def list_search_connections(db: AsyncSession) -> list[dict]:
    """List Azure AI Search connections from Foundry project."""
    endpoint, key = await get_project_endpoint(db)
    client = _get_project_client(endpoint, key)
    connections = await asyncio.to_thread(
        client.connections.list,
        connection_type=ConnectionType.AZURE_AI_SEARCH,
    )
    return [{"name": c.name, "target": c.target, "is_default": c.is_default} for c in connections]

async def list_indexes(db: AsyncSession) -> list[dict]:
    """List all indexes in the Foundry project."""
    endpoint, key = await get_project_endpoint(db)
    client = _get_project_client(endpoint, key)
    indexes = await asyncio.to_thread(client.indexes.list)
    return [{"name": i.name, "version": i.version, "type": i.type} for i in indexes]

def build_search_tool(connection_id: str, index_name: str, query_type: str, top_k: int):
    """Build AzureAISearchTool from config."""
    return AzureAISearchTool(
        azure_ai_search=AzureAISearchToolResource(
            indexes=[AISearchIndexResource(
                project_connection_id=connection_id,
                index_name=index_name,
                query_type=query_type,
                top_k=top_k,
            )]
        )
    )