1. Registry
  2. Packages
  3. Google Cloud (GCP)
  4. API Docs
  5. diagflow
  6. Tool
Viewing docs for Google Cloud v10.2.0
published on Tuesday, Oct 20, 2026 by Pulumi
gcp logo
Viewing docs for Google Cloud v10.2.0
published on Tuesday, Oct 20, 2026 by Pulumi

    Provides a list of actions available to a Generator (e.g., OpenAPI call, Function call, Connector call).

    To get more information about Tool, see:

    Example Usage

    Dialogflow Tool Basic

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const basicTool = new gcp.diagflow.Tool("basic_tool", {
        location: "global",
        toolId: "basic_tool_key",
        toolKey: "basic_tool_key",
        displayName: "basic-tool",
        description: "A basic tool with OpenAPI spec",
        actionConfirmationRequirement: {
            searchAction: "NOT_REQUIRED",
        },
        openApiSpec: {
            textSchema: `openapi: 3.0.0
    info:
      title: basic_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    `,
        },
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    basic_tool = gcp.diagflow.Tool("basic_tool",
        location="global",
        tool_id="basic_tool_key",
        tool_key="basic_tool_key",
        display_name="basic-tool",
        description="A basic tool with OpenAPI spec",
        action_confirmation_requirement={
            "searchAction": "NOT_REQUIRED",
        },
        open_api_spec={
            "text_schema": """openapi: 3.0.0
    info:
      title: basic_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    """,
        })
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v10/go/gcp/diagflow"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := diagflow.NewTool(ctx, "basic_tool", &diagflow.ToolArgs{
    			Location:    pulumi.String("global"),
    			ToolId:      pulumi.String("basic_tool_key"),
    			ToolKey:     pulumi.String("basic_tool_key"),
    			DisplayName: pulumi.String("basic-tool"),
    			Description: pulumi.String("A basic tool with OpenAPI spec"),
    			ActionConfirmationRequirement: pulumi.StringMap{
    				"searchAction": pulumi.String("NOT_REQUIRED"),
    			},
    			OpenApiSpec: &diagflow.ToolOpenApiSpecArgs{
    				TextSchema: pulumi.String(`openapi: 3.0.0
    info:
      title: basic_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    `),
    			},
    		})
    		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 basicTool = new Gcp.Diagflow.Tool("basic_tool", new()
        {
            Location = "global",
            ToolId = "basic_tool_key",
            ToolKey = "basic_tool_key",
            DisplayName = "basic-tool",
            Description = "A basic tool with OpenAPI spec",
            ActionConfirmationRequirement = 
            {
                { "searchAction", "NOT_REQUIRED" },
            },
            OpenApiSpec = new Gcp.Diagflow.Inputs.ToolOpenApiSpecArgs
            {
                TextSchema = @"openapi: 3.0.0
    info:
      title: basic_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    ",
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.diagflow.Tool;
    import com.pulumi.gcp.diagflow.ToolArgs;
    import com.pulumi.gcp.diagflow.inputs.ToolOpenApiSpecArgs;
    import java.util.ArrayList;
    import java.util.Arrays;
    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 basicTool = new Tool("basicTool", ToolArgs.builder()
                .location("global")
                .toolId("basic_tool_key")
                .toolKey("basic_tool_key")
                .displayName("basic-tool")
                .description("A basic tool with OpenAPI spec")
                .actionConfirmationRequirement(Map.of("searchAction", "NOT_REQUIRED"))
                .openApiSpec(ToolOpenApiSpecArgs.builder()
                    .textSchema("""
    openapi: 3.0.0
    info:
      title: basic_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
                    """)
                    .build())
                .build());
    
        }
    }
    
    resources:
      basicTool:
        type: gcp:diagflow:Tool
        name: basic_tool
        properties:
          location: global
          toolId: basic_tool_key
          toolKey: basic_tool_key
          displayName: basic-tool
          description: A basic tool with OpenAPI spec
          actionConfirmationRequirement:
            searchAction: NOT_REQUIRED
          openApiSpec:
            textSchema: |
              openapi: 3.0.0
              info:
                title: basic_tool_key
                version: 1.0.0
              paths:
                /search:
                  get:
                    summary: Search function
                    operationId: searchAction
                    responses:
                      '200':
                        description: OK
    
    terraform {
      required_providers {
        gcp = {
          source = "pulumi/gcp"
        }
      }
    }
    
    resource "gcp_diagflow_tool" "basic_tool" {
      lifecycle {
        create_before_destroy = true
      }
      location     = "global"
      tool_id      = "basic_tool_key"
      tool_key     = "basic_tool_key"
      display_name = "basic-tool"
      description  = "A basic tool with OpenAPI spec"
      action_confirmation_requirement = {
        "searchAction" = "NOT_REQUIRED"
      }
      open_api_spec = {
        text_schema = <<EOF
    openapi: 3.0.0
    info:
      title: basic_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    EOF
    
      }
    }
    

    Dialogflow Tool Connector

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const testProject = gcp.organizations.getProject({});
    const bqDataset = new gcp.bigquery.Dataset("bq_dataset", {
        datasetId: "df_tool_dataset",
        friendlyName: "test",
        description: "This is a test description",
        location: "us-central1",
        deleteContentsOnDestroy: true,
    });
    const bqTable = new gcp.bigquery.Table("bq_table", {
        deletionProtection: false,
        datasetId: bqDataset.datasetId,
        tableId: "df_tool_table",
    });
    const connectorSaDatasetPerms = new gcp.bigquery.DatasetIamMember("connector_sa_dataset_perms", {
        project: testProject.then(testProject => testProject.projectId),
        datasetId: bqDataset.datasetId,
        role: "roles/bigquery.dataEditor",
        member: testProject.then(testProject => `serviceAccount:${testProject.number}-compute@developer.gserviceaccount.com`),
    });
    const integrationConnector = new gcp.integrationconnectors.Connection("integration_connector", {
        name: "df-tool-connection",
        location: "us-central1",
        connectorVersion: testProject.then(testProject => `projects/${testProject.projectId}/locations/global/providers/gcp/connectors/bigquery/versions/1`),
        description: "tf created description",
        configVariables: [
            {
                key: "dataset_id",
                stringValue: bqDataset.datasetId,
            },
            {
                key: "project_id",
                stringValue: testProject.then(testProject => testProject.projectId),
            },
            {
                key: "support_native_data_type",
                booleanValue: false,
            },
            {
                key: "proxy_enabled",
                booleanValue: false,
            },
        ],
        serviceAccount: testProject.then(testProject => `${testProject.number}-compute@developer.gserviceaccount.com`),
        authConfig: {
            authType: "AUTH_TYPE_UNSPECIFIED",
        },
    }, {
        dependsOn: [connectorSaDatasetPerms],
    });
    const connectorTool = new gcp.diagflow.Tool("connector_tool", {
        location: "us-central1",
        toolKey: "connector_tool_key",
        displayName: "connector-tool",
        description: "A tool with Connector spec",
        connectorSpec: {
            name: pulumi.all([testProject, integrationConnector.name]).apply(([testProject, name]) => `projects/${testProject.projectId}/locations/us-central1/connections/${name}`),
            actions: [
                {
                    connectionActionId: "ExecuteCustomQuery",
                    inputFields: ["test1"],
                    outputFields: ["test1"],
                },
                {
                    entityOperation: {
                        entityId: bqTable.tableId,
                        operation: "LIST",
                    },
                },
            ],
        },
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    test_project = gcp.organizations.get_project()
    bq_dataset = gcp.bigquery.Dataset("bq_dataset",
        dataset_id="df_tool_dataset",
        friendly_name="test",
        description="This is a test description",
        location="us-central1",
        delete_contents_on_destroy=True)
    bq_table = gcp.bigquery.Table("bq_table",
        deletion_protection=False,
        dataset_id=bq_dataset.dataset_id,
        table_id="df_tool_table")
    connector_sa_dataset_perms = gcp.bigquery.DatasetIamMember("connector_sa_dataset_perms",
        project=test_project.project_id,
        dataset_id=bq_dataset.dataset_id,
        role="roles/bigquery.dataEditor",
        member=f"serviceAccount:{test_project.number}-compute@developer.gserviceaccount.com")
    integration_connector = gcp.integrationconnectors.Connection("integration_connector",
        name="df-tool-connection",
        location="us-central1",
        connector_version=f"projects/{test_project.project_id}/locations/global/providers/gcp/connectors/bigquery/versions/1",
        description="tf created description",
        config_variables=[
            {
                "key": "dataset_id",
                "string_value": bq_dataset.dataset_id,
            },
            {
                "key": "project_id",
                "string_value": test_project.project_id,
            },
            {
                "key": "support_native_data_type",
                "boolean_value": False,
            },
            {
                "key": "proxy_enabled",
                "boolean_value": False,
            },
        ],
        service_account=f"{test_project.number}-compute@developer.gserviceaccount.com",
        auth_config={
            "auth_type": "AUTH_TYPE_UNSPECIFIED",
        },
        opts = pulumi.ResourceOptions(depends_on=[connector_sa_dataset_perms]))
    connector_tool = gcp.diagflow.Tool("connector_tool",
        location="us-central1",
        tool_key="connector_tool_key",
        display_name="connector-tool",
        description="A tool with Connector spec",
        connector_spec={
            "name": integration_connector.name.apply(lambda name: f"projects/{test_project.project_id}/locations/us-central1/connections/{name}"),
            "actions": [
                {
                    "connection_action_id": "ExecuteCustomQuery",
                    "input_fields": ["test1"],
                    "output_fields": ["test1"],
                },
                {
                    "entity_operation": {
                        "entity_id": bq_table.table_id,
                        "operation": "LIST",
                    },
                },
            ],
        })
    
    package main
    
    import (
    	"fmt"
    
    	"github.com/pulumi/pulumi-gcp/sdk/v10/go/gcp/bigquery"
    	"github.com/pulumi/pulumi-gcp/sdk/v10/go/gcp/diagflow"
    	"github.com/pulumi/pulumi-gcp/sdk/v10/go/gcp/integrationconnectors"
    	"github.com/pulumi/pulumi-gcp/sdk/v10/go/gcp/organizations"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		testProject, err := organizations.LookupProject(ctx, &organizations.LookupProjectArgs{}, nil)
    		if err != nil {
    			return err
    		}
    		bqDataset, err := bigquery.NewDataset(ctx, "bq_dataset", &bigquery.DatasetArgs{
    			DatasetId:               pulumi.String("df_tool_dataset"),
    			FriendlyName:            pulumi.String("test"),
    			Description:             pulumi.String("This is a test description"),
    			Location:                pulumi.String("us-central1"),
    			DeleteContentsOnDestroy: pulumi.Bool(true),
    		})
    		if err != nil {
    			return err
    		}
    		bqTable, err := bigquery.NewTable(ctx, "bq_table", &bigquery.TableArgs{
    			DeletionProtection: pulumi.Bool(false),
    			DatasetId:          bqDataset.DatasetId,
    			TableId:            pulumi.String("df_tool_table"),
    		})
    		if err != nil {
    			return err
    		}
    		connectorSaDatasetPerms, err := bigquery.NewDatasetIamMember(ctx, "connector_sa_dataset_perms", &bigquery.DatasetIamMemberArgs{
    			Project:   pulumi.String(testProject.ProjectId),
    			DatasetId: bqDataset.DatasetId,
    			Role:      pulumi.String("roles/bigquery.dataEditor"),
    			Member:    pulumi.Sprintf("serviceAccount:%v-compute@developer.gserviceaccount.com", testProject.Number),
    		})
    		if err != nil {
    			return err
    		}
    		integrationConnector, err := integrationconnectors.NewConnection(ctx, "integration_connector", &integrationconnectors.ConnectionArgs{
    			Name:             pulumi.String("df-tool-connection"),
    			Location:         pulumi.String("us-central1"),
    			ConnectorVersion: pulumi.Sprintf("projects/%v/locations/global/providers/gcp/connectors/bigquery/versions/1", testProject.ProjectId),
    			Description:      pulumi.String("tf created description"),
    			ConfigVariables: integrationconnectors.ConnectionConfigVariableArray{
    				&integrationconnectors.ConnectionConfigVariableArgs{
    					Key:         pulumi.String("dataset_id"),
    					StringValue: bqDataset.DatasetId,
    				},
    				&integrationconnectors.ConnectionConfigVariableArgs{
    					Key:         pulumi.String("project_id"),
    					StringValue: pulumi.String(testProject.ProjectId),
    				},
    				&integrationconnectors.ConnectionConfigVariableArgs{
    					Key:          pulumi.String("support_native_data_type"),
    					BooleanValue: pulumi.Bool(false),
    				},
    				&integrationconnectors.ConnectionConfigVariableArgs{
    					Key:          pulumi.String("proxy_enabled"),
    					BooleanValue: pulumi.Bool(false),
    				},
    			},
    			ServiceAccount: pulumi.Sprintf("%v-compute@developer.gserviceaccount.com", testProject.Number),
    			AuthConfig: &integrationconnectors.ConnectionAuthConfigArgs{
    				AuthType: pulumi.String("AUTH_TYPE_UNSPECIFIED"),
    			},
    		}, pulumi.DependsOn([]pulumi.Resource{
    			connectorSaDatasetPerms,
    		}))
    		if err != nil {
    			return err
    		}
    		_, err = diagflow.NewTool(ctx, "connector_tool", &diagflow.ToolArgs{
    			Location:    pulumi.String("us-central1"),
    			ToolKey:     pulumi.String("connector_tool_key"),
    			DisplayName: pulumi.String("connector-tool"),
    			Description: pulumi.String("A tool with Connector spec"),
    			ConnectorSpec: &diagflow.ToolConnectorSpecArgs{
    				Name: integrationConnector.Name.ApplyT(func(name string) (string, error) {
    					return fmt.Sprintf("projects/%v/locations/us-central1/connections/%v", testProject.ProjectId, name), nil
    				}).(pulumi.StringOutput),
    				Actions: diagflow.ToolConnectorSpecActionArray{
    					&diagflow.ToolConnectorSpecActionArgs{
    						ConnectionActionId: pulumi.String("ExecuteCustomQuery"),
    						InputFields: pulumi.StringArray{
    							pulumi.String("test1"),
    						},
    						OutputFields: pulumi.StringArray{
    							pulumi.String("test1"),
    						},
    					},
    					&diagflow.ToolConnectorSpecActionArgs{
    						EntityOperation: &diagflow.ToolConnectorSpecActionEntityOperationArgs{
    							EntityId:  bqTable.TableId,
    							Operation: pulumi.String("LIST"),
    						},
    					},
    				},
    			},
    		})
    		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 testProject = Gcp.Organizations.GetProject.Invoke();
    
        var bqDataset = new Gcp.BigQuery.Dataset("bq_dataset", new()
        {
            DatasetId = "df_tool_dataset",
            FriendlyName = "test",
            Description = "This is a test description",
            Location = "us-central1",
            DeleteContentsOnDestroy = true,
        });
    
        var bqTable = new Gcp.BigQuery.Table("bq_table", new()
        {
            DeletionProtection = false,
            DatasetId = bqDataset.DatasetId,
            TableId = "df_tool_table",
        });
    
        var connectorSaDatasetPerms = new Gcp.BigQuery.DatasetIamMember("connector_sa_dataset_perms", new()
        {
            Project = testProject.Apply(getProjectResult => getProjectResult.ProjectId),
            DatasetId = bqDataset.DatasetId,
            Role = "roles/bigquery.dataEditor",
            Member = $"serviceAccount:{testProject.Apply(getProjectResult => getProjectResult.Number)}-compute@developer.gserviceaccount.com",
        });
    
        var integrationConnector = new Gcp.IntegrationConnectors.Connection("integration_connector", new()
        {
            Name = "df-tool-connection",
            Location = "us-central1",
            ConnectorVersion = $"projects/{testProject.Apply(getProjectResult => getProjectResult.ProjectId)}/locations/global/providers/gcp/connectors/bigquery/versions/1",
            Description = "tf created description",
            ConfigVariables = new[]
            {
                new Gcp.IntegrationConnectors.Inputs.ConnectionConfigVariableArgs
                {
                    Key = "dataset_id",
                    StringValue = bqDataset.DatasetId,
                },
                new Gcp.IntegrationConnectors.Inputs.ConnectionConfigVariableArgs
                {
                    Key = "project_id",
                    StringValue = testProject.Apply(getProjectResult => getProjectResult.ProjectId),
                },
                new Gcp.IntegrationConnectors.Inputs.ConnectionConfigVariableArgs
                {
                    Key = "support_native_data_type",
                    BooleanValue = false,
                },
                new Gcp.IntegrationConnectors.Inputs.ConnectionConfigVariableArgs
                {
                    Key = "proxy_enabled",
                    BooleanValue = false,
                },
            },
            ServiceAccount = $"{testProject.Apply(getProjectResult => getProjectResult.Number)}-compute@developer.gserviceaccount.com",
            AuthConfig = new Gcp.IntegrationConnectors.Inputs.ConnectionAuthConfigArgs
            {
                AuthType = "AUTH_TYPE_UNSPECIFIED",
            },
        }, new CustomResourceOptions
        {
            DependsOn =
            {
                connectorSaDatasetPerms,
            },
        });
    
        var connectorTool = new Gcp.Diagflow.Tool("connector_tool", new()
        {
            Location = "us-central1",
            ToolKey = "connector_tool_key",
            DisplayName = "connector-tool",
            Description = "A tool with Connector spec",
            ConnectorSpec = new Gcp.Diagflow.Inputs.ToolConnectorSpecArgs
            {
                Name = Output.Tuple(testProject, integrationConnector.Name).Apply(values =>
                {
                    var testProject = values.Item1;
                    var name = values.Item2;
                    return $"projects/{testProject.Apply(getProjectResult => getProjectResult.ProjectId)}/locations/us-central1/connections/{name}";
                }),
                Actions = new[]
                {
                    new Gcp.Diagflow.Inputs.ToolConnectorSpecActionArgs
                    {
                        ConnectionActionId = "ExecuteCustomQuery",
                        InputFields = new[]
                        {
                            "test1",
                        },
                        OutputFields = new[]
                        {
                            "test1",
                        },
                    },
                    new Gcp.Diagflow.Inputs.ToolConnectorSpecActionArgs
                    {
                        EntityOperation = new Gcp.Diagflow.Inputs.ToolConnectorSpecActionEntityOperationArgs
                        {
                            EntityId = bqTable.TableId,
                            Operation = "LIST",
                        },
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.organizations.OrganizationsFunctions;
    import com.pulumi.gcp.organizations.inputs.GetProjectArgs;
    import com.pulumi.gcp.bigquery.Dataset;
    import com.pulumi.gcp.bigquery.DatasetArgs;
    import com.pulumi.gcp.bigquery.Table;
    import com.pulumi.gcp.bigquery.TableArgs;
    import com.pulumi.gcp.bigquery.DatasetIamMember;
    import com.pulumi.gcp.bigquery.DatasetIamMemberArgs;
    import com.pulumi.gcp.integrationconnectors.Connection;
    import com.pulumi.gcp.integrationconnectors.ConnectionArgs;
    import com.pulumi.gcp.integrationconnectors.inputs.ConnectionConfigVariableArgs;
    import com.pulumi.gcp.integrationconnectors.inputs.ConnectionAuthConfigArgs;
    import com.pulumi.gcp.diagflow.Tool;
    import com.pulumi.gcp.diagflow.ToolArgs;
    import com.pulumi.gcp.diagflow.inputs.ToolConnectorSpecArgs;
    import com.pulumi.gcp.diagflow.inputs.ToolConnectorSpecActionArgs;
    import com.pulumi.gcp.diagflow.inputs.ToolConnectorSpecActionEntityOperationArgs;
    import com.pulumi.resources.CustomResourceOptions;
    import java.util.ArrayList;
    import java.util.Arrays;
    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) {
            final var testProject = OrganizationsFunctions.getProject(GetProjectArgs.builder()
                .build());
    
            var bqDataset = new Dataset("bqDataset", DatasetArgs.builder()
                .datasetId("df_tool_dataset")
                .friendlyName("test")
                .description("This is a test description")
                .location("us-central1")
                .deleteContentsOnDestroy(true)
                .build());
    
            var bqTable = new Table("bqTable", TableArgs.builder()
                .deletionProtection(false)
                .datasetId(bqDataset.datasetId())
                .tableId("df_tool_table")
                .build());
    
            var connectorSaDatasetPerms = new DatasetIamMember("connectorSaDatasetPerms", DatasetIamMemberArgs.builder()
                .project(testProject.projectId())
                .datasetId(bqDataset.datasetId())
                .role("roles/bigquery.dataEditor")
                .member(String.format("serviceAccount:%s-compute@developer.gserviceaccount.com", testProject.number()))
                .build());
    
            var integrationConnector = new Connection("integrationConnector", ConnectionArgs.builder()
                .name("df-tool-connection")
                .location("us-central1")
                .connectorVersion(String.format("projects/%s/locations/global/providers/gcp/connectors/bigquery/versions/1", testProject.projectId()))
                .description("tf created description")
                .configVariables(            
                    ConnectionConfigVariableArgs.builder()
                        .key("dataset_id")
                        .stringValue(bqDataset.datasetId())
                        .build(),
                    ConnectionConfigVariableArgs.builder()
                        .key("project_id")
                        .stringValue(testProject.projectId())
                        .build(),
                    ConnectionConfigVariableArgs.builder()
                        .key("support_native_data_type")
                        .booleanValue(false)
                        .build(),
                    ConnectionConfigVariableArgs.builder()
                        .key("proxy_enabled")
                        .booleanValue(false)
                        .build())
                .serviceAccount(String.format("%s-compute@developer.gserviceaccount.com", testProject.number()))
                .authConfig(ConnectionAuthConfigArgs.builder()
                    .authType("AUTH_TYPE_UNSPECIFIED")
                    .build())
                .build(), CustomResourceOptions.builder()
                    .dependsOn(connectorSaDatasetPerms)
                    .build());
    
            var connectorTool = new Tool("connectorTool", ToolArgs.builder()
                .location("us-central1")
                .toolKey("connector_tool_key")
                .displayName("connector-tool")
                .description("A tool with Connector spec")
                .connectorSpec(ToolConnectorSpecArgs.builder()
                    .name(integrationConnector.name().applyValue(_name -> String.format("projects/%s/locations/us-central1/connections/%s", testProject.projectId(),_name)))
                    .actions(                
                        ToolConnectorSpecActionArgs.builder()
                            .connectionActionId("ExecuteCustomQuery")
                            .inputFields("test1")
                            .outputFields("test1")
                            .build(),
                        ToolConnectorSpecActionArgs.builder()
                            .entityOperation(ToolConnectorSpecActionEntityOperationArgs.builder()
                                .entityId(bqTable.tableId())
                                .operation("LIST")
                                .build())
                            .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      bqDataset:
        type: gcp:bigquery:Dataset
        name: bq_dataset
        properties:
          datasetId: df_tool_dataset
          friendlyName: test
          description: This is a test description
          location: us-central1
          deleteContentsOnDestroy: true
      bqTable:
        type: gcp:bigquery:Table
        name: bq_table
        properties:
          deletionProtection: false
          datasetId: ${bqDataset.datasetId}
          tableId: df_tool_table
      connectorSaDatasetPerms:
        type: gcp:bigquery:DatasetIamMember
        name: connector_sa_dataset_perms
        properties:
          project: ${testProject.projectId}
          datasetId: ${bqDataset.datasetId}
          role: roles/bigquery.dataEditor
          member: serviceAccount:${testProject.number}-compute@developer.gserviceaccount.com
      integrationConnector:
        type: gcp:integrationconnectors:Connection
        name: integration_connector
        properties:
          name: df-tool-connection
          location: us-central1
          connectorVersion: projects/${testProject.projectId}/locations/global/providers/gcp/connectors/bigquery/versions/1
          description: tf created description
          configVariables:
            - key: dataset_id
              stringValue: ${bqDataset.datasetId}
            - key: project_id
              stringValue: ${testProject.projectId}
            - key: support_native_data_type
              booleanValue: false
            - key: proxy_enabled
              booleanValue: false
          serviceAccount: ${testProject.number}-compute@developer.gserviceaccount.com
          authConfig:
            authType: AUTH_TYPE_UNSPECIFIED
        options:
          dependsOn:
            - ${connectorSaDatasetPerms}
      connectorTool:
        type: gcp:diagflow:Tool
        name: connector_tool
        properties:
          location: us-central1
          toolKey: connector_tool_key
          displayName: connector-tool
          description: A tool with Connector spec
          connectorSpec:
            name: projects/${testProject.projectId}/locations/us-central1/connections/${integrationConnector.name}
            actions:
              - connectionActionId: ExecuteCustomQuery
                inputFields:
                  - test1
                outputFields:
                  - test1
              - entityOperation:
                  entityId: ${bqTable.tableId}
                  operation: LIST
    variables:
      testProject:
        fn::invoke:
          function: gcp:organizations:getProject
          arguments: {}
    
    terraform {
      required_providers {
        gcp = {
          source = "pulumi/gcp"
        }
      }
    }
    
    data "gcp_organizations_project" "testProject" {
    }
    
    resource "gcp_bigquery_dataset" "bq_dataset" {
      lifecycle {
        create_before_destroy = true
      }
      dataset_id                 = "df_tool_dataset"
      friendly_name              = "test"
      description                = "This is a test description"
      location                   = "us-central1"
      delete_contents_on_destroy = true
    }
    resource "gcp_bigquery_table" "bq_table" {
      lifecycle {
        create_before_destroy = true
      }
      deletion_protection = false
      dataset_id          = gcp_bigquery_dataset.bq_dataset.dataset_id
      table_id            = "df_tool_table"
    }
    resource "gcp_bigquery_dataset_iam_member" "connector_sa_dataset_perms" {
      lifecycle {
        create_before_destroy = true
      }
      project    = data.gcp_organizations_project.testProject.project_id
      dataset_id = gcp_bigquery_dataset.bq_dataset.dataset_id
      role       = "roles/bigquery.dataEditor"
      member     ="serviceAccount:${data.gcp_organizations_project.testProject.number}-compute@developer.gserviceaccount.com"
    }
    resource "gcp_integrationconnectors_connection" "integration_connector" {
      depends_on = [gcp_bigquery_dataset_iam_member.connector_sa_dataset_perms]
      lifecycle {
        create_before_destroy = true
      }
      name              = "df-tool-connection"
      location          = "us-central1"
      connector_version ="projects/${data.gcp_organizations_project.testProject.project_id}/locations/global/providers/gcp/connectors/bigquery/versions/1"
      description       = "tf created description"
      config_variables {
        key          = "dataset_id"
        string_value = gcp_bigquery_dataset.bq_dataset.dataset_id
      }
      config_variables {
        key          = "project_id"
        string_value = data.gcp_organizations_project.testProject.project_id
      }
      config_variables {
        key           = "support_native_data_type"
        boolean_value = false
      }
      config_variables {
        key           = "proxy_enabled"
        boolean_value = false
      }
      service_account ="${data.gcp_organizations_project.testProject.number}-compute@developer.gserviceaccount.com"
      auth_config = {
        auth_type = "AUTH_TYPE_UNSPECIFIED"
      }
    }
    resource "gcp_diagflow_tool" "connector_tool" {
      lifecycle {
        create_before_destroy = true
      }
      location     = "us-central1"
      tool_key     = "connector_tool_key"
      display_name = "connector-tool"
      description  = "A tool with Connector spec"
      connector_spec = {
        name ="projects/${data.gcp_organizations_project.testProject.project_id}/locations/us-central1/connections/${gcp_integrationconnectors_connection.integration_connector.name}"
        actions = [{
          connection_action_id = "ExecuteCustomQuery"
          input_fields         = ["test1"]
          output_fields        = ["test1"]
          }, {
          entity_operation = {
            entity_id = gcp_bigquery_table.bq_table.table_id
            operation = "LIST"
          }
        }]
      }
    }
    

    Dialogflow Tool Function

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const functionTool = new gcp.diagflow.Tool("function_tool", {
        location: "global",
        toolKey: "function_tool_key",
        displayName: "function-tool",
        description: "A tool with Function spec",
        functionSpec: {
            methodType: "GET",
            inputSchema: JSON.stringify({
                type: "object",
                properties: {
                    param1: {
                        type: "string",
                    },
                },
            }),
            outputSchema: JSON.stringify({
                type: "object",
                properties: {
                    result: {
                        type: "string",
                    },
                },
            }),
        },
    });
    
    import pulumi
    import json
    import pulumi_gcp as gcp
    
    function_tool = gcp.diagflow.Tool("function_tool",
        location="global",
        tool_key="function_tool_key",
        display_name="function-tool",
        description="A tool with Function spec",
        function_spec={
            "method_type": "GET",
            "input_schema": json.dumps({
                "type": "object",
                "properties": {
                    "param1": {
                        "type": "string",
                    },
                },
            }),
            "output_schema": json.dumps({
                "type": "object",
                "properties": {
                    "result": {
                        "type": "string",
                    },
                },
            }),
        })
    
    package main
    
    import (
    	"encoding/json"
    
    	"github.com/pulumi/pulumi-gcp/sdk/v10/go/gcp/diagflow"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		tmpJSON0, err := json.Marshal(map[string]interface{}{
    			"type": "object",
    			"properties": map[string]map[string]string{
    				"param1": map[string]string{
    					"type": "string",
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		json0 := string(tmpJSON0)
    		tmpJSON1, err := json.Marshal(map[string]interface{}{
    			"type": "object",
    			"properties": map[string]map[string]string{
    				"result": map[string]string{
    					"type": "string",
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		json1 := string(tmpJSON1)
    		_, err = diagflow.NewTool(ctx, "function_tool", &diagflow.ToolArgs{
    			Location:    pulumi.String("global"),
    			ToolKey:     pulumi.String("function_tool_key"),
    			DisplayName: pulumi.String("function-tool"),
    			Description: pulumi.String("A tool with Function spec"),
    			FunctionSpec: &diagflow.ToolFunctionSpecArgs{
    				MethodType:   pulumi.String("GET"),
    				InputSchema:  pulumi.String(json0),
    				OutputSchema: pulumi.String(json1),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using System.Text.Json;
    using Pulumi;
    using Gcp = Pulumi.Gcp;
    
    return await Deployment.RunAsync(() => 
    {
        var functionTool = new Gcp.Diagflow.Tool("function_tool", new()
        {
            Location = "global",
            ToolKey = "function_tool_key",
            DisplayName = "function-tool",
            Description = "A tool with Function spec",
            FunctionSpec = new Gcp.Diagflow.Inputs.ToolFunctionSpecArgs
            {
                MethodType = "GET",
                InputSchema = JsonSerializer.Serialize(new Dictionary<string, object?>
                {
                    ["type"] = "object",
                    ["properties"] = new Dictionary<string, object?>
                    {
                        ["param1"] = new Dictionary<string, object?>
                        {
                            ["type"] = "string",
                        },
                    },
                }),
                OutputSchema = JsonSerializer.Serialize(new Dictionary<string, object?>
                {
                    ["type"] = "object",
                    ["properties"] = new Dictionary<string, object?>
                    {
                        ["result"] = new Dictionary<string, object?>
                        {
                            ["type"] = "string",
                        },
                    },
                }),
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.diagflow.Tool;
    import com.pulumi.gcp.diagflow.ToolArgs;
    import com.pulumi.gcp.diagflow.inputs.ToolFunctionSpecArgs;
    import static com.pulumi.codegen.internal.Serialization.*;
    import java.util.ArrayList;
    import java.util.Arrays;
    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 functionTool = new Tool("functionTool", ToolArgs.builder()
                .location("global")
                .toolKey("function_tool_key")
                .displayName("function-tool")
                .description("A tool with Function spec")
                .functionSpec(ToolFunctionSpecArgs.builder()
                    .methodType("GET")
                    .inputSchema(serializeJson(
                        jsonObject(
                            jsonProperty("type", "object"),
                            jsonProperty("properties", jsonObject(
                                jsonProperty("param1", jsonObject(
                                    jsonProperty("type", "string")
                                ))
                            ))
                        )))
                    .outputSchema(serializeJson(
                        jsonObject(
                            jsonProperty("type", "object"),
                            jsonProperty("properties", jsonObject(
                                jsonProperty("result", jsonObject(
                                    jsonProperty("type", "string")
                                ))
                            ))
                        )))
                    .build())
                .build());
    
        }
    }
    
    resources:
      functionTool:
        type: gcp:diagflow:Tool
        name: function_tool
        properties:
          location: global
          toolKey: function_tool_key
          displayName: function-tool
          description: A tool with Function spec
          functionSpec:
            methodType: GET
            inputSchema:
              fn::toJSON:
                type: object
                properties:
                  param1:
                    type: string
            outputSchema:
              fn::toJSON:
                type: object
                properties:
                  result:
                    type: string
    
    terraform {
      required_providers {
        gcp = {
          source = "pulumi/gcp"
        }
      }
    }
    
    resource "gcp_diagflow_tool" "function_tool" {
      lifecycle {
        create_before_destroy = true
      }
      location     = "global"
      tool_key     = "function_tool_key"
      display_name = "function-tool"
      description  = "A tool with Function spec"
      function_spec = {
        method_type = "GET"
        input_schema = jsonencode({
          "type" = "object"
          "properties" = {
            "param1" = {
              "type" = "string"
            }
          }
        })
        output_schema = jsonencode({
          "type" = "object"
          "properties" = {
            "result" = {
              "type" = "string"
            }
          }
        })
      }
    }
    

    Dialogflow Tool Auth

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const authTool = new gcp.diagflow.Tool("auth_tool", {
        location: "global",
        toolKey: "auth_tool_key",
        displayName: "auth-tool",
        description: "A tool with OpenAPI spec and API Key Auth",
        openApiSpec: {
            textSchema: `openapi: 3.0.0
    info:
      title: auth_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    `,
            authentication: {
                apiKeyConfig: {
                    keyName: "X-API-KEY",
                    apiKey: "secret-key",
                    secretVersionForApiKey: "projects/-/secrets/-/versions/-",
                    requestLocation: "HEADER",
                },
            },
        },
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    auth_tool = gcp.diagflow.Tool("auth_tool",
        location="global",
        tool_key="auth_tool_key",
        display_name="auth-tool",
        description="A tool with OpenAPI spec and API Key Auth",
        open_api_spec={
            "text_schema": """openapi: 3.0.0
    info:
      title: auth_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    """,
            "authentication": {
                "api_key_config": {
                    "key_name": "X-API-KEY",
                    "api_key": "secret-key",
                    "secret_version_for_api_key": "projects/-/secrets/-/versions/-",
                    "request_location": "HEADER",
                },
            },
        })
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v10/go/gcp/diagflow"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := diagflow.NewTool(ctx, "auth_tool", &diagflow.ToolArgs{
    			Location:    pulumi.String("global"),
    			ToolKey:     pulumi.String("auth_tool_key"),
    			DisplayName: pulumi.String("auth-tool"),
    			Description: pulumi.String("A tool with OpenAPI spec and API Key Auth"),
    			OpenApiSpec: &diagflow.ToolOpenApiSpecArgs{
    				TextSchema: pulumi.String(`openapi: 3.0.0
    info:
      title: auth_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    `),
    				Authentication: &diagflow.ToolOpenApiSpecAuthenticationArgs{
    					ApiKeyConfig: &diagflow.ToolOpenApiSpecAuthenticationApiKeyConfigArgs{
    						KeyName:                pulumi.String("X-API-KEY"),
    						ApiKey:                 pulumi.String("secret-key"),
    						SecretVersionForApiKey: pulumi.String("projects/-/secrets/-/versions/-"),
    						RequestLocation:        pulumi.String("HEADER"),
    					},
    				},
    			},
    		})
    		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 authTool = new Gcp.Diagflow.Tool("auth_tool", new()
        {
            Location = "global",
            ToolKey = "auth_tool_key",
            DisplayName = "auth-tool",
            Description = "A tool with OpenAPI spec and API Key Auth",
            OpenApiSpec = new Gcp.Diagflow.Inputs.ToolOpenApiSpecArgs
            {
                TextSchema = @"openapi: 3.0.0
    info:
      title: auth_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    ",
                Authentication = new Gcp.Diagflow.Inputs.ToolOpenApiSpecAuthenticationArgs
                {
                    ApiKeyConfig = new Gcp.Diagflow.Inputs.ToolOpenApiSpecAuthenticationApiKeyConfigArgs
                    {
                        KeyName = "X-API-KEY",
                        ApiKey = "secret-key",
                        SecretVersionForApiKey = "projects/-/secrets/-/versions/-",
                        RequestLocation = "HEADER",
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.diagflow.Tool;
    import com.pulumi.gcp.diagflow.ToolArgs;
    import com.pulumi.gcp.diagflow.inputs.ToolOpenApiSpecArgs;
    import com.pulumi.gcp.diagflow.inputs.ToolOpenApiSpecAuthenticationArgs;
    import com.pulumi.gcp.diagflow.inputs.ToolOpenApiSpecAuthenticationApiKeyConfigArgs;
    import java.util.ArrayList;
    import java.util.Arrays;
    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 authTool = new Tool("authTool", ToolArgs.builder()
                .location("global")
                .toolKey("auth_tool_key")
                .displayName("auth-tool")
                .description("A tool with OpenAPI spec and API Key Auth")
                .openApiSpec(ToolOpenApiSpecArgs.builder()
                    .textSchema("""
    openapi: 3.0.0
    info:
      title: auth_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
                    """)
                    .authentication(ToolOpenApiSpecAuthenticationArgs.builder()
                        .apiKeyConfig(ToolOpenApiSpecAuthenticationApiKeyConfigArgs.builder()
                            .keyName("X-API-KEY")
                            .apiKey("secret-key")
                            .secretVersionForApiKey("projects/-/secrets/-/versions/-")
                            .requestLocation("HEADER")
                            .build())
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      authTool:
        type: gcp:diagflow:Tool
        name: auth_tool
        properties:
          location: global
          toolKey: auth_tool_key
          displayName: auth-tool
          description: A tool with OpenAPI spec and API Key Auth
          openApiSpec:
            textSchema: |
              openapi: 3.0.0
              info:
                title: auth_tool_key
                version: 1.0.0
              paths:
                /search:
                  get:
                    summary: Search function
                    operationId: searchAction
                    responses:
                      '200':
                        description: OK
            authentication:
              apiKeyConfig:
                keyName: X-API-KEY
                apiKey: secret-key
                secretVersionForApiKey: projects/-/secrets/-/versions/-
                requestLocation: HEADER
    
    terraform {
      required_providers {
        gcp = {
          source = "pulumi/gcp"
        }
      }
    }
    
    resource "gcp_diagflow_tool" "auth_tool" {
      lifecycle {
        create_before_destroy = true
      }
      location     = "global"
      tool_key     = "auth_tool_key"
      display_name = "auth-tool"
      description  = "A tool with OpenAPI spec and API Key Auth"
      open_api_spec = {
        text_schema = <<EOF
    openapi: 3.0.0
    info:
      title: auth_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    EOF
    
        authentication = {
          api_key_config = {
            key_name                   = "X-API-KEY"
            api_key                    = "secret-key"
            secret_version_for_api_key = "projects/-/secrets/-/versions/-"
            request_location           = "HEADER"
          }
        }
      }
    }
    

    Dialogflow Tool Bearer

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const bearerTool = new gcp.diagflow.Tool("bearer_tool", {
        location: "global",
        toolKey: "bearer_token_tool_key",
        displayName: "bearer-tool",
        description: "A tool with OpenAPI spec and Bearer Token Auth",
        openApiSpec: {
            textSchema: `openapi: 3.0.0
    info:
      title: bearer_token_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    `,
            authentication: {
                bearerTokenConfig: {
                    token: "secret-token",
                    secretVersionForToken: "projects/-/secrets/-/versions/-",
                },
            },
        },
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    bearer_tool = gcp.diagflow.Tool("bearer_tool",
        location="global",
        tool_key="bearer_token_tool_key",
        display_name="bearer-tool",
        description="A tool with OpenAPI spec and Bearer Token Auth",
        open_api_spec={
            "text_schema": """openapi: 3.0.0
    info:
      title: bearer_token_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    """,
            "authentication": {
                "bearer_token_config": {
                    "token": "secret-token",
                    "secret_version_for_token": "projects/-/secrets/-/versions/-",
                },
            },
        })
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v10/go/gcp/diagflow"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := diagflow.NewTool(ctx, "bearer_tool", &diagflow.ToolArgs{
    			Location:    pulumi.String("global"),
    			ToolKey:     pulumi.String("bearer_token_tool_key"),
    			DisplayName: pulumi.String("bearer-tool"),
    			Description: pulumi.String("A tool with OpenAPI spec and Bearer Token Auth"),
    			OpenApiSpec: &diagflow.ToolOpenApiSpecArgs{
    				TextSchema: pulumi.String(`openapi: 3.0.0
    info:
      title: bearer_token_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    `),
    				Authentication: &diagflow.ToolOpenApiSpecAuthenticationArgs{
    					BearerTokenConfig: &diagflow.ToolOpenApiSpecAuthenticationBearerTokenConfigArgs{
    						Token:                 pulumi.String("secret-token"),
    						SecretVersionForToken: pulumi.String("projects/-/secrets/-/versions/-"),
    					},
    				},
    			},
    		})
    		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 bearerTool = new Gcp.Diagflow.Tool("bearer_tool", new()
        {
            Location = "global",
            ToolKey = "bearer_token_tool_key",
            DisplayName = "bearer-tool",
            Description = "A tool with OpenAPI spec and Bearer Token Auth",
            OpenApiSpec = new Gcp.Diagflow.Inputs.ToolOpenApiSpecArgs
            {
                TextSchema = @"openapi: 3.0.0
    info:
      title: bearer_token_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    ",
                Authentication = new Gcp.Diagflow.Inputs.ToolOpenApiSpecAuthenticationArgs
                {
                    BearerTokenConfig = new Gcp.Diagflow.Inputs.ToolOpenApiSpecAuthenticationBearerTokenConfigArgs
                    {
                        Token = "secret-token",
                        SecretVersionForToken = "projects/-/secrets/-/versions/-",
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.diagflow.Tool;
    import com.pulumi.gcp.diagflow.ToolArgs;
    import com.pulumi.gcp.diagflow.inputs.ToolOpenApiSpecArgs;
    import com.pulumi.gcp.diagflow.inputs.ToolOpenApiSpecAuthenticationArgs;
    import com.pulumi.gcp.diagflow.inputs.ToolOpenApiSpecAuthenticationBearerTokenConfigArgs;
    import java.util.ArrayList;
    import java.util.Arrays;
    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 bearerTool = new Tool("bearerTool", ToolArgs.builder()
                .location("global")
                .toolKey("bearer_token_tool_key")
                .displayName("bearer-tool")
                .description("A tool with OpenAPI spec and Bearer Token Auth")
                .openApiSpec(ToolOpenApiSpecArgs.builder()
                    .textSchema("""
    openapi: 3.0.0
    info:
      title: bearer_token_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
                    """)
                    .authentication(ToolOpenApiSpecAuthenticationArgs.builder()
                        .bearerTokenConfig(ToolOpenApiSpecAuthenticationBearerTokenConfigArgs.builder()
                            .token("secret-token")
                            .secretVersionForToken("projects/-/secrets/-/versions/-")
                            .build())
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      bearerTool:
        type: gcp:diagflow:Tool
        name: bearer_tool
        properties:
          location: global
          toolKey: bearer_token_tool_key
          displayName: bearer-tool
          description: A tool with OpenAPI spec and Bearer Token Auth
          openApiSpec:
            textSchema: |
              openapi: 3.0.0
              info:
                title: bearer_token_tool_key
                version: 1.0.0
              paths:
                /search:
                  get:
                    summary: Search function
                    operationId: searchAction
                    responses:
                      '200':
                        description: OK
            authentication:
              bearerTokenConfig:
                token: secret-token
                secretVersionForToken: projects/-/secrets/-/versions/-
    
    terraform {
      required_providers {
        gcp = {
          source = "pulumi/gcp"
        }
      }
    }
    
    resource "gcp_diagflow_tool" "bearer_tool" {
      lifecycle {
        create_before_destroy = true
      }
      location     = "global"
      tool_key     = "bearer_token_tool_key"
      display_name = "bearer-tool"
      description  = "A tool with OpenAPI spec and Bearer Token Auth"
      open_api_spec = {
        text_schema = <<EOF
    openapi: 3.0.0
    info:
      title: bearer_token_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    EOF
    
        authentication = {
          bearer_token_config = {
            token                    = "secret-token"
            secret_version_for_token = "projects/-/secrets/-/versions/-"
          }
        }
      }
    }
    

    Dialogflow Tool Oauth

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    import * as std from "@pulumi/std";
    
    const oauthTool = new gcp.diagflow.Tool("oauth_tool", {
        location: "global",
        toolKey: "oauth_tool_key",
        displayName: "oauth-tool",
        description: "A tool with OpenAPI spec and OAuth Config",
        openApiSpec: {
            textSchema: `openapi: 3.0.0
    info:
      title: oauth_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    `,
            authentication: {
                oauthConfig: {
                    clientId: "client-id",
                    clientSecret: "client-secret",
                    secretVersionForClientSecret: "projects/-/secrets/-/versions/-",
                    oauthGrantType: "CLIENT_CREDENTIAL",
                    tokenEndpoint: "https://example.com/oauth/token",
                    scopes: [
                        "scope1",
                        "scope2",
                    ],
                },
            },
            tlsConfig: {
                caCerts: [{
                    displayName: "example ca cert name",
                    cert: std.base64encode({
                        input: "example cert",
                    }).then(invoke => invoke.result),
                }],
            },
            serviceDirectoryConfig: {
                service: "projects/-/locations/-/namespaces/-/services/-",
            },
        },
    });
    
    import pulumi
    import pulumi_gcp as gcp
    import pulumi_std as std
    
    oauth_tool = gcp.diagflow.Tool("oauth_tool",
        location="global",
        tool_key="oauth_tool_key",
        display_name="oauth-tool",
        description="A tool with OpenAPI spec and OAuth Config",
        open_api_spec={
            "text_schema": """openapi: 3.0.0
    info:
      title: oauth_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    """,
            "authentication": {
                "oauth_config": {
                    "client_id": "client-id",
                    "client_secret": "client-secret",
                    "secret_version_for_client_secret": "projects/-/secrets/-/versions/-",
                    "oauth_grant_type": "CLIENT_CREDENTIAL",
                    "token_endpoint": "https://example.com/oauth/token",
                    "scopes": [
                        "scope1",
                        "scope2",
                    ],
                },
            },
            "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/-",
            },
        })
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v10/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 {
    		invokeBase64encode, err := std.Base64encode(ctx, &std.Base64encodeArgs{
    			Input: "example cert",
    		}, nil)
    		if err != nil {
    			return err
    		}
    		_, err = diagflow.NewTool(ctx, "oauth_tool", &diagflow.ToolArgs{
    			Location:    pulumi.String("global"),
    			ToolKey:     pulumi.String("oauth_tool_key"),
    			DisplayName: pulumi.String("oauth-tool"),
    			Description: pulumi.String("A tool with OpenAPI spec and OAuth Config"),
    			OpenApiSpec: &diagflow.ToolOpenApiSpecArgs{
    				TextSchema: pulumi.String(`openapi: 3.0.0
    info:
      title: oauth_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    `),
    				Authentication: &diagflow.ToolOpenApiSpecAuthenticationArgs{
    					OauthConfig: &diagflow.ToolOpenApiSpecAuthenticationOauthConfigArgs{
    						ClientId:                     pulumi.String("client-id"),
    						ClientSecret:                 pulumi.String("client-secret"),
    						SecretVersionForClientSecret: pulumi.String("projects/-/secrets/-/versions/-"),
    						OauthGrantType:               pulumi.String("CLIENT_CREDENTIAL"),
    						TokenEndpoint:                pulumi.String("https://example.com/oauth/token"),
    						Scopes: pulumi.StringArray{
    							pulumi.String("scope1"),
    							pulumi.String("scope2"),
    						},
    					},
    				},
    				TlsConfig: &diagflow.ToolOpenApiSpecTlsConfigArgs{
    					CaCerts: diagflow.ToolOpenApiSpecTlsConfigCaCertArray{
    						&diagflow.ToolOpenApiSpecTlsConfigCaCertArgs{
    							DisplayName: pulumi.String("example ca cert name"),
    							Cert:        pulumi.String(invokeBase64encode.Result),
    						},
    					},
    				},
    				ServiceDirectoryConfig: &diagflow.ToolOpenApiSpecServiceDirectoryConfigArgs{
    					Service: pulumi.String("projects/-/locations/-/namespaces/-/services/-"),
    				},
    			},
    		})
    		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 oauthTool = new Gcp.Diagflow.Tool("oauth_tool", new()
        {
            Location = "global",
            ToolKey = "oauth_tool_key",
            DisplayName = "oauth-tool",
            Description = "A tool with OpenAPI spec and OAuth Config",
            OpenApiSpec = new Gcp.Diagflow.Inputs.ToolOpenApiSpecArgs
            {
                TextSchema = @"openapi: 3.0.0
    info:
      title: oauth_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    ",
                Authentication = new Gcp.Diagflow.Inputs.ToolOpenApiSpecAuthenticationArgs
                {
                    OauthConfig = new Gcp.Diagflow.Inputs.ToolOpenApiSpecAuthenticationOauthConfigArgs
                    {
                        ClientId = "client-id",
                        ClientSecret = "client-secret",
                        SecretVersionForClientSecret = "projects/-/secrets/-/versions/-",
                        OauthGrantType = "CLIENT_CREDENTIAL",
                        TokenEndpoint = "https://example.com/oauth/token",
                        Scopes = new[]
                        {
                            "scope1",
                            "scope2",
                        },
                    },
                },
                TlsConfig = new Gcp.Diagflow.Inputs.ToolOpenApiSpecTlsConfigArgs
                {
                    CaCerts = new[]
                    {
                        new Gcp.Diagflow.Inputs.ToolOpenApiSpecTlsConfigCaCertArgs
                        {
                            DisplayName = "example ca cert name",
                            Cert = Std.Base64encode.Invoke(new()
                            {
                                Input = "example cert",
                            }).Apply(invoke => invoke.Result),
                        },
                    },
                },
                ServiceDirectoryConfig = new Gcp.Diagflow.Inputs.ToolOpenApiSpecServiceDirectoryConfigArgs
                {
                    Service = "projects/-/locations/-/namespaces/-/services/-",
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.diagflow.Tool;
    import com.pulumi.gcp.diagflow.ToolArgs;
    import com.pulumi.gcp.diagflow.inputs.ToolOpenApiSpecArgs;
    import com.pulumi.gcp.diagflow.inputs.ToolOpenApiSpecAuthenticationArgs;
    import com.pulumi.gcp.diagflow.inputs.ToolOpenApiSpecAuthenticationOauthConfigArgs;
    import com.pulumi.gcp.diagflow.inputs.ToolOpenApiSpecTlsConfigArgs;
    import com.pulumi.gcp.diagflow.inputs.ToolOpenApiSpecTlsConfigCaCertArgs;
    import com.pulumi.gcp.diagflow.inputs.ToolOpenApiSpecServiceDirectoryConfigArgs;
    import com.pulumi.std.StdFunctions;
    import com.pulumi.std.inputs.Base64encodeArgs;
    import java.util.ArrayList;
    import java.util.Arrays;
    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 oauthTool = new Tool("oauthTool", ToolArgs.builder()
                .location("global")
                .toolKey("oauth_tool_key")
                .displayName("oauth-tool")
                .description("A tool with OpenAPI spec and OAuth Config")
                .openApiSpec(ToolOpenApiSpecArgs.builder()
                    .textSchema("""
    openapi: 3.0.0
    info:
      title: oauth_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
                    """)
                    .authentication(ToolOpenApiSpecAuthenticationArgs.builder()
                        .oauthConfig(ToolOpenApiSpecAuthenticationOauthConfigArgs.builder()
                            .clientId("client-id")
                            .clientSecret("client-secret")
                            .secretVersionForClientSecret("projects/-/secrets/-/versions/-")
                            .oauthGrantType("CLIENT_CREDENTIAL")
                            .tokenEndpoint("https://example.com/oauth/token")
                            .scopes(                        
                                "scope1",
                                "scope2")
                            .build())
                        .build())
                    .tlsConfig(ToolOpenApiSpecTlsConfigArgs.builder()
                        .caCerts(ToolOpenApiSpecTlsConfigCaCertArgs.builder()
                            .displayName("example ca cert name")
                            .cert(StdFunctions.base64encode(Base64encodeArgs.builder()
                                .input("example cert")
                                .build()).result())
                            .build())
                        .build())
                    .serviceDirectoryConfig(ToolOpenApiSpecServiceDirectoryConfigArgs.builder()
                        .service("projects/-/locations/-/namespaces/-/services/-")
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      oauthTool:
        type: gcp:diagflow:Tool
        name: oauth_tool
        properties:
          location: global
          toolKey: oauth_tool_key
          displayName: oauth-tool
          description: A tool with OpenAPI spec and OAuth Config
          openApiSpec:
            textSchema: |
              openapi: 3.0.0
              info:
                title: oauth_tool_key
                version: 1.0.0
              paths:
                /search:
                  get:
                    summary: Search function
                    operationId: searchAction
                    responses:
                      '200':
                        description: OK
            authentication:
              oauthConfig:
                clientId: client-id
                clientSecret: client-secret
                secretVersionForClientSecret: projects/-/secrets/-/versions/-
                oauthGrantType: CLIENT_CREDENTIAL
                tokenEndpoint: https://example.com/oauth/token
                scopes:
                  - scope1
                  - scope2
            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/-
    
    terraform {
      required_providers {
        gcp = {
          source = "pulumi/gcp"
        }
        std = {
          source = "pulumi/std"
        }
      }
    }
    
    resource "gcp_diagflow_tool" "oauth_tool" {
      lifecycle {
        create_before_destroy = true
      }
      location     = "global"
      tool_key     = "oauth_tool_key"
      display_name = "oauth-tool"
      description  = "A tool with OpenAPI spec and OAuth Config"
      open_api_spec = {
        text_schema = <<EOF
    openapi: 3.0.0
    info:
      title: oauth_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    EOF
    
        authentication = {
          oauth_config = {
            client_id                        = "client-id"
            client_secret                    = "client-secret"
            secret_version_for_client_secret = "projects/-/secrets/-/versions/-"
            oauth_grant_type                 = "CLIENT_CREDENTIAL"
            token_endpoint                   = "https://example.com/oauth/token"
            scopes                           = ["scope1", "scope2"]
          }
        }
        tls_config = {
          ca_certs = [{
            display_name = "example ca cert name"
            cert         = base64encode("example cert")
          }]
        }
        service_directory_config = {
          service = "projects/-/locations/-/namespaces/-/services/-"
        }
      }
    }
    

    Dialogflow Tool Service Agent

    import * as pulumi from "@pulumi/pulumi";
    import * as gcp from "@pulumi/gcp";
    
    const serviceAgentTool = new gcp.diagflow.Tool("service_agent_tool", {
        location: "global",
        toolKey: "service_agent_tool_key",
        displayName: "service-agent-tool",
        description: "A tool with OpenAPI spec and Service Agent Auth",
        openApiSpec: {
            textSchema: `openapi: 3.0.0
    info:
      title: service_agent_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    `,
            authentication: {
                serviceAgentAuthConfig: {
                    serviceAgentAuth: "ID_TOKEN",
                },
            },
        },
    });
    
    import pulumi
    import pulumi_gcp as gcp
    
    service_agent_tool = gcp.diagflow.Tool("service_agent_tool",
        location="global",
        tool_key="service_agent_tool_key",
        display_name="service-agent-tool",
        description="A tool with OpenAPI spec and Service Agent Auth",
        open_api_spec={
            "text_schema": """openapi: 3.0.0
    info:
      title: service_agent_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    """,
            "authentication": {
                "service_agent_auth_config": {
                    "service_agent_auth": "ID_TOKEN",
                },
            },
        })
    
    package main
    
    import (
    	"github.com/pulumi/pulumi-gcp/sdk/v10/go/gcp/diagflow"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		_, err := diagflow.NewTool(ctx, "service_agent_tool", &diagflow.ToolArgs{
    			Location:    pulumi.String("global"),
    			ToolKey:     pulumi.String("service_agent_tool_key"),
    			DisplayName: pulumi.String("service-agent-tool"),
    			Description: pulumi.String("A tool with OpenAPI spec and Service Agent Auth"),
    			OpenApiSpec: &diagflow.ToolOpenApiSpecArgs{
    				TextSchema: pulumi.String(`openapi: 3.0.0
    info:
      title: service_agent_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    `),
    				Authentication: &diagflow.ToolOpenApiSpecAuthenticationArgs{
    					ServiceAgentAuthConfig: &diagflow.ToolOpenApiSpecAuthenticationServiceAgentAuthConfigArgs{
    						ServiceAgentAuth: pulumi.String("ID_TOKEN"),
    					},
    				},
    			},
    		})
    		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 serviceAgentTool = new Gcp.Diagflow.Tool("service_agent_tool", new()
        {
            Location = "global",
            ToolKey = "service_agent_tool_key",
            DisplayName = "service-agent-tool",
            Description = "A tool with OpenAPI spec and Service Agent Auth",
            OpenApiSpec = new Gcp.Diagflow.Inputs.ToolOpenApiSpecArgs
            {
                TextSchema = @"openapi: 3.0.0
    info:
      title: service_agent_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    ",
                Authentication = new Gcp.Diagflow.Inputs.ToolOpenApiSpecAuthenticationArgs
                {
                    ServiceAgentAuthConfig = new Gcp.Diagflow.Inputs.ToolOpenApiSpecAuthenticationServiceAgentAuthConfigArgs
                    {
                        ServiceAgentAuth = "ID_TOKEN",
                    },
                },
            },
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.gcp.diagflow.Tool;
    import com.pulumi.gcp.diagflow.ToolArgs;
    import com.pulumi.gcp.diagflow.inputs.ToolOpenApiSpecArgs;
    import com.pulumi.gcp.diagflow.inputs.ToolOpenApiSpecAuthenticationArgs;
    import com.pulumi.gcp.diagflow.inputs.ToolOpenApiSpecAuthenticationServiceAgentAuthConfigArgs;
    import java.util.ArrayList;
    import java.util.Arrays;
    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 serviceAgentTool = new Tool("serviceAgentTool", ToolArgs.builder()
                .location("global")
                .toolKey("service_agent_tool_key")
                .displayName("service-agent-tool")
                .description("A tool with OpenAPI spec and Service Agent Auth")
                .openApiSpec(ToolOpenApiSpecArgs.builder()
                    .textSchema("""
    openapi: 3.0.0
    info:
      title: service_agent_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
                    """)
                    .authentication(ToolOpenApiSpecAuthenticationArgs.builder()
                        .serviceAgentAuthConfig(ToolOpenApiSpecAuthenticationServiceAgentAuthConfigArgs.builder()
                            .serviceAgentAuth("ID_TOKEN")
                            .build())
                        .build())
                    .build())
                .build());
    
        }
    }
    
    resources:
      serviceAgentTool:
        type: gcp:diagflow:Tool
        name: service_agent_tool
        properties:
          location: global
          toolKey: service_agent_tool_key
          displayName: service-agent-tool
          description: A tool with OpenAPI spec and Service Agent Auth
          openApiSpec:
            textSchema: |
              openapi: 3.0.0
              info:
                title: service_agent_tool_key
                version: 1.0.0
              paths:
                /search:
                  get:
                    summary: Search function
                    operationId: searchAction
                    responses:
                      '200':
                        description: OK
            authentication:
              serviceAgentAuthConfig:
                serviceAgentAuth: ID_TOKEN
    
    terraform {
      required_providers {
        gcp = {
          source = "pulumi/gcp"
        }
      }
    }
    
    resource "gcp_diagflow_tool" "service_agent_tool" {
      lifecycle {
        create_before_destroy = true
      }
      location     = "global"
      tool_key     = "service_agent_tool_key"
      display_name = "service-agent-tool"
      description  = "A tool with OpenAPI spec and Service Agent Auth"
      open_api_spec = {
        text_schema = <<EOF
    openapi: 3.0.0
    info:
      title: service_agent_tool_key
      version: 1.0.0
    paths:
      /search:
        get:
          summary: Search function
          operationId: searchAction
          responses:
            '200':
              description: OK
    EOF
    
        authentication = {
          service_agent_auth_config = {
            service_agent_auth = "ID_TOKEN"
          }
        }
      }
    }
    

    Create Tool Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new Tool(name: string, args: ToolArgs, opts?: CustomResourceOptions);
    @overload
    def Tool(resource_name: str,
             args: ToolArgs,
             opts: Optional[ResourceOptions] = None)
    
    @overload
    def Tool(resource_name: str,
             opts: Optional[ResourceOptions] = None,
             location: Optional[str] = None,
             tool_key: Optional[str] = None,
             action_confirmation_requirement: Optional[Mapping[str, str]] = None,
             connector_spec: Optional[ToolConnectorSpecArgs] = None,
             deletion_policy: Optional[str] = None,
             description: Optional[str] = None,
             display_name: Optional[str] = None,
             function_spec: Optional[ToolFunctionSpecArgs] = None,
             open_api_spec: Optional[ToolOpenApiSpecArgs] = None,
             project: Optional[str] = None,
             tool_id: Optional[str] = None)
    func NewTool(ctx *Context, name string, args ToolArgs, opts ...ResourceOption) (*Tool, error)
    public Tool(string name, ToolArgs args, CustomResourceOptions? opts = null)
    public Tool(String name, ToolArgs args)
    public Tool(String name, ToolArgs args, CustomResourceOptions options)
    
    type: gcp:diagflow:Tool
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    
    resource "gcp_diagflow_tool" "name" {
        # resource properties
    }

    Parameters

    name string
    The unique name of the resource.
    args ToolArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args ToolArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args ToolArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args ToolArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args ToolArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Constructor example

    The following reference example uses placeholder values for all input properties.

    var gcpToolResource = new Gcp.Diagflow.Tool("gcpToolResource", new()
    {
        Location = "string",
        ToolKey = "string",
        ActionConfirmationRequirement = 
        {
            { "string", "string" },
        },
        ConnectorSpec = new Gcp.Diagflow.Inputs.ToolConnectorSpecArgs
        {
            Actions = new[]
            {
                new Gcp.Diagflow.Inputs.ToolConnectorSpecActionArgs
                {
                    ConnectionActionId = "string",
                    EntityOperation = new Gcp.Diagflow.Inputs.ToolConnectorSpecActionEntityOperationArgs
                    {
                        EntityId = "string",
                        Operation = "string",
                    },
                    InputFields = new[]
                    {
                        "string",
                    },
                    OutputFields = new[]
                    {
                        "string",
                    },
                },
            },
            Name = "string",
        },
        DeletionPolicy = "string",
        Description = "string",
        DisplayName = "string",
        FunctionSpec = new Gcp.Diagflow.Inputs.ToolFunctionSpecArgs
        {
            InputSchema = "string",
            MethodType = "string",
            OutputSchema = "string",
        },
        OpenApiSpec = new Gcp.Diagflow.Inputs.ToolOpenApiSpecArgs
        {
            TextSchema = "string",
            Authentication = new Gcp.Diagflow.Inputs.ToolOpenApiSpecAuthenticationArgs
            {
                ApiKeyConfig = new Gcp.Diagflow.Inputs.ToolOpenApiSpecAuthenticationApiKeyConfigArgs
                {
                    KeyName = "string",
                    RequestLocation = "string",
                    ApiKey = "string",
                    SecretVersionForApiKey = "string",
                },
                BearerTokenConfig = new Gcp.Diagflow.Inputs.ToolOpenApiSpecAuthenticationBearerTokenConfigArgs
                {
                    SecretVersionForToken = "string",
                    Token = "string",
                },
                OauthConfig = new Gcp.Diagflow.Inputs.ToolOpenApiSpecAuthenticationOauthConfigArgs
                {
                    ClientId = "string",
                    OauthGrantType = "string",
                    TokenEndpoint = "string",
                    ClientSecret = "string",
                    Scopes = new[]
                    {
                        "string",
                    },
                    SecretVersionForClientSecret = "string",
                },
                ServiceAgentAuthConfig = new Gcp.Diagflow.Inputs.ToolOpenApiSpecAuthenticationServiceAgentAuthConfigArgs
                {
                    ServiceAgentAuth = "string",
                },
            },
            ServiceDirectoryConfig = new Gcp.Diagflow.Inputs.ToolOpenApiSpecServiceDirectoryConfigArgs
            {
                Service = "string",
            },
            TlsConfig = new Gcp.Diagflow.Inputs.ToolOpenApiSpecTlsConfigArgs
            {
                CaCerts = new[]
                {
                    new Gcp.Diagflow.Inputs.ToolOpenApiSpecTlsConfigCaCertArgs
                    {
                        Cert = "string",
                        DisplayName = "string",
                    },
                },
            },
        },
        Project = "string",
        ToolId = "string",
    });
    
    example, err := diagflow.NewTool(ctx, "gcpToolResource", &diagflow.ToolArgs{
    	Location: pulumi.String("string"),
    	ToolKey:  pulumi.String("string"),
    	ActionConfirmationRequirement: pulumi.StringMap{
    		"string": pulumi.String("string"),
    	},
    	ConnectorSpec: &diagflow.ToolConnectorSpecArgs{
    		Actions: diagflow.ToolConnectorSpecActionArray{
    			&diagflow.ToolConnectorSpecActionArgs{
    				ConnectionActionId: pulumi.String("string"),
    				EntityOperation: &diagflow.ToolConnectorSpecActionEntityOperationArgs{
    					EntityId:  pulumi.String("string"),
    					Operation: pulumi.String("string"),
    				},
    				InputFields: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				OutputFields: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    			},
    		},
    		Name: pulumi.String("string"),
    	},
    	DeletionPolicy: pulumi.String("string"),
    	Description:    pulumi.String("string"),
    	DisplayName:    pulumi.String("string"),
    	FunctionSpec: &diagflow.ToolFunctionSpecArgs{
    		InputSchema:  pulumi.String("string"),
    		MethodType:   pulumi.String("string"),
    		OutputSchema: pulumi.String("string"),
    	},
    	OpenApiSpec: &diagflow.ToolOpenApiSpecArgs{
    		TextSchema: pulumi.String("string"),
    		Authentication: &diagflow.ToolOpenApiSpecAuthenticationArgs{
    			ApiKeyConfig: &diagflow.ToolOpenApiSpecAuthenticationApiKeyConfigArgs{
    				KeyName:                pulumi.String("string"),
    				RequestLocation:        pulumi.String("string"),
    				ApiKey:                 pulumi.String("string"),
    				SecretVersionForApiKey: pulumi.String("string"),
    			},
    			BearerTokenConfig: &diagflow.ToolOpenApiSpecAuthenticationBearerTokenConfigArgs{
    				SecretVersionForToken: pulumi.String("string"),
    				Token:                 pulumi.String("string"),
    			},
    			OauthConfig: &diagflow.ToolOpenApiSpecAuthenticationOauthConfigArgs{
    				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.ToolOpenApiSpecAuthenticationServiceAgentAuthConfigArgs{
    				ServiceAgentAuth: pulumi.String("string"),
    			},
    		},
    		ServiceDirectoryConfig: &diagflow.ToolOpenApiSpecServiceDirectoryConfigArgs{
    			Service: pulumi.String("string"),
    		},
    		TlsConfig: &diagflow.ToolOpenApiSpecTlsConfigArgs{
    			CaCerts: diagflow.ToolOpenApiSpecTlsConfigCaCertArray{
    				&diagflow.ToolOpenApiSpecTlsConfigCaCertArgs{
    					Cert:        pulumi.String("string"),
    					DisplayName: pulumi.String("string"),
    				},
    			},
    		},
    	},
    	Project: pulumi.String("string"),
    	ToolId:  pulumi.String("string"),
    })
    
    resource "gcp_diagflow_tool" "gcpToolResource" {
      lifecycle {
        create_before_destroy = true
      }
      location = "string"
      tool_key = "string"
      action_confirmation_requirement = {
        "string" = "string"
      }
      connector_spec = {
        actions = [{
          connection_action_id = "string"
          entity_operation = {
            entity_id = "string"
            operation = "string"
          }
          input_fields  = ["string"]
          output_fields = ["string"]
        }]
        name = "string"
      }
      deletion_policy = "string"
      description     = "string"
      display_name    = "string"
      function_spec = {
        input_schema  = "string"
        method_type   = "string"
        output_schema = "string"
      }
      open_api_spec = {
        text_schema = "string"
        authentication = {
          api_key_config = {
            key_name                   = "string"
            request_location           = "string"
            api_key                    = "string"
            secret_version_for_api_key = "string"
          }
          bearer_token_config = {
            secret_version_for_token = "string"
            token                    = "string"
          }
          oauth_config = {
            client_id                        = "string"
            oauth_grant_type                 = "string"
            token_endpoint                   = "string"
            client_secret                    = "string"
            scopes                           = ["string"]
            secret_version_for_client_secret = "string"
          }
          service_agent_auth_config = {
            service_agent_auth = "string"
          }
        }
        service_directory_config = {
          service = "string"
        }
        tls_config = {
          ca_certs = [{
            cert         = "string"
            display_name = "string"
          }]
        }
      }
      project = "string"
      tool_id = "string"
    }
    
    var gcpToolResource = new com.pulumi.gcp.diagflow.Tool("gcpToolResource", com.pulumi.gcp.diagflow.ToolArgs.builder()
        .location("string")
        .toolKey("string")
        .actionConfirmationRequirement(Map.of("string", "string"))
        .connectorSpec(ToolConnectorSpecArgs.builder()
            .actions(ToolConnectorSpecActionArgs.builder()
                .connectionActionId("string")
                .entityOperation(ToolConnectorSpecActionEntityOperationArgs.builder()
                    .entityId("string")
                    .operation("string")
                    .build())
                .inputFields("string")
                .outputFields("string")
                .build())
            .name("string")
            .build())
        .deletionPolicy("string")
        .description("string")
        .displayName("string")
        .functionSpec(ToolFunctionSpecArgs.builder()
            .inputSchema("string")
            .methodType("string")
            .outputSchema("string")
            .build())
        .openApiSpec(ToolOpenApiSpecArgs.builder()
            .textSchema("string")
            .authentication(ToolOpenApiSpecAuthenticationArgs.builder()
                .apiKeyConfig(ToolOpenApiSpecAuthenticationApiKeyConfigArgs.builder()
                    .keyName("string")
                    .requestLocation("string")
                    .apiKey("string")
                    .secretVersionForApiKey("string")
                    .build())
                .bearerTokenConfig(ToolOpenApiSpecAuthenticationBearerTokenConfigArgs.builder()
                    .secretVersionForToken("string")
                    .token("string")
                    .build())
                .oauthConfig(ToolOpenApiSpecAuthenticationOauthConfigArgs.builder()
                    .clientId("string")
                    .oauthGrantType("string")
                    .tokenEndpoint("string")
                    .clientSecret("string")
                    .scopes("string")
                    .secretVersionForClientSecret("string")
                    .build())
                .serviceAgentAuthConfig(ToolOpenApiSpecAuthenticationServiceAgentAuthConfigArgs.builder()
                    .serviceAgentAuth("string")
                    .build())
                .build())
            .serviceDirectoryConfig(ToolOpenApiSpecServiceDirectoryConfigArgs.builder()
                .service("string")
                .build())
            .tlsConfig(ToolOpenApiSpecTlsConfigArgs.builder()
                .caCerts(ToolOpenApiSpecTlsConfigCaCertArgs.builder()
                    .cert("string")
                    .displayName("string")
                    .build())
                .build())
            .build())
        .project("string")
        .toolId("string")
        .build());
    
    gcp_tool_resource = gcp.diagflow.Tool("gcpToolResource",
        location="string",
        tool_key="string",
        action_confirmation_requirement={
            "string": "string",
        },
        connector_spec={
            "actions": [{
                "connection_action_id": "string",
                "entity_operation": {
                    "entity_id": "string",
                    "operation": "string",
                },
                "input_fields": ["string"],
                "output_fields": ["string"],
            }],
            "name": "string",
        },
        deletion_policy="string",
        description="string",
        display_name="string",
        function_spec={
            "input_schema": "string",
            "method_type": "string",
            "output_schema": "string",
        },
        open_api_spec={
            "text_schema": "string",
            "authentication": {
                "api_key_config": {
                    "key_name": "string",
                    "request_location": "string",
                    "api_key": "string",
                    "secret_version_for_api_key": "string",
                },
                "bearer_token_config": {
                    "secret_version_for_token": "string",
                    "token": "string",
                },
                "oauth_config": {
                    "client_id": "string",
                    "oauth_grant_type": "string",
                    "token_endpoint": "string",
                    "client_secret": "string",
                    "scopes": ["string"],
                    "secret_version_for_client_secret": "string",
                },
                "service_agent_auth_config": {
                    "service_agent_auth": "string",
                },
            },
            "service_directory_config": {
                "service": "string",
            },
            "tls_config": {
                "ca_certs": [{
                    "cert": "string",
                    "display_name": "string",
                }],
            },
        },
        project="string",
        tool_id="string")
    
    const gcpToolResource = new gcp.diagflow.Tool("gcpToolResource", {
        location: "string",
        toolKey: "string",
        actionConfirmationRequirement: {
            string: "string",
        },
        connectorSpec: {
            actions: [{
                connectionActionId: "string",
                entityOperation: {
                    entityId: "string",
                    operation: "string",
                },
                inputFields: ["string"],
                outputFields: ["string"],
            }],
            name: "string",
        },
        deletionPolicy: "string",
        description: "string",
        displayName: "string",
        functionSpec: {
            inputSchema: "string",
            methodType: "string",
            outputSchema: "string",
        },
        openApiSpec: {
            textSchema: "string",
            authentication: {
                apiKeyConfig: {
                    keyName: "string",
                    requestLocation: "string",
                    apiKey: "string",
                    secretVersionForApiKey: "string",
                },
                bearerTokenConfig: {
                    secretVersionForToken: "string",
                    token: "string",
                },
                oauthConfig: {
                    clientId: "string",
                    oauthGrantType: "string",
                    tokenEndpoint: "string",
                    clientSecret: "string",
                    scopes: ["string"],
                    secretVersionForClientSecret: "string",
                },
                serviceAgentAuthConfig: {
                    serviceAgentAuth: "string",
                },
            },
            serviceDirectoryConfig: {
                service: "string",
            },
            tlsConfig: {
                caCerts: [{
                    cert: "string",
                    displayName: "string",
                }],
            },
        },
        project: "string",
        toolId: "string",
    });
    
    type: gcp:diagflow:Tool
    properties:
        actionConfirmationRequirement:
            string: string
        connectorSpec:
            actions:
                - connectionActionId: string
                  entityOperation:
                    entityId: string
                    operation: string
                  inputFields:
                    - string
                  outputFields:
                    - string
            name: string
        deletionPolicy: string
        description: string
        displayName: string
        functionSpec:
            inputSchema: string
            methodType: string
            outputSchema: string
        location: string
        openApiSpec:
            authentication:
                apiKeyConfig:
                    apiKey: string
                    keyName: string
                    requestLocation: string
                    secretVersionForApiKey: string
                bearerTokenConfig:
                    secretVersionForToken: string
                    token: string
                oauthConfig:
                    clientId: string
                    clientSecret: string
                    oauthGrantType: string
                    scopes:
                        - string
                    secretVersionForClientSecret: string
                    tokenEndpoint: string
                serviceAgentAuthConfig:
                    serviceAgentAuth: string
            serviceDirectoryConfig:
                service: string
            textSchema: string
            tlsConfig:
                caCerts:
                    - cert: string
                      displayName: string
        project: string
        toolId: string
        toolKey: string
    

    Tool Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    In Python, inputs that are objects can be passed either as argument classes or as dictionary literals.

    The Tool resource accepts the following input properties:

    Location string
    The location of the tool.
    ToolKey string
    Required. A human readable short name of the tool, which should be unique within the project. It should only contain letters, numbers, and underscores, and it will be used by LLM to identify the tool.
    ActionConfirmationRequirement Dictionary<string, string>
    Optional. Confirmation requirement for the actions. Each key is an action name in the actionSchemas. If an action's confirmation requirement is not specified (either the key is not present, or its value is CONFIRMATION_REQUIREMENT_UNSPECIFIED), a default value will be populated depending on the action's method type: GET actions default to NOT_REQUIRED, and other actions default to REQUIRED. Valid values are REQUIRED and NOT_REQUIRED.
    ConnectorSpec ToolConnectorSpec
    Integration connectors tool specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    DeletionPolicy string
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    Description string
    Optional. Human readable description of the tool.
    DisplayName string
    Optional. The human-readable name of the tool, unique within the project and location.
    FunctionSpec ToolFunctionSpec
    Client side executed function specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    OpenApiSpec ToolOpenApiSpec
    OpenAPI specification of the Tool. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    ToolId string
    Optional. The ID to use for the tool, which will become the final component of the tool's resource name. The tool ID must be compliant with the regression formula [a-zA-Z][a-zA-Z0-9_-]* with the characters length in range of [3,64]. If the field is not provided, an Id will be auto-generated.
    Location string
    The location of the tool.
    ToolKey string
    Required. A human readable short name of the tool, which should be unique within the project. It should only contain letters, numbers, and underscores, and it will be used by LLM to identify the tool.
    ActionConfirmationRequirement map[string]string
    Optional. Confirmation requirement for the actions. Each key is an action name in the actionSchemas. If an action's confirmation requirement is not specified (either the key is not present, or its value is CONFIRMATION_REQUIREMENT_UNSPECIFIED), a default value will be populated depending on the action's method type: GET actions default to NOT_REQUIRED, and other actions default to REQUIRED. Valid values are REQUIRED and NOT_REQUIRED.
    ConnectorSpec ToolConnectorSpecArgs
    Integration connectors tool specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    DeletionPolicy string
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    Description string
    Optional. Human readable description of the tool.
    DisplayName string
    Optional. The human-readable name of the tool, unique within the project and location.
    FunctionSpec ToolFunctionSpecArgs
    Client side executed function specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    OpenApiSpec ToolOpenApiSpecArgs
    OpenAPI specification of the Tool. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    ToolId string
    Optional. The ID to use for the tool, which will become the final component of the tool's resource name. The tool ID must be compliant with the regression formula [a-zA-Z][a-zA-Z0-9_-]* with the characters length in range of [3,64]. If the field is not provided, an Id will be auto-generated.
    location string
    The location of the tool.
    tool_key string
    Required. A human readable short name of the tool, which should be unique within the project. It should only contain letters, numbers, and underscores, and it will be used by LLM to identify the tool.
    action_confirmation_requirement map(string)
    Optional. Confirmation requirement for the actions. Each key is an action name in the actionSchemas. If an action's confirmation requirement is not specified (either the key is not present, or its value is CONFIRMATION_REQUIREMENT_UNSPECIFIED), a default value will be populated depending on the action's method type: GET actions default to NOT_REQUIRED, and other actions default to REQUIRED. Valid values are REQUIRED and NOT_REQUIRED.
    connector_spec object
    Integration connectors tool specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    deletion_policy string
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    description string
    Optional. Human readable description of the tool.
    display_name string
    Optional. The human-readable name of the tool, unique within the project and location.
    function_spec object
    Client side executed function specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    open_api_spec object
    OpenAPI specification of the Tool. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    tool_id string
    Optional. The ID to use for the tool, which will become the final component of the tool's resource name. The tool ID must be compliant with the regression formula [a-zA-Z][a-zA-Z0-9_-]* with the characters length in range of [3,64]. If the field is not provided, an Id will be auto-generated.
    location String
    The location of the tool.
    toolKey String
    Required. A human readable short name of the tool, which should be unique within the project. It should only contain letters, numbers, and underscores, and it will be used by LLM to identify the tool.
    actionConfirmationRequirement Map<String,String>
    Optional. Confirmation requirement for the actions. Each key is an action name in the actionSchemas. If an action's confirmation requirement is not specified (either the key is not present, or its value is CONFIRMATION_REQUIREMENT_UNSPECIFIED), a default value will be populated depending on the action's method type: GET actions default to NOT_REQUIRED, and other actions default to REQUIRED. Valid values are REQUIRED and NOT_REQUIRED.
    connectorSpec ToolConnectorSpec
    Integration connectors tool specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    deletionPolicy String
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    description String
    Optional. Human readable description of the tool.
    displayName String
    Optional. The human-readable name of the tool, unique within the project and location.
    functionSpec ToolFunctionSpec
    Client side executed function specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    openApiSpec ToolOpenApiSpec
    OpenAPI specification of the Tool. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    toolId String
    Optional. The ID to use for the tool, which will become the final component of the tool's resource name. The tool ID must be compliant with the regression formula [a-zA-Z][a-zA-Z0-9_-]* with the characters length in range of [3,64]. If the field is not provided, an Id will be auto-generated.
    location string
    The location of the tool.
    toolKey string
    Required. A human readable short name of the tool, which should be unique within the project. It should only contain letters, numbers, and underscores, and it will be used by LLM to identify the tool.
    actionConfirmationRequirement {[key: string]: string}
    Optional. Confirmation requirement for the actions. Each key is an action name in the actionSchemas. If an action's confirmation requirement is not specified (either the key is not present, or its value is CONFIRMATION_REQUIREMENT_UNSPECIFIED), a default value will be populated depending on the action's method type: GET actions default to NOT_REQUIRED, and other actions default to REQUIRED. Valid values are REQUIRED and NOT_REQUIRED.
    connectorSpec ToolConnectorSpec
    Integration connectors tool specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    deletionPolicy string
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    description string
    Optional. Human readable description of the tool.
    displayName string
    Optional. The human-readable name of the tool, unique within the project and location.
    functionSpec ToolFunctionSpec
    Client side executed function specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    openApiSpec ToolOpenApiSpec
    OpenAPI specification of the Tool. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    toolId string
    Optional. The ID to use for the tool, which will become the final component of the tool's resource name. The tool ID must be compliant with the regression formula [a-zA-Z][a-zA-Z0-9_-]* with the characters length in range of [3,64]. If the field is not provided, an Id will be auto-generated.
    location str
    The location of the tool.
    tool_key str
    Required. A human readable short name of the tool, which should be unique within the project. It should only contain letters, numbers, and underscores, and it will be used by LLM to identify the tool.
    action_confirmation_requirement Mapping[str, str]
    Optional. Confirmation requirement for the actions. Each key is an action name in the actionSchemas. If an action's confirmation requirement is not specified (either the key is not present, or its value is CONFIRMATION_REQUIREMENT_UNSPECIFIED), a default value will be populated depending on the action's method type: GET actions default to NOT_REQUIRED, and other actions default to REQUIRED. Valid values are REQUIRED and NOT_REQUIRED.
    connector_spec ToolConnectorSpecArgs
    Integration connectors tool specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    deletion_policy str
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    description str
    Optional. Human readable description of the tool.
    display_name str
    Optional. The human-readable name of the tool, unique within the project and location.
    function_spec ToolFunctionSpecArgs
    Client side executed function specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    open_api_spec ToolOpenApiSpecArgs
    OpenAPI specification of the Tool. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    project str
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    tool_id str
    Optional. The ID to use for the tool, which will become the final component of the tool's resource name. The tool ID must be compliant with the regression formula [a-zA-Z][a-zA-Z0-9_-]* with the characters length in range of [3,64]. If the field is not provided, an Id will be auto-generated.
    location String
    The location of the tool.
    toolKey String
    Required. A human readable short name of the tool, which should be unique within the project. It should only contain letters, numbers, and underscores, and it will be used by LLM to identify the tool.
    actionConfirmationRequirement Map<String>
    Optional. Confirmation requirement for the actions. Each key is an action name in the actionSchemas. If an action's confirmation requirement is not specified (either the key is not present, or its value is CONFIRMATION_REQUIREMENT_UNSPECIFIED), a default value will be populated depending on the action's method type: GET actions default to NOT_REQUIRED, and other actions default to REQUIRED. Valid values are REQUIRED and NOT_REQUIRED.
    connectorSpec Property Map
    Integration connectors tool specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    deletionPolicy String
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    description String
    Optional. Human readable description of the tool.
    displayName String
    Optional. The human-readable name of the tool, unique within the project and location.
    functionSpec Property Map
    Client side executed function specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    openApiSpec Property Map
    OpenAPI specification of the Tool. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    toolId String
    Optional. The ID to use for the tool, which will become the final component of the tool's resource name. The tool ID must be compliant with the regression formula [a-zA-Z][a-zA-Z0-9_-]* with the characters length in range of [3,64]. If the field is not provided, an Id will be auto-generated.

    Outputs

    All input properties are implicitly available as output properties. Additionally, the Tool resource produces the following output properties:

    CreateTime string
    Output only. Creation time of this tool.
    Id string
    The provider-assigned unique ID for this managed resource.
    Name string
    The resource name of the tool. Format: projects/<Project ID>/locations/<Location ID>/tools/<Tool ID>.
    SatisfiesPzi bool
    Output only. A read only boolean field reflecting Zone Isolation status of the tool.
    SatisfiesPzs bool
    Output only. A read only boolean field reflecting Zone Separation status of the tool.
    UpdateTime string
    Output only. Update time of this tool.
    CreateTime string
    Output only. Creation time of this tool.
    Id string
    The provider-assigned unique ID for this managed resource.
    Name string
    The resource name of the tool. Format: projects/<Project ID>/locations/<Location ID>/tools/<Tool ID>.
    SatisfiesPzi bool
    Output only. A read only boolean field reflecting Zone Isolation status of the tool.
    SatisfiesPzs bool
    Output only. A read only boolean field reflecting Zone Separation status of the tool.
    UpdateTime string
    Output only. Update time of this tool.
    create_time string
    Output only. Creation time of this tool.
    id string
    The provider-assigned unique ID for this managed resource.
    name string
    The resource name of the tool. Format: projects/<Project ID>/locations/<Location ID>/tools/<Tool ID>.
    satisfies_pzi bool
    Output only. A read only boolean field reflecting Zone Isolation status of the tool.
    satisfies_pzs bool
    Output only. A read only boolean field reflecting Zone Separation status of the tool.
    update_time string
    Output only. Update time of this tool.
    createTime String
    Output only. Creation time of this tool.
    id String
    The provider-assigned unique ID for this managed resource.
    name String
    The resource name of the tool. Format: projects/<Project ID>/locations/<Location ID>/tools/<Tool ID>.
    satisfiesPzi Boolean
    Output only. A read only boolean field reflecting Zone Isolation status of the tool.
    satisfiesPzs Boolean
    Output only. A read only boolean field reflecting Zone Separation status of the tool.
    updateTime String
    Output only. Update time of this tool.
    createTime string
    Output only. Creation time of this tool.
    id string
    The provider-assigned unique ID for this managed resource.
    name string
    The resource name of the tool. Format: projects/<Project ID>/locations/<Location ID>/tools/<Tool ID>.
    satisfiesPzi boolean
    Output only. A read only boolean field reflecting Zone Isolation status of the tool.
    satisfiesPzs boolean
    Output only. A read only boolean field reflecting Zone Separation status of the tool.
    updateTime string
    Output only. Update time of this tool.
    create_time str
    Output only. Creation time of this tool.
    id str
    The provider-assigned unique ID for this managed resource.
    name str
    The resource name of the tool. Format: projects/<Project ID>/locations/<Location ID>/tools/<Tool ID>.
    satisfies_pzi bool
    Output only. A read only boolean field reflecting Zone Isolation status of the tool.
    satisfies_pzs bool
    Output only. A read only boolean field reflecting Zone Separation status of the tool.
    update_time str
    Output only. Update time of this tool.
    createTime String
    Output only. Creation time of this tool.
    id String
    The provider-assigned unique ID for this managed resource.
    name String
    The resource name of the tool. Format: projects/<Project ID>/locations/<Location ID>/tools/<Tool ID>.
    satisfiesPzi Boolean
    Output only. A read only boolean field reflecting Zone Isolation status of the tool.
    satisfiesPzs Boolean
    Output only. A read only boolean field reflecting Zone Separation status of the tool.
    updateTime String
    Output only. Update time of this tool.

    Look up Existing Tool Resource

    Get an existing Tool resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: ToolState, opts?: CustomResourceOptions): Tool
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            action_confirmation_requirement: Optional[Mapping[str, str]] = None,
            connector_spec: Optional[ToolConnectorSpecArgs] = None,
            create_time: Optional[str] = None,
            deletion_policy: Optional[str] = None,
            description: Optional[str] = None,
            display_name: Optional[str] = None,
            function_spec: Optional[ToolFunctionSpecArgs] = None,
            location: Optional[str] = None,
            name: Optional[str] = None,
            open_api_spec: Optional[ToolOpenApiSpecArgs] = None,
            project: Optional[str] = None,
            satisfies_pzi: Optional[bool] = None,
            satisfies_pzs: Optional[bool] = None,
            tool_id: Optional[str] = None,
            tool_key: Optional[str] = None,
            update_time: Optional[str] = None) -> Tool
    func GetTool(ctx *Context, name string, id IDInput, state *ToolState, opts ...ResourceOption) (*Tool, error)
    public static Tool Get(string name, Input<string> id, ToolState? state, CustomResourceOptions? opts = null)
    public static Tool get(String name, Output<String> id, ToolState state, CustomResourceOptions options)
    resources:  _:    type: gcp:diagflow:Tool    get:      id: ${id}
    import {
      to = gcp_diagflow_tool.example
      id = "${id}"
    }
    
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    ActionConfirmationRequirement Dictionary<string, string>
    Optional. Confirmation requirement for the actions. Each key is an action name in the actionSchemas. If an action's confirmation requirement is not specified (either the key is not present, or its value is CONFIRMATION_REQUIREMENT_UNSPECIFIED), a default value will be populated depending on the action's method type: GET actions default to NOT_REQUIRED, and other actions default to REQUIRED. Valid values are REQUIRED and NOT_REQUIRED.
    ConnectorSpec ToolConnectorSpec
    Integration connectors tool specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    CreateTime string
    Output only. Creation time of this tool.
    DeletionPolicy string
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    Description string
    Optional. Human readable description of the tool.
    DisplayName string
    Optional. The human-readable name of the tool, unique within the project and location.
    FunctionSpec ToolFunctionSpec
    Client side executed function specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    Location string
    The location of the tool.
    Name string
    The resource name of the tool. Format: projects/<Project ID>/locations/<Location ID>/tools/<Tool ID>.
    OpenApiSpec ToolOpenApiSpec
    OpenAPI specification of the Tool. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    SatisfiesPzi bool
    Output only. A read only boolean field reflecting Zone Isolation status of the tool.
    SatisfiesPzs bool
    Output only. A read only boolean field reflecting Zone Separation status of the tool.
    ToolId string
    Optional. The ID to use for the tool, which will become the final component of the tool's resource name. The tool ID must be compliant with the regression formula [a-zA-Z][a-zA-Z0-9_-]* with the characters length in range of [3,64]. If the field is not provided, an Id will be auto-generated.
    ToolKey string
    Required. A human readable short name of the tool, which should be unique within the project. It should only contain letters, numbers, and underscores, and it will be used by LLM to identify the tool.
    UpdateTime string
    Output only. Update time of this tool.
    ActionConfirmationRequirement map[string]string
    Optional. Confirmation requirement for the actions. Each key is an action name in the actionSchemas. If an action's confirmation requirement is not specified (either the key is not present, or its value is CONFIRMATION_REQUIREMENT_UNSPECIFIED), a default value will be populated depending on the action's method type: GET actions default to NOT_REQUIRED, and other actions default to REQUIRED. Valid values are REQUIRED and NOT_REQUIRED.
    ConnectorSpec ToolConnectorSpecArgs
    Integration connectors tool specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    CreateTime string
    Output only. Creation time of this tool.
    DeletionPolicy string
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    Description string
    Optional. Human readable description of the tool.
    DisplayName string
    Optional. The human-readable name of the tool, unique within the project and location.
    FunctionSpec ToolFunctionSpecArgs
    Client side executed function specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    Location string
    The location of the tool.
    Name string
    The resource name of the tool. Format: projects/<Project ID>/locations/<Location ID>/tools/<Tool ID>.
    OpenApiSpec ToolOpenApiSpecArgs
    OpenAPI specification of the Tool. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    Project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    SatisfiesPzi bool
    Output only. A read only boolean field reflecting Zone Isolation status of the tool.
    SatisfiesPzs bool
    Output only. A read only boolean field reflecting Zone Separation status of the tool.
    ToolId string
    Optional. The ID to use for the tool, which will become the final component of the tool's resource name. The tool ID must be compliant with the regression formula [a-zA-Z][a-zA-Z0-9_-]* with the characters length in range of [3,64]. If the field is not provided, an Id will be auto-generated.
    ToolKey string
    Required. A human readable short name of the tool, which should be unique within the project. It should only contain letters, numbers, and underscores, and it will be used by LLM to identify the tool.
    UpdateTime string
    Output only. Update time of this tool.
    action_confirmation_requirement map(string)
    Optional. Confirmation requirement for the actions. Each key is an action name in the actionSchemas. If an action's confirmation requirement is not specified (either the key is not present, or its value is CONFIRMATION_REQUIREMENT_UNSPECIFIED), a default value will be populated depending on the action's method type: GET actions default to NOT_REQUIRED, and other actions default to REQUIRED. Valid values are REQUIRED and NOT_REQUIRED.
    connector_spec object
    Integration connectors tool specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    create_time string
    Output only. Creation time of this tool.
    deletion_policy string
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    description string
    Optional. Human readable description of the tool.
    display_name string
    Optional. The human-readable name of the tool, unique within the project and location.
    function_spec object
    Client side executed function specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    location string
    The location of the tool.
    name string
    The resource name of the tool. Format: projects/<Project ID>/locations/<Location ID>/tools/<Tool ID>.
    open_api_spec object
    OpenAPI specification of the Tool. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    satisfies_pzi bool
    Output only. A read only boolean field reflecting Zone Isolation status of the tool.
    satisfies_pzs bool
    Output only. A read only boolean field reflecting Zone Separation status of the tool.
    tool_id string
    Optional. The ID to use for the tool, which will become the final component of the tool's resource name. The tool ID must be compliant with the regression formula [a-zA-Z][a-zA-Z0-9_-]* with the characters length in range of [3,64]. If the field is not provided, an Id will be auto-generated.
    tool_key string
    Required. A human readable short name of the tool, which should be unique within the project. It should only contain letters, numbers, and underscores, and it will be used by LLM to identify the tool.
    update_time string
    Output only. Update time of this tool.
    actionConfirmationRequirement Map<String,String>
    Optional. Confirmation requirement for the actions. Each key is an action name in the actionSchemas. If an action's confirmation requirement is not specified (either the key is not present, or its value is CONFIRMATION_REQUIREMENT_UNSPECIFIED), a default value will be populated depending on the action's method type: GET actions default to NOT_REQUIRED, and other actions default to REQUIRED. Valid values are REQUIRED and NOT_REQUIRED.
    connectorSpec ToolConnectorSpec
    Integration connectors tool specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    createTime String
    Output only. Creation time of this tool.
    deletionPolicy String
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    description String
    Optional. Human readable description of the tool.
    displayName String
    Optional. The human-readable name of the tool, unique within the project and location.
    functionSpec ToolFunctionSpec
    Client side executed function specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    location String
    The location of the tool.
    name String
    The resource name of the tool. Format: projects/<Project ID>/locations/<Location ID>/tools/<Tool ID>.
    openApiSpec ToolOpenApiSpec
    OpenAPI specification of the Tool. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    satisfiesPzi Boolean
    Output only. A read only boolean field reflecting Zone Isolation status of the tool.
    satisfiesPzs Boolean
    Output only. A read only boolean field reflecting Zone Separation status of the tool.
    toolId String
    Optional. The ID to use for the tool, which will become the final component of the tool's resource name. The tool ID must be compliant with the regression formula [a-zA-Z][a-zA-Z0-9_-]* with the characters length in range of [3,64]. If the field is not provided, an Id will be auto-generated.
    toolKey String
    Required. A human readable short name of the tool, which should be unique within the project. It should only contain letters, numbers, and underscores, and it will be used by LLM to identify the tool.
    updateTime String
    Output only. Update time of this tool.
    actionConfirmationRequirement {[key: string]: string}
    Optional. Confirmation requirement for the actions. Each key is an action name in the actionSchemas. If an action's confirmation requirement is not specified (either the key is not present, or its value is CONFIRMATION_REQUIREMENT_UNSPECIFIED), a default value will be populated depending on the action's method type: GET actions default to NOT_REQUIRED, and other actions default to REQUIRED. Valid values are REQUIRED and NOT_REQUIRED.
    connectorSpec ToolConnectorSpec
    Integration connectors tool specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    createTime string
    Output only. Creation time of this tool.
    deletionPolicy string
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    description string
    Optional. Human readable description of the tool.
    displayName string
    Optional. The human-readable name of the tool, unique within the project and location.
    functionSpec ToolFunctionSpec
    Client side executed function specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    location string
    The location of the tool.
    name string
    The resource name of the tool. Format: projects/<Project ID>/locations/<Location ID>/tools/<Tool ID>.
    openApiSpec ToolOpenApiSpec
    OpenAPI specification of the Tool. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    project string
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    satisfiesPzi boolean
    Output only. A read only boolean field reflecting Zone Isolation status of the tool.
    satisfiesPzs boolean
    Output only. A read only boolean field reflecting Zone Separation status of the tool.
    toolId string
    Optional. The ID to use for the tool, which will become the final component of the tool's resource name. The tool ID must be compliant with the regression formula [a-zA-Z][a-zA-Z0-9_-]* with the characters length in range of [3,64]. If the field is not provided, an Id will be auto-generated.
    toolKey string
    Required. A human readable short name of the tool, which should be unique within the project. It should only contain letters, numbers, and underscores, and it will be used by LLM to identify the tool.
    updateTime string
    Output only. Update time of this tool.
    action_confirmation_requirement Mapping[str, str]
    Optional. Confirmation requirement for the actions. Each key is an action name in the actionSchemas. If an action's confirmation requirement is not specified (either the key is not present, or its value is CONFIRMATION_REQUIREMENT_UNSPECIFIED), a default value will be populated depending on the action's method type: GET actions default to NOT_REQUIRED, and other actions default to REQUIRED. Valid values are REQUIRED and NOT_REQUIRED.
    connector_spec ToolConnectorSpecArgs
    Integration connectors tool specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    create_time str
    Output only. Creation time of this tool.
    deletion_policy str
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    description str
    Optional. Human readable description of the tool.
    display_name str
    Optional. The human-readable name of the tool, unique within the project and location.
    function_spec ToolFunctionSpecArgs
    Client side executed function specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    location str
    The location of the tool.
    name str
    The resource name of the tool. Format: projects/<Project ID>/locations/<Location ID>/tools/<Tool ID>.
    open_api_spec ToolOpenApiSpecArgs
    OpenAPI specification of the Tool. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    project str
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    satisfies_pzi bool
    Output only. A read only boolean field reflecting Zone Isolation status of the tool.
    satisfies_pzs bool
    Output only. A read only boolean field reflecting Zone Separation status of the tool.
    tool_id str
    Optional. The ID to use for the tool, which will become the final component of the tool's resource name. The tool ID must be compliant with the regression formula [a-zA-Z][a-zA-Z0-9_-]* with the characters length in range of [3,64]. If the field is not provided, an Id will be auto-generated.
    tool_key str
    Required. A human readable short name of the tool, which should be unique within the project. It should only contain letters, numbers, and underscores, and it will be used by LLM to identify the tool.
    update_time str
    Output only. Update time of this tool.
    actionConfirmationRequirement Map<String>
    Optional. Confirmation requirement for the actions. Each key is an action name in the actionSchemas. If an action's confirmation requirement is not specified (either the key is not present, or its value is CONFIRMATION_REQUIREMENT_UNSPECIFIED), a default value will be populated depending on the action's method type: GET actions default to NOT_REQUIRED, and other actions default to REQUIRED. Valid values are REQUIRED and NOT_REQUIRED.
    connectorSpec Property Map
    Integration connectors tool specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    createTime String
    Output only. Creation time of this tool.
    deletionPolicy String
    Whether Terraform will be prevented from destroying the resource. Defaults to DELETE. When a 'terraform destroy' or 'pulumi up' would delete the resource, the command will fail if this field is set to "PREVENT" in Terraform state. When set to "ABANDON", the command will remove the resource from Terraform management without updating or deleting the resource in the API. When set to "DELETE", deleting the resource is allowed.
    description String
    Optional. Human readable description of the tool.
    displayName String
    Optional. The human-readable name of the tool, unique within the project and location.
    functionSpec Property Map
    Client side executed function specification. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    location String
    The location of the tool.
    name String
    The resource name of the tool. Format: projects/<Project ID>/locations/<Location ID>/tools/<Tool ID>.
    openApiSpec Property Map
    OpenAPI specification of the Tool. This field is part of a union field specification: Only one of openApiSpec, functionSpec, or connectorSpec may be set. Structure is documented below.
    project String
    The ID of the project in which the resource belongs. If it is not provided, the provider project is used.
    satisfiesPzi Boolean
    Output only. A read only boolean field reflecting Zone Isolation status of the tool.
    satisfiesPzs Boolean
    Output only. A read only boolean field reflecting Zone Separation status of the tool.
    toolId String
    Optional. The ID to use for the tool, which will become the final component of the tool's resource name. The tool ID must be compliant with the regression formula [a-zA-Z][a-zA-Z0-9_-]* with the characters length in range of [3,64]. If the field is not provided, an Id will be auto-generated.
    toolKey String
    Required. A human readable short name of the tool, which should be unique within the project. It should only contain letters, numbers, and underscores, and it will be used by LLM to identify the tool.
    updateTime String
    Output only. Update time of this tool.

    Supporting Types

    ToolConnectorSpec, ToolConnectorSpecArgs

    Actions List<ToolConnectorSpecAction>
    Actions for the tool to use. Structure is documented below.
    Name string
    The full resource name of the referenced Integration Connectors Connection. Format: projects/*/locations/*/connections/*
    Actions []ToolConnectorSpecAction
    Actions for the tool to use. Structure is documented below.
    Name string
    The full resource name of the referenced Integration Connectors Connection. Format: projects/*/locations/*/connections/*
    actions list(object)
    Actions for the tool to use. Structure is documented below.
    name string
    The full resource name of the referenced Integration Connectors Connection. Format: projects/*/locations/*/connections/*
    actions List<ToolConnectorSpecAction>
    Actions for the tool to use. Structure is documented below.
    name String
    The full resource name of the referenced Integration Connectors Connection. Format: projects/*/locations/*/connections/*
    actions ToolConnectorSpecAction[]
    Actions for the tool to use. Structure is documented below.
    name string
    The full resource name of the referenced Integration Connectors Connection. Format: projects/*/locations/*/connections/*
    actions Sequence[ToolConnectorSpecAction]
    Actions for the tool to use. Structure is documented below.
    name str
    The full resource name of the referenced Integration Connectors Connection. Format: projects/*/locations/*/connections/*
    actions List<Property Map>
    Actions for the tool to use. Structure is documented below.
    name String
    The full resource name of the referenced Integration Connectors Connection. Format: projects/*/locations/*/connections/*

    ToolConnectorSpecAction, ToolConnectorSpecActionArgs

    ConnectionActionId string
    ID of a Connection action for the tool to use. This field is part of a required union field actionSpec.
    EntityOperation ToolConnectorSpecActionEntityOperation
    Entity operation configuration for the tool to use. This field is part of a required union field actionSpec. Structure is documented below.
    InputFields List<string>
    Entity fields to use as inputs for the operation. If no fields are specified, all fields of the Entity will be used.
    OutputFields List<string>
    Entity fields to return from the operation. If no fields are specified, all fields of the Entity will be returned.
    ConnectionActionId string
    ID of a Connection action for the tool to use. This field is part of a required union field actionSpec.
    EntityOperation ToolConnectorSpecActionEntityOperation
    Entity operation configuration for the tool to use. This field is part of a required union field actionSpec. Structure is documented below.
    InputFields []string
    Entity fields to use as inputs for the operation. If no fields are specified, all fields of the Entity will be used.
    OutputFields []string
    Entity fields to return from the operation. If no fields are specified, all fields of the Entity will be returned.
    connection_action_id string
    ID of a Connection action for the tool to use. This field is part of a required union field actionSpec.
    entity_operation object
    Entity operation configuration for the tool to use. This field is part of a required union field actionSpec. Structure is documented below.
    input_fields list(string)
    Entity fields to use as inputs for the operation. If no fields are specified, all fields of the Entity will be used.
    output_fields list(string)
    Entity fields to return from the operation. If no fields are specified, all fields of the Entity will be returned.
    connectionActionId String
    ID of a Connection action for the tool to use. This field is part of a required union field actionSpec.
    entityOperation ToolConnectorSpecActionEntityOperation
    Entity operation configuration for the tool to use. This field is part of a required union field actionSpec. Structure is documented below.
    inputFields List<String>
    Entity fields to use as inputs for the operation. If no fields are specified, all fields of the Entity will be used.
    outputFields List<String>
    Entity fields to return from the operation. If no fields are specified, all fields of the Entity will be returned.
    connectionActionId string
    ID of a Connection action for the tool to use. This field is part of a required union field actionSpec.
    entityOperation ToolConnectorSpecActionEntityOperation
    Entity operation configuration for the tool to use. This field is part of a required union field actionSpec. Structure is documented below.
    inputFields string[]
    Entity fields to use as inputs for the operation. If no fields are specified, all fields of the Entity will be used.
    outputFields string[]
    Entity fields to return from the operation. If no fields are specified, all fields of the Entity will be returned.
    connection_action_id str
    ID of a Connection action for the tool to use. This field is part of a required union field actionSpec.
    entity_operation ToolConnectorSpecActionEntityOperation
    Entity operation configuration for the tool to use. This field is part of a required union field actionSpec. Structure is documented below.
    input_fields Sequence[str]
    Entity fields to use as inputs for the operation. If no fields are specified, all fields of the Entity will be used.
    output_fields Sequence[str]
    Entity fields to return from the operation. If no fields are specified, all fields of the Entity will be returned.
    connectionActionId String
    ID of a Connection action for the tool to use. This field is part of a required union field actionSpec.
    entityOperation Property Map
    Entity operation configuration for the tool to use. This field is part of a required union field actionSpec. Structure is documented below.
    inputFields List<String>
    Entity fields to use as inputs for the operation. If no fields are specified, all fields of the Entity will be used.
    outputFields List<String>
    Entity fields to return from the operation. If no fields are specified, all fields of the Entity will be returned.

    ToolConnectorSpecActionEntityOperation, ToolConnectorSpecActionEntityOperationArgs

    EntityId string
    ID of the entity.
    Operation string
    The operation to perform on the entity. Possible values are: LIST, GET, CREATE, UPDATE, DELETE.
    EntityId string
    ID of the entity.
    Operation string
    The operation to perform on the entity. Possible values are: LIST, GET, CREATE, UPDATE, DELETE.
    entity_id string
    ID of the entity.
    operation string
    The operation to perform on the entity. Possible values are: LIST, GET, CREATE, UPDATE, DELETE.
    entityId String
    ID of the entity.
    operation String
    The operation to perform on the entity. Possible values are: LIST, GET, CREATE, UPDATE, DELETE.
    entityId string
    ID of the entity.
    operation string
    The operation to perform on the entity. Possible values are: LIST, GET, CREATE, UPDATE, DELETE.
    entity_id str
    ID of the entity.
    operation str
    The operation to perform on the entity. Possible values are: LIST, GET, CREATE, UPDATE, DELETE.
    entityId String
    ID of the entity.
    operation String
    The operation to perform on the entity. Possible values are: LIST, GET, CREATE, UPDATE, DELETE.

    ToolFunctionSpec, ToolFunctionSpecArgs

    InputSchema string
    Optional. The JSON schema is encapsulated in a google.protobuf.Struct to describe the input of the function. This input is a JSON object that contains the function's parameters as properties of the object.
    MethodType string
    Optional. The method type of the function. If not specified, the default value is GET. Possible values are: GET, POST, PUT, DELETE, PATCH.
    OutputSchema string
    Optional. The JSON schema is encapsulated in a google.protobuf.Struct to describe the output of the function. This output is a JSON object that contains the function's parameters as properties of the object.
    InputSchema string
    Optional. The JSON schema is encapsulated in a google.protobuf.Struct to describe the input of the function. This input is a JSON object that contains the function's parameters as properties of the object.
    MethodType string
    Optional. The method type of the function. If not specified, the default value is GET. Possible values are: GET, POST, PUT, DELETE, PATCH.
    OutputSchema string
    Optional. The JSON schema is encapsulated in a google.protobuf.Struct to describe the output of the function. This output is a JSON object that contains the function's parameters as properties of the object.
    input_schema string
    Optional. The JSON schema is encapsulated in a google.protobuf.Struct to describe the input of the function. This input is a JSON object that contains the function's parameters as properties of the object.
    method_type string
    Optional. The method type of the function. If not specified, the default value is GET. Possible values are: GET, POST, PUT, DELETE, PATCH.
    output_schema string
    Optional. The JSON schema is encapsulated in a google.protobuf.Struct to describe the output of the function. This output is a JSON object that contains the function's parameters as properties of the object.
    inputSchema String
    Optional. The JSON schema is encapsulated in a google.protobuf.Struct to describe the input of the function. This input is a JSON object that contains the function's parameters as properties of the object.
    methodType String
    Optional. The method type of the function. If not specified, the default value is GET. Possible values are: GET, POST, PUT, DELETE, PATCH.
    outputSchema String
    Optional. The JSON schema is encapsulated in a google.protobuf.Struct to describe the output of the function. This output is a JSON object that contains the function's parameters as properties of the object.
    inputSchema string
    Optional. The JSON schema is encapsulated in a google.protobuf.Struct to describe the input of the function. This input is a JSON object that contains the function's parameters as properties of the object.
    methodType string
    Optional. The method type of the function. If not specified, the default value is GET. Possible values are: GET, POST, PUT, DELETE, PATCH.
    outputSchema string
    Optional. The JSON schema is encapsulated in a google.protobuf.Struct to describe the output of the function. This output is a JSON object that contains the function's parameters as properties of the object.
    input_schema str
    Optional. The JSON schema is encapsulated in a google.protobuf.Struct to describe the input of the function. This input is a JSON object that contains the function's parameters as properties of the object.
    method_type str
    Optional. The method type of the function. If not specified, the default value is GET. Possible values are: GET, POST, PUT, DELETE, PATCH.
    output_schema str
    Optional. The JSON schema is encapsulated in a google.protobuf.Struct to describe the output of the function. This output is a JSON object that contains the function's parameters as properties of the object.
    inputSchema String
    Optional. The JSON schema is encapsulated in a google.protobuf.Struct to describe the input of the function. This input is a JSON object that contains the function's parameters as properties of the object.
    methodType String
    Optional. The method type of the function. If not specified, the default value is GET. Possible values are: GET, POST, PUT, DELETE, PATCH.
    outputSchema String
    Optional. The JSON schema is encapsulated in a google.protobuf.Struct to describe the output of the function. This output is a JSON object that contains the function's parameters as properties of the object.

    ToolOpenApiSpec, ToolOpenApiSpecArgs

    TextSchema string
    Required. The OpenAPI schema specified as a text. Note: Plays a role in linking the OpenAPI spec with the tool. The info.title field in the OpenAPI schema must match the toolKey of the tool, otherwise the API will overwrite info.title with toolKey.
    Authentication ToolOpenApiSpecAuthentication
    Optional. Authentication information required by the API. Structure is documented below.
    ServiceDirectoryConfig ToolOpenApiSpecServiceDirectoryConfig
    Optional. Service Directory configuration. Structure is documented below.
    TlsConfig ToolOpenApiSpecTlsConfig
    Optional. TLS configuration for the HTTPS verification. Structure is documented below.
    TextSchema string
    Required. The OpenAPI schema specified as a text. Note: Plays a role in linking the OpenAPI spec with the tool. The info.title field in the OpenAPI schema must match the toolKey of the tool, otherwise the API will overwrite info.title with toolKey.
    Authentication ToolOpenApiSpecAuthentication
    Optional. Authentication information required by the API. Structure is documented below.
    ServiceDirectoryConfig ToolOpenApiSpecServiceDirectoryConfig
    Optional. Service Directory configuration. Structure is documented below.
    TlsConfig ToolOpenApiSpecTlsConfig
    Optional. TLS configuration for the HTTPS verification. Structure is documented below.
    text_schema string
    Required. The OpenAPI schema specified as a text. Note: Plays a role in linking the OpenAPI spec with the tool. The info.title field in the OpenAPI schema must match the toolKey of the tool, otherwise the API will overwrite info.title with toolKey.
    authentication object
    Optional. Authentication information required by the API. Structure is documented below.
    service_directory_config object
    Optional. Service Directory configuration. Structure is documented below.
    tls_config object
    Optional. TLS configuration for the HTTPS verification. Structure is documented below.
    textSchema String
    Required. The OpenAPI schema specified as a text. Note: Plays a role in linking the OpenAPI spec with the tool. The info.title field in the OpenAPI schema must match the toolKey of the tool, otherwise the API will overwrite info.title with toolKey.
    authentication ToolOpenApiSpecAuthentication
    Optional. Authentication information required by the API. Structure is documented below.
    serviceDirectoryConfig ToolOpenApiSpecServiceDirectoryConfig
    Optional. Service Directory configuration. Structure is documented below.
    tlsConfig ToolOpenApiSpecTlsConfig
    Optional. TLS configuration for the HTTPS verification. Structure is documented below.
    textSchema string
    Required. The OpenAPI schema specified as a text. Note: Plays a role in linking the OpenAPI spec with the tool. The info.title field in the OpenAPI schema must match the toolKey of the tool, otherwise the API will overwrite info.title with toolKey.
    authentication ToolOpenApiSpecAuthentication
    Optional. Authentication information required by the API. Structure is documented below.
    serviceDirectoryConfig ToolOpenApiSpecServiceDirectoryConfig
    Optional. Service Directory configuration. Structure is documented below.
    tlsConfig ToolOpenApiSpecTlsConfig
    Optional. TLS configuration for the HTTPS verification. Structure is documented below.
    text_schema str
    Required. The OpenAPI schema specified as a text. Note: Plays a role in linking the OpenAPI spec with the tool. The info.title field in the OpenAPI schema must match the toolKey of the tool, otherwise the API will overwrite info.title with toolKey.
    authentication ToolOpenApiSpecAuthentication
    Optional. Authentication information required by the API. Structure is documented below.
    service_directory_config ToolOpenApiSpecServiceDirectoryConfig
    Optional. Service Directory configuration. Structure is documented below.
    tls_config ToolOpenApiSpecTlsConfig
    Optional. TLS configuration for the HTTPS verification. Structure is documented below.
    textSchema String
    Required. The OpenAPI schema specified as a text. Note: Plays a role in linking the OpenAPI spec with the tool. The info.title field in the OpenAPI schema must match the toolKey of the tool, otherwise the API will overwrite info.title with toolKey.
    authentication Property Map
    Optional. Authentication information required by the API. Structure is documented below.
    serviceDirectoryConfig Property Map
    Optional. Service Directory configuration. Structure is documented below.
    tlsConfig Property Map
    Optional. TLS configuration for the HTTPS verification. Structure is documented below.

    ToolOpenApiSpecAuthentication, ToolOpenApiSpecAuthenticationArgs

    ApiKeyConfig ToolOpenApiSpecAuthenticationApiKeyConfig
    Config for API key auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    BearerTokenConfig ToolOpenApiSpecAuthenticationBearerTokenConfig
    Config for bearer token auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    OauthConfig ToolOpenApiSpecAuthenticationOauthConfig
    Config for OAuth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    ServiceAgentAuthConfig ToolOpenApiSpecAuthenticationServiceAgentAuthConfig
    Config for Dialogflow service agent auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    ApiKeyConfig ToolOpenApiSpecAuthenticationApiKeyConfig
    Config for API key auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    BearerTokenConfig ToolOpenApiSpecAuthenticationBearerTokenConfig
    Config for bearer token auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    OauthConfig ToolOpenApiSpecAuthenticationOauthConfig
    Config for OAuth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    ServiceAgentAuthConfig ToolOpenApiSpecAuthenticationServiceAgentAuthConfig
    Config for Dialogflow service agent auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    api_key_config object
    Config for API key auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    bearer_token_config object
    Config for bearer token auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    oauth_config object
    Config for OAuth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    service_agent_auth_config object
    Config for Dialogflow service agent auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    apiKeyConfig ToolOpenApiSpecAuthenticationApiKeyConfig
    Config for API key auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    bearerTokenConfig ToolOpenApiSpecAuthenticationBearerTokenConfig
    Config for bearer token auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    oauthConfig ToolOpenApiSpecAuthenticationOauthConfig
    Config for OAuth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    serviceAgentAuthConfig ToolOpenApiSpecAuthenticationServiceAgentAuthConfig
    Config for Dialogflow service agent auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    apiKeyConfig ToolOpenApiSpecAuthenticationApiKeyConfig
    Config for API key auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    bearerTokenConfig ToolOpenApiSpecAuthenticationBearerTokenConfig
    Config for bearer token auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    oauthConfig ToolOpenApiSpecAuthenticationOauthConfig
    Config for OAuth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    serviceAgentAuthConfig ToolOpenApiSpecAuthenticationServiceAgentAuthConfig
    Config for Dialogflow service agent auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    api_key_config ToolOpenApiSpecAuthenticationApiKeyConfig
    Config for API key auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    bearer_token_config ToolOpenApiSpecAuthenticationBearerTokenConfig
    Config for bearer token auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    oauth_config ToolOpenApiSpecAuthenticationOauthConfig
    Config for OAuth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    service_agent_auth_config ToolOpenApiSpecAuthenticationServiceAgentAuthConfig
    Config for Dialogflow service agent auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    apiKeyConfig Property Map
    Config for API key auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    bearerTokenConfig Property Map
    Config for bearer token auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    oauthConfig Property Map
    Config for OAuth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.
    serviceAgentAuthConfig Property Map
    Config for Dialogflow service agent auth. This field is part of a union field authConfig: Only one of apiKeyConfig, oauthConfig, serviceAgentAuthConfig, or bearerTokenConfig may be set. Structure is documented below.

    ToolOpenApiSpecAuthenticationApiKeyConfig, ToolOpenApiSpecAuthenticationApiKeyConfigArgs

    KeyName string
    The parameter name or the header name of the API key. E.g., If the API request is "https://example.com/act?X-Api-Key=", "X-Api-Key" would be the parameter name.
    RequestLocation string
    Key location in the request. Possible values are: HEADER, QUERY_STRING.
    ApiKey string
    Optional. The API key. If the secretVersionForApiKey field is set, this field will be ignored. Note: This property is sensitive and will not be displayed in the plan.
    SecretVersionForApiKey string
    Optional. The name of the SecretManager secret version resource storing the API key. If this field is set, the apiKey field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}
    KeyName string
    The parameter name or the header name of the API key. E.g., If the API request is "https://example.com/act?X-Api-Key=", "X-Api-Key" would be the parameter name.
    RequestLocation string
    Key location in the request. Possible values are: HEADER, QUERY_STRING.
    ApiKey string
    Optional. The API key. If the secretVersionForApiKey field is set, this field will be ignored. Note: This property is sensitive and will not be displayed in the plan.
    SecretVersionForApiKey string
    Optional. The name of the SecretManager secret version resource storing the API key. If this field is set, the apiKey field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}
    key_name string
    The parameter name or the header name of the API key. E.g., If the API request is "https://example.com/act?X-Api-Key=", "X-Api-Key" would be the parameter name.
    request_location string
    Key location in the request. Possible values are: HEADER, QUERY_STRING.
    api_key string
    Optional. The API key. If the secretVersionForApiKey field is set, this field will be ignored. Note: This property is sensitive and will not be displayed in the plan.
    secret_version_for_api_key string
    Optional. The name of the SecretManager secret version resource storing the API key. If this field is set, the apiKey field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}
    keyName String
    The parameter name or the header name of the API key. E.g., If the API request is "https://example.com/act?X-Api-Key=", "X-Api-Key" would be the parameter name.
    requestLocation String
    Key location in the request. Possible values are: HEADER, QUERY_STRING.
    apiKey String
    Optional. The API key. If the secretVersionForApiKey field is set, this field will be ignored. Note: This property is sensitive and will not be displayed in the plan.
    secretVersionForApiKey String
    Optional. The name of the SecretManager secret version resource storing the API key. If this field is set, the apiKey field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}
    keyName string
    The parameter name or the header name of the API key. E.g., If the API request is "https://example.com/act?X-Api-Key=", "X-Api-Key" would be the parameter name.
    requestLocation string
    Key location in the request. Possible values are: HEADER, QUERY_STRING.
    apiKey string
    Optional. The API key. If the secretVersionForApiKey field is set, this field will be ignored. Note: This property is sensitive and will not be displayed in the plan.
    secretVersionForApiKey string
    Optional. The name of the SecretManager secret version resource storing the API key. If this field is set, the apiKey field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}
    key_name str
    The parameter name or the header name of the API key. E.g., If the API request is "https://example.com/act?X-Api-Key=", "X-Api-Key" would be the parameter name.
    request_location str
    Key location in the request. Possible values are: HEADER, QUERY_STRING.
    api_key str
    Optional. The API key. If the secretVersionForApiKey field is set, this field will be ignored. Note: This property is sensitive and will not be displayed in the plan.
    secret_version_for_api_key str
    Optional. The name of the SecretManager secret version resource storing the API key. If this field is set, the apiKey field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}
    keyName String
    The parameter name or the header name of the API key. E.g., If the API request is "https://example.com/act?X-Api-Key=", "X-Api-Key" would be the parameter name.
    requestLocation String
    Key location in the request. Possible values are: HEADER, QUERY_STRING.
    apiKey String
    Optional. The API key. If the secretVersionForApiKey field is set, this field will be ignored. Note: This property is sensitive and will not be displayed in the plan.
    secretVersionForApiKey String
    Optional. The name of the SecretManager secret version resource storing the API key. If this field is set, the apiKey field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}

    ToolOpenApiSpecAuthenticationBearerTokenConfig, ToolOpenApiSpecAuthenticationBearerTokenConfigArgs

    SecretVersionForToken string
    Optional. The name of the SecretManager secret version resource storing the Bearer token. If this field is set, the token field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}
    Token string
    Optional. The text token appended to the text Bearer to the request Authorization header. Note: This property is sensitive and will not be displayed in the plan.
    SecretVersionForToken string
    Optional. The name of the SecretManager secret version resource storing the Bearer token. If this field is set, the token field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}
    Token string
    Optional. The text token appended to the text Bearer to the request Authorization header. Note: This property is sensitive and will not be displayed in the plan.
    secret_version_for_token string
    Optional. The name of the SecretManager secret version resource storing the Bearer token. If this field is set, the token field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}
    token string
    Optional. The text token appended to the text Bearer to the request Authorization header. Note: This property is sensitive and will not be displayed in the plan.
    secretVersionForToken String
    Optional. The name of the SecretManager secret version resource storing the Bearer token. If this field is set, the token field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}
    token String
    Optional. The text token appended to the text Bearer to the request Authorization header. Note: This property is sensitive and will not be displayed in the plan.
    secretVersionForToken string
    Optional. The name of the SecretManager secret version resource storing the Bearer token. If this field is set, the token field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}
    token string
    Optional. The text token appended to the text Bearer to the request Authorization header. Note: This property is sensitive and will not be displayed in the plan.
    secret_version_for_token str
    Optional. The name of the SecretManager secret version resource storing the Bearer token. If this field is set, the token field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}
    token str
    Optional. The text token appended to the text Bearer to the request Authorization header. Note: This property is sensitive and will not be displayed in the plan.
    secretVersionForToken String
    Optional. The name of the SecretManager secret version resource storing the Bearer token. If this field is set, the token field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}
    token String
    Optional. The text token appended to the text Bearer to the request Authorization header. Note: This property is sensitive and will not be displayed in the plan.

    ToolOpenApiSpecAuthenticationOauthConfig, ToolOpenApiSpecAuthenticationOauthConfigArgs

    ClientId string
    The client ID from the OAuth provider.
    OauthGrantType string
    OAuth grant types. Possible values are: CLIENT_CREDENTIAL.
    TokenEndpoint string
    The token endpoint in the OAuth provider to exchange for an access token.
    ClientSecret string
    Optional. The client secret from the OAuth provider. If the secretVersionForClientSecret field is set, this field will be ignored. Note: This property is sensitive and will not be displayed in the plan.
    Scopes List<string>
    Optional. The OAuth scopes to grant.
    SecretVersionForClientSecret string
    Optional. The name of the SecretManager secret version resource storing the client secret. If this field is set, the clientSecret field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}
    ClientId string
    The client ID from the OAuth provider.
    OauthGrantType string
    OAuth grant types. Possible values are: CLIENT_CREDENTIAL.
    TokenEndpoint string
    The token endpoint in the OAuth provider to exchange for an access token.
    ClientSecret string
    Optional. The client secret from the OAuth provider. If the secretVersionForClientSecret field is set, this field will be ignored. Note: This property is sensitive and will not be displayed in the plan.
    Scopes []string
    Optional. The OAuth scopes to grant.
    SecretVersionForClientSecret string
    Optional. The name of the SecretManager secret version resource storing the client secret. If this field is set, the clientSecret field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}
    client_id string
    The client ID from the OAuth provider.
    oauth_grant_type string
    OAuth grant types. Possible values are: CLIENT_CREDENTIAL.
    token_endpoint string
    The token endpoint in the OAuth provider to exchange for an access token.
    client_secret string
    Optional. The client secret from the OAuth provider. If the secretVersionForClientSecret field is set, this field will be ignored. Note: This property is sensitive and will not be displayed in the plan.
    scopes list(string)
    Optional. The OAuth scopes to grant.
    secret_version_for_client_secret string
    Optional. The name of the SecretManager secret version resource storing the client secret. If this field is set, the clientSecret field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}
    clientId String
    The client ID from the OAuth provider.
    oauthGrantType String
    OAuth grant types. Possible values are: CLIENT_CREDENTIAL.
    tokenEndpoint String
    The token endpoint in the OAuth provider to exchange for an access token.
    clientSecret String
    Optional. The client secret from the OAuth provider. If the secretVersionForClientSecret field is set, this field will be ignored. Note: This property is sensitive and will not be displayed in the plan.
    scopes List<String>
    Optional. The OAuth scopes to grant.
    secretVersionForClientSecret String
    Optional. The name of the SecretManager secret version resource storing the client secret. If this field is set, the clientSecret field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}
    clientId string
    The client ID from the OAuth provider.
    oauthGrantType string
    OAuth grant types. Possible values are: CLIENT_CREDENTIAL.
    tokenEndpoint string
    The token endpoint in the OAuth provider to exchange for an access token.
    clientSecret string
    Optional. The client secret from the OAuth provider. If the secretVersionForClientSecret field is set, this field will be ignored. Note: This property is sensitive and will not be displayed in the plan.
    scopes string[]
    Optional. The OAuth scopes to grant.
    secretVersionForClientSecret string
    Optional. The name of the SecretManager secret version resource storing the client secret. If this field is set, the clientSecret field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}
    client_id str
    The client ID from the OAuth provider.
    oauth_grant_type str
    OAuth grant types. Possible values are: CLIENT_CREDENTIAL.
    token_endpoint str
    The token endpoint in the OAuth provider to exchange for an access token.
    client_secret str
    Optional. The client secret from the OAuth provider. If the secretVersionForClientSecret field is set, this field will be ignored. Note: This property is sensitive and will not be displayed in the plan.
    scopes Sequence[str]
    Optional. The OAuth scopes to grant.
    secret_version_for_client_secret str
    Optional. The name of the SecretManager secret version resource storing the client secret. If this field is set, the clientSecret field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}
    clientId String
    The client ID from the OAuth provider.
    oauthGrantType String
    OAuth grant types. Possible values are: CLIENT_CREDENTIAL.
    tokenEndpoint String
    The token endpoint in the OAuth provider to exchange for an access token.
    clientSecret String
    Optional. The client secret from the OAuth provider. If the secretVersionForClientSecret field is set, this field will be ignored. Note: This property is sensitive and will not be displayed in the plan.
    scopes List<String>
    Optional. The OAuth scopes to grant.
    secretVersionForClientSecret String
    Optional. The name of the SecretManager secret version resource storing the client secret. If this field is set, the clientSecret field will be ignored. Format: projects/{project}/secrets/{secret}/versions/{version}

    ToolOpenApiSpecAuthenticationServiceAgentAuthConfig, ToolOpenApiSpecAuthenticationServiceAgentAuthConfigArgs

    ServiceAgentAuth string
    Optional. Indicate the auth token type generated from the Dialogflow service agent. The generated token is sent in the Authorization header. Possible values are: ID_TOKEN, ACCESS_TOKEN.
    ServiceAgentAuth string
    Optional. Indicate the auth token type generated from the Dialogflow service agent. The generated token is sent in the Authorization header. Possible values are: ID_TOKEN, ACCESS_TOKEN.
    service_agent_auth string
    Optional. Indicate the auth token type generated from the Dialogflow service agent. The generated token is sent in the Authorization header. Possible values are: ID_TOKEN, ACCESS_TOKEN.
    serviceAgentAuth String
    Optional. Indicate the auth token type generated from the Dialogflow service agent. The generated token is sent in the Authorization header. Possible values are: ID_TOKEN, ACCESS_TOKEN.
    serviceAgentAuth string
    Optional. Indicate the auth token type generated from the Dialogflow service agent. The generated token is sent in the Authorization header. Possible values are: ID_TOKEN, ACCESS_TOKEN.
    service_agent_auth str
    Optional. Indicate the auth token type generated from the Dialogflow service agent. The generated token is sent in the Authorization header. Possible values are: ID_TOKEN, ACCESS_TOKEN.
    serviceAgentAuth String
    Optional. Indicate the auth token type generated from the Dialogflow service agent. The generated token is sent in the Authorization header. Possible values are: ID_TOKEN, ACCESS_TOKEN.

    ToolOpenApiSpecServiceDirectoryConfig, ToolOpenApiSpecServiceDirectoryConfigArgs

    Service string
    The name of Service Directory service. Format: projects/<ProjectID>/locations/<LocationID>/namespaces/<NamespaceID>/services/<ServiceID>. LocationID of the service directory must be the same as the location of the tool.
    Service string
    The name of Service Directory service. Format: projects/<ProjectID>/locations/<LocationID>/namespaces/<NamespaceID>/services/<ServiceID>. LocationID of the service directory must be the same as the location of the tool.
    service string
    The name of Service Directory service. Format: projects/<ProjectID>/locations/<LocationID>/namespaces/<NamespaceID>/services/<ServiceID>. LocationID of the service directory must be the same as the location of the tool.
    service String
    The name of Service Directory service. Format: projects/<ProjectID>/locations/<LocationID>/namespaces/<NamespaceID>/services/<ServiceID>. LocationID of the service directory must be the same as the location of the tool.
    service string
    The name of Service Directory service. Format: projects/<ProjectID>/locations/<LocationID>/namespaces/<NamespaceID>/services/<ServiceID>. LocationID of the service directory must be the same as the location of the tool.
    service str
    The name of Service Directory service. Format: projects/<ProjectID>/locations/<LocationID>/namespaces/<NamespaceID>/services/<ServiceID>. LocationID of the service directory must be the same as the location of the tool.
    service String
    The name of Service Directory service. Format: projects/<ProjectID>/locations/<LocationID>/namespaces/<NamespaceID>/services/<ServiceID>. LocationID of the service directory must be the same as the location of the tool.

    ToolOpenApiSpecTlsConfig, ToolOpenApiSpecTlsConfigArgs

    CaCerts List<ToolOpenApiSpecTlsConfigCaCert>
    Specifies a list of allowed custom CA certificates for HTTPS verification. Structure is documented below.
    CaCerts []ToolOpenApiSpecTlsConfigCaCert
    Specifies a list of allowed custom CA certificates for HTTPS verification. Structure is documented below.
    ca_certs list(object)
    Specifies a list of allowed custom CA certificates for HTTPS verification. Structure is documented below.
    caCerts List<ToolOpenApiSpecTlsConfigCaCert>
    Specifies a list of allowed custom CA certificates for HTTPS verification. Structure is documented below.
    caCerts ToolOpenApiSpecTlsConfigCaCert[]
    Specifies a list of allowed custom CA certificates for HTTPS verification. Structure is documented below.
    ca_certs Sequence[ToolOpenApiSpecTlsConfigCaCert]
    Specifies a list of allowed custom CA certificates for HTTPS verification. Structure is documented below.
    caCerts List<Property Map>
    Specifies a list of allowed custom CA certificates for HTTPS verification. Structure is documented below.

    ToolOpenApiSpecTlsConfigCaCert, ToolOpenApiSpecTlsConfigCaCertArgs

    Cert string
    The allowed custom CA certificates (in DER format) for HTTPS verification. This overrides the default SSL trust store. If this is empty or unspecified, Dialogflow will use Google's default trust store to verify certificates. N.B. Make sure the HTTPS server certificates are signed with "subject alt name". A base64-encoded string.
    DisplayName string
    The name of the allowed custom CA certificates. This can be used to disambiguate the custom CA certificates.
    Cert string
    The allowed custom CA certificates (in DER format) for HTTPS verification. This overrides the default SSL trust store. If this is empty or unspecified, Dialogflow will use Google's default trust store to verify certificates. N.B. Make sure the HTTPS server certificates are signed with "subject alt name". A base64-encoded string.
    DisplayName string
    The name of the allowed custom CA certificates. This can be used to disambiguate the custom CA certificates.
    cert string
    The allowed custom CA certificates (in DER format) for HTTPS verification. This overrides the default SSL trust store. If this is empty or unspecified, Dialogflow will use Google's default trust store to verify certificates. N.B. Make sure the HTTPS server certificates are signed with "subject alt name". A base64-encoded string.
    display_name string
    The name of the allowed custom CA certificates. This can be used to disambiguate the custom CA certificates.
    cert String
    The allowed custom CA certificates (in DER format) for HTTPS verification. This overrides the default SSL trust store. If this is empty or unspecified, Dialogflow will use Google's default trust store to verify certificates. N.B. Make sure the HTTPS server certificates are signed with "subject alt name". A base64-encoded string.
    displayName String
    The name of the allowed custom CA certificates. This can be used to disambiguate the custom CA certificates.
    cert string
    The allowed custom CA certificates (in DER format) for HTTPS verification. This overrides the default SSL trust store. If this is empty or unspecified, Dialogflow will use Google's default trust store to verify certificates. N.B. Make sure the HTTPS server certificates are signed with "subject alt name". A base64-encoded string.
    displayName string
    The name of the allowed custom CA certificates. This can be used to disambiguate the custom CA certificates.
    cert str
    The allowed custom CA certificates (in DER format) for HTTPS verification. This overrides the default SSL trust store. If this is empty or unspecified, Dialogflow will use Google's default trust store to verify certificates. N.B. Make sure the HTTPS server certificates are signed with "subject alt name". A base64-encoded string.
    display_name str
    The name of the allowed custom CA certificates. This can be used to disambiguate the custom CA certificates.
    cert String
    The allowed custom CA certificates (in DER format) for HTTPS verification. This overrides the default SSL trust store. If this is empty or unspecified, Dialogflow will use Google's default trust store to verify certificates. N.B. Make sure the HTTPS server certificates are signed with "subject alt name". A base64-encoded string.
    displayName String
    The name of the allowed custom CA certificates. This can be used to disambiguate the custom CA certificates.

    Import

    Tool can be imported using any of these accepted formats:

    • projects/{{project}}/locations/{{location}}/tools/{{name}}
    • {{project}}/{{location}}/{{name}}
    • {{location}}/{{name}}

    When using the pulumi import command, Tool can be imported using one of the formats above. For example:

    $ pulumi import gcp:diagflow/tool:Tool default projects/{{project}}/locations/{{location}}/tools/{{name}}
    $ pulumi import gcp:diagflow/tool:Tool default {{project}}/{{location}}/{{name}}
    $ pulumi import gcp:diagflow/tool:Tool default {{location}}/{{name}}
    

    To learn more about importing existing cloud resources, see Importing resources.

    Package Details

    Repository
    Google Cloud (GCP) Classic pulumi/pulumi-gcp
    License
    Apache-2.0
    Notes
    This Pulumi package is based on the google-beta Terraform Provider.
    gcp logo
    Viewing docs for Google Cloud v10.2.0
    published on Tuesday, Oct 20, 2026 by Pulumi

      Try Pulumi Cloud free.
      Your team will thank you.

      Start free trial