diff --git a/openapi/openapiv2.json b/openapi/openapiv2.json index bb5acc172..ce7cfd5cf 100644 --- a/openapi/openapiv2.json +++ b/openapi/openapiv2.json @@ -15074,6 +15074,35 @@ }, "description": "ComputeProvider stores information used by a worker control plane controller\nto respond to worker lifecycle events. For example, when a Task is received\non a TaskQueue that has no active pollers, a serverless worker lifecycle\ncontroller might need to invoke an AWS Lambda Function that itself ends up\ncalling the SDK's worker.New() function." }, + "v1ComputeProviderReleaseStage": { + "type": "string", + "enum": [ + "COMPUTE_PROVIDER_RELEASE_STAGE_UNSPECIFIED", + "COMPUTE_PROVIDER_RELEASE_STAGE_PRE_RELEASE", + "COMPUTE_PROVIDER_RELEASE_STAGE_PUBLIC_PREVIEW", + "COMPUTE_PROVIDER_RELEASE_STAGE_GENERALLY_AVAILABLE" + ], + "default": "COMPUTE_PROVIDER_RELEASE_STAGE_UNSPECIFIED", + "description": "How far along its rollout a compute provider is. Clients use this to label a\nprovider in a picker, and to decide whether to offer it prominently, so the\nlabel follows the server rather than being hardcoded per client.\n\n - COMPUTE_PROVIDER_RELEASE_STAGE_UNSPECIFIED: Release stage is not specified. Clients should treat the provider as\nusable but unlabeled.\n - COMPUTE_PROVIDER_RELEASE_STAGE_PRE_RELEASE: The provider is implemented but not yet ready for general use. Expect\nbreaking changes. Clients should label it accordingly and may choose not\nto offer it by default.\n - COMPUTE_PROVIDER_RELEASE_STAGE_PUBLIC_PREVIEW: The provider is available to all users but still gathering feedback, and\nmay change in backwards-incompatible ways before becoming generally\navailable.\n - COMPUTE_PROVIDER_RELEASE_STAGE_GENERALLY_AVAILABLE: The provider is generally available and covered by compatibility\nguarantees." + }, + "v1ComputeProviderStatus": { + "type": "object", + "properties": { + "type": { + "type": "string", + "description": "The provider type, matching ComputeProvider.type. This is the value a\nclient sends back when configuring a scaling group, so it is the\nprovider's identity, not a display name." + }, + "enabled": { + "type": "boolean", + "description": "Whether this Service will accept a ComputeConfig naming this provider.\nDepends both on the build and on Service configuration, the same way the\nper-capability booleans in GetSystemInfoResponse.Capabilities do." + }, + "releaseStage": { + "$ref": "#/definitions/v1ComputeProviderReleaseStage", + "description": "How far along its rollout the provider is. Lets a client label a\nprovider without shipping its own release-stage table, and lets the\nlabel change without a client release." + } + }, + "description": "ComputeProviderStatus describes one compute provider this Service knows\nabout, so a client can discover which providers exist and how to present\nthem without hardcoding a list of its own.\n\nThis is typed where ComputeProvider.details is an opaque Payload, and the\ndifference is deliberate. Provider *config* is open-ended and genuinely\nprovider-specific: a Lambda ARN, a Cloud Run worker pool, and an AgentCore\nendpoint ARN share no shape, which is why an earlier typed\nProviderDetailAWSLambda gave way to a Payload. Provider *status* is uniform.\nEvery provider has an identity, an enabled bit, and a release stage, and none\nneeds a field the others do not.\n\nA Service reports a provider it recognizes even when that provider is\ndisabled, so a client can tell \"this Service has never heard of AgentCore\"\napart from \"this Service knows AgentCore but it is turned off here\", and say\nso rather than silently omitting the option." + }, "v1ComputeScaler": { "type": "object", "properties": { @@ -16326,7 +16355,7 @@ }, "serverScaledProviderCloudRun": { "type": "boolean", - "description": "True if the server supports the Cloud Run compute provider for\nserver-scaled deployments. Dependent on server version and the\nprovider being enabled via server configuration." + "description": "True if the server supports the Cloud Run compute provider for\nserver-scaled deployments. Dependent on server version and the\nprovider being enabled via server configuration.\n\nSuperseded by NamespaceInfo.compute_providers, which reports every\nprovider and its release stage per Namespace rather than one boolean\nper provider for the whole Service. Retained for wire compatibility\nwith clients that already read it. No further per-provider booleans\nshould be added here: this response is served as a fixed payload in\nsome deployments, so it cannot express per-Namespace availability." } }, "description": "System capability details." @@ -17183,6 +17212,14 @@ "$ref": "#/definitions/NamespaceInfoLimits", "title": "Namespace configured limits" }, + "computeProviders": { + "type": "array", + "items": { + "type": "object", + "$ref": "#/definitions/v1ComputeProviderStatus" + }, + "description": "The compute providers available for server-scaled Worker Deployments in\nthis Namespace: which ones this Namespace can use, whether each is\ncurrently enabled, and how far along its rollout each one is.\n\nNamespace-scoped rather than Service-scoped for two reasons. Availability\ngenuinely varies per Namespace: a provider is tied to the cloud a\nNamespace runs in, so an AWS Namespace and a GCP Namespace do not offer\nthe same set, and managed deployments gate providers per account.\nGetSystemInfo cannot express either, and is served as a fixed payload\nahead of the Service in some deployments, so a per-provider boolean there\nis not reachable as a real signal." + }, "supportsSchedules": { "type": "boolean", "description": "Whether scheduled workflows are supported on this namespace. This is only needed\ntemporarily while the feature is experimental, so we can give it a high tag." diff --git a/openapi/openapiv3.yaml b/openapi/openapiv3.yaml index 1d4c2cdc0..3cdf641a5 100644 --- a/openapi/openapiv3.yaml +++ b/openapi/openapiv3.yaml @@ -11255,6 +11255,50 @@ components: on a TaskQueue that has no active pollers, a serverless worker lifecycle controller might need to invoke an AWS Lambda Function that itself ends up calling the SDK's worker.New() function. + ComputeProviderStatus: + type: object + properties: + type: + type: string + description: |- + The provider type, matching ComputeProvider.type. This is the value a + client sends back when configuring a scaling group, so it is the + provider's identity, not a display name. + enabled: + type: boolean + description: |- + Whether this Service will accept a ComputeConfig naming this provider. + Depends both on the build and on Service configuration, the same way the + per-capability booleans in GetSystemInfoResponse.Capabilities do. + releaseStage: + enum: + - COMPUTE_PROVIDER_RELEASE_STAGE_UNSPECIFIED + - COMPUTE_PROVIDER_RELEASE_STAGE_PRE_RELEASE + - COMPUTE_PROVIDER_RELEASE_STAGE_PUBLIC_PREVIEW + - COMPUTE_PROVIDER_RELEASE_STAGE_GENERALLY_AVAILABLE + type: string + description: |- + How far along its rollout the provider is. Lets a client label a + provider without shipping its own release-stage table, and lets the + label change without a client release. + format: enum + description: |- + ComputeProviderStatus describes one compute provider this Service knows + about, so a client can discover which providers exist and how to present + them without hardcoding a list of its own. + + This is typed where ComputeProvider.details is an opaque Payload, and the + difference is deliberate. Provider *config* is open-ended and genuinely + provider-specific: a Lambda ARN, a Cloud Run worker pool, and an AgentCore + endpoint ARN share no shape, which is why an earlier typed + ProviderDetailAWSLambda gave way to a Payload. Provider *status* is uniform. + Every provider has an identity, an enabled bit, and a release stage, and none + needs a field the others do not. + + A Service reports a provider it recognizes even when that provider is + disabled, so a client can tell "this Service has never heard of AgentCore" + apart from "this Service knows AgentCore but it is turned off here", and say + so rather than silently omitting the option. ComputeScaler: type: object properties: @@ -12648,6 +12692,13 @@ components: True if the server supports the Cloud Run compute provider for server-scaled deployments. Dependent on server version and the provider being enabled via server configuration. + + Superseded by NamespaceInfo.compute_providers, which reports every + provider and its release stage per Namespace rather than one boolean + per provider for the whole Service. Retained for wire compatibility + with clients that already read it. No further per-provider booleans + should be added here: this response is served as a fixed payload in + some deployments, so it cannot express per-Namespace availability. description: System capability details. GetWorkerBuildIdCompatibilityResponse: type: object @@ -13480,6 +13531,22 @@ components: allOf: - $ref: '#/components/schemas/NamespaceInfo_Limits' description: Namespace configured limits + computeProviders: + type: array + items: + $ref: '#/components/schemas/ComputeProviderStatus' + description: |- + The compute providers available for server-scaled Worker Deployments in + this Namespace: which ones this Namespace can use, whether each is + currently enabled, and how far along its rollout each one is. + + Namespace-scoped rather than Service-scoped for two reasons. Availability + genuinely varies per Namespace: a provider is tied to the cloud a + Namespace runs in, so an AWS Namespace and a GCP Namespace do not offer + the same set, and managed deployments gate providers per account. + GetSystemInfo cannot express either, and is served as a fixed payload + ahead of the Service in some deployments, so a per-provider boolean there + is not reachable as a real signal. supportsSchedules: type: boolean description: |- diff --git a/temporal/api/compute/v1/status.proto b/temporal/api/compute/v1/status.proto new file mode 100644 index 000000000..af660272c --- /dev/null +++ b/temporal/api/compute/v1/status.proto @@ -0,0 +1,45 @@ +syntax = "proto3"; + +package temporal.api.compute.v1; + +option go_package = "go.temporal.io/api/compute/v1;compute"; +option java_package = "io.temporal.api.compute.v1"; +option java_multiple_files = true; +option java_outer_classname = "StatusProto"; +option ruby_package = "Temporalio::Api::Compute::V1"; +option csharp_namespace = "Temporalio.Api.Compute.V1"; + +import "temporal/api/enums/v1/compute.proto"; + +// ComputeProviderStatus describes one compute provider this Service knows +// about, so a client can discover which providers exist and how to present +// them without hardcoding a list of its own. +// +// This is typed where ComputeProvider.details is an opaque Payload, and the +// difference is deliberate. Provider *config* is open-ended and genuinely +// provider-specific: a Lambda ARN, a Cloud Run worker pool, and an AgentCore +// endpoint ARN share no shape, which is why an earlier typed +// ProviderDetailAWSLambda gave way to a Payload. Provider *status* is uniform. +// Every provider has an identity, an enabled bit, and a release stage, and none +// needs a field the others do not. +// +// A Service reports a provider it recognizes even when that provider is +// disabled, so a client can tell "this Service has never heard of AgentCore" +// apart from "this Service knows AgentCore but it is turned off here", and say +// so rather than silently omitting the option. +message ComputeProviderStatus { + // The provider type, matching ComputeProvider.type. This is the value a + // client sends back when configuring a scaling group, so it is the + // provider's identity, not a display name. + string type = 1; + + // Whether this Service will accept a ComputeConfig naming this provider. + // Depends both on the build and on Service configuration, the same way the + // per-capability booleans in GetSystemInfoResponse.Capabilities do. + bool enabled = 2; + + // How far along its rollout the provider is. Lets a client label a + // provider without shipping its own release-stage table, and lets the + // label change without a client release. + temporal.api.enums.v1.ComputeProviderReleaseStage release_stage = 3; +} diff --git a/temporal/api/enums/v1/compute.proto b/temporal/api/enums/v1/compute.proto new file mode 100644 index 000000000..d67e4525e --- /dev/null +++ b/temporal/api/enums/v1/compute.proto @@ -0,0 +1,30 @@ +syntax = "proto3"; + +package temporal.api.enums.v1; + +option go_package = "go.temporal.io/api/enums/v1;enums"; +option java_package = "io.temporal.api.enums.v1"; +option java_multiple_files = true; +option java_outer_classname = "ComputeProto"; +option ruby_package = "Temporalio::Api::Enums::V1"; +option csharp_namespace = "Temporalio.Api.Enums.V1"; + +// How far along its rollout a compute provider is. Clients use this to label a +// provider in a picker, and to decide whether to offer it prominently, so the +// label follows the server rather than being hardcoded per client. +enum ComputeProviderReleaseStage { + // Release stage is not specified. Clients should treat the provider as + // usable but unlabeled. + COMPUTE_PROVIDER_RELEASE_STAGE_UNSPECIFIED = 0; + // The provider is implemented but not yet ready for general use. Expect + // breaking changes. Clients should label it accordingly and may choose not + // to offer it by default. + COMPUTE_PROVIDER_RELEASE_STAGE_PRE_RELEASE = 1; + // The provider is available to all users but still gathering feedback, and + // may change in backwards-incompatible ways before becoming generally + // available. + COMPUTE_PROVIDER_RELEASE_STAGE_PUBLIC_PREVIEW = 2; + // The provider is generally available and covered by compatibility + // guarantees. + COMPUTE_PROVIDER_RELEASE_STAGE_GENERALLY_AVAILABLE = 3; +} diff --git a/temporal/api/namespace/v1/message.proto b/temporal/api/namespace/v1/message.proto index a80566458..d0db45a7e 100644 --- a/temporal/api/namespace/v1/message.proto +++ b/temporal/api/namespace/v1/message.proto @@ -12,6 +12,7 @@ option csharp_namespace = "Temporalio.Api.Namespace.V1"; import "google/protobuf/duration.proto"; import "google/protobuf/timestamp.proto"; +import "temporal/api/compute/v1/status.proto"; import "temporal/api/enums/v1/namespace.proto"; @@ -83,6 +84,19 @@ message NamespaceInfo { int64 workflow_task_completion_size_limit_error = 3; } + // The compute providers available for server-scaled Worker Deployments in + // this Namespace: which ones this Namespace can use, whether each is + // currently enabled, and how far along its rollout each one is. + // + // Namespace-scoped rather than Service-scoped for two reasons. Availability + // genuinely varies per Namespace: a provider is tied to the cloud a + // Namespace runs in, so an AWS Namespace and a GCP Namespace do not offer + // the same set, and managed deployments gate providers per account. + // GetSystemInfo cannot express either, and is served as a fixed payload + // ahead of the Service in some deployments, so a per-provider boolean there + // is not reachable as a real signal. + repeated temporal.api.compute.v1.ComputeProviderStatus compute_providers = 9; + // Whether scheduled workflows are supported on this namespace. This is only needed // temporarily while the feature is experimental, so we can give it a high tag. bool supports_schedules = 100; diff --git a/temporal/api/workflowservice/v1/request_response.proto b/temporal/api/workflowservice/v1/request_response.proto index de1c271cd..0a90dfbf2 100644 --- a/temporal/api/workflowservice/v1/request_response.proto +++ b/temporal/api/workflowservice/v1/request_response.proto @@ -1392,6 +1392,13 @@ message GetSystemInfoResponse { // True if the server supports the Cloud Run compute provider for // server-scaled deployments. Dependent on server version and the // provider being enabled via server configuration. + // + // Superseded by NamespaceInfo.compute_providers, which reports every + // provider and its release stage per Namespace rather than one boolean + // per provider for the whole Service. Retained for wire compatibility + // with clients that already read it. No further per-provider booleans + // should be added here: this response is served as a fixed payload in + // some deployments, so it cannot express per-Namespace availability. bool server_scaled_provider_cloud_run = 13; }