feat(coderd): use task data model for list (#20394)

Updates coder/internal#976

codersdk/aitasks.go

@@ -103,6 +103,17 @@ const (
 	TaskStatusError        TaskStatus = "error"
 )
 
+func AllTaskStatuses() []TaskStatus {
+	return []TaskStatus{
+		TaskStatusPending,
+		TaskStatusInitializing,
+		TaskStatusActive,
+		TaskStatusPaused,
+		TaskStatusError,
+		TaskStatusUnknown,
+	}
+}
+
 // TaskState represents the high-level lifecycle of a task.
 //
 // Experimental: This type is experimental and may change in the future.
@@ -160,18 +171,37 @@ type TaskStateEntry struct {
 type TasksFilter struct {
 	// Owner can be a username, UUID, or "me".
 	Owner string `json:"owner,omitempty"`
-	// Status filters the tasks by their status.
-	//
-	// TODO(mafredri): Enable this field.
-	// Status TaskStatus `json:"status,omitempty"`
-	// WorkspaceStatus is a workspace status to filter by.
-	//
-	// Deprecated: Use TaskStatus instead.
-	WorkspaceStatus string `json:"workspace_status,omitempty" typescript:"-"`
-	// Offset is the number of tasks to skip before returning results.
-	Offset int `json:"offset,omitempty" typescript:"-"`
-	// Limit is a limit on the number of tasks returned.
-	Limit int `json:"limit,omitempty" typescript:"-"`
+	// Organization can be an organization name or UUID.
+	Organization string `json:"organization,omitempty"`
+	// Status filters the tasks by their task status.
+	Status TaskStatus `json:"status,omitempty"`
+	// FilterQuery allows specifying a raw filter query.
+	FilterQuery string `json:"filter_query,omitempty"`
+}
+
+func (f TasksFilter) asRequestOption() RequestOption {
+	return func(r *http.Request) {
+		var params []string
+		// Make sure all user input is quoted to ensure it's parsed as a single
+		// string.
+		if f.Owner != "" {
+			params = append(params, fmt.Sprintf("owner:%q", f.Owner))
+		}
+		if f.Organization != "" {
+			params = append(params, fmt.Sprintf("organization:%q", f.Organization))
+		}
+		if f.Status != "" {
+			params = append(params, fmt.Sprintf("status:%q", string(f.Status)))
+		}
+		if f.FilterQuery != "" {
+			// If custom stuff is added, just add it on here.
+			params = append(params, f.FilterQuery)
+		}
+
+		q := r.URL.Query()
+		q.Set("q", strings.Join(params, " "))
+		r.URL.RawQuery = q.Encode()
+	}
 }
 
 // Tasks lists all tasks belonging to the user or specified owner.
@@ -182,15 +212,7 @@ func (c *ExperimentalClient) Tasks(ctx context.Context, filter *TasksFilter) ([]
 		filter = &TasksFilter{}
 	}
 
-	var wsFilter WorkspaceFilter
-	wsFilter.Owner = filter.Owner
-	wsFilter.Status = filter.WorkspaceStatus
-	page := Pagination{
-		Offset: filter.Offset,
-		Limit:  filter.Limit,
-	}
-
-	res, err := c.Request(ctx, http.MethodGet, "/api/experimental/tasks", nil, wsFilter.asRequestOption(), page.asRequestOption())
+	res, err := c.Request(ctx, http.MethodGet, "/api/experimental/tasks", nil, filter.asRequestOption())
 	if err != nil {
 		return nil, err
 	}
@@ -233,6 +255,72 @@ func (c *ExperimentalClient) TaskByID(ctx context.Context, id uuid.UUID) (Task,
 	return task, nil
 }
 
+func splitTaskIdentifier(identifier string) (owner string, taskName string, err error) {
+	parts := strings.Split(identifier, "/")
+
+	switch len(parts) {
+	case 1:
+		owner = Me
+		taskName = parts[0]
+	case 2:
+		owner = parts[0]
+		taskName = parts[1]
+	default:
+		return "", "", xerrors.Errorf("invalid task identifier: %q", identifier)
+	}
+	return owner, taskName, nil
+}
+
+// TaskByIdentifier fetches and returns a task by an identifier, which may be
+// either a UUID, a name (for a task owned by the current user), or a
+// "user/task" combination, where user is either a username or UUID.
+//
+// Since there is no TaskByOwnerAndName endpoint yet, this function uses the
+// list endpoint with filtering when a name is provided.
+func (c *ExperimentalClient) TaskByIdentifier(ctx context.Context, identifier string) (Task, error) {
+	identifier = strings.TrimSpace(identifier)
+
+	// Try parsing as UUID first.
+	if taskID, err := uuid.Parse(identifier); err == nil {
+		return c.TaskByID(ctx, taskID)
+	}
+
+	// Not a UUID, treat as identifier.
+	owner, taskName, err := splitTaskIdentifier(identifier)
+	if err != nil {
+		return Task{}, err
+	}
+
+	tasks, err := c.Tasks(ctx, &TasksFilter{
+		Owner: owner,
+	})
+	if err != nil {
+		return Task{}, xerrors.Errorf("list tasks for owner %q: %w", owner, err)
+	}
+
+	if taskID, err := uuid.Parse(taskName); err == nil {
+		// Find task by ID.
+		for _, task := range tasks {
+			if task.ID == taskID {
+				return task, nil
+			}
+		}
+	} else {
+		// Find task by name.
+		for _, task := range tasks {
+			if task.Name == taskName {
+				return task, nil
+			}
+		}
+	}
+
+	// Mimic resource not found from API.
+	var notFoundErr error = &Error{
+		Response: Response{Message: "Resource not found or you do not have access to this resource"},
+	}
+	return Task{}, xerrors.Errorf("task %q not found for owner %q: %w", taskName, owner, notFoundErr)
+}
+
 // DeleteTask deletes a task by its ID.
 //
 // Experimental: This method is experimental and may change in the future.

codersdk/aitasks_internal_test.go

@@ -0,0 +1,75 @@
+package codersdk
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func Test_splitTaskIdentifier(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name          string
+		identifier    string
+		expectedOwner string
+		expectedTask  string
+		expectErr     bool
+	}{
+		{
+			name:          "bare task name",
+			identifier:    "mytask",
+			expectedOwner: Me,
+			expectedTask:  "mytask",
+			expectErr:     false,
+		},
+		{
+			name:          "owner/task format",
+			identifier:    "alice/her-task",
+			expectedOwner: "alice",
+			expectedTask:  "her-task",
+			expectErr:     false,
+		},
+		{
+			name:          "uuid/task format",
+			identifier:    "550e8400-e29b-41d4-a716-446655440000/task1",
+			expectedOwner: "550e8400-e29b-41d4-a716-446655440000",
+			expectedTask:  "task1",
+			expectErr:     false,
+		},
+		{
+			name:          "owner/uuid format",
+			identifier:    "alice/3abe1dcf-cd87-4078-8b54-c0e2058ad2e2",
+			expectedOwner: "alice",
+			expectedTask:  "3abe1dcf-cd87-4078-8b54-c0e2058ad2e2",
+			expectErr:     false,
+		},
+		{
+			name:       "too many slashes",
+			identifier: "owner/task/extra",
+			expectErr:  true,
+		},
+		{
+			name:          "empty parts acceptable",
+			identifier:    "/task",
+			expectedOwner: "",
+			expectedTask:  "task",
+			expectErr:     false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			owner, taskName, err := splitTaskIdentifier(tt.identifier)
+			if tt.expectErr {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+				assert.Equal(t, tt.expectedOwner, owner)
+				assert.Equal(t, tt.expectedTask, taskName)
+			}
+		})
+	}
+}

codersdk/toolsdk/bash.go

@@ -266,20 +266,25 @@ func getWorkspaceAgent(workspace codersdk.Workspace, agentName string) (codersdk
 	return codersdk.WorkspaceAgent{}, xerrors.Errorf("multiple agents found, please specify the agent name, available agents: %v", availableNames)
 }
 
-// namedWorkspace gets a workspace by owner/name or just name
-func namedWorkspace(ctx context.Context, client *codersdk.Client, identifier string) (codersdk.Workspace, error) {
-	// Parse owner and workspace name
+func splitNameAndOwner(identifier string) (name string, owner string) {
+	// Parse owner and name (workspace, task).
 	parts := strings.SplitN(identifier, "/", 2)
-	var owner, workspaceName string
 
 	if len(parts) == 2 {
 		owner = parts[0]
-		workspaceName = parts[1]
+		name = parts[1]
 	} else {
 		owner = "me"
-		workspaceName = identifier
+		name = identifier
 	}
 
+	return name, owner
+}
+
+// namedWorkspace gets a workspace by owner/name or just name
+func namedWorkspace(ctx context.Context, client *codersdk.Client, identifier string) (codersdk.Workspace, error) {
+	workspaceName, owner := splitNameAndOwner(identifier)
+
 	// Handle -- separator format (convert to / format)
 	if strings.Contains(identifier, "--") && !strings.Contains(identifier, "/") {
 		dashParts := strings.SplitN(identifier, "--", 2)

codersdk/toolsdk/toolsdk.go

@@ -1909,24 +1909,12 @@ var DeleteTask = Tool[DeleteTaskArgs, codersdk.Response]{
 
 		expClient := codersdk.NewExperimentalClient(deps.coderClient)
 
-		var owner string
-		id, err := uuid.Parse(args.TaskID)
-		if err == nil {
-			task, err := expClient.TaskByID(ctx, id)
-			if err != nil {
-				return codersdk.Response{}, xerrors.Errorf("get task %q: %w", args.TaskID, err)
-			}
-			owner = task.OwnerName
-		} else {
-			ws, err := normalizedNamedWorkspace(ctx, deps.coderClient, args.TaskID)
-			if err != nil {
-				return codersdk.Response{}, xerrors.Errorf("get task workspace %q: %w", args.TaskID, err)
-			}
-			owner = ws.OwnerName
-			id = ws.ID
+		task, err := expClient.TaskByIdentifier(ctx, args.TaskID)
+		if err != nil {
+			return codersdk.Response{}, xerrors.Errorf("resolve task: %w", err)
 		}
 
-		err = expClient.DeleteTask(ctx, owner, id)
+		err = expClient.DeleteTask(ctx, task.OwnerName, task.ID)
 		if err != nil {
 			return codersdk.Response{}, xerrors.Errorf("delete task: %w", err)
 		}
@@ -1938,8 +1926,8 @@ var DeleteTask = Tool[DeleteTaskArgs, codersdk.Response]{
 }
 
 type ListTasksArgs struct {
-	WorkspaceStatus string `json:"status"`
-	User            string `json:"user"`
+	Status codersdk.TaskStatus `json:"status"`
+	User   string              `json:"user"`
 }
 
 type ListTasksResponse struct {
@@ -1972,8 +1960,8 @@ var ListTasks = Tool[ListTasksArgs, ListTasksResponse]{
 
 		expClient := codersdk.NewExperimentalClient(deps.coderClient)
 		tasks, err := expClient.Tasks(ctx, &codersdk.TasksFilter{
-			Owner:           args.User,
-			WorkspaceStatus: args.WorkspaceStatus,
+			Owner:  args.User,
+			Status: args.Status,
 		})
 		if err != nil {
 			return ListTasksResponse{}, xerrors.Errorf("list tasks: %w", err)
@@ -1990,7 +1978,7 @@ type GetTaskStatusArgs struct {
 }
 
 type GetTaskStatusResponse struct {
-	Status codersdk.WorkspaceStatus `json:"status"`
+	Status codersdk.TaskStatus      `json:"status"`
 	State  *codersdk.TaskStateEntry `json:"state"`
 }
 
@@ -2016,22 +2004,13 @@ var GetTaskStatus = Tool[GetTaskStatusArgs, GetTaskStatusResponse]{
 
 		expClient := codersdk.NewExperimentalClient(deps.coderClient)
 
-		id, err := uuid.Parse(args.TaskID)
+		task, err := expClient.TaskByIdentifier(ctx, args.TaskID)
 		if err != nil {
-			ws, err := normalizedNamedWorkspace(ctx, deps.coderClient, args.TaskID)
-			if err != nil {
-				return GetTaskStatusResponse{}, xerrors.Errorf("get task workspace %q: %w", args.TaskID, err)
-			}
-			id = ws.ID
-		}
-
-		task, err := expClient.TaskByID(ctx, id)
-		if err != nil {
-			return GetTaskStatusResponse{}, xerrors.Errorf("get task %q: %w", args.TaskID, err)
+			return GetTaskStatusResponse{}, xerrors.Errorf("resolve task %q: %w", args.TaskID, err)
 		}
 
 		return GetTaskStatusResponse{
-			Status: task.WorkspaceStatus,
+			Status: task.Status,
 			State:  task.CurrentState,
 		}, nil
 	},
@@ -2071,12 +2050,13 @@ var SendTaskInput = Tool[SendTaskInputArgs, codersdk.Response]{
 		}
 
 		expClient := codersdk.NewExperimentalClient(deps.coderClient)
-		id, owner, err := resolveTaskID(ctx, deps.coderClient, args.TaskID)
+
+		task, err := expClient.TaskByIdentifier(ctx, args.TaskID)
 		if err != nil {
-			return codersdk.Response{}, err
+			return codersdk.Response{}, xerrors.Errorf("resolve task %q: %w", args.TaskID, err)
 		}
 
-		err = expClient.TaskSend(ctx, owner, id, codersdk.TaskSendRequest{
+		err = expClient.TaskSend(ctx, task.OwnerName, task.ID, codersdk.TaskSendRequest{
 			Input: args.Input,
 		})
 		if err != nil {
@@ -2114,12 +2094,13 @@ var GetTaskLogs = Tool[GetTaskLogsArgs, codersdk.TaskLogsResponse]{
 		}
 
 		expClient := codersdk.NewExperimentalClient(deps.coderClient)
-		id, owner, err := resolveTaskID(ctx, deps.coderClient, args.TaskID)
+
+		task, err := expClient.TaskByIdentifier(ctx, args.TaskID)
 		if err != nil {
 			return codersdk.TaskLogsResponse{}, err
 		}
 
-		logs, err := expClient.TaskLogs(ctx, owner, id)
+		logs, err := expClient.TaskLogs(ctx, task.OwnerName, task.ID)
 		if err != nil {
 			return codersdk.TaskLogsResponse{}, xerrors.Errorf("get task logs %q: %w", args.TaskID, err)
 		}
@@ -2128,13 +2109,6 @@ var GetTaskLogs = Tool[GetTaskLogsArgs, codersdk.TaskLogsResponse]{
 	},
 }
 
-// normalizedNamedWorkspace normalizes the workspace name before getting the
-// workspace by name.
-func normalizedNamedWorkspace(ctx context.Context, client *codersdk.Client, name string) (codersdk.Workspace, error) {
-	// Maybe namedWorkspace should itself call NormalizeWorkspaceInput?
-	return namedWorkspace(ctx, client, NormalizeWorkspaceInput(name))
-}
-
 // NormalizeWorkspaceInput converts workspace name input to standard format.
 // Handles the following input formats:
 //   - workspace                    → workspace
@@ -2205,15 +2179,3 @@ func taskIDDescription(action string) string {
 func userDescription(action string) string {
 	return fmt.Sprintf("Username or ID of the user for which to %s. Omit or use the `me` keyword to %s for the authenticated user.", action, action)
 }
-
-func resolveTaskID(ctx context.Context, coderClient *codersdk.Client, taskID string) (uuid.UUID, string, error) {
-	id, err := uuid.Parse(taskID)
-	if err == nil {
-		return id, codersdk.Me, nil
-	}
-	ws, err := normalizedNamedWorkspace(ctx, coderClient, taskID)
-	if err != nil {
-		return uuid.UUID{}, codersdk.Me, xerrors.Errorf("get task workspace %q: %w", taskID, err)
-	}
-	return ws.ID, ws.OwnerName, nil
-}

codersdk/toolsdk/toolsdk_test.go

@@ -35,6 +35,7 @@ import (
 	"github.com/coder/coder/v2/codersdk/agentsdk"
 	"github.com/coder/coder/v2/codersdk/toolsdk"
 	"github.com/coder/coder/v2/codersdk/workspacesdk"
+	"github.com/coder/coder/v2/provisioner/echo"
 	"github.com/coder/coder/v2/provisionersdk/proto"
 	"github.com/coder/coder/v2/testutil"
 )
@@ -881,11 +882,9 @@ func TestTools(t *testing.T) {
 		}
 	})
 
-	t.Run("WorkspaceDeleteTask", func(t *testing.T) {
+	t.Run("DeleteTask", func(t *testing.T) {
 		t.Parallel()
 
-		t.Skip("TODO(mafredri): Remove, fixed down-stack!")
-
 		// nolint:gocritic // This is in a test package and does not end up in the build
 		aiTV := dbfake.TemplateVersion(t, store).Seed(database.TemplateVersion{
 			OrganizationID: owner.OrganizationID,
@@ -896,21 +895,37 @@ func TestTools(t *testing.T) {
 			},
 		}).Do()
 
-		// nolint:gocritic // This is in a test package and does not end up in the build
-		ws1 := dbfake.WorkspaceBuild(t, store, database.WorkspaceTable{
+		ws1Table := dbgen.Workspace(t, store, database.WorkspaceTable{
 			Name:           "delete-task-workspace-1",
 			OrganizationID: owner.OrganizationID,
 			OwnerID:        member.ID,
 			TemplateID:     aiTV.Template.ID,
-		}).WithTask(nil).Do()
+		})
+		task1 := dbgen.Task(t, store, database.TaskTable{
+			OrganizationID:    owner.OrganizationID,
+			OwnerID:           member.ID,
+			Name:              ws1Table.Name,
+			WorkspaceID:       uuid.NullUUID{UUID: ws1Table.ID, Valid: true},
+			TemplateVersionID: aiTV.TemplateVersion.ID,
+			Prompt:            "delete task 1",
+		})
+		_ = dbfake.WorkspaceBuild(t, store, ws1Table).WithTask(nil).Do()
 
-		// nolint:gocritic // This is in a test package and does not end up in the build
-		_ = dbfake.WorkspaceBuild(t, store, database.WorkspaceTable{
+		ws2Table := dbgen.Workspace(t, store, database.WorkspaceTable{
 			Name:           "delete-task-workspace-2",
 			OrganizationID: owner.OrganizationID,
 			OwnerID:        member.ID,
 			TemplateID:     aiTV.Template.ID,
-		}).WithTask(nil).Do()
+		})
+		task2 := dbgen.Task(t, store, database.TaskTable{
+			OrganizationID:    owner.OrganizationID,
+			OwnerID:           member.ID,
+			Name:              ws2Table.Name,
+			WorkspaceID:       uuid.NullUUID{UUID: ws2Table.ID, Valid: true},
+			TemplateVersionID: aiTV.TemplateVersion.ID,
+			Prompt:            "delete task 2",
+		})
+		_ = dbfake.WorkspaceBuild(t, store, ws2Table).WithTask(nil).Do()
 
 		tests := []struct {
 			name  string
@@ -920,13 +935,13 @@ func TestTools(t *testing.T) {
 			{
 				name: "ByUUID",
 				args: toolsdk.DeleteTaskArgs{
-					TaskID: ws1.Workspace.ID.String(),
+					TaskID: task1.ID.String(),
 				},
 			},
 			{
-				name: "ByWorkspaceIdentifier",
+				name: "ByIdentifier",
 				args: toolsdk.DeleteTaskArgs{
-					TaskID: "delete-task-workspace-2",
+					TaskID: task2.Name,
 				},
 			},
 			{
@@ -975,47 +990,64 @@ func TestTools(t *testing.T) {
 		}
 	})
 
-	t.Run("WorkspaceListTasks", func(t *testing.T) {
+	t.Run("ListTasks", func(t *testing.T) {
 		t.Parallel()
 
-		t.Skip("TODO(mafredri): Remove, fixed down-stack!")
+		ctx := testutil.Context(t, testutil.WaitLong)
+		client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})
+		owner := coderdtest.CreateFirstUser(t, client)
+		_, member := coderdtest.CreateAnotherUser(t, client, owner.OrganizationID)
+		taskClient, _ := coderdtest.CreateAnotherUser(t, client, owner.OrganizationID)
 
-		taskClient, taskUser := coderdtest.CreateAnotherUserMutators(t, client, owner.OrganizationID, nil)
-
-		// nolint:gocritic // This is in a test package and does not end up in the build
-		aiTV := dbfake.TemplateVersion(t, store).Seed(database.TemplateVersion{
-			OrganizationID: owner.OrganizationID,
-			CreatedBy:      owner.UserID,
-			HasAITask: sql.NullBool{
-				Bool:  true,
-				Valid: true,
+		// Create a template with AI task support using the proper flow.
+		version := coderdtest.CreateTemplateVersion(t, client, owner.OrganizationID, &echo.Responses{
+			Parse:          echo.ParseComplete,
+			ProvisionApply: echo.ApplyComplete,
+			ProvisionPlan: []*proto.Response{
+				{Type: &proto.Response_Plan{Plan: &proto.PlanComplete{
+					Parameters: []*proto.RichParameter{{Name: "AI Prompt", Type: "string"}},
+					HasAiTasks: true,
+				}}},
 			},
-		}).Do()
+		})
+		coderdtest.AwaitTemplateVersionJobCompleted(t, client, version.ID)
+		template := coderdtest.CreateTemplate(t, client, owner.OrganizationID, version.ID)
+
+		expClient := codersdk.NewExperimentalClient(client)
+		taskExpClient := codersdk.NewExperimentalClient(taskClient)
 
 		// This task should not show up since listing is user-scoped.
-		// nolint:gocritic // This is in a test package and does not end up in the build
-		_ = dbfake.WorkspaceBuild(t, store, database.WorkspaceTable{
-			Name:           "list-task-workspace-member",
-			OrganizationID: owner.OrganizationID,
-			OwnerID:        member.ID,
-			TemplateID:     aiTV.Template.ID,
-		}).WithTask(nil).Do()
+		_, err := expClient.CreateTask(ctx, member.Username, codersdk.CreateTaskRequest{
+			TemplateVersionID: template.ActiveVersionID,
+			Input:             "task for member",
+			Name:              "list-task-workspace-member",
+		})
+		require.NoError(t, err)
 
-		// These tasks should show up.
+		// Create tasks for taskUser. These should show up in the list.
 		for i := range 5 {
-			// nolint:gocritic // This is in a test package and does not end up in the build
-			var transition database.WorkspaceTransition
+			taskName := fmt.Sprintf("list-task-workspace-%d", i)
+			task, err := taskExpClient.CreateTask(ctx, codersdk.Me, codersdk.CreateTaskRequest{
+				TemplateVersionID: template.ActiveVersionID,
+				Input:             fmt.Sprintf("task %d", i),
+				Name:              taskName,
+			})
+			require.NoError(t, err)
+			require.True(t, task.WorkspaceID.Valid, "task should have workspace ID")
+
+			// For the first task, stop the workspace to make it paused.
 			if i == 0 {
-				// nolint:gocritic // This is in a test package and does not end up in the build
-				transition = database.WorkspaceTransitionStop
+				ws, err := taskClient.Workspace(ctx, task.WorkspaceID.UUID)
+				require.NoError(t, err)
+				coderdtest.AwaitWorkspaceBuildJobCompleted(t, taskClient, ws.LatestBuild.ID)
+
+				// Stop the workspace to set task status to paused.
+				build, err := taskClient.CreateWorkspaceBuild(ctx, task.WorkspaceID.UUID, codersdk.CreateWorkspaceBuildRequest{
+					Transition: codersdk.WorkspaceTransitionStop,
+				})
+				require.NoError(t, err)
+				coderdtest.AwaitWorkspaceBuildJobCompleted(t, taskClient, build.ID)
 			}
-			// nolint:gocritic // This is in a test package and does not end up in the build
-			_ = dbfake.WorkspaceBuild(t, store, database.WorkspaceTable{
-				Name:           fmt.Sprintf("list-task-workspace-%d", i),
-				OrganizationID: owner.OrganizationID,
-				OwnerID:        taskUser.ID,
-				TemplateID:     aiTV.Template.ID,
-			}).Seed(database.WorkspaceBuild{Transition: transition}).WithTask(nil).Do()
 		}
 
 		tests := []struct {
@@ -1038,7 +1070,7 @@ func TestTools(t *testing.T) {
 			{
 				name: "ListFiltered",
 				args: toolsdk.ListTasksArgs{
-					WorkspaceStatus: "stopped",
+					Status: codersdk.TaskStatusPaused,
 				},
 				expected: []string{
 					"list-task-workspace-0",
@@ -1068,11 +1100,9 @@ func TestTools(t *testing.T) {
 		}
 	})
 
-	t.Run("WorkspaceGetTask", func(t *testing.T) {
+	t.Run("GetTask", func(t *testing.T) {
 		t.Parallel()
 
-		t.Skip("TODO(mafredri): Remove, fixed down-stack!")
-
 		// nolint:gocritic // This is in a test package and does not end up in the build
 		aiTV := dbfake.TemplateVersion(t, store).Seed(database.TemplateVersion{
 			OrganizationID: owner.OrganizationID,
@@ -1083,33 +1113,41 @@ func TestTools(t *testing.T) {
 			},
 		}).Do()
 
-		// nolint:gocritic // This is in a test package and does not end up in the build
-		ws1 := dbfake.WorkspaceBuild(t, store, database.WorkspaceTable{
+		ws1Table := dbgen.Workspace(t, store, database.WorkspaceTable{
 			Name:           "get-task-workspace-1",
 			OrganizationID: owner.OrganizationID,
 			OwnerID:        member.ID,
 			TemplateID:     aiTV.Template.ID,
-		}).WithTask(nil).Do()
+		})
+		task := dbgen.Task(t, store, database.TaskTable{
+			OrganizationID:    owner.OrganizationID,
+			OwnerID:           member.ID,
+			Name:              "get-task-1",
+			WorkspaceID:       uuid.NullUUID{UUID: ws1Table.ID, Valid: true},
+			TemplateVersionID: aiTV.TemplateVersion.ID,
+			Prompt:            "get task",
+		})
+		_ = dbfake.WorkspaceBuild(t, store, ws1Table).WithTask(nil).Do()
 
 		tests := []struct {
 			name     string
 			args     toolsdk.GetTaskStatusArgs
-			expected codersdk.WorkspaceStatus
+			expected codersdk.TaskStatus
 			error    string
 		}{
 			{
 				name: "ByUUID",
 				args: toolsdk.GetTaskStatusArgs{
-					TaskID: ws1.Workspace.ID.String(),
+					TaskID: task.ID.String(),
 				},
-				expected: codersdk.WorkspaceStatusRunning,
+				expected: codersdk.TaskStatusInitializing,
 			},
 			{
-				name: "ByWorkspaceIdentifier",
+				name: "ByIdentifier",
 				args: toolsdk.GetTaskStatusArgs{
-					TaskID: "get-task-workspace-1",
+					TaskID: task.Name,
 				},
-				expected: codersdk.WorkspaceStatusRunning,
+				expected: codersdk.TaskStatusInitializing,
 			},
 			{
 				name:  "NoID",
@@ -1301,8 +1339,6 @@ func TestTools(t *testing.T) {
 	t.Run("SendTaskInput", func(t *testing.T) {
 		t.Parallel()
 
-		t.Skip("TODO(mafredri): Remove, fixed down-stack!")
-
 		// Start a fake AgentAPI that accepts GET /status and POST /message.
 		srv := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
 			if r.Method == http.MethodGet && r.URL.Path == "/status" {
@@ -1340,13 +1376,21 @@ func TestTools(t *testing.T) {
 			},
 		}).Do()
 
-		// nolint:gocritic // This is in a test package and does not end up in the build
-		ws := dbfake.WorkspaceBuild(t, store, database.WorkspaceTable{
-			Name:           "send-task-input",
+		wsTable := dbgen.Workspace(t, store, database.WorkspaceTable{
+			Name:           "send-task-input-ws",
 			OrganizationID: owner.OrganizationID,
 			OwnerID:        member.ID,
 			TemplateID:     aiTV.Template.ID,
-		}).WithTask(&proto.App{Url: srv.URL}).Do()
+		})
+		task := dbgen.Task(t, store, database.TaskTable{
+			OrganizationID:    owner.OrganizationID,
+			OwnerID:           member.ID,
+			Name:              "send-task-input",
+			WorkspaceID:       uuid.NullUUID{UUID: wsTable.ID, Valid: true},
+			TemplateVersionID: aiTV.TemplateVersion.ID,
+			Prompt:            "send task input",
+		})
+		ws := dbfake.WorkspaceBuild(t, store, wsTable).WithTask(&proto.App{Url: srv.URL}).Do()
 
 		_ = agenttest.New(t, client.URL, ws.AgentToken)
 		coderdtest.NewWorkspaceAgentWaiter(t, client, ws.Workspace.ID).Wait()
@@ -1359,14 +1403,14 @@ func TestTools(t *testing.T) {
 			{
 				name: "ByUUID",
 				args: toolsdk.SendTaskInputArgs{
-					TaskID: ws.Workspace.ID.String(),
+					TaskID: task.ID.String(),
 					Input:  "frob the baz",
 				},
 			},
 			{
-				name: "ByWorkspaceIdentifier",
+				name: "ByIdentifier",
 				args: toolsdk.SendTaskInputArgs{
-					TaskID: "send-task-input",
+					TaskID: task.Name,
 					Input:  "frob the baz",
 				},
 			},
@@ -1404,7 +1448,7 @@ func TestTools(t *testing.T) {
 					TaskID: r.Workspace.ID.String(),
 					Input:  "this is ignored",
 				},
-				error: "Task is not configured with a sidebar app",
+				error: "Resource not found",
 			},
 		}
 
@@ -1429,8 +1473,6 @@ func TestTools(t *testing.T) {
 	t.Run("GetTaskLogs", func(t *testing.T) {
 		t.Parallel()
 
-		t.Skip("TODO(mafredri): Remove, fixed down-stack!")
-
 		messages := []agentapi.Message{
 			{
 				Id:      0,
@@ -1471,13 +1513,21 @@ func TestTools(t *testing.T) {
 			},
 		}).Do()
 
-		// nolint:gocritic // This is in a test package and does not end up in the build
-		ws := dbfake.WorkspaceBuild(t, store, database.WorkspaceTable{
-			Name:           "get-task-logs",
+		wsTable := dbgen.Workspace(t, store, database.WorkspaceTable{
+			Name:           "get-task-logs-ws",
 			OrganizationID: owner.OrganizationID,
 			OwnerID:        member.ID,
 			TemplateID:     aiTV.Template.ID,
-		}).WithTask(&proto.App{Url: srv.URL}).Do()
+		})
+		task := dbgen.Task(t, store, database.TaskTable{
+			OrganizationID:    owner.OrganizationID,
+			OwnerID:           member.ID,
+			Name:              "get-task-logs",
+			WorkspaceID:       uuid.NullUUID{UUID: wsTable.ID, Valid: true},
+			TemplateVersionID: aiTV.TemplateVersion.ID,
+			Prompt:            "get task logs",
+		})
+		ws := dbfake.WorkspaceBuild(t, store, wsTable).WithTask(&proto.App{Url: srv.URL}).Do()
 
 		_ = agenttest.New(t, client.URL, ws.AgentToken)
 		coderdtest.NewWorkspaceAgentWaiter(t, client, ws.Workspace.ID).Wait()
@@ -1491,14 +1541,14 @@ func TestTools(t *testing.T) {
 			{
 				name: "ByUUID",
 				args: toolsdk.GetTaskLogsArgs{
-					TaskID: ws.Workspace.ID.String(),
+					TaskID: task.ID.String(),
 				},
 				expected: messages,
 			},
 			{
-				name: "ByWorkspaceIdentifier",
+				name: "ByIdentifier",
 				args: toolsdk.GetTaskLogsArgs{
-					TaskID: "get-task-logs",
+					TaskID: task.Name,
 				},
 				expected: messages,
 			},
@@ -1526,7 +1576,7 @@ func TestTools(t *testing.T) {
 				args: toolsdk.GetTaskLogsArgs{
 					TaskID: r.Workspace.ID.String(),
 				},
-				error: "Task is not configured with a sidebar app",
+				error: "Resource not found",
 			},
 		}
 
@@ -1777,23 +1827,6 @@ func TestMain(m *testing.M) {
 			if runtime.GOOS == "windows" && tool.Name == "coder_workspace_bash" {
 				continue
 			}
-			ignored := false
-			for _, ignore := range []string{
-				"coder_delete_task",
-				"coder_list_tasks",
-				"coder_get_task_status",
-				"coder_send_task_input",
-				"coder_get_task_logs",
-				"coder_get_task_logs",
-			} {
-				if ignore == tool.Name {
-					ignored = true
-					break
-				}
-			}
-			if ignored {
-				continue
-			}
 			untested = append(untested, tool.Name)
 		}
 	}