gcp.diagflow.CxTool

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";
import * as std from "@pulumi/std";

const agent = new gcp.diagflow.CxAgent("agent", {
    displayName: "dialogflowcx-agent-open-api",
    location: "global",
    defaultLanguageCode: "en",
    timeZone: "America/New_York",
    description: "Example description.",
});
const openApiTool = new gcp.diagflow.CxTool("open_api_tool", {
    parent: agent.id,
    displayName: "Example Open API Tool",
    description: "Example Description",
    openApiSpec: {
        authentication: {
            oauthConfig: {
                oauthGrantType: "CLIENT_CREDENTIAL",
                clientId: "example client ID",
                clientSecret: "example client secret",
                scopes: ["example scope"],
                secretVersionForClientSecret: "projects/-/secrets/-/versions/-",
                tokenEndpoint: "https://example.com/oauth/token",
            },
        },
        tlsConfig: {
            caCerts: [{
                displayName: "example ca cert name",
                cert: std.base64encode({
                    input: "example cert",
                }).then(invoke => invoke.result),
            }],
        },
        serviceDirectoryConfig: {
            service: "projects/-/locations/-/namespaces/-/services/-",
        },
        textSchema: `    {
      "openapi": "3.0.0",
      "info": {
        "title": "Time API",
        "version": "1.0.0",
        "description": "A simple API to get the current time."
      },
      "servers": [
        {
          "url": "https://example-api-endpoint.com"
        }
      ],
      "paths": {
        "/time": {
          "get": {
            "operationId": "getCurrentTime",
            "summary": "Gets the current server time.",
            "responses": {
              "200": {
                "description": "Successful response with the current time.",
                "content": {
                  "application/json": {
                    "schema": {
                      "type": "object",
                      "properties": {
                        "currentTime": {
                          "type": "string",
                          "format": "date-time",
                          "description": "The current time in ISO 8601 format."
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
`,
    },
});

import pulumi
import pulumi_gcp as gcp
import pulumi_std as std

agent = gcp.diagflow.CxAgent("agent",
    display_name="dialogflowcx-agent-open-api",
    location="global",
    default_language_code="en",
    time_zone="America/New_York",
    description="Example description.")
open_api_tool = gcp.diagflow.CxTool("open_api_tool",
    parent=agent.id,
    display_name="Example Open API Tool",
    description="Example Description",
    open_api_spec={
        "authentication": {
            "oauth_config": {
                "oauth_grant_type": "CLIENT_CREDENTIAL",
                "client_id": "example client ID",
                "client_secret": "example client secret",
                "scopes": ["example scope"],
                "secret_version_for_client_secret": "projects/-/secrets/-/versions/-",
                "token_endpoint": "https://example.com/oauth/token",
            },
        },
        "tls_config": {
            "ca_certs": [{
                "display_name": "example ca cert name",
                "cert": std.base64encode(input="example cert").result,
            }],
        },
        "service_directory_config": {
            "service": "projects/-/locations/-/namespaces/-/services/-",
        },
        "text_schema": """    {
      "openapi": "3.0.0",
      "info": {
        "title": "Time API",
        "version": "1.0.0",
        "description": "A simple API to get the current time."
      },
      "servers": [
        {
          "url": "https://example-api-endpoint.com"
        }
      ],
      "paths": {
        "/time": {
          "get": {
            "operationId": "getCurrentTime",
            "summary": "Gets the current server time.",
            "responses": {
              "200": {
                "description": "Successful response with the current time.",
                "content": {
                  "application/json": {
                    "schema": {
                      "type": "object",
                      "properties": {
                        "currentTime": {
                          "type": "string",
                          "format": "date-time",
                          "description": "The current time in ISO 8601 format."
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
""",
    })

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/diagflow"
	"github.com/pulumi/pulumi-std/sdk/go/std"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		agent, err := diagflow.NewCxAgent(ctx, "agent", &diagflow.CxAgentArgs{
			DisplayName:         pulumi.String("dialogflowcx-agent-open-api"),
			Location:            pulumi.String("global"),
			DefaultLanguageCode: pulumi.String("en"),
			TimeZone:            pulumi.String("America/New_York"),
			Description:         pulumi.String("Example description."),
		})
		if err != nil {
			return err
		}
		invokeBase64encode, err := std.Base64encode(ctx, &std.Base64encodeArgs{
			Input: "example cert",
		}, nil)
		if err != nil {
			return err
		}
		_, err = diagflow.NewCxTool(ctx, "open_api_tool", &diagflow.CxToolArgs{
			Parent:      agent.ID(),
			DisplayName: pulumi.String("Example Open API Tool"),
			Description: pulumi.String("Example Description"),
			OpenApiSpec: &diagflow.CxToolOpenApiSpecArgs{
				Authentication: &diagflow.CxToolOpenApiSpecAuthenticationArgs{
					OauthConfig: &diagflow.CxToolOpenApiSpecAuthenticationOauthConfigArgs{
						OauthGrantType: pulumi.String("CLIENT_CREDENTIAL"),
						ClientId:       pulumi.String("example client ID"),
						ClientSecret:   pulumi.String("example client secret"),
						Scopes: pulumi.StringArray{
							pulumi.String("example scope"),
						},
						SecretVersionForClientSecret: pulumi.String("projects/-/secrets/-/versions/-"),
						TokenEndpoint:                pulumi.String("https://example.com/oauth/token"),
					},
				},
				TlsConfig: &diagflow.CxToolOpenApiSpecTlsConfigArgs{
					CaCerts: diagflow.CxToolOpenApiSpecTlsConfigCaCertArray{
						&diagflow.CxToolOpenApiSpecTlsConfigCaCertArgs{
							DisplayName: pulumi.String("example ca cert name"),
							Cert:        pulumi.String(invokeBase64encode.Result),
						},
					},
				},
				ServiceDirectoryConfig: &diagflow.CxToolOpenApiSpecServiceDirectoryConfigArgs{
					Service: pulumi.String("projects/-/locations/-/namespaces/-/services/-"),
				},
				TextSchema: pulumi.String(`    {
      "openapi": "3.0.0",
      "info": {
        "title": "Time API",
        "version": "1.0.0",
        "description": "A simple API to get the current time."
      },
      "servers": [
        {
          "url": "https://example-api-endpoint.com"
        }
      ],
      "paths": {
        "/time": {
          "get": {
            "operationId": "getCurrentTime",
            "summary": "Gets the current server time.",
            "responses": {
              "200": {
                "description": "Successful response with the current time.",
                "content": {
                  "application/json": {
                    "schema": {
                      "type": "object",
                      "properties": {
                        "currentTime": {
                          "type": "string",
                          "format": "date-time",
                          "description": "The current time in ISO 8601 format."
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
`),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;
using Std = Pulumi.Std;

return await Deployment.RunAsync(() => 
{
    var agent = new Gcp.Diagflow.CxAgent("agent", new()
    {
        DisplayName = "dialogflowcx-agent-open-api",
        Location = "global",
        DefaultLanguageCode = "en",
        TimeZone = "America/New_York",
        Description = "Example description.",
    });

    var openApiTool = new Gcp.Diagflow.CxTool("open_api_tool", new()
    {
        Parent = agent.Id,
        DisplayName = "Example Open API Tool",
        Description = "Example Description",
        OpenApiSpec = new Gcp.Diagflow.Inputs.CxToolOpenApiSpecArgs
        {
            Authentication = new Gcp.Diagflow.Inputs.CxToolOpenApiSpecAuthenticationArgs
            {
                OauthConfig = new Gcp.Diagflow.Inputs.CxToolOpenApiSpecAuthenticationOauthConfigArgs
                {
                    OauthGrantType = "CLIENT_CREDENTIAL",
                    ClientId = "example client ID",
                    ClientSecret = "example client secret",
                    Scopes = new[]
                    {
                        "example scope",
                    },
                    SecretVersionForClientSecret = "projects/-/secrets/-/versions/-",
                    TokenEndpoint = "https://example.com/oauth/token",
                },
            },
            TlsConfig = new Gcp.Diagflow.Inputs.CxToolOpenApiSpecTlsConfigArgs
            {
                CaCerts = new[]
                {
                    new Gcp.Diagflow.Inputs.CxToolOpenApiSpecTlsConfigCaCertArgs
                    {
                        DisplayName = "example ca cert name",
                        Cert = Std.Base64encode.Invoke(new()
                        {
                            Input = "example cert",
                        }).Apply(invoke => invoke.Result),
                    },
                },
            },
            ServiceDirectoryConfig = new Gcp.Diagflow.Inputs.CxToolOpenApiSpecServiceDirectoryConfigArgs
            {
                Service = "projects/-/locations/-/namespaces/-/services/-",
            },
            TextSchema = @"    {
      ""openapi"": ""3.0.0"",
      ""info"": {
        ""title"": ""Time API"",
        ""version"": ""1.0.0"",
        ""description"": ""A simple API to get the current time.""
      },
      ""servers"": [
        {
          ""url"": ""https://example-api-endpoint.com""
        }
      ],
      ""paths"": {
        ""/time"": {
          ""get"": {
            ""operationId"": ""getCurrentTime"",
            ""summary"": ""Gets the current server time."",
            ""responses"": {
              ""200"": {
                ""description"": ""Successful response with the current time."",
                ""content"": {
                  ""application/json"": {
                    ""schema"": {
                      ""type"": ""object"",
                      ""properties"": {
                        ""currentTime"": {
                          ""type"": ""string"",
                          ""format"": ""date-time"",
                          ""description"": ""The current time in ISO 8601 format.""
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.diagflow.CxAgent;
import com.pulumi.gcp.diagflow.CxAgentArgs;
import com.pulumi.gcp.diagflow.CxTool;
import com.pulumi.gcp.diagflow.CxToolArgs;
import com.pulumi.gcp.diagflow.inputs.CxToolOpenApiSpecArgs;
import com.pulumi.gcp.diagflow.inputs.CxToolOpenApiSpecAuthenticationArgs;
import com.pulumi.gcp.diagflow.inputs.CxToolOpenApiSpecAuthenticationOauthConfigArgs;
import com.pulumi.gcp.diagflow.inputs.CxToolOpenApiSpecTlsConfigArgs;
import com.pulumi.gcp.diagflow.inputs.CxToolOpenApiSpecServiceDirectoryConfigArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.Base64encodeArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var agent = new CxAgent("agent", CxAgentArgs.builder()
            .displayName("dialogflowcx-agent-open-api")
            .location("global")
            .defaultLanguageCode("en")
            .timeZone("America/New_York")
            .description("Example description.")
            .build());

        var openApiTool = new CxTool("openApiTool", CxToolArgs.builder()
            .parent(agent.id())
            .displayName("Example Open API Tool")
            .description("Example Description")
            .openApiSpec(CxToolOpenApiSpecArgs.builder()
                .authentication(CxToolOpenApiSpecAuthenticationArgs.builder()
                    .oauthConfig(CxToolOpenApiSpecAuthenticationOauthConfigArgs.builder()
                        .oauthGrantType("CLIENT_CREDENTIAL")
                        .clientId("example client ID")
                        .clientSecret("example client secret")
                        .scopes("example scope")
                        .secretVersionForClientSecret("projects/-/secrets/-/versions/-")
                        .tokenEndpoint("https://example.com/oauth/token")
                        .build())
                    .build())
                .tlsConfig(CxToolOpenApiSpecTlsConfigArgs.builder()
                    .caCerts(CxToolOpenApiSpecTlsConfigCaCertArgs.builder()
                        .displayName("example ca cert name")
                        .cert(StdFunctions.base64encode(Base64encodeArgs.builder()
                            .input("example cert")
                            .build()).result())
                        .build())
                    .build())
                .serviceDirectoryConfig(CxToolOpenApiSpecServiceDirectoryConfigArgs.builder()
                    .service("projects/-/locations/-/namespaces/-/services/-")
                    .build())
                .textSchema("""
    {
      "openapi": "3.0.0",
      "info": {
        "title": "Time API",
        "version": "1.0.0",
        "description": "A simple API to get the current time."
      },
      "servers": [
        {
          "url": "https://example-api-endpoint.com"
        }
      ],
      "paths": {
        "/time": {
          "get": {
            "operationId": "getCurrentTime",
            "summary": "Gets the current server time.",
            "responses": {
              "200": {
                "description": "Successful response with the current time.",
                "content": {
                  "application/json": {
                    "schema": {
                      "type": "object",
                      "properties": {
                        "currentTime": {
                          "type": "string",
                          "format": "date-time",
                          "description": "The current time in ISO 8601 format."
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
                """)
                .build())
            .build());

    }
}

resources:
  agent:
    type: gcp:diagflow:CxAgent
    properties:
      displayName: dialogflowcx-agent-open-api
      location: global
      defaultLanguageCode: en
      timeZone: America/New_York
      description: Example description.
  openApiTool:
    type: gcp:diagflow:CxTool
    name: open_api_tool
    properties:
      parent: ${agent.id}
      displayName: Example Open API Tool
      description: Example Description
      openApiSpec:
        authentication:
          oauthConfig:
            oauthGrantType: CLIENT_CREDENTIAL
            clientId: example client ID
            clientSecret: example client secret
            scopes:
              - example scope
            secretVersionForClientSecret: projects/-/secrets/-/versions/-
            tokenEndpoint: https://example.com/oauth/token
        tlsConfig:
          caCerts:
            - displayName: example ca cert name
              cert:
                fn::invoke:
                  function: std:base64encode
                  arguments:
                    input: example cert
                  return: result
        serviceDirectoryConfig:
          service: projects/-/locations/-/namespaces/-/services/-
        textSchema: |2
              {
                "openapi": "3.0.0",
                "info": {
                  "title": "Time API",
                  "version": "1.0.0",
                  "description": "A simple API to get the current time."
                },
                "servers": [
                  {
                    "url": "https://example-api-endpoint.com"
                  }
                ],
                "paths": {
                  "/time": {
                    "get": {
                      "operationId": "getCurrentTime",
                      "summary": "Gets the current server time.",
                      "responses": {
                        "200": {
                          "description": "Successful response with the current time.",
                          "content": {
                            "application/json": {
                              "schema": {
                                "type": "object",
                                "properties": {
                                  "currentTime": {
                                    "type": "string",
                                    "format": "date-time",
                                    "description": "The current time in ISO 8601 format."
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const myDatastore = new gcp.discoveryengine.DataStore("my_datastore", {
    location: "global",
    dataStoreId: "datastore-tool-test-_79169",
    displayName: "datastore for Tool test",
    industryVertical: "GENERIC",
    contentConfig: "NO_CONTENT",
    solutionTypes: ["SOLUTION_TYPE_CHAT"],
});
const agent = new gcp.diagflow.CxAgent("agent", {
    displayName: "dialogflowcx-agent-data-store",
    location: "global",
    defaultLanguageCode: "en",
    timeZone: "America/New_York",
    description: "Example description.",
    deleteChatEngineOnDestroy: true,
}, {
    dependsOn: [myDatastore],
});
const project = gcp.organizations.getProject({});
const dataStoreTool = new gcp.diagflow.CxTool("data_store_tool", {
    parent: agent.id,
    displayName: "Example Data Store Tool",
    description: "Example Description",
    dataStoreSpec: {
        dataStoreConnections: [{
            dataStoreType: "UNSTRUCTURED",
            dataStore: pulumi.all([project, myDatastore.dataStoreId]).apply(([project, dataStoreId]) => `projects/${project.number}/locations/global/collections/default_collection/dataStores/${dataStoreId}`),
            documentProcessingMode: "DOCUMENTS",
        }],
        fallbackPrompt: {},
    },
}, {
    dependsOn: [
        myDatastore,
        agent,
    ],
});

import pulumi
import pulumi_gcp as gcp

my_datastore = gcp.discoveryengine.DataStore("my_datastore",
    location="global",
    data_store_id="datastore-tool-test-_79169",
    display_name="datastore for Tool test",
    industry_vertical="GENERIC",
    content_config="NO_CONTENT",
    solution_types=["SOLUTION_TYPE_CHAT"])
agent = gcp.diagflow.CxAgent("agent",
    display_name="dialogflowcx-agent-data-store",
    location="global",
    default_language_code="en",
    time_zone="America/New_York",
    description="Example description.",
    delete_chat_engine_on_destroy=True,
    opts = pulumi.ResourceOptions(depends_on=[my_datastore]))
project = gcp.organizations.get_project()
data_store_tool = gcp.diagflow.CxTool("data_store_tool",
    parent=agent.id,
    display_name="Example Data Store Tool",
    description="Example Description",
    data_store_spec={
        "data_store_connections": [{
            "data_store_type": "UNSTRUCTURED",
            "data_store": my_datastore.data_store_id.apply(lambda data_store_id: f"projects/{project.number}/locations/global/collections/default_collection/dataStores/{data_store_id}"),
            "document_processing_mode": "DOCUMENTS",
        }],
        "fallback_prompt": {},
    },
    opts = pulumi.ResourceOptions(depends_on=[
            my_datastore,
            agent,
        ]))

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/diagflow"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/discoveryengine"
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/organizations"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		myDatastore, err := discoveryengine.NewDataStore(ctx, "my_datastore", &discoveryengine.DataStoreArgs{
			Location:         pulumi.String("global"),
			DataStoreId:      pulumi.String("datastore-tool-test-_79169"),
			DisplayName:      pulumi.String("datastore for Tool test"),
			IndustryVertical: pulumi.String("GENERIC"),
			ContentConfig:    pulumi.String("NO_CONTENT"),
			SolutionTypes: pulumi.StringArray{
				pulumi.String("SOLUTION_TYPE_CHAT"),
			},
		})
		if err != nil {
			return err
		}
		agent, err := diagflow.NewCxAgent(ctx, "agent", &diagflow.CxAgentArgs{
			DisplayName:               pulumi.String("dialogflowcx-agent-data-store"),
			Location:                  pulumi.String("global"),
			DefaultLanguageCode:       pulumi.String("en"),
			TimeZone:                  pulumi.String("America/New_York"),
			Description:               pulumi.String("Example description."),
			DeleteChatEngineOnDestroy: pulumi.Bool(true),
		}, pulumi.DependsOn([]pulumi.Resource{
			myDatastore,
		}))
		if err != nil {
			return err
		}
		project, err := organizations.LookupProject(ctx, &organizations.LookupProjectArgs{}, nil)
		if err != nil {
			return err
		}
		_, err = diagflow.NewCxTool(ctx, "data_store_tool", &diagflow.CxToolArgs{
			Parent:      agent.ID(),
			DisplayName: pulumi.String("Example Data Store Tool"),
			Description: pulumi.String("Example Description"),
			DataStoreSpec: &diagflow.CxToolDataStoreSpecArgs{
				DataStoreConnections: diagflow.CxToolDataStoreSpecDataStoreConnectionArray{
					&diagflow.CxToolDataStoreSpecDataStoreConnectionArgs{
						DataStoreType: pulumi.String("UNSTRUCTURED"),
						DataStore: myDatastore.DataStoreId.ApplyT(func(dataStoreId string) (string, error) {
							return fmt.Sprintf("projects/%v/locations/global/collections/default_collection/dataStores/%v", project.Number, dataStoreId), nil
						}).(pulumi.StringOutput),
						DocumentProcessingMode: pulumi.String("DOCUMENTS"),
					},
				},
				FallbackPrompt: &diagflow.CxToolDataStoreSpecFallbackPromptArgs{},
			},
		}, pulumi.DependsOn([]pulumi.Resource{
			myDatastore,
			agent,
		}))
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() => 
{
    var myDatastore = new Gcp.DiscoveryEngine.DataStore("my_datastore", new()
    {
        Location = "global",
        DataStoreId = "datastore-tool-test-_79169",
        DisplayName = "datastore for Tool test",
        IndustryVertical = "GENERIC",
        ContentConfig = "NO_CONTENT",
        SolutionTypes = new[]
        {
            "SOLUTION_TYPE_CHAT",
        },
    });

    var agent = new Gcp.Diagflow.CxAgent("agent", new()
    {
        DisplayName = "dialogflowcx-agent-data-store",
        Location = "global",
        DefaultLanguageCode = "en",
        TimeZone = "America/New_York",
        Description = "Example description.",
        DeleteChatEngineOnDestroy = true,
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            myDatastore,
        },
    });

    var project = Gcp.Organizations.GetProject.Invoke();

    var dataStoreTool = new Gcp.Diagflow.CxTool("data_store_tool", new()
    {
        Parent = agent.Id,
        DisplayName = "Example Data Store Tool",
        Description = "Example Description",
        DataStoreSpec = new Gcp.Diagflow.Inputs.CxToolDataStoreSpecArgs
        {
            DataStoreConnections = new[]
            {
                new Gcp.Diagflow.Inputs.CxToolDataStoreSpecDataStoreConnectionArgs
                {
                    DataStoreType = "UNSTRUCTURED",
                    DataStore = Output.Tuple(project, myDatastore.DataStoreId).Apply(values =>
                    {
                        var project = values.Item1;
                        var dataStoreId = values.Item2;
                        return $"projects/{project.Apply(getProjectResult => getProjectResult.Number)}/locations/global/collections/default_collection/dataStores/{dataStoreId}";
                    }),
                    DocumentProcessingMode = "DOCUMENTS",
                },
            },
            FallbackPrompt = null,
        },
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            myDatastore,
            agent,
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.discoveryengine.DataStore;
import com.pulumi.gcp.discoveryengine.DataStoreArgs;
import com.pulumi.gcp.diagflow.CxAgent;
import com.pulumi.gcp.diagflow.CxAgentArgs;
import com.pulumi.gcp.organizations.OrganizationsFunctions;
import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
import com.pulumi.gcp.diagflow.CxTool;
import com.pulumi.gcp.diagflow.CxToolArgs;
import com.pulumi.gcp.diagflow.inputs.CxToolDataStoreSpecArgs;
import com.pulumi.gcp.diagflow.inputs.CxToolDataStoreSpecFallbackPromptArgs;
import com.pulumi.resources.CustomResourceOptions;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var myDatastore = new DataStore("myDatastore", DataStoreArgs.builder()
            .location("global")
            .dataStoreId("datastore-tool-test-_79169")
            .displayName("datastore for Tool test")
            .industryVertical("GENERIC")
            .contentConfig("NO_CONTENT")
            .solutionTypes("SOLUTION_TYPE_CHAT")
            .build());

        var agent = new CxAgent("agent", CxAgentArgs.builder()
            .displayName("dialogflowcx-agent-data-store")
            .location("global")
            .defaultLanguageCode("en")
            .timeZone("America/New_York")
            .description("Example description.")
            .deleteChatEngineOnDestroy(true)
            .build(), CustomResourceOptions.builder()
                .dependsOn(myDatastore)
                .build());

        final var project = OrganizationsFunctions.getProject(GetProjectArgs.builder()
            .build());

        var dataStoreTool = new CxTool("dataStoreTool", CxToolArgs.builder()
            .parent(agent.id())
            .displayName("Example Data Store Tool")
            .description("Example Description")
            .dataStoreSpec(CxToolDataStoreSpecArgs.builder()
                .dataStoreConnections(CxToolDataStoreSpecDataStoreConnectionArgs.builder()
                    .dataStoreType("UNSTRUCTURED")
                    .dataStore(myDatastore.dataStoreId().applyValue(_dataStoreId -> String.format("projects/%s/locations/global/collections/default_collection/dataStores/%s", project.number(),_dataStoreId)))
                    .documentProcessingMode("DOCUMENTS")
                    .build())
                .fallbackPrompt(CxToolDataStoreSpecFallbackPromptArgs.builder()
                    .build())
                .build())
            .build(), CustomResourceOptions.builder()
                .dependsOn(                
                    myDatastore,
                    agent)
                .build());

    }
}

resources:
  agent:
    type: gcp:diagflow:CxAgent
    properties:
      displayName: dialogflowcx-agent-data-store
      location: global
      defaultLanguageCode: en
      timeZone: America/New_York
      description: Example description.
      deleteChatEngineOnDestroy: true
    options:
      dependsOn:
        - ${myDatastore}
  dataStoreTool:
    type: gcp:diagflow:CxTool
    name: data_store_tool
    properties:
      parent: ${agent.id}
      displayName: Example Data Store Tool
      description: Example Description
      dataStoreSpec:
        dataStoreConnections:
          - dataStoreType: UNSTRUCTURED
            dataStore: projects/${project.number}/locations/global/collections/default_collection/dataStores/${myDatastore.dataStoreId}
            documentProcessingMode: DOCUMENTS
        fallbackPrompt: {}
    options:
      dependsOn:
        - ${myDatastore}
        - ${agent}
  myDatastore:
    type: gcp:discoveryengine:DataStore
    name: my_datastore
    properties:
      location: global
      dataStoreId: datastore-tool-test-_79169
      displayName: datastore for Tool test
      industryVertical: GENERIC
      contentConfig: NO_CONTENT
      solutionTypes:
        - SOLUTION_TYPE_CHAT
variables:
  project:
    fn::invoke:
      function: gcp:organizations:getProject
      arguments: {}

import * as pulumi from "@pulumi/pulumi";
import * as gcp from "@pulumi/gcp";

const agent = new gcp.diagflow.CxAgent("agent", {
    displayName: "dialogflowcx-agent-fucntion",
    location: "global",
    defaultLanguageCode: "en",
    timeZone: "America/New_York",
    description: "Example description.",
});
const functionTool = new gcp.diagflow.CxTool("function_tool", {
    parent: agent.id,
    displayName: "Example Function Tool",
    description: "Example Description",
    functionSpec: {
        inputSchema: `      {
        "type": "object",
        "properties": {
          "message_to_echo": {
            "type": "string",
            "description": "The message that should be echoed back."
          }
        },
        "required": [
          "message_to_echo"
        ]
      }
`,
        outputSchema: `      {
        "type": "object",
        "properties": {
          "echoed_message": {
            "type": "string",
            "description": "The message that is echoed back."
          }
        }
      }
`,
    },
});

import pulumi
import pulumi_gcp as gcp

agent = gcp.diagflow.CxAgent("agent",
    display_name="dialogflowcx-agent-fucntion",
    location="global",
    default_language_code="en",
    time_zone="America/New_York",
    description="Example description.")
function_tool = gcp.diagflow.CxTool("function_tool",
    parent=agent.id,
    display_name="Example Function Tool",
    description="Example Description",
    function_spec={
        "input_schema": """      {
        "type": "object",
        "properties": {
          "message_to_echo": {
            "type": "string",
            "description": "The message that should be echoed back."
          }
        },
        "required": [
          "message_to_echo"
        ]
      }
""",
        "output_schema": """      {
        "type": "object",
        "properties": {
          "echoed_message": {
            "type": "string",
            "description": "The message that is echoed back."
          }
        }
      }
""",
    })

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v8/go/gcp/diagflow"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		agent, err := diagflow.NewCxAgent(ctx, "agent", &diagflow.CxAgentArgs{
			DisplayName:         pulumi.String("dialogflowcx-agent-fucntion"),
			Location:            pulumi.String("global"),
			DefaultLanguageCode: pulumi.String("en"),
			TimeZone:            pulumi.String("America/New_York"),
			Description:         pulumi.String("Example description."),
		})
		if err != nil {
			return err
		}
		_, err = diagflow.NewCxTool(ctx, "function_tool", &diagflow.CxToolArgs{
			Parent:      agent.ID(),
			DisplayName: pulumi.String("Example Function Tool"),
			Description: pulumi.String("Example Description"),
			FunctionSpec: &diagflow.CxToolFunctionSpecArgs{
				InputSchema: pulumi.String(`      {
        "type": "object",
        "properties": {
          "message_to_echo": {
            "type": "string",
            "description": "The message that should be echoed back."
          }
        },
        "required": [
          "message_to_echo"
        ]
      }
`),
				OutputSchema: pulumi.String(`      {
        "type": "object",
        "properties": {
          "echoed_message": {
            "type": "string",
            "description": "The message that is echoed back."
          }
        }
      }
`),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Gcp = Pulumi.Gcp;

return await Deployment.RunAsync(() => 
{
    var agent = new Gcp.Diagflow.CxAgent("agent", new()
    {
        DisplayName = "dialogflowcx-agent-fucntion",
        Location = "global",
        DefaultLanguageCode = "en",
        TimeZone = "America/New_York",
        Description = "Example description.",
    });

    var functionTool = new Gcp.Diagflow.CxTool("function_tool", new()
    {
        Parent = agent.Id,
        DisplayName = "Example Function Tool",
        Description = "Example Description",
        FunctionSpec = new Gcp.Diagflow.Inputs.CxToolFunctionSpecArgs
        {
            InputSchema = @"      {
        ""type"": ""object"",
        ""properties"": {
          ""message_to_echo"": {
            ""type"": ""string"",
            ""description"": ""The message that should be echoed back.""
          }
        },
        ""required"": [
          ""message_to_echo""
        ]
      }
",
            OutputSchema = @"      {
        ""type"": ""object"",
        ""properties"": {
          ""echoed_message"": {
            ""type"": ""string"",
            ""description"": ""The message that is echoed back.""
          }
        }
      }
",
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.diagflow.CxAgent;
import com.pulumi.gcp.diagflow.CxAgentArgs;
import com.pulumi.gcp.diagflow.CxTool;
import com.pulumi.gcp.diagflow.CxToolArgs;
import com.pulumi.gcp.diagflow.inputs.CxToolFunctionSpecArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var agent = new CxAgent("agent", CxAgentArgs.builder()
            .displayName("dialogflowcx-agent-fucntion")
            .location("global")
            .defaultLanguageCode("en")
            .timeZone("America/New_York")
            .description("Example description.")
            .build());

        var functionTool = new CxTool("functionTool", CxToolArgs.builder()
            .parent(agent.id())
            .displayName("Example Function Tool")
            .description("Example Description")
            .functionSpec(CxToolFunctionSpecArgs.builder()
                .inputSchema("""
      {
        "type": "object",
        "properties": {
          "message_to_echo": {
            "type": "string",
            "description": "The message that should be echoed back."
          }
        },
        "required": [
          "message_to_echo"
        ]
      }
                """)
                .outputSchema("""
      {
        "type": "object",
        "properties": {
          "echoed_message": {
            "type": "string",
            "description": "The message that is echoed back."
          }
        }
      }
                """)
                .build())
            .build());

    }
}

resources:
  agent:
    type: gcp:diagflow:CxAgent
    properties:
      displayName: dialogflowcx-agent-fucntion
      location: global
      defaultLanguageCode: en
      timeZone: America/New_York
      description: Example description.
  functionTool:
    type: gcp:diagflow:CxTool
    name: function_tool
    properties:
      parent: ${agent.id}
      displayName: Example Function Tool
      description: Example Description
      functionSpec:
        inputSchema: |2
                {
                  "type": "object",
                  "properties": {
                    "message_to_echo": {
                      "type": "string",
                      "description": "The message that should be echoed back."
                    }
                  },
                  "required": [
                    "message_to_echo"
                  ]
                }
        outputSchema: |2
                {
                  "type": "object",
                  "properties": {
                    "echoed_message": {
                      "type": "string",
                      "description": "The message that is echoed back."
                    }
                  }
                }

var cxToolResource = new Gcp.Diagflow.CxTool("cxToolResource", new()
{
    Description = "string",
    DisplayName = "string",
    DataStoreSpec = new Gcp.Diagflow.Inputs.CxToolDataStoreSpecArgs
    {
        DataStoreConnections = new[]
        {
            new Gcp.Diagflow.Inputs.CxToolDataStoreSpecDataStoreConnectionArgs
            {
                DataStore = "string",
                DataStoreType = "string",
                DocumentProcessingMode = "string",
            },
        },
        FallbackPrompt = null,
    },
    FunctionSpec = new Gcp.Diagflow.Inputs.CxToolFunctionSpecArgs
    {
        InputSchema = "string",
        OutputSchema = "string",
    },
    OpenApiSpec = new Gcp.Diagflow.Inputs.CxToolOpenApiSpecArgs
    {
        TextSchema = "string",
        Authentication = new Gcp.Diagflow.Inputs.CxToolOpenApiSpecAuthenticationArgs
        {
            ApiKeyConfig = new Gcp.Diagflow.Inputs.CxToolOpenApiSpecAuthenticationApiKeyConfigArgs
            {
                KeyName = "string",
                RequestLocation = "string",
                ApiKey = "string",
                SecretVersionForApiKey = "string",
            },
            BearerTokenConfig = new Gcp.Diagflow.Inputs.CxToolOpenApiSpecAuthenticationBearerTokenConfigArgs
            {
                SecretVersionForToken = "string",
                Token = "string",
            },
            OauthConfig = new Gcp.Diagflow.Inputs.CxToolOpenApiSpecAuthenticationOauthConfigArgs
            {
                ClientId = "string",
                OauthGrantType = "string",
                TokenEndpoint = "string",
                ClientSecret = "string",
                Scopes = new[]
                {
                    "string",
                },
                SecretVersionForClientSecret = "string",
            },
            ServiceAgentAuthConfig = new Gcp.Diagflow.Inputs.CxToolOpenApiSpecAuthenticationServiceAgentAuthConfigArgs
            {
                ServiceAgentAuth = "string",
            },
        },
        ServiceDirectoryConfig = new Gcp.Diagflow.Inputs.CxToolOpenApiSpecServiceDirectoryConfigArgs
        {
            Service = "string",
        },
        TlsConfig = new Gcp.Diagflow.Inputs.CxToolOpenApiSpecTlsConfigArgs
        {
            CaCerts = new[]
            {
                new Gcp.Diagflow.Inputs.CxToolOpenApiSpecTlsConfigCaCertArgs
                {
                    Cert = "string",
                    DisplayName = "string",
                },
            },
        },
    },
    Parent = "string",
});

example, err := diagflow.NewCxTool(ctx, "cxToolResource", &diagflow.CxToolArgs{
	Description: pulumi.String("string"),
	DisplayName: pulumi.String("string"),
	DataStoreSpec: &diagflow.CxToolDataStoreSpecArgs{
		DataStoreConnections: diagflow.CxToolDataStoreSpecDataStoreConnectionArray{
			&diagflow.CxToolDataStoreSpecDataStoreConnectionArgs{
				DataStore:              pulumi.String("string"),
				DataStoreType:          pulumi.String("string"),
				DocumentProcessingMode: pulumi.String("string"),
			},
		},
		FallbackPrompt: &diagflow.CxToolDataStoreSpecFallbackPromptArgs{},
	},
	FunctionSpec: &diagflow.CxToolFunctionSpecArgs{
		InputSchema:  pulumi.String("string"),
		OutputSchema: pulumi.String("string"),
	},
	OpenApiSpec: &diagflow.CxToolOpenApiSpecArgs{
		TextSchema: pulumi.String("string"),
		Authentication: &diagflow.CxToolOpenApiSpecAuthenticationArgs{
			ApiKeyConfig: &diagflow.CxToolOpenApiSpecAuthenticationApiKeyConfigArgs{
				KeyName:                pulumi.String("string"),
				RequestLocation:        pulumi.String("string"),
				ApiKey:                 pulumi.String("string"),
				SecretVersionForApiKey: pulumi.String("string"),
			},
			BearerTokenConfig: &diagflow.CxToolOpenApiSpecAuthenticationBearerTokenConfigArgs{
				SecretVersionForToken: pulumi.String("string"),
				Token:                 pulumi.String("string"),
			},
			OauthConfig: &diagflow.CxToolOpenApiSpecAuthenticationOauthConfigArgs{
				ClientId:       pulumi.String("string"),
				OauthGrantType: pulumi.String("string"),
				TokenEndpoint:  pulumi.String("string"),
				ClientSecret:   pulumi.String("string"),
				Scopes: pulumi.StringArray{
					pulumi.String("string"),
				},
				SecretVersionForClientSecret: pulumi.String("string"),
			},
			ServiceAgentAuthConfig: &diagflow.CxToolOpenApiSpecAuthenticationServiceAgentAuthConfigArgs{
				ServiceAgentAuth: pulumi.String("string"),
			},
		},
		ServiceDirectoryConfig: &diagflow.CxToolOpenApiSpecServiceDirectoryConfigArgs{
			Service: pulumi.String("string"),
		},
		TlsConfig: &diagflow.CxToolOpenApiSpecTlsConfigArgs{
			CaCerts: diagflow.CxToolOpenApiSpecTlsConfigCaCertArray{
				&diagflow.CxToolOpenApiSpecTlsConfigCaCertArgs{
					Cert:        pulumi.String("string"),
					DisplayName: pulumi.String("string"),
				},
			},
		},
	},
	Parent: pulumi.String("string"),
})