temporalio 0.0.1

data/bridge/sdk-core/protos/api_upstream/temporal/api/workflowservice/v1/service.proto

@@ -0,0 +1,401 @@
+// The MIT License
+//
+// Copyright (c) 2020 Temporal Technologies Inc.  All rights reserved.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+syntax = "proto3";
+
+package temporal.api.workflowservice.v1;
+
+option go_package = "go.temporal.io/api/workflowservice/v1;workflowservice";
+option java_package = "io.temporal.api.workflowservice.v1";
+option java_multiple_files = true;
+option java_outer_classname = "ServiceProto";
+option ruby_package = "Temporal::Api::WorkflowService::V1";
+option csharp_namespace = "Temporal.Api.WorkflowService.V1";
+
+
+import "temporal/api/workflowservice/v1/request_response.proto";
+
+// WorkflowService API defines how Temporal SDKs and other clients interact with the Temporal server
+// to create and interact with workflows and activities.
+//
+// Users are expected to call `StartWorkflowExecution` to create a new workflow execution.
+//
+// To drive workflows, a worker using a Temporal SDK must exist which regularly polls for workflow
+// and activity tasks from the service. For each workflow task, the sdk must process the
+// (incremental or complete) event history and respond back with any newly generated commands.
+//
+// For each activity task, the worker is expected to execute the user's code which implements that
+// activity, responding with completion or failure.
+service WorkflowService {
+
+    // RegisterNamespace creates a new namespace which can be used as a container for all resources.
+    //
+    // A Namespace is a top level entity within Temporal, and is used as a container for resources
+    // like workflow executions, task queues, etc. A Namespace acts as a sandbox and provides
+    // isolation for all resources within the namespace. All resources belongs to exactly one
+    // namespace.
+    rpc RegisterNamespace (RegisterNamespaceRequest) returns (RegisterNamespaceResponse) {
+    }
+
+    // DescribeNamespace returns the information and configuration for a registered namespace.
+    rpc DescribeNamespace (DescribeNamespaceRequest) returns (DescribeNamespaceResponse) {
+    }
+
+    // ListNamespaces returns the information and configuration for all namespaces.
+    rpc ListNamespaces (ListNamespacesRequest) returns (ListNamespacesResponse) {
+    }
+
+    // UpdateNamespace is used to update the information and configuration of a registered
+    // namespace.
+    //
+    // (-- api-linter: core::0134::method-signature=disabled
+    //     aip.dev/not-precedent: UpdateNamespace RPC doesn't follow Google API format. --)
+    // (-- api-linter: core::0134::response-message-name=disabled
+    //     aip.dev/not-precedent: UpdateNamespace RPC doesn't follow Google API format. --)
+    rpc UpdateNamespace (UpdateNamespaceRequest) returns (UpdateNamespaceResponse) {
+    }
+
+    // DeprecateNamespace is used to update the state of a registered namespace to DEPRECATED.
+    //
+    // Once the namespace is deprecated it cannot be used to start new workflow executions. Existing
+    // workflow executions will continue to run on deprecated namespaces.
+    // Deprecated.
+    rpc DeprecateNamespace (DeprecateNamespaceRequest) returns (DeprecateNamespaceResponse) {
+    }
+
+    // StartWorkflowExecution starts a new workflow execution.
+    //
+    // It will create the execution with a `WORKFLOW_EXECUTION_STARTED` event in its history and
+    // also schedule the first workflow task. Returns `WorkflowExecutionAlreadyStarted`, if an
+    // instance already exists with same workflow id.
+    rpc StartWorkflowExecution (StartWorkflowExecutionRequest) returns (StartWorkflowExecutionResponse) {
+    }
+
+    // GetWorkflowExecutionHistory returns the history of specified workflow execution. Fails with
+    // `NotFound` if the specified workflow execution is unknown to the service.
+    rpc GetWorkflowExecutionHistory (GetWorkflowExecutionHistoryRequest) returns (GetWorkflowExecutionHistoryResponse) {
+    }
+    
+    // GetWorkflowExecutionHistoryReverse returns the history of specified workflow execution in reverse 
+    // order (starting from last event). Fails with`NotFound` if the specified workflow execution is 
+    // unknown to the service.
+    rpc GetWorkflowExecutionHistoryReverse (GetWorkflowExecutionHistoryReverseRequest) returns (GetWorkflowExecutionHistoryReverseResponse) {
+    }
+
+    // PollWorkflowTaskQueue is called by workers to make progress on workflows.
+    //
+    // A WorkflowTask is dispatched to callers for active workflow executions with pending workflow
+    // tasks. The worker is expected to call `RespondWorkflowTaskCompleted` when it is done
+    // processing the task. The service will create a `WorkflowTaskStarted` event in the history for
+    // this task before handing it to the worker.
+    rpc PollWorkflowTaskQueue (PollWorkflowTaskQueueRequest) returns (PollWorkflowTaskQueueResponse) {
+    }
+
+    // RespondWorkflowTaskCompleted is called by workers to successfully complete workflow tasks
+    // they received from `PollWorkflowTaskQueue`.
+    //
+    // Completing a WorkflowTask will write a `WORKFLOW_TASK_COMPLETED` event to the workflow's
+    // history, along with events corresponding to whatever commands the SDK generated while
+    // executing the task (ex timer started, activity task scheduled, etc).
+    rpc RespondWorkflowTaskCompleted (RespondWorkflowTaskCompletedRequest) returns (RespondWorkflowTaskCompletedResponse) {
+    }
+
+    // RespondWorkflowTaskFailed is called by workers to indicate the processing of a workflow task
+    // failed.
+    //
+    // This results in a `WORKFLOW_TASK_FAILED` event written to the history, and a new workflow
+    // task will be scheduled. This API can be used to report unhandled failures resulting from
+    // applying the workflow task.
+    //
+    // Temporal will only append first WorkflowTaskFailed event to the history of workflow execution
+    // for consecutive failures.
+    rpc RespondWorkflowTaskFailed (RespondWorkflowTaskFailedRequest) returns (RespondWorkflowTaskFailedResponse) {
+    }
+
+    // PollActivityTaskQueue is called by workers to process activity tasks from a specific task
+    // queue.
+    //
+    // The worker is expected to call one of the `RespondActivityTaskXXX` methods when it is done
+    // processing the task.
+    //
+    // An activity task is dispatched whenever a `SCHEDULE_ACTIVITY_TASK` command is produced during
+    // workflow execution. An in memory `ACTIVITY_TASK_STARTED` event is written to mutable state
+    // before the task is dispatched to the worker. The started event, and the final event
+    // (`ACTIVITY_TASK_COMPLETED` / `ACTIVITY_TASK_FAILED` / `ACTIVITY_TASK_TIMED_OUT`) will both be
+    // written permanently to Workflow execution history when Activity is finished. This is done to
+    // avoid writing many events in the case of a failure/retry loop.
+    rpc PollActivityTaskQueue (PollActivityTaskQueueRequest) returns (PollActivityTaskQueueResponse) {
+    }
+
+    // RecordActivityTaskHeartbeat is optionally called by workers while they execute activities.
+    //
+    // If worker fails to heartbeat within the `heartbeat_timeout` interval for the activity task,
+    // then it will be marked as timed out and an `ACTIVITY_TASK_TIMED_OUT` event will be written to
+    // the workflow history. Calling `RecordActivityTaskHeartbeat` will fail with `NotFound` in
+    // such situations, in that event, the SDK should request cancellation of the activity.
+    rpc RecordActivityTaskHeartbeat (RecordActivityTaskHeartbeatRequest) returns (RecordActivityTaskHeartbeatResponse) {
+    }
+
+    // See `RecordActivityTaskHeartbeat`. This version allows clients to record heartbeats by
+    // namespace/workflow id/activity id instead of task token.
+    //
+    // (-- api-linter: core::0136::prepositions=disabled
+    //     aip.dev/not-precedent: "By" is used to indicate request type. --)
+    rpc RecordActivityTaskHeartbeatById (RecordActivityTaskHeartbeatByIdRequest) returns (RecordActivityTaskHeartbeatByIdResponse) {
+    }
+
+    // RespondActivityTaskCompleted is called by workers when they successfully complete an activity
+    // task.
+    //
+    // This results in a new `ACTIVITY_TASK_COMPLETED` event being written to the workflow history
+    // and a new workflow task created for the workflow. Fails with `NotFound` if the task token is
+    // no longer valid due to activity timeout, already being completed, or never having existed.
+    rpc RespondActivityTaskCompleted (RespondActivityTaskCompletedRequest) returns (RespondActivityTaskCompletedResponse) {
+    }
+
+    // See `RecordActivityTaskCompleted`. This version allows clients to record completions by
+    // namespace/workflow id/activity id instead of task token.
+    //
+    // (-- api-linter: core::0136::prepositions=disabled
+    //     aip.dev/not-precedent: "By" is used to indicate request type. --)
+    rpc RespondActivityTaskCompletedById (RespondActivityTaskCompletedByIdRequest) returns (RespondActivityTaskCompletedByIdResponse) {
+    }
+
+    // RespondActivityTaskFailed is called by workers when processing an activity task fails.
+    //
+    // This results in a new `ACTIVITY_TASK_FAILED` event being written to the workflow history and
+    // a new workflow task created for the workflow. Fails with `NotFound` if the task token is no
+    // longer valid due to activity timeout, already being completed, or never having existed.
+    rpc RespondActivityTaskFailed (RespondActivityTaskFailedRequest) returns (RespondActivityTaskFailedResponse) {
+    }
+
+    // See `RecordActivityTaskFailed`. This version allows clients to record failures by
+    // namespace/workflow id/activity id instead of task token.
+    //
+    // (-- api-linter: core::0136::prepositions=disabled
+    //     aip.dev/not-precedent: "By" is used to indicate request type. --)
+    rpc RespondActivityTaskFailedById (RespondActivityTaskFailedByIdRequest) returns (RespondActivityTaskFailedByIdResponse) {
+    }
+
+    // RespondActivityTaskFailed is called by workers when processing an activity task fails.
+    //
+    // This results in a new `ACTIVITY_TASK_CANCELED` event being written to the workflow history
+    // and a new workflow task created for the workflow. Fails with `NotFound` if the task token is
+    // no longer valid due to activity timeout, already being completed, or never having existed.
+    rpc RespondActivityTaskCanceled (RespondActivityTaskCanceledRequest) returns (RespondActivityTaskCanceledResponse) {
+    }
+
+    // See `RecordActivityTaskCanceled`. This version allows clients to record failures by
+    // namespace/workflow id/activity id instead of task token.
+    //
+    // (-- api-linter: core::0136::prepositions=disabled
+    //     aip.dev/not-precedent: "By" is used to indicate request type. --)
+    rpc RespondActivityTaskCanceledById (RespondActivityTaskCanceledByIdRequest) returns (RespondActivityTaskCanceledByIdResponse) {
+    }
+
+    // RequestCancelWorkflowExecution is called by workers when they want to request cancellation of
+    // a workflow execution.
+    //
+    // This results in a new `WORKFLOW_EXECUTION_CANCEL_REQUESTED` event being written to the
+    // workflow history and a new workflow task created for the workflow. It returns success if the requested
+    // workflow is already closed. It fails with 'NotFound' if the requested workflow doesn't exist.
+    rpc RequestCancelWorkflowExecution (RequestCancelWorkflowExecutionRequest) returns (RequestCancelWorkflowExecutionResponse) {
+    }
+
+    // SignalWorkflowExecution is used to send a signal to a running workflow execution.
+    //
+    // This results in a `WORKFLOW_EXECUTION_SIGNALED` event recorded in the history and a workflow
+    // task being created for the execution.
+    rpc SignalWorkflowExecution (SignalWorkflowExecutionRequest) returns (SignalWorkflowExecutionResponse) {
+    }
+
+    // SignalWithStartWorkflowExecution is used to ensure a signal is sent to a workflow, even if
+    // it isn't yet started.
+    //
+    // If the workflow is running, a `WORKFLOW_EXECUTION_SIGNALED` event is recorded in the history
+    // and a workflow task is generated.
+    //
+    // If the workflow is not running or not found, then the workflow is created with
+    // `WORKFLOW_EXECUTION_STARTED` and `WORKFLOW_EXECUTION_SIGNALED` events in its history, and a
+    // workflow task is generated.
+    //
+    // (-- api-linter: core::0136::prepositions=disabled
+    //     aip.dev/not-precedent: "With" is used to indicate combined operation. --)
+    rpc SignalWithStartWorkflowExecution (SignalWithStartWorkflowExecutionRequest) returns (SignalWithStartWorkflowExecutionResponse) {
+    }
+
+    // ResetWorkflowExecution will reset an existing workflow execution to a specified
+    // `WORKFLOW_TASK_COMPLETED` event (exclusive). It will immediately terminate the current
+    // execution instance.
+    // TODO: Does exclusive here mean *just* the completed event, or also WFT started? Otherwise the task is doomed to time out?
+    rpc ResetWorkflowExecution (ResetWorkflowExecutionRequest) returns (ResetWorkflowExecutionResponse) {
+    }
+
+    // TerminateWorkflowExecution terminates an existing workflow execution by recording a
+    // `WORKFLOW_EXECUTION_TERMINATED` event in the history and immediately terminating the
+    // execution instance.
+    rpc TerminateWorkflowExecution (TerminateWorkflowExecutionRequest) returns (TerminateWorkflowExecutionResponse) {
+    }
+
+    // ListOpenWorkflowExecutions is a visibility API to list the open executions in a specific namespace.
+    rpc ListOpenWorkflowExecutions (ListOpenWorkflowExecutionsRequest) returns (ListOpenWorkflowExecutionsResponse) {
+    }
+
+    // ListClosedWorkflowExecutions is a visibility API to list the closed executions in a specific namespace.
+    rpc ListClosedWorkflowExecutions (ListClosedWorkflowExecutionsRequest) returns (ListClosedWorkflowExecutionsResponse) {
+    }
+
+    // ListWorkflowExecutions is a visibility API to list workflow executions in a specific namespace.
+    rpc ListWorkflowExecutions (ListWorkflowExecutionsRequest) returns (ListWorkflowExecutionsResponse) {
+    }
+
+    // ListArchivedWorkflowExecutions is a visibility API to list archived workflow executions in a specific namespace.
+    rpc ListArchivedWorkflowExecutions (ListArchivedWorkflowExecutionsRequest) returns (ListArchivedWorkflowExecutionsResponse) {
+    }
+
+    // ScanWorkflowExecutions is a visibility API to list large amount of workflow executions in a specific namespace without order.
+    rpc ScanWorkflowExecutions (ScanWorkflowExecutionsRequest) returns (ScanWorkflowExecutionsResponse) {
+    }
+
+    // CountWorkflowExecutions is a visibility API to count of workflow executions in a specific namespace.
+    rpc CountWorkflowExecutions (CountWorkflowExecutionsRequest) returns (CountWorkflowExecutionsResponse) {
+    }
+
+    // GetSearchAttributes is a visibility API to get all legal keys that could be used in list APIs
+    rpc GetSearchAttributes (GetSearchAttributesRequest) returns (GetSearchAttributesResponse) {
+    }
+
+    // RespondQueryTaskCompleted is called by workers to complete queries which were delivered on
+    // the `query` (not `queries`) field of a `PollWorkflowTaskQueueResponse`.
+    //
+    // Completing the query will unblock the corresponding client call to `QueryWorkflow` and return
+    // the query result a response.
+    rpc RespondQueryTaskCompleted (RespondQueryTaskCompletedRequest) returns (RespondQueryTaskCompletedResponse) {
+    }
+
+    // ResetStickyTaskQueue resets the sticky task queue related information in the mutable state of
+    // a given workflow. This is prudent for workers to perform if a workflow has been paged out of
+    // their cache.
+    //
+    // Things cleared are:
+    // 1. StickyTaskQueue
+    // 2. StickyScheduleToStartTimeout
+    rpc ResetStickyTaskQueue (ResetStickyTaskQueueRequest) returns (ResetStickyTaskQueueResponse) {
+    }
+
+    // QueryWorkflow requests a query be executed for a specified workflow execution.
+    rpc QueryWorkflow (QueryWorkflowRequest) returns (QueryWorkflowResponse) {
+    }
+
+    // DescribeWorkflowExecution returns information about the specified workflow execution.
+    rpc DescribeWorkflowExecution (DescribeWorkflowExecutionRequest) returns (DescribeWorkflowExecutionResponse) {
+    }
+
+    // DescribeTaskQueue returns information about the target task queue.
+    rpc DescribeTaskQueue (DescribeTaskQueueRequest) returns (DescribeTaskQueueResponse) {
+    }
+
+    // GetClusterInfo returns information about temporal cluster
+    rpc GetClusterInfo(GetClusterInfoRequest) returns (GetClusterInfoResponse){
+    }
+
+    // GetSystemInfo returns information about the system.
+    rpc GetSystemInfo(GetSystemInfoRequest) returns (GetSystemInfoResponse) {
+    }
+
+    rpc ListTaskQueuePartitions(ListTaskQueuePartitionsRequest) returns (ListTaskQueuePartitionsResponse) {
+    }
+
+    // Creates a new schedule.
+    // (-- api-linter: core::0133::method-signature=disabled
+    //     aip.dev/not-precedent: CreateSchedule doesn't follow Google API format --)
+    // (-- api-linter: core::0133::response-message-name=disabled
+    //     aip.dev/not-precedent: CreateSchedule doesn't follow Google API format --)
+    // (-- api-linter: core::0133::http-uri-parent=disabled
+    //     aip.dev/not-precedent: CreateSchedule doesn't follow Google API format --)
+    rpc CreateSchedule (CreateScheduleRequest) returns (CreateScheduleResponse) {
+    }
+
+    // Returns the schedule description and current state of an existing schedule.
+    rpc DescribeSchedule (DescribeScheduleRequest) returns (DescribeScheduleResponse) {
+    }
+
+    // Changes the configuration or state of an existing schedule.
+    // (-- api-linter: core::0134::response-message-name=disabled
+    //     aip.dev/not-precedent: UpdateSchedule RPC doesn't follow Google API format. --)
+    // (-- api-linter: core::0134::method-signature=disabled
+    //     aip.dev/not-precedent: UpdateSchedule RPC doesn't follow Google API format. --)
+    rpc UpdateSchedule (UpdateScheduleRequest) returns (UpdateScheduleResponse) {
+    }
+
+    // Makes a specific change to a schedule or triggers an immediate action.
+    // (-- api-linter: core::0134::synonyms=disabled
+    //     aip.dev/not-precedent: we have both patch and update. --)
+    rpc PatchSchedule (PatchScheduleRequest) returns (PatchScheduleResponse) {
+    }
+
+    // Lists matching times within a range.
+    rpc ListScheduleMatchingTimes (ListScheduleMatchingTimesRequest) returns (ListScheduleMatchingTimesResponse) {
+    }
+
+    // Deletes a schedule, removing it from the system.
+    // (-- api-linter: core::0135::method-signature=disabled
+    //     aip.dev/not-precedent: DeleteSchedule doesn't follow Google API format --)
+    // (-- api-linter: core::0135::response-message-name=disabled
+    //     aip.dev/not-precedent: DeleteSchedule doesn't follow Google API format --)
+    rpc DeleteSchedule (DeleteScheduleRequest) returns (DeleteScheduleResponse) {
+    }
+
+    // List all schedules in a namespace.
+    rpc ListSchedules (ListSchedulesRequest) returns (ListSchedulesResponse) {
+    }
+
+    // (-- api-linter: core::0134::response-message-name=disabled
+    //     aip.dev/not-precedent: UpdateWorkerBuildIdOrdering RPC doesn't follow Google API format. --)
+    // (-- api-linter: core::0134::method-signature=disabled
+    //     aip.dev/not-precedent: UpdateWorkerBuildIdOrdering RPC doesn't follow Google API format. --)
+    rpc UpdateWorkerBuildIdOrdering (UpdateWorkerBuildIdOrderingRequest) returns (UpdateWorkerBuildIdOrderingResponse) {}
+    // This could / maybe should just be part of `DescribeTaskQueue`, but is broken out here to show easily.
+    rpc GetWorkerBuildIdOrdering (GetWorkerBuildIdOrderingRequest) returns (GetWorkerBuildIdOrderingResponse) {}
+
+    // Invokes the specified update function on user workflow code.
+    // (-- api-linter: core::0134=disabled
+    //     aip.dev/not-precedent: UpdateWorkflow doesn't follow Google API format --)
+    rpc UpdateWorkflow(UpdateWorkflowRequest) returns (UpdateWorkflowResponse) {
+    }
+
+    // StartBatchOperation starts a new batch operation
+    rpc StartBatchOperation(StartBatchOperationRequest) returns (StartBatchOperationResponse) {
+    }
+
+    // StopBatchOperation stops a batch operation
+    rpc StopBatchOperation(StopBatchOperationRequest) returns (StopBatchOperationResponse) {
+    }
+
+    // DescribeBatchOperation returns the information about a batch operation
+    rpc DescribeBatchOperation(DescribeBatchOperationRequest) returns (DescribeBatchOperationResponse) {
+    }
+
+    // ListBatchOperations returns a list of batch operations
+    rpc ListBatchOperations(ListBatchOperationsRequest) returns (ListBatchOperationsResponse) {
+    }
+}

data/bridge/sdk-core/protos/grpc/health/v1/health.proto

@@ -0,0 +1,63 @@
+// Copyright 2015 The gRPC Authors
+//
+// 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.
+
+// The canonical version of this proto can be found at
+// https://github.com/grpc/grpc-proto/blob/master/grpc/health/v1/health.proto
+
+syntax = "proto3";
+
+package grpc.health.v1;
+
+option csharp_namespace = "Grpc.Health.V1";
+option go_package = "google.golang.org/grpc/health/grpc_health_v1";
+option java_multiple_files = true;
+option java_outer_classname = "HealthProto";
+option java_package = "io.grpc.health.v1";
+
+message HealthCheckRequest {
+  string service = 1;
+}
+
+message HealthCheckResponse {
+  enum ServingStatus {
+    UNKNOWN = 0;
+    SERVING = 1;
+    NOT_SERVING = 2;
+    SERVICE_UNKNOWN = 3;  // Used only by the Watch method.
+  }
+  ServingStatus status = 1;
+}
+
+service Health {
+  // If the requested service is unknown, the call will fail with status
+  // NOT_FOUND.
+  rpc Check(HealthCheckRequest) returns (HealthCheckResponse);
+
+  // Performs a watch for the serving status of the requested service.
+  // The server will immediately send back a message indicating the current
+  // serving status.  It will then subsequently send a new message whenever
+  // the service's serving status changes.
+  //
+  // If the requested service is unknown when the call is received, the
+  // server will send a message setting the serving status to
+  // SERVICE_UNKNOWN but will *not* terminate the call.  If at some
+  // future point, the serving status of the service becomes known, the
+  // server will send a new message with the service's serving status.
+  //
+  // If the call terminates with status UNIMPLEMENTED, then clients
+  // should assume this method is not supported and should not retry the
+  // call.  If the call terminates with any other status (including OK),
+  // clients should retry the call with appropriate exponential backoff.
+  rpc Watch(HealthCheckRequest) returns (stream HealthCheckResponse);
+}

data/bridge/sdk-core/protos/local/temporal/sdk/core/activity_result/activity_result.proto

@@ -0,0 +1,78 @@
+syntax = "proto3";
+
+package coresdk.activity_result;
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
+import "temporal/api/common/v1/message.proto";
+import "temporal/api/failure/v1/message.proto";
+
+/**
+ * Used to report activity completions to core
+ */
+message ActivityExecutionResult {
+    oneof status {
+        Success completed = 1;
+        Failure failed = 2;
+        Cancellation cancelled = 3;
+        WillCompleteAsync will_complete_async = 4;
+    }
+}
+
+// Used to report activity resolutions to lang. IE: This is what the activities are resolved with
+// in the workflow.
+message ActivityResolution {
+    oneof status {
+        Success completed = 1;
+        Failure failed = 2;
+        Cancellation cancelled = 3;
+        DoBackoff backoff = 4;
+    }
+}
+
+/** Used to report successful completion either when executing or resolving */
+message Success {
+    temporal.api.common.v1.Payload result = 1;
+}
+
+/** Used to report activity failure either when executing or resolving */
+message Failure {
+    temporal.api.failure.v1.Failure failure = 1;
+}
+
+/**
+ * Used to report cancellation from both Core and Lang.
+ * When Lang reports a cancelled activity, it must put a CancelledFailure in the failure field.
+ * When Core reports a cancelled activity, it must put an ActivityFailure with CancelledFailure
+ * as the cause in the failure field.
+ */
+message Cancellation {
+    temporal.api.failure.v1.Failure failure = 1;
+}
+
+/**
+ * Used in ActivityExecutionResult to notify Core that this Activity will complete asynchronously.
+ * Core will forget about this Activity and free up resources used to track this Activity.
+ */
+message WillCompleteAsync {
+}
+
+/**
+ * Issued when a local activity needs to retry but also wants to back off more than would be
+ * reasonable to WFT heartbeat for. Lang is expected to schedule a timer for the duration
+ * and then start a local activity of the same type & same inputs with the provided attempt number
+ * after the timer has elapsed.
+ *
+ * This exists because Core does not have a concept of starting commands by itself, they originate
+ * from lang. So expecting lang to start the timer / next pass of the activity fits more smoothly.
+ */
+message DoBackoff {
+    // The attempt number that lang should provide when scheduling the retry. If the LA failed
+    // on attempt 4 and we told lang to back off with a timer, this number will be 5.
+    uint32 attempt = 1;
+    google.protobuf.Duration backoff_duration = 2;
+    // The time the first attempt of this local activity was scheduled. Must be passed with attempt
+    // to the retry LA.
+    google.protobuf.Timestamp original_schedule_time = 3;
+}
+

data/bridge/sdk-core/protos/local/temporal/sdk/core/activity_task/activity_task.proto

@@ -0,0 +1,79 @@
+syntax = "proto3";
+
+/**
+ * Definitions of the different activity tasks returned from [crate::Core::poll_task].
+ */
+package coresdk.activity_task;
+
+import "google/protobuf/duration.proto";
+import "google/protobuf/timestamp.proto";
+import "temporal/api/common/v1/message.proto";
+import "temporal/sdk/core/common/common.proto";
+
+message ActivityTask {
+    /// A unique identifier for this task
+    bytes task_token = 1;
+    oneof variant {
+        /// Start activity execution.
+        Start start = 3;
+        /// Attempt to cancel activity execution.
+        Cancel cancel = 4;
+    }
+}
+
+// Begin executing an activity
+message Start {
+    // The namespace the workflow lives in
+    string workflow_namespace = 1;
+    // The workflow's type name or function identifier
+    string workflow_type = 2;
+    // The workflow execution which requested this activity
+    temporal.api.common.v1.WorkflowExecution workflow_execution = 3;
+    // The activity's ID
+    string activity_id = 4;
+    // The activity's type name or function identifier
+    string activity_type = 5;
+    map<string, temporal.api.common.v1.Payload> header_fields = 6;
+    // Arguments to the activity
+    repeated temporal.api.common.v1.Payload input = 7;
+    // The last details that were recorded by a heartbeat when this task was generated
+    repeated temporal.api.common.v1.Payload heartbeat_details = 8;
+    // When the task was *first* scheduled
+    google.protobuf.Timestamp scheduled_time = 9;
+    // When this current attempt at the task was scheduled
+    google.protobuf.Timestamp current_attempt_scheduled_time = 10;
+    // When this attempt was started, which is to say when core received it by polling.
+    google.protobuf.Timestamp started_time = 11;
+    uint32 attempt = 12;
+
+    // Timeout from the first schedule time to completion
+    google.protobuf.Duration schedule_to_close_timeout = 13;
+    // Timeout from starting an attempt to reporting its result
+    google.protobuf.Duration start_to_close_timeout = 14;
+    // If set a heartbeat must be reported within this interval
+    google.protobuf.Duration heartbeat_timeout = 15;
+    // This is an actual retry policy the service uses. It can be different from the one provided
+    // (or not) during activity scheduling as the service can override the provided one in case its
+    // values are not specified or exceed configured system limits.
+    temporal.api.common.v1.RetryPolicy retry_policy = 16;
+
+    // Set to true if this is a local activity. Note that heartbeating does not apply to local
+    // activities.
+    bool is_local = 17;
+}
+
+/// Attempt to cancel a running activity
+message Cancel {
+    ActivityCancelReason reason = 1;
+}
+
+enum ActivityCancelReason {
+    /// The activity no longer exists according to server (may be already completed)
+    NOT_FOUND = 0;
+    /// Activity was explicitly cancelled
+    CANCELLED = 1;
+    /// Activity timed out
+    TIMED_OUT = 2;
+}
+
+