getAiReasoningEngineQuery function

Future<GetAiReasoningEngineQueryResult> getAiReasoningEngineQuery(GetAiReasoningEngineQueryArgs args, { InvokeOptions? options, })

Get the output of a query sent to a Vertex AI Reasoning Engine agent.

Example Usage

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

const defaultAiReasoningEngine = new gcp.vertex.AiReasoningEngine("default", {
    displayName: "vertex-mds-_91657",
    description: "Retrieves tenant project number",
    region: "us-central1",
    spec: {
        sourceCodeSpec: {
            inlineSource: {
                sourceArchive: std.filebase64({
                    input: "./test-fixtures/mds_agent_src.tar.gz",
                }).then(invoke => invoke.result),
            },
            pythonSpec: {
                entrypointModule: "metadata_agent",
                entrypointObject: "root_agent",
            },
        },
    },
});
const _default = gcp.vertex.getAiReasoningEngineQueryOutput({
    reasoningEngineId: defaultAiReasoningEngine.name,
    region: "us-central1",
    classMethod: "query",
});

import pulumi
import pulumi_gcp as gcp
import pulumi_std as std

default_ai_reasoning_engine = gcp.vertex.AiReasoningEngine("default",
    display_name="vertex-mds-_91657",
    description="Retrieves tenant project number",
    region="us-central1",
    spec={
        "source_code_spec": {
            "inline_source": {
                "source_archive": std.filebase64(input="./test-fixtures/mds_agent_src.tar.gz").result,
            },
            "python_spec": {
                "entrypoint_module": "metadata_agent",
                "entrypoint_object": "root_agent",
            },
        },
    })
default = gcp.vertex.get_ai_reasoning_engine_query_output(reasoning_engine_id=default_ai_reasoning_engine.name,
    region="us-central1",
    class_method="query")

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

return await Deployment.RunAsync(() =>
{
    var defaultAiReasoningEngine = new Gcp.Vertex.AiReasoningEngine("default", new()
    {
        DisplayName = "vertex-mds-_91657",
        Description = "Retrieves tenant project number",
        Region = "us-central1",
        Spec = new Gcp.Vertex.Inputs.AiReasoningEngineSpecArgs
        {
            SourceCodeSpec = new Gcp.Vertex.Inputs.AiReasoningEngineSpecSourceCodeSpecArgs
            {
                InlineSource = new Gcp.Vertex.Inputs.AiReasoningEngineSpecSourceCodeSpecInlineSourceArgs
                {
                    SourceArchive = Std.Filebase64.Invoke(new()
                    {
                        Input = "./test-fixtures/mds_agent_src.tar.gz",
                    }).Apply(invoke => invoke.Result),
                },
                PythonSpec = new Gcp.Vertex.Inputs.AiReasoningEngineSpecSourceCodeSpecPythonSpecArgs
                {
                    EntrypointModule = "metadata_agent",
                    EntrypointObject = "root_agent",
                },
            },
        },
    });

    var @default = Gcp.Vertex.GetAiReasoningEngineQuery.Invoke(new()
    {
        ReasoningEngineId = defaultAiReasoningEngine.Name,
        Region = "us-central1",
        ClassMethod = "query",
    });

});

package main

import (
	"github.com/pulumi/pulumi-gcp/sdk/v9/go/gcp/vertex"
	"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 {
		invokeFilebase64, err := std.Filebase64(ctx, &std.Filebase64Args{
			Input: "./test-fixtures/mds_agent_src.tar.gz",
		}, nil)
		if err != nil {
			return err
		}
		defaultAiReasoningEngine, err := vertex.NewAiReasoningEngine(ctx, "default", &vertex.AiReasoningEngineArgs{
			DisplayName: pulumi.String("vertex-mds-_91657"),
			Description: pulumi.String("Retrieves tenant project number"),
			Region:      pulumi.String("us-central1"),
			Spec: &vertex.AiReasoningEngineSpecArgs{
				SourceCodeSpec: &vertex.AiReasoningEngineSpecSourceCodeSpecArgs{
					InlineSource: &vertex.AiReasoningEngineSpecSourceCodeSpecInlineSourceArgs{
						SourceArchive: pulumi.String(invokeFilebase64.Result),
					},
					PythonSpec: &vertex.AiReasoningEngineSpecSourceCodeSpecPythonSpecArgs{
						EntrypointModule: pulumi.String("metadata_agent"),
						EntrypointObject: pulumi.String("root_agent"),
					},
				},
			},
		})
		if err != nil {
			return err
		}
		_ = vertex.GetAiReasoningEngineQueryOutput(ctx, vertex.GetAiReasoningEngineQueryOutputArgs{
			ReasoningEngineId: defaultAiReasoningEngine.Name,
			Region:            pulumi.String("us-central1"),
			ClassMethod:       pulumi.String("query"),
		}, nil)
		return nil
	})
}

pulumi {
  required_providers {
    gcp = {
      source = "pulumi/gcp"
    }
    std = {
      source = "pulumi/std"
    }
  }
}

data "gcp_vertex_getaireasoningenginequery" "default" {
  reasoning_engine_id = gcp_vertex_aireasoningengine.default.name
  region              = "us-central1"
  class_method        = "query"
}

resource "gcp_vertex_aireasoningengine" "default" {
  display_name = "vertex-mds-_91657"
  description  = "Retrieves tenant project number"
  region       = "us-central1"
  spec = {
    source_code_spec = {
      inline_source = {
        source_archive = filebase64("./test-fixtures/mds_agent_src.tar.gz")
      }
      python_spec = {
        entrypoint_module = "metadata_agent"
        entrypoint_object = "root_agent"
      }
    }
  }
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.gcp.vertex.AiReasoningEngine;
import com.pulumi.gcp.vertex.AiReasoningEngineArgs;
import com.pulumi.gcp.vertex.inputs.AiReasoningEngineSpecArgs;
import com.pulumi.gcp.vertex.inputs.AiReasoningEngineSpecSourceCodeSpecArgs;
import com.pulumi.gcp.vertex.inputs.AiReasoningEngineSpecSourceCodeSpecInlineSourceArgs;
import com.pulumi.gcp.vertex.inputs.AiReasoningEngineSpecSourceCodeSpecPythonSpecArgs;
import com.pulumi.std.StdFunctions;
import com.pulumi.std.inputs.Filebase64Args;
import com.pulumi.gcp.vertex.VertexFunctions;
import com.pulumi.gcp.vertex.inputs.GetAiReasoningEngineQueryArgs;
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 defaultAiReasoningEngine = new AiReasoningEngine("defaultAiReasoningEngine", AiReasoningEngineArgs.builder()
            .displayName("vertex-mds-_91657")
            .description("Retrieves tenant project number")
            .region("us-central1")
            .spec(AiReasoningEngineSpecArgs.builder()
                .sourceCodeSpec(AiReasoningEngineSpecSourceCodeSpecArgs.builder()
                    .inlineSource(AiReasoningEngineSpecSourceCodeSpecInlineSourceArgs.builder()
                        .sourceArchive(StdFunctions.filebase64(Filebase64Args.builder()
                            .input("./test-fixtures/mds_agent_src.tar.gz")
                            .build()).result())
                        .build())
                    .pythonSpec(AiReasoningEngineSpecSourceCodeSpecPythonSpecArgs.builder()
                        .entrypointModule("metadata_agent")
                        .entrypointObject("root_agent")
                        .build())
                    .build())
                .build())
            .build());

        final var default = VertexFunctions.getAiReasoningEngineQuery(GetAiReasoningEngineQueryArgs.builder()
            .reasoningEngineId(defaultAiReasoningEngine.name())
            .region("us-central1")
            .classMethod("query")
            .build());

    }
}

resources:
  defaultAiReasoningEngine:
    type: gcp:vertex:AiReasoningEngine
    name: default
    properties:
      displayName: vertex-mds-_91657
      description: Retrieves tenant project number
      region: us-central1
      spec:
        sourceCodeSpec:
          inlineSource:
            sourceArchive:
              fn::invoke:
                function: std:filebase64
                arguments:
                  input: ./test-fixtures/mds_agent_src.tar.gz
                return: result
          pythonSpec:
            entrypointModule: metadata_agent
            entrypointObject: root_agent
variables:
  default:
    fn::invoke:
      function: gcp:vertex:getAiReasoningEngineQuery
      arguments:
        reasoningEngineId: ${defaultAiReasoningEngine.name}
        region: us-central1
        classMethod: query

args Arguments passed to this invoke. Arguments for getAiReasoningEngineQuery. options Invoke options controlling this call.

Implementation

Future<GetAiReasoningEngineQueryResult> getAiReasoningEngineQuery(
  GetAiReasoningEngineQueryArgs args, {
  pulumi.InvokeOptions? options,
}) async {
  final deployment = pulumi.Deployment.instance;
  final result = await deployment.invoke<Map<String, dynamic>>(
    'gcp:vertex/getAiReasoningEngineQuery:getAiReasoningEngineQuery',
    args.toMap(),
    options: pulumi.toDeploymentInvokeOptions(options),
  );
  return GetAiReasoningEngineQueryResult.fromMap(result);
}