gcp.ces.Evaluation

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

const app = new gcp.ces.App("app", {
    appId: "app-id",
    location: "us",
    displayName: "my-app",
    languageSettings: {
        defaultLanguageCode: "en-US",
    },
    timeZoneSettings: {
        timeZone: "America/Los_Angeles",
    },
});
const cesEvaluationBasic = new gcp.ces.Evaluation("ces_evaluation_basic", {
    evaluationId: "eval-basic",
    displayName: "my-evaluation-basic",
    location: "us",
    app: app.appId,
});

import pulumi
import pulumi_gcp as gcp

app = gcp.ces.App("app",
    app_id="app-id",
    location="us",
    display_name="my-app",
    language_settings={
        "default_language_code": "en-US",
    },
    time_zone_settings={
        "time_zone": "America/Los_Angeles",
    })
ces_evaluation_basic = gcp.ces.Evaluation("ces_evaluation_basic",
    evaluation_id="eval-basic",
    display_name="my-evaluation-basic",
    location="us",
    app=app.app_id)

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/ces"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		app, err := ces.NewApp(ctx, "app", &ces.AppArgs{
			AppId:       pulumi.String("app-id"),
			Location:    pulumi.String("us"),
			DisplayName: pulumi.String("my-app"),
			LanguageSettings: &ces.AppLanguageSettingsArgs{
				DefaultLanguageCode: pulumi.String("en-US"),
			},
			TimeZoneSettings: &ces.AppTimeZoneSettingsArgs{
				TimeZone: pulumi.String("America/Los_Angeles"),
			},
		})
		if err != nil {
			return err
		}
		_, err = ces.NewEvaluation(ctx, "ces_evaluation_basic", &ces.EvaluationArgs{
			EvaluationId: pulumi.String("eval-basic"),
			DisplayName:  pulumi.String("my-evaluation-basic"),
			Location:     pulumi.String("us"),
			App:          app.AppId,
		})
		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 app = new Gcp.Ces.App("app", new()
    {
        AppId = "app-id",
        Location = "us",
        DisplayName = "my-app",
        LanguageSettings = new Gcp.Ces.Inputs.AppLanguageSettingsArgs
        {
            DefaultLanguageCode = "en-US",
        },
        TimeZoneSettings = new Gcp.Ces.Inputs.AppTimeZoneSettingsArgs
        {
            TimeZone = "America/Los_Angeles",
        },
    });

    var cesEvaluationBasic = new Gcp.Ces.Evaluation("ces_evaluation_basic", new()
    {
        EvaluationId = "eval-basic",
        DisplayName = "my-evaluation-basic",
        Location = "us",
        App = app.AppId,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.ces.App;
import com.pulumi.gcp.ces.AppArgs;
import com.pulumi.gcp.ces.inputs.AppLanguageSettingsArgs;
import com.pulumi.gcp.ces.inputs.AppTimeZoneSettingsArgs;
import com.pulumi.gcp.ces.Evaluation;
import com.pulumi.gcp.ces.EvaluationArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

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

    public static void stack(Context ctx) {
        var app = new App("app", AppArgs.builder()
            .appId("app-id")
            .location("us")
            .displayName("my-app")
            .languageSettings(AppLanguageSettingsArgs.builder()
                .defaultLanguageCode("en-US")
                .build())
            .timeZoneSettings(AppTimeZoneSettingsArgs.builder()
                .timeZone("America/Los_Angeles")
                .build())
            .build());

        var cesEvaluationBasic = new Evaluation("cesEvaluationBasic", EvaluationArgs.builder()
            .evaluationId("eval-basic")
            .displayName("my-evaluation-basic")
            .location("us")
            .app(app.appId())
            .build());

    }
}

resources:
  app:
    type: gcp:ces:App
    properties:
      appId: app-id
      location: us
      displayName: my-app
      languageSettings:
        defaultLanguageCode: en-US
      timeZoneSettings:
        timeZone: America/Los_Angeles
  cesEvaluationBasic:
    type: gcp:ces:Evaluation
    name: ces_evaluation_basic
    properties:
      evaluationId: eval-basic
      displayName: my-evaluation-basic
      location: us
      app: ${app.appId}

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

const app = new gcp.ces.App("app", {
    appId: "app-id-full",
    location: "us",
    displayName: "my-app-full",
    languageSettings: {
        defaultLanguageCode: "en-US",
    },
    timeZoneSettings: {
        timeZone: "America/Los_Angeles",
    },
});
const tool = new gcp.ces.Tool("tool", {
    location: "us",
    app: app.appId,
    toolId: "tool-id-full",
    executionType: "SYNCHRONOUS",
    pythonFunction: {
        name: "example_function",
        pythonCode: "def example_function() -> int: return 0",
    },
});
const cesEvaluationFull = new gcp.ces.Evaluation("ces_evaluation_full", {
    evaluationId: "evaluation-id-full",
    displayName: "my-evaluation-full",
    location: "us",
    app: app.appId,
    description: "Full evaluation for testing",
    tags: [
        "test",
        "full",
    ],
    golden: {
        evaluationExpectations: [pulumi.interpolate`projects/${app.project}/locations/us/apps/${app.appId}/evaluationExpectations/dummy-exp`],
        turns: [{
            steps: [
                {
                    userInput: {
                        text: "Hello",
                        willContinue: true,
                    },
                },
                {
                    userInput: {
                        variables: {
                            key: "value",
                        },
                    },
                },
                {
                    expectation: {
                        note: "Expect tool call",
                        toolCall: {
                            id: "tool-call-id",
                            tool: pulumi.interpolate`projects/${app.project}/locations/us/apps/${app.appId}/tools/${tool.toolId}`,
                            args: {
                                param: "value",
                            },
                        },
                    },
                },
                {
                    expectation: {
                        note: "Expect agent response",
                        agentResponse: {
                            role: "agent",
                            chunks: [
                                {
                                    updatedVariables: {
                                        key: "value",
                                    },
                                },
                                {
                                    agentTransfer: {
                                        targetAgent: pulumi.interpolate`projects/${app.project}/locations/us/apps/${app.appId}/agents/dummy-agent`,
                                    },
                                },
                                {
                                    toolCall: {
                                        id: "tool-call-id-3",
                                        tool: pulumi.interpolate`projects/${app.project}/locations/us/apps/${app.appId}/tools/${tool.toolId}`,
                                    },
                                },
                                {
                                    toolResponse: {
                                        id: "tool-call-id-3",
                                        response: {
                                            result: "success",
                                        },
                                        tool: pulumi.interpolate`projects/${app.project}/locations/us/apps/${app.appId}/tools/${tool.toolId}`,
                                    },
                                },
                            ],
                        },
                    },
                },
                {
                    expectation: {
                        note: "Expect toolset tool call",
                        toolCall: {
                            id: "tool-call-id-2",
                            toolsetTool: {
                                toolset: pulumi.interpolate`projects/${app.project}/locations/us/apps/${app.appId}/toolsets/dummy-toolset`,
                                toolId: "dummy-tool",
                            },
                        },
                    },
                },
                {
                    agentTransfer: {
                        targetAgent: pulumi.interpolate`projects/${app.project}/locations/us/apps/${app.appId}/agents/dummy-agent`,
                    },
                },
                {
                    expectation: {
                        agentTransfer: {
                            targetAgent: pulumi.interpolate`projects/${app.project}/locations/us/apps/${app.appId}/agents/dummy-agent`,
                            displayName: "dummy-agent",
                        },
                    },
                },
                {
                    expectation: {
                        note: "Expect mock tool response",
                        mockToolResponse: {
                            id: "tool-call-id-4",
                            response: {
                                result: "mocked",
                            },
                            tool: pulumi.interpolate`projects/${app.project}/locations/us/apps/${app.appId}/tools/${tool.toolId}`,
                        },
                    },
                },
                {
                    expectation: {
                        note: "Expect tool response",
                        toolResponse: {
                            toolsetTool: {
                                toolset: pulumi.interpolate`projects/${app.project}/locations/us/apps/${app.appId}/toolsets/dummy-toolset`,
                                toolId: "dummy-tool",
                            },
                        },
                    },
                },
                {
                    expectation: {
                        note: "Expect updated variables",
                        updatedVariables: {
                            notes: "Some notes",
                        },
                    },
                },
                {
                    userInput: {
                        toolResponses: {
                            toolResponses: [{
                                id: "tool-call-id-5",
                                response: {
                                    result: "user-provided",
                                },
                                tool: pulumi.interpolate`projects/${app.project}/locations/us/apps/${app.appId}/tools/${tool.toolId}`,
                            }],
                        },
                    },
                },
                {
                    userInput: {
                        event: {
                            event: "my-event",
                        },
                    },
                },
                {
                    userInput: {
                        dtmf: "1234",
                    },
                },
                {
                    userInput: {
                        audio: "c29tZSBhdWRpbyBkYXRh",
                    },
                },
                {
                    userInput: {
                        blob: {
                            mimeType: "text/plain",
                            data: "c29tZSBibG9iIGRhdGE=",
                        },
                    },
                },
                {
                    userInput: {
                        image: {
                            mimeType: "image/png",
                            data: "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAAAAAA6fptVAAAACklEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=",
                        },
                    },
                },
                {
                    userInput: {
                        toolResponses: {
                            toolResponses: [{
                                id: "tool-call-id",
                                response: {
                                    result: "success",
                                },
                                tool: pulumi.interpolate`projects/${app.project}/locations/us/apps/${app.appId}/tools/${tool.toolId}`,
                            }],
                        },
                    },
                },
                {
                    expectation: {
                        note: "Expect tool response",
                        toolResponse: {
                            id: "tool-call-id",
                            response: {
                                result: "success",
                            },
                            tool: pulumi.interpolate`projects/${app.project}/locations/us/apps/${app.appId}/tools/${tool.toolId}`,
                        },
                    },
                },
                {
                    expectation: {
                        note: "Expect agent response with chunks",
                        agentResponse: {
                            role: "agent",
                            chunks: [
                                {
                                    text: "Hello again",
                                },
                                {
                                    text: "Hello again transcript",
                                },
                                {
                                    blob: {
                                        mimeType: "text/plain",
                                        data: "c29tZSBibG9iIGRhdGE=",
                                    },
                                },
                                {
                                    image: {
                                        mimeType: "image/png",
                                        data: "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAAAAAA6fptVAAAACklEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=",
                                    },
                                },
                                {
                                    toolCall: {
                                        id: "tool-call-id-3",
                                        tool: pulumi.interpolate`projects/${app.project}/locations/us/apps/${app.appId}/tools/${tool.toolId}`,
                                        args: {
                                            param: "value",
                                        },
                                    },
                                },
                            ],
                        },
                    },
                },
            ],
        }],
    },
});

import pulumi
import pulumi_gcp as gcp

app = gcp.ces.App("app",
    app_id="app-id-full",
    location="us",
    display_name="my-app-full",
    language_settings={
        "default_language_code": "en-US",
    },
    time_zone_settings={
        "time_zone": "America/Los_Angeles",
    })
tool = gcp.ces.Tool("tool",
    location="us",
    app=app.app_id,
    tool_id="tool-id-full",
    execution_type="SYNCHRONOUS",
    python_function={
        "name": "example_function",
        "python_code": "def example_function() -> int: return 0",
    })
ces_evaluation_full = gcp.ces.Evaluation("ces_evaluation_full",
    evaluation_id="evaluation-id-full",
    display_name="my-evaluation-full",
    location="us",
    app=app.app_id,
    description="Full evaluation for testing",
    tags=[
        "test",
        "full",
    ],
    golden={
        "evaluation_expectations": [pulumi.Output.all(
            project=app.project,
            app_id=app.app_id
).apply(lambda resolved_outputs: f"projects/{resolved_outputs['project']}/locations/us/apps/{resolved_outputs['app_id']}/evaluationExpectations/dummy-exp")
],
        "turns": [{
            "steps": [
                {
                    "user_input": {
                        "text": "Hello",
                        "will_continue": True,
                    },
                },
                {
                    "user_input": {
                        "variables": {
                            "key": "value",
                        },
                    },
                },
                {
                    "expectation": {
                        "note": "Expect tool call",
                        "tool_call": {
                            "id": "tool-call-id",
                            "tool": pulumi.Output.all(
                                project=app.project,
                                app_id=app.app_id,
                                tool_id=tool.tool_id
).apply(lambda resolved_outputs: f"projects/{resolved_outputs['project']}/locations/us/apps/{resolved_outputs['app_id']}/tools/{resolved_outputs['tool_id']}")
,
                            "args": {
                                "param": "value",
                            },
                        },
                    },
                },
                {
                    "expectation": {
                        "note": "Expect agent response",
                        "agent_response": {
                            "role": "agent",
                            "chunks": [
                                {
                                    "updated_variables": {
                                        "key": "value",
                                    },
                                },
                                {
                                    "agent_transfer": {
                                        "target_agent": pulumi.Output.all(
                                            project=app.project,
                                            app_id=app.app_id
).apply(lambda resolved_outputs: f"projects/{resolved_outputs['project']}/locations/us/apps/{resolved_outputs['app_id']}/agents/dummy-agent")
,
                                    },
                                },
                                {
                                    "tool_call": {
                                        "id": "tool-call-id-3",
                                        "tool": pulumi.Output.all(
                                            project=app.project,
                                            app_id=app.app_id,
                                            tool_id=tool.tool_id
).apply(lambda resolved_outputs: f"projects/{resolved_outputs['project']}/locations/us/apps/{resolved_outputs['app_id']}/tools/{resolved_outputs['tool_id']}")
,
                                    },
                                },
                                {
                                    "tool_response": {
                                        "id": "tool-call-id-3",
                                        "response": {
                                            "result": "success",
                                        },
                                        "tool": pulumi.Output.all(
                                            project=app.project,
                                            app_id=app.app_id,
                                            tool_id=tool.tool_id
).apply(lambda resolved_outputs: f"projects/{resolved_outputs['project']}/locations/us/apps/{resolved_outputs['app_id']}/tools/{resolved_outputs['tool_id']}")
,
                                    },
                                },
                            ],
                        },
                    },
                },
                {
                    "expectation": {
                        "note": "Expect toolset tool call",
                        "tool_call": {
                            "id": "tool-call-id-2",
                            "toolset_tool": {
                                "toolset": pulumi.Output.all(
                                    project=app.project,
                                    app_id=app.app_id
).apply(lambda resolved_outputs: f"projects/{resolved_outputs['project']}/locations/us/apps/{resolved_outputs['app_id']}/toolsets/dummy-toolset")
,
                                "tool_id": "dummy-tool",
                            },
                        },
                    },
                },
                {
                    "agent_transfer": {
                        "target_agent": pulumi.Output.all(
                            project=app.project,
                            app_id=app.app_id
).apply(lambda resolved_outputs: f"projects/{resolved_outputs['project']}/locations/us/apps/{resolved_outputs['app_id']}/agents/dummy-agent")
,
                    },
                },
                {
                    "expectation": {
                        "agent_transfer": {
                            "target_agent": pulumi.Output.all(
                                project=app.project,
                                app_id=app.app_id
).apply(lambda resolved_outputs: f"projects/{resolved_outputs['project']}/locations/us/apps/{resolved_outputs['app_id']}/agents/dummy-agent")
,
                            "display_name": "dummy-agent",
                        },
                    },
                },
                {
                    "expectation": {
                        "note": "Expect mock tool response",
                        "mock_tool_response": {
                            "id": "tool-call-id-4",
                            "response": {
                                "result": "mocked",
                            },
                            "tool": pulumi.Output.all(
                                project=app.project,
                                app_id=app.app_id,
                                tool_id=tool.tool_id
).apply(lambda resolved_outputs: f"projects/{resolved_outputs['project']}/locations/us/apps/{resolved_outputs['app_id']}/tools/{resolved_outputs['tool_id']}")
,
                        },
                    },
                },
                {
                    "expectation": {
                        "note": "Expect tool response",
                        "tool_response": {
                            "toolset_tool": {
                                "toolset": pulumi.Output.all(
                                    project=app.project,
                                    app_id=app.app_id
).apply(lambda resolved_outputs: f"projects/{resolved_outputs['project']}/locations/us/apps/{resolved_outputs['app_id']}/toolsets/dummy-toolset")
,
                                "tool_id": "dummy-tool",
                            },
                        },
                    },
                },
                {
                    "expectation": {
                        "note": "Expect updated variables",
                        "updated_variables": {
                            "notes": "Some notes",
                        },
                    },
                },
                {
                    "user_input": {
                        "tool_responses": {
                            "tool_responses": [{
                                "id": "tool-call-id-5",
                                "response": {
                                    "result": "user-provided",
                                },
                                "tool": pulumi.Output.all(
                                    project=app.project,
                                    app_id=app.app_id,
                                    tool_id=tool.tool_id
).apply(lambda resolved_outputs: f"projects/{resolved_outputs['project']}/locations/us/apps/{resolved_outputs['app_id']}/tools/{resolved_outputs['tool_id']}")
,
                            }],
                        },
                    },
                },
                {
                    "user_input": {
                        "event": {
                            "event": "my-event",
                        },
                    },
                },
                {
                    "user_input": {
                        "dtmf": "1234",
                    },
                },
                {
                    "user_input": {
                        "audio": "c29tZSBhdWRpbyBkYXRh",
                    },
                },
                {
                    "user_input": {
                        "blob": {
                            "mime_type": "text/plain",
                            "data": "c29tZSBibG9iIGRhdGE=",
                        },
                    },
                },
                {
                    "user_input": {
                        "image": {
                            "mime_type": "image/png",
                            "data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAAAAAA6fptVAAAACklEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=",
                        },
                    },
                },
                {
                    "user_input": {
                        "tool_responses": {
                            "tool_responses": [{
                                "id": "tool-call-id",
                                "response": {
                                    "result": "success",
                                },
                                "tool": pulumi.Output.all(
                                    project=app.project,
                                    app_id=app.app_id,
                                    tool_id=tool.tool_id
).apply(lambda resolved_outputs: f"projects/{resolved_outputs['project']}/locations/us/apps/{resolved_outputs['app_id']}/tools/{resolved_outputs['tool_id']}")
,
                            }],
                        },
                    },
                },
                {
                    "expectation": {
                        "note": "Expect tool response",
                        "tool_response": {
                            "id": "tool-call-id",
                            "response": {
                                "result": "success",
                            },
                            "tool": pulumi.Output.all(
                                project=app.project,
                                app_id=app.app_id,
                                tool_id=tool.tool_id
).apply(lambda resolved_outputs: f"projects/{resolved_outputs['project']}/locations/us/apps/{resolved_outputs['app_id']}/tools/{resolved_outputs['tool_id']}")
,
                        },
                    },
                },
                {
                    "expectation": {
                        "note": "Expect agent response with chunks",
                        "agent_response": {
                            "role": "agent",
                            "chunks": [
                                {
                                    "text": "Hello again",
                                },
                                {
                                    "text": "Hello again transcript",
                                },
                                {
                                    "blob": {
                                        "mime_type": "text/plain",
                                        "data": "c29tZSBibG9iIGRhdGE=",
                                    },
                                },
                                {
                                    "image": {
                                        "mime_type": "image/png",
                                        "data": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAAAAAA6fptVAAAACklEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=",
                                    },
                                },
                                {
                                    "tool_call": {
                                        "id": "tool-call-id-3",
                                        "tool": pulumi.Output.all(
                                            project=app.project,
                                            app_id=app.app_id,
                                            tool_id=tool.tool_id
).apply(lambda resolved_outputs: f"projects/{resolved_outputs['project']}/locations/us/apps/{resolved_outputs['app_id']}/tools/{resolved_outputs['tool_id']}")
,
                                        "args": {
                                            "param": "value",
                                        },
                                    },
                                },
                            ],
                        },
                    },
                },
            ],
        }],
    })

package main

import (
	"fmt"

	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/ces"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		app, err := ces.NewApp(ctx, "app", &ces.AppArgs{
			AppId:       pulumi.String("app-id-full"),
			Location:    pulumi.String("us"),
			DisplayName: pulumi.String("my-app-full"),
			LanguageSettings: &ces.AppLanguageSettingsArgs{
				DefaultLanguageCode: pulumi.String("en-US"),
			},
			TimeZoneSettings: &ces.AppTimeZoneSettingsArgs{
				TimeZone: pulumi.String("America/Los_Angeles"),
			},
		})
		if err != nil {
			return err
		}
		tool, err := ces.NewTool(ctx, "tool", &ces.ToolArgs{
			Location:      pulumi.String("us"),
			App:           app.AppId,
			ToolId:        pulumi.String("tool-id-full"),
			ExecutionType: pulumi.String("SYNCHRONOUS"),
			PythonFunction: &ces.ToolPythonFunctionArgs{
				Name:       pulumi.String("example_function"),
				PythonCode: pulumi.String("def example_function() -> int: return 0"),
			},
		})
		if err != nil {
			return err
		}
		_, err = ces.NewEvaluation(ctx, "ces_evaluation_full", &ces.EvaluationArgs{
			EvaluationId: pulumi.String("evaluation-id-full"),
			DisplayName:  pulumi.String("my-evaluation-full"),
			Location:     pulumi.String("us"),
			App:          app.AppId,
			Description:  pulumi.String("Full evaluation for testing"),
			Tags: pulumi.StringArray{
				pulumi.String("test"),
				pulumi.String("full"),
			},
			Golden: &ces.EvaluationGoldenArgs{
				EvaluationExpectations: pulumi.StringArray{
					pulumi.All(app.Project, app.AppId).ApplyT(func(_args []interface{}) (string, error) {
						project := _args[0].(string)
						appId := _args[1].(string)
						return fmt.Sprintf("projects/%v/locations/us/apps/%v/evaluationExpectations/dummy-exp", project, appId), nil
					}).(pulumi.StringOutput),
				},
				Turns: ces.EvaluationGoldenTurnArray{
					&ces.EvaluationGoldenTurnArgs{
						Steps: ces.EvaluationGoldenTurnStepArray{
							&ces.EvaluationGoldenTurnStepArgs{
								UserInput: &ces.EvaluationGoldenTurnStepUserInputArgs{
									Text:         pulumi.String("Hello"),
									WillContinue: pulumi.Bool(true),
								},
							},
							&ces.EvaluationGoldenTurnStepArgs{
								UserInput: &ces.EvaluationGoldenTurnStepUserInputArgs{
									Variables: pulumi.StringMap{
										"key": pulumi.String("value"),
									},
								},
							},
							&ces.EvaluationGoldenTurnStepArgs{
								Expectation: &ces.EvaluationGoldenTurnStepExpectationArgs{
									Note: pulumi.String("Expect tool call"),
									ToolCall: &ces.EvaluationGoldenTurnStepExpectationToolCallArgs{
										Id: pulumi.String("tool-call-id"),
										Tool: pulumi.All(app.Project, app.AppId, tool.ToolId).ApplyT(func(_args []interface{}) (string, error) {
											project := _args[0].(string)
											appId := _args[1].(string)
											toolId := _args[2].(string)
											return fmt.Sprintf("projects/%v/locations/us/apps/%v/tools/%v", project, appId, toolId), nil
										}).(pulumi.StringOutput),
										Args: pulumi.StringMap{
											"param": pulumi.String("value"),
										},
									},
								},
							},
							&ces.EvaluationGoldenTurnStepArgs{
								Expectation: &ces.EvaluationGoldenTurnStepExpectationArgs{
									Note: pulumi.String("Expect agent response"),
									AgentResponse: &ces.EvaluationGoldenTurnStepExpectationAgentResponseArgs{
										Role: pulumi.String("agent"),
										Chunks: ces.EvaluationGoldenTurnStepExpectationAgentResponseChunkArray{
											&ces.EvaluationGoldenTurnStepExpectationAgentResponseChunkArgs{
												UpdatedVariables: pulumi.StringMap{
													"key": pulumi.String("value"),
												},
											},
											&ces.EvaluationGoldenTurnStepExpectationAgentResponseChunkArgs{
												AgentTransfer: &ces.EvaluationGoldenTurnStepExpectationAgentResponseChunkAgentTransferArgs{
													TargetAgent: pulumi.All(app.Project, app.AppId).ApplyT(func(_args []interface{}) (string, error) {
														project := _args[0].(string)
														appId := _args[1].(string)
														return fmt.Sprintf("projects/%v/locations/us/apps/%v/agents/dummy-agent", project, appId), nil
													}).(pulumi.StringOutput),
												},
											},
											&ces.EvaluationGoldenTurnStepExpectationAgentResponseChunkArgs{
												ToolCall: &ces.EvaluationGoldenTurnStepExpectationAgentResponseChunkToolCallArgs{
													Id: pulumi.String("tool-call-id-3"),
													Tool: pulumi.All(app.Project, app.AppId, tool.ToolId).ApplyT(func(_args []interface{}) (string, error) {
														project := _args[0].(string)
														appId := _args[1].(string)
														toolId := _args[2].(string)
														return fmt.Sprintf("projects/%v/locations/us/apps/%v/tools/%v", project, appId, toolId), nil
													}).(pulumi.StringOutput),
												},
											},
											&ces.EvaluationGoldenTurnStepExpectationAgentResponseChunkArgs{
												ToolResponse: &ces.EvaluationGoldenTurnStepExpectationAgentResponseChunkToolResponseArgs{
													Id: pulumi.String("tool-call-id-3"),
													Response: pulumi.StringMap{
														"result": pulumi.String("success"),
													},
													Tool: pulumi.All(app.Project, app.AppId, tool.ToolId).ApplyT(func(_args []interface{}) (string, error) {
														project := _args[0].(string)
														appId := _args[1].(string)
														toolId := _args[2].(string)
														return fmt.Sprintf("projects/%v/locations/us/apps/%v/tools/%v", project, appId, toolId), nil
													}).(pulumi.StringOutput),
												},
											},
										},
									},
								},
							},
							&ces.EvaluationGoldenTurnStepArgs{
								Expectation: &ces.EvaluationGoldenTurnStepExpectationArgs{
									Note: pulumi.String("Expect toolset tool call"),
									ToolCall: &ces.EvaluationGoldenTurnStepExpectationToolCallArgs{
										Id: pulumi.String("tool-call-id-2"),
										ToolsetTool: &ces.EvaluationGoldenTurnStepExpectationToolCallToolsetToolArgs{
											Toolset: pulumi.All(app.Project, app.AppId).ApplyT(func(_args []interface{}) (string, error) {
												project := _args[0].(string)
												appId := _args[1].(string)
												return fmt.Sprintf("projects/%v/locations/us/apps/%v/toolsets/dummy-toolset", project, appId), nil
											}).(pulumi.StringOutput),
											ToolId: pulumi.String("dummy-tool"),
										},
									},
								},
							},
							&ces.EvaluationGoldenTurnStepArgs{
								AgentTransfer: &ces.EvaluationGoldenTurnStepAgentTransferArgs{
									TargetAgent: pulumi.All(app.Project, app.AppId).ApplyT(func(_args []interface{}) (string, error) {
										project := _args[0].(string)
										appId := _args[1].(string)
										return fmt.Sprintf("projects/%v/locations/us/apps/%v/agents/dummy-agent", project, appId), nil
									}).(pulumi.StringOutput),
								},
							},
							&ces.EvaluationGoldenTurnStepArgs{
								Expectation: &ces.EvaluationGoldenTurnStepExpectationArgs{
									AgentTransfer: &ces.EvaluationGoldenTurnStepExpectationAgentTransferArgs{
										TargetAgent: pulumi.All(app.Project, app.AppId).ApplyT(func(_args []interface{}) (string, error) {
											project := _args[0].(string)
											appId := _args[1].(string)
											return fmt.Sprintf("projects/%v/locations/us/apps/%v/agents/dummy-agent", project, appId), nil
										}).(pulumi.StringOutput),
										DisplayName: pulumi.String("dummy-agent"),
									},
								},
							},
							&ces.EvaluationGoldenTurnStepArgs{
								Expectation: &ces.EvaluationGoldenTurnStepExpectationArgs{
									Note: pulumi.String("Expect mock tool response"),
									MockToolResponse: &ces.EvaluationGoldenTurnStepExpectationMockToolResponseArgs{
										Id: pulumi.String("tool-call-id-4"),
										Response: pulumi.StringMap{
											"result": pulumi.String("mocked"),
										},
										Tool: pulumi.All(app.Project, app.AppId, tool.ToolId).ApplyT(func(_args []interface{}) (string, error) {
											project := _args[0].(string)
											appId := _args[1].(string)
											toolId := _args[2].(string)
											return fmt.Sprintf("projects/%v/locations/us/apps/%v/tools/%v", project, appId, toolId), nil
										}).(pulumi.StringOutput),
									},
								},
							},
							&ces.EvaluationGoldenTurnStepArgs{
								Expectation: &ces.EvaluationGoldenTurnStepExpectationArgs{
									Note: pulumi.String("Expect tool response"),
									ToolResponse: &ces.EvaluationGoldenTurnStepExpectationToolResponseArgs{
										ToolsetTool: &ces.EvaluationGoldenTurnStepExpectationToolResponseToolsetToolArgs{
											Toolset: pulumi.All(app.Project, app.AppId).ApplyT(func(_args []interface{}) (string, error) {
												project := _args[0].(string)
												appId := _args[1].(string)
												return fmt.Sprintf("projects/%v/locations/us/apps/%v/toolsets/dummy-toolset", project, appId), nil
											}).(pulumi.StringOutput),
											ToolId: pulumi.String("dummy-tool"),
										},
									},
								},
							},
							&ces.EvaluationGoldenTurnStepArgs{
								Expectation: &ces.EvaluationGoldenTurnStepExpectationArgs{
									Note: pulumi.String("Expect updated variables"),
									UpdatedVariables: &ces.EvaluationGoldenTurnStepExpectationUpdatedVariablesArgs{
										Notes: pulumi.String("Some notes"),
									},
								},
							},
							&ces.EvaluationGoldenTurnStepArgs{
								UserInput: &ces.EvaluationGoldenTurnStepUserInputArgs{
									ToolResponses: &ces.EvaluationGoldenTurnStepUserInputToolResponsesArgs{
										ToolResponses: ces.EvaluationGoldenTurnStepUserInputToolResponsesToolResponseArray{
											&ces.EvaluationGoldenTurnStepUserInputToolResponsesToolResponseArgs{
												Id: pulumi.String("tool-call-id-5"),
												Response: pulumi.StringMap{
													"result": pulumi.String("user-provided"),
												},
												Tool: pulumi.All(app.Project, app.AppId, tool.ToolId).ApplyT(func(_args []interface{}) (string, error) {
													project := _args[0].(string)
													appId := _args[1].(string)
													toolId := _args[2].(string)
													return fmt.Sprintf("projects/%v/locations/us/apps/%v/tools/%v", project, appId, toolId), nil
												}).(pulumi.StringOutput),
											},
										},
									},
								},
							},
							&ces.EvaluationGoldenTurnStepArgs{
								UserInput: &ces.EvaluationGoldenTurnStepUserInputArgs{
									Event: &ces.EvaluationGoldenTurnStepUserInputEventArgs{
										Event: pulumi.String("my-event"),
									},
								},
							},
							&ces.EvaluationGoldenTurnStepArgs{
								UserInput: &ces.EvaluationGoldenTurnStepUserInputArgs{
									Dtmf: pulumi.String("1234"),
								},
							},
							&ces.EvaluationGoldenTurnStepArgs{
								UserInput: &ces.EvaluationGoldenTurnStepUserInputArgs{
									Audio: pulumi.String("c29tZSBhdWRpbyBkYXRh"),
								},
							},
							&ces.EvaluationGoldenTurnStepArgs{
								UserInput: &ces.EvaluationGoldenTurnStepUserInputArgs{
									Blob: &ces.EvaluationGoldenTurnStepUserInputBlobArgs{
										MimeType: pulumi.String("text/plain"),
										Data:     pulumi.String("c29tZSBibG9iIGRhdGE="),
									},
								},
							},
							&ces.EvaluationGoldenTurnStepArgs{
								UserInput: &ces.EvaluationGoldenTurnStepUserInputArgs{
									Image: &ces.EvaluationGoldenTurnStepUserInputImageArgs{
										MimeType: pulumi.String("image/png"),
										Data:     pulumi.String("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAAAAAA6fptVAAAACklEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII="),
									},
								},
							},
							&ces.EvaluationGoldenTurnStepArgs{
								UserInput: &ces.EvaluationGoldenTurnStepUserInputArgs{
									ToolResponses: &ces.EvaluationGoldenTurnStepUserInputToolResponsesArgs{
										ToolResponses: ces.EvaluationGoldenTurnStepUserInputToolResponsesToolResponseArray{
											&ces.EvaluationGoldenTurnStepUserInputToolResponsesToolResponseArgs{
												Id: pulumi.String("tool-call-id"),
												Response: pulumi.StringMap{
													"result": pulumi.String("success"),
												},
												Tool: pulumi.All(app.Project, app.AppId, tool.ToolId).ApplyT(func(_args []interface{}) (string, error) {
													project := _args[0].(string)
													appId := _args[1].(string)
													toolId := _args[2].(string)
													return fmt.Sprintf("projects/%v/locations/us/apps/%v/tools/%v", project, appId, toolId), nil
												}).(pulumi.StringOutput),
											},
										},
									},
								},
							},
							&ces.EvaluationGoldenTurnStepArgs{
								Expectation: &ces.EvaluationGoldenTurnStepExpectationArgs{
									Note: pulumi.String("Expect tool response"),
									ToolResponse: &ces.EvaluationGoldenTurnStepExpectationToolResponseArgs{
										Id: pulumi.String("tool-call-id"),
										Response: pulumi.StringMap{
											"result": pulumi.String("success"),
										},
										Tool: pulumi.All(app.Project, app.AppId, tool.ToolId).ApplyT(func(_args []interface{}) (string, error) {
											project := _args[0].(string)
											appId := _args[1].(string)
											toolId := _args[2].(string)
											return fmt.Sprintf("projects/%v/locations/us/apps/%v/tools/%v", project, appId, toolId), nil
										}).(pulumi.StringOutput),
									},
								},
							},
							&ces.EvaluationGoldenTurnStepArgs{
								Expectation: &ces.EvaluationGoldenTurnStepExpectationArgs{
									Note: pulumi.String("Expect agent response with chunks"),
									AgentResponse: &ces.EvaluationGoldenTurnStepExpectationAgentResponseArgs{
										Role: pulumi.String("agent"),
										Chunks: ces.EvaluationGoldenTurnStepExpectationAgentResponseChunkArray{
											&ces.EvaluationGoldenTurnStepExpectationAgentResponseChunkArgs{
												Text: pulumi.String("Hello again"),
											},
											&ces.EvaluationGoldenTurnStepExpectationAgentResponseChunkArgs{
												Text: pulumi.String("Hello again transcript"),
											},
											&ces.EvaluationGoldenTurnStepExpectationAgentResponseChunkArgs{
												Blob: &ces.EvaluationGoldenTurnStepExpectationAgentResponseChunkBlobArgs{
													MimeType: pulumi.String("text/plain"),
													Data:     pulumi.String("c29tZSBibG9iIGRhdGE="),
												},
											},
											&ces.EvaluationGoldenTurnStepExpectationAgentResponseChunkArgs{
												Image: &ces.EvaluationGoldenTurnStepExpectationAgentResponseChunkImageArgs{
													MimeType: pulumi.String("image/png"),
													Data:     pulumi.String("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAAAAAA6fptVAAAACklEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII="),
												},
											},
											&ces.EvaluationGoldenTurnStepExpectationAgentResponseChunkArgs{
												ToolCall: &ces.EvaluationGoldenTurnStepExpectationAgentResponseChunkToolCallArgs{
													Id: pulumi.String("tool-call-id-3"),
													Tool: pulumi.All(app.Project, app.AppId, tool.ToolId).ApplyT(func(_args []interface{}) (string, error) {
														project := _args[0].(string)
														appId := _args[1].(string)
														toolId := _args[2].(string)
														return fmt.Sprintf("projects/%v/locations/us/apps/%v/tools/%v", project, appId, toolId), nil
													}).(pulumi.StringOutput),
													Args: pulumi.StringMap{
														"param": pulumi.String("value"),
													},
												},
											},
										},
									},
								},
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}