Files
coder/coderd/chat_projects.go
Jaayden Halko 17a2b62205 feat: add an API to attach templates to chat projects (#30754)
Adds the API for attaching workspace templates to a chat project, on the
schema and queries in #32309. A project can attach templates, turn on a
limit that restricts its chats to them, and set a default template with
either a default preset or default parameter values. Attaching a
template never grants access to it: every reader is checked against the
template's own sharing. This PR stores and returns `limit_templates`;
#32310 enforces it.

- The limit is opt-in. `limit_templates` is off unless a request turns
it on, which is what every existing project gets.
- Templates are attached and detached one at a time with `PUT` and
`DELETE /chats/projects/{project}/templates/{template}`, so a caller
never replaces a list they can only partly see. Attaching needs project
`update` and template `use`. Detaching needs project `update` and
template `read`, and a template the caller cannot read is reported as
not found. `POST /chats/projects` accepts `template_ids`,
`limit_templates`, and `default_template` for the new project.
- `PATCH /chats/projects/{project}` sets `limit_templates` and
`default_template`, and no longer changes which templates are attached.
The default must be an attached template the caller can read, and its
preset must belong to the template's active version. Default parameter
names and values are checked against that version for templates on the
classic parameter flow; dynamic parameters are checked when a workspace
is built. Detaching the default template clears the default.
- Project responses list only the attached templates the caller can
read, as `templates`, and count the rest as `hidden_template_count`.
`default_template` is omitted when the caller cannot read it. Deleted,
deprecated, and agent-disabled templates are left out and are not
counted as hidden.
- Editing uses `chat_project:update`, which the project owner and the
project `admin` ACL role have.
- Attaching and detaching are audited as writes to the project, with the
template list before and after, including the templates attached while
creating a project. Changes to `limit_templates` and the default
template are part of the project's own audit diff.

Not included: showing which project members lack access to an attached
template, and MCP server attachments.

Stack (merge top to bottom):
- #32309
- #30754 👈
- #32310
- #30755
- #32371
- #32372
- #30756
- #32373
- #32374
- #32375
- #30898
- #32376
- #32377
- #32378
- #32379
2026-11-18 20:36:34 +07:00

438 lines
15 KiB
Go

package coderd
import (
"context"
"database/sql"
"errors"
"fmt"
"net/http"
"strings"
"unicode/utf8"
"github.com/google/uuid"
"golang.org/x/xerrors"
"github.com/coder/coder/v2/coderd/audit"
"github.com/coder/coder/v2/coderd/database"
"github.com/coder/coder/v2/coderd/database/db2sdk"
"github.com/coder/coder/v2/coderd/database/dbauthz"
"github.com/coder/coder/v2/coderd/httpapi"
"github.com/coder/coder/v2/coderd/httpmw"
"github.com/coder/coder/v2/coderd/rbac"
"github.com/coder/coder/v2/coderd/rbac/policy"
"github.com/coder/coder/v2/coderd/util/ptr"
"github.com/coder/coder/v2/coderd/util/slice"
"github.com/coder/coder/v2/coderd/x/chatd/chattool"
"github.com/coder/coder/v2/codersdk"
)
// @Summary List chat projects
// @ID list-chat-projects
// @Security CoderSessionToken
// @Tags Chats
// @Produce json
// @Success 200 {array} codersdk.ChatProject
// @Router /api/experimental/chats/projects [get]
// @x-apidocgen {"skip": true}
func (api *API) listChatProjects(rw http.ResponseWriter, r *http.Request) {
ctx := r.Context()
apiKey := httpmw.APIKey(r)
projects, err := api.Database.GetChatProjectsOwnedOrSharedWithUserID(ctx, apiKey.UserID)
if err != nil {
httpapi.Write(ctx, rw, http.StatusInternalServerError, codersdk.Response{
Message: "Failed to list chat projects.",
Detail: err.Error(),
})
return
}
converted, err := api.convertChatProjects(r, projects)
if err != nil {
httpapi.Write(ctx, rw, http.StatusInternalServerError, codersdk.Response{
Message: "Failed to list chat projects.",
Detail: err.Error(),
})
return
}
httpapi.Write(ctx, rw, http.StatusOK, converted)
}
// @Summary Create chat project
// @ID create-chat-project
// @Security CoderSessionToken
// @Tags Chats
// @Accept json
// @Produce json
// @Param organization path string true "Organization ID" format(uuid)
// @Param request body codersdk.CreateChatProjectRequest true "Create chat project request"
// @Success 201 {object} codersdk.ChatProject
// @Router /api/experimental/organizations/{organization}/chats/projects [post]
// @x-apidocgen {"skip": true}
func (api *API) postChatProject(rw http.ResponseWriter, r *http.Request) {
ctx := r.Context()
apiKey := httpmw.APIKey(r)
organization := httpmw.OrganizationParam(r)
var req codersdk.CreateChatProjectRequest
if !httpapi.Read(ctx, rw, r, &req) {
return
}
req.Name = strings.TrimSpace(req.Name)
req.Icon = strings.TrimSpace(req.Icon)
if req.Name == "" {
writeChatProjectFieldError(ctx, rw, "name", "Name is required.")
return
}
if !validateChatProjectFields(ctx, rw, req.Name, req.Description, req.Icon) {
return
}
if !api.Authorize(r, policy.ActionCreate, database.ChatProject{
OrganizationID: organization.ID,
OwnerID: apiKey.UserID,
}.RBACObject()) {
httpapi.Forbidden(rw)
return
}
req.TemplateIDs = slice.Unique(req.TemplateIDs)
templates, err := api.attachableChatProjectTemplates(ctx, organization.ID, req.TemplateIDs)
if err != nil {
api.writeChatProjectTemplateError(ctx, rw, err, "Failed to validate chat project templates.")
return
}
defaultTemplate, err := validateChatProjectDefaultTemplate(ctx, api.Database, templates, req.DefaultTemplate)
if err != nil {
api.writeChatProjectTemplateError(ctx, rw, err, "Failed to validate the default template.")
return
}
// The project's own audit diff does not hold its templates, so the ones
// attached here are audited like later attachments. Deferred first, so
// it is recorded after the project's creation.
templatesAudit, commitTemplatesAudit := api.initChatProjectTemplatesAudit(rw, r, organization.ID)
defer commitTemplatesAudit()
aReq, commitAudit := audit.InitRequest[database.ChatProject](rw, &audit.RequestParams{
Audit: *api.Auditor.Load(),
Log: api.Logger,
Request: r,
Action: database.AuditActionCreate,
OrganizationID: organization.ID,
})
defer commitAudit()
var project database.ChatProject
err = api.Database.InTx(func(tx database.Store) error {
// The lock serializes a user's creates so concurrent requests cannot
// both observe room under the cap.
if err := tx.AcquireLock(ctx, database.GenLockID("chat-projects-owner:"+apiKey.UserID.String())); err != nil {
return xerrors.Errorf("lock chat projects: %w", err)
}
// The count spans the user's projects in every organization, and the
// caller was already authorized to create one.
//nolint:gocritic // See above.
count, err := tx.CountChatProjectsByOwnerID(dbauthz.AsSystemRestricted(ctx), apiKey.UserID)
if err != nil {
return xerrors.Errorf("count chat projects: %w", err)
}
if count >= maxChatProjectsPerOwner {
return errChatProjectLimit
}
project, err = tx.InsertChatProject(ctx, database.InsertChatProjectParams{
ID: uuid.NullUUID{},
OrganizationID: organization.ID,
OwnerID: apiKey.UserID,
Name: req.Name,
Description: req.Description,
Icon: req.Icon,
LimitTemplates: req.LimitTemplates,
DefaultTemplateID: defaultTemplate.templateID,
DefaultTemplateVersionPresetID: defaultTemplate.presetID,
DefaultParameters: defaultTemplate.parameters,
})
if err != nil {
return err
}
if len(req.TemplateIDs) == 0 {
return nil
}
_, err = tx.InsertChatProjectTemplates(ctx, database.InsertChatProjectTemplatesParams{
ProjectID: project.ID,
TemplateIDs: req.TemplateIDs,
CreatedBy: apiKey.UserID,
})
return err
}, nil)
if errors.Is(err, errChatProjectLimit) {
httpapi.Write(ctx, rw, http.StatusConflict, codersdk.Response{
Message: fmt.Sprintf("You can have at most %d chat projects. Delete a project to create another.", maxChatProjectsPerOwner),
})
return
}
if err != nil {
api.writeChatProjectTemplateError(ctx, rw, err, "Failed to create chat project.")
return
}
aReq.New = project
if len(req.TemplateIDs) > 0 {
templatesAudit.Old = database.AuditableChatProjectTemplates{
ProjectID: project.ID,
ProjectName: project.Name,
TemplateIDs: []uuid.UUID{},
}
templatesAudit.New = templatesAudit.Old
templatesAudit.New.TemplateIDs = req.TemplateIDs
}
api.writeChatProject(rw, r, http.StatusCreated, project)
}
// @Summary Get chat project
// @ID get-chat-project
// @Security CoderSessionToken
// @Tags Chats
// @Produce json
// @Param organization path string true "Organization ID" format(uuid)
// @Param project path string true "Chat project ID" format(uuid)
// @Success 200 {object} codersdk.ChatProject
// @Router /api/experimental/organizations/{organization}/chats/projects/{project} [get]
// @x-apidocgen {"skip": true}
//
//nolint:revive // HTTP handler writes to ResponseWriter.
func (api *API) getChatProject(rw http.ResponseWriter, r *http.Request) {
project := httpmw.ChatProjectParam(r)
if !api.Authorize(r, policy.ActionRead, project.RBACObject()) {
httpapi.ResourceNotFound(rw)
return
}
api.writeChatProject(rw, r, http.StatusOK, project)
}
// @Summary Update chat project
// @ID update-chat-project
// @Security CoderSessionToken
// @Tags Chats
// @Accept json
// @Produce json
// @Param organization path string true "Organization ID" format(uuid)
// @Param project path string true "Chat project ID" format(uuid)
// @Param request body codersdk.UpdateChatProjectRequest true "Update chat project request"
// @Success 200 {object} codersdk.ChatProject
// @Router /api/experimental/organizations/{organization}/chats/projects/{project} [patch]
// @x-apidocgen {"skip": true}
func (api *API) patchChatProject(rw http.ResponseWriter, r *http.Request) {
ctx := r.Context()
project := httpmw.ChatProjectParam(r)
// Update covers the template limit and default template, so anyone
// allowed to edit the project, including through its ACL, can change
// them.
if !api.authorizeChatProjectChange(rw, r, policy.ActionUpdate, project.RBACObject()) {
return
}
aReq, commitAudit := audit.InitRequest[database.ChatProject](rw, &audit.RequestParams{
Audit: *api.Auditor.Load(),
Log: api.Logger,
Request: r,
Action: database.AuditActionWrite,
OrganizationID: project.OrganizationID,
})
defer commitAudit()
aReq.Old = project
var req codersdk.UpdateChatProjectRequest
if !httpapi.Read(ctx, rw, r, &req) {
return
}
if req.Name != nil {
*req.Name = strings.TrimSpace(*req.Name)
}
if req.Icon != nil {
*req.Icon = strings.TrimSpace(*req.Icon)
}
if req.Name != nil && *req.Name == "" {
writeChatProjectFieldError(ctx, rw, "name", "Name must not be blank.")
return
}
name := ptr.NilToDefault(req.Name, project.Name)
description := ptr.NilToDefault(req.Description, project.Description)
icon := ptr.NilToDefault(req.Icon, project.Icon)
if !validateChatProjectFields(ctx, rw, name, description, icon) {
return
}
// Omitted template settings are left to the query, which keeps the
// current columns instead of writing back this request's snapshot.
var limitTemplates sql.NullBool
if req.LimitTemplates != nil {
limitTemplates = sql.NullBool{Bool: *req.LimitTemplates, Valid: true}
}
var updated database.ChatProject
err := api.Database.InTx(func(tx database.Store) error {
var defaultTemplate chatProjectDefaultTemplate
if req.DefaultTemplate != nil {
// Detaching a template takes the same lock, so the default
// cannot be pointed at a template that is being detached.
if _, err := tx.GetChatProjectByIDForUpdate(ctx, project.ID); err != nil {
return err
}
templates, err := chattool.LoadProjectTemplates(ctx, tx, project)
if err != nil {
return err
}
defaultTemplate, err = validateChatProjectDefaultTemplate(ctx, tx, templates.Templates, req.DefaultTemplate)
if err != nil {
return err
}
}
var err error
updated, err = tx.UpdateChatProjectByID(ctx, database.UpdateChatProjectByIDParams{
ID: project.ID,
Name: name,
Description: description,
Icon: icon,
LimitTemplates: limitTemplates,
UpdateDefaultTemplate: req.DefaultTemplate != nil,
DefaultTemplateID: defaultTemplate.templateID,
DefaultTemplateVersionPresetID: defaultTemplate.presetID,
DefaultParameters: defaultTemplate.parameters,
})
return err
}, nil)
if err != nil {
api.writeChatProjectTemplateError(ctx, rw, err, "Failed to update chat project.")
return
}
aReq.New = updated
api.writeChatProject(rw, r, http.StatusOK, updated)
}
// @Summary Delete chat project
// @ID delete-chat-project
// @Security CoderSessionToken
// @Tags Chats
// @Param organization path string true "Organization ID" format(uuid)
// @Param project path string true "Chat project ID" format(uuid)
// @Success 204
// @Router /api/experimental/organizations/{organization}/chats/projects/{project} [delete]
// @x-apidocgen {"skip": true}
func (api *API) deleteChatProject(rw http.ResponseWriter, r *http.Request) {
ctx := r.Context()
project := httpmw.ChatProjectParam(r)
if !api.authorizeChatProjectChange(rw, r, policy.ActionDelete, project.RBACObject()) {
return
}
aReq, commitAudit := audit.InitRequest[database.ChatProject](rw, &audit.RequestParams{
Audit: *api.Auditor.Load(),
Log: api.Logger,
Request: r,
Action: database.AuditActionDelete,
OrganizationID: project.OrganizationID,
})
defer commitAudit()
aReq.Old = project
err := api.Database.DeleteChatProjectByID(ctx, project.ID)
if errors.Is(err, sql.ErrNoRows) || httpapi.Is404Error(err) {
httpapi.ResourceNotFound(rw)
return
}
if err != nil {
httpapi.Write(ctx, rw, http.StatusInternalServerError, codersdk.Response{
Message: "Failed to delete chat project.",
Detail: err.Error(),
})
return
}
rw.WriteHeader(http.StatusNoContent)
}
func (api *API) authorizeChatProjectChange(rw http.ResponseWriter, r *http.Request, action policy.Action, object rbac.Objecter) bool {
if !api.Authorize(r, policy.ActionRead, object) {
httpapi.ResourceNotFound(rw)
return false
}
if !api.Authorize(r, action, object) {
httpapi.Forbidden(rw)
return false
}
return true
}
// writeChatProject writes the project as the caller sees it.
func (api *API) writeChatProject(rw http.ResponseWriter, r *http.Request, status int, project database.ChatProject) {
ctx := r.Context()
converted, err := api.convertChatProjects(r, []database.ChatProject{project})
if err != nil {
httpapi.Write(ctx, rw, http.StatusInternalServerError, codersdk.Response{
Message: "Failed to load chat project templates.",
Detail: err.Error(),
})
return
}
httpapi.Write(ctx, rw, status, converted[0])
}
// convertChatProjects converts projects with the caller's permissions on
// them and the attached templates the caller can access.
func (api *API) convertChatProjects(r *http.Request, projects []database.ChatProject) ([]codersdk.ChatProject, error) {
ctx := r.Context()
templates, err := chattool.LoadProjectsTemplates(ctx, api.Database, projects)
if err != nil {
return nil, err
}
subject := httpmw.UserAuthorization(ctx)
return slice.List(projects, func(project database.ChatProject) codersdk.ChatProject {
obj := project.RBACObject()
// Denials are expected here, so this skips api.Authorize, which
// logs each one as a warning.
can := func(action policy.Action) bool {
return api.HTTPAuth.Authorizer.Authorize(ctx, subject, action, obj) == nil
}
return db2sdk.ChatProject(project, codersdk.ChatProjectPermissions{
Update: can(policy.ActionUpdate),
Delete: can(policy.ActionDelete),
Share: can(policy.ActionShare),
}, templates[project.ID])
}), nil
}
// maxChatProjectsPerOwner caps how many projects one user owns across all
// organizations.
const maxChatProjectsPerOwner = 100
var errChatProjectLimit = xerrors.New("chat project limit reached")
const (
// The project name is embedded in every generation's system prompt and
// memory tool descriptions, so it is kept short.
chatProjectNameMaxChars = 64
chatProjectDescriptionMaxChars = 1024
chatProjectIconMaxChars = 256
)
// validateChatProjectFields writes a 400 response and returns false when a
// sanitized field exceeds its limit.
func validateChatProjectFields(ctx context.Context, rw http.ResponseWriter, name, description, icon string) bool {
if utf8.RuneCountInString(name) > chatProjectNameMaxChars {
writeChatProjectFieldError(ctx, rw, "name", fmt.Sprintf("Name must be at most %d characters.", chatProjectNameMaxChars))
return false
}
if utf8.RuneCountInString(description) > chatProjectDescriptionMaxChars {
writeChatProjectFieldError(ctx, rw, "description", fmt.Sprintf("Description must be at most %d characters.", chatProjectDescriptionMaxChars))
return false
}
if utf8.RuneCountInString(icon) > chatProjectIconMaxChars {
writeChatProjectFieldError(ctx, rw, "icon", fmt.Sprintf("Icon must be at most %d characters.", chatProjectIconMaxChars))
return false
}
return true
}
func writeChatProjectFieldError(ctx context.Context, rw http.ResponseWriter, field, detail string) {
httpapi.Write(ctx, rw, http.StatusBadRequest, codersdk.Response{
Message: detail,
Validations: []codersdk.ValidationError{{Field: field, Detail: detail}},
})
}