pulumi-language-ruby 0.0.1

data/pulumi/language.proto

@@ -0,0 +1,653 @@
+// Copyright 2016-2023, Pulumi Corporation.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+import "pulumi/codegen/hcl.proto";
+import "pulumi/plugin.proto";
+import "google/protobuf/empty.proto";
+import "google/protobuf/struct.proto";
+
+package pulumirpc;
+
+option go_package = "github.com/pulumi/pulumi/sdk/v3/proto/go;pulumirpc";
+
+// The LanguageRuntime service defines a standard interface for [language hosts/runtimes](languages). At a high level, a
+// language runtime provides the ability to execute programs, install and query dependencies, and generate code for a
+// specific language.
+service LanguageRuntime {
+    // `Handshake` is the first call made by the engine to a language host. It is used to pass the engine's address to
+    // the language host so that it may establish its own connections back, and to establish protocol configuration that
+    // will be used to communicate between the two parties.
+    rpc Handshake(LanguageHandshakeRequest) returns (LanguageHandshakeResponse) {}
+
+    // `GetRequiredPlugins` computes the complete set of anticipated [plugins](plugins) required by a Pulumi program.
+    // Among other things, it is intended to be used to pre-install plugins before running a program with
+    // [](pulumirpc.LanguageRuntime.Run), to avoid the need to install them on-demand in response to [resource
+    // registrations](resource-registration) sent back from the running program to the engine.
+    //
+    // :::{important}
+    // The use of `GetRequiredPlugins` is deprecated in favour of [](pulumirpc.LanguageRuntime.GetRequiredPackages),
+    // which returns more granular information about which plugins are required by which packages.
+    // :::
+    rpc GetRequiredPlugins(GetRequiredPluginsRequest) returns (GetRequiredPluginsResponse) {
+        option deprecated = true;
+    }
+
+    // `GetRequiredPackages` computes the complete set of anticipated [packages](pulumirpc.PackageDependency) required
+    // by a program. It is used to pre-install packages before running a program with [](pulumirpc.LanguageRuntime.Run),
+    // to avoid the need to install them on-demand in response to [resource registrations](resource-registration) sent
+    // back from the running program to the engine. Moreover, when importing resources into a stack, it is used to
+    // determine which plugins are required to service the import of a given resource, since given the presence of
+    // [parameterized providers](parameterized-providers), it is not in general true that a package name corresponds 1:1
+    // with a plugin name. It replaces [](pulumirpc.LanguageRuntime.GetRequiredPlugins) in the face of [parameterized
+    // providers](parameterized-providers), which as mentioned above can enable multiple instances of the same plugin to
+    // provide multiple packages.
+    rpc GetRequiredPackages(GetRequiredPackagesRequest) returns (GetRequiredPackagesResponse) {}
+
+    // `Run` executes a Pulumi program, returning information about whether or not the program produced an error.
+    rpc Run(RunRequest) returns (RunResponse) {}
+
+    // `GetPluginInfo` returns information about the [plugin](plugins) implementing this language runtime.
+    rpc GetPluginInfo(google.protobuf.Empty) returns (PluginInfo) {}
+
+    // `InstallDependencies` accepts a request specifying a Pulumi project and program that can be executed with
+    // [](pulumirpc.LanguageRuntime.Run) and installs the dependencies for that program (e.g. by running `npm install`
+    // for NodeJS, or `pip install` for Python). Since dependency installation could take a while, and callers may wish
+    // to report on its progress, this method returns a stream of [](pulumirpc.InstallDependenciesResponse) messages
+    // containing information about standard error and output.
+    rpc InstallDependencies(InstallDependenciesRequest) returns (stream InstallDependenciesResponse) {}
+
+    // `RuntimeOptionsPrompts` accepts a request specifying a Pulumi project and returns a list of additional prompts to
+    // ask during `pulumi new`.
+    rpc RuntimeOptionsPrompts(RuntimeOptionsRequest) returns (RuntimeOptionsResponse) {}
+
+    // `Template` allows the language runtime to perform additional templating on a newly instantiated project template.
+    // For example the Python runtime might want to convert a requirements.txt into a pyproject.toml suitable for use
+    // with uv or poetry.
+    rpc Template(TemplateRequest) returns (TemplateResponse) {}
+
+    // `About` returns information about the language runtime being used.
+    rpc About(AboutRequest) returns (AboutResponse) {}
+
+    // `GetProgramDependencies` computes the set of language-level dependencies (e.g. NPM packages for NodeJS, or Maven
+    // libraries for Java) required by a program.
+    rpc GetProgramDependencies(GetProgramDependenciesRequest) returns (GetProgramDependenciesResponse) {}
+
+    // `RunPlugin` is used to execute a program written in this host's language that implements a Pulumi
+    // [plugin](plugins). It is to plugins what [](pulumirpc.LanguageRuntime.Run) is to programs. Since a plugin is not
+    // expected to terminate until instructed/for a long time, this method returns a stream of
+    // [](pulumirpc.RunPluginResponse) messages containing information about standard error and output, as well as the
+    // exit code of the plugin when it does terminate.
+    rpc RunPlugin(RunPluginRequest) returns (stream RunPluginResponse) {}
+
+    // `GenerateProgram` generates code in this host's language that implements the given [PCL](pcl) program. Unlike
+    // [](pulumirpc.LanguageRuntime.GenerateProject), this method *only* generates program code, and does not e.g.
+    // generate a `package.json` for a NodeJS project that details how to run that code.
+    // [](pulumirpc.LanguageRuntime.GenerateProject), this method underpins ["programgen"](programgen) and the main
+    // functionality powering `pulumi convert`.
+    rpc GenerateProgram(GenerateProgramRequest) returns (GenerateProgramResponse) {}
+
+    // `GenerateProject` generates code in this host's language that implements the given [PCL](pcl) program and wraps
+    // it in some language-specific notion of a "project", where a project is a buildable or runnable artifact. In this
+    // sense, `GenerateProject`'s output is a superset of that of [](pulumirpc.LanguageRuntime.GenerateProgram). For
+    // instance, when generating a NodeJS project, this method might generate a corresponding `package.json` file, as
+    // well as the relevant NodeJS program code. Along with [](pulumirpc.LanguageRuntime.GenerateProgram), this method
+    // underpins ["programgen"](programgen) and the main functionality powering `pulumi convert`.
+    rpc GenerateProject(GenerateProjectRequest) returns (GenerateProjectResponse) {}
+
+    // `GeneratePackage` generates code in this host's language that implements an [SDK](sdkgen) ("sdkgen") for the
+    // given Pulumi package, as specified by a [schema](schema).
+    rpc GeneratePackage(GeneratePackageRequest) returns (GeneratePackageResponse) {}
+
+    // `Pack` accepts a request specifying a generated SDK package and packs it into a language-specific artifact. For
+    // instance, in the case of Java, it might produce a JAR file from a list of `.java` sources; in the case of NodeJS,
+    // a `.tgz` file might be produced from a list of `.js` sources; and so on. Presently, `Pack` is primarily used in
+    // [language conformance tests](language-conformance-tests), though it is intended to be used more widely in future
+    // to standardise e.g. provider publishing workflows.
+    rpc Pack(PackRequest) returns (PackResponse) {}
+
+    // `Link` links local dependencies into a project (program or plugin). The dependencies can be binary artifacts such
+    // as wheel or tar.gz files, or source directories. `Link` will update the language specific project files, such as
+    // `package.json`, `pyproject.toml`, `go.mod`, etc, to include the dependency. `Link` returns instructions for the
+    // user on how to use the linked package in the project.
+    rpc Link(LinkRequest) returns (LinkResponse) {}
+
+    // `Cancel` signals the language runtime to gracefully shut down and abort any ongoing operations.
+    // Operations aborted in this way will return an error.
+    rpc Cancel(google.protobuf.Empty) returns (google.protobuf.Empty) {}
+}
+
+// A `ProgramInfo` struct specifies a Pulumi program, and is built typically based on the location of a `Pulumi.yaml`
+// file and the `runtime`, `main` and other properties within that file.
+message ProgramInfo {
+    // The root of the project containing the program, where the `Pulumi.yaml` file is located. This should be an
+    // absolute path on the filesystem that is accessible to the language host.
+    string root_directory = 1;
+
+    // The directory containing the program to execute (e.g. the location of the `index.ts` for a TypeScript NodeJS
+    // program). This should be an absolute path on the filesystem that is accessible to the language host. If
+    // `ProgramInfo` is being built from a `Pulumi.yaml`, this will typically be the directory portion of the `main`
+    // property in that file.
+    string program_directory = 2;
+
+    // The entry point of the program to execute. This should be a relative path from the `program_directory`, and is
+    // often just `.` to indicate the program directory itself, but it can also be a filename inside the directory.. If
+    // `ProgramInfo` is being built from a `Pulumi.yaml`, this will typically be the filename specified `main` property
+    // in that file if it is present, or the aforementioned `.` if not.
+    string entry_point = 3;
+
+    // A struct capturing any language-specific options. If `ProgramInfo` is being built from a `Pulumi.yaml`, this will
+    // contain the `runtime.options` property from that file.
+    google.protobuf.Struct options = 4;
+}
+
+// `AboutRequest` is the type of requests sent as part of an [](pulumirpc.LanguageRuntime.About) call.
+message AboutRequest {
+    // The program to use.
+    ProgramInfo info = 1;
+}
+
+// `AboutResponse` is the type of responses sent by an [](pulumirpc.LanguageRuntime.About) call. It contains information
+// about the language runtime being used.
+message AboutResponse {
+    // The primary executable for the runtime of this language. This should be an absolute path. E.g. for NodeJS on a
+    // POSIX system, this might be something like `/usr/bin/node`.
+    string executable = 1;
+
+    // The version of the runtime underpinning the language host. E.g. for a NodeJS host, this might be the version of
+    // `node` being used.
+    string version = 2;
+
+    // Other host-specific metadata about the runtime underpinning the language host.
+    map<string, string> metadata = 3;
+}
+
+// `GetProgramDependenciesRequest` is the type of requests sent as part of a
+// [](pulumirpc.LanguageRuntime.GetProgramDependencies) call.
+message GetProgramDependenciesRequest {
+    // The project name.
+    //
+    // :::{important}
+    // This is deprecated in favour of passing a [program info](pulumirpc.ProgramInfo) struct as the `info` field. Newer
+    // versions of the engine will always set this field to the string `"deprecated"`.
+    // :::
+    string project = 1 [deprecated = true];
+
+    // The program's working directory.
+    //
+    // :::{important}
+    // This is deprecated in favour of passing a [program info](pulumirpc.ProgramInfo) struct as the `info` field, with
+    // the `program_directory` field set to this value.
+    // :::
+    string pwd = 2 [deprecated = true];
+
+    // The path to the program.
+    //
+    // :::{important}
+    // This is deprecated in favour of passing a [program info](pulumirpc.ProgramInfo) struct as the `info` field, with
+    // the `entry_point` field set to this value.
+    // :::
+    string program = 3 [deprecated = true];
+
+    // True if transitive dependencies should be included in the response.
+    bool transitiveDependencies = 4;
+
+    // The program to use.
+    ProgramInfo info = 5;
+}
+
+// `DependencyInfo` is a struct that captures information about a language-specific dependency required by a program
+// (e.g. an NPM package for NodeJS, or a Maven library for Java). It is returned as part of a
+// [](pulumirpc.LanguageRuntime.GetProgramDependenciesResponse).
+message DependencyInfo {
+    // The name of the dependency.
+    string name = 1;
+
+    // The version of the dependency.
+    string version = 2;
+}
+
+// `GetProgramDependenciesResponse` is the type of responses sent by a
+// [](pulumirpc.LanguageRuntime.GetProgramDependencies) call. It contains information about the dependencies of a
+// program.
+message GetProgramDependenciesResponse {
+    // The dependencies of the program specified by the request.
+    repeated DependencyInfo dependencies = 1;
+}
+
+// `GetRequiredPluginsRequest` is the type of requests sent as part of a
+// [](pulumirpc.LanguageRuntime.GetRequiredPlugins) call.
+message GetRequiredPluginsRequest {
+    // The project name.
+    //
+    // :::{important}
+    // This is deprecated in favour of passing a [program info](pulumirpc.ProgramInfo) struct as the `info` field. Newer
+    // versions of the engine will always set this field to the string `"deprecated"`.
+    // :::
+    string project = 1 [deprecated = true];
+
+    // The program's working directory.
+    //
+    // :::{important}
+    // This is deprecated in favour of passing a [program info](pulumirpc.ProgramInfo) struct as the `info` field, with
+    // the `program_directory` field set to this value.
+    // :::
+    string pwd = 2 [deprecated = true];
+
+    // The path to the program.
+    //
+    // :::{important}
+    // This is deprecated in favour of passing a [program info](pulumirpc.ProgramInfo) struct as the `info` field, with
+    // the `entry_point` field set to this value.
+    // :::
+    string program = 3 [deprecated = true];
+
+    // The program to use.
+    ProgramInfo info = 4;
+}
+
+// `GetRequiredPluginsResponse` is the type of responses sent by a [](pulumirpc.LanguageRuntime.GetRequiredPlugins)
+// call. It contains information about the plugins required by a program.
+message GetRequiredPluginsResponse {
+    // The plugins required by the program specified by the request.
+    repeated PluginDependency plugins = 1;
+}
+
+// `GetRequiredPackagesRequest` is the type of requests sent as part of a
+// [](pulumirpc.LanguageRuntime.GetRequiredPackages) call.
+message GetRequiredPackagesRequest {
+    // The program to use.
+    ProgramInfo info = 1;
+}
+
+// `GetRequiredPackagesResponse` is the type of responses sent by a [](pulumirpc.LanguageRuntime.GetRequiredPackages)
+// call. It contains information about the packages required by a program.
+message GetRequiredPackagesResponse {
+    // The packages required by the program specified by the request.
+    repeated PackageDependency packages = 1;
+}
+
+// `RunRequest` is the type of requests sent as part of a [](pulumirpc.LanguageRuntime.Run) call.
+message RunRequest {
+    // The project name.
+    string project = 1;
+
+    // The name of the stack being deployed into.
+    string stack = 2;
+
+    // The program's working directory.
+    string pwd = 3;
+
+    // The path to the program.
+    //
+    // :::{important}
+    // This is deprecated in favour of passing a [program info](pulumirpc.ProgramInfo) struct as the `info` field, with
+    // the `entry_point` field set to this value.
+    // :::
+    string program = 4 [deprecated = true];
+
+    // Any arguments to pass to the program.
+    repeated string args = 5;
+
+    // Configuration variables to apply before running the program.
+    map<string, string> config = 6;
+
+    // True if we are only doing a dry run (preview).
+    bool dryRun = 7;
+
+    // The degree of parallelism that should be used for resource operations. A value less than or equal to 1 indicates
+    // serial execution.
+    int32 parallel = 8;
+
+    // The address of the [](pulumirpc.ResourceMonitor) that the program should connect to send [resource
+    // registrations](resource-registration) and other calls to.
+    string monitor_address = 9;
+
+    // This is deprecated, query mode is no longer a supported feature.
+    bool queryMode = 10 [deprecated = true];
+
+    // A list of configuration keys whose values should be treated as secrets.
+    repeated string configSecretKeys = 11;
+
+    // The organization of the stack being deployed into.
+    string organization = 12;
+
+    // This is deprecated, runtimes should look at the string based config as that maintains the full textual data from
+    // the users config file.
+    google.protobuf.Struct configPropertyMap = 13 [deprecated = true];
+
+    // The program to use.
+    ProgramInfo info = 14;
+
+    // The target of a codegen.LoaderServer to use for loading schemas.
+    string loader_target = 15;
+
+    // True if and only if the host should start the program under a debugger.
+    bool attach_debugger = 16;
+}
+
+// `RunResponse` is the type of responses sent by a [](pulumirpc.LanguageRuntime.Run) call.
+message RunResponse {
+    // Information about any unhandled error that occurred during the run.
+    string error = 1;
+
+    // True if an error happened, but it was reported to the user. Work should halt immediately, reporting nothing
+    // further to the user (since this reporting has already happened). This corresponds to a `result.Bail()` value
+    // being raised in the Go application layer.
+    bool bail = 2;
+}
+
+// `InstallDependenciesRequest` is the type of requests sent as part of an
+// [](pulumirpc.LanguageRuntime.InstallDependencies) call.
+message InstallDependenciesRequest {
+    // The program's working directory.
+    //
+    // :::{important}
+    // This is deprecated in favour of passing a [program info](pulumirpc.ProgramInfo) struct as the `info` field, with
+    // the `program_directory` field set to this value.
+    // :::
+    string directory = 1 [deprecated = true];
+
+    // True if we are running in a terminal and may use [ANSI escape
+    // codes](https://en.wikipedia.org/wiki/ANSI_escape_code) in our output.
+    bool is_terminal = 2;
+
+    // The program to use.
+    ProgramInfo info = 3;
+
+    // True if the host should use language-specific version managers, such as `pyenv` or `nvm`, to set up the version
+    // of the language toolchain used.
+    bool use_language_version_tools = 4;
+
+    // True if this install is for a plugin, as opposed to a top level Pulumi program.
+    bool is_plugin = 5;
+}
+
+// `InstallDependenciesResponse` is the type of responses streamed by an
+// [](pulumirpc.LanguageRuntime.InstallDependencies) call.
+message InstallDependenciesResponse {
+    // A line of standard output.
+    bytes stdout = 1;
+
+    // A line of standard error.
+    bytes stderr = 2;
+}
+
+// `RuntimeOptionsRequest` is the type of requests sent as part of a [](pulumirpc.LanguageRuntime.RuntimeOptionsPrompts)
+// call.
+message RuntimeOptionsRequest {
+    // The program to use.
+    ProgramInfo info = 1;
+}
+
+// `RuntimeOptionPrompt` is a struct that captures information about a runtime option that should be prompted for during
+// `pulumi new`.
+message RuntimeOptionPrompt {
+    // `RuntimeOptionType` is an enum that captures the type of a runtime option.
+    enum RuntimeOptionType {
+        // A string value.
+        STRING = 0;
+
+        // A 32-bit integer value.
+        INT32 = 1;
+    }
+
+    // `RuntimeOptionValue` is a struct that captures the value of a runtime option.
+    message RuntimeOptionValue {
+        // The type of the runtime option.
+        RuntimeOptionType promptType = 1;
+
+        // The string value of the runtime option, if and only if the type is `STRING`.
+        string stringValue = 2;
+
+        // The 32-bit integer value of the runtime option, if and only if the type is `INT32`.
+        int32 int32Value = 3;
+
+        // The display name of the runtime option, to be used in prompts.
+        string displayName = 4;
+    }
+
+    // A unique key that identifies the runtime option.
+    string key = 1;
+
+    // A human-readable description of the runtime option.
+    string description = 2;
+
+    // The type of the runtime option.
+    RuntimeOptionType promptType = 3;
+
+    // A set of choices for the runtime option that may be displayed as part of the prompting process.
+    repeated RuntimeOptionValue choices = 4;
+
+    // The default value of the runtime option.
+    RuntimeOptionValue default = 5;
+}
+
+// `RuntimeOptionsResponse` is the type of responses sent by a [](pulumirpc.LanguageRuntime.RuntimeOptionsPrompts) call.
+// It contains information about additional prompts to ask during `pulumi new`.
+message RuntimeOptionsResponse {
+    // Prompts to ask the user.
+    repeated RuntimeOptionPrompt prompts = 1;
+}
+
+// `TemplateRequest` is the type of requests sent as part of a [](pulumirpc.LanguageRuntime.Template) call.
+message TemplateRequest {
+    // The [plugin program](pulumirpc.ProgramInfo) to use.
+    ProgramInfo info = 1;
+
+    // The name of the project we are templating.
+    string project_name = 2;
+}
+
+// `TemplateResponse` is the type of responses sent by a [](pulumirpc.LanguageRuntime.Template) call.
+message TemplateResponse {}
+
+// `RunPluginRequest` is the type of requests sent as part of a [](pulumirpc.LanguageRuntime.RunPlugin) call.
+message RunPluginRequest{
+    // The plugin program's working directory.
+    string pwd = 1;
+
+    // The path to the plugin program.
+    //
+    // :::{important}
+    // This is deprecated in favour of passing a [program info](pulumirpc.ProgramInfo) struct as the `info` field, with
+    // the `entry_point` field set to this value.
+    // :::
+    string program = 2 [deprecated = true];
+
+    // Any arguments to pass to the plugin program.
+    repeated string args = 3;
+
+    // Any environment variables to set prior to executing the plugin program.
+    repeated string env = 4;
+
+    // The [plugin program](pulumirpc.ProgramInfo) to use.
+    ProgramInfo info = 5;
+
+    // The kind of plugin to run (resource/analyzer/etc).
+    string kind = 6;
+
+    // The name of the plugin (for display purposes)
+    string name = 7;
+
+    // True if a plugin should be started under a debugger.
+    bool attach_debugger = 8;
+}
+
+// `RunPluginResponse` is the type of responses streamed by a [](pulumirpc.LanguageRuntime.RunPlugin) call.
+message RunPluginResponse {
+    oneof output {
+        // A line of standard output.
+        bytes stdout = 1;
+
+        // A line of standard error.
+        bytes stderr = 2;
+
+        // An exit code that the plugin program has terminated with. This should be the last message sent by the host.
+        int32 exitcode = 3;
+    }
+}
+
+// `GenerateProgramRequest` is the type of requests sent as part of a [](pulumirpc.LanguageRuntime.GenerateProgram)
+// call.
+message GenerateProgramRequest {
+    // The source of the project, represented as a map of file names to [PCL](pcl) source code.
+    map<string, string> source = 1;
+
+    // The target of a codegen.LoaderServer to use for loading schemas.
+    string loader_target = 2;
+
+    // True if [PCL binding](pcl-binding) should be strict.
+    bool strict = 3;
+}
+
+// `GenerateProgramResponse` is the type of responses sent by a [](pulumirpc.LanguageRuntime.GenerateProgram) call.
+message GenerateProgramResponse {
+    // Any diagnostics raised by code generation.
+    repeated pulumirpc.codegen.Diagnostic diagnostics = 1;
+
+    // The generated program source code, represented as a map of file names to byte contents.
+    map<string, bytes> source = 2;
+}
+
+// `GenerateProjectRequest` is the type of requests sent as part of a [](pulumirpc.LanguageRuntime.GenerateProject) call.
+message GenerateProjectRequest {
+    // The directory containing [PCL](pcl) source code, from which the project should be generated.
+    string source_directory = 1;
+
+    // The directory in which generated project files should be written. This should be an absolute path on the
+    // filesystem that is accessible to the language host.
+    string target_directory = 2;
+
+    // A string containing JSON to be used as the Pulumi project file (that is, as the contents of `Pulumi.yaml`).
+    string project = 3;
+
+    // True if [PCL binding](pcl-binding) should be strict.
+    bool strict = 4;
+
+    // The target of a codegen.LoaderServer to use for loading schemas.
+    string loader_target = 5;
+
+    // Local dependencies that the generated project should reference explicitly, instead of e.g. using the language's
+    // package system. This is a map of package names to local paths of language-specific artifacts that should be used.
+    // For instance, in the case of a NodeJS project, this might be a map of NPM package names to local paths to be
+    // used, such as `{ "@pulumi/aws": "/some/path/to/aws.tgz" }` if a local tarball is to be used instead of the
+    // published `@pulumi/aws` package.
+    map<string, string> local_dependencies = 6;
+}
+
+// `GenerateProjectResponse` is the type of responses sent by a [](pulumirpc.LanguageRuntime.GenerateProject) call.
+message GenerateProjectResponse {
+    // Any diagnostics raised by code generation.
+    repeated pulumirpc.codegen.Diagnostic diagnostics = 1;
+}
+
+// `GeneratePackageRequest` is the type of requests sent as part of a [](pulumirpc.LanguageRuntime.GeneratePackage) call.
+message GeneratePackageRequest {
+    // The directory to generate the package in. This should be an absolute path on the filesystem that is accessible to
+    // the language host.
+    string directory = 1;
+
+    // A JSON-encoded string containing the schema from which the SDK package should be generated.
+    string schema = 2;
+
+    // Extra files that should be copied as-is to the generated output.
+    map<string, bytes> extra_files = 3;
+
+    // The target of a codegen.LoaderServer to use for loading schemas.
+    string loader_target = 4;
+
+    // Local dependencies that the generated package should reference explicitly, instead of e.g. using the language's
+    // package system. This is a map of package names to local paths of language-specific artifacts that should be used.
+    // For instance, in the case of a NodeJS package, this might be a map of NPM package names to local paths to be
+    // used, such as `{ "@pulumi/aws": "/some/path/to/aws.tgz" }` if a local tarball is to be used instead of the
+    // published `@pulumi/aws` package.
+    map<string, string> local_dependencies = 5;
+
+    // If true, generates an SDK appropriate for local usage. This may differ from a standard publishable SDK depending
+    // on the language (e.g. for a NodeJS package that is intended to be imported locally, the language host may choose
+    // not to generate a `package.json`).
+    bool local = 6;
+}
+
+// `GeneratePackageResponse` is the type of responses sent by a [](pulumirpc.LanguageRuntime.GeneratePackage) call.
+message GeneratePackageResponse {
+    // Any diagnostics raised by code generation.
+    repeated pulumirpc.codegen.Diagnostic diagnostics = 1;
+}
+
+// `PackRequest` is the type of requests sent as part of a [](pulumirpc.LanguageRuntime.Pack) call.
+message PackRequest {
+    // The directory containing the package to pack. This should be an absolute path on the filesystem that is accessible
+    // to the language host.
+    string package_directory = 1;
+
+    // The directory to write the packed artifact to. This should be an absolute path on the filesystem that is
+    // accessible to the language host.
+    string destination_directory = 2;
+}
+
+// `PackResponse` is the type of responses sent by a [](pulumirpc.LanguageRuntime.Pack) call.
+message PackResponse {
+    // The path to the packed artifact. This should be an absolute path on the filesystem that is accessible to the
+    // language host.
+    string artifact_path = 1;
+}
+
+// `LanguageHandshakeRequest` is the type of requests sent as part of a [](pulumirpc.LanguageRuntime.Handshake) call.
+message LanguageHandshakeRequest {
+    // The gRPC address of the engine calling the language host.
+    string engine_address = 1;
+
+    // The optional root directory, where the `PulumiPlugin.yaml` file or language binary is located. This can't be sent
+    // when the engine is attaching to a language via a port number.
+    optional string root_directory = 2;
+
+    // The optional absolute path to the directory of the language program to execute. Generally, but not required to
+    // be, underneath the root directory. This can't be sent when the engine is attaching to a language via a port
+    // number.
+    optional string program_directory = 3;
+}
+
+// `LanguageHandshakeResponse` is the type of responses sent by a [](pulumirpc.LanguageRuntime.Handshake) call.
+message LanguageHandshakeResponse {
+}
+
+// `LinkRequest` is the type of requests sent as part of a [](pulumirpc.LanguageRuntime.Link) call.
+message LinkRequest {
+    // The program to use.
+    ProgramInfo info = 1;
+
+    // The target of a codegen.LoaderServer to use for loading schemas.
+    string loader_target = 2;
+
+    message LinkDependency {
+        PackageDependency package = 1;
+        string path = 2;
+    }
+
+    // Local dependencies that should be linked into the program or plugin's language specific project files.
+    // Each dependency has a path to a language specific artifact. This can be a binary artifact like a
+    // Python wheel or a tar.gz for Node.js, or a source directory.
+    repeated LinkDependency packages = 3;
+}
+
+// `LinkResponse` is the type of responses sent by a [](pulumirpc.LanguageRuntime.Link) call.
+message LinkResponse {
+    // The instructions on how to use a linked package in a program or plugin. These instructions are meant
+    // to be displayed to the user. For example when linking a local Python dependency, this might return
+    // `import my_namespace_mypkg as mypkg`.
+    string import_instructions = 1;
+}