@heynixie/contract 0.56.0 → 0.57.0

package/dist/build-query-utils.d.ts

@@ -345,10 +345,11 @@ export declare function buildQueryUtils(client: ContractClient): {
         list: import("@orpc/tanstack-query").ProcedureUtils<Record<never, never>, unknown, {
             tasks: {
                 brief: string;
+                isPauseRequested: boolean;
                 isTakingMessages: boolean;
                 lastActivityAt: Date;
                 name: string;
-                state: "done" | "failed" | "ready" | "running" | "waiting";
+                state: "closed" | "done" | "failed" | "paused" | "ready" | "running" | "stopped" | "waiting";
                 taskID: string;
             }[];
         }, import("@orpc/contract").ErrorFromErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
@@ -357,6 +358,275 @@ export declare function buildQueryUtils(client: ContractClient): {
                 status: number;
             };
         }>>> & import("@orpc/tanstack-query").GeneralUtils<unknown>;
+        pause: import("@orpc/tanstack-query").ProcedureUtils<Record<never, never>, {
+            clientActionID: string;
+            taskID: string;
+        }, {
+            controlledAt: Date;
+            isPauseRequested: boolean;
+            state: "closed" | "done" | "failed" | "paused" | "ready" | "running" | "stopped" | "waiting";
+            taskID: string;
+        }, import("@orpc/contract").ErrorFromErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            TASK_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            TASK_STATE_REFUSED: {
+                message: string;
+                status: number;
+                data: import("zod").ZodObject<{
+                    isPauseRequested: import("zod").ZodBoolean;
+                    state: import("zod").ZodEnum<{
+                        closed: "closed";
+                        done: "done";
+                        failed: "failed";
+                        paused: "paused";
+                        ready: "ready";
+                        running: "running";
+                        stopped: "stopped";
+                        waiting: "waiting";
+                    }>;
+                }, import("zod/v4/core").$strip>;
+            };
+        }>>> & import("@orpc/tanstack-query").GeneralUtils<{
+            clientActionID: string;
+            taskID: string;
+        }>;
+        resume: import("@orpc/tanstack-query").ProcedureUtils<Record<never, never>, {
+            clientActionID: string;
+            taskID: string;
+        }, {
+            controlledAt: Date;
+            isPauseRequested: boolean;
+            state: "closed" | "done" | "failed" | "paused" | "ready" | "running" | "stopped" | "waiting";
+            taskID: string;
+        }, import("@orpc/contract").ErrorFromErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            TASK_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            TASK_STATE_REFUSED: {
+                message: string;
+                status: number;
+                data: import("zod").ZodObject<{
+                    isPauseRequested: import("zod").ZodBoolean;
+                    state: import("zod").ZodEnum<{
+                        closed: "closed";
+                        done: "done";
+                        failed: "failed";
+                        paused: "paused";
+                        ready: "ready";
+                        running: "running";
+                        stopped: "stopped";
+                        waiting: "waiting";
+                    }>;
+                }, import("zod/v4/core").$strip>;
+            };
+        }>>> & import("@orpc/tanstack-query").GeneralUtils<{
+            clientActionID: string;
+            taskID: string;
+        }>;
+        stop: import("@orpc/tanstack-query").ProcedureUtils<Record<never, never>, {
+            clientActionID: string;
+            taskID: string;
+        }, {
+            controlledAt: Date;
+            isPauseRequested: boolean;
+            state: "closed" | "done" | "failed" | "paused" | "ready" | "running" | "stopped" | "waiting";
+            taskID: string;
+        }, import("@orpc/contract").ErrorFromErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            TASK_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            TASK_STATE_REFUSED: {
+                message: string;
+                status: number;
+                data: import("zod").ZodObject<{
+                    isPauseRequested: import("zod").ZodBoolean;
+                    state: import("zod").ZodEnum<{
+                        closed: "closed";
+                        done: "done";
+                        failed: "failed";
+                        paused: "paused";
+                        ready: "ready";
+                        running: "running";
+                        stopped: "stopped";
+                        waiting: "waiting";
+                    }>;
+                }, import("zod/v4/core").$strip>;
+            };
+        }>>> & import("@orpc/tanstack-query").GeneralUtils<{
+            clientActionID: string;
+            taskID: string;
+        }>;
+        restart: import("@orpc/tanstack-query").ProcedureUtils<Record<never, never>, {
+            clientActionID: string;
+            taskID: string;
+        }, {
+            controlledAt: Date;
+            isPauseRequested: boolean;
+            state: "closed" | "done" | "failed" | "paused" | "ready" | "running" | "stopped" | "waiting";
+            taskID: string;
+        }, import("@orpc/contract").ErrorFromErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            TASK_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            TASK_STATE_REFUSED: {
+                message: string;
+                status: number;
+                data: import("zod").ZodObject<{
+                    isPauseRequested: import("zod").ZodBoolean;
+                    state: import("zod").ZodEnum<{
+                        closed: "closed";
+                        done: "done";
+                        failed: "failed";
+                        paused: "paused";
+                        ready: "ready";
+                        running: "running";
+                        stopped: "stopped";
+                        waiting: "waiting";
+                    }>;
+                }, import("zod/v4/core").$strip>;
+            };
+        }>>> & import("@orpc/tanstack-query").GeneralUtils<{
+            clientActionID: string;
+            taskID: string;
+        }>;
+        close: import("@orpc/tanstack-query").ProcedureUtils<Record<never, never>, {
+            clientActionID: string;
+            taskID: string;
+        }, {
+            controlledAt: Date;
+            isPauseRequested: boolean;
+            state: "closed" | "done" | "failed" | "paused" | "ready" | "running" | "stopped" | "waiting";
+            taskID: string;
+        }, import("@orpc/contract").ErrorFromErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            TASK_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            TASK_STATE_REFUSED: {
+                message: string;
+                status: number;
+                data: import("zod").ZodObject<{
+                    isPauseRequested: import("zod").ZodBoolean;
+                    state: import("zod").ZodEnum<{
+                        closed: "closed";
+                        done: "done";
+                        failed: "failed";
+                        paused: "paused";
+                        ready: "ready";
+                        running: "running";
+                        stopped: "stopped";
+                        waiting: "waiting";
+                    }>;
+                }, import("zod/v4/core").$strip>;
+            };
+        }>, {
+            CONVERSATION_NEVER_CLOSES: {
+                message: string;
+                status: number;
+            };
+        }>>> & import("@orpc/tanstack-query").GeneralUtils<{
+            clientActionID: string;
+            taskID: string;
+        }>;
+        interrupt: import("@orpc/tanstack-query").ProcedureUtils<Record<never, never>, {
+            clientActionID: string;
+            taskID: string;
+        }, {
+            controlledAt: Date;
+            isPauseRequested: boolean;
+            state: "closed" | "done" | "failed" | "paused" | "ready" | "running" | "stopped" | "waiting";
+            taskID: string;
+        }, import("@orpc/contract").ErrorFromErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            TASK_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            TASK_STATE_REFUSED: {
+                message: string;
+                status: number;
+                data: import("zod").ZodObject<{
+                    isPauseRequested: import("zod").ZodBoolean;
+                    state: import("zod").ZodEnum<{
+                        closed: "closed";
+                        done: "done";
+                        failed: "failed";
+                        paused: "paused";
+                        ready: "ready";
+                        running: "running";
+                        stopped: "stopped";
+                        waiting: "waiting";
+                    }>;
+                }, import("zod/v4/core").$strip>;
+            };
+        }>>> & import("@orpc/tanstack-query").GeneralUtils<{
+            clientActionID: string;
+            taskID: string;
+        }>;
     } & import("@orpc/tanstack-query").GeneralUtils<unknown>;
     memory: {
         export: import("@orpc/tanstack-query").ProcedureUtils<Record<never, never>, {

package/dist/contract.d.ts

@@ -354,14 +354,18 @@ export declare const contract: {
         list: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
             tasks: z.ZodArray<z.ZodObject<{
                 brief: z.ZodString;
+                isPauseRequested: z.ZodBoolean;
                 isTakingMessages: z.ZodBoolean;
                 lastActivityAt: z.ZodDate;
                 name: z.ZodString;
                 state: z.ZodEnum<{
+                    closed: "closed";
                     done: "done";
                     failed: "failed";
+                    paused: "paused";
                     ready: "ready";
                     running: "running";
+                    stopped: "stopped";
                     waiting: "waiting";
                 }>;
                 taskID: z.ZodString;
@@ -372,6 +376,311 @@ export declare const contract: {
                 status: number;
             };
         }>, Record<never, never>>;
+        pause: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+            taskID: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            controlledAt: z.ZodDate;
+            isPauseRequested: z.ZodBoolean;
+            state: z.ZodEnum<{
+                closed: "closed";
+                done: "done";
+                failed: "failed";
+                paused: "paused";
+                ready: "ready";
+                running: "running";
+                stopped: "stopped";
+                waiting: "waiting";
+            }>;
+            taskID: z.ZodString;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            TASK_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            TASK_STATE_REFUSED: {
+                message: string;
+                status: number;
+                data: z.ZodObject<{
+                    isPauseRequested: z.ZodBoolean;
+                    state: z.ZodEnum<{
+                        closed: "closed";
+                        done: "done";
+                        failed: "failed";
+                        paused: "paused";
+                        ready: "ready";
+                        running: "running";
+                        stopped: "stopped";
+                        waiting: "waiting";
+                    }>;
+                }, z.core.$strip>;
+            };
+        }>, Record<never, never>>;
+        resume: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+            taskID: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            controlledAt: z.ZodDate;
+            isPauseRequested: z.ZodBoolean;
+            state: z.ZodEnum<{
+                closed: "closed";
+                done: "done";
+                failed: "failed";
+                paused: "paused";
+                ready: "ready";
+                running: "running";
+                stopped: "stopped";
+                waiting: "waiting";
+            }>;
+            taskID: z.ZodString;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            TASK_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            TASK_STATE_REFUSED: {
+                message: string;
+                status: number;
+                data: z.ZodObject<{
+                    isPauseRequested: z.ZodBoolean;
+                    state: z.ZodEnum<{
+                        closed: "closed";
+                        done: "done";
+                        failed: "failed";
+                        paused: "paused";
+                        ready: "ready";
+                        running: "running";
+                        stopped: "stopped";
+                        waiting: "waiting";
+                    }>;
+                }, z.core.$strip>;
+            };
+        }>, Record<never, never>>;
+        stop: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+            taskID: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            controlledAt: z.ZodDate;
+            isPauseRequested: z.ZodBoolean;
+            state: z.ZodEnum<{
+                closed: "closed";
+                done: "done";
+                failed: "failed";
+                paused: "paused";
+                ready: "ready";
+                running: "running";
+                stopped: "stopped";
+                waiting: "waiting";
+            }>;
+            taskID: z.ZodString;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            TASK_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            TASK_STATE_REFUSED: {
+                message: string;
+                status: number;
+                data: z.ZodObject<{
+                    isPauseRequested: z.ZodBoolean;
+                    state: z.ZodEnum<{
+                        closed: "closed";
+                        done: "done";
+                        failed: "failed";
+                        paused: "paused";
+                        ready: "ready";
+                        running: "running";
+                        stopped: "stopped";
+                        waiting: "waiting";
+                    }>;
+                }, z.core.$strip>;
+            };
+        }>, Record<never, never>>;
+        restart: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+            taskID: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            controlledAt: z.ZodDate;
+            isPauseRequested: z.ZodBoolean;
+            state: z.ZodEnum<{
+                closed: "closed";
+                done: "done";
+                failed: "failed";
+                paused: "paused";
+                ready: "ready";
+                running: "running";
+                stopped: "stopped";
+                waiting: "waiting";
+            }>;
+            taskID: z.ZodString;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            TASK_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            TASK_STATE_REFUSED: {
+                message: string;
+                status: number;
+                data: z.ZodObject<{
+                    isPauseRequested: z.ZodBoolean;
+                    state: z.ZodEnum<{
+                        closed: "closed";
+                        done: "done";
+                        failed: "failed";
+                        paused: "paused";
+                        ready: "ready";
+                        running: "running";
+                        stopped: "stopped";
+                        waiting: "waiting";
+                    }>;
+                }, z.core.$strip>;
+            };
+        }>, Record<never, never>>;
+        close: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+            taskID: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            controlledAt: z.ZodDate;
+            isPauseRequested: z.ZodBoolean;
+            state: z.ZodEnum<{
+                closed: "closed";
+                done: "done";
+                failed: "failed";
+                paused: "paused";
+                ready: "ready";
+                running: "running";
+                stopped: "stopped";
+                waiting: "waiting";
+            }>;
+            taskID: z.ZodString;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            TASK_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            TASK_STATE_REFUSED: {
+                message: string;
+                status: number;
+                data: z.ZodObject<{
+                    isPauseRequested: z.ZodBoolean;
+                    state: z.ZodEnum<{
+                        closed: "closed";
+                        done: "done";
+                        failed: "failed";
+                        paused: "paused";
+                        ready: "ready";
+                        running: "running";
+                        stopped: "stopped";
+                        waiting: "waiting";
+                    }>;
+                }, z.core.$strip>;
+            };
+        }>, {
+            CONVERSATION_NEVER_CLOSES: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        interrupt: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            clientActionID: z.ZodUUID;
+            taskID: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            controlledAt: z.ZodDate;
+            isPauseRequested: z.ZodBoolean;
+            state: z.ZodEnum<{
+                closed: "closed";
+                done: "done";
+                failed: "failed";
+                paused: "paused";
+                ready: "ready";
+                running: "running";
+                stopped: "stopped";
+                waiting: "waiting";
+            }>;
+            taskID: z.ZodString;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            UNAUTHORIZED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CLIENT_ACTION_ID_REUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            TASK_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            TASK_STATE_REFUSED: {
+                message: string;
+                status: number;
+                data: z.ZodObject<{
+                    isPauseRequested: z.ZodBoolean;
+                    state: z.ZodEnum<{
+                        closed: "closed";
+                        done: "done";
+                        failed: "failed";
+                        paused: "paused";
+                        ready: "ready";
+                        running: "running";
+                        stopped: "stopped";
+                        waiting: "waiting";
+                    }>;
+                }, z.core.$strip>;
+            };
+        }>, Record<never, never>>;
     };
     memory: {
         export: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{

package/dist/host-contract.d.ts

@@ -10,6 +10,163 @@ export declare const hostContract: {
         lastSequence: z.ZodInt;
         shreddedRecords: z.ZodInt;
     }, z.core.$strip>, Record<never, never>, Record<never, never>>;
+    tasks: {
+        pause: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            taskID: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            taskID: z.ZodString;
+            state: z.ZodEnum<{
+                closed: "closed";
+                done: "done";
+                failed: "failed";
+                paused: "paused";
+                ready: "ready";
+                running: "running";
+                stopped: "stopped";
+                waiting: "waiting";
+            }>;
+            isPauseRequested: z.ZodBoolean;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            TASK_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            TASK_STATE_REFUSED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        resume: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            taskID: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            taskID: z.ZodString;
+            state: z.ZodEnum<{
+                closed: "closed";
+                done: "done";
+                failed: "failed";
+                paused: "paused";
+                ready: "ready";
+                running: "running";
+                stopped: "stopped";
+                waiting: "waiting";
+            }>;
+            isPauseRequested: z.ZodBoolean;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            TASK_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            TASK_STATE_REFUSED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        stop: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            taskID: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            taskID: z.ZodString;
+            state: z.ZodEnum<{
+                closed: "closed";
+                done: "done";
+                failed: "failed";
+                paused: "paused";
+                ready: "ready";
+                running: "running";
+                stopped: "stopped";
+                waiting: "waiting";
+            }>;
+            isPauseRequested: z.ZodBoolean;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            TASK_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            TASK_STATE_REFUSED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        restart: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            taskID: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            taskID: z.ZodString;
+            state: z.ZodEnum<{
+                closed: "closed";
+                done: "done";
+                failed: "failed";
+                paused: "paused";
+                ready: "ready";
+                running: "running";
+                stopped: "stopped";
+                waiting: "waiting";
+            }>;
+            isPauseRequested: z.ZodBoolean;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            TASK_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            TASK_STATE_REFUSED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        close: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            taskID: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            taskID: z.ZodString;
+            state: z.ZodEnum<{
+                closed: "closed";
+                done: "done";
+                failed: "failed";
+                paused: "paused";
+                ready: "ready";
+                running: "running";
+                stopped: "stopped";
+                waiting: "waiting";
+            }>;
+            isPauseRequested: z.ZodBoolean;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            TASK_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            TASK_STATE_REFUSED: {
+                message: string;
+                status: number;
+            };
+        }>, {
+            CONVERSATION_NEVER_CLOSES: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+        interrupt: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
+            taskID: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            taskID: z.ZodString;
+            state: z.ZodEnum<{
+                closed: "closed";
+                done: "done";
+                failed: "failed";
+                paused: "paused";
+                ready: "ready";
+                running: "running";
+                stopped: "stopped";
+                waiting: "waiting";
+            }>;
+            isPauseRequested: z.ZodBoolean;
+        }, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+            TASK_NOT_FOUND: {
+                message: string;
+                status: number;
+            };
+            TASK_STATE_REFUSED: {
+                message: string;
+                status: number;
+            };
+        }>, Record<never, never>>;
+    };
     sessions: {
         issueCode: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
             code: z.ZodString;

package/dist/index.js

@@ -720,14 +720,39 @@ var moveTargetSchema = z9.discriminatedUnion("kind", [
   z9.object({ kind: z9.literal("task"), taskID: threadSchema }),
   newTaskTargetSchema
 ]);
+var taskStateSchema = z9.enum([
+  "ready",
+  "running",
+  "waiting",
+  "paused",
+  "stopped",
+  "done",
+  "failed",
+  "closed"
+]);
 var listedTaskSchema = z9.object({
   brief: z9.string(),
+  isPauseRequested: z9.boolean(),
   isTakingMessages: z9.boolean(),
   lastActivityAt: z9.date(),
   name: z9.string(),
-  state: z9.enum(["ready", "running", "waiting", "done", "failed"]),
+  state: taskStateSchema,
+  taskID: threadSchema
+});
+var controlledTaskSchema = z9.object({
+  controlledAt: z9.date(),
+  isPauseRequested: z9.boolean(),
+  state: taskStateSchema,
   taskID: threadSchema
 });
+var taskControl = checkedAction.errors({
+  TASK_NOT_FOUND: { message: "No task has this ID", status: 404 },
+  TASK_STATE_REFUSED: {
+    message: "The task is in a state that does not take this control",
+    status: 409,
+    data: z9.object({ isPauseRequested: z9.boolean(), state: taskStateSchema })
+  }
+}).input(z9.object({ clientActionID: clientActionIDSchema, taskID: threadSchema })).output(controlledTaskSchema);
 var followRecords = signedIn.input(z9.object({ afterSequence: sequenceSchema, thread: threadSchema.optional() })).output(eventIterator2(z9.object({ record: recordSchema })));
 var contract = {
   conversation: {
@@ -783,7 +808,15 @@ var contract = {
     })).output(z9.object({ movedAt: z9.date(), taskID: threadSchema }))
   },
   tasks: {
-    list: signedIn.output(z9.object({ tasks: z9.array(listedTaskSchema) }))
+    list: signedIn.output(z9.object({ tasks: z9.array(listedTaskSchema) })),
+    pause: taskControl,
+    resume: taskControl,
+    stop: taskControl,
+    restart: taskControl,
+    close: taskControl.errors({
+      CONVERSATION_NEVER_CLOSES: { message: "The conversation is never closed", status: 409 }
+    }),
+    interrupt: taskControl
   },
   memory: {
     readVersions: signedIn.input(z9.object({ versions: z9.array(versionRefSchema).min(1).max(100) })).output(z9.object({ versions: z9.array(versionTextSchema) })),
@@ -1039,6 +1072,27 @@ var prompts = oc3.errors({
   PROMPT_CHECK: { message: "the override fails the definitions checks", status: 400 }
 });
 var forgottenItemsSchema = z10.object({ itemIDs: z10.array(z10.string()) });
+var hostTaskStateSchema = z10.enum([
+  "ready",
+  "running",
+  "waiting",
+  "paused",
+  "stopped",
+  "done",
+  "failed",
+  "closed"
+]);
+var taskControl2 = oc3.errors({
+  TASK_NOT_FOUND: { message: "no task has that ID", status: 404 },
+  TASK_STATE_REFUSED: {
+    message: "the task is in a state that does not take this control",
+    status: 409
+  }
+}).input(z10.strictObject({ taskID: z10.string().min(1) })).output(z10.object({
+  taskID: z10.string(),
+  state: hostTaskStateSchema,
+  isPauseRequested: z10.boolean()
+}));
 var hostContract = {
   reset: oc3.output(z10.object({
     resetAt: z10.date(),
@@ -1050,6 +1104,16 @@ var hostContract = {
     lastSequence: z10.int().nonnegative(),
     shreddedRecords: z10.int().nonnegative()
   })),
+  tasks: {
+    pause: taskControl2,
+    resume: taskControl2,
+    stop: taskControl2,
+    restart: taskControl2,
+    close: taskControl2.errors({
+      CONVERSATION_NEVER_CLOSES: { message: "the conversation is never closed", status: 409 }
+    }),
+    interrupt: taskControl2
+  },
   sessions: {
     issueCode: oc3.output(z10.object({ code: z10.string(), expiresAt: z10.date() })),
     list: oc3.output(z10.array(hostSessionSchema)),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heynixie/contract",
-  "version": "0.56.0",
+  "version": "0.57.0",
   "description": "The oRPC contract of the nixie API, with the types a client needs",
   "license": "MIT",
   "repository": {