@temporalio/core-bridge 1.14.1 → 1.15.0

package/sdk-core/crates/common/protos/api_upstream/temporal/api/activity/v1/message.proto

@@ -9,10 +9,26 @@ option java_outer_classname = "MessageProto";
 option ruby_package = "Temporalio::Api::Activity::V1";
 option csharp_namespace = "Temporalio.Api.Activity.V1";
 
+import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
+
 import "temporal/api/common/v1/message.proto";
+import "temporal/api/deployment/v1/message.proto";
+import "temporal/api/enums/v1/activity.proto";
+import "temporal/api/enums/v1/workflow.proto";
+import "temporal/api/failure/v1/message.proto";
 import "temporal/api/taskqueue/v1/message.proto";
+import "temporal/api/sdk/v1/user_metadata.proto";
 
-import "google/protobuf/duration.proto";
+// The outcome of a completed activity execution: either a successful result or a failure.
+message ActivityExecutionOutcome {
+    oneof value {
+        // The result if the activity completed successfully.
+        temporal.api.common.v1.Payloads result = 1;
+        // The failure if the activity completed unsuccessfully.
+        temporal.api.failure.v1.Failure failure = 2;
+    }
+}
 
 message ActivityOptions {
     temporal.api.taskqueue.v1.TaskQueue task_queue = 1;
@@ -40,6 +56,142 @@ message ActivityOptions {
     google.protobuf.Duration start_to_close_timeout = 4;
     // Maximum permitted time between successful worker heartbeats.
     google.protobuf.Duration heartbeat_timeout = 5;
-
+    // The retry policy for the activity. Will never exceed `schedule_to_close_timeout`.
     temporal.api.common.v1.RetryPolicy retry_policy = 6;
-}
+
+    // Priority metadata. If this message is not present, or any fields are not
+    // present, they inherit the values from the workflow.
+    temporal.api.common.v1.Priority priority = 7;
+}
+
+// Information about a standalone activity.
+message ActivityExecutionInfo {
+    // Unique identifier of this activity within its namespace along with run ID (below).
+    string activity_id = 1;
+    string run_id = 2;
+
+    // The type of the activity, a string that maps to a registered activity on a worker.
+    temporal.api.common.v1.ActivityType activity_type = 3;
+    // A general status for this activity, indicates whether it is currently running or in one of the terminal statuses.
+    temporal.api.enums.v1.ActivityExecutionStatus status = 4;
+    // More detailed breakdown of ACTIVITY_EXECUTION_STATUS_RUNNING.
+    temporal.api.enums.v1.PendingActivityState run_state = 5;
+
+    string task_queue = 6;
+
+    // Indicates how long the caller is willing to wait for an activity completion. Limits how long
+    // retries will be attempted.
+    //
+    // (-- api-linter: core::0140::prepositions=disabled
+    //     aip.dev/not-precedent: "to" is used to indicate interval. --)
+    google.protobuf.Duration schedule_to_close_timeout = 7;
+    // Limits time an activity task can stay in a task queue before a worker picks it up. This
+    // timeout is always non retryable, as all a retry would achieve is to put it back into the same
+    // queue. Defaults to `schedule_to_close_timeout`.
+    //
+    // (-- api-linter: core::0140::prepositions=disabled
+    //     aip.dev/not-precedent: "to" is used to indicate interval. --)
+    google.protobuf.Duration schedule_to_start_timeout = 8;
+    // Maximum time a single activity attempt is allowed to execute after being picked up by a worker. This
+    // timeout is always retryable.
+    //
+    // (-- api-linter: core::0140::prepositions=disabled
+    //     aip.dev/not-precedent: "to" is used to indicate interval. --)
+    google.protobuf.Duration start_to_close_timeout = 9;
+
+    // Maximum permitted time between successful worker heartbeats.
+    google.protobuf.Duration heartbeat_timeout = 10;
+
+    // The retry policy for the activity. Will never exceed `schedule_to_close_timeout`.
+    temporal.api.common.v1.RetryPolicy retry_policy = 11;
+
+    // Details provided in the last recorded activity heartbeat.
+    temporal.api.common.v1.Payloads heartbeat_details = 12;
+    // Time the last heartbeat was recorded.
+    google.protobuf.Timestamp last_heartbeat_time = 13;
+    // Time the last attempt was started.
+    google.protobuf.Timestamp last_started_time = 14;
+    // The attempt this activity is currently on. Incremented each time a new attempt is scheduled.
+    int32 attempt = 15;
+    // How long this activity has been running for, including all attempts and backoff between attempts.
+    google.protobuf.Duration execution_duration = 16;
+    // Time the activity was originally scheduled via a StartActivityExecution request.
+    google.protobuf.Timestamp schedule_time = 17;
+    // Scheduled time + schedule to close timeout.
+    google.protobuf.Timestamp expiration_time = 18;
+    // Time when the activity transitioned to a closed state.
+    google.protobuf.Timestamp close_time = 19;
+
+    // Failure details from the last failed attempt.
+    temporal.api.failure.v1.Failure last_failure = 20;
+    string last_worker_identity = 21;
+
+    // Time from the last attempt failure to the next activity retry.
+    // If the activity is currently running, this represents the next retry interval in case the attempt fails.
+    // If activity is currently backing off between attempt, this represents the current retry interval.
+    // If there is no next retry allowed, this field will be null.
+    // This interval is typically calculated from the specified retry policy, but may be modified if an activity fails
+    // with a retryable application failure specifying a retry delay.
+    google.protobuf.Duration current_retry_interval = 22;
+
+    // The time when the last activity attempt completed. If activity has not been completed yet, it will be null.
+    google.protobuf.Timestamp last_attempt_complete_time = 23;
+
+    // The time when the next activity attempt will be scheduled.
+    // If activity is currently scheduled or started, this field will be null.
+    google.protobuf.Timestamp next_attempt_schedule_time = 24;
+
+    // The Worker Deployment Version this activity was dispatched to most recently.
+    // If nil, the activity has not yet been dispatched or was last dispatched to an unversioned worker.
+    temporal.api.deployment.v1.WorkerDeploymentVersion last_deployment_version = 25;
+
+    // Priority metadata.
+    temporal.api.common.v1.Priority priority = 26;
+
+    // Incremented each time the activity's state is mutated in persistence.
+    int64 state_transition_count = 27;
+
+    // Updated once on scheduled and once on terminal status.
+    int64 state_size_bytes = 28;
+
+    temporal.api.common.v1.SearchAttributes search_attributes = 29;
+    temporal.api.common.v1.Header header = 30;
+    // Metadata for use by user interfaces to display the fixed as-of-start summary and details of the activity.
+    temporal.api.sdk.v1.UserMetadata user_metadata = 31;
+
+    // Set if activity cancelation was requested.
+    string canceled_reason = 32;
+}
+
+// Limited activity information returned in the list response.
+// When adding fields here, ensure that it is also present in ActivityExecutionInfo (note that it
+// may already be present in ActivityExecutionInfo but not at the top-level).
+message ActivityExecutionListInfo {
+    // A unique identifier of this activity within its namespace along with run ID (below).
+    string activity_id = 1;
+    // The run ID of the standalone activity.
+    string run_id = 2;
+
+    // The type of the activity, a string that maps to a registered activity on a worker.
+    temporal.api.common.v1.ActivityType activity_type = 3;
+    // Time the activity was originally scheduled via a StartActivityExecution request.
+    google.protobuf.Timestamp schedule_time = 4;
+    // If the activity is in a terminal status, this field represents the time the activity transitioned to that status.
+    google.protobuf.Timestamp close_time = 5;
+    // Only scheduled and terminal statuses appear here. More detailed information in PendingActivityInfo but not
+    // available in the list response.
+    temporal.api.enums.v1.ActivityExecutionStatus status = 6;
+
+    // Search attributes from the start request.
+    temporal.api.common.v1.SearchAttributes search_attributes = 7;
+
+    // The task queue this activity was scheduled on when it was originally started, updated on activity options update.
+    string task_queue = 8;
+    // Updated on terminal status.
+    int64 state_transition_count = 9;
+    // Updated once on scheduled and once on terminal status.
+    int64 state_size_bytes = 10;
+    // The difference between close time and scheduled time.
+    // This field is only populated if the activity is closed.
+    google.protobuf.Duration execution_duration = 11;
+}

package/sdk-core/crates/common/protos/api_upstream/temporal/api/command/v1/message.proto

@@ -179,6 +179,11 @@ message ContinueAsNewWorkflowExecutionCommandAttributes {
     // Deprecated. Only considered for versioning v0.2.
     bool inherit_build_id = 15 [deprecated = true];
 
+    // Experimental. Optionally decide the versioning behavior that the first task of the new run should use.
+    // For example, choose to AutoUpgrade on continue-as-new instead of inheriting the pinned version
+    // of the previous run.
+    temporal.api.enums.v1.ContinueAsNewVersioningBehavior initial_versioning_behavior = 16;
+
     // `workflow_execution_timeout` is omitted as it shouldn't be overridden from within a workflow.
 }
 
@@ -244,6 +249,27 @@ message ScheduleNexusOperationCommandAttributes {
     // Note these headers are not the same as Temporal headers on internal activities and child workflows, these are
     // transmitted to Nexus operations that may be external and are not traditional payloads.
     map<string, string> nexus_header = 6;
+
+    // Schedule-to-start timeout for this operation.
+    // Indicates how long the caller is willing to wait for the operation to be started (or completed if synchronous)
+    // by the handler. If the operation is not started within this timeout, it will fail with
+    // TIMEOUT_TYPE_SCHEDULE_TO_START.
+    // If not set or zero, no schedule-to-start timeout is enforced.
+    // (-- api-linter: core::0140::prepositions=disabled
+    //     aip.dev/not-precedent: "to" is used to indicate interval. --)
+    // Requires server version 1.31.0 or later.
+    google.protobuf.Duration schedule_to_start_timeout = 7;
+
+    // Start-to-close timeout for this operation.
+    // Indicates how long the caller is willing to wait for an asynchronous operation to complete after it has been
+    // started. If the operation does not complete within this timeout after starting, it will fail with
+    // TIMEOUT_TYPE_START_TO_CLOSE.
+    // Only applies to asynchronous operations. Synchronous operations ignore this timeout.
+    // If not set or zero, no start-to-close timeout is enforced.
+    // (-- api-linter: core::0140::prepositions=disabled
+    //     aip.dev/not-precedent: "to" is used to indicate interval. --)
+    // Requires server version 1.31.0 or later.
+    google.protobuf.Duration start_to_close_timeout = 8;
 }
 
 message RequestCancelNexusOperationCommandAttributes {

package/sdk-core/crates/common/protos/api_upstream/temporal/api/common/v1/message.proto

@@ -32,6 +32,14 @@ message Payloads {
 message Payload {
     map<string,bytes> metadata = 1;
     bytes data = 2;
+    // Details about externally stored payloads associated with this payload.
+    repeated ExternalPayloadDetails external_payloads = 3;
+
+    // Describes an externally stored object referenced by this payload.
+    message ExternalPayloadDetails {
+        // Size in bytes of the externally stored payload
+        int64 size_bytes = 1;
+    }
 }
 
 // A user-defined set of *indexed* fields that are used/exposed when listing/searching workflows.
@@ -338,4 +346,3 @@ message WorkerSelector {
         string worker_instance_key = 1;
     }
 }
-

package/sdk-core/crates/common/protos/api_upstream/temporal/api/deployment/v1/message.proto

@@ -120,7 +120,13 @@ message WorkerDeploymentVersionInfo {
 
     // Timestamp when this version first became current or ramping.
     google.protobuf.Timestamp first_activation_time = 12;
+
+    // Timestamp when this version last became current.
+    // Can be used to determine whether a version has ever been Current.
+    google.protobuf.Timestamp last_current_time = 15;
+
     // Timestamp when this version last stopped being current or ramping.
+    // Cleared if the version becomes current or ramping again.
     google.protobuf.Timestamp last_deactivation_time = 13;
 
     // Range: [0, 100]. Must be zero if the version is not ramping (i.e. `ramping_since_time` is nil).
@@ -201,6 +207,10 @@ message WorkerDeploymentInfo {
     // to this Worker Deployment. They can either set their own identity as the manager or unset the field to proceed.
     string manager_identity = 6;
 
+    // Indicates whether the routing_config has been fully propagated to all
+    // relevant task queues and their partitions.
+    temporal.api.enums.v1.RoutingConfigUpdateState routing_config_update_state = 7;
+
     message WorkerDeploymentVersionSummary {
         // Deprecated. Use `deployment_version`.
         string version = 1 [deprecated = true];
@@ -228,7 +238,11 @@ message WorkerDeploymentInfo {
         google.protobuf.Timestamp routing_update_time = 8;
         // Timestamp when this version first became current or ramping.
         google.protobuf.Timestamp first_activation_time = 9;
+        // Timestamp when this version last became current.
+        // Can be used to determine whether a version has ever been Current.
+        google.protobuf.Timestamp last_current_time = 12;
         // Timestamp when this version last stopped being current or ramping.
+        // Cleared if the version becomes current or ramping again.
         google.protobuf.Timestamp last_deactivation_time = 10;
     }
 }
@@ -285,4 +299,16 @@ message RoutingConfig {
     // Last time ramping version percentage was changed.
     // If ramping version is changed, this is also updated, even if the percentage stays the same.
     google.protobuf.Timestamp ramping_version_percentage_changed_time = 6;
+    // Monotonically increasing value which is incremented on every mutation 
+    // to any field of this message to achieve eventual consistency between task queues and their partitions.
+    int64 revision_number = 10;
+}
+
+// Used as part of WorkflowExecutionStartedEventAttributes to pass down the AutoUpgrade behavior and source deployment version 
+// to a workflow execution whose parent/previous workflow has an AutoUpgrade behavior.
+message InheritedAutoUpgradeInfo {
+    // The source deployment version of the parent/previous workflow.
+    temporal.api.deployment.v1.WorkerDeploymentVersion source_deployment_version = 1;
+    // The revision number of the source deployment version of the parent/previous workflow.
+    int64 source_deployment_revision_number = 2;
 }

package/sdk-core/crates/common/protos/api_upstream/temporal/api/enums/v1/activity.proto

@@ -0,0 +1,81 @@
+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 = "ActivityProto";
+option ruby_package = "Temporalio::Api::Enums::V1";
+option csharp_namespace = "Temporalio.Api.Enums.V1";
+
+// Status of a standalone activity.
+// The status is updated once, when the activity is originally scheduled, and again when the activity reaches a terminal
+// status.
+// (-- api-linter: core::0216::synonyms=disabled
+//     aip.dev/not-precedent: Named consistently with WorkflowExecutionStatus. --)
+enum ActivityExecutionStatus {
+    ACTIVITY_EXECUTION_STATUS_UNSPECIFIED = 0;
+
+    // The activity has not reached a terminal status. See PendingActivityState for the run state
+    // (SCHEDULED, STARTED, or CANCEL_REQUESTED).
+    ACTIVITY_EXECUTION_STATUS_RUNNING = 1;
+
+    // The activity completed successfully. An activity can complete even after cancellation is
+    // requested if the worker calls RespondActivityTaskCompleted before acknowledging cancellation.
+    ACTIVITY_EXECUTION_STATUS_COMPLETED = 2;
+
+    // The activity failed. Causes:
+    // - Worker returned a non-retryable failure
+    // - RetryPolicy.maximum_attempts exhausted
+    // - Attempt failed after cancellation was requested (retries blocked)
+    ACTIVITY_EXECUTION_STATUS_FAILED = 3;
+
+    // The activity was canceled. Reached when:
+    // - Cancellation requested while SCHEDULED (immediate), or
+    // - Cancellation requested while STARTED and worker called RespondActivityTaskCanceled.
+    //
+    // Workers discover cancellation requests via heartbeat responses (cancel_requested=true).
+    // Activities that do not heartbeat will not learn of cancellation and may complete, fail, or
+    // time out normally. CANCELED requires explicit worker acknowledgment or immediate cancellation
+    // of a SCHEDULED activity.
+    ACTIVITY_EXECUTION_STATUS_CANCELED = 4;
+
+    // The activity was terminated. Immediate; does not wait for worker acknowledgment.
+    ACTIVITY_EXECUTION_STATUS_TERMINATED = 5;
+
+    // The activity timed out. See TimeoutType for the specific timeout.
+    // - SCHEDULE_TO_START and SCHEDULE_TO_CLOSE timeouts always result in TIMED_OUT.
+    // - START_TO_CLOSE and HEARTBEAT may retry if RetryPolicy permits; TIMED_OUT is
+    //   reached when retry is blocked (RetryPolicy.maximum_attempts exhausted,
+    //   SCHEDULE_TO_CLOSE would be exceeded, or cancellation has been requested).
+    ACTIVITY_EXECUTION_STATUS_TIMED_OUT = 6;
+}
+
+// Defines whether to allow re-using an activity ID from a previously *closed* activity.
+// If the request is denied, the server returns an `ActivityExecutionAlreadyStarted` error.
+//
+// See `ActivityIdConflictPolicy` for handling ID duplication with a *running* activity.
+enum ActivityIdReusePolicy {
+    ACTIVITY_ID_REUSE_POLICY_UNSPECIFIED = 0;
+    // Always allow starting an activity using the same activity ID.
+    ACTIVITY_ID_REUSE_POLICY_ALLOW_DUPLICATE = 1;
+    // Allow starting an activity using the same ID only when the last activity's final state is one
+    // of {failed, canceled, terminated, timed out}.
+    ACTIVITY_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY = 2;
+    // Do not permit re-use of the ID for this activity. Future start requests could potentially change the policy,
+    // allowing re-use of the ID.
+    ACTIVITY_ID_REUSE_POLICY_REJECT_DUPLICATE = 3;
+}
+
+// Defines what to do when trying to start an activity with the same ID as a *running* activity.
+// Note that it is *never* valid to have two running instances of the same activity ID.
+//
+// See `ActivityIdReusePolicy` for handling activity ID duplication with a *closed* activity.
+enum ActivityIdConflictPolicy {
+    ACTIVITY_ID_CONFLICT_POLICY_UNSPECIFIED = 0;
+    // Don't start a new activity; instead return `ActivityExecutionAlreadyStarted` error.
+    ACTIVITY_ID_CONFLICT_POLICY_FAIL = 1;
+    // Don't start a new activity; instead return a handle for the running activity.
+    ACTIVITY_ID_CONFLICT_POLICY_USE_EXISTING = 2;
+}

package/sdk-core/crates/common/protos/api_upstream/temporal/api/enums/v1/event_type.proto

@@ -169,4 +169,8 @@ enum EventType {
     EVENT_TYPE_NEXUS_OPERATION_CANCEL_REQUEST_COMPLETED = 56;
     // A cancellation request for a Nexus operation resulted in an error.
     EVENT_TYPE_NEXUS_OPERATION_CANCEL_REQUEST_FAILED = 57;
+    // An event that indicates that the workflow execution has been paused.
+    EVENT_TYPE_WORKFLOW_EXECUTION_PAUSED = 58;
+    // An event that indicates that the previously paused workflow execution has been unpaused.
+    EVENT_TYPE_WORKFLOW_EXECUTION_UNPAUSED = 59;
 }

package/sdk-core/crates/common/protos/api_upstream/temporal/api/enums/v1/failed_cause.proto

@@ -81,6 +81,8 @@ enum WorkflowTaskFailedCause {
     WORKFLOW_TASK_FAILED_CAUSE_FEATURE_DISABLED = 35;
     // A workflow task failed because a grpc message was too large.
     WORKFLOW_TASK_FAILED_CAUSE_GRPC_MESSAGE_TOO_LARGE = 36;
+    // A workflow task failed because payloads were too large.
+    WORKFLOW_TASK_FAILED_CAUSE_PAYLOADS_TOO_LARGE = 37;
 }
 
 enum StartChildWorkflowExecutionFailedCause {
@@ -123,6 +125,8 @@ enum ResourceExhaustedCause {
     RESOURCE_EXHAUSTED_CAUSE_CIRCUIT_BREAKER_OPEN = 8;
     // Namespace exceeds operations rate limit.
     RESOURCE_EXHAUSTED_CAUSE_OPS_LIMIT = 9;
+    // Limits related to Worker Deployments are reached.
+    RESOURCE_EXHAUSTED_CAUSE_WORKER_DEPLOYMENT_LIMITS = 10;
 }
 
 enum ResourceExhaustedScope {

package/sdk-core/crates/common/protos/api_upstream/temporal/api/enums/v1/task_queue.proto

@@ -10,6 +10,11 @@ option ruby_package = "Temporalio::Api::Enums::V1";
 option csharp_namespace = "Temporalio.Api.Enums.V1";
 
 enum TaskQueueKind {
+    // Tasks from any non workflow task may be unspecified.
+    //
+    // Task queue kind is used to differentiate whether a workflow task queue is sticky or 
+    // normal. If a task is not a workflow task, Task queue kind will sometimes be 
+    // unspecified.
     TASK_QUEUE_KIND_UNSPECIFIED = 0;
     // Tasks from a normal workflow task queue always include complete workflow history
     //
@@ -100,3 +105,13 @@ enum RateLimitSource {
     // The value was set as the system default.
     RATE_LIMIT_SOURCE_SYSTEM = 3;
 }
+
+// Indicates whether a change to the Routing Config has been
+// propagated to all relevant Task Queues and their partitions.
+enum RoutingConfigUpdateState {
+    ROUTING_CONFIG_UPDATE_STATE_UNSPECIFIED = 0;
+    // Update to the RoutingConfig is currently in progress.
+    ROUTING_CONFIG_UPDATE_STATE_IN_PROGRESS = 1;
+    // Update to the RoutingConfig has completed successfully.
+    ROUTING_CONFIG_UPDATE_STATE_COMPLETED = 2;
+}

package/sdk-core/crates/common/protos/api_upstream/temporal/api/enums/v1/workflow.proto

@@ -23,11 +23,13 @@ enum WorkflowIdReusePolicy {
     // Do not permit re-use of the workflow id for this workflow. Future start workflow requests
     // could potentially change the policy, allowing re-use of the workflow id.
     WORKFLOW_ID_REUSE_POLICY_REJECT_DUPLICATE = 3;
-    // This option belongs in WorkflowIdConflictPolicy but is here for backwards compatibility.
-    // If specified, it acts like ALLOW_DUPLICATE, but also the WorkflowId*Conflict*Policy on
-    // the request is treated as WORKFLOW_ID_CONFLICT_POLICY_TERMINATE_EXISTING.
-    // If no running workflow, then the behavior is the same as ALLOW_DUPLICATE.
-    WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING = 4;
+    // Terminate the current Workflow if one is already running; otherwise allow reusing the
+    // Workflow ID. When using this option, `WorkflowIdConflictPolicy` must be left unspecified.
+    //
+    // Deprecated. Instead, set `WorkflowIdReusePolicy` to `ALLOW_DUPLICATE` and
+    // `WorkflowIdConflictPolicy` to `TERMINATE_EXISTING`. Note that `WorkflowIdConflictPolicy`
+    // requires Temporal Server v1.24.0 or later.
+    WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING = 4 [deprecated = true];
 }
 
 // Defines what to do when trying to start a workflow with the same workflow id as a *running* workflow.
@@ -77,6 +79,7 @@ enum WorkflowExecutionStatus {
     WORKFLOW_EXECUTION_STATUS_TERMINATED = 5;
     WORKFLOW_EXECUTION_STATUS_CONTINUED_AS_NEW = 6;
     WORKFLOW_EXECUTION_STATUS_TIMED_OUT = 7;
+    WORKFLOW_EXECUTION_STATUS_PAUSED = 8;
 }
 
 enum PendingActivityState {
@@ -133,9 +136,15 @@ enum VersioningBehavior {
     // User needs to use Patching to keep the new code compatible with prior versions when dealing
     // with Unversioned workflows.
     VERSIONING_BEHAVIOR_UNSPECIFIED = 0;
-    // Workflow will start on the Current Deployment Version of its Task Queue, and then
-    // will be pinned to that same Deployment Version until completion (the Version that
-    // this Workflow is pinned to is specified in `versioning_info.version`).
+    // Workflow will start on its Target Version and then will be pinned to that same Deployment
+    // Version until completion (the Version that this Workflow is pinned to is specified in
+    // `versioning_info.version` and is the Pinned Version of the Workflow).
+    //
+    // The workflow's Target Version is the Current Version of its Task Queue, or, if the
+    // Task Queue has a Ramping Version with non-zero Ramp Percentage `P`, the workflow's Target
+    // Version has a P% chance of being the Ramping Version. Whether a workflow falls into the
+    // Ramping group depends on its Workflow ID and and the Ramp Percentage.
+    //
     // This behavior eliminates most of compatibility concerns users face when changing their code.
     // Patching is not needed when pinned workflows code change.
     // Can be overridden explicitly via `UpdateWorkflowExecutionOptions` API to move the
@@ -145,8 +154,13 @@ enum VersioningBehavior {
     // Version, in which case the activity will be sent to the Current Deployment Version of its own
     // task queue.
     VERSIONING_BEHAVIOR_PINNED = 1;
-    // Workflow will automatically move to the Current Deployment Version of its Task Queue when the
-    // next workflow task is dispatched.
+    // Workflow will automatically move to its Target Version when the next workflow task is dispatched.
+    //
+    // The workflow's Target Version is the Current Version of its Task Queue, or, if the
+    // Task Queue has a Ramping Version with non-zero Ramp Percentage `P`, the workflow's Target
+    // Version has a P% chance of being the Ramping Version. Whether a workflow falls into the
+    // Ramping group depends on its Workflow ID and and the Ramp Percentage.
+    //
     // AutoUpgrade behavior is suitable for long-running workflows as it allows them to move to the
     // latest Deployment Version, but the user still needs to use Patching to keep the new code
     // compatible with prior versions for changed workflow types.
@@ -154,10 +168,43 @@ enum VersioningBehavior {
     // execution (as specified in versioning_info.version based on the last completed
     // workflow task). Exception to this would be when the activity Task Queue workers are not
     // present in the workflow's Deployment Version, in which case, the activity will be sent to a
-    // different Deployment Version according to the Current Deployment Version of its own task
-    // queue.
-    // Workflows stuck on a backlogged activity will still auto-upgrade if the Current Deployment
-    // Version of their Task Queue changes, without having to wait for the backlogged activity to
-    // complete on the old Version.
+    // different Deployment Version according to the Current or Ramping Deployment Version of its own
+    // Task Queue.
+    // Workflows stuck on a backlogged activity will still auto-upgrade if their Target Version
+    // changes, without having to wait for the backlogged activity to complete on the old Version.
     VERSIONING_BEHAVIOR_AUTO_UPGRADE = 2;
 }
+
+// Experimental. Defines the versioning behavior to be used by the first task of a new workflow run in a continue-as-new chain.
+enum ContinueAsNewVersioningBehavior {
+    CONTINUE_AS_NEW_VERSIONING_BEHAVIOR_UNSPECIFIED = 0;
+
+    // Start the new run with AutoUpgrade behavior. Use the Target Version of the workflow's task queue at
+    // start-time, as AutoUpgrade workflows do. After the first workflow task completes, use whatever
+    // Versioning Behavior the workflow is annotated with in the workflow code.
+    //
+    // Note that if the previous workflow had a Pinned override, that override will be inherited by the
+    // new workflow run regardless of the ContinueAsNewVersioningBehavior specified in the continue-as-new
+    // command. If a Pinned override is inherited by the new run, and the new run starts with AutoUpgrade
+    // behavior, the base version of the new run will be the Target Version as described above, but the
+    // effective version will be whatever is specified by the Versioning Override until the override is removed.
+    CONTINUE_AS_NEW_VERSIONING_BEHAVIOR_AUTO_UPGRADE = 1;
+}
+
+// SuggestContinueAsNewReason specifies why SuggestContinueAsNew is true.
+enum SuggestContinueAsNewReason {
+    SUGGEST_CONTINUE_AS_NEW_REASON_UNSPECIFIED = 0;
+
+    // Workflow History size is getting too large.
+    SUGGEST_CONTINUE_AS_NEW_REASON_HISTORY_SIZE_TOO_LARGE = 1;
+
+    // Workflow History event count is getting too large.
+    SUGGEST_CONTINUE_AS_NEW_REASON_TOO_MANY_HISTORY_EVENTS = 2;
+
+    // Workflow's count of completed plus in-flight updates is too large.
+    SUGGEST_CONTINUE_AS_NEW_REASON_TOO_MANY_UPDATES = 3;
+
+    // Workflow's Target Worker Deployment Version is different from its
+    // Current Version and the workflow is versioned.
+    SUGGEST_CONTINUE_AS_NEW_REASON_TARGET_WORKER_DEPLOYMENT_VERSION_CHANGED = 4;
+}

package/sdk-core/crates/common/protos/api_upstream/temporal/api/errordetails/v1/message.proto

@@ -121,3 +121,11 @@ message MultiOperationExecutionFailure {
         repeated google.protobuf.Any details = 3;
     }
 }
+
+// An error indicating that an activity execution failed to start. Returned when there is an existing activity with the
+// given activity ID, and the given ID reuse and conflict policies do not permit starting a new one or attaching to an
+// existing one.
+message ActivityExecutionAlreadyStartedFailure {
+    string start_request_id = 1;
+    string run_id = 2;
+}