ibm-watsonx-orchestrate-mcp-server 1.13.0b0__py3-none-any.whl

.gitignore

@@ -0,0 +1,17 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+uv.lock
+
+*.env
+
+*/.bob/*
+*.DS_STORE*

ibm_watsonx_orchestrate_mcp_server/server.py

@@ -0,0 +1,46 @@
+import logging
+import sys
+import os
+from ibm_watsonx_orchestrate_mcp_server.utils.logging import setup_logging
+from ibm_watsonx_orchestrate_mcp_server.utils.config import config, MCPTransportTypes
+from fastmcp import FastMCP
+from ibm_watsonx_orchestrate_mcp_server.src import __all_tools__
+
+mcp: FastMCP = FastMCP(name=config.server_name)
+
+def _configure_logging() -> logging.Logger:
+    setup_logging(debug=config.debug)
+    return logging.getLogger(config.server_name)
+
+def _load_tools() -> None:
+    for tool in __all_tools__:
+        mcp.tool()(tool)
+
+def start_server() -> None:
+    logger: logging.Logger = _configure_logging()
+
+    if config.working_directory:
+        os.chdir(config.working_directory)
+
+    _load_tools()
+    
+    # Start server
+    logger.debug(f"🚀 Starting {config.server_name} v{config.version}")
+    logger.debug(f"📡 Transport: {config.transport}, Host: {config.host}, Port: {config.port}")
+    
+    try:
+        if config.transport in (MCPTransportTypes.HTTP_STREAMABLE, MCPTransportTypes.SSE):
+            logger.info(f"🌐 Starting HTTP server on {config.host}:{config.port}")
+            mcp.run(transport=config.transport, host=config.host, port=config.port)
+        else:
+            logger.info("📡 Starting STDIO transport")
+            mcp.run()
+            
+    except KeyboardInterrupt:
+        logger.info("🛑 Server interrupted by user")
+    except Exception as e:
+        logger.error(f"💥 Server error: {e}", exc_info=True)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    start_server()

ibm_watsonx_orchestrate_mcp_server/src/__init__.py

@@ -0,0 +1,10 @@
+from .version_checker import check_version
+from .agents.mcp_tools import __tools__ as agent_tools
+from .tools.mcp_tools import __tools__ as tool_tools
+from .toolkits.mcp_tools import __tools__ as toolkit_tools
+from .knowledge_bases.mcp_tools import __tools__ as knowledge_base_tools
+from .connections.mcp_tools import __tools__ as connection_tools
+from .voice_configurations.mcp_tools import __tools__ as voice_configuration_tools
+from .models.mcp_tools import __tools__ as model_tools
+
+__all_tools__ = agent_tools + tool_tools + toolkit_tools + knowledge_base_tools + connection_tools + voice_configuration_tools + model_tools + [check_version]

ibm_watsonx_orchestrate_mcp_server/src/agents/mcp_tools.py

@@ -0,0 +1,162 @@
+from ibm_watsonx_orchestrate.agent_builder.agents import SpecVersion
+from ibm_watsonx_orchestrate.cli.commands.agents.agents_controller import (
+    AgentsController,
+    AgentKind
+)
+from ibm_watsonx_orchestrate.cli.common import ListFormats
+
+from typing_extensions import Optional, List, Literal
+from ibm_watsonx_orchestrate_mcp_server.utils.common import silent_call;
+
+from ibm_watsonx_orchestrate_mcp_server.utils.files.files import get_working_directory_path
+from ibm_watsonx_orchestrate_mcp_server.src.agents.types import ListAgents, CreateAgentOptions, AnyAgent
+
+def __get_existing_agent(name: str, kind: str) -> Optional[AnyAgent]:
+    """
+    Get an existing agent with the given name.
+    """
+    ac: AgentsController = AgentsController()
+    try:
+        agent: Optional[AnyAgent] = silent_call(fn=ac.get_agent, name=name, kind=kind)
+        return agent
+    except:
+        return None
+
+def list_agents(
+    kind: Optional[AgentKind] = None,
+    verbose: bool = False
+) -> ListAgents:
+    """
+    Get a list of all the agents in watsonx Orchestrate (wxo)
+
+    Args:
+        kind (AgentKind, optional): Return only agents of the kind specified. If None is passed then return everything. Allowed values ['native' | 'external' | 'assistant' | None] (default: None)
+        verbose (bool): When set the tool will return the raw agents specifications without resolving ids to names. This should only be done in edge cases as names are more widely used. (default: False)
+    
+    Returns:
+        ListAgents: A class containing lists of native, assistant and external agents.
+    """
+    ac: AgentsController = AgentsController()
+    format: Literal[ListFormats.JSON] | None = ListFormats.JSON if not verbose else None
+    output: ListAgents = silent_call(fn=ac.list_agents, format=format, kind=kind, verbose=verbose)
+
+    return output
+
+def create_or_update_agent(options: CreateAgentOptions) -> AnyAgent:
+    """
+    Create or update an agent based on the provided options.
+    If the agent name already exists, the agent will be updated with the provided options. Else it will create a new agent.
+
+    Args:
+        options (CreateAgentOptions): The options to use when creating the agent.
+    
+    Returns:
+        AnyAgent: The newly created agent.
+    """
+    ac: AgentsController = AgentsController()
+    existing_agents = {
+        AgentKind.NATIVE:  __get_existing_agent(options.name, AgentKind.NATIVE),
+        AgentKind.EXTERNAL: __get_existing_agent(options.name, AgentKind.EXTERNAL),
+        AgentKind.ASSISTANT: __get_existing_agent(options.name, AgentKind.ASSISTANT)
+    }
+    existing_agents_list = [value for value in existing_agents.values() if value is not None]
+
+    existing_agent = None
+    if len(existing_agents_list) == 1:
+        existing_agent = existing_agents_list[0]
+    elif len(existing_agents_list) > 1:
+        raise Exception(f"Multiple agents found with name {options.name} update is ambiguous. Please delete the duplicate and try again.")
+    
+    if not existing_agent:
+        if not options.kind:
+            options.kind = AgentKind.NATIVE
+        agent: AnyAgent = silent_call(fn=ac.generate_agent_spec, **options.model_dump())
+    else:
+        agent = existing_agent.model_copy(update=options.model_dump(exclude_unset=True))
+    silent_call(fn=ac.publish_or_update_agents, agents=[agent])
+    agent.spec_version = SpecVersion.V1
+    return agent
+
+def import_agent(path: str, app_id: Optional[str]) -> List[AnyAgent]:
+    """
+    Import an agent into the watsonx Orchestrate platform using Agent spec files
+
+    Args:
+        path (str): The absolute of relative path to an agent spec file
+        app_id (str | None): An optional app_id which relates an Orchestrate connection object to the Agent. Used for external and assistant Agent authentication.
+    
+    Returns:
+        List[AnyAgent]: The newly created agent.
+    """
+
+    working_directory_path: str = get_working_directory_path(path)
+    ac: AgentsController = AgentsController()
+    agents: List[AnyAgent] = silent_call(ac.import_agent, file=working_directory_path, app_id=app_id)
+    silent_call(fn=ac.publish_or_update_agents, agents=agents)
+    return agents
+
+def remove_agent(name: str, kind: AgentKind) -> str:
+    """
+    Remove an agent from the watsonx Orchestrate platform
+
+    Args:
+        name (str): The name of the agent to remove
+        kind (AgentKind): The kind of agent to remove
+    
+    Returns:
+        str: A message indicating the success of the removal
+    """
+
+    ac: AgentsController = AgentsController()
+    silent_call(fn=ac.remove_agent, name=name, kind=kind)
+
+    return f"The Agent {name} successfully removed"
+
+def export_agent(name: str, kind: AgentKind, output_file_path: str, agent_only_flag: bool = False) -> str:
+    """
+    Export an agent from the watsonx Orchestrate platform.
+    Args:
+        name (str): The name of the agent to export
+        kind (AgentKind): The kind of agent to export
+        output_file_path (str): The path to export the agent to. Should be a zip file with a '.zip' extension unless the agent_only_flag is set in which case it should a yaml file with a '.yaml' extension.
+        agent_only_flag (bool, optional): If set to True, only the agent definition will be exported and not the agent's dependencies. Defaults to False.
+    
+    Returns:
+        str: A message indicating the success of the export
+    """
+    working_directory_output_path: str = get_working_directory_path(output_file_path)
+    ac: AgentsController = AgentsController()
+    silent_call(fn=ac.export_agent, name=name, kind=kind, output_path=working_directory_output_path, agent_only_flag=agent_only_flag)
+    
+    return f"The Agent {name} successfully exported"
+
+def deploy_agent(name: str,) -> str:
+    """
+    Deploys an agent to the watsonx Orchestrate platform. Promoting it from the draft environment to the live environment. The agent must already have been created or imported into the Orchestrate platform.
+
+    Args:
+        name (str): The name of the agent you want to deploy.
+    
+    Returns:
+        str: A message indicating the success of the deployment
+    """
+    ac: AgentsController = AgentsController()
+    silent_call(fn=ac.deploy_agent, name=name)
+
+    return f"The Agent {name} successfully deployed"
+
+def undeploy_agent(name: str,) -> str:
+    """
+    Undeploys an agent from the watsonx Orchestrate platform. Demoting it from the live environment to the draft environment.
+    Args:
+        name (str): The name of the agent you want to undeploy.
+
+    Returns:
+        str: A message indicating the success of the undeployment
+    """
+    ac: AgentsController = AgentsController()
+    silent_call(fn=ac.undeploy_agent, name=name)
+    
+    return f"The Agent {name} successfully undeployed"
+
+__tools__ = [list_agents, create_or_update_agent, import_agent, remove_agent, export_agent]

ibm_watsonx_orchestrate_mcp_server/src/agents/types.py

@@ -0,0 +1,122 @@
+from typing import Any, TypeAlias
+from ibm_watsonx_orchestrate.agent_builder.agents.agent import Agent
+from ibm_watsonx_orchestrate.agent_builder.agents.external_agent import ExternalAgent
+from ibm_watsonx_orchestrate.agent_builder.agents.assistant_agent import AssistantAgent
+from ibm_watsonx_orchestrate.cli.commands.agents.agents_controller import (
+    AgentKind
+)
+from ibm_watsonx_orchestrate.agent_builder.agents.types import (
+    ExternalAgentAuthScheme,
+    AgentProvider,
+    AgentStyle,
+    DEFAULT_LLM
+)
+
+from typing_extensions import Optional, List
+from pydantic import BaseModel, Field
+
+class ListAgents:
+    native: List[dict] = []
+    assistant: List[dict] = []
+    external: List[dict] = []
+
+class ExternalAgentAuthConfig(BaseModel):
+    token: str = Field(
+        description="The apikey, bearer token or client secret required to auth to an external agent"
+    )
+    grant_type: Optional[str] = Field(
+        default=None,
+        description="Used when the provider is Salesforce. Defaults to 'client_credentials' if None is passed"
+    )
+
+class AgentConfig(BaseModel):
+    hidden: bool = Field(
+        default=False,
+        description="Should the agent be hidden in the UI"
+    )
+    enable_cot: bool = Field(
+        default=False,
+        description="Should the agent display chain of thought reasoning"
+    )
+
+class CreateAgentOptions(BaseModel):
+    name: str = Field(
+        description="Name of the agent you wish to create"
+    )
+    description: str = Field(
+        description="Description of the agent you wish to create. Should be descriptive of what capabilites an agent has to assist in routing from a parent agent"
+    )
+    title: Optional[str] = Field(
+        default=None,
+        description="Title of the agent you wish to create. Required for External and Assistant Agents"
+    )
+    kind: Optional[AgentKind] = Field(
+        default=None,
+        description="Kind of agent you wish to create"
+    )
+    instructions: Optional[str] = Field(
+        default=None,
+        description="Used for native agents. Controls the behaviour of the agent. Should include tool calling directions, collaborator routing instructions, output format requirements and any other guidance the agent should follow"
+    )
+    api_url: Optional[str] = Field(
+        default=None,
+        description="Required for External Agents. The API URL of the external agent"
+    )
+    auth_scheme: ExternalAgentAuthScheme = Field(
+        default=ExternalAgentAuthScheme.NONE,
+        description="Used for External Agents to control the auth scheme used when authenticating to the api"
+    )
+    provider: AgentProvider = Field(
+        default=AgentProvider.EXT_CHAT,
+        description="Used for External Agents to control the provider type of the external agent"
+    )
+    auth_config: Optional[ExternalAgentAuthConfig] = Field(
+        default=None,
+        description="Used for External Agents when 'auth_scheme' is not 'None' to pass is secret values like API key, bearer token or client_secret"
+    )
+    tags: Optional[List[str]] = Field(
+        default=None,
+        description="Optional tags that will appear in the UI."
+    )
+    chat_params: Optional[dict[str, Any]] = Field(
+        default=None,
+        description="Chat parameters in JSON format (e.g., '{\"stream\": true}'). Only needed for External and Assistant Agents"
+    )
+    config: Optional[AgentConfig] = Field(
+        default=None,
+        description="Used to configure options on the agent such as if it should appear in the UI or not"
+    )
+    app_id: Optional[str] = Field(
+        default=None,
+        description="The name of a connection that contains authentication secrets. Used for external and assistant agents only"
+    )
+    llm: str = Field(
+        default=DEFAULT_LLM,
+        description="The LLM model to use for this agent. If not specified, the default will be used. The value provided must be a model in the watsonx Orchestrate platform"
+    )
+    style: AgentStyle = Field(
+        default=AgentStyle.DEFAULT,
+        description="The style of the agent. This is used to control the behavior of the agent. Only used for native agents"
+    )
+    custom_join_tool: Optional[str] = Field(
+        default=None,
+        description="Used only when style is 'planner'. The name of the custom join tool to use for this agent. Only used for native agents"
+    )
+    structured_output: Optional[dict] = Field(
+        default=None,
+        description="Used only when style is 'planner'. A JSON Schema object that defines the desired structure of the agent\'s final output. Only used for native agents"
+    )
+    collaborators: Optional[List[str]] = Field(
+        default=None,
+        description="The names of agents that this agent should be able to call as collaborators. Only used for native agents"
+    )
+    tools: Optional[List[str]] = Field(
+        default=None,
+        description="The names of tools that this agent should be able to call. Only used for native agents"
+    )
+    knowledge_base: Optional[List[str]] = Field(
+        default=None,
+        description="The names of knowledge bases that this agent should be able to access. Only used for native agents"
+    )
+
+AnyAgent: TypeAlias = Agent | ExternalAgent | AssistantAgent

ibm_watsonx_orchestrate_mcp_server/src/connections/helpers.py

@@ -0,0 +1,31 @@
+from typing import Optional, List
+from ibm_watsonx_orchestrate.client.connections.connections_client import ConnectionsClient, ListConfigsResponse
+from ibm_watsonx_orchestrate.client.connections.utils import get_connections_client
+from ibm_watsonx_orchestrate_mcp_server.utils.common import silent_call
+
+class ConnectionsHelper:
+    def __init__(self, connnections_client: Optional[ConnectionsClient] = None):
+        self.connections_client: ConnectionsClient | None = connnections_client
+    
+    def __get_connections_client(self) -> ConnectionsClient:
+        if self.connections_client:
+            return self.connections_client
+        else:
+            return silent_call(fn=get_connections_client)
+    
+    def get_connection_by_id(self, connection_id: str) -> ListConfigsResponse | None:
+        connections_client: ConnectionsClient = self.__get_connections_client()
+
+        connections: List[ListConfigsResponse]= silent_call(fn=connections_client.get_drafts_by_ids, conn_ids=[connection_id])
+
+        if len(connections) == 0:
+            return None
+        if len(connections) > 1:
+            raise Exception(f"Multiple connections found with id '{connection_id}'.")
+        return connections[0]
+
+    def get_app_id_by_connection_id(self, connection_id: str) -> str | None:
+        connection: ListConfigsResponse | None = self.get_connection_by_id(connection_id)
+        if not connection:
+            return None
+        return connection.app_id

ibm_watsonx_orchestrate_mcp_server/src/connections/mcp_tools.py

@@ -0,0 +1,149 @@
+
+from typing import Any, Literal, List
+
+from ibm_watsonx_orchestrate.cli.commands.connections import connections_controller
+from ibm_watsonx_orchestrate.agent_builder.connections.types import ConnectionsListResponse
+from ibm_watsonx_orchestrate.cli.common import ListFormats
+from ibm_watsonx_orchestrate_mcp_server.utils.common import silent_call
+from ibm_watsonx_orchestrate_mcp_server.utils.files.files import get_working_directory_path
+from ibm_watsonx_orchestrate_mcp_server.src.connections.types import ConfigureConnectionsOptions, SetCredentialsConnectionOptions, SetIdentityProviderOptions
+
+
+def list_connections(verbose: bool=False) -> ConnectionsListResponse | List[dict[str, Any]]:
+    """
+    Lists the avalible connections available on the watsonx Orchestrate platform.
+
+    Args:
+        verbose (bool): If True then the connections will be returned in a verbose format. Defaults to False.
+    
+    Returns:
+        dict[str, Any]: A dictionary containing the connections.
+    """
+
+    format: Literal[ListFormats.JSON] | None = ListFormats.JSON if not verbose else None
+    connections: ConnectionsListResponse | List[dict] = silent_call(fn=connections_controller.list_connections, environment=None, verbose=verbose, format=format)
+    return connections
+
+def create_connection(app_id: str) -> str:
+    """
+    Creates a connection in the watsonx Orchestrate platform.
+
+    Args:
+        app_id (str): An arbitrary string that will be used to identify the connection.
+
+    Returns:
+        str: A success message indicating the connection was created successfully.
+    """
+
+    silent_call(fn=connections_controller.add_connection, app_id=app_id)
+    return f"Connection '{app_id}' created successfully."
+
+def remove_connection(app_id: str) -> str:
+    """
+    Removes a connection from the watsonx Orchestrate platform. 
+
+    Args:
+        app_id (str): The app id of the connection to remove.
+
+    Returns:
+        str: A success message indicating the connection was removed successfully.
+    """
+    silent_call(fn=connections_controller.remove_connection, app_id=app_id)
+    return f"Connection '{app_id}' removed successfully."
+
+def import_connection(file_path: str) -> str:
+    """
+    Imports connections from a spec file into the watsonx Orchestrate platform.
+
+    Args:
+        file_path (str): The path to the connections spec file.
+
+    Returns:
+        str: A success message indicating the connections were imported successfully.
+    """
+    working_directory_file_path: str = get_working_directory_path(file_path)
+    silent_call(fn=connections_controller.import_connection, file=working_directory_file_path)
+    return f"Connection imported successfully from '{file_path}'."
+
+def configure_connection(options: ConfigureConnectionsOptions) -> str:
+    """
+    Configures a connection for a certain environment in the watsonx Orchestrate platform.
+
+    Args:
+        options (ConfigureConnectionsOptions): The options for configuring the connection.
+
+    Returns:
+        str: A success message indicating the connection was configured successfully.
+    """
+    silent_call(
+        fn=connections_controller.configure_connection,
+        app_id=options.app_id,
+        environment=options.environment,
+        type=options.type,
+        kind=options.kind,
+        server_url=options.server_url,
+        sso=options.sso,
+        idp_token_use=options.idp_token_use,
+        idp_token_type=options.idp_token_type,
+        idp_token_header=options.idp_token_header,
+        app_token_header=options.app_token_header,
+    )
+    return f"Connection '{options.app_id}' configured successfully."
+
+def set_credentials_connection(options: SetCredentialsConnectionOptions) -> str:
+    """
+    Sets the credentials for a connection in the watsonx Orchestrate platform.
+    Args:
+        options (SetCredentialsConnectionOptions): The options for setting the credentials for the connection.
+    Returns:
+        str: A success message indicating the credentials were correctly set.
+    """
+    scope: str | None = " ".join(options.scope) if options.scope else None
+    entries: List[str] | None = [f"{k}={v}" for k, v in options.entries.items()] if options.entries else None
+
+    silent_call(
+        fn=connections_controller.set_credentials_connection,
+        app_id=options.app_id,
+        environment=options.environment,
+        username=options.username,
+        password=options.password,
+        token=options.token,
+        api_key=options.api_key,
+        client_id=options.client_id,
+        client_secret=options.client_secret,
+        send_via=options.send_via,
+        token_url=options.token_url,
+        auth_url=options.auth_url,
+        grant_type=options.grant_type,
+        scope=scope,
+        entries=entries,
+        token_entries=options.token_entries,
+        auth_entries=options.auth_entries
+    )
+    return f"Credentials set for connection '{options.app_id}'"
+
+def set_identity_provider(options: SetIdentityProviderOptions) -> str:
+    """
+    Set the identity provider for a connection for sso enabled auth flow.
+
+    Args:
+        options (SetIdentityProviderOptions): The options for setting an identity provider for a connection
+    
+    Returns:
+        str: A success message indicating the identity provider was correctly set.
+    """
+    silent_call(
+        fn=connections_controller.set_identity_provider_connection,
+        app_id=options.app_id,
+        environment=options.environment,
+        url=options.url,
+        client_id=options.client_id,
+        client_secret=options.client_secret,
+        scope=options.scope,
+        grant_type=options.grant_type,
+        token_entries=options.token_entries
+    )
+
+    return f"Identity Provider set for connection '{options.app_id}'"
+
+__tools__ = [list_connections, create_connection, remove_connection, import_connection, configure_connection, set_credentials_connection, set_identity_provider]

ibm_watsonx_orchestrate_mcp_server/src/connections/types.py

@@ -0,0 +1,113 @@
+from ibm_watsonx_orchestrate.agent_builder.connections import ConnectionEnvironment, ConnectionKind, ConnectionPreference
+from ibm_watsonx_orchestrate.agent_builder.connections.types import ConnectionSendVia, ConnectionCredentialsEntry
+from pydantic import BaseModel, Field
+from typing import Optional, List
+
+class BaseConnectionOptions(BaseModel):
+    app_id: str = Field(
+        description="The app id of the connection to configure"
+    )
+    environment: ConnectionEnvironment = Field(
+        description="The environemnt you wish to configre the connection for."
+    )
+
+class ConfigureConnectionsOptions(BaseConnectionOptions):
+    type: ConnectionPreference = Field(
+        description="The type of connection you wish to configure. Setting type to 'team' will mean the connection's credentials are shared by all users. Setting 'member' will require each user to provide their own credentials for the connection"
+    )
+    kind: ConnectionKind = Field(
+        description="The kind of connection you wish to configure."
+    )
+    server_url: Optional[str]=Field(
+        default=None,
+        description="The url the connections credentials will be used against."
+    )
+    sso: bool = Field(
+        default=False,
+        description="If true, the connection will be configured to use single sign on. Only supported when kind is 'oauth_auth_on_behalf_of_flow' and is required to be true in that case"
+    )
+    idp_token_use: Optional[str] = Field(
+        default=None,
+        description="The token use used by the identity provider when using single sign on. Only supported when sso is true"
+    )
+    idp_token_type: Optional[str] = Field(
+        default=None,
+        description="The token type used by the identity provider when using single sign on. Only supported when sso is true"
+    )
+    idp_token_header: Optional[List[str]] = Field(
+        default=None,
+        description="Header values for the identity provider token request. Defaults to using 'content-type: application/x-www-form-urlencoded'. Formatted as <header_key>: <header_value>. Only supported when sso is true"
+    )
+    app_token_header: Optional[List[str]] = Field(
+        default=None,
+        description="Header values for the application token request. Defaults to using 'content-type: application/x-www-form-urlencoded'. Formatted as <header_key>: <header_value>. Only supported when sso is true"
+    )
+
+class SetCredentialsConnectionOptions(BaseConnectionOptions):
+    username: Optional[str] = Field(
+        default=None,
+        description="The username to login with. Required when connection kind is 'basic' or 'oauth_auth_password_flow'"
+    )
+    password: Optional[str] = Field(
+        default=None,
+        description="The password to login with. Required when connection kind is 'basic' or 'oauth_auth_password_flow'"
+    )
+    token: Optional[str] = Field(
+        default=None,
+        description="The bearer token to login with. Required when connection kind is 'bearer'"
+    )
+    api_key: Optional[str] = Field(
+        default=None,
+        description="The api key to login with. Required when connection kind is 'api_key'"
+    )
+    client_id: Optional[str] = Field(
+        default=None,
+        description="The client id for the OAuth request. Required when connection kind is 'oauth_auth_code_flow', 'oauth_auth_client_credentials_flow', 'oauth_auth_password_flow' or 'oauth_auth_on_behalf_of_flow'"
+    )
+    client_secret: Optional[str] = Field(
+        default=None,
+        description="The client secret for the OAuth request. Required when connection kind is 'oauth_auth_code_flow', 'oauth_auth_client_credentials_flow' or 'oauth_auth_password_flow'"
+    )
+    send_via: Optional[ConnectionSendVia] = Field(
+        default=None,
+        description="The location where the token will be sent during the OAuth handshake. Used when connection kind is 'oauth_auth_client_credentials_flow'. Defaults to 'header'."
+    )
+    token_url: Optional[str] = Field(
+        default=None,
+        description="The url to request the token from. Required when connection kind is 'oauth_auth_code_flow', 'oauth_auth_client_credentials_flow', 'oauth_auth_password_flow' or 'oauth_auth_on_behalf_of_flow'"
+    )
+    auth_url: Optional[str] = Field(
+        default=None,
+        description="The url to request the authorization from. Required when connection kind is 'oauth_auth_code_flow'"
+    )
+    grant_type: Optional[str] = Field(
+        default=None,
+        description="The grant type of the token requested for the token server. Required when connections kind is 'oauth_auth_on_behalf_of_flow'. Defaults for 'oauth_auth_client_credentials_flow' to 'client_credentials' and for 'oauth_auth_password_flow' it defaults to 'password'"
+    )
+    scope: Optional[List[str]] = Field(
+        default=None,
+        description="An optional set of scopes. Used for 'oauth_auth_code_flow', 'oauth_auth_client_credentials_flow' and 'oauth_auth_password_flow'"
+    )
+    entries: Optional[dict] = Field(
+        default=None,
+        description="A dictionary containing arbitrary key value pairs to be used in the key_value connection. Required when kind is  'key_value'"
+    )
+    token_entries: Optional[List[ConnectionCredentialsEntry]] = Field(
+        default=None,
+        description="A list of optional custom fields to be passed with OAuth token requests. Supported when connection kind is 'oauth_auth_code_flow', 'oauth_auth_client_credentials_flow', 'oauth_auth_password_flow' or 'oauth_auth_on_behalf_of_flow'"
+    )
+    auth_entries: Optional[List[ConnectionCredentialsEntry]] = Field(
+        default=None,
+        description="A list of optional custom fields to be passed with OAuth authorization requests. Supported when connection kind is 'oauth_auth_code_flow'. Location must be 'query'."
+    )
+
+class SetIdentityProviderOptions(BaseConnectionOptions):
+    url: str = Field(description="The URL of the identity provider service")
+    client_id: str = Field(description="The client id used to authenticate with the identity provider")
+    client_secret: str = Field(description="The client secret used to authenticate with the identity provider")
+    scope: str = Field(description="The scope used to authenticate with the identity provider")
+    grant_type: str = Field(description="The grant type requested from the identity provider")
+    token_entries: Optional[List[ConnectionCredentialsEntry]] = Field(
+        default=None,
+        description="A list of optional custom fields to be passed with OAuth token requests. Supported when connection kind is 'oauth_auth_code_flow', 'oauth_auth_client_credentials_flow', 'oauth_auth_password_flow' or 'oauth_auth_on_behalf_of_flow'"
+    )