refactor: lift task creation to coderd

Instead of creating tasks with a specialised call to `CreateWorkspace` on the frontend, we instead lift this to the backend and allow the frontend to simply call `CreateAITask`.
coder · DanielleMaywood · Aug 12, 2025 · Aug 11, 2025 · Aug 11, 2025 · Aug 11, 2025
commit 30b40081bc0132e6b8a37f8e2a7f8e6868c07d70
diff --git a/coderd/aitasks.go b/coderd/aitasks.go
@@ -7,7 +7,10 @@ import (
 
 	"github.com/google/uuid"
 
+	"github.com/coder/coder/v2/coderd/audit"
+	"github.com/coder/coder/v2/coderd/database"
 	"github.com/coder/coder/v2/coderd/httpapi"
+	"github.com/coder/coder/v2/coderd/httpmw"
 	"github.com/coder/coder/v2/codersdk"
 )
 
@@ -61,3 +64,59 @@ func (api *API) aiTasksPrompts(rw http.ResponseWriter, r *http.Request) {
 		Prompts: promptsByBuildID,
 	})
 }
+
+// This endpoint is experimental and not guaranteed to be stable, so we're not
+// generating public-facing documentation for it.
+func (api *API) aiTasksCreate(rw http.ResponseWriter, r *http.Request) {
+	var (
+		ctx     = r.Context()
+		apiKey  = httpmw.APIKey(r)
+		auditor = api.Auditor.Load()
+	)
+
+	var req codersdk.CreateAITasksRequest
+	if !httpapi.Read(ctx, rw, r, &req) {
+		return
+	}
+
+	user, err := api.Database.GetUserByID(ctx, apiKey.UserID)
+	if httpapi.Is404Error(err) {
+		httpapi.ResourceNotFound(rw)
+		return
+	}
+	if err != nil {
+		httpapi.Write(ctx, rw, http.StatusInternalServerError, codersdk.Response{
+			Message: "Internal error fetching user.",
+			Detail:  err.Error(),
+		})
+		return
+	}
+
+	createReq := codersdk.CreateWorkspaceRequest{
+		Name:                    req.Name,
+		TemplateVersionID:       req.TemplateVersionID,
+		TemplateVersionPresetID: req.TemplateVersionPresetID,
+		RichParameterValues: []codersdk.WorkspaceBuildParameter{
+			{Name: "AI Prompt", Value: req.Prompt},
+		},
+	}
+
+	owner := workspaceOwner{
+		ID:        user.ID,
+		Username:  user.Username,
+		AvatarURL: user.AvatarURL,
+	}
+
+	aReq, commitAudit := audit.InitRequest[database.WorkspaceTable](rw, &audit.RequestParams{
+		Audit:   *auditor,
+		Log:     api.Logger,
+		Request: r,
+		Action:  database.AuditActionCreate,
+		AdditionalFields: audit.AdditionalFields{
+			WorkspaceOwner: owner.Username,
+		},
+	})
+
+	defer commitAudit()
+	createWorkspace(ctx, aReq, apiKey.UserID, api, owner, createReq, rw, r)
+}
diff --git a/coderd/aitasks_test.go b/coderd/aitasks_test.go
@@ -139,3 +139,58 @@
 		require.Empty(t, prompts.Prompts)
 	})
 }
+
+func TestAITasksCreate(t *testing.T) {
+	t.Parallel()
+
+	makeEchoResponses := func(parameters []*proto.RichParameter) *echo.Responses {
+		return &echo.Responses{
+			Parse:          echo.ParseComplete,
+			ProvisionApply: echo.ApplyComplete,
+			ProvisionPlan: []*proto.Response{
+				{Type: &proto.Response_Plan{Plan: &proto.PlanComplete{Parameters: parameters}}},
+			},
+		}
+	}
+
+	t.Run("OK", func(t *testing.T) {
+		var (
+			ctx = testutil.Context(t, testutil.WaitShort)
+
+			taskName   = "task-foo-bar-baz"
+			taskPrompt = "Some task prompt"
+		)
+
+		client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})
+		user := coderdtest.CreateFirstUser(t, client)
+
+		// Given: A template with an "AI Prompt"
+		version := coderdtest.CreateTemplateVersion(t, client, user.OrganizationID, makeEchoResponses([]*proto.RichParameter{
+			{Name: "AI Prompt", Type: "string"},
+		}))
+		coderdtest.AwaitTemplateVersionJobCompleted(t, client, version.ID)
+		template := coderdtest.CreateTemplate(t, client, user.OrganizationID, version.ID)
+
+		expClient := codersdk.NewExperimentalClient(client)
+
+		// When: We attempt to create a Task.
+		workspace, err := expClient.AITasksCreate(ctx, codersdk.CreateAITasksRequest{
+			Name:              taskName,
+			TemplateVersionID: template.ActiveVersionID,
+			Prompt:            taskPrompt,
+		})
+		require.NoError(t, err)
+		coderdtest.AwaitWorkspaceBuildJobCompleted(t, client, workspace.LatestBuild.ID)
+
+		// Then: We expect a workspace to have been created.
+		require.Equal(t, taskName, workspace.Name)
+		require.Equal(t, template.ID, workspace.TemplateID)
+
+		// And: We expect it to have the "AI Prompt" parameter correctly set.
+		parameters, err := client.WorkspaceBuildParameters(ctx, workspace.LatestBuild.ID)
+		require.NoError(t, err)
+		require.Len(t, parameters, 1)
+		require.Equal(t, "AI Prompt", parameters[0].Name)
+		require.Equal(t, taskPrompt, parameters[0].Value)
+	})
+}
diff --git a/coderd/coderd.go b/coderd/coderd.go
@@ -994,6 +994,7 @@ func New(options *Options) *API {
 		r.Use(apiKeyMiddleware)
 		r.Route("/aitasks", func(r chi.Router) {
 			r.Get("/prompts", api.aiTasksPrompts)
+			r.Post("/", api.aiTasksCreate)
 		})
 		r.Route("/mcp", func(r chi.Router) {
 			r.Use(

diff --git a/codersdk/aitasks.go b/codersdk/aitasks.go
@@ -44,3 +44,29 @@ func (c *ExperimentalClient) AITaskPrompts(ctx context.Context, buildIDs []uuid.
 	var prompts AITasksPromptsResponse
 	return prompts, json.NewDecoder(res.Body).Decode(&prompts)
 }
+
+type CreateAITasksRequest struct {
+	Name                    string    `json:"name"`
+	TemplateVersionID       uuid.UUID `json:"template_version_id"`
+	TemplateVersionPresetID uuid.UUID `json:"template_version_preset_id,omitempty"`
+	Prompt                  string    `json:"prompt"`
+}
+
+func (c *ExperimentalClient) AITasksCreate(ctx context.Context, request CreateAITasksRequest) (Workspace, error) {
+	res, err := c.Request(ctx, http.MethodPost, "/api/experimental/aitasks/", request)
+	if err != nil {
+		return Workspace{}, err
+	}
+	defer res.Body.Close()
+
+	if res.StatusCode != http.StatusCreated {
+		return Workspace{}, ReadBodyAsError(res)
+	}
+
+	var workspace Workspace
+	if err := json.NewDecoder(res.Body).Decode(&workspace); err != nil {
+		return Workspace{}, err
+	}
+
+	return workspace, nil
+}
@@ -2665,6 +2665,17 @@ class ExperimentalApiMethods {
 
 		return response.data;
 	};
+
+	createAITask = async (
+		req: TypesGen.CreateAITasksRequest,
+	): Promise<TypesGen.Workspace> => {
+		const response = await this.axios.post<TypesGen.Workspace>(
+			"/api/experimental/aitasks",
+			req,
+		);
+
+		return response.data;
+	};
 }
 
 // This is a hard coded CSRF token/cookie pair for local development. In prod,

diff --git a/site/src/api/typesGenerated.ts b/site/src/api/typesGenerated.ts
@@ -232,7 +232,6 @@ type TaskFormProps = {
 };
 
 const TaskForm: FC<TaskFormProps> = ({ templates, onSuccess }) => {
-	const { user } = useAuthenticated();
 	const queryClient = useQueryClient();
 	const [selectedTemplateId, setSelectedTemplateId] = useState<string>(
 		templates[0].id,
@@ -293,7 +292,7 @@ const TaskForm: FC<TaskFormProps> = ({ templates, onSuccess }) => {
 			templateVersionId,
 			presetId,
 		}: CreateTaskMutationFnProps) =>
-			data.createTask(prompt, user.id, templateVersionId, presetId),
+			data.createTask(prompt, templateVersionId, presetId),
 		onSuccess: async (task) => {
 			await queryClient.invalidateQueries({
 				queryKey: ["tasks"],
@@ -727,7 +726,6 @@ export const data = {
 
 	async createTask(
 		prompt: string,
-		userId: string,
 		templateVersionId: string,
 		presetId: string | null = null,
 	): Promise<Task> {
@@ -741,13 +739,11 @@ export const data = {
 			}
 		}
 
-		const workspace = await API.createWorkspace(userId, {
+		const workspace = await API.experimental.createAITask({
 			name: `task-${generateWorkspaceName()}`,
 			template_version_id: templateVersionId,
 			template_version_preset_id: preset_id || undefined,
-			rich_parameter_values: [
-				{ name: AI_PROMPT_PARAMETER_NAME, value: prompt },
-			],
+			prompt,
 		});
 
 		return {