refactor: modify task creation endpoint to return a task, not workspace (#19637)

Relates to https://github.com/coder/internal/issues/898

Refactor the `POST /api/experimental/tasks/{user}` endpoint to return a
codersdk.Task instead of a codersdk.Workspace

coderd/aitasks.go

@@ -188,7 +188,6 @@ func (api *API) tasksCreate(rw http.ResponseWriter, r *http.Request) {
 			WorkspaceOwner: owner.Username,
 		},
 	})
-
 	defer commitAudit()
 	w, err := createWorkspace(ctx, aReq, apiKey.UserID, api, owner, createReq, r)
 	if err != nil {
@@ -196,7 +195,65 @@ func (api *API) tasksCreate(rw http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	httpapi.Write(ctx, rw, http.StatusCreated, w)
+	task := taskFromWorkspace(w, req.Prompt)
+	httpapi.Write(ctx, rw, http.StatusCreated, task)
+}
+
+func taskFromWorkspace(ws codersdk.Workspace, initialPrompt string) codersdk.Task {
+	// TODO(DanielleMaywood):
+	// This just picks up the first agent it discovers.
+	// This approach _might_ break when a task has multiple agents,
+	// depending on which agent was found first.
+	//
+	// We explicitly do not have support for running tasks
+	// inside of a sub agent at the moment, so we can be sure
+	// that any sub agents are not the agent we're looking for.
+	var taskAgentID uuid.NullUUID
+	var taskAgentLifecycle *codersdk.WorkspaceAgentLifecycle
+	var taskAgentHealth *codersdk.WorkspaceAgentHealth
+	for _, resource := range ws.LatestBuild.Resources {
+		for _, agent := range resource.Agents {
+			if agent.ParentID.Valid {
+				continue
+			}
+
+			taskAgentID = uuid.NullUUID{Valid: true, UUID: agent.ID}
+			taskAgentLifecycle = &agent.LifecycleState
+			taskAgentHealth = &agent.Health
+			break
+		}
+	}
+
+	var currentState *codersdk.TaskStateEntry
+	if ws.LatestAppStatus != nil {
+		currentState = &codersdk.TaskStateEntry{
+			Timestamp: ws.LatestAppStatus.CreatedAt,
+			State:     codersdk.TaskState(ws.LatestAppStatus.State),
+			Message:   ws.LatestAppStatus.Message,
+			URI:       ws.LatestAppStatus.URI,
+		}
+	}
+
+	return codersdk.Task{
+		ID:                      ws.ID,
+		OrganizationID:          ws.OrganizationID,
+		OwnerID:                 ws.OwnerID,
+		OwnerName:               ws.OwnerName,
+		Name:                    ws.Name,
+		TemplateID:              ws.TemplateID,
+		TemplateName:            ws.TemplateName,
+		TemplateDisplayName:     ws.TemplateDisplayName,
+		TemplateIcon:            ws.TemplateIcon,
+		WorkspaceID:             uuid.NullUUID{Valid: true, UUID: ws.ID},
+		WorkspaceAgentID:        taskAgentID,
+		WorkspaceAgentLifecycle: taskAgentLifecycle,
+		WorkspaceAgentHealth:    taskAgentHealth,
+		CreatedAt:               ws.CreatedAt,
+		UpdatedAt:               ws.UpdatedAt,
+		InitialPrompt:           initialPrompt,
+		Status:                  ws.LatestBuild.Status,
+		CurrentState:            currentState,
+	}
 }
 
 // tasksFromWorkspaces converts a slice of API workspaces into tasks, fetching
@@ -221,60 +278,7 @@ func (api *API) tasksFromWorkspaces(ctx context.Context, apiWorkspaces []codersd
 
 	tasks := make([]codersdk.Task, 0, len(apiWorkspaces))
 	for _, ws := range apiWorkspaces {
-		// TODO(DanielleMaywood):
-		// This just picks up the first agent it discovers.
-		// This approach _might_ break when a task has multiple agents,
-		// depending on which agent was found first.
-		//
-		// We explicitly do not have support for running tasks
-		// inside of a sub agent at the moment, so we can be sure
-		// that any sub agents are not the agent we're looking for.
-		var taskAgentID uuid.NullUUID
-		var taskAgentLifecycle *codersdk.WorkspaceAgentLifecycle
-		var taskAgentHealth *codersdk.WorkspaceAgentHealth
-		for _, resource := range ws.LatestBuild.Resources {
-			for _, agent := range resource.Agents {
-				if agent.ParentID.Valid {
-					continue
-				}
-
-				taskAgentID = uuid.NullUUID{Valid: true, UUID: agent.ID}
-				taskAgentLifecycle = &agent.LifecycleState
-				taskAgentHealth = &agent.Health
-				break
-			}
-		}
-
-		var currentState *codersdk.TaskStateEntry
-		if ws.LatestAppStatus != nil {
-			currentState = &codersdk.TaskStateEntry{
-				Timestamp: ws.LatestAppStatus.CreatedAt,
-				State:     codersdk.TaskState(ws.LatestAppStatus.State),
-				Message:   ws.LatestAppStatus.Message,
-				URI:       ws.LatestAppStatus.URI,
-			}
-		}
-
-		tasks = append(tasks, codersdk.Task{
-			ID:                      ws.ID,
-			OrganizationID:          ws.OrganizationID,
-			OwnerID:                 ws.OwnerID,
-			OwnerName:               ws.OwnerName,
-			Name:                    ws.Name,
-			TemplateID:              ws.TemplateID,
-			TemplateName:            ws.TemplateName,
-			TemplateDisplayName:     ws.TemplateDisplayName,
-			TemplateIcon:            ws.TemplateIcon,
-			WorkspaceID:             uuid.NullUUID{Valid: true, UUID: ws.ID},
-			WorkspaceAgentID:        taskAgentID,
-			WorkspaceAgentLifecycle: taskAgentLifecycle,
-			WorkspaceAgentHealth:    taskAgentHealth,
-			CreatedAt:               ws.CreatedAt,
-			UpdatedAt:               ws.UpdatedAt,
-			InitialPrompt:           promptsByBuildID[ws.LatestBuild.ID],
-			Status:                  ws.LatestBuild.Status,
-			CurrentState:            currentState,
-		})
+		tasks = append(tasks, taskFromWorkspace(ws, promptsByBuildID[ws.LatestBuild.ID]))
 	}
 
 	return tasks, nil

coderd/aitasks_test.go

@@ -419,19 +419,23 @@ func TestTasksCreate(t *testing.T) {
 		expClient := codersdk.NewExperimentalClient(client)
 
 		// When: We attempt to create a Task.
-		workspace, err := expClient.CreateTask(ctx, "me", codersdk.CreateTaskRequest{
+		task, err := expClient.CreateTask(ctx, "me", codersdk.CreateTaskRequest{
 			TemplateVersionID: template.ActiveVersionID,
 			Prompt:            taskPrompt,
 		})
 		require.NoError(t, err)
-		coderdtest.AwaitWorkspaceBuildJobCompleted(t, client, workspace.LatestBuild.ID)
+		require.True(t, task.WorkspaceID.Valid)
+
+		ws, err := client.Workspace(ctx, task.WorkspaceID.UUID)
+		require.NoError(t, err)
+		coderdtest.AwaitWorkspaceBuildJobCompleted(t, client, ws.LatestBuild.ID)
 
 		// Then: We expect a workspace to have been created.
-		assert.NotEmpty(t, workspace.Name)
-		assert.Equal(t, template.ID, workspace.TemplateID)
+		assert.NotEmpty(t, task.Name)
+		assert.Equal(t, template.ID, task.TemplateID)
 
 		// And: We expect it to have the "AI Prompt" parameter correctly set.
-		parameters, err := client.WorkspaceBuildParameters(ctx, workspace.LatestBuild.ID)
+		parameters, err := client.WorkspaceBuildParameters(ctx, ws.LatestBuild.ID)
 		require.NoError(t, err)
 		require.Len(t, parameters, 1)
 		assert.Equal(t, codersdk.AITaskPromptParameterName, parameters[0].Name)