elasticstack.KibanaAgentbuilderTool

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

// ES|QL tool
const esqlTool = new elasticstack.KibanaAgentbuilderTool("esql_tool", {
    toolId: "my-esql-tool",
    type: "esql",
    description: "Analyzes trade data with time filtering",
    tags: [
        "analytics",
        "finance",
    ],
    configuration: JSON.stringify({
        query: "FROM financial_trades | WHERE execution_timestamp >= ?startTime | STATS trade_count=COUNT(*), avg_price=AVG(execution_price) BY symbol | SORT trade_count DESC | LIMIT ?limit",
        params: {
            limit: {
                type: "integer",
                description: "Maximum number of results to return",
            },
            startTime: {
                type: "date",
                description: "Start time for the analysis in ISO format",
            },
        },
    }),
});
// Workflow tool — references an agent builder workflow
const myWorkflow = new elasticstack.KibanaAgentbuilderWorkflow("my_workflow", {configurationYaml: `name: My Workflow
enabled: true
triggers:
  - type: manual
inputs:
  - name: message
    type: string
    default: \\"hello world\\"
steps:
  - name: hello_world_step
    type: console
    with:
      message: \\"{{ inputs.message }}\\"
`});
const workflowTool = new elasticstack.KibanaAgentbuilderTool("workflow_tool", {
    toolId: "my-workflow-tool",
    type: "workflow",
    description: "Exposes a workflow as an agent tool",
    configuration: pulumi.jsonStringify({
        workflow_id: myWorkflow.workflowId,
    }),
});

import pulumi
import json
import pulumi_elasticstack as elasticstack

# ES|QL tool
esql_tool = elasticstack.KibanaAgentbuilderTool("esql_tool",
    tool_id="my-esql-tool",
    type="esql",
    description="Analyzes trade data with time filtering",
    tags=[
        "analytics",
        "finance",
    ],
    configuration=json.dumps({
        "query": "FROM financial_trades | WHERE execution_timestamp >= ?startTime | STATS trade_count=COUNT(*), avg_price=AVG(execution_price) BY symbol | SORT trade_count DESC | LIMIT ?limit",
        "params": {
            "limit": {
                "type": "integer",
                "description": "Maximum number of results to return",
            },
            "startTime": {
                "type": "date",
                "description": "Start time for the analysis in ISO format",
            },
        },
    }))
# Workflow tool — references an agent builder workflow
my_workflow = elasticstack.KibanaAgentbuilderWorkflow("my_workflow", configuration_yaml="""name: My Workflow
enabled: true
triggers:
  - type: manual
inputs:
  - name: message
    type: string
    default: \"hello world\"
steps:
  - name: hello_world_step
    type: console
    with:
      message: \"{{ inputs.message }}\"
""")
workflow_tool = elasticstack.KibanaAgentbuilderTool("workflow_tool",
    tool_id="my-workflow-tool",
    type="workflow",
    description="Exposes a workflow as an agent tool",
    configuration=pulumi.Output.json_dumps({
        "workflow_id": my_workflow.workflow_id,
    }))

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-terraform-provider/sdks/go/elasticstack/elasticstack"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"query": "FROM financial_trades | WHERE execution_timestamp >= ?startTime | STATS trade_count=COUNT(*), avg_price=AVG(execution_price) BY symbol | SORT trade_count DESC | LIMIT ?limit",
			"params": map[string]interface{}{
				"limit": map[string]interface{}{
					"type":        "integer",
					"description": "Maximum number of results to return",
				},
				"startTime": map[string]interface{}{
					"type":        "date",
					"description": "Start time for the analysis in ISO format",
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		// ES|QL tool
		_, err = elasticstack.NewKibanaAgentbuilderTool(ctx, "esql_tool", &elasticstack.KibanaAgentbuilderToolArgs{
			ToolId:      pulumi.String("my-esql-tool"),
			Type:        pulumi.String("esql"),
			Description: pulumi.String("Analyzes trade data with time filtering"),
			Tags: pulumi.StringArray{
				pulumi.String("analytics"),
				pulumi.String("finance"),
			},
			Configuration: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		// Workflow tool — references an agent builder workflow
		myWorkflow, err := elasticstack.NewKibanaAgentbuilderWorkflow(ctx, "my_workflow", &elasticstack.KibanaAgentbuilderWorkflowArgs{
			ConfigurationYaml: pulumi.String(`name: My Workflow
enabled: true
triggers:
  - type: manual
inputs:
  - name: message
    type: string
    default: \"hello world\"
steps:
  - name: hello_world_step
    type: console
    with:
      message: \"{{ inputs.message }}\"
`),
		})
		if err != nil {
			return err
		}
		_, err = elasticstack.NewKibanaAgentbuilderTool(ctx, "workflow_tool", &elasticstack.KibanaAgentbuilderToolArgs{
			ToolId:      pulumi.String("my-workflow-tool"),
			Type:        pulumi.String("workflow"),
			Description: pulumi.String("Exposes a workflow as an agent tool"),
			Configuration: myWorkflow.WorkflowId.ApplyT(func(workflowId string) (pulumi.String, error) {
				var _zero pulumi.String
				tmpJSON1, err := json.Marshal(map[string]interface{}{
					"workflow_id": workflowId,
				})
				if err != nil {
					return _zero, err
				}
				json1 := string(tmpJSON1)
				return pulumi.String(json1), nil
			}).(pulumi.StringOutput),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Elasticstack = Pulumi.Elasticstack;

return await Deployment.RunAsync(() => 
{
    // ES|QL tool
    var esqlTool = new Elasticstack.KibanaAgentbuilderTool("esql_tool", new()
    {
        ToolId = "my-esql-tool",
        Type = "esql",
        Description = "Analyzes trade data with time filtering",
        Tags = new[]
        {
            "analytics",
            "finance",
        },
        Configuration = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["query"] = "FROM financial_trades | WHERE execution_timestamp >= ?startTime | STATS trade_count=COUNT(*), avg_price=AVG(execution_price) BY symbol | SORT trade_count DESC | LIMIT ?limit",
            ["params"] = new Dictionary<string, object?>
            {
                ["limit"] = new Dictionary<string, object?>
                {
                    ["type"] = "integer",
                    ["description"] = "Maximum number of results to return",
                },
                ["startTime"] = new Dictionary<string, object?>
                {
                    ["type"] = "date",
                    ["description"] = "Start time for the analysis in ISO format",
                },
            },
        }),
    });

    // Workflow tool — references an agent builder workflow
    var myWorkflow = new Elasticstack.KibanaAgentbuilderWorkflow("my_workflow", new()
    {
        ConfigurationYaml = @"name: My Workflow
enabled: true
triggers:
  - type: manual
inputs:
  - name: message
    type: string
    default: \""hello world\""
steps:
  - name: hello_world_step
    type: console
    with:
      message: \""{{ inputs.message }}\""
",
    });

    var workflowTool = new Elasticstack.KibanaAgentbuilderTool("workflow_tool", new()
    {
        ToolId = "my-workflow-tool",
        Type = "workflow",
        Description = "Exposes a workflow as an agent tool",
        Configuration = Output.JsonSerialize(Output.Create(new Dictionary<string, object?>
        {
            ["workflow_id"] = myWorkflow.WorkflowId,
        })),
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.elasticstack.KibanaAgentbuilderTool;
import com.pulumi.elasticstack.KibanaAgentbuilderToolArgs;
import com.pulumi.elasticstack.KibanaAgentbuilderWorkflow;
import com.pulumi.elasticstack.KibanaAgentbuilderWorkflowArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        // ES|QL tool
        var esqlTool = new KibanaAgentbuilderTool("esqlTool", KibanaAgentbuilderToolArgs.builder()
            .toolId("my-esql-tool")
            .type("esql")
            .description("Analyzes trade data with time filtering")
            .tags(            
                "analytics",
                "finance")
            .configuration(serializeJson(
                jsonObject(
                    jsonProperty("query", "FROM financial_trades | WHERE execution_timestamp >= ?startTime | STATS trade_count=COUNT(*), avg_price=AVG(execution_price) BY symbol | SORT trade_count DESC | LIMIT ?limit"),
                    jsonProperty("params", jsonObject(
                        jsonProperty("limit", jsonObject(
                            jsonProperty("type", "integer"),
                            jsonProperty("description", "Maximum number of results to return")
                        )),
                        jsonProperty("startTime", jsonObject(
                            jsonProperty("type", "date"),
                            jsonProperty("description", "Start time for the analysis in ISO format")
                        ))
                    ))
                )))
            .build());

        // Workflow tool — references an agent builder workflow
        var myWorkflow = new KibanaAgentbuilderWorkflow("myWorkflow", KibanaAgentbuilderWorkflowArgs.builder()
            .configurationYaml("""
name: My Workflow
enabled: true
triggers:
  - type: manual
inputs:
  - name: message
    type: string
    default: \"hello world\"
steps:
  - name: hello_world_step
    type: console
    with:
      message: \"{{ inputs.message }}\"
            """)
            .build());

        var workflowTool = new KibanaAgentbuilderTool("workflowTool", KibanaAgentbuilderToolArgs.builder()
            .toolId("my-workflow-tool")
            .type("workflow")
            .description("Exposes a workflow as an agent tool")
            .configuration(myWorkflow.workflowId().applyValue(_workflowId -> serializeJson(
                jsonObject(
                    jsonProperty("workflow_id", _workflowId)
                ))))
            .build());

    }
}

resources:
  # ES|QL tool
  esqlTool:
    type: elasticstack:KibanaAgentbuilderTool
    name: esql_tool
    properties:
      toolId: my-esql-tool
      type: esql
      description: Analyzes trade data with time filtering
      tags:
        - analytics
        - finance
      configuration:
        fn::toJSON:
          query: FROM financial_trades | WHERE execution_timestamp >= ?startTime | STATS trade_count=COUNT(*), avg_price=AVG(execution_price) BY symbol | SORT trade_count DESC | LIMIT ?limit
          params:
            limit:
              type: integer
              description: Maximum number of results to return
            startTime:
              type: date
              description: Start time for the analysis in ISO format
  # Workflow tool — references an agent builder workflow
  myWorkflow:
    type: elasticstack:KibanaAgentbuilderWorkflow
    name: my_workflow
    properties:
      configurationYaml: |
        name: My Workflow
        enabled: true
        triggers:
          - type: manual
        inputs:
          - name: message
            type: string
            default: \"hello world\"
        steps:
          - name: hello_world_step
            type: console
            with:
              message: \"{{ inputs.message }}\"
  workflowTool:
    type: elasticstack:KibanaAgentbuilderTool
    name: workflow_tool
    properties:
      toolId: my-workflow-tool
      type: workflow
      description: Exposes a workflow as an agent tool
      configuration:
        fn::toJSON:
          workflow_id: ${myWorkflow.workflowId}

var kibanaAgentbuilderToolResource = new Elasticstack.KibanaAgentbuilderTool("kibanaAgentbuilderToolResource", new()
{
    Configuration = "string",
    ToolId = "string",
    Type = "string",
    Description = "string",
    KibanaConnections = new[]
    {
        new Elasticstack.Inputs.KibanaAgentbuilderToolKibanaConnectionArgs
        {
            ApiKey = "string",
            BearerToken = "string",
            CaCerts = new[]
            {
                "string",
            },
            Endpoints = new[]
            {
                "string",
            },
            Insecure = false,
            Password = "string",
            Username = "string",
        },
    },
    SpaceId = "string",
    Tags = new[]
    {
        "string",
    },
});

example, err := elasticstack.NewKibanaAgentbuilderTool(ctx, "kibanaAgentbuilderToolResource", &elasticstack.KibanaAgentbuilderToolArgs{
	Configuration: pulumi.String("string"),
	ToolId:        pulumi.String("string"),
	Type:          pulumi.String("string"),
	Description:   pulumi.String("string"),
	KibanaConnections: elasticstack.KibanaAgentbuilderToolKibanaConnectionArray{
		&elasticstack.KibanaAgentbuilderToolKibanaConnectionArgs{
			ApiKey:      pulumi.String("string"),
			BearerToken: pulumi.String("string"),
			CaCerts: pulumi.StringArray{
				pulumi.String("string"),
			},
			Endpoints: pulumi.StringArray{
				pulumi.String("string"),
			},
			Insecure: pulumi.Bool(false),
			Password: pulumi.String("string"),
			Username: pulumi.String("string"),
		},
	},
	SpaceId: pulumi.String("string"),
	Tags: pulumi.StringArray{
		pulumi.String("string"),
	},
})

resource "elasticstack_kibanaagentbuildertool" "kibanaAgentbuilderToolResource" {
  configuration = "string"
  tool_id       = "string"
  type          = "string"
  description   = "string"
  kibana_connections {
    api_key      = "string"
    bearer_token = "string"
    ca_certs     = ["string"]
    endpoints    = ["string"]
    insecure     = false
    password     = "string"
    username     = "string"
  }
  space_id = "string"
  tags     = ["string"]
}

var kibanaAgentbuilderToolResource = new KibanaAgentbuilderTool("kibanaAgentbuilderToolResource", KibanaAgentbuilderToolArgs.builder()
    .configuration("string")
    .toolId("string")
    .type("string")
    .description("string")
    .kibanaConnections(KibanaAgentbuilderToolKibanaConnectionArgs.builder()
        .apiKey("string")
        .bearerToken("string")
        .caCerts("string")
        .endpoints("string")
        .insecure(false)
        .password("string")
        .username("string")
        .build())
    .spaceId("string")
    .tags("string")
    .build());

kibana_agentbuilder_tool_resource = elasticstack.KibanaAgentbuilderTool("kibanaAgentbuilderToolResource",
    configuration="string",
    tool_id="string",
    type="string",
    description="string",
    kibana_connections=[{
        "api_key": "string",
        "bearer_token": "string",
        "ca_certs": ["string"],
        "endpoints": ["string"],
        "insecure": False,
        "password": "string",
        "username": "string",
    }],
    space_id="string",
    tags=["string"])

const kibanaAgentbuilderToolResource = new elasticstack.KibanaAgentbuilderTool("kibanaAgentbuilderToolResource", {
    configuration: "string",
    toolId: "string",
    type: "string",
    description: "string",
    kibanaConnections: [{
        apiKey: "string",
        bearerToken: "string",
        caCerts: ["string"],
        endpoints: ["string"],
        insecure: false,
        password: "string",
        username: "string",
    }],
    spaceId: "string",
    tags: ["string"],
});

type: elasticstack:KibanaAgentbuilderTool
properties:
    configuration: string
    description: string
    kibanaConnections:
        - apiKey: string
          bearerToken: string
          caCerts:
            - string
          endpoints:
            - string
          insecure: false
          password: string
          username: string
    spaceId: string
    tags:
        - string
    toolId: string
    type: string