@superdurable/dex 1.8.0 → 1.10.0

package/dist/src/gen/dex.d.ts

@@ -1,9 +1,24 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
-import { type CallOptions, type ChannelCredentials, Client, type ClientOptions, type ClientReadableStream, type ClientUnaryCall, type handleServerStreamingCall, type handleUnaryCall, type Metadata, type ServiceError, type UntypedServiceImplementation } from "@grpc/grpc-js";
+import { type CallOptions, type ChannelCredentials, Client, type ClientDuplexStream, type ClientOptions, type ClientReadableStream, type ClientUnaryCall, type handleBidiStreamingCall, type handleServerStreamingCall, type handleUnaryCall, type Metadata, type ServiceError, type UntypedServiceImplementation } from "@grpc/grpc-js";
 import { Duration } from "./google/protobuf/duration.js";
 import { Empty } from "./google/protobuf/empty.js";
 import { NullValue } from "./google/protobuf/struct.js";
 export declare const protobufPackage = "dex";
+/** Explains why a Worker declined a task. */
+export declare enum PollWorkerTaskRejectReason {
+    /** POLL_WORKER_TASK_REJECT_REASON_UNSPECIFIED - No rejection reason was supplied. */
+    POLL_WORKER_TASK_REJECT_REASON_UNSPECIFIED = 0,
+    /** POLL_WORKER_TASK_REJECT_REASON_NO_CAPACITY - All Worker execution slots are occupied. */
+    POLL_WORKER_TASK_REJECT_REASON_NO_CAPACITY = 1,
+    UNRECOGNIZED = -1
+}
+/** Distinguishes absence of a Worker from loss of an assigned Worker. */
+export declare enum DispatchTaskErrorReason {
+    DISPATCH_TASK_ERROR_REASON_UNSPECIFIED = 0,
+    DISPATCH_TASK_ERROR_REASON_NO_WORKER_AVAILABLE = 1,
+    DISPATCH_TASK_ERROR_REASON_WORKER_DISCONNECTED = 2,
+    UNRECOGNIZED = -1
+}
 export declare enum IndexType {
     INDEX_TYPE_UNSPECIFIED = 0,
     /** INDEX_TYPE_KEYWORD - Default for string/object when type is omitted. */
@@ -199,6 +214,200 @@ export interface ServerInfo {
     /** Newest protocol version implemented by this Server. */
     currentProtocolVersion: number;
 }
+/** Carries one Worker frame on a pull stream. Register must be the first frame. */
+export interface PollWorkerTaskRequest {
+    frame: //
+    /** Starts this queue stream; no other frame may precede registration. */
+    {
+        $case: "register";
+        value: PollWorkerTaskRegister;
+    } | //
+    /** Reports task progress or its final result. */
+    {
+        $case: "taskFrame";
+        value: PollWorkerTaskFrame;
+    } | //
+    /** Declines an assigned task when the Worker has no capacity. */
+    {
+        $case: "reject";
+        value: PollWorkerTaskReject;
+    } | //
+    /** Acknowledges a server liveness check. */
+    {
+        $case: "pong";
+        value: PollWorkerTaskPong;
+    } | undefined;
+}
+/** Registers one queue stream for a Worker process. */
+export interface PollWorkerTaskRegister {
+    /** Names this stream's queue: app_worker_id or one declared flow_type. */
+    queue: string;
+    /** Identifies this Worker process across reconnects; a restart uses a new ID. */
+    appWorkerId: string;
+    /** Lists the Flow types this Worker can execute. */
+    flowTypes: string[];
+    /** Identifies the SDK implementation for diagnostics. */
+    sdkName: string;
+    /** Identifies the SDK release for diagnostics. */
+    sdkVersion: string;
+}
+/** Carries a task's heartbeat, stream write, result, or Worker error. */
+export interface PollWorkerTaskFrame {
+    /** Matches the task_id sent by Dex on this stream. */
+    taskId: string;
+    output: //
+    /** Includes heartbeat, stream write, and final result variants. */
+    {
+        $case: "waitFor";
+        value: InvokeWaitForMethodOutput;
+    } | //
+    /** Includes heartbeat, stream write, and final result variants. */
+    {
+        $case: "execute";
+        value: InvokeExecuteMethodOutput;
+    } | //
+    /** Completes an RPC task. */
+    {
+        $case: "rpc";
+        value: InvokeWorkerRPCResponse;
+    } | //
+    /** Ends the task with a Worker error. */
+    {
+        $case: "workerError";
+        value: WorkerErrorResponse;
+    } | undefined;
+}
+/** Declines a task so Dex can assign it to another available Worker stream. */
+export interface PollWorkerTaskReject {
+    /** Matches the declined task on this stream. */
+    taskId: string;
+    /** Explains why the Worker cannot accept the task. */
+    reason: PollWorkerTaskRejectReason;
+}
+/** Acknowledges a server Ping on the same stream. */
+export interface PollWorkerTaskPong {
+}
+/** Carries one server frame on a pull stream. */
+export interface PollWorkerTaskResponse {
+    frame: //
+    /** Confirms that Dex accepted this stream's queue registration. */
+    {
+        $case: "registered";
+        value: PollWorkerTaskRegistered;
+    } | //
+    /** Assigns work to the registered Worker. */
+    {
+        $case: "task";
+        value: PollWorkerTask;
+    } | //
+    /** Requests cancellation of the assigned task. */
+    {
+        $case: "cancelTask";
+        value: PollWorkerTaskCancelTask;
+    } | //
+    /** Requests a reconnect after the current task finishes. */
+    {
+        $case: "reconnect";
+        value: PollWorkerTaskReconnect;
+    } | //
+    /** Checks whether an idle stream remains responsive. */
+    {
+        $case: "ping";
+        value: PollWorkerTaskPing;
+    } | undefined;
+}
+/** Confirms that Dex accepted the queue registration. */
+export interface PollWorkerTaskRegistered {
+}
+/** Assigns one task to this stream until its final result, error, or rejection. */
+export interface PollWorkerTask {
+    /** Identifies the assignment for result and cancellation frames. */
+    taskId: string;
+    /** Bounds task execution, including Worker processing time. */
+    deadline: Date | undefined;
+    request: //
+    /** Runs a Step's WaitFor method. */
+    {
+        $case: "waitFor";
+        value: InvokeWaitForMethodRequest;
+    } | //
+    /** Runs a Step's Execute method. */
+    {
+        $case: "execute";
+        value: InvokeExecuteMethodRequest;
+    } | //
+    /** Runs a Worker RPC. */
+    {
+        $case: "rpc";
+        value: InvokeWorkerRPCRequest;
+    } | undefined;
+}
+/** Requests cancellation of the task currently assigned to this stream. */
+export interface PollWorkerTaskCancelTask {
+    /** Matches the task currently assigned on this stream. */
+    taskId: string;
+}
+/** Asks the Worker to finish its task and reconnect for queue ownership changes or shutdown. */
+export interface PollWorkerTaskReconnect {
+    /** Explains why Dex needs a new queue stream. */
+    reason: string;
+}
+/** Checks that an idle pull stream remains responsive. */
+export interface PollWorkerTaskPing {
+}
+/** Describes one task dispatched to a Dex task queue. */
+export interface DispatchTaskRequest {
+    /** Selects the initial queue: a sticky Worker ID or a Flow type. */
+    queue: string;
+    /** Names the Flow type queue after a sticky wait expires. */
+    fallbackQueue: string;
+    /** Identifies the Flow for Worker affinity within a Flow type queue. */
+    flowId: string;
+    /** Limits waiting on a sticky queue before trying fallback_queue. */
+    stickyWait: Duration | undefined;
+    /** Limits total waiting for a Worker to accept the task. */
+    dispatchWait: Duration | undefined;
+    /** Bounds task execution, including Worker processing time. */
+    deadline: Date | undefined;
+    /** Identifies this dispatch across Worker and server streams. */
+    taskId: string;
+    request: {
+        $case: "waitFor";
+        value: InvokeWaitForMethodRequest;
+    } | {
+        $case: "execute";
+        value: InvokeExecuteMethodRequest;
+    } | {
+        $case: "rpc";
+        value: InvokeWorkerRPCRequest;
+    } | undefined;
+}
+/** Relays Worker output, then ends with a result, Worker error, or dispatch error. */
+export interface DispatchTaskResponse {
+    output: {
+        $case: "waitFor";
+        value: InvokeWaitForMethodOutput;
+    } | {
+        $case: "execute";
+        value: InvokeExecuteMethodOutput;
+    } | {
+        $case: "rpc";
+        value: InvokeWorkerRPCResponse;
+    } | {
+        $case: "workerError";
+        value: WorkerErrorResponse;
+    } | {
+        $case: "dispatchError";
+        value: DispatchTaskError;
+    } | undefined;
+    /** Identifies the Worker that produced the final result or Worker error. */
+    servedByAppWorkerId: string;
+}
+/** Reports a failure before Dex receives a Worker result. */
+export interface DispatchTaskError {
+    reason: DispatchTaskErrorReason;
+    detail: string;
+}
 export interface Value {
     kind: //
     /** Hydrate from blob storage, then replace with string_value. */
@@ -360,6 +569,8 @@ export interface WorkerTarget {
     /** Plaintext gRPC dial target, not an HTTP URL. */
     address: string;
     isHeadlessAddress: boolean;
+    /** Routes work through a connected pull Worker; mutually exclusive with address. */
+    isPullMode: boolean;
 }
 export interface StartFlowRequest {
     flowId: string;
@@ -926,6 +1137,8 @@ export interface WorkerErrorResponse {
     errorType: string;
     stackTrace: string;
     retryAfterSeconds: number;
+    /** Pull Workers set the gRPC code push mode would return; push mode uses its transport status. */
+    grpcStatus: number;
 }
 export interface InternalActivityError {
     serverDetail: string;
@@ -1259,6 +1472,8 @@ export interface ContinueAsNewDump {
     /** Stored values only; index metadata remains in backend search attributes. */
     attributes: KV[];
     pendingAttributeSyncItems: AttributeSyncItem[];
+    /** Retains the last serving Worker's sticky queue across a Flow continuation. */
+    dexTaskQueue: string;
 }
 export interface ContinueAsNewDump_ChannelReceivedEntry {
     key: string;
@@ -1280,8 +1495,6 @@ export interface InterpreterWorkflowInput {
     isResumeFromContinueAsNew: boolean;
     continueAsNewInput: ContinueAsNewInput | undefined;
     timeoutHandlerOptions: FlowTimeoutHandlerOptions | undefined;
-    /** Tenant of a multi-tenant Flow, set at start and copied to SubFlows. Empty in single-tenant mode. */
-    tenantId: string;
 }
 export interface InterpreterWorkflowOutput {
     stepCompletionOutputs: StepCompletionOutput[];
@@ -1295,17 +1508,27 @@ export interface BlobStoreCleanupWorkflowOutput {
 export interface InvokeWaitForMethodActivityInput {
     workerTarget: WorkerTarget | undefined;
     request: InvokeWaitForMethodRequest | undefined;
-    /** Tenant of the dispatching Flow; empty in single-tenant mode. */
-    tenantId: string;
+    /** Selects the sticky Worker queue; empty selects the request's Flow type queue. */
+    dexTaskQueue: string;
+    /** Limits total waiting for a pull Worker to accept this attempt. */
+    dispatchWait: Duration | undefined;
+    /** Limits waiting on the sticky queue before the Flow type queue. */
+    stickyWait: Duration | undefined;
 }
 export interface InvokeWaitForMethodActivityOutput {
     response: InvokeWaitForMethodResponse | undefined;
+    /** Identifies the Worker that completed this pull task for sticky routing. */
+    servedByAppWorkerId: string;
 }
 export interface InvokeExecuteMethodActivityInput {
     workerTarget: WorkerTarget | undefined;
     request: InvokeExecuteMethodRequest | undefined;
-    /** Tenant of the dispatching Flow; empty in single-tenant mode. */
-    tenantId: string;
+    /** Selects the sticky Worker queue; empty selects the request's Flow type queue. */
+    dexTaskQueue: string;
+    /** Limits total waiting for a pull Worker to accept this attempt. */
+    dispatchWait: Duration | undefined;
+    /** Limits waiting on the sticky queue before the Flow type queue. */
+    stickyWait: Duration | undefined;
 }
 export interface RecoveryErrorInfo {
     detail: string;
@@ -1320,6 +1543,8 @@ export interface InternalLocalStepActivityFailure {
 }
 export interface InvokeExecuteMethodActivityOutput {
     response: InvokeExecuteMethodResponse | undefined;
+    /** Identifies the Worker that completed this pull task for sticky routing. */
+    servedByAppWorkerId: string;
 }
 export interface DumpFlowForContinueAsNewActivityInput {
     request: ContinueAsNewDumpRequest | undefined;
@@ -1330,13 +1555,13 @@ export interface DumpFlowForContinueAsNewActivityOutput {
 export interface InvokeWorkerRPCActivityInput {
     rpcPrep: PrepareRpcQueryResponse | undefined;
     request: InvokeRPCRequest | undefined;
-    /** Tenant of the Flow; empty in single-tenant mode. */
-    tenantId: string;
 }
 export interface InvokeWorkerRPCActivityOutput {
     response: InvokeWorkerRPCResponse | undefined;
     /** Correlates this local Activity result with its InvokeRpc Update. */
     requestId: string;
+    /** Identifies the Worker that completed this pull task for sticky routing. */
+    servedByAppWorkerId: string;
 }
 export interface CleanupBlobStoreActivityInput {
     storeId: string;
@@ -1359,8 +1584,6 @@ export interface StartSubFlowActivityInput {
     parentFlowConfig: FlowConfig | undefined;
     /** Source Step; activity context supplies parent Flow and run IDs. */
     parentStepExecutionId: string;
-    /** Tenant of the parent Flow, inherited by the SubFlow; empty in single-tenant mode. */
-    tenantId: string;
 }
 export interface StartSubFlowActivityOutput {
     immediateFlowResult: FlowResult | undefined;
@@ -1422,6 +1645,8 @@ export interface PrepareRpcQueryResponse {
     loadedAttributeMapInstances: string[];
     loadedChannelNames: string[];
     loadedChannelMapInstances: string[];
+    /** Selects the last Worker queue for RPC dispatch. */
+    dexTaskQueue: string;
 }
 export interface PrepareRpcQueryResponse_ChannelInfosEntry {
     key: string;
@@ -1467,6 +1692,20 @@ export interface StepExecutionNumbers {
     numbers: number[];
 }
 export declare const ServerInfo: MessageFns<ServerInfo>;
+export declare const PollWorkerTaskRequest: MessageFns<PollWorkerTaskRequest>;
+export declare const PollWorkerTaskRegister: MessageFns<PollWorkerTaskRegister>;
+export declare const PollWorkerTaskFrame: MessageFns<PollWorkerTaskFrame>;
+export declare const PollWorkerTaskReject: MessageFns<PollWorkerTaskReject>;
+export declare const PollWorkerTaskPong: MessageFns<PollWorkerTaskPong>;
+export declare const PollWorkerTaskResponse: MessageFns<PollWorkerTaskResponse>;
+export declare const PollWorkerTaskRegistered: MessageFns<PollWorkerTaskRegistered>;
+export declare const PollWorkerTask: MessageFns<PollWorkerTask>;
+export declare const PollWorkerTaskCancelTask: MessageFns<PollWorkerTaskCancelTask>;
+export declare const PollWorkerTaskReconnect: MessageFns<PollWorkerTaskReconnect>;
+export declare const PollWorkerTaskPing: MessageFns<PollWorkerTaskPing>;
+export declare const DispatchTaskRequest: MessageFns<DispatchTaskRequest>;
+export declare const DispatchTaskResponse: MessageFns<DispatchTaskResponse>;
+export declare const DispatchTaskError: MessageFns<DispatchTaskError>;
 export declare const Value: MessageFns<Value>;
 export declare const EncodedObject: MessageFns<EncodedObject>;
 export declare const AttributeWrite: MessageFns<AttributeWrite>;
@@ -2073,6 +2312,79 @@ export declare const WorkerServiceClient: {
     service: typeof WorkerServiceService;
     serviceName: string;
 };
+/** Hosted by Dex server; pull Workers open one queue stream for at most one task at a time. */
+export type WorkerTaskServiceService = typeof WorkerTaskServiceService;
+export declare const WorkerTaskServiceService: {
+    /** Exchanges registration, task, result, and control frames for one Dex task queue. */
+    readonly pollWorkerTask: {
+        readonly path: "/dex.WorkerTaskService/PollWorkerTask";
+        readonly requestStream: true;
+        readonly responseStream: true;
+        readonly requestSerialize: (value: PollWorkerTaskRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => PollWorkerTaskRequest;
+        readonly responseSerialize: (value: PollWorkerTaskResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => PollWorkerTaskResponse;
+    };
+};
+export interface WorkerTaskServiceServer extends UntypedServiceImplementation {
+    /** Exchanges registration, task, result, and control frames for one Dex task queue. */
+    pollWorkerTask: handleBidiStreamingCall<PollWorkerTaskRequest, PollWorkerTaskResponse>;
+}
+export interface WorkerTaskServiceClient extends Client {
+    /** Exchanges registration, task, result, and control frames for one Dex task queue. */
+    pollWorkerTask(): ClientDuplexStream<PollWorkerTaskRequest, PollWorkerTaskResponse>;
+    pollWorkerTask(options: Partial<CallOptions>): ClientDuplexStream<PollWorkerTaskRequest, PollWorkerTaskResponse>;
+    pollWorkerTask(metadata: Metadata, options?: Partial<CallOptions>): ClientDuplexStream<PollWorkerTaskRequest, PollWorkerTaskResponse>;
+}
+export declare const WorkerTaskServiceClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): WorkerTaskServiceClient;
+    service: typeof WorkerTaskServiceService;
+    serviceName: string;
+};
+/** Hosted on the internal listener; server instances route tasks and Worker streams to queue owners. */
+export type MatchingServiceService = typeof MatchingServiceService;
+export declare const MatchingServiceService: {
+    /** Streams Worker output frames and a final result or dispatch error. */
+    readonly dispatchTask: {
+        readonly path: "/dex.MatchingService/DispatchTask";
+        readonly requestStream: false;
+        readonly responseStream: true;
+        readonly requestSerialize: (value: DispatchTaskRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => DispatchTaskRequest;
+        readonly responseSerialize: (value: DispatchTaskResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => DispatchTaskResponse;
+    };
+    /** Proxies a Worker's queue stream from its receiving instance to the queue owner. */
+    readonly forwardPollWorkerTask: {
+        readonly path: "/dex.MatchingService/ForwardPollWorkerTask";
+        readonly requestStream: true;
+        readonly responseStream: true;
+        readonly requestSerialize: (value: PollWorkerTaskRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => PollWorkerTaskRequest;
+        readonly responseSerialize: (value: PollWorkerTaskResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => PollWorkerTaskResponse;
+    };
+};
+export interface MatchingServiceServer extends UntypedServiceImplementation {
+    /** Streams Worker output frames and a final result or dispatch error. */
+    dispatchTask: handleServerStreamingCall<DispatchTaskRequest, DispatchTaskResponse>;
+    /** Proxies a Worker's queue stream from its receiving instance to the queue owner. */
+    forwardPollWorkerTask: handleBidiStreamingCall<PollWorkerTaskRequest, PollWorkerTaskResponse>;
+}
+export interface MatchingServiceClient extends Client {
+    /** Streams Worker output frames and a final result or dispatch error. */
+    dispatchTask(request: DispatchTaskRequest, options?: Partial<CallOptions>): ClientReadableStream<DispatchTaskResponse>;
+    dispatchTask(request: DispatchTaskRequest, metadata?: Metadata, options?: Partial<CallOptions>): ClientReadableStream<DispatchTaskResponse>;
+    /** Proxies a Worker's queue stream from its receiving instance to the queue owner. */
+    forwardPollWorkerTask(): ClientDuplexStream<PollWorkerTaskRequest, PollWorkerTaskResponse>;
+    forwardPollWorkerTask(options: Partial<CallOptions>): ClientDuplexStream<PollWorkerTaskRequest, PollWorkerTaskResponse>;
+    forwardPollWorkerTask(metadata: Metadata, options?: Partial<CallOptions>): ClientDuplexStream<PollWorkerTaskRequest, PollWorkerTaskResponse>;
+}
+export declare const MatchingServiceClient: {
+    new (address: string, credentials: ChannelCredentials, options?: Partial<ClientOptions>): MatchingServiceClient;
+    service: typeof MatchingServiceService;
+    serviceName: string;
+};
 /** Server-internal only (interpreter CAN activity → API). Not SDK-facing. */
 export type InternalServiceService = typeof InternalServiceService;
 export declare const InternalServiceService: {