# coding=utf-8
# *** WARNING: this file was generated by pulumi-language-python. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import builtins as _builtins
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from . import _utilities
from . import outputs
from ._inputs import *

__all__ = [
    'GetGenaiAgentResult',
    'AwaitableGetGenaiAgentResult',
    'get_genai_agent',
    'get_genai_agent_output',
]

@pulumi.output_type
class GetGenaiAgentResult:
    """
    A collection of values returned by getGenaiAgent.
    """
    def __init__(__self__, agent_guardrails=None, agent_id=None, anthropic_api_keys=None, api_key_infos=None, api_keys=None, chatbot_identifiers=None, chatbots=None, child_agents=None, created_at=None, deployments=None, description=None, functions=None, id=None, if_case=None, instruction=None, k=None, knowledge_bases=None, max_tokens=None, model_uuid=None, models=None, name=None, open_ai_api_keys=None, parent_agents=None, project_id=None, region=None, retrieval_method=None, route_created_at=None, route_created_by=None, route_name=None, route_uuid=None, tags=None, temperature=None, templates=None, top_p=None, updated_at=None, url=None, user_id=None):
        if agent_guardrails and not isinstance(agent_guardrails, list):
            raise TypeError("Expected argument 'agent_guardrails' to be a list")
        pulumi.set(__self__, "agent_guardrails", agent_guardrails)
        if agent_id and not isinstance(agent_id, str):
            raise TypeError("Expected argument 'agent_id' to be a str")
        pulumi.set(__self__, "agent_id", agent_id)
        if anthropic_api_keys and not isinstance(anthropic_api_keys, list):
            raise TypeError("Expected argument 'anthropic_api_keys' to be a list")
        pulumi.set(__self__, "anthropic_api_keys", anthropic_api_keys)
        if api_key_infos and not isinstance(api_key_infos, list):
            raise TypeError("Expected argument 'api_key_infos' to be a list")
        pulumi.set(__self__, "api_key_infos", api_key_infos)
        if api_keys and not isinstance(api_keys, list):
            raise TypeError("Expected argument 'api_keys' to be a list")
        pulumi.set(__self__, "api_keys", api_keys)
        if chatbot_identifiers and not isinstance(chatbot_identifiers, list):
            raise TypeError("Expected argument 'chatbot_identifiers' to be a list")
        pulumi.set(__self__, "chatbot_identifiers", chatbot_identifiers)
        if chatbots and not isinstance(chatbots, list):
            raise TypeError("Expected argument 'chatbots' to be a list")
        pulumi.set(__self__, "chatbots", chatbots)
        if child_agents and not isinstance(child_agents, list):
            raise TypeError("Expected argument 'child_agents' to be a list")
        pulumi.set(__self__, "child_agents", child_agents)
        if created_at and not isinstance(created_at, str):
            raise TypeError("Expected argument 'created_at' to be a str")
        pulumi.set(__self__, "created_at", created_at)
        if deployments and not isinstance(deployments, list):
            raise TypeError("Expected argument 'deployments' to be a list")
        pulumi.set(__self__, "deployments", deployments)
        if description and not isinstance(description, str):
            raise TypeError("Expected argument 'description' to be a str")
        pulumi.set(__self__, "description", description)
        if functions and not isinstance(functions, list):
            raise TypeError("Expected argument 'functions' to be a list")
        pulumi.set(__self__, "functions", functions)
        if id and not isinstance(id, str):
            raise TypeError("Expected argument 'id' to be a str")
        pulumi.set(__self__, "id", id)
        if if_case and not isinstance(if_case, str):
            raise TypeError("Expected argument 'if_case' to be a str")
        pulumi.set(__self__, "if_case", if_case)
        if instruction and not isinstance(instruction, str):
            raise TypeError("Expected argument 'instruction' to be a str")
        pulumi.set(__self__, "instruction", instruction)
        if k and not isinstance(k, int):
            raise TypeError("Expected argument 'k' to be a int")
        pulumi.set(__self__, "k", k)
        if knowledge_bases and not isinstance(knowledge_bases, list):
            raise TypeError("Expected argument 'knowledge_bases' to be a list")
        pulumi.set(__self__, "knowledge_bases", knowledge_bases)
        if max_tokens and not isinstance(max_tokens, int):
            raise TypeError("Expected argument 'max_tokens' to be a int")
        pulumi.set(__self__, "max_tokens", max_tokens)
        if model_uuid and not isinstance(model_uuid, str):
            raise TypeError("Expected argument 'model_uuid' to be a str")
        pulumi.set(__self__, "model_uuid", model_uuid)
        if models and not isinstance(models, list):
            raise TypeError("Expected argument 'models' to be a list")
        pulumi.set(__self__, "models", models)
        if name and not isinstance(name, str):
            raise TypeError("Expected argument 'name' to be a str")
        pulumi.set(__self__, "name", name)
        if open_ai_api_keys and not isinstance(open_ai_api_keys, list):
            raise TypeError("Expected argument 'open_ai_api_keys' to be a list")
        pulumi.set(__self__, "open_ai_api_keys", open_ai_api_keys)
        if parent_agents and not isinstance(parent_agents, list):
            raise TypeError("Expected argument 'parent_agents' to be a list")
        pulumi.set(__self__, "parent_agents", parent_agents)
        if project_id and not isinstance(project_id, str):
            raise TypeError("Expected argument 'project_id' to be a str")
        pulumi.set(__self__, "project_id", project_id)
        if region and not isinstance(region, str):
            raise TypeError("Expected argument 'region' to be a str")
        pulumi.set(__self__, "region", region)
        if retrieval_method and not isinstance(retrieval_method, str):
            raise TypeError("Expected argument 'retrieval_method' to be a str")
        pulumi.set(__self__, "retrieval_method", retrieval_method)
        if route_created_at and not isinstance(route_created_at, str):
            raise TypeError("Expected argument 'route_created_at' to be a str")
        pulumi.set(__self__, "route_created_at", route_created_at)
        if route_created_by and not isinstance(route_created_by, str):
            raise TypeError("Expected argument 'route_created_by' to be a str")
        pulumi.set(__self__, "route_created_by", route_created_by)
        if route_name and not isinstance(route_name, str):
            raise TypeError("Expected argument 'route_name' to be a str")
        pulumi.set(__self__, "route_name", route_name)
        if route_uuid and not isinstance(route_uuid, str):
            raise TypeError("Expected argument 'route_uuid' to be a str")
        pulumi.set(__self__, "route_uuid", route_uuid)
        if tags and not isinstance(tags, list):
            raise TypeError("Expected argument 'tags' to be a list")
        pulumi.set(__self__, "tags", tags)
        if temperature and not isinstance(temperature, float):
            raise TypeError("Expected argument 'temperature' to be a float")
        pulumi.set(__self__, "temperature", temperature)
        if templates and not isinstance(templates, list):
            raise TypeError("Expected argument 'templates' to be a list")
        pulumi.set(__self__, "templates", templates)
        if top_p and not isinstance(top_p, float):
            raise TypeError("Expected argument 'top_p' to be a float")
        pulumi.set(__self__, "top_p", top_p)
        if updated_at and not isinstance(updated_at, str):
            raise TypeError("Expected argument 'updated_at' to be a str")
        pulumi.set(__self__, "updated_at", updated_at)
        if url and not isinstance(url, str):
            raise TypeError("Expected argument 'url' to be a str")
        pulumi.set(__self__, "url", url)
        if user_id and not isinstance(user_id, str):
            raise TypeError("Expected argument 'user_id' to be a str")
        pulumi.set(__self__, "user_id", user_id)

    @_builtins.property
    @pulumi.getter(name="agentGuardrails")
    def agent_guardrails(self) -> Optional[Sequence['outputs.GetGenaiAgentAgentGuardrailResult']]:
        return pulumi.get(self, "agent_guardrails")

    @_builtins.property
    @pulumi.getter(name="agentId")
    def agent_id(self) -> _builtins.str:
        return pulumi.get(self, "agent_id")

    @_builtins.property
    @pulumi.getter(name="anthropicApiKeys")
    def anthropic_api_keys(self) -> Optional[Sequence['outputs.GetGenaiAgentAnthropicApiKeyResult']]:
        return pulumi.get(self, "anthropic_api_keys")

    @_builtins.property
    @pulumi.getter(name="apiKeyInfos")
    def api_key_infos(self) -> Optional[Sequence['outputs.GetGenaiAgentApiKeyInfoResult']]:
        return pulumi.get(self, "api_key_infos")

    @_builtins.property
    @pulumi.getter(name="apiKeys")
    def api_keys(self) -> Optional[Sequence['outputs.GetGenaiAgentApiKeyResult']]:
        return pulumi.get(self, "api_keys")

    @_builtins.property
    @pulumi.getter(name="chatbotIdentifiers")
    def chatbot_identifiers(self) -> Optional[Sequence['outputs.GetGenaiAgentChatbotIdentifierResult']]:
        return pulumi.get(self, "chatbot_identifiers")

    @_builtins.property
    @pulumi.getter
    def chatbots(self) -> Optional[Sequence['outputs.GetGenaiAgentChatbotResult']]:
        return pulumi.get(self, "chatbots")

    @_builtins.property
    @pulumi.getter(name="childAgents")
    def child_agents(self) -> Sequence['outputs.GetGenaiAgentChildAgentResult']:
        return pulumi.get(self, "child_agents")

    @_builtins.property
    @pulumi.getter(name="createdAt")
    def created_at(self) -> _builtins.str:
        return pulumi.get(self, "created_at")

    @_builtins.property
    @pulumi.getter
    def deployments(self) -> Optional[Sequence['outputs.GetGenaiAgentDeploymentResult']]:
        return pulumi.get(self, "deployments")

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[_builtins.str]:
        return pulumi.get(self, "description")

    @_builtins.property
    @pulumi.getter
    def functions(self) -> Optional[Sequence['outputs.GetGenaiAgentFunctionResult']]:
        return pulumi.get(self, "functions")

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.str:
        """
        The provider-assigned unique ID for this managed resource.
        """
        return pulumi.get(self, "id")

    @_builtins.property
    @pulumi.getter(name="ifCase")
    def if_case(self) -> Optional[_builtins.str]:
        return pulumi.get(self, "if_case")

    @_builtins.property
    @pulumi.getter
    def instruction(self) -> _builtins.str:
        return pulumi.get(self, "instruction")

    @_builtins.property
    @pulumi.getter
    def k(self) -> Optional[_builtins.int]:
        return pulumi.get(self, "k")

    @_builtins.property
    @pulumi.getter(name="knowledgeBases")
    def knowledge_bases(self) -> Optional[Sequence['outputs.GetGenaiAgentKnowledgeBaseResult']]:
        return pulumi.get(self, "knowledge_bases")

    @_builtins.property
    @pulumi.getter(name="maxTokens")
    def max_tokens(self) -> Optional[_builtins.int]:
        return pulumi.get(self, "max_tokens")

    @_builtins.property
    @pulumi.getter(name="modelUuid")
    def model_uuid(self) -> _builtins.str:
        return pulumi.get(self, "model_uuid")

    @_builtins.property
    @pulumi.getter
    def models(self) -> Sequence['outputs.GetGenaiAgentModelResult']:
        return pulumi.get(self, "models")

    @_builtins.property
    @pulumi.getter
    def name(self) -> _builtins.str:
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter(name="openAiApiKeys")
    def open_ai_api_keys(self) -> Optional[Sequence['outputs.GetGenaiAgentOpenAiApiKeyResult']]:
        return pulumi.get(self, "open_ai_api_keys")

    @_builtins.property
    @pulumi.getter(name="parentAgents")
    def parent_agents(self) -> Sequence['outputs.GetGenaiAgentParentAgentResult']:
        return pulumi.get(self, "parent_agents")

    @_builtins.property
    @pulumi.getter(name="projectId")
    def project_id(self) -> _builtins.str:
        return pulumi.get(self, "project_id")

    @_builtins.property
    @pulumi.getter
    def region(self) -> _builtins.str:
        return pulumi.get(self, "region")

    @_builtins.property
    @pulumi.getter(name="retrievalMethod")
    def retrieval_method(self) -> Optional[_builtins.str]:
        return pulumi.get(self, "retrieval_method")

    @_builtins.property
    @pulumi.getter(name="routeCreatedAt")
    def route_created_at(self) -> _builtins.str:
        return pulumi.get(self, "route_created_at")

    @_builtins.property
    @pulumi.getter(name="routeCreatedBy")
    def route_created_by(self) -> Optional[_builtins.str]:
        return pulumi.get(self, "route_created_by")

    @_builtins.property
    @pulumi.getter(name="routeName")
    def route_name(self) -> Optional[_builtins.str]:
        return pulumi.get(self, "route_name")

    @_builtins.property
    @pulumi.getter(name="routeUuid")
    def route_uuid(self) -> Optional[_builtins.str]:
        return pulumi.get(self, "route_uuid")

    @_builtins.property
    @pulumi.getter
    def tags(self) -> Optional[Sequence[_builtins.str]]:
        return pulumi.get(self, "tags")

    @_builtins.property
    @pulumi.getter
    def temperature(self) -> Optional[_builtins.float]:
        return pulumi.get(self, "temperature")

    @_builtins.property
    @pulumi.getter
    def templates(self) -> Optional[Sequence['outputs.GetGenaiAgentTemplateResult']]:
        return pulumi.get(self, "templates")

    @_builtins.property
    @pulumi.getter(name="topP")
    def top_p(self) -> Optional[_builtins.float]:
        return pulumi.get(self, "top_p")

    @_builtins.property
    @pulumi.getter(name="updatedAt")
    def updated_at(self) -> _builtins.str:
        return pulumi.get(self, "updated_at")

    @_builtins.property
    @pulumi.getter
    def url(self) -> Optional[_builtins.str]:
        return pulumi.get(self, "url")

    @_builtins.property
    @pulumi.getter(name="userId")
    def user_id(self) -> Optional[_builtins.str]:
        return pulumi.get(self, "user_id")


class AwaitableGetGenaiAgentResult(GetGenaiAgentResult):
    # pylint: disable=using-constant-test
    def __await__(self):
        if False:
            yield self
        return GetGenaiAgentResult(
            agent_guardrails=self.agent_guardrails,
            agent_id=self.agent_id,
            anthropic_api_keys=self.anthropic_api_keys,
            api_key_infos=self.api_key_infos,
            api_keys=self.api_keys,
            chatbot_identifiers=self.chatbot_identifiers,
            chatbots=self.chatbots,
            child_agents=self.child_agents,
            created_at=self.created_at,
            deployments=self.deployments,
            description=self.description,
            functions=self.functions,
            id=self.id,
            if_case=self.if_case,
            instruction=self.instruction,
            k=self.k,
            knowledge_bases=self.knowledge_bases,
            max_tokens=self.max_tokens,
            model_uuid=self.model_uuid,
            models=self.models,
            name=self.name,
            open_ai_api_keys=self.open_ai_api_keys,
            parent_agents=self.parent_agents,
            project_id=self.project_id,
            region=self.region,
            retrieval_method=self.retrieval_method,
            route_created_at=self.route_created_at,
            route_created_by=self.route_created_by,
            route_name=self.route_name,
            route_uuid=self.route_uuid,
            tags=self.tags,
            temperature=self.temperature,
            templates=self.templates,
            top_p=self.top_p,
            updated_at=self.updated_at,
            url=self.url,
            user_id=self.user_id)


def get_genai_agent(agent_guardrails: Optional[Sequence[Union['GetGenaiAgentAgentGuardrailArgs', 'GetGenaiAgentAgentGuardrailArgsDict']]] = None,
                    agent_id: Optional[_builtins.str] = None,
                    anthropic_api_keys: Optional[Sequence[Union['GetGenaiAgentAnthropicApiKeyArgs', 'GetGenaiAgentAnthropicApiKeyArgsDict']]] = None,
                    api_key_infos: Optional[Sequence[Union['GetGenaiAgentApiKeyInfoArgs', 'GetGenaiAgentApiKeyInfoArgsDict']]] = None,
                    api_keys: Optional[Sequence[Union['GetGenaiAgentApiKeyArgs', 'GetGenaiAgentApiKeyArgsDict']]] = None,
                    chatbot_identifiers: Optional[Sequence[Union['GetGenaiAgentChatbotIdentifierArgs', 'GetGenaiAgentChatbotIdentifierArgsDict']]] = None,
                    chatbots: Optional[Sequence[Union['GetGenaiAgentChatbotArgs', 'GetGenaiAgentChatbotArgsDict']]] = None,
                    deployments: Optional[Sequence[Union['GetGenaiAgentDeploymentArgs', 'GetGenaiAgentDeploymentArgsDict']]] = None,
                    description: Optional[_builtins.str] = None,
                    functions: Optional[Sequence[Union['GetGenaiAgentFunctionArgs', 'GetGenaiAgentFunctionArgsDict']]] = None,
                    if_case: Optional[_builtins.str] = None,
                    k: Optional[_builtins.int] = None,
                    knowledge_bases: Optional[Sequence[Union['GetGenaiAgentKnowledgeBaseArgs', 'GetGenaiAgentKnowledgeBaseArgsDict']]] = None,
                    max_tokens: Optional[_builtins.int] = None,
                    models: Optional[Sequence[Union['GetGenaiAgentModelArgs', 'GetGenaiAgentModelArgsDict']]] = None,
                    open_ai_api_keys: Optional[Sequence[Union['GetGenaiAgentOpenAiApiKeyArgs', 'GetGenaiAgentOpenAiApiKeyArgsDict']]] = None,
                    retrieval_method: Optional[_builtins.str] = None,
                    route_created_by: Optional[_builtins.str] = None,
                    route_name: Optional[_builtins.str] = None,
                    route_uuid: Optional[_builtins.str] = None,
                    tags: Optional[Sequence[_builtins.str]] = None,
                    temperature: Optional[_builtins.float] = None,
                    templates: Optional[Sequence[Union['GetGenaiAgentTemplateArgs', 'GetGenaiAgentTemplateArgsDict']]] = None,
                    top_p: Optional[_builtins.float] = None,
                    url: Optional[_builtins.str] = None,
                    user_id: Optional[_builtins.str] = None,
                    opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetGenaiAgentResult:
    """
    Use this data source to access information about an existing resource.
    """
    __args__ = dict()
    __args__['agentGuardrails'] = agent_guardrails
    __args__['agentId'] = agent_id
    __args__['anthropicApiKeys'] = anthropic_api_keys
    __args__['apiKeyInfos'] = api_key_infos
    __args__['apiKeys'] = api_keys
    __args__['chatbotIdentifiers'] = chatbot_identifiers
    __args__['chatbots'] = chatbots
    __args__['deployments'] = deployments
    __args__['description'] = description
    __args__['functions'] = functions
    __args__['ifCase'] = if_case
    __args__['k'] = k
    __args__['knowledgeBases'] = knowledge_bases
    __args__['maxTokens'] = max_tokens
    __args__['models'] = models
    __args__['openAiApiKeys'] = open_ai_api_keys
    __args__['retrievalMethod'] = retrieval_method
    __args__['routeCreatedBy'] = route_created_by
    __args__['routeName'] = route_name
    __args__['routeUuid'] = route_uuid
    __args__['tags'] = tags
    __args__['temperature'] = temperature
    __args__['templates'] = templates
    __args__['topP'] = top_p
    __args__['url'] = url
    __args__['userId'] = user_id
    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
    __ret__ = pulumi.runtime.invoke('digitalocean:index/getGenaiAgent:getGenaiAgent', __args__, opts=opts, typ=GetGenaiAgentResult).value

    return AwaitableGetGenaiAgentResult(
        agent_guardrails=pulumi.get(__ret__, 'agent_guardrails'),
        agent_id=pulumi.get(__ret__, 'agent_id'),
        anthropic_api_keys=pulumi.get(__ret__, 'anthropic_api_keys'),
        api_key_infos=pulumi.get(__ret__, 'api_key_infos'),
        api_keys=pulumi.get(__ret__, 'api_keys'),
        chatbot_identifiers=pulumi.get(__ret__, 'chatbot_identifiers'),
        chatbots=pulumi.get(__ret__, 'chatbots'),
        child_agents=pulumi.get(__ret__, 'child_agents'),
        created_at=pulumi.get(__ret__, 'created_at'),
        deployments=pulumi.get(__ret__, 'deployments'),
        description=pulumi.get(__ret__, 'description'),
        functions=pulumi.get(__ret__, 'functions'),
        id=pulumi.get(__ret__, 'id'),
        if_case=pulumi.get(__ret__, 'if_case'),
        instruction=pulumi.get(__ret__, 'instruction'),
        k=pulumi.get(__ret__, 'k'),
        knowledge_bases=pulumi.get(__ret__, 'knowledge_bases'),
        max_tokens=pulumi.get(__ret__, 'max_tokens'),
        model_uuid=pulumi.get(__ret__, 'model_uuid'),
        models=pulumi.get(__ret__, 'models'),
        name=pulumi.get(__ret__, 'name'),
        open_ai_api_keys=pulumi.get(__ret__, 'open_ai_api_keys'),
        parent_agents=pulumi.get(__ret__, 'parent_agents'),
        project_id=pulumi.get(__ret__, 'project_id'),
        region=pulumi.get(__ret__, 'region'),
        retrieval_method=pulumi.get(__ret__, 'retrieval_method'),
        route_created_at=pulumi.get(__ret__, 'route_created_at'),
        route_created_by=pulumi.get(__ret__, 'route_created_by'),
        route_name=pulumi.get(__ret__, 'route_name'),
        route_uuid=pulumi.get(__ret__, 'route_uuid'),
        tags=pulumi.get(__ret__, 'tags'),
        temperature=pulumi.get(__ret__, 'temperature'),
        templates=pulumi.get(__ret__, 'templates'),
        top_p=pulumi.get(__ret__, 'top_p'),
        updated_at=pulumi.get(__ret__, 'updated_at'),
        url=pulumi.get(__ret__, 'url'),
        user_id=pulumi.get(__ret__, 'user_id'))
def get_genai_agent_output(agent_guardrails: Optional[pulumi.Input[Optional[Sequence[Union['GetGenaiAgentAgentGuardrailArgs', 'GetGenaiAgentAgentGuardrailArgsDict']]]]] = None,
                           agent_id: Optional[pulumi.Input[_builtins.str]] = None,
                           anthropic_api_keys: Optional[pulumi.Input[Optional[Sequence[Union['GetGenaiAgentAnthropicApiKeyArgs', 'GetGenaiAgentAnthropicApiKeyArgsDict']]]]] = None,
                           api_key_infos: Optional[pulumi.Input[Optional[Sequence[Union['GetGenaiAgentApiKeyInfoArgs', 'GetGenaiAgentApiKeyInfoArgsDict']]]]] = None,
                           api_keys: Optional[pulumi.Input[Optional[Sequence[Union['GetGenaiAgentApiKeyArgs', 'GetGenaiAgentApiKeyArgsDict']]]]] = None,
                           chatbot_identifiers: Optional[pulumi.Input[Optional[Sequence[Union['GetGenaiAgentChatbotIdentifierArgs', 'GetGenaiAgentChatbotIdentifierArgsDict']]]]] = None,
                           chatbots: Optional[pulumi.Input[Optional[Sequence[Union['GetGenaiAgentChatbotArgs', 'GetGenaiAgentChatbotArgsDict']]]]] = None,
                           deployments: Optional[pulumi.Input[Optional[Sequence[Union['GetGenaiAgentDeploymentArgs', 'GetGenaiAgentDeploymentArgsDict']]]]] = None,
                           description: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
                           functions: Optional[pulumi.Input[Optional[Sequence[Union['GetGenaiAgentFunctionArgs', 'GetGenaiAgentFunctionArgsDict']]]]] = None,
                           if_case: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
                           k: Optional[pulumi.Input[Optional[_builtins.int]]] = None,
                           knowledge_bases: Optional[pulumi.Input[Optional[Sequence[Union['GetGenaiAgentKnowledgeBaseArgs', 'GetGenaiAgentKnowledgeBaseArgsDict']]]]] = None,
                           max_tokens: Optional[pulumi.Input[Optional[_builtins.int]]] = None,
                           models: Optional[pulumi.Input[Optional[Sequence[Union['GetGenaiAgentModelArgs', 'GetGenaiAgentModelArgsDict']]]]] = None,
                           open_ai_api_keys: Optional[pulumi.Input[Optional[Sequence[Union['GetGenaiAgentOpenAiApiKeyArgs', 'GetGenaiAgentOpenAiApiKeyArgsDict']]]]] = None,
                           retrieval_method: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
                           route_created_by: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
                           route_name: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
                           route_uuid: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
                           tags: Optional[pulumi.Input[Optional[Sequence[_builtins.str]]]] = None,
                           temperature: Optional[pulumi.Input[Optional[_builtins.float]]] = None,
                           templates: Optional[pulumi.Input[Optional[Sequence[Union['GetGenaiAgentTemplateArgs', 'GetGenaiAgentTemplateArgsDict']]]]] = None,
                           top_p: Optional[pulumi.Input[Optional[_builtins.float]]] = None,
                           url: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
                           user_id: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
                           opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetGenaiAgentResult]:
    """
    Use this data source to access information about an existing resource.
    """
    __args__ = dict()
    __args__['agentGuardrails'] = agent_guardrails
    __args__['agentId'] = agent_id
    __args__['anthropicApiKeys'] = anthropic_api_keys
    __args__['apiKeyInfos'] = api_key_infos
    __args__['apiKeys'] = api_keys
    __args__['chatbotIdentifiers'] = chatbot_identifiers
    __args__['chatbots'] = chatbots
    __args__['deployments'] = deployments
    __args__['description'] = description
    __args__['functions'] = functions
    __args__['ifCase'] = if_case
    __args__['k'] = k
    __args__['knowledgeBases'] = knowledge_bases
    __args__['maxTokens'] = max_tokens
    __args__['models'] = models
    __args__['openAiApiKeys'] = open_ai_api_keys
    __args__['retrievalMethod'] = retrieval_method
    __args__['routeCreatedBy'] = route_created_by
    __args__['routeName'] = route_name
    __args__['routeUuid'] = route_uuid
    __args__['tags'] = tags
    __args__['temperature'] = temperature
    __args__['templates'] = templates
    __args__['topP'] = top_p
    __args__['url'] = url
    __args__['userId'] = user_id
    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
    __ret__ = pulumi.runtime.invoke_output('digitalocean:index/getGenaiAgent:getGenaiAgent', __args__, opts=opts, typ=GetGenaiAgentResult)
    return __ret__.apply(lambda __response__: GetGenaiAgentResult(
        agent_guardrails=pulumi.get(__response__, 'agent_guardrails'),
        agent_id=pulumi.get(__response__, 'agent_id'),
        anthropic_api_keys=pulumi.get(__response__, 'anthropic_api_keys'),
        api_key_infos=pulumi.get(__response__, 'api_key_infos'),
        api_keys=pulumi.get(__response__, 'api_keys'),
        chatbot_identifiers=pulumi.get(__response__, 'chatbot_identifiers'),
        chatbots=pulumi.get(__response__, 'chatbots'),
        child_agents=pulumi.get(__response__, 'child_agents'),
        created_at=pulumi.get(__response__, 'created_at'),
        deployments=pulumi.get(__response__, 'deployments'),
        description=pulumi.get(__response__, 'description'),
        functions=pulumi.get(__response__, 'functions'),
        id=pulumi.get(__response__, 'id'),
        if_case=pulumi.get(__response__, 'if_case'),
        instruction=pulumi.get(__response__, 'instruction'),
        k=pulumi.get(__response__, 'k'),
        knowledge_bases=pulumi.get(__response__, 'knowledge_bases'),
        max_tokens=pulumi.get(__response__, 'max_tokens'),
        model_uuid=pulumi.get(__response__, 'model_uuid'),
        models=pulumi.get(__response__, 'models'),
        name=pulumi.get(__response__, 'name'),
        open_ai_api_keys=pulumi.get(__response__, 'open_ai_api_keys'),
        parent_agents=pulumi.get(__response__, 'parent_agents'),
        project_id=pulumi.get(__response__, 'project_id'),
        region=pulumi.get(__response__, 'region'),
        retrieval_method=pulumi.get(__response__, 'retrieval_method'),
        route_created_at=pulumi.get(__response__, 'route_created_at'),
        route_created_by=pulumi.get(__response__, 'route_created_by'),
        route_name=pulumi.get(__response__, 'route_name'),
        route_uuid=pulumi.get(__response__, 'route_uuid'),
        tags=pulumi.get(__response__, 'tags'),
        temperature=pulumi.get(__response__, 'temperature'),
        templates=pulumi.get(__response__, 'templates'),
        top_p=pulumi.get(__response__, 'top_p'),
        updated_at=pulumi.get(__response__, 'updated_at'),
        url=pulumi.get(__response__, 'url'),
        user_id=pulumi.get(__response__, 'user_id')))
